@nicia-ai/typegraph 0.34.0 → 0.36.0

package/dist/{chunk-A7SZZFAG.js → chunk-5VTR2F2K.js}

@@ -1,10 +1,9 @@
-import { createBackendOverlay, isPresent, groupBy, chunk, sqlValueList } from './chunk-V3QNTB7Z.js';
-import { validateCanonicalIsoDate, nowIso } from './chunk-XXVEULWX.js';
-import { withRecordedRelationsPrecondition } from './chunk-2MRAX3UE.js';
-import { sqlNull } from './chunk-GZCNZ7QW.js';
-import { MAX_PG_IDENTIFIER_LENGTH } from './chunk-2EBMPJBO.js';
-import { resolveEmbeddingFields, getSearchableMetadata, DEFAULT_SEARCHABLE_LANGUAGE } from './chunk-Z5XBMDXU.js';
-import { ConfigurationError, ValidationError, CardinalityError, EndpointError, DisjointError, UniquenessError, RestrictedDeleteError } from './chunk-TQOYM4LN.js';
+import { asCompiledRowsSql, asCompiledStatementSql } from './chunk-UT3S4SEN.js';
+import { createBackendOverlay, isPresent, rowPropsToObject, groupBy, chunk, sqlValueList, rowPropsToJsonText } from './chunk-IU46OHVW.js';
+import { validateCanonicalIsoDate, withRecordedRelationsPrecondition, nowIso } from './chunk-JFUPDJXD.js';
+import { MAX_PG_IDENTIFIER_LENGTH, sqlNull } from './chunk-OHMP6N2J.js';
+import { resolveEmbeddingFields, getSearchableFields, DEFAULT_SEARCHABLE_LANGUAGE } from './chunk-KBGQIPRQ.js';
+import { ConfigurationError, ValidationError, CardinalityError, EndpointError, DisjointError, UniquenessError, RestrictedDeleteError } from './chunk-WI7ISNQF.js';
 import { sql } from 'drizzle-orm';
 import { nanoid } from 'nanoid';
 
@@ -95,17 +94,6 @@ function coordinateContext(coordinate) {
     ...coordinate.recorded === void 0 ? {} : { recordedAsOf: coordinate.recorded.asOf }
   };
 }
