WebAssembly Runtime¶

class WasmVocabulary {
  /** Load vocabulary from raw byte arrays. */
  static from_bytes(vocab_data: Uint8Array, offset_data: Uint8Array): WasmVocabulary;

  /** Create an empty vocabulary (for testing). */
  static empty(): WasmVocabulary;

  /** Number of terms in the vocabulary. */
  len(): number;

  /** Check if the vocabulary is empty. */
  is_empty(): boolean;

  /** Look up a term by its integer ID. Returns null if not found. */
  get_by_index(id: bigint): string | null;

  /** Check if a term ID represents a literal (vs IRI or blank node). */
  is_literal(id: bigint): boolean;

  /** Check if a term ID represents an IRI or blank node. */
  is_iri_or_blank(id: bigint): boolean;

  /** Get the boundary index between literals and IRIs. */
  first_iri_index(): number;

  /** Get vocabulary statistics as a JSON object. */
  stats(): { term_count: number; first_iri_index: number; is_empty: boolean };
}

class WasmIndex {
  /** Load an index from raw byte arrays. */
  static from_bytes(
    permutation: 'SPO' | 'SOP' | 'PSO' | 'POS' | 'OSP' | 'OPS',
    data: Uint8Array,
    metadata: Uint8Array
  ): WasmIndex;

  /** Get the permutation type as a string. */
  permutation(): string;

  /** Total number of triples in this index. */
  num_triples(): bigint;

  /** Number of compressed blocks. */
  num_blocks(): number;

  /** Check if the index is empty. */
  is_empty(): boolean;

  /**
   * Scan for triples matching a prefix pattern.
   * prefix: Array of 0-3 term IDs.
   *   [] = all triples
   *   [s] = triples with subject s
   *   [s, p] = triples with subject s and predicate p
   *   [s, p, o] = exact triple lookup
   * Returns: Array of [subject_id, predicate_id, object_id] tuples.
   */
  scan(prefix: bigint[], limit: number): [bigint, bigint, bigint][];

  /** Count triples matching a prefix (more efficient than scan). */
  count(prefix: bigint[]): bigint;

  /** Check if any triple matches the prefix. */
  exists(prefix: bigint[]): boolean;

  /** Get index statistics as a JSON object. */
  stats(): { permutation: string; triple_count: number; block_count: number; is_empty: boolean };
}

class WasmEngine {
  /** Create an engine with the given vocabulary. */
  constructor(vocabulary: WasmVocabulary);

  /** Attach the SPO index. */
  set_spo_index(index: WasmIndex): void;

  /** Attach the POS index. */
  set_pos_index(index: WasmIndex): void;

  /** Attach the OSP index. */
  set_osp_index(index: WasmIndex): void;

  /** Get vocabulary statistics. */
  vocab_stats(): { term_count: number; is_empty: boolean };

  /** Get index statistics for all loaded indices. */
  index_stats(): {
    spo: { triple_count: number; block_count: number } | null;
    pos: { triple_count: number; block_count: number } | null;
    osp: { triple_count: number; block_count: number } | null;
  };

  /** Look up a term string by its ID. */
  lookup_term(id: bigint): string | null;

  /** Scan triples from the SPO index. */
  scan(prefix: bigint[], limit: number): [bigint, bigint, bigint][];

  /** Resolve term IDs to their string representations. */
  resolve_triple(
    subject_id: bigint,
    predicate_id: bigint,
    object_id: bigint
  ): { subject: string; predicate: string; object: string };
}

import init, {
  WasmEngine,
  WasmVocabulary,
  WasmIndex,
  version,
} from '@indentia/graph-wasm';

async function buildEngine(baseUrl: string): Promise<WasmEngine> {
  await init();

  const load = async (path: string): Promise<Uint8Array> => {
    const res = await fetch(`${baseUrl}/${path}`);
    return new Uint8Array(await res.arrayBuffer());
  };

  const vocab = WasmVocabulary.from_bytes(
    await load('vocabulary'),
    await load('vocabulary.offsets'),
  );

  const engine = new WasmEngine(vocab);

  // Load indices in parallel
  const [spoData, spoMeta, posData, posMeta] = await Promise.all([
    load('spo'), load('spo.meta'),
    load('pos'), load('pos.meta'),
  ]);

  engine.set_spo_index(WasmIndex.from_bytes('SPO', spoData, spoMeta));
  engine.set_pos_index(WasmIndex.from_bytes('POS', posData, posMeta));

  return engine;
}

// Usage
const engine = await buildEngine('https://cdn.example.com/indentiadb-index');
console.log(`Loaded ${engine.vocab_stats().term_count} terms`);