@wiscale/velesdb-sdk 1.18.0 → 3.0.0

package/dist/index.mjs

@@ -43,6 +43,7 @@ var REST_CAPABILITIES = Object.freeze({
   graphTraversal: true,
   secondaryIndexes: true,
   agentMemory: true,
+  enableStreaming: true,
   streamInsert: true,
   pqTraining: true,
   velesqlQuery: true,
@@ -58,9 +59,10 @@ var WASM_CAPABILITIES = Object.freeze({
   graphTraversal: false,
   secondaryIndexes: false,
   agentMemory: false,
+  enableStreaming: false,
   streamInsert: false,
   pqTraining: false,
-  velesqlQuery: true,
+  velesqlQuery: false,
   collectionIntrospection: false
 });
 
@@ -298,20 +300,47 @@ async function wasmMultiQuerySearch(ctx, collectionName, vectors, options) {
   );
   return raw.map((r) => mapWasmResult(ctx, collection, r));
 }
-async function wasmQuery(ctx, collectionName, _queryString, params, _options) {
+var PURE_NEAR_QUERY = /^\s*select\s+\*\s+from\s+([a-z_]\w*)\s+where\s+vector\s+near\s+\$([a-z_]\w*)\s*(?:limit\s+(\d+))?\s*;?\s*$/i;
+function parsePureNearQuery(queryString) {
+  const match = PURE_NEAR_QUERY.exec(queryString);
+  if (!match) {
+    throw new VelesDBError(
+      `The WASM backend only executes pure top-k NEAR queries of the form "SELECT * FROM <collection> WHERE vector NEAR $param [LIMIT n]". WHERE predicates, JOIN, GROUP BY, MATCH, set operations and FUSION are not evaluated in WASM \u2014 use the REST backend (velesdb-server) for full VelesQL. Received: ${queryString}`,
+      "NOT_SUPPORTED"
+    );
+  }
+  const parsed = { from: match[1], param: match[2] };
+  if (match[3] !== void 0) {
+    parsed.limit = Number(match[3]);
+  }
+  return parsed;
+}
+function resolveQueryK(limit, requestedK) {
+  if (limit !== void 0) {
+    return limit;
+  }
+  return typeof requestedK === "number" && Number.isInteger(requestedK) && requestedK > 0 ? requestedK : 10;
+}
+async function wasmQuery(ctx, collectionName, queryString, params, _options) {
   const collection = ctx.getCollection(collectionName);
   if (!collection) {
     throw new NotFoundError(`Collection '${collectionName}'`);
   }
-  const paramsVector = params?.q;
+  const parsed = parsePureNearQuery(queryString);
+  if (parsed.from !== collectionName) {
+    throw new VelesDBError(
+      `Query targets collection '${parsed.from}' but was executed against '${collectionName}'.`,
+      "BAD_REQUEST"
+    );
+  }
+  const paramsVector = params?.[parsed.param];
   if (!Array.isArray(paramsVector) && !(paramsVector instanceof Float32Array)) {
     throw new VelesDBError(
-      "WASM query() expects params.q to contain the query embedding vector.",
+      `WASM query() expects params.${parsed.param} 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 k = resolveQueryK(parsed.limit, params?.k);
   const raw = collection.store.query(
     paramsVector instanceof Float32Array ? paramsVector : new Float32Array(paramsVector),
     k
@@ -725,6 +754,9 @@ function validateCollectionName(name) {
     );
   }
 }
+async function safeJsonParse(response) {
+  return response.json().catch(() => ({}));
+}
 function toNumberArray(v) {
   return v instanceof Float32Array ? Array.from(v) : v;
 }
@@ -778,12 +810,18 @@ async function wasmScroll(_collection, _request) {
 async function wasmTrainPq(_collection, _options) {
   wasmNotSupported("PQ training");
 }
+async function wasmEnableStreaming(_collection, _config) {
+  wasmNotSupported("Streaming enable");
+}
 async function wasmStreamInsert(_collection, _docs) {
   wasmNotSupported("Streaming insert");
 }
 async function wasmStreamUpsertPoints(_collection, _docs) {
   wasmNotSupported("Streaming batch upsert");
 }
+async function wasmUpsertBatchRaw(_collection, _docs) {
+  wasmNotSupported("Binary bulk upsert (upsertBatchRaw)");
+}
 async function wasmCreateGraphCollection(_name, _config) {
   wasmNotSupported("Graph collections");
 }
@@ -799,6 +837,9 @@ async function wasmGetCollectionConfig(_collection) {
 async function wasmSearchIds(_collection, _query, _options) {
   wasmNotSupported("searchIds");
 }
+async function wasmMultiQuerySearchIds(_collection, _vectors, _options) {
+  wasmNotSupported("multiQuerySearchIds");
+}
 async function wasmStoreSemanticFact(_collection, _entry) {
   wasmNotSupported("Agent memory");
 }
@@ -811,6 +852,12 @@ async function wasmRecordEpisodicEvent(_collection, _event) {
 async function wasmRecallEpisodicEvents(_collection, _embedding, _k) {
   wasmNotSupported("Agent memory");
 }
+async function wasmRecallRecentEvents(_collection, _since) {
+  wasmNotSupported("Agent memory");
+}
+async function wasmRecallOlderThanEvents(_collection, _before) {
+  wasmNotSupported("Agent memory");
+}
 async function wasmStoreProceduralPattern(_collection, _pattern) {
   wasmNotSupported("Agent memory");
 }
@@ -858,6 +905,18 @@ function wasmUpsertNodePayload(_c, _id, _p) {
 function wasmGraphSearch(_c, _r) {
   return Promise.resolve(wasmNotSupported("Graph search"));
 }
+function wasmRelate(_c, _req) {
+  return Promise.resolve(wasmNotSupported("Relation edges"));
+}
+function wasmUnrelate(_c, _id) {
+  return Promise.resolve(wasmNotSupported("Relation edge removal"));
+}
+function wasmGetRelations(_c, _id) {
+  return Promise.resolve(wasmNotSupported("Relation edges"));
+}
+function wasmSetTtlDurable(_c, _id, _ttl) {
+  return Promise.resolve(wasmNotSupported("Durable TTL"));
+}
 
 // src/backends/wasm.ts
 var WasmBackend = class {
@@ -1037,6 +1096,9 @@ var WasmBackend = class {
       }
     }
   }
+  async upsertBatchRaw(c, d) {
+    return wasmUpsertBatchRaw(c, d);
+  }
   async delete(collectionName, id) {
     this.ensureInitialized();
     const collection = this.collections.get(collectionName);
@@ -1168,6 +1230,10 @@ var WasmBackend = class {
     this.ensureInitialized();
     return wasmTrainPq(c, o);
   }
+  async enableStreaming(c, cfg) {
+    this.ensureInitialized();
+    return wasmEnableStreaming(c, cfg);
+  }
   async streamInsert(c, d) {
     this.ensureInitialized();
     return wasmStreamInsert(c, d);
@@ -1196,6 +1262,10 @@ var WasmBackend = class {
     this.ensureInitialized();
     return wasmSearchIds(c, q, o);
   }
+  async multiQuerySearchIds(c, v, o) {
+    this.ensureInitialized();
+    return wasmMultiQuerySearchIds(c, v, o);
+  }
   async storeSemanticFact(c, e) {
     this.ensureInitialized();
     return wasmStoreSemanticFact(c, e);
@@ -1212,6 +1282,14 @@ var WasmBackend = class {
     this.ensureInitialized();
     return wasmRecallEpisodicEvents(c, e, k);
   }
+  async recallRecentEvents(c, since) {
+    this.ensureInitialized();
+    return wasmRecallRecentEvents(c, since);
+  }
+  async recallOlderThanEvents(c, before) {
+    this.ensureInitialized();
+    return wasmRecallOlderThanEvents(c, before);
+  }
   async storeProceduralPattern(c, p) {
     this.ensureInitialized();
     return wasmStoreProceduralPattern(c, p);
@@ -1273,16 +1351,46 @@ var WasmBackend = class {
     this.ensureInitialized();
     return wasmSparseSearchNamed(c, q, idx, o);
   }
+  async relate(c, req) {
+    this.ensureInitialized();
+    return wasmRelate(c, req);
+  }
+  async unrelate(c, edgeId) {
+    this.ensureInitialized();
+    return wasmUnrelate(c, edgeId);
+  }
+  async getRelations(c, pointId) {
+    this.ensureInitialized();
+    return wasmGetRelations(c, pointId);
+  }
+  async setTtlDurable(c, pointId, ttlSeconds) {
+    this.ensureInitialized();
+    return wasmSetTtlDurable(c, pointId, ttlSeconds);
+  }
 };
 
 // src/backends/crud-backend.ts
+var RAW_BULK_HEADER_LEN = 16;
+var RAW_BULK_MAGIC = [86, 82, 66, 49];
+var RAW_BULK_ID_WIDTH = 8;
+var U64_MAX = 18446744073709551615n;
+function coerceDecimalStringId(id) {
+  if (!/^\d+$/.test(id)) return NaN;
+  const big = BigInt(id);
+  if (big > U64_MAX) return NaN;
+  return big > BigInt(Number.MAX_SAFE_INTEGER) ? id : Number(id);
+}
 function parseRestPointId(id) {
-  if (typeof id !== "number" || !Number.isFinite(id) || id < 0 || !Number.isInteger(id) || id > Number.MAX_SAFE_INTEGER) {
+  const coerced = typeof id === "string" ? coerceDecimalStringId(id) : id;
+  if (typeof coerced === "string") {
+    return coerced;
+  }
+  if (!Number.isFinite(coerced) || coerced < 0 || !Number.isInteger(coerced) || coerced > 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)}`
+      `REST backend requires numeric u64-compatible IDs: a non-negative integer in the JS safe integer range (0..${Number.MAX_SAFE_INTEGER}) or a decimal string up to u64::MAX (${U64_MAX}). Received: ${String(id)}`
     );
   }
-  return id;
+  return coerced;
 }
 function sparseVectorToRestFormat(sv) {
   const result = {};
@@ -1415,6 +1523,105 @@ async function flush(transport, collection) {
   );
   throwOnError(response, `Collection '${collection}'`);
 }
+function encodeRawBulk(ids, vectors, dim) {
+  const count = ids.length;
+  if (vectors.length !== count) {
+    throw new ValidationError(
+      `encodeRawBulk: ids length (${count}) must match vectors length (${vectors.length})`
+    );
+  }
+  const buf = new Uint8Array(RAW_BULK_HEADER_LEN + count * 8 + count * dim * 4);
+  const view = new DataView(buf.buffer);
+  buf.set(RAW_BULK_MAGIC, 0);
+  view.setUint32(4, count, true);
+  view.setUint32(8, dim, true);
+  buf[12] = RAW_BULK_ID_WIDTH;
+  writeIds(view, ids);
+  writeVectors(view, vectors, dim, count);
+  return buf;
+}
+function writeIds(view, ids) {
+  let off = RAW_BULK_HEADER_LEN;
+  for (const id of ids) {
+    view.setBigUint64(off, BigInt(id), true);
+    off += 8;
+  }
+}
+function writeVectors(view, vectors, dim, count) {
+  let off = RAW_BULK_HEADER_LEN + count * 8;
+  for (const vec of vectors) {
+    if (vec.length !== dim) {
+      throw new ValidationError(
+        `encodeRawBulk: vector length (${vec.length}) must match dim (${dim})`
+      );
+    }
+    for (let i = 0; i < dim; i++) {
+      view.setFloat32(off, vec[i] ?? 0, true);
+      off += 4;
+    }
+  }
+}
+async function upsertBatchRaw(transport, collection, docs, dim) {
+  const ids = docs.map((d) => coerceNumericId(d.id));
+  const vectors = docs.map((d) => d.vector);
+  const body = encodeRawBulk(ids, vectors, dim);
+  return sendRawBulk(transport, collection, body);
+}
+function coerceNumericId(id) {
+  const parsed = parseRestPointId(id);
+  if (typeof parsed === "string") {
+    throw new ValidationError(
+      `upsertBatchRaw requires ids in the JS safe integer range; received: ${parsed}`
+    );
+  }
+  return parsed;
+}
+async function sendRawBulk(transport, collection, body) {
+  const url = `${transport.baseUrl}${collectionPath(collection)}/points/raw`;
+  const headers = {
+    "Content-Type": "application/octet-stream"
+  };
+  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);
+    return await parseRawBulkResponse(response);
+  } catch (error) {
+    clearTimeout(timeoutId);
+    throw wrapRawBulkError(error);
+  }
+}
+async function parseRawBulkResponse(response) {
+  const data = await safeJsonParse(response);
+  if (!response.ok) {
+    const code = typeof data.code === "string" ? data.code : `HTTP_${response.status}`;
+    const message = typeof data.error === "string" ? data.error : `HTTP ${response.status}`;
+    throw new VelesDBError(message, code);
+  }
+  return typeof data.count === "number" ? data.count : 0;
+}
+function wrapRawBulkError(error) {
+  if (error instanceof VelesDBError) {
+    return error;
+  }
+  if (error instanceof Error && error.name === "AbortError") {
+    return new ConnectionError("Request timeout");
+  }
+  const message = error instanceof Error ? error.message : "Unknown error";
+  return new ConnectionError(
+    `Raw bulk upsert failed: ${message}`,
+    error instanceof Error ? error : void 0
+  );
+}
 
 // src/backends/rest-http.ts
 var STATUS_ERROR_CODES = {
@@ -1485,7 +1692,7 @@ async function request(config, method, path, body) {
       signal: controller.signal
     });
     clearTimeout(timeoutId);