-
-// src/query/sql-intent.ts
-function asCompiledRowsSql(query) {
-  return query;
-}
-function asCompiledSelectSql(query) {
-  return asCompiledRowsSql(query);
-}
-function asCompiledStatementSql(query) {
-  return query;
-}
 var SqlSchemaDescriptor = class {
   // Private field gives SqlSchema nominal identity; runtime checks use instanceof.
   #brand = true;
@@ -115,6 +103,7 @@ var SqlSchemaDescriptor = class {
   recordedNodesTable;
   recordedEdgesTable;
   recordedClockTable;
+  revisionOriginsTable;
   fulltextTable;
   constructor(fields) {
     this.tables = fields.tables;
@@ -123,6 +112,7 @@ var SqlSchemaDescriptor = class {
     this.recordedNodesTable = fields.recordedNodesTable;
     this.recordedEdgesTable = fields.recordedEdgesTable;
     this.recordedClockTable = fields.recordedClockTable;
+    this.revisionOriginsTable = fields.revisionOriginsTable;
     this.fulltextTable = fields.fulltextTable;
     void this.#brand;
     Object.freeze(this);
@@ -134,6 +124,7 @@ var DEFAULT_TABLE_NAMES = {
   recordedNodes: "typegraph_recorded_nodes",
   recordedEdges: "typegraph_recorded_edges",
   recordedClock: "typegraph_recorded_clock",
+  revisionOrigins: "typegraph_revision_origins",
   fulltext: "typegraph_node_fulltext",
   uniques: "typegraph_node_uniques"
 };
@@ -144,6 +135,7 @@ function resolveTableNames(names) {
     recordedNodes: names.recordedNodes ?? DEFAULT_TABLE_NAMES.recordedNodes,
     recordedEdges: names.recordedEdges ?? DEFAULT_TABLE_NAMES.recordedEdges,
     recordedClock: names.recordedClock ?? DEFAULT_TABLE_NAMES.recordedClock,
+    revisionOrigins: names.revisionOrigins ?? DEFAULT_TABLE_NAMES.revisionOrigins,
     fulltext: names.fulltext ?? DEFAULT_TABLE_NAMES.fulltext,
     uniques: names.uniques ?? DEFAULT_TABLE_NAMES.uniques
   };
@@ -190,6 +182,7 @@ function createSqlSchema(names = {}) {
   validateTableName(tables.recordedNodes, "recordedNodes");
   validateTableName(tables.recordedEdges, "recordedEdges");
   validateTableName(tables.recordedClock, "recordedClock");
+  validateTableName(tables.revisionOrigins, "revisionOrigins");
   validateTableName(tables.fulltext, "fulltext");
   validateTableName(tables.uniques, "uniques");
   return freezeSqlSchema({
@@ -199,6 +192,7 @@ function createSqlSchema(names = {}) {
     recordedNodesTable: sql.raw(quoteIdentifier(tables.recordedNodes)),
     recordedEdgesTable: sql.raw(quoteIdentifier(tables.recordedEdges)),
     recordedClockTable: sql.raw(quoteIdentifier(tables.recordedClock)),
+    revisionOriginsTable: sql.raw(quoteIdentifier(tables.revisionOrigins)),
     fulltextTable: sql.raw(quoteIdentifier(tables.fulltext))
   });
 }
@@ -279,6 +273,7 @@ function recordedReadSqlSchema(binding) {
     recordedNodesTable: schema.recordedNodesTable,
     recordedEdgesTable: schema.recordedEdgesTable,
     recordedClockTable: schema.recordedClockTable,
+    revisionOriginsTable: schema.revisionOriginsTable,
     fulltextTable: schema.fulltextTable
   });
 }
@@ -360,10 +355,13 @@ async function assertRecordedCaptureTransactionIsolation(target) {
   if (isSupportedRecordedIsolationLevel(isolationLevel)) return;
   throw unsupportedPostgresIsolationError(isolationLevel);
 }
-function recordedCaptureRequiresCallbackTransactionError(details) {
+function recordedCaptureRequiresCallbackTransactionError(details = {}) {
   return new ConfigurationError(
     "withTransaction() has no recorded-time capture flush point when history is enabled.",
-    details,
+    {
+      ...details,
+      code: "RECORDED_CAPTURE_REQUIRES_CALLBACK_TRANSACTION"
+    },
     {
       suggestion: "Use store.withRecordedTransaction(externalTx, async (tx) => ...) so TypeGraph can flush capture before the caller commits."
     }
@@ -372,50 +370,72 @@ function recordedCaptureRequiresCallbackTransactionError(details) {
 function historyUnsafeRawWriteError(surface) {
   return new ConfigurationError(
     `${surface} is not available when history capture is enabled because raw SQL writes bypass recorded-time capture.`,
-    { code: "RECORDED_CAPTURE_RAW_SQL_DISABLED" },
+    {
+      code: "RECORDED_CAPTURE_RAW_SQL_DISABLED"
+    },
     {
       suggestion: "Run graph writes through store.nodes/store.edges (or tx.nodes/tx.edges inside a transaction), or perform raw relational writes outside a history-enabled TypeGraph store."
     }
   );
 }
+function revisionTrackingUnsafeRawWriteError(surface) {
+  return new ConfigurationError(
+    `${surface} is not available when revision tracking is enabled because raw SQL writes bypass the revision anchor.`,
+    {
+      code: "REVISION_TRACKING_RAW_SQL_DISABLED"
+    },
+    {
+      suggestion: "Run graph writes through store.nodes/store.edges (or tx.nodes/tx.edges inside a transaction), so TypeGraph can advance the revision anchor."
+    }
+  );
+}
 function failHistoryUnsafeSqlRef() {
   throw historyUnsafeRawWriteError("tx.sql");
 }
+function failRevisionTrackingUnsafeSqlRef() {
+  throw revisionTrackingUnsafeRawWriteError("tx.sql");
+}
 function createHistoryUnsafeSqlRef() {
+  return createUnsafeSqlRef(failHistoryUnsafeSqlRef);
+}
+function createRevisionTrackingUnsafeSqlRef() {
+  return createUnsafeSqlRef(failRevisionTrackingUnsafeSqlRef);
+}
+function createUnsafeSqlRef(fail) {
   return new Proxy(
-    function historyUnsafeSqlRef() {
-      return failHistoryUnsafeSqlRef();
+    function unsafeSqlRef() {
+      return fail();
     },
     {
       get() {
-        return failHistoryUnsafeSqlRef();
+        return fail();
       },
       apply() {
-        return failHistoryUnsafeSqlRef();
+        return fail();
       },
       set() {
-        return failHistoryUnsafeSqlRef();
+        return fail();
       },
       defineProperty() {
-        return failHistoryUnsafeSqlRef();
+        return fail();
       },
       deleteProperty() {
-        return failHistoryUnsafeSqlRef();
+        return fail();
       },
       // Enumeration / inspection traps too, so spreading (`{...tx.sql}`),
       // `Object.keys`, `in`, and prototype reads also fail loudly rather than
       // silently yielding an empty object that reads as "no raw handle".
       has() {
-        return failHistoryUnsafeSqlRef();
+        return fail();
       },
       ownKeys() {
-        return failHistoryUnsafeSqlRef();
+        return fail();
       },
       getOwnPropertyDescriptor() {
-        return failHistoryUnsafeSqlRef();
+        return fail();
       },
       getPrototypeOf() {
-        return failHistoryUnsafeSqlRef();
+        return fail();
       }
     }
   );
@@ -476,6 +496,44 @@ function assertCapturableBackend(backend) {
     );
   }
 }
+function assertRevisionTrackableBackend(backend) {
+  if (!backend.capabilities.transactions) {
+    throw new ConfigurationError(
+      "revisionTracking: true requires a backend with transaction support.",
+      { dialect: backend.dialect },
+      {
+        suggestion: "Use a transactional SQLite/PostgreSQL backend or leave revision tracking disabled."
+      }
+    );
+  }
+  if (backend.executeStatement === void 0) {
+    throw new ConfigurationError(
+      "revisionTracking: true requires a backend that supports executeStatement.",
+      { dialect: backend.dialect },
+      {
+        suggestion: "Use a built-in SQLite/PostgreSQL backend, or implement executeStatement so TypeGraph can advance the revision clock."
+      }
+    );
+  }
+  if (backend.tableNames === void 0) {
+    throw new ConfigurationError(
+      "revisionTracking: true requires a backend that exposes tableNames.",
+      { dialect: backend.dialect },
+      {
+        suggestion: "Use a built-in SQLite/PostgreSQL backend, or set tableNames so TypeGraph can address the revision clock relation."
+      }
+    );
+  }
+  if (backend.ensureRevisionOriginsTable === void 0) {
+    throw new ConfigurationError(
+      "revisionTracking: true requires a backend that can bootstrap revision origins.",
+      { dialect: backend.dialect },
+      {
+        suggestion: "Use a built-in SQLite/PostgreSQL backend, or implement ensureRevisionOriginsTable so TypeGraph can durably namespace revision anchors."
+      }
+    );
+  }
+}
 
 // src/store/recorded-capture/clock.ts
 var RECORDED_MIN = "1970-01-01T00:00:00.000Z";
@@ -506,19 +564,37 @@ function graphWriteLockEvidence() {
 function uncapturedGraphWriteLock() {
   return graphWriteLockEvidence();
 }
-async function lockRecordedGraphWrite(target, graphId) {
-  if (target.dialect !== "postgres") return graphWriteLockEvidence();
+function createRecordedGraphLockMemo() {
+  return /* @__PURE__ */ new Map();
+}
+var recordedGraphLockMemos = /* @__PURE__ */ new WeakMap();
+function registerRecordedGraphLockMemo(backend, memo) {
+  recordedGraphLockMemos.set(backend, memo);
+}
+async function acquireRecordedGraphWriteLock(target, graphId) {
   await target.execute(
     asCompiledRowsSql(recordedGraphWriteAdvisoryLockSql(graphId))
   );
-  return graphWriteLockEvidence();
 }
-async function lockRecordedGraphWrites(target, graphIds) {
-  if (target.dialect !== "postgres") return;
-  const uniqueGraphIds = [...new Set(graphIds)].toSorted();
-  for (const graphId of uniqueGraphIds) {
-    await lockRecordedGraphWrite(target, graphId);
+async function lockRecordedGraphWrite(target, graphId, memo) {
+  if (target.dialect !== "postgres") return graphWriteLockEvidence();
+  const effectiveMemo = memo ?? recordedGraphLockMemos.get(target);
+  if (effectiveMemo === void 0) {
+    await acquireRecordedGraphWriteLock(target, graphId);
+    return graphWriteLockEvidence();
+  }
+  let pending = effectiveMemo.get(graphId);
+  if (pending === void 0) {
+    pending = acquireRecordedGraphWriteLock(target, graphId).catch(
+      (error) => {
+        effectiveMemo.delete(graphId);
+        throw error;
+      }
+    );
+    effectiveMemo.set(graphId, pending);
   }
+  await pending;
+  return graphWriteLockEvidence();
 }
 function failInvalidClockTimestamp(value) {
   throw new ConfigurationError(
@@ -574,6 +650,53 @@ async function readRecordedClock(target, schema, graphId) {
   const first = rows[0];
   return first === void 0 ? void 0 : toCanonicalIso(first.recorded_at);
 }
+async function readRevisionOrigin(target, schema, graphId) {
+  const rows = await target.execute(
+    asCompiledRowsSql(sql`
+      SELECT origin
+      FROM ${schema.revisionOriginsTable}
+      WHERE graph_id = ${graphId}
+    `)
+  );
+  const first = rows[0];
+  if (first === void 0) return void 0;
+  if (typeof first.origin !== "string" || first.origin.length === 0) {
+    throw new ConfigurationError(
+      "Revision origin row contained an invalid origin",
+      { graphId, origin: first.origin }
+    );
+  }
+  return first.origin;
+}
+async function ensureRevisionOrigin(target, schema, graphId) {
+  const ensureTable = target.ensureRevisionOriginsTable;
+  if (ensureTable === void 0) {
+    throw new ConfigurationError(
+      "Revision tracking requires a backend that can bootstrap revision origins.",
+      { dialect: target.dialect },
+      {
+        suggestion: "Use a built-in SQLite/PostgreSQL backend, or implement ensureRevisionOriginsTable on the custom backend."
+      }
+    );
+  }
+  await ensureTable();
+  const existing = await readRevisionOrigin(target, schema, graphId);
+  if (existing !== void 0) return existing;
+  await executeStatement(
+    target,
+    sql`
+      INSERT INTO ${schema.revisionOriginsTable} (graph_id, origin)
+      VALUES (${graphId}, ${generateId()})
+      ON CONFLICT (graph_id) DO NOTHING
+    `
+  );
+  const origin = await readRevisionOrigin(target, schema, graphId);
+  if (origin !== void 0) return origin;
+  throw new ConfigurationError(
+    "Revision origin was not persisted after initialization.",
+    { graphId, dialect: target.dialect }
+  );
+}
 async function writeRecordedClock(target, schema, graphId, recordedAt) {
   await executeStatement(
     target,
@@ -601,9 +724,9 @@ async function lockRecordedClock(target, schema, graphId, ownsWriteLock) {
     `
   );
 }
-async function allocateRecordedCommit(target, schema, graphId, ownsWriteLock) {
+async function allocateRecordedCommit(target, schema, graphId, ownsWriteLock, previousRevision) {
   await lockRecordedClock(target, schema, graphId, ownsWriteLock);
-  const previous = await readRecordedClock(target, schema, graphId);
+  const previous = previousRevision ?? await readRecordedClock(target, schema, graphId);
   const recordedCommitTime = nextRecordedCommitTime(previous);
   if (!Number.isFinite(recordedCommitTime) || recordedCommitTime >= RECORDED_MAX_TIME) {
     throw new ConfigurationError(
@@ -618,6 +741,15 @@ async function allocateRecordedCommit(target, schema, graphId, ownsWriteLock) {
   await writeRecordedClock(target, schema, graphId, recordedCommit);
   return recordedCommit;
 }
+async function advanceRevisionClock(target, schema, graphId, ownsWriteLock, previousRevision) {
+  return allocateRecordedCommit(
+    target,
+    schema,
+    graphId,
+    ownsWriteLock,
+    previousRevision
+  );
+}
 
 // src/store/insert-dispatch.ts
 function nodeInsertDispatch(backend) {
@@ -767,7 +899,7 @@ function recordedCommonCells() {
     graph_id: (row) => sql`${row.graph_id}`,
     id: (row) => sql`${row.id}`,
     kind: (row) => sql`${row.kind}`,
-    props: (row) => sql`${row.props}`,
+    props: (row) => sql`${rowPropsToJsonText(row.props)}`,
     valid_from: (row) => sql`${sqlNull(row.valid_from)}`,
     valid_to: (row) => sql`${sqlNull(row.valid_to)}`,
     created_at: (row) => sql`${row.created_at}`,
@@ -1028,6 +1160,21 @@ async function queryConnectedEdgeIds(target, schema, params) {
 }
 
 // src/store/recorded-capture.ts
+var RECORDED_FLUSH_OBSERVER = /* @__PURE__ */ Symbol("typegraph.recordedFlushObserver");
+function readRecordedFlushObserver(options) {
+  return options?.[RECORDED_FLUSH_OBSERVER];
+}
+function stripRecordedFlushObserver(options) {
+  if (options === void 0) return void 0;
+  const { [RECORDED_FLUSH_OBSERVER]: _observer, ...backendOptions } = options;
+  return backendOptions;
+}
+function withRecordedFlushObserver(options, observer) {
+  return {
+    ...stripRecordedFlushObserver(options),
+    [RECORDED_FLUSH_OBSERVER]: observer
+  };
+}
 function nodeIdentityKey(graphId, kind, id) {
   return `${graphId}\0${kind}\0${id}`;
 }
@@ -1046,22 +1193,32 @@ function edgeParamsIdentityKey(params) {
 function edgeRowIdentityKey(row) {
   return edgeIdentityKey(row.graph_id, row.id);
 }
+function recordedCaptureSealedError(details) {
+  return new ConfigurationError(
+    "Recorded-time capture session is sealed: a graph write happened after the transaction's capture was flushed.",
+    details,
+    {
+      suggestion: "Perform all writes inside the withRecordedTransaction callback; do not reuse the transaction context after it returns."
+    }
+  );
+}
 function createRecordedCaptureSession() {
   const touched = /* @__PURE__ */ new Map();
   let sealed = false;
   function touch(entity) {
     if (sealed) {
-      throw new ConfigurationError(
-        "Recorded-time capture session is sealed: a graph write happened after the transaction's capture was flushed.",
-        { entity: entity.entity, graphId: entity.graphId, id: entity.id },
-        {
-          suggestion: "Perform all writes inside the withRecordedTransaction callback; do not reuse the transaction context after it returns."
-        }
-      );
+      throw recordedCaptureSealedError({
+        entity: entity.entity,
+        graphId: entity.graphId,
+        id: entity.id
+      });
     }
     touched.set(entityKey(entity), entity);
   }
   return {
+    assertOpen() {
+      if (sealed) throw recordedCaptureSealedError({});
+    },
     touchNode(graphId, kind, id, afterImage) {
       touch({ entity: "node", graphId, kind, id, afterImage });
     },
@@ -1079,7 +1236,8 @@ function createRecordedCaptureSession() {
         );
       }
       sealed = true;
-      if (touched.size === 0) return;
+      if (touched.size === 0) return /* @__PURE__ */ new Map();
+      const recordedByGraph = /* @__PURE__ */ new Map();
       const byGraph = groupBy(touched.values(), (entity) => entity.graphId);
       for (const [graphId, entities] of byGraph) {
         const recordedCommit = await allocateRecordedCommit(
@@ -1088,6 +1246,7 @@ function createRecordedCaptureSession() {
           graphId,
           ownsWriteLock
         );
+        recordedByGraph.set(graphId, recordedCommit);
         const nodes = entities.filter(
           (entity) => entity.entity === "node"
         );
@@ -1098,24 +1257,29 @@ function createRecordedCaptureSession() {
         await flushEdges(target, schema, graphId, edges, recordedCommit);
       }
       touched.clear();
+      return recordedByGraph;
     }
   };
 }
 function createRecordedTransactionBackend(target, session, schema) {
   const nodeDispatch = nodeInsertDispatch(target);
   const edgeDispatch = edgeInsertDispatch(target);
+  const graphLocks = createRecordedGraphLockMemo();
   async function lockGraph(graphId) {
-    await lockRecordedGraphWrite(target, graphId);
+    await lockRecordedGraphWrite(target, graphId, graphLocks);
   }
   async function lockGraphs(params) {
-    await lockRecordedGraphWrites(
-      target,
-      params.map((parameter) => parameter.graphId)
-    );
+    const graphIds = [
+      ...new Set(params.map((parameter) => parameter.graphId))
+    ].toSorted();
+    for (const graphId of graphIds) {
+      await lockRecordedGraphWrite(target, graphId, graphLocks);
+    }
   }
-  return createBackendOverlay(target, {
+  const overlay = createBackendOverlay(target, {
     ...rawWriteGuards(target, "tx.backend"),
     async insertNode(params) {
+      session.assertOpen();
       await lockGraph(params.graphId);
       const row = await target.insertNode(params);
       session.touchNode(params.graphId, params.kind, params.id, row);
@@ -1123,6 +1287,7 @@ function createRecordedTransactionBackend(target, session, schema) {
     },
     ...target.insertNodeNoReturn === void 0 ? {} : {
       async insertNodeNoReturn(params) {
+        session.assertOpen();
         await lockGraph(params.graphId);
         await runInsertNoReturn(nodeDispatch, params);
         session.touchNode(params.graphId, params.kind, params.id);
@@ -1130,6 +1295,7 @@ function createRecordedTransactionBackend(target, session, schema) {
     },
     ...target.insertNodesBatch === void 0 ? {} : {
       async insertNodesBatch(params) {
+        session.assertOpen();
         await lockGraphs(params);
         await runInsertBatch(nodeDispatch, params);
         for (const node of params) {
@@ -1139,6 +1305,7 @@ function createRecordedTransactionBackend(target, session, schema) {
     },
     ...target.insertNodesBatchReturning === void 0 ? {} : {
       async insertNodesBatchReturning(params) {
+        session.assertOpen();
         await lockGraphs(params);
         const rows = await runInsertBatchReturning(nodeDispatch, params);
         const rowsByIdentity = new Map(
@@ -1156,17 +1323,20 @@ function createRecordedTransactionBackend(target, session, schema) {
       }
     },
     async updateNode(params) {
+      session.assertOpen();
       await lockGraph(params.graphId);
       const row = await target.updateNode(params);
       session.touchNode(params.graphId, params.kind, params.id, row);
       return row;
     },
     async deleteNode(params) {
+      session.assertOpen();
       await lockGraph(params.graphId);
       await target.deleteNode(params);
       session.touchNode(params.graphId, params.kind, params.id);
     },
     async hardDeleteNode(params) {
+      session.assertOpen();
       await lockGraph(params.graphId);
       const connectedEdgeIds = await queryConnectedEdgeIds(
         target,
@@ -1180,6 +1350,7 @@ function createRecordedTransactionBackend(target, session, schema) {
       }
     },
     async insertEdge(params) {
+      session.assertOpen();
       await lockGraph(params.graphId);
       const row = await target.insertEdge(params);
       session.touchEdge(params.graphId, params.id, row);
@@ -1187,6 +1358,7 @@ function createRecordedTransactionBackend(target, session, schema) {
     },
     ...target.insertEdgeNoReturn === void 0 ? {} : {
       async insertEdgeNoReturn(params) {
+        session.assertOpen();
         await lockGraph(params.graphId);
         await runInsertNoReturn(edgeDispatch, params);
         session.touchEdge(params.graphId, params.id);
@@ -1194,6 +1366,7 @@ function createRecordedTransactionBackend(target, session, schema) {
     },
     ...target.insertEdgesBatch === void 0 ? {} : {
       async insertEdgesBatch(params) {
+        session.assertOpen();
         await lockGraphs(params);
         await runInsertBatch(edgeDispatch, params);
         for (const edge of params) {
@@ -1203,6 +1376,7 @@ function createRecordedTransactionBackend(target, session, schema) {
     },
     ...target.insertEdgesBatchReturning === void 0 ? {} : {
       async insertEdgesBatchReturning(params) {
+        session.assertOpen();
         await lockGraphs(params);
         const rows = await runInsertBatchReturning(edgeDispatch, params);
         const rowsByIdentity = new Map(
@@ -1219,22 +1393,47 @@ function createRecordedTransactionBackend(target, session, schema) {
       }
     },
     async updateEdge(params) {
+      session.assertOpen();
       await lockGraph(params.graphId);
       const row = await target.updateEdge(params);
       session.touchEdge(params.graphId, params.id, row);
       return row;
     },
     async deleteEdge(params) {
+      session.assertOpen();
       await lockGraph(params.graphId);
       await target.deleteEdge(params);
       session.touchEdge(params.graphId, params.id);
     },
     async hardDeleteEdge(params) {
+      session.assertOpen();
       await lockGraph(params.graphId);
       await target.hardDeleteEdge(params);
       session.touchEdge(params.graphId, params.id);
+    },
+    ...target.deleteEdgesBatch === void 0 ? {} : {
+      async deleteEdgesBatch(params) {
+        session.assertOpen();
+        await lockGraph(params.graphId);
+        await target.deleteEdgesBatch(params);
+        for (const id of params.ids) {
+          session.touchEdge(params.graphId, id);
+        }
+      }
+    },
+    ...target.hardDeleteEdgesBatch === void 0 ? {} : {
+      async hardDeleteEdgesBatch(params) {
+        session.assertOpen();
+        await lockGraph(params.graphId);
+        await target.hardDeleteEdgesBatch(params);
+        for (const id of params.ids) {
+          session.touchEdge(params.graphId, id);
+        }
+      }
     }
   });
+  registerRecordedGraphLockMemo(overlay, graphLocks);
+  return overlay;
 }
 function createRecordedTransactionScope(target, schema, ownsWriteLock = false) {
   requireCaptureStatements(target);
@@ -1243,7 +1442,7 @@ function createRecordedTransactionScope(target, schema, ownsWriteLock = false) {
   return {
     backend: createRecordedTransactionBackend(target, session, resolvedSchema),
     async flush() {
-      await withRecordedRelationsPrecondition(
+      return withRecordedRelationsPrecondition(
         session.flush(target, resolvedSchema, ownsWriteLock),
         { dialect: target.dialect, surface: "capture-flush" }
       );
@@ -1331,15 +1530,28 @@ function createRecordedBackend(backend, schema) {
     async hardDeleteEdge(params) {
       await capture((target) => target.hardDeleteEdge(params));
     },
+    ...backend.deleteEdgesBatch === void 0 ? {} : {
+      async deleteEdgesBatch(params) {
+        await capture((target) => target.deleteEdgesBatch(params));
+      }
+    },
+    ...backend.hardDeleteEdgesBatch === void 0 ? {} : {
+      async hardDeleteEdgesBatch(params) {
+        await capture((target) => target.hardDeleteEdgesBatch(params));
+      }
+    },
     async transaction(fn, options) {
-      assertRequestedRecordedIsolation(backend, options);
+      const observer = readRecordedFlushObserver(options);
+      const backendOptions = stripRecordedFlushObserver(options);
+      assertRequestedRecordedIsolation(backend, backendOptions);
       return backend.transaction(async (target) => {
         await assertRecordedCaptureTransactionIsolation(target);
         const scope = createRecordedTransactionScope(target, schema, true);
         const result = await fn(scope.backend, createHistoryUnsafeSqlRef());
-        await scope.flush();
+        const instants = await scope.flush();
+        observer?.(instants);
         return result;
-      }, options);
+      }, backendOptions);
     },
     ...backend.adoptTransaction === void 0 ? {} : {
       adoptTransaction(externalTx) {
@@ -1395,6 +1607,65 @@ async function syncEmbeddings(ctx, schema, props) {
     }
   }
 }
+async function syncEmbeddingsBatchForKind(args, schema, items) {
+  const { graphId, nodeKind, backend } = args;
+  if (!backend.upsertEmbedding || !backend.deleteEmbedding) {
+    return;
+  }
+  const embeddingFields = getEmbeddingFields(schema);
+  if (embeddingFields.length === 0) {
+    return;
+  }
+  for (const field of embeddingFields) {
+    const rows = [];
+    const deletionIds = [];
+    for (const item of items) {
+      const value = item.props[field.fieldPath];
+      if (isValidEmbeddingValue(value)) {
+        rows.push({ nodeId: item.nodeId, embedding: value });
+      } else if (value === void 0) {
+        deletionIds.push(item.nodeId);
+      }
+    }
+    if (rows.length > 0) {
+      if (backend.upsertEmbeddingBatch === void 0) {
+        for (const row of rows) {
+          await backend.upsertEmbedding({
+            graphId,
+            nodeKind,
+            nodeId: row.nodeId,
+            fieldPath: field.fieldPath,
+            embedding: row.embedding,
+            dimensions: field.dimensions,
+            metric: field.metric,
+            indexType: field.indexType
+          });
+        }
+      } else {
+        await backend.upsertEmbeddingBatch({
+          graphId,
+          nodeKind,
+          fieldPath: field.fieldPath,
+          dimensions: field.dimensions,
+          metric: field.metric,
+          indexType: field.indexType,
+          rows
+        });
+      }
+    }
+    for (const nodeId of deletionIds) {
+      await backend.deleteEmbedding({
+        graphId,
+        nodeKind,
+        nodeId,
+        fieldPath: field.fieldPath,
+        dimensions: field.dimensions,
+        metric: field.metric,
+        indexType: field.indexType
+      });
+    }
+  }
+}
 async function deleteNodeEmbeddings(ctx, schema) {
   const { backend } = ctx;
   if (!backend.deleteEmbedding) {
@@ -1424,42 +1695,6 @@ function isValidEmbeddingValue(value) {
 }
 
 // src/store/fulltext-sync.ts
-var searchableFieldsCache = /* @__PURE__ */ new WeakMap();
-function getSearchableFields(schema) {
-  const cached = searchableFieldsCache.get(schema);
-  if (cached) return cached;
-  const fields = computeSearchableFields(schema);
-  searchableFieldsCache.set(schema, fields);
-  return fields;
-}
-function computeSearchableFields(schema) {
-  if (schema.type !== "object") return [];
-  const def = schema.def;
-  const shape = def.shape;
-  if (!shape) return [];
-  const fields = [];
-  for (const [fieldPath, fieldSchema] of Object.entries(shape)) {
-    const metadata = getSearchableMetadata(fieldSchema);
-    if (metadata !== void 0) {
-      fields.push({ fieldPath, metadata });
-    }
-  }
-  warnIfConflictingLanguages(fields);
-  return fields;
-}
-function warnIfConflictingLanguages(fields) {
-  if (fields.length < 2) return;
-  const languages = new Set(fields.map((field) => field.metadata.language));
-  if (languages.size < 2) return;
-  if (typeof console === "undefined" || typeof console.warn !== "function") {
-    return;
-  }
-  const fieldSummary = fields.map((field) => `${field.fieldPath}=${field.metadata.language}`).join(", ");
-  const winning = fields[0]?.metadata.language ?? DEFAULT_SEARCHABLE_LANGUAGE;
-  console.warn(
-    `[typegraph] searchable() fields declare conflicting languages (${fieldSummary}). The first field's language ("${winning}") is recorded on the fulltext row; true multilingual indexing requires a dedicated node kind per language.`
-  );
-}
 var FIELD_SEPARATOR = "\n";
 function resolveCombinedLanguage(fields) {
   return fields[0]?.metadata.language ?? DEFAULT_SEARCHABLE_LANGUAGE;
@@ -1503,6 +1738,55 @@ async function syncFulltext(ctx, schema, props) {
     nodeId: ctx.nodeId
   });
 }
+async function syncFulltextBatchForKind(args, schema, items) {
+  const { graphId, nodeKind, backend } = args;
+  if (!backend.upsertFulltext || !backend.deleteFulltext) {
+    return;
+  }
+  const rows = [];
+  const emptyContentIds = [];
+  const hasSearchableFields = getSearchableFields(schema).length > 0;
+  for (const item of items) {
+    const computed = computeFulltextContent(schema, item.props);
+    if (computed !== void 0) {
+      rows.push({
+        nodeId: item.nodeId,
+        content: computed.content,
+        language: computed.language
+      });
+    } else if (hasSearchableFields) {
+      emptyContentIds.push(item.nodeId);
+    }
+  }
+  if (rows.length > 0) {
+    if (backend.upsertFulltextBatch === void 0) {
+      for (const row of rows) {
+        await backend.upsertFulltext({
+          graphId,
+          nodeKind,
+          nodeId: row.nodeId,
+          content: row.content,
+          language: row.language
+        });
+      }
+    } else {
+      await backend.upsertFulltextBatch({ graphId, nodeKind, rows });
+    }
+  }
+  if (emptyContentIds.length > 0) {
+    if (backend.deleteFulltextBatch === void 0) {
+      for (const nodeId of emptyContentIds) {
+        await backend.deleteFulltext({ graphId, nodeKind, nodeId });
+      }
+    } else {
+      await backend.deleteFulltextBatch({
+        graphId,
+        nodeKind,
+        nodeIds: emptyContentIds
+      });
+    }
+  }
+}
 async function deleteNodeFulltext(ctx, schema) {
   const { backend } = ctx;
   if (!backend.deleteFulltext) {
@@ -1640,10 +1924,7 @@ function checkUniqueEdge(edgeKind, fromKind, fromId, _toKind, _toId, existingCou
 }
 function validateEdgeEndpoints(edgeKind, fromKind, toKind, registration, registry) {
   const validFromKinds = registration.from.map((node) => node.kind);
-  const fromValid = validFromKinds.some(
-    (validKind) => registry.isAssignableTo(fromKind, validKind)
-  );
-  if (!fromValid) {
+  if (!registry.isAssignableToAny(fromKind, validFromKinds)) {
     return new EndpointError({
       edgeKind,
       endpoint: "from",
@@ -1652,10 +1933,7 @@ function validateEdgeEndpoints(edgeKind, fromKind, toKind, registration, registr
     });
   }
   const validToKinds = registration.to.map((node) => node.kind);
-  const toValid = validToKinds.some(
-    (validKind) => registry.isAssignableTo(toKind, validKind)
-  );
-  if (!toValid) {
+  if (!registry.isAssignableToAny(toKind, validToKinds)) {
     return new EndpointError({
       edgeKind,
       endpoint: "to",
@@ -1736,6 +2014,36 @@ async function insertUniquenessEntries(ctx, kind, id, props, constraints) {
     });
   }
 }
+async function insertUniquenessEntriesBatch(ctx, items) {
+  const entries = [];
+  for (const item of items) {
+    for (const constraint of item.constraints) {
+      if (!checkWherePredicate(constraint, item.props)) {
+        continue;
+      }
+      entries.push({
+        graphId: ctx.graphId,
+        nodeKind: item.kind,
+        constraintName: constraint.name,
+        key: computeUniqueKey(
+          item.props,
+          constraint.fields,
+          constraint.collation
+        ),
+        nodeId: item.id,
+        concreteKind: item.kind
+      });
+    }
+  }
+  if (entries.length === 0) return;
+  if (ctx.backend.insertUniqueBatch !== void 0) {
+    await ctx.backend.insertUniqueBatch(entries);
+    return;
+  }
+  for (const entry of entries) {
+    await ctx.backend.insertUnique(entry);
+  }
+}
 async function deleteUniquenessEntries(ctx, kind, props, constraints) {
   for (const constraint of constraints) {
     if (!checkWherePredicate(constraint, props)) {
@@ -1847,6 +2155,14 @@ async function enforceNodeDeleteBehavior(ctx, args, backend, policy) {
     }
     case "cascade":
     case "disconnect": {
+      const batchDelete = args.mode === "hard" ? backend.hardDeleteEdgesBatch : backend.deleteEdgesBatch;
+      if (batchDelete !== void 0) {
+        await batchDelete.call(backend, {
+          graphId: ctx.graphId,
+          ids: connectedEdges.map((edge) => edge.id)
+        });
+        break;
+      }
       for (const edge of connectedEdges) {
         await (args.mode === "hard" ? backend.hardDeleteEdge({ graphId: ctx.graphId, id: edge.id }) : backend.deleteEdge({ graphId: ctx.graphId, id: edge.id }));
       }
@@ -1875,8 +2191,35 @@ async function applyNodeInsertSideEffects(ctx, args, backend) {
     )
   ]);
 }
+async function applyNodeInsertSideEffectsBatch(ctx, items, backend) {
+  if (items.length === 0) return;
+  await insertUniquenessEntriesBatch(
+    uniquenessContext(ctx, backend),
+    items.map((item) => ({
+      kind: item.kind,
+      id: item.id,
+      props: item.props,
+      constraints: item.uniqueConstraints
+    }))
+  );
+  const byKind = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    const group = byKind.get(item.kind) ?? { schema: item.schema, rows: [] };
+    group.rows.push({ nodeId: item.id, props: item.props });
+    byKind.set(item.kind, group);
+  }
+  await Promise.all(
+    [...byKind.entries()].flatMap(([kind, group]) => {
+      const syncArguments = { graphId: ctx.graphId, nodeKind: kind, backend };
+      return [
+        syncEmbeddingsBatchForKind(syncArguments, group.schema, group.rows),
+        syncFulltextBatchForKind(syncArguments, group.schema, group.rows)
+      ];
+    })
+  );
+}
 function parseRowProps(row) {
-  return JSON.parse(row.props);
+  return rowPropsToObject(row.props);
 }
 async function applyNodeUpdate(ctx, args, backend) {
   const { kind, id } = args.existing;
@@ -2005,6 +2348,6 @@ async function applyNodeResurrect(ctx, args, backend) {
   return row;
 }
 
-export { ALIAS_CTE_PREFIX, DEFAULT_SQL_SCHEMA, EMBEDDINGS_CTE_ALIAS, FULLTEXT_CTE_ALIAS, HYBRID_CANDIDATES_CTE_ALIAS, applyNodeHardDelete, applyNodeInsertSideEffects, applyNodeResurrect, applyNodeSoftDelete, applyNodeUpdate, asCompiledRowsSql, asCompiledSelectSql, asCompiledStatementSql, asRecordedInstant, assertRecordedCaptureTransactionIsolation, assertValidRecordedInstant, checkCardinality, checkDisjointness, checkUniqueEdge, checkUniquenessConstraints, checkWherePredicate, closeRecordedHardDeletedKind, computeFulltextContent, computeUniqueKey, coordinateContext, createHistoryUnsafeSqlRef, createNodeWriteContext, createRecordedBackend, createRecordedReadBinding, createRecordedTransactionScope, createSqlSchema, createUniquenessContext, describeCoordinate, edgeInsertDispatch, generateId, getEdgeRowsByIds, getEmbeddingFields, getKindsForUniquenessCheck, getNodeRowsByIds, getSearchableFields, lockRecordedGraphWrite, nodeInsertDispatch, readRecordedClock, recordedBindParamBudget, recordedCaptureRequiresCallbackTransactionError, recordedReadSchemaFor, recordedReadSqlSchema, recordedRelation, requireExternalRecordedReadSource, requireRecordedReadBinding, requireSqlSchema, resolveReadCoordinate, runInsertBatch, runInsertBatchReturning, runInsertNoReturn, uncapturedGraphWriteLock, validateEdgeEndpoints, vectorSlotKey, withRecordedCoordinate };
-//# sourceMappingURL=chunk-A7SZZFAG.js.map
-//# sourceMappingURL=chunk-A7SZZFAG.js.map
+export { ALIAS_CTE_PREFIX, DEFAULT_SQL_SCHEMA, EMBEDDINGS_CTE_ALIAS, FULLTEXT_CTE_ALIAS, HYBRID_CANDIDATES_CTE_ALIAS, advanceRevisionClock, applyNodeHardDelete, applyNodeInsertSideEffects, applyNodeInsertSideEffectsBatch, applyNodeResurrect, applyNodeSoftDelete, applyNodeUpdate, asRecordedInstant, assertRecordedCaptureTransactionIsolation, assertRevisionTrackableBackend, assertValidRecordedInstant, checkCardinality, checkDisjointness, checkUniqueEdge, checkUniquenessConstraints, checkWherePredicate, closeRecordedHardDeletedKind, computeFulltextContent, computeUniqueKey, coordinateContext, createHistoryUnsafeSqlRef, createNodeWriteContext, createRecordedBackend, createRecordedReadBinding, createRecordedTransactionScope, createRevisionTrackingUnsafeSqlRef, createSqlSchema, createUniquenessContext, describeCoordinate, edgeInsertDispatch, ensureRevisionOrigin, generateId, getEdgeRowsByIds, getEmbeddingFields, getKindsForUniquenessCheck, getNodeRowsByIds, lockRecordedGraphWrite, nodeInsertDispatch, readRecordedClock, readRevisionOrigin, recordedBindParamBudget, recordedCaptureRequiresCallbackTransactionError, recordedReadSchemaFor, recordedReadSqlSchema, recordedRelation, requireExternalRecordedReadSource, requireRecordedReadBinding, requireSqlSchema, resolveReadCoordinate, runInsertBatch, runInsertBatchReturning, runInsertNoReturn, uncapturedGraphWriteLock, validateEdgeEndpoints, vectorSlotKey, withRecordedCoordinate, withRecordedFlushObserver };
+//# sourceMappingURL=chunk-5VTR2F2K.js.map
+//# sourceMappingURL=chunk-5VTR2F2K.js.map