@wiscale/velesdb-sdk 1.11.0 → 1.13.0

package/dist/index.mjs

@@ -1,4 +1,4 @@
-// src/types.ts
+// src/types/errors.ts
 var VelesDBError = class extends Error {
   constructor(message, code, cause) {
     super(message);
@@ -32,6 +32,610 @@ var BackpressureError = class extends VelesDBError {
   }
 };
 
+// src/capabilities.ts
+var REST_CAPABILITIES = Object.freeze({
+  vectorSearch: true,
+  textSearch: true,
+  hybridSearch: true,
+  multiQuerySearch: true,
+  sparseSearch: true,
+  scroll: true,
+  graphTraversal: true,
+  secondaryIndexes: true,
+  agentMemory: true,
+  streamInsert: true,
+  pqTraining: true,
+  velesqlQuery: true,
+  collectionIntrospection: true
+});
+var WASM_CAPABILITIES = Object.freeze({
+  vectorSearch: true,
+  textSearch: true,
+  hybridSearch: true,
+  multiQuerySearch: true,
+  sparseSearch: false,
+  scroll: false,
+  graphTraversal: false,
+  secondaryIndexes: false,
+  agentMemory: false,
+  streamInsert: false,
+  pqTraining: false,
+  velesqlQuery: true,
+  collectionIntrospection: false
+});
+
+// src/backends/wasm-helpers.ts
+function normalizeIdString(id) {
+  const trimmed = id.trim();
+  return /^\d+$/.test(trimmed) ? trimmed : null;
+}
+function canonicalPayloadKeyFromResultId(id) {
+  if (typeof id === "bigint") {
+    return id.toString();
+  }
+  if (typeof id === "number") {
+    return String(Math.trunc(id));
+  }
+  const normalized = normalizeIdString(id);
+  if (normalized !== null) {
+    return normalized.replace(/^0+(?=\d)/, "");
+  }
+  return String(toNumericId(id));
+}
+function canonicalPayloadKey(id) {
+  if (typeof id === "number") {
+    return String(Math.trunc(id));
+  }
+  const normalized = normalizeIdString(id);
+  if (normalized !== null) {
+    return normalized.replace(/^0+(?=\d)/, "");
+  }
+  return String(toNumericId(id));
+}
+function sparseVectorToArrays(sv) {
+  const indices = [];
+  const values = [];
+  for (const [k, v] of Object.entries(sv)) {
+    indices.push(Number(k));
+    values.push(v);
+  }
+  return { indices, values };
+}
+function toNumericId(id) {
+  if (typeof id === "number") {
+    return id;
+  }
+  const normalized = normalizeIdString(id);
+  if (normalized !== null) {
+    const parsed = Number(normalized);
+    if (Number.isSafeInteger(parsed)) {
+      return parsed;
+    }
+  }
+  let hash = 0;
+  for (let i = 0; i < id.length; i++) {
+    const char = id.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+    hash = hash & hash;
+  }
+  return Math.abs(hash);
+}
+function buildWasmContext(wasmModule, collections) {
+  return {
+    wasmModule,
+    getCollection: (name) => collections.get(name),
+    canonicalPayloadKeyFromResultId: (id) => canonicalPayloadKeyFromResultId(id),
+    canonicalPayloadKey: (id) => canonicalPayloadKey(id),
+    sparseVectorToArrays: (sv) => sparseVectorToArrays(sv),
+    toNumericId: (id) => toNumericId(id)
+  };
+}
+function buildCollectionInfo(name, data) {
+  return {
+    name,
+    dimension: data.config.dimension ?? 0,
+    metric: data.config.metric ?? "cosine",
+    count: data.store.len,
+    createdAt: data.createdAt
+  };
+}
+
+// src/backends/wasm-search.ts
+function searchSparseOnly(ctx, collection, indices, values, k) {
+  const sparseResults = collection.store.sparse_search(
+    new Uint32Array(indices),
+    new Float32Array(values),
+    k
+  );
+  return sparseResults.map((r) => ({
+    id: String(r.doc_id),
+    score: r.score,
+    payload: collection.payloads.get(ctx.canonicalPayloadKeyFromResultId(r.doc_id))
+  }));
+}
+function searchHybridFusion(ctx, collection, queryVector, indices, values, k) {
+  const denseResults = collection.store.search(queryVector, k);
+  const sparseResults = collection.store.sparse_search(
+    new Uint32Array(indices),
+    new Float32Array(values),
+    k
+  );
+  const denseForFuse = denseResults.map(
+    ([id, score]) => [Number(id), score]
+  );
+  const sparseForFuse = sparseResults.map(
+    (r) => [Number(r.doc_id), r.score]
+  );
+  const fused = ctx.wasmModule.hybrid_search_fuse(
+    denseForFuse,
+    sparseForFuse,
+    60,
+    k
+  );
+  return fused.slice(0, k).map((r) => ({
+    id: String(r.doc_id),
+    score: r.score,
+    payload: collection.payloads.get(ctx.canonicalPayloadKeyFromResultId(r.doc_id))
+  }));
+}
+function searchWithFilter(ctx, collection, queryVector, k, filter) {
+  const results = collection.store.search_with_filter(
+    queryVector,
+    k,
+    filter
+  );
+  return results.map((r) => ({
+    id: String(r.id),
+    score: r.score,
+    payload: r.payload || collection.payloads.get(ctx.canonicalPayloadKeyFromResultId(r.id))
+  }));
+}
+function searchDenseOnly(ctx, collection, queryVector, k) {
+  const rawResults = collection.store.search(queryVector, k);
+  return rawResults.map(([id, score]) => {
+    const result = { id: String(id), score };
+    const payload = collection.payloads.get(ctx.canonicalPayloadKeyFromResultId(id));
+    if (payload) {
+      result.payload = payload;
+    }
+    return result;
+  });
+}
+async function wasmSearch(ctx, collectionName, query3, options) {
+  const collection = ctx.getCollection(collectionName);
+  if (!collection) {
+    throw new NotFoundError(`Collection '${collectionName}'`);
+  }
+  const queryVector = query3 instanceof Float32Array ? query3 : new Float32Array(query3);
+  if (queryVector.length !== collection.config.dimension) {
+    throw new VelesDBError(
+      `Query dimension mismatch: expected ${collection.config.dimension}, got ${queryVector.length}`,
+      "DIMENSION_MISMATCH"
+    );
+  }
+  const k = options?.k ?? 10;
+  if (options?.sparseVector) {
+    const { indices, values } = ctx.sparseVectorToArrays(options.sparseVector);
+    const hasDense = queryVector.length > 0 && collection.config.dimension !== void 0 && collection.config.dimension > 0;
+    return hasDense ? searchHybridFusion(ctx, collection, queryVector, indices, values, k) : searchSparseOnly(ctx, collection, indices, values, k);
+  }
+  if (options?.filter) {
+    return searchWithFilter(ctx, collection, queryVector, k, options.filter);
+  }
+  return searchDenseOnly(ctx, collection, queryVector, k);
+}
+async function wasmSearchBatch(ctx, collectionName, searches) {
+  const results = [];
+  for (const s of searches) {
+    results.push(
+      await wasmSearch(ctx, collectionName, s.vector, {
+        k: s.k,
+        filter: s.filter,
+        quality: s.quality
+      })
+    );
+  }
+  return results;
+}
+function mapWasmResult(ctx, collection, r) {
+  if (Array.isArray(r)) {
+    const key2 = ctx.canonicalPayloadKeyFromResultId(r[0]);
+    return { id: String(r[0]), score: r[1], payload: collection.payloads.get(key2) };
+  }
+  const key = ctx.canonicalPayloadKeyFromResultId(r.id);
+  return { id: String(r.id), score: r.score, payload: r.payload ?? collection.payloads.get(key) };
+}
+async function wasmTextSearch(ctx, collectionName, query3, options) {
+  const collection = ctx.getCollection(collectionName);
+  if (!collection) {
+    throw new NotFoundError(`Collection '${collectionName}'`);
+  }
+  const k = options?.k ?? 10;
+  const raw = collection.store.text_search(query3, k, void 0);
+  return raw.map((r) => mapWasmResult(ctx, collection, r));
+}
+async function wasmHybridSearch(ctx, collectionName, vector, textQuery, options) {
+  const collection = ctx.getCollection(collectionName);
+  if (!collection) {
+    throw new NotFoundError(`Collection '${collectionName}'`);
+  }
+  const queryVector = vector instanceof Float32Array ? vector : new Float32Array(vector);
+  const k = options?.k ?? 10;
+  const vectorWeight = options?.vectorWeight ?? 0.5;
+  const raw = collection.store.hybrid_search(
+    queryVector,
+    textQuery,
+    k,
+    vectorWeight
+  );
+  return raw.map((r) => {
+    const key = ctx.canonicalPayloadKeyFromResultId(r.id);
+    return { id: String(r.id), score: r.score, payload: r.payload ?? collection.payloads.get(key) };
+  });
+}
+async function wasmMultiQuerySearch(ctx, collectionName, vectors, options) {
+  const collection = ctx.getCollection(collectionName);
+  if (!collection) {
+    throw new NotFoundError(`Collection '${collectionName}'`);
+  }
+  if (vectors.length === 0) {
+    return [];
+  }
+  const numVectors = vectors.length;
+  const dimension = collection.config.dimension ?? 0;
+  const flat = new Float32Array(numVectors * dimension);
+  vectors.forEach((vector, idx) => {
+    const src = vector instanceof Float32Array ? vector : new Float32Array(vector);
+    flat.set(src, idx * dimension);
+  });
+  const strategy = options?.fusion ?? "rrf";
+  const raw = collection.store.multi_query_search(
+    flat,
+    numVectors,
+    options?.k ?? 10,
+    strategy,
+    options?.fusionParams?.k ?? 60
+  );
+  return raw.map((r) => mapWasmResult(ctx, collection, r));
+}
+async function wasmQuery(ctx, collectionName, _queryString, params, _options) {
+  const collection = ctx.getCollection(collectionName);
+  if (!collection) {
+    throw new NotFoundError(`Collection '${collectionName}'`);
+  }
+  const paramsVector = params?.q;
+  if (!Array.isArray(paramsVector) && !(paramsVector instanceof Float32Array)) {
+    throw new VelesDBError(
+      "WASM query() expects params.q to contain the query embedding vector.",
+      "BAD_REQUEST"
+    );
+  }
+  const requestedK = params?.k;
+  const k = typeof requestedK === "number" && Number.isInteger(requestedK) && requestedK > 0 ? requestedK : 10;
+  const raw = collection.store.query(
+    paramsVector instanceof Float32Array ? paramsVector : new Float32Array(paramsVector),
+    k
+  );
+  return {
+    results: raw,
+    stats: {
+      executionTimeMs: 0,
+      strategy: "wasm-query",
+      scannedNodes: raw.length
+    }
+  };
+}
+
+// src/errors.ts
+var VelesError = class extends VelesDBError {
+  constructor(message, code, cause) {
+    super(message, code, cause);
+    this.name = "VelesError";
+  }
+};
+var CollectionExistsError = class extends VelesError {
+  constructor(message) {
+    super(message, "VELES-001");
+    this.name = "CollectionExistsError";
+  }
+};
+var CollectionNotFoundError = class extends VelesError {
+  constructor(message) {
+    super(message, "VELES-002");
+    this.name = "CollectionNotFoundError";
+  }
+};
+var PointNotFoundError = class extends VelesError {
+  constructor(message) {
+    super(message, "VELES-003");
+    this.name = "PointNotFoundError";
+  }
+};
+var DimensionMismatchError = class extends VelesError {
+  constructor(message) {
+    super(message, "VELES-004");
+    this.name = "DimensionMismatchError";
+  }
+};
+var InvalidVectorError = class extends VelesError {
+  constructor(message) {
+    super(message, "VELES-005");
+    this.name = "InvalidVectorError";
+  }
+};
+var StorageError = class extends VelesError {
+  constructor(message) {
+    super(message, "VELES-006");
+    this.name = "StorageError";
+  }
+};
+var IndexError = class extends VelesError {
+  constructor(message) {
+    super(message, "VELES-007");
+    this.name = "IndexError";
+  }
+};
+var IndexCorruptedError = class extends VelesError {
+  constructor(message) {
+    super(message, "VELES-008");
+    this.name = "IndexCorruptedError";
+  }
+};
+var ConfigError = class extends VelesError {
+  constructor(message) {
+    super(message, "VELES-009");
+    this.name = "ConfigError";
+  }
+};
+var QueryError = class extends VelesError {
+  constructor(message) {
+    super(message, "VELES-010");
+    this.name = "QueryError";
+  }
+};
+var IoError = class extends VelesError {
+  constructor(message) {
+    super(message, "VELES-011");
+    this.name = "IoError";
+  }
+};
+var SerializationError = class extends VelesError {
+  constructor(message) {
+    super(message, "VELES-012");
+    this.name = "SerializationError";
+  }
+};
+var InternalError = class extends VelesError {
+  constructor(message) {
+    super(message, "VELES-013");
+    this.name = "InternalError";
+  }
+};
+var VectorNotAllowedError = class extends VelesError {
+  constructor(message) {
+    super(message, "VELES-014");
+    this.name = "VectorNotAllowedError";
+  }
+};
+var SearchNotSupportedError = class extends VelesError {
+  constructor(message) {
+    super(message, "VELES-015");
+    this.name = "SearchNotSupportedError";
+  }
+};
+var VectorRequiredError = class extends VelesError {
+  constructor(message) {
+    super(message, "VELES-016");
+    this.name = "VectorRequiredError";
+  }
+};
+var SchemaValidationError = class extends VelesError {
+  constructor(message) {
+    super(message, "VELES-017");
+    this.name = "SchemaValidationError";
+  }
+};
+var GraphNotSupportedError = class extends VelesError {
+  constructor(message) {
+    super(message, "VELES-018");
+    this.name = "GraphNotSupportedError";
+  }
+};
+var EdgeExistsError = class extends VelesError {
+  constructor(message) {
+    super(message, "VELES-019");
+    this.name = "EdgeExistsError";
+  }
+};
+var EdgeNotFoundError = class extends VelesError {
+  constructor(message) {
+    super(message, "VELES-020");
+    this.name = "EdgeNotFoundError";
+  }
+};
+var InvalidEdgeLabelError = class extends VelesError {
+  constructor(message) {
+    super(message, "VELES-021");
+    this.name = "InvalidEdgeLabelError";
+  }
+};
+var NodeNotFoundError = class extends VelesError {
+  constructor(message) {
+    super(message, "VELES-022");
+    this.name = "NodeNotFoundError";
+  }
+};
+var OverflowError = class extends VelesError {
+  constructor(message) {
+    super(message, "VELES-023");
+    this.name = "OverflowError";
+  }
+};
+var ColumnStoreError = class extends VelesError {
+  constructor(message) {
+    super(message, "VELES-024");
+    this.name = "ColumnStoreError";
+  }
+};
+var GpuError = class extends VelesError {
+  constructor(message) {
+    super(message, "VELES-025");
+    this.name = "GpuError";
+  }
+};
+var EpochMismatchError = class extends VelesError {
+  constructor(message) {
+    super(message, "VELES-026");
+    this.name = "EpochMismatchError";
+  }
+};
+var GuardRailError = class extends VelesError {
+  constructor(message) {
+    super(message, "VELES-027");
+    this.name = "GuardRailError";
+  }
+};
+var InvalidQuantizerConfigError = class extends VelesError {
+  constructor(message) {
+    super(message, "VELES-028");
+    this.name = "InvalidQuantizerConfigError";
+  }
+};
+var TrainingFailedError = class extends VelesError {
+  constructor(message) {
+    super(message, "VELES-029");
+    this.name = "TrainingFailedError";
+  }
+};
+var SparseIndexError = class extends VelesError {
+  constructor(message) {
+    super(message, "VELES-030");
+    this.name = "SparseIndexError";
+  }
+};
+var DatabaseLockedError = class extends VelesError {
+  constructor(message) {
+    super(message, "VELES-031");
+    this.name = "DatabaseLockedError";
+  }
+};
+var InvalidDimensionError = class extends VelesError {
+  constructor(message) {
+    super(message, "VELES-032");
+    this.name = "InvalidDimensionError";
+  }
+};
+var AllocationFailedError = class extends VelesError {
+  constructor(message) {
+    super(message, "VELES-033");
+    this.name = "AllocationFailedError";
+  }
+};
+var InvalidCollectionNameError = class extends VelesError {
+  constructor(message) {
+    super(message, "VELES-034");
+    this.name = "InvalidCollectionNameError";
+  }
+};
+var SnapshotBuildFailedError = class extends VelesError {
+  constructor(message) {
+    super(message, "VELES-035");
+    this.name = "SnapshotBuildFailedError";
+  }
+};
+var IncompatibleSchemaVersionError = class extends VelesError {
+  constructor(message) {
+    super(message, "VELES-036");
+    this.name = "IncompatibleSchemaVersionError";
+  }
+};
+var VELES_ERROR_CODES = [
+  "VELES-001",
+  "VELES-002",
+  "VELES-003",
+  "VELES-004",
+  "VELES-005",
+  "VELES-006",
+  "VELES-007",
+  "VELES-008",
+  "VELES-009",
+  "VELES-010",
+  "VELES-011",
+  "VELES-012",
+  "VELES-013",
+  "VELES-014",
+  "VELES-015",
+  "VELES-016",
+  "VELES-017",
+  "VELES-018",
+  "VELES-019",
+  "VELES-020",
+  "VELES-021",
+  "VELES-022",
+  "VELES-023",
+  "VELES-024",
+  "VELES-025",
+  "VELES-026",
+  "VELES-027",
+  "VELES-028",
+  "VELES-029",
+  "VELES-030",
+  "VELES-031",
+  "VELES-032",
+  "VELES-033",
+  "VELES-034",
+  "VELES-035",
+  "VELES-036"
+];
+var CODE_TO_CLASS = {
+  "VELES-001": CollectionExistsError,
+  "VELES-002": CollectionNotFoundError,
+  "VELES-003": PointNotFoundError,
+  "VELES-004": DimensionMismatchError,
+  "VELES-005": InvalidVectorError,
+  "VELES-006": StorageError,
+  "VELES-007": IndexError,
+  "VELES-008": IndexCorruptedError,
+  "VELES-009": ConfigError,
+  "VELES-010": QueryError,
+  "VELES-011": IoError,
+  "VELES-012": SerializationError,
+  "VELES-013": InternalError,
+  "VELES-014": VectorNotAllowedError,
+  "VELES-015": SearchNotSupportedError,
+  "VELES-016": VectorRequiredError,
+  "VELES-017": SchemaValidationError,
+  "VELES-018": GraphNotSupportedError,
+  "VELES-019": EdgeExistsError,
+  "VELES-020": EdgeNotFoundError,
+  "VELES-021": InvalidEdgeLabelError,
+  "VELES-022": NodeNotFoundError,
+  "VELES-023": OverflowError,
+  "VELES-024": ColumnStoreError,
+  "VELES-025": GpuError,
+  "VELES-026": EpochMismatchError,
+  "VELES-027": GuardRailError,
+  "VELES-028": InvalidQuantizerConfigError,
+  "VELES-029": TrainingFailedError,
+  "VELES-030": SparseIndexError,
+  "VELES-031": DatabaseLockedError,
+  "VELES-032": InvalidDimensionError,
+  "VELES-033": AllocationFailedError,
+  "VELES-034": InvalidCollectionNameError,
+  "VELES-035": SnapshotBuildFailedError,
+  "VELES-036": IncompatibleSchemaVersionError
+};
+function parseVelesError(code, message) {
+  if (code === null || code === void 0) {
+    return new VelesError(message, "VELES-UNKNOWN");
+  }
+  const Cls = CODE_TO_CLASS[code];
+  if (Cls !== void 0) {
+    return new Cls(message);
+  }
+  return new VelesError(message, code);
+}
+
 // src/backends/shared.ts
 function throwOnError(response, resourceLabel) {
   if (!response.error) {
@@ -40,20 +644,87 @@ function throwOnError(response, resourceLabel) {
   if (response.error.code === "NOT_FOUND" && resourceLabel !== void 0) {
     throw new NotFoundError(resourceLabel);
   }
-  throw new VelesDBError(response.error.message, response.error.code);
+  throw parseVelesError(response.error.code, response.error.message);
 }
 function returnNullOnNotFound(response) {
   if (!response.error) {
     return void 0;
   }
-  if (response.error.code === "NOT_FOUND") {
+  if (isNotFoundError(response.error.code)) {
+    return true;
+  }
+  throw parseVelesError(response.error.code, response.error.message);
+}
+function isNotFoundError(code) {
+  if (code === void 0) {
+    return false;
+  }
+  if (code === "NOT_FOUND") {
     return true;
   }
-  throw new VelesDBError(response.error.message, response.error.code);
+  const err = parseVelesError(code, "");
+  return err instanceof CollectionNotFoundError || err instanceof PointNotFoundError || err instanceof EdgeNotFoundError || err instanceof NodeNotFoundError;
 }
 function collectionPath(collection) {
   return `/collections/${encodeURIComponent(collection)}`;
 }
+var MAX_COLLECTION_NAME_LENGTH = 128;
+var WINDOWS_RESERVED_NAMES = /* @__PURE__ */ new Set([
+  "CON",
+  "PRN",
+  "AUX",
+  "NUL",
+  "COM1",
+  "COM2",
+  "COM3",
+  "COM4",
+  "COM5",
+  "COM6",
+  "COM7",
+  "COM8",
+  "COM9",
+  "LPT1",
+  "LPT2",
+  "LPT3",
+  "LPT4",
+  "LPT5",
+  "LPT6",
+  "LPT7",
+  "LPT8",
+  "LPT9"
+]);
+function validateCollectionName(name) {
+  if (typeof name !== "string" || name.length === 0) {
+    throw new InvalidCollectionNameError(
+      "Collection name must be a non-empty string"
+    );
+  }
+  if (name.length > MAX_COLLECTION_NAME_LENGTH) {
+    throw new InvalidCollectionNameError(
+      `Collection name '${name}' exceeds maximum length of ${MAX_COLLECTION_NAME_LENGTH} characters`
+    );
+  }
+  if (name === "." || name === "..") {
+    throw new InvalidCollectionNameError(
+      `Collection name '${name}' is not allowed (path traversal)`
+    );
+  }
+  if (name.startsWith("-")) {
+    throw new InvalidCollectionNameError(
+      `Collection name '${name}' must not start with a hyphen`
+    );
+  }
+  if (!/^[A-Za-z0-9_-]+$/.test(name)) {
+    throw new InvalidCollectionNameError(
+      `Collection name '${name}' contains forbidden characters; only ASCII letters, digits, underscores, and hyphens are allowed`
+    );
+  }
+  if (WINDOWS_RESERVED_NAMES.has(name.toUpperCase())) {
+    throw new InvalidCollectionNameError(
+      `Collection name '${name}' is a Windows reserved device name`
+    );
+  }
+}
 function toNumberArray(v) {
   return v instanceof Float32Array ? Array.from(v) : v;
 }
@@ -64,6 +735,127 @@ function wasmNotSupported(feature) {
   );
 }
 
+// src/backends/wasm-stubs.ts
+async function wasmCreateIndex(_collection, _options) {
+  wasmNotSupported("Index management (createIndex)");
+}
+async function wasmListIndexes(_collection) {
+  wasmNotSupported("Index management (listIndexes)");
+}
+async function wasmHasIndex(_collection, _label, _property) {
+  wasmNotSupported("Index management (hasIndex)");
+}
+async function wasmDropIndex(_collection, _label, _property) {
+  wasmNotSupported("Index management (dropIndex)");
+}
+async function wasmAddEdge(_collection, _edge) {
+  wasmNotSupported("Knowledge Graph operations");
+}
+async function wasmGetEdges(_collection, _options) {
+  wasmNotSupported("Knowledge Graph operations");
+}
+async function wasmTraverseGraph(_collection, _request) {
+  wasmNotSupported("Graph traversal");
+}
+async function wasmTraverseParallel(_collection, _request) {
+  wasmNotSupported("Graph parallel traversal");
+}
+async function wasmGetNodeDegree(_collection, _nodeId) {
+  wasmNotSupported("Graph degree query");
+}
+async function wasmQueryExplain(_queryString, _params, _options) {
+  if (_options?.analyze) {
+    wasmNotSupported("EXPLAIN ANALYZE");
+  }
+  wasmNotSupported("Query explain");
+}
+async function wasmCollectionSanity(_collection) {
+  wasmNotSupported("Collection sanity endpoint");
+}
+async function wasmScroll(_collection, _request) {
+  wasmNotSupported("scroll");
+}
+async function wasmTrainPq(_collection, _options) {
+  wasmNotSupported("PQ training");
+}
+async function wasmStreamInsert(_collection, _docs) {
+  wasmNotSupported("Streaming insert");
+}
+async function wasmStreamUpsertPoints(_collection, _docs) {
+  wasmNotSupported("Streaming batch upsert");
+}
+async function wasmCreateGraphCollection(_name, _config) {
+  wasmNotSupported("Graph collections");
+}
+async function wasmGetCollectionStats(_collection) {
+  wasmNotSupported("Collection stats");
+}
+async function wasmAnalyzeCollection(_collection) {
+  wasmNotSupported("Collection analyze");
+}
+async function wasmGetCollectionConfig(_collection) {
+  wasmNotSupported("Collection config");
+}
+async function wasmSearchIds(_collection, _query, _options) {
+  wasmNotSupported("searchIds");
+}
+async function wasmStoreSemanticFact(_collection, _entry) {
+  wasmNotSupported("Agent memory");
+}
+async function wasmSearchSemanticMemory(_collection, _embedding, _k) {
+  wasmNotSupported("Agent memory");
+}
+async function wasmRecordEpisodicEvent(_collection, _event) {
+  wasmNotSupported("Agent memory");
+}
+async function wasmRecallEpisodicEvents(_collection, _embedding, _k) {
+  wasmNotSupported("Agent memory");
+}
+async function wasmStoreProceduralPattern(_collection, _pattern) {
+  wasmNotSupported("Agent memory");
+}
+async function wasmMatchProceduralPatterns(_collection, _embedding, _k) {
+  wasmNotSupported("Agent memory");
+}
+
+// src/backends/wasm-wave4-stubs.ts
+function wasmRebuildIndex(_c) {
+  return Promise.resolve(wasmNotSupported("Index rebuild"));
+}
+function wasmGetGuardrails() {
+  return Promise.resolve(wasmNotSupported("Guardrails"));
+}
+function wasmUpdateGuardrails(_r) {
+  return Promise.resolve(wasmNotSupported("Guardrails"));
+}
+function wasmAggregate(_q, _p, _o) {
+  return Promise.resolve(wasmNotSupported("Aggregate queries"));
+}
+function wasmMatchQuery(_c, _q, _p, _o) {
+  return Promise.resolve(wasmNotSupported("MATCH queries"));
+}
+function wasmRemoveEdge(_c, _id) {
+  return Promise.resolve(wasmNotSupported("Graph edge removal"));
+}
+function wasmGetEdgeCount(_c) {
+  return Promise.resolve(wasmNotSupported("Graph edge count"));
+}
+function wasmListNodes(_c) {
+  return Promise.resolve(wasmNotSupported("Graph list nodes"));
+}
+function wasmGetNodeEdges(_c, _id, _o) {
+  return Promise.resolve(wasmNotSupported("Graph node edges"));
+}
+function wasmGetNodePayload(_c, _id) {
+  return Promise.resolve(wasmNotSupported("Graph node payload (read)"));
+}
+function wasmUpsertNodePayload(_c, _id, _p) {
+  return Promise.resolve(wasmNotSupported("Graph node payload (upsert)"));
+}
+function wasmGraphSearch(_c, _r) {
+  return Promise.resolve(wasmNotSupported("Graph search"));
+}
+
 // src/backends/wasm.ts
 var WasmBackend = class {
   constructor() {
@@ -71,6 +863,9 @@ var WasmBackend = class {
     this.collections = /* @__PURE__ */ new Map();
     this._initialized = false;
   }
+  // ========================================================================
+  // Lifecycle
+  // ========================================================================
   async init() {
     if (this._initialized) {
       return;
@@ -89,45 +884,32 @@ var WasmBackend = class {
   isInitialized() {
     return this._initialized;
   }
+  async close() {
+    for (const [, data] of this.collections) {
+      data.store.free();
+    }
+    this.collections.clear();
+    this._initialized = false;
+  }
+  capabilities() {
+    return WASM_CAPABILITIES;
+  }
   ensureInitialized() {
     if (!this._initialized || !this.wasmModule) {
       throw new ConnectionError("WASM backend not initialized");
     }
   }
-  normalizeIdString(id) {
-    const trimmed = id.trim();
-    return /^\d+$/.test(trimmed) ? trimmed : null;
-  }
-  canonicalPayloadKeyFromResultId(id) {
-    if (typeof id === "bigint") {
-      return id.toString();
-    }
-    if (typeof id === "number") {
-      return String(Math.trunc(id));
-    }
-    const normalized = this.normalizeIdString(id);
-    if (normalized !== null) {
-      return normalized.replace(/^0+(?=\d)/, "");
-    }
-    return String(this.toNumericId(id));
-  }
-  canonicalPayloadKey(id) {
-    if (typeof id === "number") {
-      return String(Math.trunc(id));
-    }
-    const normalized = this.normalizeIdString(id);
-    if (normalized !== null) {
-      return normalized.replace(/^0+(?=\d)/, "");
-    }
-    return String(this.toNumericId(id));
-  }
+  // ========================================================================
+  // Collection management
+  // ========================================================================
   async createCollection(name, config) {
     this.ensureInitialized();
     if (this.collections.has(name)) {
       throw new VelesDBError(`Collection '${name}' already exists`, "COLLECTION_EXISTS");
     }
+    const dimension = config.dimension ?? 0;
     const metric = config.metric ?? "cosine";
-    const store = new this.wasmModule.VectorStore(config.dimension, metric);
+    const store = new this.wasmModule.VectorStore(dimension, metric);
     this.collections.set(name, {
       config: { ...config, metric },
       store,
@@ -146,39 +928,27 @@ var WasmBackend = class {
   }
   async getCollection(name) {
     this.ensureInitialized();
-    const collection = this.collections.get(name);
-    if (!collection) {
-      return null;
-    }
-    return {
-      name,
-      dimension: collection.config.dimension ?? 0,
-      metric: collection.config.metric ?? "cosine",
-      count: collection.store.len,
-      createdAt: collection.createdAt
-    };
+    const data = this.collections.get(name);
+    return data ? buildCollectionInfo(name, data) : null;
   }
   async listCollections() {
     this.ensureInitialized();
     const result = [];
     for (const [name, data] of this.collections) {
-      result.push({
-        name,
-        dimension: data.config.dimension ?? 0,
-        metric: data.config.metric ?? "cosine",
-        count: data.store.len,
-        createdAt: data.createdAt
-      });
+      result.push(buildCollectionInfo(name, data));
     }
     return result;
   }
-  async insert(collectionName, doc) {
+  // ========================================================================
+  // Point CRUD
+  // ========================================================================
+  async upsert(collectionName, doc) {
     this.ensureInitialized();
     const collection = this.collections.get(collectionName);
     if (!collection) {
       throw new NotFoundError(`Collection '${collectionName}'`);
     }
-    const id = this.toNumericId(doc.id);
+    const id = toNumericId(doc.id);
     const vector = doc.vector instanceof Float32Array ? doc.vector : new Float32Array(doc.vector);
     if (vector.length !== collection.config.dimension) {
       throw new VelesDBError(
@@ -192,20 +962,19 @@ var WasmBackend = class {
       collection.store.insert(BigInt(id), vector);
     }
     if (doc.payload) {
-      collection.payloads.set(this.canonicalPayloadKey(doc.id), doc.payload);
+      collection.payloads.set(canonicalPayloadKey(doc.id), doc.payload);
     }
   }
-  async insertBatch(collectionName, docs) {
+  async upsertBatch(collectionName, docs) {
     this.ensureInitialized();
     const collection = this.collections.get(collectionName);
     if (!collection) {
       throw new NotFoundError(`Collection '${collectionName}'`);
     }
     for (const doc of docs) {
-      const vectorLen = doc.vector.length;
-      if (vectorLen !== collection.config.dimension) {
+      if (doc.vector.length !== collection.config.dimension) {
         throw new VelesDBError(
-          `Vector dimension mismatch for doc ${doc.id}: expected ${collection.config.dimension}, got ${vectorLen}`,
+          `Vector dimension mismatch for doc ${doc.id}: expected ${collection.config.dimension}, got ${doc.vector.length}`,
           "DIMENSION_MISMATCH"
         );
       }
@@ -213,7 +982,7 @@ var WasmBackend = class {
     collection.store.reserve(docs.length);
     const batch = [];
     for (const doc of docs) {
-      const id = BigInt(this.toNumericId(doc.id));
+      const id = BigInt(toNumericId(doc.id));
       const vector = doc.vector instanceof Float32Array ? doc.vector : new Float32Array(doc.vector);
       if (doc.payload) {
         collection.store.insert_with_payload(id, vector, doc.payload);
@@ -226,95 +995,20 @@ var WasmBackend = class {
     }
     for (const doc of docs) {
       if (doc.payload) {
-        collection.payloads.set(this.canonicalPayloadKey(doc.id), doc.payload);
+        collection.payloads.set(canonicalPayloadKey(doc.id), doc.payload);
       }
     }
   }
-  async search(collectionName, query2, options) {
-    this.ensureInitialized();
-    const collection = this.collections.get(collectionName);
-    if (!collection) {
-      throw new NotFoundError(`Collection '${collectionName}'`);
-    }
-    const queryVector = query2 instanceof Float32Array ? query2 : new Float32Array(query2);
-    if (queryVector.length !== collection.config.dimension) {
-      throw new VelesDBError(
-        `Query dimension mismatch: expected ${collection.config.dimension}, got ${queryVector.length}`,
-        "DIMENSION_MISMATCH"
-      );
-    }
-    const k = options?.k ?? 10;
-    if (options?.sparseVector) {
-      const { indices, values } = this.sparseVectorToArrays(options.sparseVector);
-      if (queryVector.length > 0 && collection.config.dimension && collection.config.dimension > 0) {
-        const denseResults = collection.store.search(queryVector, k);
-        const sparseResults = collection.store.sparse_search(
-          new Uint32Array(indices),
-          new Float32Array(values),
-          k
-        );
-        const sparseArray = sparseResults;
-        const denseForFuse = denseResults.map(([id, score]) => [Number(id), score]);
-        const sparseForFuse = sparseArray.map((r) => [Number(r.doc_id), r.score]);
-        const fused = this.wasmModule.hybrid_search_fuse(denseForFuse, sparseForFuse, 60);
-        return fused.slice(0, k).map((r) => ({
-          id: String(r.doc_id),
-          score: r.score,
-          payload: collection.payloads.get(this.canonicalPayloadKeyFromResultId(r.doc_id))
-        }));
-      } else {
-        const sparseResults = collection.store.sparse_search(
-          new Uint32Array(indices),
-          new Float32Array(values),
-          k
-        );
-        return sparseResults.map((r) => ({
-          id: String(r.doc_id),
-          score: r.score,
-          payload: collection.payloads.get(this.canonicalPayloadKeyFromResultId(r.doc_id))
-        }));
-      }
-    }
-    if (options?.filter) {
-      const results = collection.store.search_with_filter(queryVector, k, options.filter);
-      return results.map((r) => ({
-        id: String(r.id),
-        score: r.score,
-        payload: r.payload || collection.payloads.get(this.canonicalPayloadKeyFromResultId(r.id))
-      }));
-    }
-    const rawResults = collection.store.search(queryVector, k);
-    return rawResults.map(([id, score]) => {
-      const stringId = String(id);
-      const result = {
-        id: stringId,
-        score
-      };
-      const payload = collection.payloads.get(this.canonicalPayloadKeyFromResultId(id));
-      if (payload) {
-        result.payload = payload;
-      }
-      return result;
-    });
-  }
-  async searchBatch(collectionName, searches) {
-    this.ensureInitialized();
-    const results = [];
-    for (const s of searches) {
-      results.push(await this.search(collectionName, s.vector, { k: s.k, filter: s.filter }));
-    }
-    return results;
-  }
   async delete(collectionName, id) {
     this.ensureInitialized();
     const collection = this.collections.get(collectionName);
     if (!collection) {
       throw new NotFoundError(`Collection '${collectionName}'`);
     }
-    const numericId = this.toNumericId(id);
+    const numericId = toNumericId(id);
     const removed = collection.store.remove(BigInt(numericId));
     if (removed) {
-      collection.payloads.delete(this.canonicalPayloadKey(id));
+      collection.payloads.delete(canonicalPayloadKey(id));
     }
     return removed;
   }
@@ -324,287 +1018,691 @@ var WasmBackend = class {
     if (!collection) {
       throw new NotFoundError(`Collection '${collectionName}'`);
     }
-    const numericId = this.toNumericId(id);
+    const numericId = toNumericId(id);
     const point = collection.store.get(BigInt(numericId));
     if (!point) {
       return null;
     }
-    const payload = point.payload ?? collection.payloads.get(this.canonicalPayloadKey(numericId));
+    const payload = point.payload ?? collection.payloads.get(canonicalPayloadKey(numericId));
     return {
       id: String(point.id),
       vector: Array.isArray(point.vector) ? point.vector : Array.from(point.vector),
       payload
     };
   }
-  async textSearch(_collection, _query, _options) {
+  // ========================================================================
+  // Collection utilities
+  // ========================================================================
+  async isEmpty(collectionName) {
     this.ensureInitialized();
-    const collection = this.collections.get(_collection);
+    const collection = this.collections.get(collectionName);
     if (!collection) {
-      throw new NotFoundError(`Collection '${_collection}'`);
-    }
-    const k = _options?.k ?? 10;
-    const field = void 0;
-    const raw = collection.store.text_search(_query, k, field);
-    return raw.map((r) => {
-      if (Array.isArray(r)) {
-        const key2 = this.canonicalPayloadKeyFromResultId(r[0]);
-        return { id: String(r[0]), score: r[1], payload: collection.payloads.get(key2) };
-      }
-      const key = this.canonicalPayloadKeyFromResultId(r.id);
-      return { id: String(r.id), score: r.score, payload: r.payload ?? collection.payloads.get(key) };
-    });
+      throw new NotFoundError(`Collection '${collectionName}'`);
+    }
+    return collection.store.is_empty;
   }
-  async hybridSearch(_collection, _vector, _textQuery, _options) {
+  async flush(collectionName) {
     this.ensureInitialized();
-    const collection = this.collections.get(_collection);
+    const collection = this.collections.get(collectionName);
     if (!collection) {
-      throw new NotFoundError(`Collection '${_collection}'`);
-    }
-    const queryVector = _vector instanceof Float32Array ? _vector : new Float32Array(_vector);
-    const k = _options?.k ?? 10;
-    const vectorWeight = _options?.vectorWeight ?? 0.5;
-    const raw = collection.store.hybrid_search(queryVector, _textQuery, k, vectorWeight);
-    return raw.map((r) => {
-      const key = this.canonicalPayloadKeyFromResultId(r.id);
-      return {
-        id: String(r.id),
-        score: r.score,
-        payload: r.payload ?? collection.payloads.get(key)
-      };
-    });
+      throw new NotFoundError(`Collection '${collectionName}'`);
+    }
   }
-  async query(_collection, _queryString, _params, _options) {
+  // ========================================================================
+  // Search & Query -- delegates to wasm-search.ts
+  // ========================================================================
+  async search(c, q, o) {
     this.ensureInitialized();
-    const collection = this.collections.get(_collection);
-    if (!collection) {
-      throw new NotFoundError(`Collection '${_collection}'`);
-    }
-    const paramsVector = _params?.q;
-    if (!Array.isArray(paramsVector) && !(paramsVector instanceof Float32Array)) {
-      throw new VelesDBError(
-        "WASM query() expects params.q to contain the query embedding vector.",
-        "BAD_REQUEST"
-      );
-    }
-    const requestedK = _params?.k;
-    const k = typeof requestedK === "number" && Number.isInteger(requestedK) && requestedK > 0 ? requestedK : 10;
-    const raw = collection.store.query(
-      paramsVector instanceof Float32Array ? paramsVector : new Float32Array(paramsVector),
-      k
-    );
-    return {
-      results: raw,
-      stats: {
-        executionTimeMs: 0,
-        strategy: "wasm-query",
-        scannedNodes: raw.length
-      }
-    };
+    return wasmSearch(buildWasmContext(this.wasmModule, this.collections), c, q, o);
   }
-  async multiQuerySearch(_collection, _vectors, _options) {
+  async searchBatch(c, s) {
     this.ensureInitialized();
-    const collection = this.collections.get(_collection);
-    if (!collection) {
-      throw new NotFoundError(`Collection '${_collection}'`);
-    }
-    if (_vectors.length === 0) {
-      return [];
-    }
-    const numVectors = _vectors.length;
-    const dimension = collection.config.dimension ?? 0;
-    const flat = new Float32Array(numVectors * dimension);
-    _vectors.forEach((vector, idx) => {
-      const src = vector instanceof Float32Array ? vector : new Float32Array(vector);
-      flat.set(src, idx * dimension);
-    });
-    const strategy = _options?.fusion ?? "rrf";
-    if (strategy === "weighted") {
-      throw new VelesDBError(
-        "Fusion strategy 'weighted' is not supported in WASM backend.",
-        "NOT_SUPPORTED"
-      );
-    }
-    const raw = collection.store.multi_query_search(
-      flat,
-      numVectors,
-      _options?.k ?? 10,
-      strategy,
-      _options?.fusionParams?.k ?? 60
-    );
-    return raw.map((r) => {
-      if (Array.isArray(r)) {
-        const key2 = this.canonicalPayloadKeyFromResultId(r[0]);
-        return { id: String(r[0]), score: r[1], payload: collection.payloads.get(key2) };
-      }
-      const key = this.canonicalPayloadKeyFromResultId(r.id);
-      return { id: String(r.id), score: r.score, payload: r.payload ?? collection.payloads.get(key) };
-    });
+    return wasmSearchBatch(buildWasmContext(this.wasmModule, this.collections), c, s);
   }
-  async queryExplain(_queryString, _params) {
+  async textSearch(c, q, o) {
     this.ensureInitialized();
-    wasmNotSupported("Query explain");
+    return wasmTextSearch(buildWasmContext(this.wasmModule, this.collections), c, q, o);
   }
-  async collectionSanity(_collection) {
+  async hybridSearch(c, v, t, o) {
     this.ensureInitialized();
-    wasmNotSupported("Collection sanity endpoint");
+    return wasmHybridSearch(buildWasmContext(this.wasmModule, this.collections), c, v, t, o);
   }
-  async isEmpty(collectionName) {
+  async query(c, q, p, o) {
     this.ensureInitialized();
-    const collection = this.collections.get(collectionName);
-    if (!collection) {
-      throw new NotFoundError(`Collection '${collectionName}'`);
-    }
-    return collection.store.is_empty();
+    return wasmQuery(buildWasmContext(this.wasmModule, this.collections), c, q, p, o);
   }
-  async flush(collectionName) {
+  async multiQuerySearch(c, v, o) {
     this.ensureInitialized();
-    const collection = this.collections.get(collectionName);
-    if (!collection) {
-      throw new NotFoundError(`Collection '${collectionName}'`);
-    }
+    return wasmMultiQuerySearch(buildWasmContext(this.wasmModule, this.collections), c, v, o);
   }
-  async close() {
-    for (const [, data] of this.collections) {
-      data.store.free();
-    }
-    this.collections.clear();
-    this._initialized = false;
+  // ========================================================================
+  // Stubs -- delegates to wasm-stubs.ts & wasm-wave4-stubs.ts
+  // ========================================================================
+  async queryExplain(q, p, o) {
+    this.ensureInitialized();
+    return wasmQueryExplain(q, p, o);
   }
-  sparseVectorToArrays(sv) {
-    const indices = [];
-    const values = [];
-    for (const [k, v] of Object.entries(sv)) {
-      indices.push(Number(k));
-      values.push(v);
-    }
-    return { indices, values };
+  async collectionSanity(c) {
+    this.ensureInitialized();
+    return wasmCollectionSanity(c);
   }
-  toNumericId(id) {
-    if (typeof id === "number") {
-      return id;
-    }
-    const normalized = this.normalizeIdString(id);
-    if (normalized !== null) {
-      const parsed = Number(normalized);
-      if (Number.isSafeInteger(parsed)) {
-        return parsed;
-      }
-    }
-    let hash = 0;
-    for (let i = 0; i < id.length; i++) {
-      const char = id.charCodeAt(i);
-      hash = (hash << 5) - hash + char;
-      hash = hash & hash;
-    }
-    return Math.abs(hash);
+  async scroll(c, r) {
+    this.ensureInitialized();
+    return wasmScroll(c, r);
   }
-  // ========================================================================
-  // Index Management (EPIC-009) - Stubs for WASM backend
-  // Note: Full implementation requires velesdb-wasm support
-  // ========================================================================
-  async createIndex(_collection, _options) {
+  async createIndex(c, o) {
     this.ensureInitialized();
-    throw new Error(
-      "WasmBackend: createIndex is not yet supported. Index operations require the REST backend with velesdb-server."
-    );
+    return wasmCreateIndex(c, o);
   }
-  async listIndexes(_collection) {
+  async listIndexes(c) {
     this.ensureInitialized();
-    return [];
+    return wasmListIndexes(c);
   }
-  async hasIndex(_collection, _label, _property) {
+  async hasIndex(c, l, p) {
     this.ensureInitialized();
-    return false;
+    return wasmHasIndex(c, l, p);
   }
-  async dropIndex(_collection, _label, _property) {
+  async dropIndex(c, l, p) {
     this.ensureInitialized();
-    return false;
+    return wasmDropIndex(c, l, p);
   }
-  // ========================================================================
-  // Knowledge Graph (EPIC-016 US-041) - Stubs for WASM backend
-  // Note: Graph operations require server-side EdgeStore
-  // ========================================================================
-  async addEdge(_collection, _edge) {
+  async addEdge(c, e) {
     this.ensureInitialized();
-    wasmNotSupported("Knowledge Graph operations");
+    return wasmAddEdge(c, e);
   }
-  async getEdges(_collection, _options) {
+  async getEdges(c, o) {
     this.ensureInitialized();
-    wasmNotSupported("Knowledge Graph operations");
+    return wasmGetEdges(c, o);
   }
-  async traverseGraph(_collection, _request) {
+  async traverseGraph(c, r) {
     this.ensureInitialized();
-    wasmNotSupported("Graph traversal");
+    return wasmTraverseGraph(c, r);
   }
-  async getNodeDegree(_collection, _nodeId) {
+  async traverseParallel(c, r) {
     this.ensureInitialized();
-    wasmNotSupported("Graph degree query");
+    return wasmTraverseParallel(c, r);
   }
-  // ========================================================================
-  // Sparse / PQ / Streaming (v1.5)
-  // ========================================================================
-  async trainPq(_collection, _options) {
+  async getNodeDegree(c, n) {
     this.ensureInitialized();
-    wasmNotSupported("PQ training");
+    return wasmGetNodeDegree(c, n);
   }
-  async streamInsert(_collection, _docs) {
+  async trainPq(c, o) {
     this.ensureInitialized();
-    wasmNotSupported("Streaming insert");
+    return wasmTrainPq(c, o);
   }
-  // ========================================================================
-  // Graph Collection / Stats / Agent Memory (Phase 8) - WASM stubs
-  // ========================================================================
-  async createGraphCollection(_name, _config) {
+  async streamInsert(c, d) {
+    this.ensureInitialized();
+    return wasmStreamInsert(c, d);
+  }
+  async streamUpsertPoints(c, d) {
+    this.ensureInitialized();
+    return wasmStreamUpsertPoints(c, d);
+  }
+  async createGraphCollection(n, c) {
+    this.ensureInitialized();
+    return wasmCreateGraphCollection(n, c);
+  }
+  async getCollectionStats(c) {
+    this.ensureInitialized();
+    return wasmGetCollectionStats(c);
+  }
+  async analyzeCollection(c) {
+    this.ensureInitialized();
+    return wasmAnalyzeCollection(c);
+  }
+  async getCollectionConfig(c) {
+    this.ensureInitialized();
+    return wasmGetCollectionConfig(c);
+  }
+  async searchIds(c, q, o) {
+    this.ensureInitialized();
+    return wasmSearchIds(c, q, o);
+  }
+  async storeSemanticFact(c, e) {
     this.ensureInitialized();
-    wasmNotSupported("Graph collections");
+    return wasmStoreSemanticFact(c, e);
   }
-  async getCollectionStats(_collection) {
+  async searchSemanticMemory(c, e, k) {
     this.ensureInitialized();
-    wasmNotSupported("Collection stats");
+    return wasmSearchSemanticMemory(c, e, k);
   }
-  async analyzeCollection(_collection) {
+  async recordEpisodicEvent(c, e) {
     this.ensureInitialized();
-    wasmNotSupported("Collection analyze");
+    return wasmRecordEpisodicEvent(c, e);
   }
-  async getCollectionConfig(_collection) {
+  async recallEpisodicEvents(c, e, k) {
     this.ensureInitialized();
-    wasmNotSupported("Collection config");
+    return wasmRecallEpisodicEvents(c, e, k);
   }
-  async searchIds(_collection, _query, _options) {
+  async storeProceduralPattern(c, p) {
     this.ensureInitialized();
-    wasmNotSupported("searchIds");
+    return wasmStoreProceduralPattern(c, p);
   }
-  async storeSemanticFact(_collection, _entry) {
+  async matchProceduralPatterns(c, e, k) {
     this.ensureInitialized();
-    wasmNotSupported("Agent memory");
+    return wasmMatchProceduralPatterns(c, e, k);
   }
-  async searchSemanticMemory(_collection, _embedding, _k) {
+  // Wave 4 stubs
+  async rebuildIndex(c) {
     this.ensureInitialized();
-    wasmNotSupported("Agent memory");
+    return wasmRebuildIndex(c);
   }
-  async recordEpisodicEvent(_collection, _event) {
+  async getGuardrails() {
     this.ensureInitialized();
-    wasmNotSupported("Agent memory");
+    return wasmGetGuardrails();
   }
-  async recallEpisodicEvents(_collection, _embedding, _k) {
+  async updateGuardrails(r) {
     this.ensureInitialized();
-    wasmNotSupported("Agent memory");
+    return wasmUpdateGuardrails(r);
   }
-  async storeProceduralPattern(_collection, _pattern) {
+  async aggregate(_q, _p, _o) {
     this.ensureInitialized();
-    wasmNotSupported("Agent memory");
+    return wasmAggregate(_q, _p, _o);
   }
-  async matchProceduralPatterns(_collection, _embedding, _k) {
+  async matchQuery(c, q, p, o) {
     this.ensureInitialized();
-    wasmNotSupported("Agent memory");
+    return wasmMatchQuery(c, q, p, o);
+  }
+  async removeEdge(c, id) {
+    this.ensureInitialized();
+    return wasmRemoveEdge(c, id);
+  }
+  async getEdgeCount(c) {
+    this.ensureInitialized();
+    return wasmGetEdgeCount(c);
+  }
+  async listNodes(c) {
+    this.ensureInitialized();
+    return wasmListNodes(c);
+  }
+  async getNodeEdges(c, id, o) {
+    this.ensureInitialized();
+    return wasmGetNodeEdges(c, id, o);
+  }
+  async getNodePayload(c, id) {
+    this.ensureInitialized();
+    return wasmGetNodePayload(c, id);
+  }
+  async upsertNodePayload(c, id, p) {
+    this.ensureInitialized();
+    return wasmUpsertNodePayload(c, id, p);
+  }
+  async graphSearch(c, r) {
+    this.ensureInitialized();
+    return wasmGraphSearch(c, r);
   }
 };
 
+// src/backends/crud-backend.ts
+function parseRestPointId(id) {
+  if (typeof id !== "number" || !Number.isFinite(id) || id < 0 || !Number.isInteger(id) || id > Number.MAX_SAFE_INTEGER) {
+    throw new ValidationError(
+      `REST backend requires numeric u64-compatible IDs in JS safe integer range (0..${Number.MAX_SAFE_INTEGER}). Received: ${String(id)}`
+    );
+  }
+  return id;
+}
+function sparseVectorToRestFormat(sv) {
+  const result = {};
+  for (const [k, v] of Object.entries(sv)) {
+    result[String(k)] = v;
+  }
+  return result;
+}
+function toDeferredIndexingWire(opts) {
+  if (!opts) return void 0;
+  const wire = {};
+  if (opts.enabled !== void 0) wire.enabled = opts.enabled;
+  if (opts.mergeThreshold !== void 0) wire.merge_threshold = opts.mergeThreshold;
+  if (opts.maxBufferAgeMs !== void 0) wire.max_buffer_age_ms = opts.maxBufferAgeMs;
+  return wire;
+}
+function toAsyncIndexBuilderWire(opts) {
+  if (!opts) return void 0;
+  const wire = {};
+  if (opts.mergeThreshold !== void 0) wire.merge_threshold = opts.mergeThreshold;
+  if (opts.segmentCount !== void 0) wire.segment_count = opts.segmentCount;
+  return wire;
+}
+async function createCollection(transport, name, config) {
+  const body = {
+    name,
+    dimension: config.dimension,
+    metric: config.metric ?? "cosine",
+    storage_mode: config.storageMode ?? "full",
+    collection_type: config.collectionType ?? "vector",
+    description: config.description,
+    hnsw_m: config.hnsw?.m,
+    hnsw_ef_construction: config.hnsw?.efConstruction,
+    hnsw_alpha: config.hnsw?.alpha,
+    hnsw_max_elements: config.hnsw?.maxElements
+  };
+  if (config.pqRescoreOversampling !== void 0) {
+    body.pq_rescore_oversampling = config.pqRescoreOversampling;
+  }
+  const deferredWire = toDeferredIndexingWire(config.deferredIndexing);
+  if (deferredWire !== void 0) {
+    body.deferred_indexing = deferredWire;
+  }
+  const asyncWire = toAsyncIndexBuilderWire(config.asyncIndexBuilder);
+  if (asyncWire !== void 0) {
+    body.async_index_builder = asyncWire;
+  }
+  const response = await transport.requestJson("POST", "/collections", body);
+  throwOnError(response);
+}
+async function deleteCollection(transport, name) {
+  const response = await transport.requestJson(
+    "DELETE",
+    collectionPath(name)
+  );
+  throwOnError(response, `Collection '${name}'`);
+}
+async function getCollection(transport, name) {
+  const response = await transport.requestJson(
+    "GET",
+    collectionPath(name)
+  );
+  if (returnNullOnNotFound(response)) {
+    return null;
+  }
+  return response.data ?? null;
+}
+async function listCollections(transport) {
+  const response = await transport.requestJson("GET", "/collections");
+  throwOnError(response);
+  return response.data ?? [];
+}
+async function upsert(transport, collection, doc) {
+  const restId = parseRestPointId(doc.id);
+  const vector = toNumberArray(doc.vector);
+  const response = await transport.requestJson(
+    "POST",
+    `${collectionPath(collection)}/points`,
+    { points: [{ id: restId, vector, payload: doc.payload }] }
+  );
+  throwOnError(response, `Collection '${collection}'`);
+}
+async function upsertBatch(transport, collection, docs) {
+  const vectors = docs.map((doc) => ({
+    id: parseRestPointId(doc.id),
+    vector: toNumberArray(doc.vector),
+    payload: doc.payload
+  }));
+  const response = await transport.requestJson(
+    "POST",
+    `${collectionPath(collection)}/points`,
+    { points: vectors }
+  );
+  throwOnError(response, `Collection '${collection}'`);
+}
+async function deletePoint(transport, collection, id) {
+  const restId = parseRestPointId(id);
+  const response = await transport.requestJson(
+    "DELETE",
+    `${collectionPath(collection)}/points/${encodeURIComponent(String(restId))}`
+  );
+  if (returnNullOnNotFound(response)) {
+    return false;
+  }
+  return response.data?.deleted ?? false;
+}
+async function get(transport, collection, id) {
+  const restId = parseRestPointId(id);
+  const response = await transport.requestJson(
+    "GET",
+    `${collectionPath(collection)}/points/${encodeURIComponent(String(restId))}`
+  );
+  if (returnNullOnNotFound(response)) {
+    return null;
+  }
+  return response.data ?? null;
+}
+async function isEmpty(transport, collection) {
+  const response = await transport.requestJson(
+    "GET",
+    `${collectionPath(collection)}/empty`
+  );
+  throwOnError(response, `Collection '${collection}'`);
+  return response.data?.is_empty ?? true;
+}
+async function flush(transport, collection) {
+  const response = await transport.requestJson(
+    "POST",
+    `${collectionPath(collection)}/flush`
+  );
+  throwOnError(response, `Collection '${collection}'`);
+}
+
+// src/backends/rest-http.ts
+var STATUS_ERROR_CODES = {
+  400: "BAD_REQUEST",
+  401: "UNAUTHORIZED",
+  403: "FORBIDDEN",
+  404: "NOT_FOUND",
+  409: "CONFLICT",
+  429: "RATE_LIMITED",
+  500: "INTERNAL_ERROR",
+  503: "SERVICE_UNAVAILABLE"
+};
+function mapStatusToErrorCode(status) {
+  return STATUS_ERROR_CODES[status] ?? "UNKNOWN_ERROR";
+}
+function stringField(obj, ...keys) {
+  for (const key of keys) {
+    if (typeof obj[key] === "string") return obj[key];
+  }
+  return void 0;
+}
+function extractErrorPayload(data) {
+  if (!data || typeof data !== "object") return {};
+  const payload = data;
+  const nested = typeof payload.error === "object" && payload.error ? payload.error : payload;
+  return {
+    code: stringField(nested, "code") ?? stringField(payload, "code"),
+    message: stringField(nested, "message") ?? stringField(payload, "message", "error")
+  };
+}
+function parseNodeId(value) {
+  if (value === null || value === void 0) {
+    return 0;
+  }
+  if (typeof value === "bigint") {
+    return value;
+  }
+  if (typeof value === "string") {
+    const num = Number(value);
+    return num > Number.MAX_SAFE_INTEGER ? BigInt(value) : num;
+  }
+  if (typeof value === "number") {
+    return value;
+  }
+  return 0;
+}
+function buildHeaders(config) {
+  const headers = { "Content-Type": "application/json" };
+  if (config.apiKey) headers["Authorization"] = `Bearer ${config.apiKey}`;
+  return headers;
+}
+function wrapCatchError(error) {
+  if (error instanceof Error && error.name === "AbortError") {
+    throw new ConnectionError("Request timeout");
+  }
+  const message = error instanceof Error ? error.message : "Unknown error";
+  const cause = error instanceof Error ? error : void 0;
+  throw new ConnectionError(`Request failed: ${message}`, cause);
+}
+async function request(config, method, path, body) {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), config.timeout);
+  try {
+    const response = await fetch(`${config.baseUrl}${path}`, {
+      method,
+      headers: buildHeaders(config),
+      body: body ? JSON.stringify(body) : void 0,
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    const data = await response.json().catch(() => ({}));
+    if (!response.ok) {
+      const ep = extractErrorPayload(data);
+      return { error: {
+        code: ep.code ?? mapStatusToErrorCode(response.status),
+        message: ep.message ?? `HTTP ${response.status}`
+      } };
+    }
+    return { data };
+  } catch (error) {
+    clearTimeout(timeoutId);
+    wrapCatchError(error);
+  }
+}
+function buildBaseTransport(config) {
+  return {
+    requestJson: (m, p, b) => request(config, m, p, b)
+  };
+}
+function buildCrudTransport(config) {
+  return {
+    requestJson: (m, p, b) => request(config, m, p, b)
+  };
+}
+function buildSearchTransport(config) {
+  return {
+    requestJson: (m, p, b) => request(config, m, p, b),
+    sparseToRest: (sv) => sparseVectorToRestFormat(sv)
+  };
+}
+function buildQueryTransport(config) {
+  return {
+    requestJson: (m, p, b) => request(config, m, p, b),
+    parseNodeId: (v) => parseNodeId(v)
+  };
+}
+function buildStreamingTransport(config) {
+  return {
+    requestJson: (m, p, b) => request(config, m, p, b),
+    baseUrl: config.baseUrl,
+    apiKey: config.apiKey,
+    timeout: config.timeout,
+    parseRestPointId,
+    sparseVectorToRestFormat,
+    mapStatusToErrorCode: (s) => mapStatusToErrorCode(s),
+    extractErrorPayload: (d) => extractErrorPayload(d)
+  };
+}
+function buildAgentMemoryTransport(config, searchFn) {
+  return {
+    requestJson: (m, p, b) => request(config, m, p, b),
+    searchVectors: (c, e, k, f2) => searchFn(c, e, { k, filter: f2 })
+  };
+}
+
+// src/backends/missing-endpoints.ts
+async function rebuildIndex(transport, collection) {
+  const response = await transport.requestJson(
+    "POST",
+    `${collectionPath(collection)}/index/rebuild`
+  );
+  throwOnError(response, `Collection '${collection}'`);
+  const data = response.data;
+  return {
+    message: data.message,
+    collection: data.collection,
+    compactedEntries: data.compacted_entries
+  };
+}
+function mapGuardRailsWire(data) {
+  return {
+    maxDepth: data.max_depth,
+    maxCardinality: data.max_cardinality,
+    memoryLimitBytes: data.memory_limit_bytes,
+    timeoutMs: data.timeout_ms,
+    rateLimitQps: data.rate_limit_qps,
+    circuitFailureThreshold: data.circuit_failure_threshold,
+    circuitRecoverySeconds: data.circuit_recovery_seconds
+  };
+}
+function toGuardRailsWireUpdate(req) {
+  const wire = {};
+  if (req.maxDepth !== void 0) wire.max_depth = req.maxDepth;
+  if (req.maxCardinality !== void 0) wire.max_cardinality = req.maxCardinality;
+  if (req.memoryLimitBytes !== void 0) wire.memory_limit_bytes = req.memoryLimitBytes;
+  if (req.timeoutMs !== void 0) wire.timeout_ms = req.timeoutMs;
+  if (req.rateLimitQps !== void 0) wire.rate_limit_qps = req.rateLimitQps;
+  if (req.circuitFailureThreshold !== void 0) {
+    wire.circuit_failure_threshold = req.circuitFailureThreshold;
+  }
+  if (req.circuitRecoverySeconds !== void 0) {
+    wire.circuit_recovery_seconds = req.circuitRecoverySeconds;
+  }
+  return wire;
+}
+async function getGuardrails(transport) {
+  const response = await transport.requestJson("GET", "/guardrails");
+  throwOnError(response);
+  return mapGuardRailsWire(response.data);
+}
+async function updateGuardrails(transport, req) {
+  const response = await transport.requestJson(
+    "PUT",
+    "/guardrails",
+    toGuardRailsWireUpdate(req)
+  );
+  throwOnError(response);
+  return mapGuardRailsWire(response.data);
+}
+async function aggregate(transport, queryString, params, options) {
+  const body = {
+    query: queryString,
+    params: params ?? {}
+  };
+  if (options?.collection !== void 0) {
+    body.collection = options.collection;
+  }
+  const response = await transport.requestJson(
+    "POST",
+    "/aggregate",
+    body
+  );
+  throwOnError(response);
+  const data = response.data;
+  return {
+    result: data.result,
+    timingMs: data.timing_ms,
+    meta: {
+      velesqlContractVersion: data.meta.velesql_contract_version,
+      count: data.meta.count
+    }
+  };
+}
+async function matchQuery(transport, collection, queryString, params, options) {
+  const body = {
+    query: queryString,
+    params: params ?? {}
+  };
+  if (options?.vector !== void 0) {
+    body.vector = toNumberArray(options.vector);
+  }
+  if (options?.threshold !== void 0) {
+    body.threshold = options.threshold;
+  }
+  const response = await transport.requestJson(
+    "POST",
+    `${collectionPath(collection)}/match`,
+    body
+  );
+  throwOnError(response, `Collection '${collection}'`);
+  const data = response.data;
+  const items = data.results.map((r) => ({
+    bindings: r.bindings,
+    score: r.score,
+    depth: r.depth,
+    projected: r.projected ?? {}
+  }));
+  return {
+    results: items,
+    tookMs: data.took_ms,
+    count: data.count,
+    meta: { velesqlContractVersion: data.meta.velesql_contract_version }
+  };
+}
+async function removeEdge(transport, collection, edgeId) {
+  const response = await transport.requestJson(
+    "DELETE",
+    `${collectionPath(collection)}/graph/edges/${edgeId}`
+  );
+  if (response.error !== void 0) {
+    const { code, message } = response.error;
+    const err = parseVelesError(code, message);
+    if (err instanceof EdgeNotFoundError) {
+      return false;
+    }
+    if (code === "NOT_FOUND") {
+      return false;
+    }
+    throwOnError(response, `Collection '${collection}'`);
+  }
+  return true;
+}
+async function getEdgeCount(transport, collection) {
+  const response = await transport.requestJson(
+    "GET",
+    `${collectionPath(collection)}/graph/edges/count`
+  );
+  throwOnError(response, `Collection '${collection}'`);
+  return response.data?.count ?? 0;
+}
+async function listNodes(transport, collection) {
+  const response = await transport.requestJson(
+    "GET",
+    `${collectionPath(collection)}/graph/nodes`
+  );
+  throwOnError(response, `Collection '${collection}'`);
+  const data = response.data;
+  return { nodeIds: data.node_ids, count: data.count };
+}
+function idToNumber(id) {
+  return typeof id === "string" ? Number(id) : id;
+}
+async function getNodeEdges(transport, collection, nodeId, options) {
+  const params = new URLSearchParams();
+  if (options?.direction) params.set("direction", options.direction);
+  if (options?.label) params.set("label", options.label);
+  const qs = params.toString();
+  const url = `${collectionPath(collection)}/graph/nodes/${nodeId}/edges` + (qs ? `?${qs}` : "");
+  const response = await transport.requestJson("GET", url);
+  throwOnError(response, `Collection '${collection}'`);
+  return (response.data?.edges ?? []).map((e) => ({
+    id: idToNumber(e.id),
+    source: idToNumber(e.source),
+    target: idToNumber(e.target),
+    label: e.label,
+    properties: e.properties
+  }));
+}
+async function getNodePayload(transport, collection, nodeId) {
+  const response = await transport.requestJson("GET", `${collectionPath(collection)}/graph/nodes/${nodeId}/payload`);
+  throwOnError(response, `Collection '${collection}'`);
+  const data = response.data;
+  return {
+    nodeId: idToNumber(data.node_id),
+    payload: data.payload
+  };
+}
+async function upsertNodePayload(transport, collection, nodeId, payload) {
+  const response = await transport.requestJson(
+    "PUT",
+    `${collectionPath(collection)}/graph/nodes/${nodeId}/payload`,
+    { payload }
+  );
+  throwOnError(response, `Collection '${collection}'`);
+}
+async function graphSearch(transport, collection, request2) {
+  const response = await transport.requestJson(
+    "POST",
+    `${collectionPath(collection)}/graph/search`,
+    {
+      vector: toNumberArray(request2.vector),
+      top_k: request2.k ?? 10
+    }
+  );
+  throwOnError(response, `Collection '${collection}'`);
+  const items = (response.data?.results ?? []).map(
+    (r) => ({
+      id: idToNumber(r.id),
+      score: r.score,
+      payload: r.payload
+    })
+  );
+  return { results: items };
+}
+
 // src/backends/agent-memory-backend.ts
 var _idCounter = 0;
 var _lastTimestamp = 0;
 function generateUniqueId() {
-  let now = Date.now();
+  const now = Date.now();
   if (now <= _lastTimestamp) {
     _idCounter++;
     if (_idCounter >= 1e3) {
@@ -685,14 +1783,23 @@ async function matchProceduralPatterns(transport, collection, embedding, k = 5)
   return transport.searchVectors(collection, embedding, k, { _memory_type: "procedural" });
 }
 
+// src/search-quality.ts
+function searchQualityToMode(quality) {
+  if (quality === void 0) {
+    return {};
+  }
+  return { mode: quality };
+}
+
 // src/backends/search-backend.ts
-async function search(transport, collection, query2, options) {
-  const queryVector = toNumberArray(query2);
+async function search(transport, collection, query3, options) {
+  const queryVector = toNumberArray(query3);
   const body = {
     vector: queryVector,
     top_k: options?.k ?? 10,
     filter: options?.filter,
-    include_vectors: options?.includeVectors ?? false
+    include_vectors: options?.includeVectors ?? false,
+    ...searchQualityToMode(options?.quality)
   };
   if (options?.sparseVector) {
     body.sparse_vector = transport.sparseToRest(options.sparseVector);
@@ -709,7 +1816,8 @@ async function searchBatch(transport, collection, searches) {
   const formattedSearches = searches.map((s) => ({
     vector: toNumberArray(s.vector),
     top_k: s.k ?? 10,
-    filter: s.filter
+    filter: s.filter,
+    ...searchQualityToMode(s.quality)
   }));
   const response = await transport.requestJson(
     "POST",
@@ -719,12 +1827,12 @@ async function searchBatch(transport, collection, searches) {
   throwOnError(response, `Collection '${collection}'`);
   return response.data?.results.map((r) => r.results) ?? [];
 }
-async function textSearch(transport, collection, query2, options) {
+async function textSearch(transport, collection, query3, options) {
   const response = await transport.requestJson(
     "POST",
     `${collectionPath(collection)}/search/text`,
     {
-      query: query2,
+      query: query3,
       top_k: options?.k ?? 10,
       filter: options?.filter
     }
@@ -767,15 +1875,16 @@ async function multiQuerySearch(transport, collection, vectors, options) {
   throwOnError(response, `Collection '${collection}'`);
   return response.data?.results ?? [];
 }
-async function searchIds(transport, collection, query2, options) {
-  const queryVector = toNumberArray(query2);
+async function searchIds(transport, collection, query3, options) {
+  const queryVector = toNumberArray(query3);
   const response = await transport.requestJson(
     "POST",
     `${collectionPath(collection)}/search/ids`,
     {
       vector: queryVector,
       top_k: options?.k ?? 10,
-      filter: options?.filter
+      filter: options?.filter,
+      ...searchQualityToMode(options?.quality)
     }
   );
   throwOnError(response, `Collection '${collection}'`);
@@ -797,6 +1906,16 @@ async function addEdge(transport, collection, edge) {
   );
   throwOnError(response, `Collection '${collection}'`);
 }
+function toGraphEdge(e) {
+  const toNum = (v) => typeof v === "string" ? Number(v) : v;
+  return {
+    id: toNum(e.id),
+    source: toNum(e.source),
+    target: toNum(e.target),
+    label: e.label,
+    properties: e.properties
+  };
+}
 async function getEdges(transport, collection, options) {
   const queryParams = options?.label ? `?label=${encodeURIComponent(options.label)}` : "";
   const response = await transport.requestJson(
@@ -804,19 +1923,19 @@ async function getEdges(transport, collection, options) {
     `${collectionPath(collection)}/graph/edges${queryParams}`
   );
   throwOnError(response, `Collection '${collection}'`);
-  return response.data?.edges ?? [];
+  return (response.data?.edges ?? []).map(toGraphEdge);
 }
-async function traverseGraph(transport, collection, request) {
+async function traverseGraph(transport, collection, request2) {
   const response = await transport.requestJson(
     "POST",
     `${collectionPath(collection)}/graph/traverse`,
     {
-      source: request.source,
-      strategy: request.strategy ?? "bfs",
-      max_depth: request.maxDepth ?? 3,
-      limit: request.limit ?? 100,
-      cursor: request.cursor,
-      rel_types: request.relTypes ?? []
+      source: request2.source,
+      strategy: request2.strategy ?? "bfs",
+      max_depth: request2.maxDepth ?? 3,
+      limit: request2.limit ?? 100,
+      cursor: request2.cursor,
+      rel_types: request2.relTypes ?? []
     }
   );
   throwOnError(response, `Collection '${collection}'`);
@@ -856,6 +1975,33 @@ async function createGraphCollection(transport, name, config) {
   });
   throwOnError(response);
 }
+async function traverseParallel(transport, collection, request2) {
+  const response = await transport.requestJson(
+    "POST",
+    `${collectionPath(collection)}/graph/traverse/parallel`,
+    {
+      sources: request2.sources,
+      max_depth: request2.maxDepth ?? 3,
+      limit: request2.limit ?? 100,
+      rel_types: request2.relTypes ?? []
+    }
+  );
+  throwOnError(response, `Collection '${collection}'`);
+  const data = response.data;
+  return {
+    results: data.results.map((r) => ({
+      targetId: r.target_id,
+      depth: r.depth,
+      path: r.path
+    })),
+    nextCursor: data.next_cursor ?? void 0,
+    hasMore: data.has_more,
+    stats: {
+      visited: data.stats.visited,
+      depthReached: data.stats.depth_reached
+    }
+  };
+}
 
 // src/backends/query-backend.ts
 function isLikelyAggregationQuery(queryString) {
@@ -900,14 +2046,18 @@ async function query(transport, collection, queryString, params, options) {
     }
   };
 }
-async function queryExplain(transport, queryString, params) {
+async function queryExplain(transport, queryString, params, options) {
+  const body = {
+    query: queryString,
+    params: params ?? {}
+  };
+  if (options?.analyze) {
+    body.analyze = true;
+  }
   const response = await transport.requestJson(
     "POST",
     "/query/explain",
-    {
-      query: queryString,
-      params: params ?? {}
-    }
+    body
   );
   throwOnError(response);
   const data = response.data;
@@ -919,7 +2069,8 @@ async function queryExplain(transport, queryString, params) {
       step: step.step,
       operation: step.operation,
       description: step.description,
-      estimatedRows: step.estimated_rows
+      estimatedRows: step.estimated_rows,
+      estimationMethod: step.estimation_method ?? null
     })),
     estimatedCost: {
       usesIndex: data.estimated_cost.uses_index,
@@ -937,7 +2088,22 @@ async function queryExplain(transport, queryString, params) {
       hasFusion: data.features.has_fusion,
       limit: data.features.limit,
       offset: data.features.offset
-    }
+    },
+    actualStats: data.actual_stats ? {
+      actualRows: data.actual_stats.actual_rows,
+      actualTimeMs: data.actual_stats.actual_time_ms,
+      loops: data.actual_stats.loops,
+      nodesVisited: data.actual_stats.nodes_visited,
+      edgesTraversed: data.actual_stats.edges_traversed
+    } : data.actual_stats === null ? null : void 0,
+    nodeStats: data.node_stats ? data.node_stats.map((ns) => ({
+      nodeLabel: ns.node_label,
+      actualTimeMs: ns.actual_time_ms,
+      actualRowsIn: ns.actual_rows_in,
+      actualRowsOut: ns.actual_rows_out,
+      loops: ns.loops,
+      estimated: ns.estimated
+    })) : data.node_stats === null ? null : void 0
   };
 }
 async function collectionSanity(transport, collection) {
@@ -968,8 +2134,49 @@ async function collectionSanity(transport, collection) {
   };
 }
 
+// src/backends/scroll-backend.ts
+async function scroll(transport, collection, request2) {
+  const body = {};
+  if (request2?.cursor !== void 0) {
+    body.cursor = request2.cursor;
+  }
+  if (request2?.batchSize !== void 0) {
+    body.batch_size = request2.batchSize;
+  }
+  if (request2?.filter !== void 0) {
+    body.filter = request2.filter;
+  }
+  const response = await transport.requestJson(
+    "POST",
+    `${collectionPath(collection)}/points/scroll`,
+    body
+  );
+  throwOnError(response, `Collection '${collection}'`);
+  const data = response.data;
+  return {
+    points: data.points,
+    nextCursor: data.next_cursor
+  };
+}
+
 // src/backends/admin-backend.ts
 function mapStatsResponse(data) {
+  let columnStats;
+  if (data.column_stats) {
+    columnStats = {};
+    for (const [key, col] of Object.entries(data.column_stats)) {
+      columnStats[key] = {
+        name: col.name,
+        nullCount: col.null_count,
+        distinctCount: col.distinct_count,
+        minValue: col.min_value,
+        maxValue: col.max_value,
+        avgSizeBytes: col.avg_size_bytes,
+        histogramBuckets: col.histogram_buckets,
+        histogramStale: col.histogram_stale
+      };
+    }
+  }
   return {
     totalPoints: data.total_points,
     totalSizeBytes: data.total_size_bytes,
@@ -977,7 +2184,8 @@ function mapStatsResponse(data) {
     deletedCount: data.deleted_count,
     avgRowSizeBytes: data.avg_row_size_bytes,
     payloadSizeBytes: data.payload_size_bytes,
-    lastAnalyzedEpochMs: data.last_analyzed_epoch_ms
+    lastAnalyzedEpochMs: data.last_analyzed_epoch_ms,
+    columnStats
   };
 }
 async function getCollectionStats(transport, collection) {
@@ -998,10 +2206,7 @@ async function analyzeCollection(transport, collection) {
   throwOnError(response, `Collection '${collection}'`);
   return mapStatsResponse(response.data);
 }
-async function getCollectionConfig(transport, collection) {
-  const response = await transport.requestJson("GET", `${collectionPath(collection)}/config`);
-  throwOnError(response, `Collection '${collection}'`);
-  const data = response.data;
+function mapConfigResponse(data) {
   return {
     name: data.name,
     dimension: data.dimension,
@@ -1010,9 +2215,22 @@ async function getCollectionConfig(transport, collection) {
     pointCount: data.point_count,
     metadataOnly: data.metadata_only,
     graphSchema: data.graph_schema,
-    embeddingDimension: data.embedding_dimension
+    embeddingDimension: data.embedding_dimension,
+    schemaVersion: data.schema_version,
+    pqRescoreOversampling: data.pq_rescore_oversampling,
+    hnswParams: data.hnsw_params,
+    deferredIndexing: data.deferred_indexing,
+    asyncIndexBuilder: data.async_index_builder
   };
 }
+async function getCollectionConfig(transport, collection) {
+  const response = await transport.requestJson(
+    "GET",
+    `${collectionPath(collection)}/config`
+  );
+  throwOnError(response, `Collection '${collection}'`);
+  return mapConfigResponse(response.data);
+}
 
 // src/backends/index-backend.ts
 async function createIndex(transport, collection, options) {
@@ -1047,218 +2265,170 @@ async function hasIndex(transport, collection, label, property) {
 }
 async function dropIndex(transport, collection, label, property) {
   const response = await transport.requestJson(
-    "DELETE",
-    `${collectionPath(collection)}/indexes/${encodeURIComponent(label)}/${encodeURIComponent(property)}`
-  );
-  if (returnNullOnNotFound(response)) {
-    return false;
-  }
-  return response.data?.dropped ?? true;
-}
-
-// src/backends/streaming-backend.ts
-async function trainPq(transport, collection, options) {
-  const m = options?.m ?? 8;
-  const k = options?.k ?? 256;
-  const withClause = options?.opq ? `WITH (m=${m}, k=${k}, opq=true)` : `WITH (m=${m}, k=${k})`;
-  const queryString = `TRAIN QUANTIZER ON ${collection} ${withClause}`;
-  const response = await transport.requestJson(
-    "POST",
-    "/query",
-    { query: queryString }
-  );
-  throwOnError(response);
-  return response.data?.message ?? "PQ training initiated";
-}
-async function streamInsert(transport, collection, docs) {
-  for (const doc of docs) {
-    const restId = transport.parseRestPointId(doc.id);
-    const vector = toNumberArray(doc.vector);
-    const body = {
-      id: restId,
-      vector,
-      payload: doc.payload
-    };
-    if (doc.sparseVector) {
-      body.sparse_vector = transport.sparseVectorToRestFormat(doc.sparseVector);
-    }
-    const url = `${transport.baseUrl}${collectionPath(collection)}/stream/insert`;
-    const headers = {
-      "Content-Type": "application/json"
-    };
-    if (transport.apiKey) {
-      headers["Authorization"] = `Bearer ${transport.apiKey}`;
-    }
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), transport.timeout);
-    try {
-      const response = await fetch(url, {
-        method: "POST",
-        headers,
-        body: JSON.stringify(body),
-        signal: controller.signal
-      });
-      clearTimeout(timeoutId);
-      if (response.status === 429) {
-        throw new BackpressureError();
-      }
-      if (!response.ok && response.status !== 202) {
-        const data = await response.json().catch(() => ({}));
-        const errorPayload = transport.extractErrorPayload(data);
-        throw new VelesDBError(
-          errorPayload.message ?? `HTTP ${response.status}`,
-          errorPayload.code ?? transport.mapStatusToErrorCode(response.status)
-        );
-      }
-    } catch (error) {
-      clearTimeout(timeoutId);
-      if (error instanceof BackpressureError || error instanceof VelesDBError) {
-        throw error;
-      }
-      if (error instanceof Error && error.name === "AbortError") {
-        throw new ConnectionError("Request timeout");
-      }
-      throw new ConnectionError(
-        `Stream insert failed: ${error instanceof Error ? error.message : "Unknown error"}`,
-        error instanceof Error ? error : void 0
-      );
-    }
-  }
-}
-
-// src/backends/crud-backend.ts
-function parseRestPointId(id) {
-  if (typeof id !== "number" || !Number.isFinite(id) || id < 0 || !Number.isInteger(id) || id > Number.MAX_SAFE_INTEGER) {
-    throw new ValidationError(
-      `REST backend requires numeric u64-compatible IDs in JS safe integer range (0..${Number.MAX_SAFE_INTEGER}). Received: ${String(id)}`
-    );
-  }
-  return id;
-}
-function sparseVectorToRestFormat(sv) {
-  const result = {};
-  for (const [k, v] of Object.entries(sv)) {
-    result[String(k)] = v;
-  }
-  return result;
-}
-async function createCollection(transport, name, config) {
-  const response = await transport.requestJson("POST", "/collections", {
-    name,
-    dimension: config.dimension,
-    metric: config.metric ?? "cosine",
-    storage_mode: config.storageMode ?? "full",
-    collection_type: config.collectionType ?? "vector",
-    description: config.description,
-    hnsw_m: config.hnsw?.m,
-    hnsw_ef_construction: config.hnsw?.efConstruction
-  });
-  throwOnError(response);
-}
-async function deleteCollection(transport, name) {
-  const response = await transport.requestJson(
-    "DELETE",
-    collectionPath(name)
-  );
-  throwOnError(response, `Collection '${name}'`);
-}
-async function getCollection(transport, name) {
-  const response = await transport.requestJson(
-    "GET",
-    collectionPath(name)
-  );
-  if (returnNullOnNotFound(response)) {
-    return null;
-  }
-  return response.data ?? null;
-}
-async function listCollections(transport) {
-  const response = await transport.requestJson("GET", "/collections");
-  throwOnError(response);
-  return response.data ?? [];
-}
-async function insert(transport, collection, doc) {
-  const restId = parseRestPointId(doc.id);
-  const vector = toNumberArray(doc.vector);
-  const response = await transport.requestJson(
-    "POST",
-    `${collectionPath(collection)}/points`,
-    { points: [{ id: restId, vector, payload: doc.payload }] }
-  );
-  throwOnError(response, `Collection '${collection}'`);
-}
-async function insertBatch(transport, collection, docs) {
-  const vectors = docs.map((doc) => ({
-    id: parseRestPointId(doc.id),
-    vector: toNumberArray(doc.vector),
-    payload: doc.payload
-  }));
-  const response = await transport.requestJson(
-    "POST",
-    `${collectionPath(collection)}/points`,
-    { points: vectors }
-  );
-  throwOnError(response, `Collection '${collection}'`);
-}
-async function deletePoint(transport, collection, id) {
-  const restId = parseRestPointId(id);
-  const response = await transport.requestJson(
-    "DELETE",
-    `${collectionPath(collection)}/points/${encodeURIComponent(String(restId))}`
-  );
-  if (returnNullOnNotFound(response)) {
-    return false;
-  }
-  return response.data?.deleted ?? false;
-}
-async function get(transport, collection, id) {
-  const restId = parseRestPointId(id);
-  const response = await transport.requestJson(
-    "GET",
-    `${collectionPath(collection)}/points/${encodeURIComponent(String(restId))}`
+    "DELETE",
+    `${collectionPath(collection)}/indexes/${encodeURIComponent(label)}/${encodeURIComponent(property)}`
   );
   if (returnNullOnNotFound(response)) {
-    return null;
+    return false;
   }
-  return response.data ?? null;
-}
-async function isEmpty(transport, collection) {
-  const response = await transport.requestJson(
-    "GET",
-    `${collectionPath(collection)}/empty`
-  );
-  throwOnError(response, `Collection '${collection}'`);
-  return response.data?.is_empty ?? true;
+  return response.data?.dropped ?? true;
 }
-async function flush(transport, collection) {
+
+// src/backends/streaming-backend.ts
+async function trainPq(transport, collection, options) {
+  validateCollectionName(collection);
+  const m = options?.m ?? 8;
+  const k = options?.k ?? 256;
+  const withClause = options?.opq ? `WITH (m=${m}, k=${k}, opq=true)` : `WITH (m=${m}, k=${k})`;
+  const queryString = `TRAIN QUANTIZER ON ${collection} ${withClause}`;
   const response = await transport.requestJson(
     "POST",
-    `${collectionPath(collection)}/flush`
+    "/query",
+    { query: queryString }
   );
-  throwOnError(response, `Collection '${collection}'`);
+  throwOnError(response);
+  return response.data?.message ?? "PQ training initiated";
+}
+async function streamInsert(transport, collection, docs) {
+  for (const doc of docs) {
+    const restId = transport.parseRestPointId(doc.id);
+    const vector = toNumberArray(doc.vector);
+    const body = {
+      id: restId,
+      vector,
+      payload: doc.payload ?? null
+    };
+    if (doc.sparseVector) {
+      body.sparse_vector = transport.sparseVectorToRestFormat(doc.sparseVector);
+    }
+    const url = `${transport.baseUrl}${collectionPath(collection)}/stream/insert`;
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (transport.apiKey) {
+      headers["Authorization"] = `Bearer ${transport.apiKey}`;
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), transport.timeout);
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(body),
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (response.status === 429) {
+        throw new BackpressureError();
+      }
+      if (!response.ok && response.status !== 202) {
+        const data = await response.json().catch(() => ({}));
+        const errorPayload = transport.extractErrorPayload(data);
+        throw new VelesDBError(
+          errorPayload.message ?? `HTTP ${response.status}`,
+          errorPayload.code ?? transport.mapStatusToErrorCode(response.status)
+        );
+      }
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof BackpressureError || error instanceof VelesDBError) {
+        throw error;
+      }
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new ConnectionError("Request timeout");
+      }
+      throw new ConnectionError(
+        `Stream insert failed: ${error instanceof Error ? error.message : "Unknown error"}`,
+        error instanceof Error ? error : void 0
+      );
+    }
+  }
+}
+async function streamUpsertPoints(transport, collection, docs) {
+  const ndjsonLines = docs.map((doc) => {
+    const restId = transport.parseRestPointId(doc.id);
+    const vector = toNumberArray(doc.vector);
+    const point = {
+      id: restId,
+      vector,
+      payload: doc.payload ?? null
+    };
+    if (doc.sparseVector) {
+      point.sparse_vector = transport.sparseVectorToRestFormat(doc.sparseVector);
+    }
+    return JSON.stringify(point);
+  });
+  const body = ndjsonLines.join("\n");
+  const url = `${transport.baseUrl}${collectionPath(collection)}/points/stream`;
+  const headers = {
+    "Content-Type": "application/x-ndjson"
+  };
+  if (transport.apiKey) {
+    headers["Authorization"] = `Bearer ${transport.apiKey}`;
+  }
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), transport.timeout);
+  try {
+    const response = await fetch(url, {
+      method: "POST",
+      headers,
+      body,
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    if (response.status === 429) {
+      throw new BackpressureError();
+    }
+    if (!response.ok) {
+      const data2 = await response.json().catch(() => ({}));
+      const errorPayload = transport.extractErrorPayload(data2);
+      throw new VelesDBError(
+        errorPayload.message ?? `HTTP ${response.status}`,
+        errorPayload.code ?? transport.mapStatusToErrorCode(response.status)
+      );
+    }
+    const data = await response.json().catch(() => ({}));
+    return {
+      message: typeof data.message === "string" ? data.message : "Stream processed",
+      inserted: typeof data.inserted === "number" ? data.inserted : 0,
+      malformed: typeof data.malformed === "number" ? data.malformed : 0,
+      failedUpserts: typeof data.failed_upserts === "number" ? data.failed_upserts : 0,
+      networkErrors: typeof data.network_errors === "number" ? data.network_errors : 0
+    };
+  } catch (error) {
+    clearTimeout(timeoutId);
+    if (error instanceof BackpressureError || error instanceof VelesDBError) {
+      throw error;
+    }
+    if (error instanceof Error && error.name === "AbortError") {
+      throw new ConnectionError("Request timeout");
+    }
+    throw new ConnectionError(
+      `Stream upsert failed: ${error instanceof Error ? error.message : "Unknown error"}`,
+      error instanceof Error ? error : void 0
+    );
+  }
 }
 
 // src/backends/rest.ts
 var RestBackend = class {
   constructor(url, apiKey, timeout = 3e4) {
     this._initialized = false;
-    this.baseUrl = url.replace(/\/$/, "");
-    this.apiKey = apiKey;
-    this.timeout = timeout;
+    this.httpConfig = { baseUrl: url.replace(/\/$/, ""), apiKey, timeout };
   }
   async init() {
     if (this._initialized) {
       return;
     }
     try {
-      const response = await this.request("GET", "/health");
+      const response = await request(this.httpConfig, "GET", "/health");
       if (response.error) {
         throw new Error(response.error.message);
       }
       this._initialized = true;
     } catch (error) {
       throw new ConnectionError(
-        `Failed to connect to VelesDB server at ${this.baseUrl}`,
+        `Failed to connect to VelesDB server at ${this.httpConfig.baseUrl}`,
         error instanceof Error ? error : void 0
       );
     }
@@ -1266,316 +2436,242 @@ var RestBackend = class {
   isInitialized() {
     return this._initialized;
   }
+  capabilities() {
+    return REST_CAPABILITIES;
+  }
+  async close() {
+    this._initialized = false;
+  }
   ensureInitialized() {
     if (!this._initialized) {
       throw new ConnectionError("REST backend not initialized");
     }
   }
-  mapStatusToErrorCode(status) {
-    switch (status) {
-      case 400:
-        return "BAD_REQUEST";
-      case 401:
-        return "UNAUTHORIZED";
-      case 403:
-        return "FORBIDDEN";
-      case 404:
-        return "NOT_FOUND";
-      case 409:
-        return "CONFLICT";
-      case 429:
-        return "RATE_LIMITED";
-      case 500:
-        return "INTERNAL_ERROR";
-      case 503:
-        return "SERVICE_UNAVAILABLE";
-      default:
-        return "UNKNOWN_ERROR";
-    }
+  // Collection CRUD
+  async createCollection(n, c) {
+    this.ensureInitialized();
+    return createCollection(buildCrudTransport(this.httpConfig), n, c);
   }
-  extractErrorPayload(data) {
-    if (!data || typeof data !== "object") {
-      return {};
-    }
-    const payload = data;
-    const nestedError = payload.error && typeof payload.error === "object" ? payload.error : void 0;
-    const codeField = nestedError?.code ?? payload.code;
-    const code = typeof codeField === "string" ? codeField : void 0;
-    const messageField = nestedError?.message ?? payload.message ?? payload.error;
-    const message = typeof messageField === "string" ? messageField : void 0;
-    return { code, message };
+  async deleteCollection(n) {
+    this.ensureInitialized();
+    return deleteCollection(buildCrudTransport(this.httpConfig), n);
   }
-  parseNodeId(value) {
-    if (value === null || value === void 0) {
-      return 0;
-    }
-    if (typeof value === "bigint") {
-      return value;
-    }
-    if (typeof value === "string") {
-      const num = Number(value);
-      return num > Number.MAX_SAFE_INTEGER ? BigInt(value) : num;
-    }
-    if (typeof value === "number") {
-      return value;
-    }
-    return 0;
+  async getCollection(n) {
+    this.ensureInitialized();
+    return getCollection(buildCrudTransport(this.httpConfig), n);
   }
-  async request(method, path, body) {
-    const url = `${this.baseUrl}${path}`;
-    const headers = { "Content-Type": "application/json" };
-    if (this.apiKey) {
-      headers["Authorization"] = `Bearer ${this.apiKey}`;
-    }
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
-    try {
-      const response = await fetch(url, {
-        method,
-        headers,
-        body: body ? JSON.stringify(body) : void 0,
-        signal: controller.signal
-      });
-      clearTimeout(timeoutId);
-      const data = await response.json().catch(() => ({}));
-      if (!response.ok) {
-        const errorPayload = this.extractErrorPayload(data);
-        return {
-          error: {
-            code: errorPayload.code ?? this.mapStatusToErrorCode(response.status),
-            message: errorPayload.message ?? `HTTP ${response.status}`
-          }
-        };
-      }
-      return { data };
-    } catch (error) {
-      clearTimeout(timeoutId);
-      if (error instanceof Error && error.name === "AbortError") {
-        throw new ConnectionError("Request timeout");
-      }
-      throw new ConnectionError(
-        `Request failed: ${error instanceof Error ? error.message : "Unknown error"}`,
-        error instanceof Error ? error : void 0
-      );
-    }
+  async listCollections() {
+    this.ensureInitialized();
+    return listCollections(buildCrudTransport(this.httpConfig));
   }
-  // ==========================================================================
-  // Transport adapters
-  // ==========================================================================
-  asCrudTransport() {
-    return {
-      requestJson: (m, p, b) => this.request(m, p, b)
-    };
+  async upsert(c, d) {
+    this.ensureInitialized();
+    return upsert(buildCrudTransport(this.httpConfig), c, d);
   }
-  asSearchTransport() {
-    return {
-      requestJson: (m, p, b) => this.request(m, p, b),
-      sparseToRest: (sv) => sparseVectorToRestFormat(sv)
-    };
+  async upsertBatch(c, d) {
+    this.ensureInitialized();
+    return upsertBatch(buildCrudTransport(this.httpConfig), c, d);
   }
-  asAgentMemoryTransport() {
-    return {
-      requestJson: (m, p, b) => this.request(m, p, b),
-      searchVectors: (c, e, k, f) => this.search(c, e, { k, filter: f })
-    };
+  async delete(c, id) {
+    this.ensureInitialized();
+    return deletePoint(buildCrudTransport(this.httpConfig), c, id);
   }
-  asQueryTransport() {
-    return {
-      requestJson: (m, p, b) => this.request(m, p, b),
-      parseNodeId: (v) => this.parseNodeId(v)
-    };
+  async get(c, id) {
+    this.ensureInitialized();
+    return get(buildCrudTransport(this.httpConfig), c, id);
   }
-  asStreamingTransport() {
-    return {
-      requestJson: (m, p, b) => this.request(m, p, b),
-      baseUrl: this.baseUrl,
-      apiKey: this.apiKey,
-      timeout: this.timeout,
-      parseRestPointId,
-      sparseVectorToRestFormat,
-      mapStatusToErrorCode: (s) => this.mapStatusToErrorCode(s),
-      extractErrorPayload: (d) => this.extractErrorPayload(d)
-    };
+  async isEmpty(c) {
+    this.ensureInitialized();
+    return isEmpty(buildCrudTransport(this.httpConfig), c);
   }
-  // ==========================================================================
-  // Collection CRUD — delegates to crud-backend.ts
-  // ==========================================================================
-  async createCollection(name, config) {
+  async flush(c) {
     this.ensureInitialized();
-    return createCollection(this.asCrudTransport(), name, config);
+    return flush(buildCrudTransport(this.httpConfig), c);
   }
-  async deleteCollection(name) {
+  // Additional REST endpoints (Sprint 2 Wave 4)
+  async rebuildIndex(c) {
     this.ensureInitialized();
-    return deleteCollection(this.asCrudTransport(), name);
+    return rebuildIndex(buildBaseTransport(this.httpConfig), c);
   }
-  async getCollection(name) {
+  async getGuardrails() {
     this.ensureInitialized();
-    return getCollection(this.asCrudTransport(), name);
+    return getGuardrails(buildBaseTransport(this.httpConfig));
   }
-  async listCollections() {
+  async updateGuardrails(r) {
     this.ensureInitialized();
-    return listCollections(this.asCrudTransport());
+    return updateGuardrails(buildBaseTransport(this.httpConfig), r);
   }
-  async insert(collection, doc) {
+  async aggregate(q, p, o) {
     this.ensureInitialized();
-    return insert(this.asCrudTransport(), collection, doc);
+    return aggregate(buildBaseTransport(this.httpConfig), q, p, o);
   }
-  async insertBatch(collection, docs) {
+  async matchQuery(c, q, p, o) {
     this.ensureInitialized();
-    return insertBatch(this.asCrudTransport(), collection, docs);
+    return matchQuery(buildBaseTransport(this.httpConfig), c, q, p, o);
   }
-  async delete(collection, id) {
+  async removeEdge(c, id) {
     this.ensureInitialized();
-    return deletePoint(this.asCrudTransport(), collection, id);
+    return removeEdge(buildBaseTransport(this.httpConfig), c, id);
   }
-  async get(collection, id) {
+  async getEdgeCount(c) {
     this.ensureInitialized();
-    return get(this.asCrudTransport(), collection, id);
+    return getEdgeCount(buildBaseTransport(this.httpConfig), c);
   }
-  async isEmpty(collection) {
+  async listNodes(c) {
     this.ensureInitialized();
-    return isEmpty(this.asCrudTransport(), collection);
+    return listNodes(buildBaseTransport(this.httpConfig), c);
   }
-  async flush(collection) {
+  async getNodeEdges(c, id, o) {
     this.ensureInitialized();
-    return flush(this.asCrudTransport(), collection);
+    return getNodeEdges(buildBaseTransport(this.httpConfig), c, id, o);
   }
-  async close() {
-    this._initialized = false;
+  async getNodePayload(c, id) {
+    this.ensureInitialized();
+    return getNodePayload(buildBaseTransport(this.httpConfig), c, id);
+  }
+  async upsertNodePayload(c, id, p) {
+    this.ensureInitialized();
+    return upsertNodePayload(buildBaseTransport(this.httpConfig), c, id, p);
   }
-  // ==========================================================================
-  // Search — delegates to search-backend.ts
-  // ==========================================================================
+  async graphSearch(c, r) {
+    this.ensureInitialized();
+    return graphSearch(buildBaseTransport(this.httpConfig), c, r);
+  }
+  // Search
   async search(c, q, o) {
     this.ensureInitialized();
-    return search(this.asSearchTransport(), c, q, o);
+    return search(buildSearchTransport(this.httpConfig), c, q, o);
   }
-  async searchBatch(collection, searches) {
+  async searchBatch(c, s) {
     this.ensureInitialized();
-    return searchBatch(this.asSearchTransport(), collection, searches);
+    return searchBatch(buildSearchTransport(this.httpConfig), c, s);
   }
   async textSearch(c, q, o) {
     this.ensureInitialized();
-    return textSearch(this.asSearchTransport(), c, q, o);
+    return textSearch(buildSearchTransport(this.httpConfig), c, q, o);
   }
   async hybridSearch(c, v, t, o) {
     this.ensureInitialized();
-    return hybridSearch(this.asSearchTransport(), c, v, t, o);
+    return hybridSearch(buildSearchTransport(this.httpConfig), c, v, t, o);
   }
   async multiQuerySearch(c, v, o) {
     this.ensureInitialized();
-    return multiQuerySearch(this.asSearchTransport(), c, v, o);
+    return multiQuerySearch(buildSearchTransport(this.httpConfig), c, v, o);
   }
   async searchIds(c, q, o) {
     this.ensureInitialized();
-    return searchIds(this.asSearchTransport(), c, q, o);
+    return searchIds(buildSearchTransport(this.httpConfig), c, q, o);
   }
-  // ==========================================================================
-  // Query — delegates to query-backend.ts
-  // ==========================================================================
+  // Query
   async query(c, q, p, o) {
     this.ensureInitialized();
-    return query(this.asQueryTransport(), c, q, p, o);
+    return query(buildQueryTransport(this.httpConfig), c, q, p, o);
   }
-  async queryExplain(q, p) {
+  async queryExplain(q, p, o) {
     this.ensureInitialized();
-    return queryExplain(this.asQueryTransport(), q, p);
+    return queryExplain(buildQueryTransport(this.httpConfig), q, p, o);
   }
-  async collectionSanity(collection) {
+  async collectionSanity(c) {
     this.ensureInitialized();
-    return collectionSanity(this.asQueryTransport(), collection);
+    return collectionSanity(buildQueryTransport(this.httpConfig), c);
   }
-  // ==========================================================================
-  // Graph — delegates to graph-backend.ts
-  // ==========================================================================
-  async addEdge(collection, edge) {
+  // Scroll
+  async scroll(c, r) {
     this.ensureInitialized();
-    return addEdge(this.asCrudTransport(), collection, edge);
+    return scroll(buildCrudTransport(this.httpConfig), c, r);
   }
-  async getEdges(collection, options) {
+  // Graph
+  async addEdge(c, e) {
     this.ensureInitialized();
-    return getEdges(this.asCrudTransport(), collection, options);
+    return addEdge(buildCrudTransport(this.httpConfig), c, e);
   }
-  async traverseGraph(collection, req) {
+  async getEdges(c, o) {
     this.ensureInitialized();
-    return traverseGraph(this.asCrudTransport(), collection, req);
+    return getEdges(buildCrudTransport(this.httpConfig), c, o);
   }
-  async getNodeDegree(collection, nodeId) {
+  async traverseGraph(c, r) {
     this.ensureInitialized();
-    return getNodeDegree(this.asCrudTransport(), collection, nodeId);
+    return traverseGraph(buildCrudTransport(this.httpConfig), c, r);
   }
-  async createGraphCollection(name, config) {
+  async traverseParallel(c, r) {
     this.ensureInitialized();
-    return createGraphCollection(this.asCrudTransport(), name, config);
+    return traverseParallel(buildCrudTransport(this.httpConfig), c, r);
   }
-  // ==========================================================================
-  // Index — delegates to index-backend.ts
-  // ==========================================================================
-  async createIndex(collection, options) {
+  async getNodeDegree(c, id) {
     this.ensureInitialized();
-    return createIndex(this.asCrudTransport(), collection, options);
+    return getNodeDegree(buildCrudTransport(this.httpConfig), c, id);
   }
-  async listIndexes(collection) {
+  async createGraphCollection(n, c) {
     this.ensureInitialized();
-    return listIndexes(this.asCrudTransport(), collection);
+    return createGraphCollection(buildCrudTransport(this.httpConfig), n, c);
   }
-  async hasIndex(collection, label, property) {
+  // Index
+  async createIndex(c, o) {
     this.ensureInitialized();
-    return hasIndex(this.asCrudTransport(), collection, label, property);
+    return createIndex(buildCrudTransport(this.httpConfig), c, o);
   }
-  async dropIndex(collection, label, property) {
+  async listIndexes(c) {
     this.ensureInitialized();
-    return dropIndex(this.asCrudTransport(), collection, label, property);
+    return listIndexes(buildCrudTransport(this.httpConfig), c);
   }
-  // ==========================================================================
-  // Admin — delegates to admin-backend.ts
-  // ==========================================================================
-  async getCollectionStats(collection) {
+  async hasIndex(c, l, p) {
     this.ensureInitialized();
-    return getCollectionStats(this.asCrudTransport(), collection);
+    return hasIndex(buildCrudTransport(this.httpConfig), c, l, p);
   }
-  async analyzeCollection(collection) {
+  async dropIndex(c, l, p) {
     this.ensureInitialized();
-    return analyzeCollection(this.asCrudTransport(), collection);
+    return dropIndex(buildCrudTransport(this.httpConfig), c, l, p);
   }
-  async getCollectionConfig(collection) {
+  // Admin
+  async getCollectionStats(c) {
     this.ensureInitialized();
-    return getCollectionConfig(this.asCrudTransport(), collection);
+    return getCollectionStats(buildCrudTransport(this.httpConfig), c);
   }
-  // ==========================================================================
-  // Streaming / PQ — delegates to streaming-backend.ts
-  // ==========================================================================
-  async trainPq(collection, options) {
+  async analyzeCollection(c) {
     this.ensureInitialized();
-    return trainPq(this.asStreamingTransport(), collection, options);
+    return analyzeCollection(buildCrudTransport(this.httpConfig), c);
   }
-  async streamInsert(collection, docs) {
+  async getCollectionConfig(c) {
+    this.ensureInitialized();
+    return getCollectionConfig(buildCrudTransport(this.httpConfig), c);
+  }
+  // Streaming / PQ
+  async trainPq(c, o) {
+    this.ensureInitialized();
+    return trainPq(buildStreamingTransport(this.httpConfig), c, o);
+  }
+  async streamInsert(c, d) {
+    this.ensureInitialized();
+    return streamInsert(buildStreamingTransport(this.httpConfig), c, d);
+  }
+  async streamUpsertPoints(c, d) {
     this.ensureInitialized();
-    return streamInsert(this.asStreamingTransport(), collection, docs);
+    return streamUpsertPoints(buildStreamingTransport(this.httpConfig), c, d);
   }
-  // ==========================================================================
-  // Agent Memory — delegates to agent-memory-backend.ts
-  // ==========================================================================
-  async storeSemanticFact(collection, entry) {
+  // Agent Memory
+  async storeSemanticFact(c, e) {
     this.ensureInitialized();
-    return storeSemanticFact(this.asAgentMemoryTransport(), collection, entry);
+    return storeSemanticFact(buildAgentMemoryTransport(this.httpConfig, (col, emb, opts) => this.search(col, emb, opts)), c, e);
   }
-  async searchSemanticMemory(collection, embedding, k = 5) {
-    return searchSemanticMemory(this.asAgentMemoryTransport(), collection, embedding, k);
+  async searchSemanticMemory(c, e, k = 5) {
+    this.ensureInitialized();
+    return searchSemanticMemory(buildAgentMemoryTransport(this.httpConfig, (col, emb, opts) => this.search(col, emb, opts)), c, e, k);
   }
-  async recordEpisodicEvent(collection, event) {
+  async recordEpisodicEvent(c, e) {
     this.ensureInitialized();
-    return recordEpisodicEvent(this.asAgentMemoryTransport(), collection, event);
+    return recordEpisodicEvent(buildAgentMemoryTransport(this.httpConfig, (col, emb, opts) => this.search(col, emb, opts)), c, e);
   }
-  async recallEpisodicEvents(collection, embedding, k = 5) {
-    return recallEpisodicEvents(this.asAgentMemoryTransport(), collection, embedding, k);
+  async recallEpisodicEvents(c, e, k = 5) {
+    this.ensureInitialized();
+    return recallEpisodicEvents(buildAgentMemoryTransport(this.httpConfig, (col, emb, opts) => this.search(col, emb, opts)), c, e, k);
   }
-  async storeProceduralPattern(collection, pattern) {
+  async storeProceduralPattern(c, p) {
     this.ensureInitialized();
-    return storeProceduralPattern(this.asAgentMemoryTransport(), collection, pattern);
+    return storeProceduralPattern(buildAgentMemoryTransport(this.httpConfig, (col, emb, opts) => this.search(col, emb, opts)), c, p);
   }
-  async matchProceduralPatterns(collection, embedding, k = 5) {
-    return matchProceduralPatterns(this.asAgentMemoryTransport(), collection, embedding, k);
+  async matchProceduralPatterns(c, e, k = 5) {
+    this.ensureInitialized();
+    return matchProceduralPatterns(buildAgentMemoryTransport(this.httpConfig, (col, emb, opts) => this.search(col, emb, opts)), c, e, k);
   }
 };
 
@@ -1615,7 +2711,7 @@ var AgentMemoryClient = class {
   }
 };
 
-// src/client.ts
+// src/client/validation.ts
 function requireNonEmptyString(value, label) {
   if (!value || typeof value !== "string") {
     throw new ValidationError(`${label} must be a non-empty string`);
@@ -1634,13 +2730,187 @@ function validateDocsBatch(docs, validateDoc) {
     validateDoc(doc);
   }
 }
+function validateDocument(doc, config) {
+  if (doc.id === void 0 || doc.id === null) {
+    throw new ValidationError("Document ID is required");
+  }
+  requireVector(doc.vector, "Vector");
+  validateRestPointId(doc.id, config);
+}
+function validateRestPointId(id, config) {
+  if (config.backend === "rest" && (typeof id !== "number" || !Number.isInteger(id) || id < 0 || id > Number.MAX_SAFE_INTEGER)) {
+    throw new ValidationError(
+      `REST backend requires numeric u64-compatible document IDs in JS safe integer range (0..${Number.MAX_SAFE_INTEGER})`
+    );
+  }
+}
+
+// src/client/search-methods.ts
+function search2(backend, collection, query3, options) {
+  requireVector(query3, "Query");
+  return backend.search(collection, query3, options);
+}
+function searchBatch2(backend, collection, searches) {
+  if (!Array.isArray(searches)) {
+    throw new ValidationError("Searches must be an array");
+  }
+  for (const s of searches) {
+    requireVector(s.vector, "Each search vector");
+  }
+  return backend.searchBatch(collection, searches);
+}
+function textSearch2(backend, collection, query3, options) {
+  requireNonEmptyString(query3, "Query");
+  return backend.textSearch(collection, query3, options);
+}
+function hybridSearch2(backend, collection, vector, textQuery, options) {
+  requireVector(vector, "Vector");
+  requireNonEmptyString(textQuery, "Text query");
+  return backend.hybridSearch(collection, vector, textQuery, options);
+}
+function multiQuerySearch2(backend, collection, vectors, options) {
+  if (!Array.isArray(vectors) || vectors.length === 0) {
+    throw new ValidationError("Vectors must be a non-empty array");
+  }
+  for (const v of vectors) {
+    requireVector(v, "Each vector");
+  }
+  return backend.multiQuerySearch(collection, vectors, options);
+}
+function trainPq2(backend, collection, options) {
+  return backend.trainPq(collection, options);
+}
+function streamInsert2(backend, config, collection, docs) {
+  validateDocsBatch(docs, (doc) => validateDocument(doc, config));
+  return backend.streamInsert(collection, docs);
+}
+function streamUpsertPoints2(backend, config, collection, docs) {
+  validateDocsBatch(docs, (doc) => validateDocument(doc, config));
+  return backend.streamUpsertPoints(collection, docs);
+}
+function scroll2(backend, collection, request2) {
+  requireNonEmptyString(collection, "Collection name");
+  if (request2?.batchSize !== void 0) {
+    if (request2.batchSize < 1 || request2.batchSize > 1e4) {
+      throw new ValidationError("batchSize must be between 1 and 10000");
+    }
+  }
+  return backend.scroll(collection, request2);
+}
+function searchIds2(backend, collection, query3, options) {
+  return backend.searchIds(collection, query3, options);
+}
+function query2(backend, collection, queryString, params, options) {
+  requireNonEmptyString(collection, "Collection name");
+  requireNonEmptyString(queryString, "Query string");
+  return backend.query(collection, queryString, params, options);
+}
+function queryExplain2(backend, queryString, params, options) {
+  requireNonEmptyString(queryString, "Query string");
+  return backend.queryExplain(queryString, params, options);
+}
+function collectionSanity2(backend, collection) {
+  requireNonEmptyString(collection, "Collection name");
+  return backend.collectionSanity(collection);
+}
+function getCollectionStats2(backend, collection) {
+  return backend.getCollectionStats(collection);
+}
+function analyzeCollection2(backend, collection) {
+  return backend.analyzeCollection(collection);
+}
+function getCollectionConfig2(backend, collection) {
+  return backend.getCollectionConfig(collection);
+}
+function rebuildIndex2(backend, collection) {
+  requireNonEmptyString(collection, "Collection");
+  return backend.rebuildIndex(collection);
+}
+function getGuardrails2(backend) {
+  return backend.getGuardrails();
+}
+function updateGuardrails2(backend, req) {
+  return backend.updateGuardrails(req);
+}
+function aggregate2(backend, queryString, params, options) {
+  requireNonEmptyString(queryString, "Query string");
+  return backend.aggregate(queryString, params, options);
+}
+
+// src/client/graph-methods.ts
+function addEdge2(backend, collection, edge) {
+  if (!edge.label || typeof edge.label !== "string") {
+    throw new ValidationError("Edge label is required and must be a string");
+  }
+  if (typeof edge.source !== "number" || typeof edge.target !== "number") {
+    throw new ValidationError("Edge source and target must be numbers");
+  }
+  return backend.addEdge(collection, edge);
+}
+function getEdges2(backend, collection, options) {
+  return backend.getEdges(collection, options);
+}
+function traverseGraph2(backend, collection, request2) {
+  if (typeof request2.source !== "number") {
+    throw new ValidationError("Source node ID must be a number");
+  }
+  if (request2.strategy && !["bfs", "dfs"].includes(request2.strategy)) {
+    throw new ValidationError("Strategy must be 'bfs' or 'dfs'");
+  }
+  return backend.traverseGraph(collection, request2);
+}
+function traverseParallel2(backend, collection, request2) {
+  if (!Array.isArray(request2.sources) || request2.sources.length === 0) {
+    throw new ValidationError("At least one source node ID is required");
+  }
+  return backend.traverseParallel(collection, request2);
+}
+function getNodeDegree2(backend, collection, nodeId) {
+  if (typeof nodeId !== "number") {
+    throw new ValidationError("Node ID must be a number");
+  }
+  return backend.getNodeDegree(collection, nodeId);
+}
+function createGraphCollection2(backend, name, config) {
+  requireNonEmptyString(name, "Collection name");
+  return backend.createGraphCollection(name, config);
+}
+function matchQuery2(backend, collection, queryString, params, options) {
+  requireNonEmptyString(collection, "Collection");
+  requireNonEmptyString(queryString, "Query string");
+  return backend.matchQuery(collection, queryString, params, options);
+}
+function removeEdge2(backend, collection, edgeId) {
+  requireNonEmptyString(collection, "Collection");
+  return backend.removeEdge(collection, edgeId);
+}
+function getEdgeCount2(backend, collection) {
+  requireNonEmptyString(collection, "Collection");
+  return backend.getEdgeCount(collection);
+}
+function listNodes2(backend, collection) {
+  requireNonEmptyString(collection, "Collection");
+  return backend.listNodes(collection);
+}
+function getNodeEdges2(backend, collection, nodeId, options) {
+  requireNonEmptyString(collection, "Collection");
+  return backend.getNodeEdges(collection, nodeId, options);
+}
+function getNodePayload2(backend, collection, nodeId) {
+  requireNonEmptyString(collection, "Collection");
+  return backend.getNodePayload(collection, nodeId);
+}
+function upsertNodePayload2(backend, collection, nodeId, payload) {
+  requireNonEmptyString(collection, "Collection");
+  return backend.upsertNodePayload(collection, nodeId, payload);
+}
+function graphSearch2(backend, collection, request2) {
+  requireNonEmptyString(collection, "Collection");
+  return backend.graphSearch(collection, request2);
+}
+
+// src/client.ts
 var VelesDB = class {
-  /**
-   * Create a new VelesDB client
-   * 
-   * @param config - Client configuration
-   * @throws {ValidationError} If configuration is invalid
-   */
   constructor(config) {
     this.initialized = false;
     this.validateConfig(config);
@@ -1668,10 +2938,7 @@ var VelesDB = class {
         throw new ValidationError(`Unknown backend: ${config.backend}`);
     }
   }
-  /**
-   * Initialize the client
-   * Must be called before any other operations
-   */
+  /** Initialize the client. Must be called before any other operations. */
   async init() {
     if (this.initialized) {
       return;
@@ -1679,9 +2946,7 @@ var VelesDB = class {
     await this.backend.init();
     this.initialized = true;
   }
-  /**
-   * Check if client is initialized
-   */
+  /** Check if client is initialized. */
   isInitialized() {
     return this.initialized;
   }
@@ -1690,12 +2955,9 @@ var VelesDB = class {
       throw new ValidationError("Client not initialized. Call init() first.");
     }
   }
-  /**
-   * Create a new collection
-   * 
-   * @param name - Collection name
-   * @param config - Collection configuration
-   */
+  // ========================================================================
+  // Collection CRUD
+  // ========================================================================
   async createCollection(name, config) {
     this.ensureInitialized();
     requireNonEmptyString(name, "Collection name");
@@ -1705,329 +2967,149 @@ var VelesDB = class {
     }
     await this.backend.createCollection(name, config);
   }
-  /**
-   * Create a metadata-only collection (no vectors, just payload data)
-   * 
-   * Useful for storing reference data that can be JOINed with vector collections.
-   * 
-   * @param name - Collection name
-   * 
-   * @example
-   * ```typescript
-   * await db.createMetadataCollection('products');
-   * await db.insertMetadata('products', { id: 'P001', name: 'Widget', price: 99 });
-   * ```
-   */
   async createMetadataCollection(name) {
     this.ensureInitialized();
     requireNonEmptyString(name, "Collection name");
     await this.backend.createCollection(name, { collectionType: "metadata_only" });
   }
-  /**
-   * Delete a collection
-   * 
-   * @param name - Collection name
-   */
   async deleteCollection(name) {
     this.ensureInitialized();
     await this.backend.deleteCollection(name);
   }
-  /**
-   * Get collection information
-   * 
-   * @param name - Collection name
-   * @returns Collection info or null if not found
-   */
   async getCollection(name) {
     this.ensureInitialized();
     return this.backend.getCollection(name);
   }
-  /**
-   * List all collections
-   * 
-   * @returns Array of collections
-   */
   async listCollections() {
     this.ensureInitialized();
     return this.backend.listCollections();
   }
-  /**
-   * Insert a vector document
-   * 
-   * @param collection - Collection name
-   * @param doc - Document to insert
-   */
-  async insert(collection, doc) {
+  // ========================================================================
+  // Point CRUD
+  // ========================================================================
+  async upsert(collection, doc) {
     this.ensureInitialized();
-    this.validateDocument(doc);
-    await this.backend.insert(collection, doc);
+    validateDocument(doc, this.config);
+    await this.backend.upsert(collection, doc);
   }
-  /**
-   * Insert multiple vector documents
-   * 
-   * @param collection - Collection name
-   * @param docs - Documents to insert
-   */
-  async insertBatch(collection, docs) {
+  async upsertBatch(collection, docs) {
     this.ensureInitialized();
-    validateDocsBatch(docs, (doc) => this.validateDocument(doc));
-    await this.backend.insertBatch(collection, docs);
+    validateDocsBatch(docs, (doc) => validateDocument(doc, this.config));
+    await this.backend.upsertBatch(collection, docs);
   }
-  validateDocument(doc) {
-    if (doc.id === void 0 || doc.id === null) {
-      throw new ValidationError("Document ID is required");
-    }
-    requireVector(doc.vector, "Vector");
-    this.validateRestPointId(doc.id);
+  async delete(collection, id) {
+    this.ensureInitialized();
+    validateRestPointId(id, this.config);
+    return this.backend.delete(collection, id);
   }
-  validateRestPointId(id) {
-    if (this.config.backend === "rest" && (typeof id !== "number" || !Number.isInteger(id) || id < 0 || id > Number.MAX_SAFE_INTEGER)) {
-      throw new ValidationError(
-        `REST backend requires numeric u64-compatible document IDs in JS safe integer range (0..${Number.MAX_SAFE_INTEGER})`
-      );
-    }
+  async get(collection, id) {
+    this.ensureInitialized();
+    validateRestPointId(id, this.config);
+    return this.backend.get(collection, id);
   }
-  /**
-   * Search for similar vectors
-   * 
-   * @param collection - Collection name
-   * @param query - Query vector
-   * @param options - Search options
-   * @returns Search results sorted by relevance
-   */
-  async search(collection, query2, options) {
+  async isEmpty(collection) {
     this.ensureInitialized();
-    requireVector(query2, "Query");
-    return this.backend.search(collection, query2, options);
+    return this.backend.isEmpty(collection);
   }
-  /**
-   * Search for multiple vectors in parallel
-   * 
-   * @param collection - Collection name
-   * @param searches - List of search queries
-   * @returns List of search results for each query
-   */
-  async searchBatch(collection, searches) {
+  async flush(collection) {
     this.ensureInitialized();
-    if (!Array.isArray(searches)) {
-      throw new ValidationError("Searches must be an array");
-    }
-    for (const s of searches) {
-      requireVector(s.vector, "Each search vector");
+    await this.backend.flush(collection);
+  }
+  async close() {
+    if (this.initialized) {
+      await this.backend.close();
+      this.initialized = false;
     }
-    return this.backend.searchBatch(collection, searches);
   }
-  /**
-   * Delete a vector by ID
-   * 
-   * @param collection - Collection name
-   * @param id - Document ID
-   * @returns true if deleted, false if not found
-   */
-  async delete(collection, id) {
+  // ========================================================================
+  // Search & Query -- delegates to client/search-methods.ts
+  // ========================================================================
+  async search(collection, query3, options) {
     this.ensureInitialized();
-    this.validateRestPointId(id);
-    return this.backend.delete(collection, id);
+    return search2(this.backend, collection, query3, options);
   }
-  /**
-   * Get a vector by ID
-   * 
-   * @param collection - Collection name
-   * @param id - Document ID
-   * @returns Document or null if not found
-   */
-  async get(collection, id) {
+  async searchBatch(collection, searches) {
     this.ensureInitialized();
-    this.validateRestPointId(id);
-    return this.backend.get(collection, id);
+    return searchBatch2(this.backend, collection, searches);
   }
-  /**
-   * Perform full-text search using BM25
-   * 
-   * @param collection - Collection name
-   * @param query - Text query
-   * @param options - Search options (k, filter)
-   * @returns Search results sorted by BM25 score
-   */
-  async textSearch(collection, query2, options) {
+  async textSearch(collection, query3, options) {
     this.ensureInitialized();
-    requireNonEmptyString(query2, "Query");
-    return this.backend.textSearch(collection, query2, options);
+    return textSearch2(this.backend, collection, query3, options);
   }
-  /**
-   * Perform hybrid search combining vector similarity and BM25 text search
-   * 
-   * @param collection - Collection name
-   * @param vector - Query vector
-   * @param textQuery - Text query for BM25
-   * @param options - Search options (k, vectorWeight, filter)
-   * @returns Search results sorted by fused score
-   */
   async hybridSearch(collection, vector, textQuery, options) {
     this.ensureInitialized();
-    requireVector(vector, "Vector");
-    requireNonEmptyString(textQuery, "Text query");
-    return this.backend.hybridSearch(collection, vector, textQuery, options);
+    return hybridSearch2(this.backend, collection, vector, textQuery, options);
+  }
+  async multiQuerySearch(collection, vectors, options) {
+    this.ensureInitialized();
+    return multiQuerySearch2(this.backend, collection, vectors, options);
   }
-  /**
-   * Execute a VelesQL multi-model query (EPIC-031 US-011)
-   * 
-   * Supports hybrid vector + graph queries with VelesQL syntax.
-   * 
-   * @param collection - Collection name
-   * @param queryString - VelesQL query string
-   * @param params - Query parameters (vectors, scalars)
-   * @param options - Query options (timeout, streaming)
-   * @returns Query response with results and execution stats
-   * 
-   * @example
-   * ```typescript
-   * const response = await db.query('docs', `
-   *   MATCH (d:Doc) WHERE vector NEAR $q LIMIT 20
-   * `, { q: queryVector });
-   * 
-   * for (const r of response.results) {
-   *   console.log(`ID ${r.id}, title: ${r.title}`);
-   * }
-   * ```
-   */
   async query(collection, queryString, params, options) {
     this.ensureInitialized();
-    requireNonEmptyString(collection, "Collection name");
-    requireNonEmptyString(queryString, "Query string");
-    return this.backend.query(collection, queryString, params, options);
+    return query2(this.backend, collection, queryString, params, options);
   }
-  /**
-   * Explain the execution plan for a VelesQL query without running it
-   *
-   * @param queryString - VelesQL query string to explain
-   * @param params - Optional query parameters (vectors, scalars)
-   * @returns Explain response with the query execution plan
-   */
-  async queryExplain(queryString, params) {
+  async queryExplain(queryString, params, options) {
     this.ensureInitialized();
-    requireNonEmptyString(queryString, "Query string");
-    return this.backend.queryExplain(queryString, params);
+    return queryExplain2(this.backend, queryString, params, options);
   }
   async collectionSanity(collection) {
     this.ensureInitialized();
-    requireNonEmptyString(collection, "Collection name");
-    return this.backend.collectionSanity(collection);
+    return collectionSanity2(this.backend, collection);
   }
-  /**
-   * Multi-query fusion search combining results from multiple query vectors
-   *
-   * Ideal for RAG pipelines using Multiple Query Generation (MQG).
-   *
-   * @param collection - Collection name
-   * @param vectors - Array of query vectors
-   * @param options - Search options (k, fusion strategy, fusionParams, filter)
-   * @returns Fused search results
-   *
-   * @example
-   * ```typescript
-   * // RRF fusion (default)
-   * const results = await db.multiQuerySearch('docs', [emb1, emb2, emb3], {
-   *   k: 10,
-   *   fusion: 'rrf',
-   *   fusionParams: { k: 60 }
-   * });
-   *
-   * // Weighted fusion
-   * const results = await db.multiQuerySearch('docs', [emb1, emb2], {
-   *   k: 10,
-   *   fusion: 'weighted',
-   *   fusionParams: { avgWeight: 0.6, maxWeight: 0.3, hitWeight: 0.1 }
-   * });
-   * ```
-   */
-  async multiQuerySearch(collection, vectors, options) {
+  async scroll(collection, request2) {
     this.ensureInitialized();
-    if (!Array.isArray(vectors) || vectors.length === 0) {
-      throw new ValidationError("Vectors must be a non-empty array");
-    }
-    for (const v of vectors) {
-      requireVector(v, "Each vector");
-    }
-    return this.backend.multiQuerySearch(collection, vectors, options);
+    return scroll2(this.backend, collection, request2);
   }
-  /**
-   * Train Product Quantization on a collection
-   *
-   * @param collection - Collection name
-   * @param options - PQ training options (m, k, opq)
-   * @returns Server response message
-   */
   async trainPq(collection, options) {
     this.ensureInitialized();
-    return this.backend.trainPq(collection, options);
+    return trainPq2(this.backend, collection, options);
   }
-  /**
-   * Stream-insert documents with backpressure support
-   *
-   * Sends documents sequentially to respect server backpressure.
-   * Throws BackpressureError on 429 responses.
-   *
-   * @param collection - Collection name
-   * @param docs - Documents to insert
-   */
   async streamInsert(collection, docs) {
     this.ensureInitialized();
-    validateDocsBatch(docs, (doc) => this.validateDocument(doc));
-    await this.backend.streamInsert(collection, docs);
+    return streamInsert2(this.backend, this.config, collection, docs);
   }
-  /**
-   * Check if a collection is empty
-   *
-   * @param collection - Collection name
-   * @returns true if empty, false otherwise
-   */
-  async isEmpty(collection) {
+  async streamUpsertPoints(collection, docs) {
     this.ensureInitialized();
-    return this.backend.isEmpty(collection);
+    return streamUpsertPoints2(this.backend, this.config, collection, docs);
   }
-  /**
-   * Flush pending changes to disk
-   * 
-   * @param collection - Collection name
-   */
-  async flush(collection) {
+  async searchIds(collection, query3, options) {
     this.ensureInitialized();
-    await this.backend.flush(collection);
+    return searchIds2(this.backend, collection, query3, options);
   }
-  /**
-   * Close the client and release resources
-   */
-  async close() {
-    if (this.initialized) {
-      await this.backend.close();
-      this.initialized = false;
-    }
+  // ========================================================================
+  // Admin / Stats -- delegates to client/search-methods.ts
+  // ========================================================================
+  async rebuildIndex(collection) {
+    this.ensureInitialized();
+    return rebuildIndex2(this.backend, collection);
   }
-  /**
-   * Get the current backend type
-   */
-  get backendType() {
-    return this.config.backend;
+  async getGuardrails() {
+    this.ensureInitialized();
+    return getGuardrails2(this.backend);
+  }
+  async updateGuardrails(req) {
+    this.ensureInitialized();
+    return updateGuardrails2(this.backend, req);
+  }
+  async aggregate(queryString, params, options) {
+    this.ensureInitialized();
+    return aggregate2(this.backend, queryString, params, options);
+  }
+  async getCollectionStats(collection) {
+    this.ensureInitialized();
+    return getCollectionStats2(this.backend, collection);
+  }
+  async analyzeCollection(collection) {
+    this.ensureInitialized();
+    return analyzeCollection2(this.backend, collection);
+  }
+  async getCollectionConfig(collection) {
+    this.ensureInitialized();
+    return getCollectionConfig2(this.backend, collection);
   }
   // ========================================================================
   // Index Management (EPIC-009)
   // ========================================================================
-  /**
-   * Create a property index for O(1) equality lookups or O(log n) range queries
-   * 
-   * @param collection - Collection name
-   * @param options - Index configuration (label, property, indexType)
-   * 
-   * @example
-   * ```typescript
-   * // Create hash index for fast email lookups
-   * await db.createIndex('users', { label: 'Person', property: 'email' });
-   * 
-   * // Create range index for timestamp queries
-   * await db.createIndex('events', { label: 'Event', property: 'timestamp', indexType: 'range' });
-   * ```
-   */
   async createIndex(collection, options) {
     this.ensureInitialized();
     if (!options.label || !options.property) {
@@ -2035,208 +3117,89 @@ var VelesDB = class {
     }
     await this.backend.createIndex(collection, options);
   }
-  /**
-   * List all indexes on a collection
-   * 
-   * @param collection - Collection name
-   * @returns Array of index information
-   */
   async listIndexes(collection) {
     this.ensureInitialized();
     return this.backend.listIndexes(collection);
   }
-  /**
-   * Check if an index exists
-   * 
-   * @param collection - Collection name
-   * @param label - Node label
-   * @param property - Property name
-   * @returns true if index exists
-   */
   async hasIndex(collection, label, property) {
     this.ensureInitialized();
     return this.backend.hasIndex(collection, label, property);
   }
-  /**
-   * Drop an index
-   * 
-   * @param collection - Collection name
-   * @param label - Node label
-   * @param property - Property name
-   * @returns true if index was dropped, false if it didn't exist
-   */
   async dropIndex(collection, label, property) {
     this.ensureInitialized();
     return this.backend.dropIndex(collection, label, property);
   }
   // ========================================================================
-  // Knowledge Graph (EPIC-016 US-041)
+  // Knowledge Graph -- delegates to client/graph-methods.ts
   // ========================================================================
-  /**
-   * Add an edge to the collection's knowledge graph
-   * 
-   * @param collection - Collection name
-   * @param edge - Edge to add (id, source, target, label, properties)
-   * 
-   * @example
-   * ```typescript
-   * await db.addEdge('social', {
-   *   id: 1,
-   *   source: 100,
-   *   target: 200,
-   *   label: 'FOLLOWS',
-   *   properties: { since: '2024-01-01' }
-   * });
-   * ```
-   */
   async addEdge(collection, edge) {
     this.ensureInitialized();
-    if (!edge.label || typeof edge.label !== "string") {
-      throw new ValidationError("Edge label is required and must be a string");
-    }
-    if (typeof edge.source !== "number" || typeof edge.target !== "number") {
-      throw new ValidationError("Edge source and target must be numbers");
-    }
-    await this.backend.addEdge(collection, edge);
+    return addEdge2(this.backend, collection, edge);
   }
-  /**
-   * Get edges from the collection's knowledge graph
-   * 
-   * @param collection - Collection name
-   * @param options - Query options (filter by label)
-   * @returns Array of edges
-   * 
-   * @example
-   * ```typescript
-   * // Get all edges with label "FOLLOWS"
-   * const edges = await db.getEdges('social', { label: 'FOLLOWS' });
-   * ```
-   */
   async getEdges(collection, options) {
     this.ensureInitialized();
-    return this.backend.getEdges(collection, options);
+    return getEdges2(this.backend, collection, options);
   }
-  // ========================================================================
-  // Graph Traversal (EPIC-016 US-050)
-  // ========================================================================
-  /**
-   * Traverse the graph using BFS or DFS from a source node
-   * 
-   * @param collection - Collection name
-   * @param request - Traversal request options
-   * @returns Traversal response with results and stats
-   * 
-   * @example
-   * ```typescript
-   * // BFS traversal from node 100
-   * const result = await db.traverseGraph('social', {
-   *   source: 100,
-   *   strategy: 'bfs',
-   *   maxDepth: 3,
-   *   limit: 100,
-   *   relTypes: ['FOLLOWS', 'KNOWS']
-   * });
-   * 
-   * for (const node of result.results) {
-   *   console.log(`Reached node ${node.targetId} at depth ${node.depth}`);
-   * }
-   * ```
-   */
-  async traverseGraph(collection, request) {
+  async traverseGraph(collection, request2) {
     this.ensureInitialized();
-    if (typeof request.source !== "number") {
-      throw new ValidationError("Source node ID must be a number");
-    }
-    if (request.strategy && !["bfs", "dfs"].includes(request.strategy)) {
-      throw new ValidationError("Strategy must be 'bfs' or 'dfs'");
-    }
-    return this.backend.traverseGraph(collection, request);
+    return traverseGraph2(this.backend, collection, request2);
+  }
+  async traverseParallel(collection, request2) {
+    this.ensureInitialized();
+    return traverseParallel2(this.backend, collection, request2);
   }
-  /**
-   * Get the in-degree and out-degree of a node
-   * 
-   * @param collection - Collection name
-   * @param nodeId - Node ID
-   * @returns Degree response with inDegree and outDegree
-   * 
-   * @example
-   * ```typescript
-   * const degree = await db.getNodeDegree('social', 100);
-   * console.log(`In: ${degree.inDegree}, Out: ${degree.outDegree}`);
-   * ```
-   */
   async getNodeDegree(collection, nodeId) {
     this.ensureInitialized();
-    if (typeof nodeId !== "number") {
-      throw new ValidationError("Node ID must be a number");
-    }
-    return this.backend.getNodeDegree(collection, nodeId);
+    return getNodeDegree2(this.backend, collection, nodeId);
   }
-  // ========================================================================
-  // Graph Collection Management (Phase 8)
-  // ========================================================================
-  /**
-   * Create a graph collection
-   *
-   * @param name - Collection name
-   * @param config - Optional graph collection configuration
-   */
   async createGraphCollection(name, config) {
     this.ensureInitialized();
-    requireNonEmptyString(name, "Collection name");
-    await this.backend.createGraphCollection(name, config);
+    return createGraphCollection2(this.backend, name, config);
   }
-  /**
-   * Get collection statistics (requires prior analyze)
-   *
-   * @param collection - Collection name
-   * @returns Statistics or null if not yet analyzed
-   */
-  async getCollectionStats(collection) {
+  async matchQuery(collection, queryString, params, options) {
     this.ensureInitialized();
-    return this.backend.getCollectionStats(collection);
+    return matchQuery2(this.backend, collection, queryString, params, options);
   }
-  /**
-   * Analyze a collection to compute statistics
-   *
-   * @param collection - Collection name
-   * @returns Computed statistics
-   */
-  async analyzeCollection(collection) {
+  async removeEdge(collection, edgeId) {
     this.ensureInitialized();
-    return this.backend.analyzeCollection(collection);
+    return removeEdge2(this.backend, collection, edgeId);
   }
-  /**
-   * Get collection configuration
-   *
-   * @param collection - Collection name
-   * @returns Collection configuration details
-   */
-  async getCollectionConfig(collection) {
+  async getEdgeCount(collection) {
     this.ensureInitialized();
-    return this.backend.getCollectionConfig(collection);
+    return getEdgeCount2(this.backend, collection);
   }
-  /**
-   * Search returning only IDs and scores (lightweight)
-   *
-   * @param collection - Collection name
-   * @param query - Query vector
-   * @param options - Search options
-   * @returns Array of id/score pairs
-   */
-  async searchIds(collection, query2, options) {
+  async listNodes(collection) {
+    this.ensureInitialized();
+    return listNodes2(this.backend, collection);
+  }
+  async getNodeEdges(collection, nodeId, options) {
+    this.ensureInitialized();
+    return getNodeEdges2(this.backend, collection, nodeId, options);
+  }
+  async getNodePayload(collection, nodeId) {
+    this.ensureInitialized();
+    return getNodePayload2(this.backend, collection, nodeId);
+  }
+  async upsertNodePayload(collection, nodeId, payload) {
+    this.ensureInitialized();
+    return upsertNodePayload2(this.backend, collection, nodeId, payload);
+  }
+  async graphSearch(collection, request2) {
     this.ensureInitialized();
-    return this.backend.searchIds(collection, query2, options);
+    return graphSearch2(this.backend, collection, request2);
+  }
+  // ========================================================================
+  // Capabilities & Backend Info
+  // ========================================================================
+  capabilities() {
+    return this.backend.capabilities();
+  }
+  get backendType() {
+    return this.config.backend;
   }
   // ========================================================================
   // Agent Memory (Phase 8)
   // ========================================================================
-  /**
-   * Create an agent memory interface
-   *
-   * @param config - Optional agent memory configuration
-   * @returns AgentMemoryClient instance
-   */
   agentMemory(config) {
     this.ensureInitialized();
     return new AgentMemoryClient(this.backend, config);
@@ -2336,6 +3299,16 @@ var VelesQLBuilder = class _VelesQLBuilder {
    * 
    * @param condition - WHERE condition
    * @param params - Optional parameters
+   * 
+   * @example
+   * ```typescript
+   * // Substring matching with CONTAINS_TEXT
+   * velesql()
+   *   .match('d', 'Document')
+   *   .where("content CONTAINS_TEXT 'keyword'")
+   *   .limit(10)
+   *   .toVelesQL();
+   * ```
    */
   where(condition, params) {
     const newParams = params ? { ...this.state.params, ...params } : this.state.params;
@@ -2544,16 +3517,205 @@ var VelesQLBuilder = class _VelesQLBuilder {
 function velesql() {
   return new VelesQLBuilder();
 }
+
+// src/filter.ts
+function isTypedFilter(input) {
+  if (typeof input !== "object" || input === null) {
+    return false;
+  }
+  if (!("condition" in input)) {
+    return false;
+  }
+  const cond = input.condition;
+  return typeof cond === "object" && cond !== null;
+}
+function normalizeFilter(input) {
+  if (input === void 0) {
+    return void 0;
+  }
+  return input;
+}
+var f = {
+  // --- Comparison -----------------------------------------------------------
+  /** `field == value` */
+  eq(field, value) {
+    return { condition: { type: "eq", field, value } };
+  },
+  /** `field != value` */
+  neq(field, value) {
+    return { condition: { type: "neq", field, value } };
+  },
+  /** `field > value` */
+  gt(field, value) {
+    return { condition: { type: "gt", field, value } };
+  },
+  /** `field >= value` */
+  gte(field, value) {
+    return { condition: { type: "gte", field, value } };
+  },
+  /** `field < value` */
+  lt(field, value) {
+    return { condition: { type: "lt", field, value } };
+  },
+  /** `field <= value` */
+  lte(field, value) {
+    return { condition: { type: "lte", field, value } };
+  },
+  // --- Set / string / null --------------------------------------------------
+  /** `field IN (values...)` — the values list is copied. */
+  in(field, values) {
+    return { condition: { type: "in", field, values: [...values] } };
+  },
+  /** Substring containment: `field LIKE '%value%'` (case-sensitive). */
+  contains(field, value) {
+    return { condition: { type: "contains", field, value } };
+  },
+  /** `field IS NULL` */
+  isNull(field) {
+    return { condition: { type: "is_null", field } };
+  },
+  /** `field IS NOT NULL` */
+  isNotNull(field) {
+    return { condition: { type: "is_not_null", field } };
+  },
+  // --- SQL patterns ---------------------------------------------------------
+  /** SQL LIKE pattern matching (case-sensitive). Supports `%` and `_`. */
+  like(field, pattern) {
+    return { condition: { type: "like", field, pattern } };
+  },
+  /** SQL ILIKE pattern matching (case-insensitive). */
+  ilike(field, pattern) {
+    return { condition: { type: "ilike", field, pattern } };
+  },
+  // --- Array ----------------------------------------------------------------
+  /** `value IN field` (field must be an array). */
+  arrayContains(field, value) {
+    return { condition: { type: "array_contains", field, value } };
+  },
+  /** At least one of `values` is present in the array field. */
+  arrayContainsAny(field, values) {
+    return { condition: { type: "array_contains_any", field, values: [...values] } };
+  },
+  /** Every value in `values` is present in the array field. */
+  arrayContainsAll(field, values) {
+    return { condition: { type: "array_contains_all", field, values: [...values] } };
+  },
+  // --- Geo ------------------------------------------------------------------
+  /** Haversine distance comparison: `distance(field, (lat, lng)) <op> threshold`. */
+  geoDistance(field, lat, lng, operator, threshold) {
+    return {
+      condition: { type: "geo_distance", field, lat, lng, operator, threshold }
+    };
+  },
+  /** Bounding-box containment: point field falls inside `[lat_min, lat_max] x [lng_min, lng_max]`. */
+  geoBbox(field, bounds) {
+    return {
+      condition: {
+        type: "geo_bbox",
+        field,
+        lat_min: bounds.lat_min,
+        lng_min: bounds.lng_min,
+        lat_max: bounds.lat_max,
+        lng_max: bounds.lng_max
+      }
+    };
+  },
+  // --- Convenience combinators ----------------------------------------------
+  /** `field NOT IN (values...)` — shorthand for `not(in(field, values))`. */
+  notIn(field, values) {
+    return { condition: { type: "not", condition: { type: "in", field, values: [...values] } } };
+  },
+  /** `field BETWEEN low AND high` — shorthand for `and([gte(field, low), lte(field, high)])`. */
+  between(field, low, high) {
+    return {
+      condition: {
+        type: "and",
+        conditions: [
+          { type: "gte", field, value: low },
+          { type: "lte", field, value: high }
+        ]
+      }
+    };
+  },
+  // --- Logical --------------------------------------------------------------
+  /** Logical AND — the filters list is copied and flattened to root conditions. */
+  and(filters) {
+    return {
+      condition: {
+        type: "and",
+        conditions: filters.map((item) => item.condition)
+      }
+    };
+  },
+  /** Logical OR — the filters list is copied and flattened to root conditions. */
+  or(filters) {
+    return {
+      condition: {
+        type: "or",
+        conditions: filters.map((item) => item.condition)
+      }
+    };
+  },
+  /** Logical NOT — wraps a single filter. */
+  not(filter) {
+    return { condition: { type: "not", condition: filter.condition } };
+  }
+};
 export {
   AgentMemoryClient,
+  AllocationFailedError,
   BackpressureError,
+  CollectionExistsError,
+  CollectionNotFoundError,
+  ColumnStoreError,
+  ConfigError,
   ConnectionError,
+  DatabaseLockedError,
+  DimensionMismatchError,
+  EdgeExistsError,
+  EdgeNotFoundError,
+  EpochMismatchError,
+  GpuError,
+  GraphNotSupportedError,
+  GuardRailError,
+  IncompatibleSchemaVersionError,
+  IndexCorruptedError,
+  IndexError,
+  InternalError,
+  InvalidCollectionNameError,
+  InvalidDimensionError,
+  InvalidEdgeLabelError,
+  InvalidQuantizerConfigError,
+  InvalidVectorError,
+  IoError,
+  NodeNotFoundError,
   NotFoundError,
+  OverflowError,
+  PointNotFoundError,
+  QueryError,
+  REST_CAPABILITIES,
   RestBackend,
+  SchemaValidationError,
+  SearchNotSupportedError,
+  SerializationError,
+  SnapshotBuildFailedError,
+  SparseIndexError,
+  StorageError,
+  TrainingFailedError,
+  VELES_ERROR_CODES,
   ValidationError,
+  VectorNotAllowedError,
+  VectorRequiredError,
   VelesDB,
   VelesDBError,
+  VelesError,
   VelesQLBuilder,
+  WASM_CAPABILITIES,
   WasmBackend,
+  f,
+  isTypedFilter,
+  normalizeFilter,
+  parseVelesError,
+  searchQualityToMode,
   velesql
 };