@wiscale/velesdb-sdk 1.17.0 → 2.0.0

package/dist/index.js

@@ -199,7 +199,7 @@ var WASM_CAPABILITIES = Object.freeze({
   agentMemory: false,
   streamInsert: false,
   pqTraining: false,
-  velesqlQuery: true,
+  velesqlQuery: false,
   collectionIntrospection: false
 });
 
@@ -437,20 +437,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
@@ -950,6 +977,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");
 }
@@ -997,6 +1030,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 {
@@ -1351,6 +1396,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);
@@ -1412,16 +1465,43 @@ 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 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 = {};
@@ -1815,16 +1895,13 @@ async function getEdgeCount(transport, collection) {
   return response.data?.count ?? 0;
 }
 async function listNodes(transport, collection) {
-  const response = await transport.requestJson(
-    "GET",
-    `${collectionPath(collection)}/graph/nodes`
-  );
+  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;
+function idToGraphId(id) {
+  return id;
 }
 async function getNodeEdges(transport, collection, nodeId, options) {
   const params = new URLSearchParams();
@@ -1835,9 +1912,9 @@ async function getNodeEdges(transport, collection, nodeId, options) {
   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),
+    id: e.id,
+    source: e.source,
+    target: e.target,
     label: e.label,
     properties: e.properties
   }));
@@ -1847,7 +1924,7 @@ async function getNodePayload(transport, collection, nodeId) {
   throwOnError(response, `Collection '${collection}'`);
   const data = response.data;
   return {
-    nodeId: idToNumber(data.node_id),
+    nodeId: idToGraphId(data.node_id),
     payload: data.payload
   };
 }
@@ -1871,7 +1948,7 @@ async function graphSearch(transport, collection, request2) {
   throwOnError(response, `Collection '${collection}'`);
   const items = (response.data?.results ?? []).map(
     (r) => ({
-      id: idToNumber(r.id),
+      id: idToGraphId(r.id),
       score: r.score,
       payload: r.payload
     })
@@ -1879,6 +1956,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;
@@ -1896,18 +1998,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`, `content`) always win and cannot be clobbered.
+          ...entry.metadata,
           _memory_type: "semantic",
-          text: entry.text,
-          ...entry.metadata
+          // `content` matches the core semantic store and the server/Python
+          // payload field (BREAKING: was `text` before this change).
+          content: entry.text
         }
       }]
     }
@@ -1918,7 +2030,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`,
@@ -1927,42 +2040,83 @@ async function recordEpisodicEvent(transport, collection, event) {
         id,
         vector: event.embedding,
         payload: {
+          // Caller-supplied data/metadata is spread first so the reserved
+          // keys below (`_memory_type`, `event_type`, `timestamp`) always
+          // win and cannot be clobbered.
+          ...event.data,
+          ...event.metadata,
           _memory_type: "episodic",
           event_type: event.eventType,
-          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-          ...event.data,
-          ...event.metadata
+          // NUMERIC unix-seconds, mirroring the core episodic store so
+          // recallRecent/recallOlderThan can range-filter on it.
+          timestamp
         }
       }]
     }
   );
   throwOnError(response);
+  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`,
     {
       points: [{
         id,
+        vector: pattern.embedding,
         payload: {
+          // Caller metadata is spread first so the reserved keys below
+          // (`_memory_type`, `name`, `steps`) always win and cannot be
+          // clobbered.
+          ...pattern.metadata,
           _memory_type: "procedural",
           name: pattern.name,
-          steps: pattern.steps,
-          ...pattern.metadata
+          steps: pattern.steps
         }
       }]
     }
   );
   throwOnError(response);
+  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) {
@@ -2112,15 +2266,29 @@ 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),
+    id: e.id,
+    source: e.source,
+    target: e.target,
     label: e.label,
     properties: e.properties
   };
 }
+function toTraverseResponse(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
+    }
+  };
+}
 async function getEdges(transport, collection, options) {
   const queryParams = options?.label ? `?label=${encodeURIComponent(options.label)}` : "";
   const response = await transport.requestJson(
@@ -2144,20 +2312,7 @@ async function traverseGraph(transport, collection, request2) {
     }
   );
   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
-    }
-  };
+  return toTraverseResponse(response.data);
 }
 async function getNodeDegree(transport, collection, nodeId) {
   const response = await transport.requestJson(
@@ -2192,21 +2347,66 @@ async function traverseParallel(transport, collection, request2) {
     }
   );
   throwOnError(response, `Collection '${collection}'`);
-  const data = response.data;
+  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 {
-    results: data.results.map((r) => ({
-      targetId: r.target_id,
-      depth: r.depth,
-      path: r.path
+    edges: raw.edges.map((e) => ({
+      id: e.id,
+      source: e.source,
+      target: e.target,
+      relType: e.rel_type,
+      properties: e.properties
     })),
-    nextCursor: data.next_cursor ?? void 0,
-    hasMore: data.has_more,
-    stats: {
-      visited: data.stats.visited,
-      depthReached: data.stats.depth_reached
-    }
+    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) {
@@ -2339,31 +2539,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;
@@ -2549,9 +2724,17 @@ async function streamInsert(transport, collection, docs) {
     }
   }
 }
+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,
@@ -2742,6 +2925,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();
@@ -2874,6 +3073,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);
@@ -2890,7 +3097,16 @@ var AgentMemoryClient = class {
     this.backend = backend;
     this.config = config;
   }
-  /** Configured embedding dimension (default: 384) */
+  /**
+   * Advisory embedding dimension passed at construction (default: 384).
+   *
+   * This value is **not** enforced and does not create or size any
+   * collection — the dimension that actually governs storage and search
+   * is the one fixed when the collection was created
+   * (`db.createCollection(name, { dimension, metric: 'cosine' })`).
+   * Embeddings you pass to `storeFact` / `recordEvent` / `learnProcedure`
+   * must match that collection dimension.
+   */
   get dimension() {
     return this.config?.dimension ?? 384;
   }
@@ -2902,15 +3118,29 @@ var AgentMemoryClient = class {
   async searchFacts(collection, embedding, k = 5) {
     return this.backend.searchSemanticMemory(collection, embedding, k);
   }
-  /** Record an episodic event */
+  /** 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 */
+  /**
+   * 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);
   }
@@ -2918,6 +3148,15 @@ 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.
+   *
+   * 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);
+  }
 };
 
 // src/client/validation.ts
@@ -2948,11 +3187,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
@@ -3057,12 +3295,15 @@ function aggregate2(backend, queryString, params, options) {
 }
 
 // src/client/graph-methods.ts
+function isGraphNodeId(value) {
+  return typeof value === "number" || typeof value === "string";
+}
 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");
+  if (!isGraphNodeId(edge.source) || !isGraphNodeId(edge.target)) {
+    throw new ValidationError("Edge source and target must be numbers or strings");
   }
   return backend.addEdge(collection, edge);
 }
@@ -3070,8 +3311,8 @@ 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 (!isGraphNodeId(request2.source)) {
+    throw new ValidationError("Source node ID must be a number or string");
   }
   if (request2.strategy && !["bfs", "dfs"].includes(request2.strategy)) {
     throw new ValidationError("Strategy must be 'bfs' or 'dfs'");
@@ -3082,6 +3323,9 @@ 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");
   }
+  if (!request2.sources.every(isGraphNodeId)) {
+    throw new ValidationError("Source node IDs must be numbers or strings");
+  }
   return backend.traverseParallel(collection, request2);
 }
 function getNodeDegree2(backend, collection, nodeId) {
@@ -3127,6 +3371,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 {
@@ -3424,6 +3702,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
   // ========================================================================