-    const data = await response.json().catch(() => ({}));
+    const data = await safeJsonParse(response);
     if (!response.ok) {
       const ep = extractErrorPayload(data);
       return { error: {
@@ -1509,6 +1716,13 @@ function buildCrudTransport(config) {
     requestJson: (m, p, b) => request(config, m, p, b)
   };
 }
+function buildRawBulkTransport(config) {
+  return {
+    baseUrl: config.baseUrl,
+    apiKey: config.apiKey,
+    timeout: config.timeout
+  };
+}
 function buildSearchTransport(config) {
   return {
     requestJson: (m, p, b) => request(config, m, p, b),
@@ -1737,6 +1951,31 @@ async function graphSearch(transport, collection, request2) {
   return { results: items };
 }
 
+// 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/agent-memory-backend.ts
 var _idCounter = 0;
 var _lastTimestamp = 0;
@@ -1754,20 +1993,28 @@ function generateUniqueId() {
   }
   return _lastTimestamp * 1e3 + _idCounter;
 }
+function memoryIdToString(id) {
+  return String(id);
+}
+function nowUnixSeconds() {
+  return Math.floor(Date.now() / 1e3);
+}
 async function storeSemanticFact(transport, collection, entry) {
   const response = await transport.requestJson(
     "POST",
     `${collectionPath(collection)}/points`,
     {
       points: [{
-        id: entry.id,
+        id: parseRestPointId(entry.id),
         vector: entry.embedding,
         payload: {
           // Caller metadata is spread first so the reserved keys below
-          // (`_memory_type`, `text`) always win and cannot be clobbered.
+          // (`_memory_type`, `content`) always win and cannot be clobbered.
           ...entry.metadata,
           _memory_type: "semantic",
-          text: entry.text
+          // `content` matches the core semantic store and the server/Python
+          // payload field (BREAKING: was `text` before this change).
+          content: entry.text
         }
       }]
     }
@@ -1778,7 +2025,8 @@ async function searchSemanticMemory(transport, collection, embedding, k = 5) {
   return transport.searchVectors(collection, embedding, k, { _memory_type: "semantic" });
 }
 async function recordEpisodicEvent(transport, collection, event) {
-  const id = generateUniqueId();
+  const id = event.id !== void 0 ? parseRestPointId(event.id) : generateUniqueId();
+  const timestamp = event.timestamp ?? nowUnixSeconds();
   const response = await transport.requestJson(
     "POST",
     `${collectionPath(collection)}/points`,
@@ -1794,19 +2042,21 @@ async function recordEpisodicEvent(transport, collection, event) {
           ...event.metadata,
           _memory_type: "episodic",
           event_type: event.eventType,
-          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          // NUMERIC unix-seconds, mirroring the core episodic store so
+          // recallRecent/recallOlderThan can range-filter on it.
+          timestamp
         }
       }]
     }
   );
   throwOnError(response);
-  return id;
+  return memoryIdToString(id);
 }
 async function recallEpisodicEvents(transport, collection, embedding, k = 5) {
   return transport.searchVectors(collection, embedding, k, { _memory_type: "episodic" });
 }
 async function storeProceduralPattern(transport, collection, pattern) {
-  const id = generateUniqueId();
+  const id = pattern.id !== void 0 ? parseRestPointId(pattern.id) : generateUniqueId();
   const response = await transport.requestJson(
     "POST",
     `${collectionPath(collection)}/points`,
@@ -1827,11 +2077,41 @@ async function storeProceduralPattern(transport, collection, pattern) {
     }
   );
   throwOnError(response);
-  return id;
+  return memoryIdToString(id);
 }
 async function matchProceduralPatterns(transport, collection, embedding, k = 5) {
   return transport.searchVectors(collection, embedding, k, { _memory_type: "procedural" });
 }
+function toEpisodicRecord(point) {
+  const payload = point.payload ?? {};
+  if (payload._memory_type !== "episodic") return void 0;
+  if (typeof payload.timestamp !== "number") return void 0;
+  return { id: String(point.id), timestamp: payload.timestamp, payload };
+}
+async function scrollEpisodicRecords(transport, collection) {
+  const records = [];
+  let cursor = null;
+  do {
+    const page = await scroll(transport, collection, {
+      cursor: cursor ?? void 0,
+      filter: { _memory_type: "episodic" }
+    });
+    for (const point of page.points) {
+      const record = toEpisodicRecord(point);
+      if (record !== void 0) records.push(record);
+    }
+    cursor = page.nextCursor;
+  } while (cursor !== null && cursor !== void 0);
+  return records;
+}
+async function recallRecentEvents(transport, collection, since) {
+  const records = await scrollEpisodicRecords(transport, collection);
+  return records.filter((r) => since === void 0 || r.timestamp >= since).sort((a, b) => b.timestamp - a.timestamp);
+}
+async function recallOlderThanEvents(transport, collection, before) {
+  const records = await scrollEpisodicRecords(transport, collection);
+  return records.filter((r) => r.timestamp < before).sort((a, b) => b.timestamp - a.timestamp);
+}
 
 // src/search-quality.ts
 function searchQualityToMode(quality) {
@@ -1930,6 +2210,22 @@ async function multiQuerySearch(transport, collection, vectors, options) {
   throwOnError(response, `Collection '${collection}'`);
   return response.data?.results ?? [];
 }
+async function multiQuerySearchIds(transport, collection, vectors, options) {
+  const formattedVectors = vectors.map(toNumberArray);
+  const response = await transport.requestJson("POST", `${collectionPath(collection)}/search/multi/ids`, {
+    vectors: formattedVectors,
+    top_k: options?.k ?? 10,
+    strategy: options?.fusion ?? "rrf",
+    rrf_k: options?.fusionParams?.k ?? 60,
+    avg_weight: options?.fusionParams?.avgWeight,
+    max_weight: options?.fusionParams?.maxWeight,
+    hit_weight: options?.fusionParams?.hitWeight,
+    dense_weight: options?.fusionParams?.denseWeight,
+    sparse_weight: options?.fusionParams?.sparseWeight
+  });
+  throwOnError(response, `Collection '${collection}'`);
+  return response.data?.results ?? [];
+}
 async function sparseSearchNamed(transport, collection, query3, indexName, options) {
   const body = {
     sparse_vectors: { [indexName]: transport.sparseToRest(query3) },
@@ -2064,6 +2360,64 @@ async function traverseParallel(transport, collection, request2) {
   throwOnError(response, `Collection '${collection}'`);
   return toTraverseResponse(response.data);
 }
+async function relate(transport, collection, req) {
+  const response = await transport.requestJson(
+    "POST",
+    `${collectionPath(collection)}/relations`,
+    {
+      source: req.source,
+      target: req.target,
+      rel_type: req.relType,
+      properties: req.properties ?? {}
+    }
+  );
+  throwOnError(response, `Collection '${collection}'`);
+  return { edgeId: response.data.edge_id };
+}
+async function unrelate(transport, collection, edgeId) {
+  const response = await transport.requestJson(
+    "DELETE",
+    `${collectionPath(collection)}/relations/${encodeURIComponent(String(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 getRelations(transport, collection, pointId) {
+  const response = await transport.requestJson(
+    "GET",
+    `${collectionPath(collection)}/points/${encodeURIComponent(String(pointId))}/relations`
+  );
+  throwOnError(response, `Collection '${collection}'`);
+  const raw = response.data;
+  return {
+    edges: raw.edges.map((e) => ({
+      id: e.id,
+      source: e.source,
+      target: e.target,
+      relType: e.rel_type,
+      properties: e.properties
+    })),
+    count: raw.count
+  };
+}
+async function setTtlDurable(transport, collection, pointId, ttlSeconds) {
+  const response = await transport.requestJson(
+    "PATCH",
+    `${collectionPath(collection)}/points/${encodeURIComponent(String(pointId))}/ttl`,
+    { ttl_seconds: ttlSeconds }
+  );
+  throwOnError(response, `Collection '${collection}'`);
+}
 
 // src/backends/query-backend.ts
 function isLikelyAggregationQuery(queryString) {
@@ -2089,7 +2443,7 @@ async function query(transport, collection, queryString, params, options) {
   );
   throwOnError(response, `Collection '${collection}'`);
   const rawData = response.data;
-  if (rawData && Object.prototype.hasOwnProperty.call(rawData, "result")) {
+  if (rawData != null && Object.prototype.hasOwnProperty.call(rawData, "result")) {
     return {
       result: rawData.result,
       stats: {
@@ -2196,31 +2550,6 @@ 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;
@@ -2384,7 +2713,7 @@ async function streamInsert(transport, collection, docs) {
         throw new BackpressureError();
       }
       if (!response.ok && response.status !== 202) {
-        const data = await response.json().catch(() => ({}));
+        const data = await safeJsonParse(response);
         const errorPayload = transport.extractErrorPayload(data);
         throw new VelesDBError(
           errorPayload.message ?? `HTTP ${response.status}`,
@@ -2406,9 +2735,35 @@ async function streamInsert(transport, collection, docs) {
     }
   }
 }
+async function enableStreaming(transport, collection, config) {
+  const body = {};
+  if (config?.bufferSize !== void 0) {
+    body.buffer_size = config.bufferSize;
+  }
+  if (config?.batchSize !== void 0) {
+    body.batch_size = config.batchSize;
+  }
+  if (config?.flushIntervalMs !== void 0) {
+    body.flush_interval_ms = config.flushIntervalMs;
+  }
+  const response = await transport.requestJson(
+    "POST",
+    `${collectionPath(collection)}/stream/enable`,
+    body
+  );
+  throwOnError(response);
+}
+function requireSafeRangeId(restId) {
+  if (typeof restId === "string") {
+    throw new ValidationError(
+      `streamUpsertPoints requires ids in the JS safe integer range (0..${Number.MAX_SAFE_INTEGER}); use upsert/upsertBatch for string ids above it. Received: ${restId}`
+    );
+  }
+  return restId;
+}
 async function streamUpsertPoints(transport, collection, docs) {
   const ndjsonLines = docs.map((doc) => {
-    const restId = transport.parseRestPointId(doc.id);
+    const restId = requireSafeRangeId(transport.parseRestPointId(doc.id));
     const vector = toNumberArray(doc.vector);
     const point = {
       id: restId,
@@ -2442,14 +2797,14 @@ async function streamUpsertPoints(transport, collection, docs) {
       throw new BackpressureError();
     }
     if (!response.ok) {
-      const data2 = await response.json().catch(() => ({}));
+      const data2 = await safeJsonParse(response);
       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(() => ({}));
+    const data = await safeJsonParse(response);
     return {
       message: typeof data.message === "string" ? data.message : "Stream processed",
       inserted: typeof data.inserted === "number" ? data.inserted : 0,
@@ -2534,6 +2889,10 @@ var RestBackend = class {
     this.ensureInitialized();
     return upsertBatch(buildCrudTransport(this.httpConfig), c, d);
   }
+  async upsertBatchRaw(c, d) {
+    this.ensureInitialized();
+    return upsertBatchRaw(buildRawBulkTransport(this.httpConfig), c, d, d[0]?.vector.length ?? 0);
+  }
   async delete(c, id) {
     this.ensureInitialized();
     return deletePoint(buildCrudTransport(this.httpConfig), c, id);
@@ -2599,6 +2958,22 @@ var RestBackend = class {
     this.ensureInitialized();
     return graphSearch(buildBaseTransport(this.httpConfig), c, r);
   }
+  async relate(c, req) {
+    this.ensureInitialized();
+    return relate(buildCrudTransport(this.httpConfig), c, req);
+  }
+  async unrelate(c, edgeId) {
+    this.ensureInitialized();
+    return unrelate(buildCrudTransport(this.httpConfig), c, edgeId);
+  }
+  async getRelations(c, pointId) {
+    this.ensureInitialized();
+    return getRelations(buildCrudTransport(this.httpConfig), c, pointId);
+  }
+  async setTtlDurable(c, pointId, ttlSeconds) {
+    this.ensureInitialized();
+    return setTtlDurable(buildCrudTransport(this.httpConfig), c, pointId, ttlSeconds);
+  }
   // Search
   async search(c, q, o) {
     this.ensureInitialized();
@@ -2620,6 +2995,10 @@ var RestBackend = class {
     this.ensureInitialized();
     return multiQuerySearch(buildSearchTransport(this.httpConfig), c, v, o);
   }
+  async multiQuerySearchIds(c, v, o) {
+    this.ensureInitialized();
+    return multiQuerySearchIds(buildSearchTransport(this.httpConfig), c, v, o);
+  }
   async searchIds(c, q, o) {
     this.ensureInitialized();
     return searchIds(buildSearchTransport(this.httpConfig), c, q, o);
@@ -2706,6 +3085,10 @@ var RestBackend = class {
     this.ensureInitialized();
     return trainPq(buildStreamingTransport(this.httpConfig), c, o);
   }
+  async enableStreaming(c, cfg) {
+    this.ensureInitialized();
+    return enableStreaming(buildStreamingTransport(this.httpConfig), c, cfg);
+  }
   async streamInsert(c, d) {
     this.ensureInitialized();
     return streamInsert(buildStreamingTransport(this.httpConfig), c, d);
@@ -2731,6 +3114,14 @@ var RestBackend = class {
     this.ensureInitialized();
     return recallEpisodicEvents(buildAgentMemoryTransport(this.httpConfig, (col, emb, opts) => this.search(col, emb, opts)), c, e, k);
   }
+  async recallRecentEvents(c, since) {
+    this.ensureInitialized();
+    return recallRecentEvents(buildAgentMemoryTransport(this.httpConfig, (col, emb, opts) => this.search(col, emb, opts)), c, since);
+  }
+  async recallOlderThanEvents(c, before) {
+    this.ensureInitialized();
+    return recallOlderThanEvents(buildAgentMemoryTransport(this.httpConfig, (col, emb, opts) => this.search(col, emb, opts)), c, before);
+  }
   async storeProceduralPattern(c, p) {
     this.ensureInitialized();
     return storeProceduralPattern(buildAgentMemoryTransport(this.httpConfig, (col, emb, opts) => this.search(col, emb, opts)), c, p);
@@ -2768,15 +3159,29 @@ var AgentMemoryClient = class {
   async searchFacts(collection, embedding, k = 5) {
     return this.backend.searchSemanticMemory(collection, embedding, k);
   }
-  /** Record an episodic event. Returns the generated point ID. */
+  /** Record an episodic event. Returns the point ID (string, u64-safe). */
   async recordEvent(collection, event) {
     return this.backend.recordEpisodicEvent(collection, event);
   }
-  /** Recall episodic events */
+  /** Recall episodic events by vector similarity. */
   async recallEvents(collection, embedding, k = 5) {
     return this.backend.recallEpisodicEvents(collection, embedding, k);
   }
-  /** Store a procedural pattern. Returns the generated point ID. */
+  /**
+   * Recall episodic events most-recent-first, optionally bounded below by
+   * `since` (inclusive unix-seconds). Mirrors core `episodic.recent(since)`.
+   */
+  async recallRecent(collection, since) {
+    return this.backend.recallRecentEvents(collection, since);
+  }
+  /**
+   * Recall episodic events strictly older than `before` (unix-seconds),
+   * most-recent-first. Mirrors core `episodic.older_than(before)`.
+   */
+  async recallOlderThan(collection, before) {
+    return this.backend.recallOlderThanEvents(collection, before);
+  }
+  /** Store a procedural pattern. Returns the point ID (string, u64-safe). */
   async learnProcedure(collection, pattern) {
     return this.backend.storeProceduralPattern(collection, pattern);
   }
@@ -2784,7 +3189,12 @@ var AgentMemoryClient = class {
   async recallProcedures(collection, embedding, k = 5) {
     return this.backend.matchProceduralPatterns(collection, embedding, k);
   }
-  /** Delete a memory entry (fact, event, or procedure) by its point ID. */
+  /**
+   * Delete a memory entry (fact, event, or procedure) by its point ID.
+   *
+   * Accepts the `string` ids returned by `recordEvent` / `learnProcedure`
+   * (u64-safe decimal strings) as well as numeric ids.
+   */
   async deleteMemory(collection, id) {
     return this.backend.delete(collection, id);
   }
@@ -2818,11 +3228,10 @@ function validateDocument(doc, config) {
   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})`
-    );
+  if (config.backend !== "rest") {
+    return;
   }
+  parseRestPointId(id);
 }
 
 // src/client/search-methods.ts
@@ -2862,9 +3271,21 @@ function multiQuerySearch2(backend, collection, vectors, options) {
   }
   return backend.multiQuerySearch(collection, vectors, options);
 }
+function multiQuerySearchIds2(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.multiQuerySearchIds(collection, vectors, options);
+}
 function trainPq2(backend, collection, options) {
   return backend.trainPq(collection, options);
 }
+function enableStreaming2(backend, collection, config) {
+  return backend.enableStreaming(collection, config);
+}
 function streamInsert2(backend, config, collection, docs) {
   validateDocsBatch(docs, (doc) => {
     validateDocument(doc, config);
@@ -3003,6 +3424,40 @@ function graphSearch2(backend, collection, request2) {
   requireNonEmptyString(collection, "Collection");
   return backend.graphSearch(collection, request2);
 }
+function relate2(backend, collection, req) {
+  requireNonEmptyString(collection, "Collection");
+  if (!req.relType || typeof req.relType !== "string") {
+    throw new ValidationError("Relation type is required and must be a string");
+  }
+  if (!isGraphNodeId(req.source) || !isGraphNodeId(req.target)) {
+    throw new ValidationError("Source and target must be numbers or strings");
+  }
+  return backend.relate(collection, req);
+}
+function unrelate2(backend, collection, edgeId) {
+  requireNonEmptyString(collection, "Collection");
+  if (!isGraphNodeId(edgeId)) {
+    throw new ValidationError("Edge ID must be a number or string");
+  }
+  return backend.unrelate(collection, edgeId);
+}
+function getRelations2(backend, collection, pointId) {
+  requireNonEmptyString(collection, "Collection");
+  if (!isGraphNodeId(pointId)) {
+    throw new ValidationError("Point ID must be a number or string");
+  }
+  return backend.getRelations(collection, pointId);
+}
+function setTtlDurable2(backend, collection, pointId, ttlSeconds) {
+  requireNonEmptyString(collection, "Collection");
+  if (!isGraphNodeId(pointId)) {
+    throw new ValidationError("Point ID must be a number or string");
+  }
+  if (typeof ttlSeconds !== "number" || ttlSeconds < 0) {
+    throw new ValidationError("ttlSeconds must be a non-negative number");
+  }
+  return backend.setTtlDurable(collection, pointId, ttlSeconds);
+}
 
 // src/client.ts
 var VelesDB = class {
@@ -3099,6 +3554,24 @@ var VelesDB = class {
     });
     await this.backend.upsertBatch(collection, docs);
   }
+  /**
+   * Bulk upsert via the binary wire format (REST backend only).
+   *
+   * Encodes `(id, vector)` pairs into the deterministic VRB1 binary layout
+   * and sends them as a single `application/octet-stream` request, avoiding
+   * per-point JSON overhead. Payloads are not carried — use
+   * {@link upsertBatch} when you need them. Throws a not-supported error on
+   * the WASM backend.
+   *
+   * @returns the number of points the server reports as inserted.
+   */
+  async upsertBatchRaw(collection, docs) {
+    this.ensureInitialized();
+    validateDocsBatch(docs, (doc) => {
+      validateDocument(doc, this.config);
+    });
+    return this.backend.upsertBatchRaw(collection, docs);
+  }
   async delete(collection, id) {
     this.ensureInitialized();
     validateRestPointId(id, this.config);
@@ -3146,6 +3619,11 @@ var VelesDB = class {
     this.ensureInitialized();
     return multiQuerySearch2(this.backend, collection, vectors, options);
   }
+  /** Multi-query fusion search returning only IDs and scores (no payloads). */
+  async multiQuerySearchIds(collection, vectors, options) {
+    this.ensureInitialized();
+    return multiQuerySearchIds2(this.backend, collection, vectors, options);
+  }
   /**
    * Pure sparse search against a named sparse index.
    *
@@ -3176,6 +3654,10 @@ var VelesDB = class {
     this.ensureInitialized();
     return trainPq2(this.backend, collection, options);
   }
+  async enableStreaming(collection, config) {
+    this.ensureInitialized();
+    return enableStreaming2(this.backend, collection, config);
+  }
   async streamInsert(collection, docs) {
     this.ensureInitialized();
     return streamInsert2(this.backend, this.config, collection, docs);
@@ -3300,6 +3782,22 @@ var VelesDB = class {
     this.ensureInitialized();
     return graphSearch2(this.backend, collection, request2);
   }
+  async relate(collection, req) {
+    this.ensureInitialized();
+    return relate2(this.backend, collection, req);
+  }
+  async unrelate(collection, edgeId) {
+    this.ensureInitialized();
+    return unrelate2(this.backend, collection, edgeId);
+  }
+  async getRelations(collection, pointId) {
+    this.ensureInitialized();
+    return getRelations2(this.backend, collection, pointId);
+  }
+  async setTtlDurable(collection, pointId, ttlSeconds) {
+    this.ensureInitialized();
+    return setTtlDurable2(this.backend, collection, pointId, ttlSeconds);
+  }
   // ========================================================================
   // Capabilities & Backend Info
   // ========================================================================