@nicia-ai/typegraph 0.34.0 → 0.36.0

package/dist/{chunk-5IQIX7LU.cjs → chunk-ZUNQ5BEP.cjs}

@@ -1,21 +1,20 @@
 'use strict';
 
-var chunkUNNPKQUG_cjs = require('./chunk-UNNPKQUG.cjs');
-var chunkYC6PWTHY_cjs = require('./chunk-YC6PWTHY.cjs');
-var chunkRHZWOJVA_cjs = require('./chunk-RHZWOJVA.cjs');
-var chunkYAZE7QZR_cjs = require('./chunk-YAZE7QZR.cjs');
-var chunkNAUA4PW5_cjs = require('./chunk-NAUA4PW5.cjs');
-var chunkJQGIPGVL_cjs = require('./chunk-JQGIPGVL.cjs');
-var chunkJIEJCTDS_cjs = require('./chunk-JIEJCTDS.cjs');
+var chunkEOLERH7Y_cjs = require('./chunk-EOLERH7Y.cjs');
+var chunkX4JBT642_cjs = require('./chunk-X4JBT642.cjs');
+var chunkRSSQKPSZ_cjs = require('./chunk-RSSQKPSZ.cjs');
+var chunk7YSP4V4R_cjs = require('./chunk-7YSP4V4R.cjs');
+var chunkH7YNSMA7_cjs = require('./chunk-H7YNSMA7.cjs');
+var chunkDIK74MXX_cjs = require('./chunk-DIK74MXX.cjs');
 var drizzleOrm = require('drizzle-orm');
 var nanoid = require('nanoid');
 
 // src/core/temporal.ts
 var RECORDED_MAX = "9999-12-31T23:59:59.999Z";
 function assertValidRecordedInstant(value, path) {
-  chunkYC6PWTHY_cjs.validateCanonicalIsoDate(value, path);
+  chunkRSSQKPSZ_cjs.validateCanonicalIsoDate(value, path);
   if (value >= RECORDED_MAX) {
-    throw new chunkJIEJCTDS_cjs.ValidationError(
+    throw new chunkDIK74MXX_cjs.ValidationError(
       `${path} must be before the recorded-time open sentinel ${RECORDED_MAX}.`,
       {
         issues: [
@@ -37,7 +36,7 @@ function asRecordedInstant(value) {
 }
 function resolveReadCoordinate(mode, asOf, suggestion) {
   if (mode !== "asOf" && asOf !== void 0) {
-    throw new chunkJIEJCTDS_cjs.ValidationError(
+    throw new chunkDIK74MXX_cjs.ValidationError(
       `Temporal mode "${mode}" does not take an asOf timestamp.`,
       {
         issues: [
@@ -68,7 +67,7 @@ function withRecordedCoordinate(coordinate, recordedAsOf) {
 }
 function assertValidAsOf(mode, asOf, options) {
   if (mode === "asOf" && asOf === void 0) {
-    throw new chunkJIEJCTDS_cjs.ValidationError(
+    throw new chunkDIK74MXX_cjs.ValidationError(
       'Temporal mode "asOf" requires a timestamp',
       {
         issues: [
@@ -81,7 +80,7 @@ function assertValidAsOf(mode, asOf, options) {
     );
   }
   if (asOf !== void 0) {
-    chunkYC6PWTHY_cjs.validateCanonicalIsoDate(asOf, "asOf");
+    chunkRSSQKPSZ_cjs.validateCanonicalIsoDate(asOf, "asOf");
   }
 }
 function describeCoordinate(coordinate) {
@@ -97,17 +96,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;
@@ -117,6 +105,7 @@ var SqlSchemaDescriptor = class {
   recordedNodesTable;
   recordedEdgesTable;
   recordedClockTable;
+  revisionOriginsTable;
   fulltextTable;
   constructor(fields) {
     this.tables = fields.tables;
@@ -125,6 +114,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);
@@ -136,6 +126,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"
 };
@@ -146,6 +137,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
   };
@@ -153,15 +145,15 @@ function resolveTableNames(names) {
 var VALID_IDENTIFIER_PATTERN = /^[a-z_][a-z0-9_$]*$/i;
 function validateTableName(name, label) {
   if (!name || name.length === 0) {
-    throw new chunkJIEJCTDS_cjs.ConfigurationError(`${label} table name cannot be empty`);
+    throw new chunkDIK74MXX_cjs.ConfigurationError(`${label} table name cannot be empty`);
   }
-  if (name.length > chunkNAUA4PW5_cjs.MAX_PG_IDENTIFIER_LENGTH) {
-    throw new chunkJIEJCTDS_cjs.ConfigurationError(
-      `${label} table name exceeds maximum length of ${chunkNAUA4PW5_cjs.MAX_PG_IDENTIFIER_LENGTH} characters`
+  if (name.length > chunk7YSP4V4R_cjs.MAX_PG_IDENTIFIER_LENGTH) {
+    throw new chunkDIK74MXX_cjs.ConfigurationError(
+      `${label} table name exceeds maximum length of ${chunk7YSP4V4R_cjs.MAX_PG_IDENTIFIER_LENGTH} characters`
     );
   }
   if (!VALID_IDENTIFIER_PATTERN.test(name)) {
-    throw new chunkJIEJCTDS_cjs.ConfigurationError(
+    throw new chunkDIK74MXX_cjs.ConfigurationError(
       `${label} table name "${name}" is not a valid SQL identifier. Table names must start with a letter or underscore and contain only letters, digits, underscores, or dollar signs.`
     );
   }
@@ -177,7 +169,7 @@ function isSqlSchema(schema) {
 }
 function requireSqlSchema(schema, surface = "SqlSchema") {
   if (isSqlSchema(schema)) return schema;
-  throw new chunkJIEJCTDS_cjs.ConfigurationError(
+  throw new chunkDIK74MXX_cjs.ConfigurationError(
     `${surface} must be created with createSqlSchema(...).`,
     { code: "INVALID_SQL_SCHEMA", surface },
     {
@@ -192,6 +184,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({
@@ -201,6 +194,7 @@ function createSqlSchema(names = {}) {
     recordedNodesTable: drizzleOrm.sql.raw(quoteIdentifier(tables.recordedNodes)),
     recordedEdgesTable: drizzleOrm.sql.raw(quoteIdentifier(tables.recordedEdges)),
     recordedClockTable: drizzleOrm.sql.raw(quoteIdentifier(tables.recordedClock)),
+    revisionOriginsTable: drizzleOrm.sql.raw(quoteIdentifier(tables.revisionOrigins)),
     fulltextTable: drizzleOrm.sql.raw(quoteIdentifier(tables.fulltext))
   });
 }
@@ -221,7 +215,7 @@ function recordedRelation(options) {
 function requireExternalRecordedReadSource(source) {
   if (source === void 0) return void 0;
   if (isExternalRecordedReadSource(source)) return source;
-  throw new chunkJIEJCTDS_cjs.ConfigurationError(
+  throw new chunkDIK74MXX_cjs.ConfigurationError(
     "recordedRead must be created with recordedRelation({ schema }).",
     { code: "INVALID_RECORDED_READ_SOURCE" },
     {
@@ -245,7 +239,7 @@ function createRecordedReadBinding(schema) {
 function requireRecordedReadBinding(binding, surface) {
   if (isRecordedReadBinding(binding)) return binding;
   if (binding !== void 0) {
-    throw new chunkJIEJCTDS_cjs.ConfigurationError(
+    throw new chunkDIK74MXX_cjs.ConfigurationError(
       "Recorded-time reads require a recorded read relation created by TypeGraph.",
       { code: "INVALID_RECORDED_READ_BINDING", surface },
       {
@@ -253,7 +247,7 @@ function requireRecordedReadBinding(binding, surface) {
       }
     );
   }
-  throw new chunkJIEJCTDS_cjs.ConfigurationError(
+  throw new chunkDIK74MXX_cjs.ConfigurationError(
     "Recorded-time reads require a recorded read relation.",
     { code: "RECORDED_READ_REQUIRES_BINDING", surface },
     {
@@ -281,6 +275,7 @@ function recordedReadSqlSchema(binding) {
     recordedNodesTable: schema.recordedNodesTable,
     recordedEdgesTable: schema.recordedEdgesTable,
     recordedClockTable: schema.recordedClockTable,
+    revisionOriginsTable: schema.revisionOriginsTable,
     fulltextTable: schema.fulltextTable
   });
 }
@@ -302,7 +297,7 @@ function generateId() {
 }
 function requireRecordedSchema(target) {
   if (target.tableNames === void 0) {
-    throw new chunkJIEJCTDS_cjs.ConfigurationError(
+    throw new chunkDIK74MXX_cjs.ConfigurationError(
       "Recorded-time capture requires the backend to expose tableNames.",
       { dialect: target.dialect },
       {
@@ -314,7 +309,7 @@ function requireRecordedSchema(target) {
 }
 function requireCaptureStatements(target) {
   if (target.executeStatement === void 0) {
-    throw new chunkJIEJCTDS_cjs.ConfigurationError(
+    throw new chunkDIK74MXX_cjs.ConfigurationError(
       "Recorded-time capture requires backend.executeStatement support on the transaction backend.",
       { dialect: target.dialect },
       {
@@ -325,10 +320,10 @@ function requireCaptureStatements(target) {
 }
 async function executeStatement(target, query) {
   requireCaptureStatements(target);
-  await target.executeStatement(asCompiledStatementSql(query));
+  await target.executeStatement(chunkEOLERH7Y_cjs.asCompiledStatementSql(query));
 }
 function unsupportedPostgresIsolationError(isolationLevel) {
-  return new chunkJIEJCTDS_cjs.ConfigurationError(
+  return new chunkDIK74MXX_cjs.ConfigurationError(
     "Recorded-time capture on PostgreSQL requires read_committed isolation.",
     { isolationLevel: isolationLevel ?? "unknown" },
     {
@@ -352,7 +347,7 @@ function normalizeIsolationLevel(value) {
 async function assertRecordedCaptureTransactionIsolation(target) {
   if (target.dialect !== "postgres") return;
   const rows = await target.execute(
-    asCompiledRowsSql(drizzleOrm.sql`
+    chunkEOLERH7Y_cjs.asCompiledRowsSql(drizzleOrm.sql`
       SELECT current_setting('transaction_isolation') AS transaction_isolation
     `)
   );
@@ -362,62 +357,87 @@ async function assertRecordedCaptureTransactionIsolation(target) {
   if (isSupportedRecordedIsolationLevel(isolationLevel)) return;
   throw unsupportedPostgresIsolationError(isolationLevel);
 }
-function recordedCaptureRequiresCallbackTransactionError(details) {
-  return new chunkJIEJCTDS_cjs.ConfigurationError(
+function recordedCaptureRequiresCallbackTransactionError(details = {}) {
+  return new chunkDIK74MXX_cjs.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."
     }
   );
 }
 function historyUnsafeRawWriteError(surface) {
-  return new chunkJIEJCTDS_cjs.ConfigurationError(
+  return new chunkDIK74MXX_cjs.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 chunkDIK74MXX_cjs.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();
       }
     }
   );
@@ -442,7 +462,7 @@ function rawWriteGuards(target, prefix) {
 }
 function assertCapturableBackend(backend) {
   if (!backend.capabilities.transactions) {
-    throw new chunkJIEJCTDS_cjs.ConfigurationError(
+    throw new chunkDIK74MXX_cjs.ConfigurationError(
       "history: true requires a backend with transaction support.",
       { dialect: backend.dialect },
       {
@@ -451,7 +471,7 @@ function assertCapturableBackend(backend) {
     );
   }
   if (backend.executeStatement === void 0) {
-    throw new chunkJIEJCTDS_cjs.ConfigurationError(
+    throw new chunkDIK74MXX_cjs.ConfigurationError(
       "history: true requires a backend that supports executeStatement.",
       { dialect: backend.dialect },
       {
@@ -460,7 +480,7 @@ function assertCapturableBackend(backend) {
     );
   }
   if (backend.capabilities.returning === false) {
-    throw new chunkJIEJCTDS_cjs.ConfigurationError(
+    throw new chunkDIK74MXX_cjs.ConfigurationError(
       "history: true requires a backend that supports UPDATE \u2026 RETURNING.",
       { dialect: backend.dialect },
       {
@@ -469,7 +489,7 @@ function assertCapturableBackend(backend) {
     );
   }
   if (backend.tableNames === void 0) {
-    throw new chunkJIEJCTDS_cjs.ConfigurationError(
+    throw new chunkDIK74MXX_cjs.ConfigurationError(
       "history: true requires a backend that exposes tableNames.",
       { dialect: backend.dialect },
       {
@@ -478,6 +498,44 @@ function assertCapturableBackend(backend) {
     );
   }
 }
+function assertRevisionTrackableBackend(backend) {
+  if (!backend.capabilities.transactions) {
+    throw new chunkDIK74MXX_cjs.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 chunkDIK74MXX_cjs.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 chunkDIK74MXX_cjs.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 chunkDIK74MXX_cjs.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";
@@ -508,22 +566,40 @@ 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))
+    chunkEOLERH7Y_cjs.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 chunkJIEJCTDS_cjs.ConfigurationError(
+  throw new chunkDIK74MXX_cjs.ConfigurationError(
     "Recorded clock row contained an invalid timestamp",
     { value }
   );
@@ -562,12 +638,12 @@ function toCanonicalIso(value) {
   return failInvalidClockTimestamp(value);
 }
 function nextRecordedCommitTime(previous) {
-  const wallTime = Date.parse(chunkYC6PWTHY_cjs.nowIso());
+  const wallTime = Date.parse(chunkRSSQKPSZ_cjs.nowIso());
   return previous === void 0 ? wallTime : Math.max(wallTime, Date.parse(previous) + 1);
 }
 async function readRecordedClock(target, schema, graphId) {
   const rows = await target.execute(
-    asCompiledRowsSql(drizzleOrm.sql`
+    chunkEOLERH7Y_cjs.asCompiledRowsSql(drizzleOrm.sql`
       SELECT recorded_at
       FROM ${schema.recordedClockTable}
       WHERE graph_id = ${graphId}
@@ -576,6 +652,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(
+    chunkEOLERH7Y_cjs.asCompiledRowsSql(drizzleOrm.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 chunkDIK74MXX_cjs.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 chunkDIK74MXX_cjs.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,
+    drizzleOrm.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 chunkDIK74MXX_cjs.ConfigurationError(
+    "Revision origin was not persisted after initialization.",
+    { graphId, dialect: target.dialect }
+  );
+}
 async function writeRecordedClock(target, schema, graphId, recordedAt) {
   await executeStatement(
     target,
@@ -589,7 +712,7 @@ async function writeRecordedClock(target, schema, graphId, recordedAt) {
 async function lockRecordedClock(target, schema, graphId, ownsWriteLock) {
   if (target.dialect === "postgres") {
     await target.execute(
-      asCompiledRowsSql(recordedClockAdvisoryLockSql(graphId))
+      chunkEOLERH7Y_cjs.asCompiledRowsSql(recordedClockAdvisoryLockSql(graphId))
     );
     return;
   }
@@ -603,12 +726,12 @@ 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 chunkJIEJCTDS_cjs.ConfigurationError(
+    throw new chunkDIK74MXX_cjs.ConfigurationError(
       `Recorded commit clock reached the open sentinel ${RECORDED_MAX}`,
       { graphId, recordedCommitTime },
       {
@@ -620,6 +743,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) {
@@ -748,7 +880,7 @@ var RECORDED_BIND_PARAM_BUDGET = 900;
 function recordedBindParamBudget(target) {
   const budget = target.capabilities.maxBindParameters ?? RECORDED_BIND_PARAM_BUDGET;
   if (!Number.isSafeInteger(budget) || budget < 1) {
-    throw new chunkJIEJCTDS_cjs.ConfigurationError(
+    throw new chunkDIK74MXX_cjs.ConfigurationError(
       `backend capabilities.maxBindParameters must be a positive integer, got: ${String(budget)}`,
       {
         code: "INVALID_BACKEND_CAPABILITY",
@@ -769,12 +901,12 @@ function recordedCommonCells() {
     graph_id: (row) => drizzleOrm.sql`${row.graph_id}`,
     id: (row) => drizzleOrm.sql`${row.id}`,
     kind: (row) => drizzleOrm.sql`${row.kind}`,
-    props: (row) => drizzleOrm.sql`${row.props}`,
-    valid_from: (row) => drizzleOrm.sql`${chunkYAZE7QZR_cjs.sqlNull(row.valid_from)}`,
-    valid_to: (row) => drizzleOrm.sql`${chunkYAZE7QZR_cjs.sqlNull(row.valid_to)}`,
+    props: (row) => drizzleOrm.sql`${chunkX4JBT642_cjs.rowPropsToJsonText(row.props)}`,
+    valid_from: (row) => drizzleOrm.sql`${chunk7YSP4V4R_cjs.sqlNull(row.valid_from)}`,
+    valid_to: (row) => drizzleOrm.sql`${chunk7YSP4V4R_cjs.sqlNull(row.valid_to)}`,
     created_at: (row) => drizzleOrm.sql`${row.created_at}`,
     updated_at: (row) => drizzleOrm.sql`${row.updated_at}`,
-    deleted_at: (row) => drizzleOrm.sql`${chunkYAZE7QZR_cjs.sqlNull(row.deleted_at)}`,
+    deleted_at: (row) => drizzleOrm.sql`${chunk7YSP4V4R_cjs.sqlNull(row.deleted_at)}`,
     recorded_from: (_row, recordedCommit) => drizzleOrm.sql`${recordedCommit}`,
     recorded_to: () => drizzleOrm.sql`${RECORDED_MAX}`,
     op: (_row, _recordedCommit, operation) => drizzleOrm.sql`${operation}`,
@@ -862,20 +994,20 @@ function entityKey(entity) {
 async function closeOpenReturning(target, table, graphId, ids, recordedCommit, kind) {
   const kindFilter = kind === void 0 ? drizzleOrm.sql`` : drizzleOrm.sql`AND kind = ${kind}`;
   const rows = await target.execute(
-    asCompiledRowsSql(drizzleOrm.sql`
+    chunkEOLERH7Y_cjs.asCompiledRowsSql(drizzleOrm.sql`
       UPDATE ${table}
       SET recorded_to = ${recordedCommit}
       WHERE graph_id = ${graphId}
         ${kindFilter}
         AND recorded_to = ${RECORDED_MAX}
-        AND id IN (${chunkUNNPKQUG_cjs.sqlValueList(ids)})
+        AND id IN (${chunkX4JBT642_cjs.sqlValueList(ids)})
       RETURNING id, deleted_at
     `)
   );
-  return new Map(rows.map((row) => [row.id, chunkUNNPKQUG_cjs.isPresent(row.deleted_at)]));
+  return new Map(rows.map((row) => [row.id, chunkX4JBT642_cjs.isPresent(row.deleted_at)]));
 }
 function recordedOp(hadOpenRow, priorRowWasTombstone, after) {
-  if (chunkUNNPKQUG_cjs.isPresent(after.deleted_at)) return "delete";
+  if (chunkX4JBT642_cjs.isPresent(after.deleted_at)) return "delete";
   if (!hadOpenRow || priorRowWasTombstone) return "create";
   return "update";
 }
@@ -912,7 +1044,7 @@ function recordedInsertsFor(afterById, closed) {
 async function flushNodes(target, schema, graphId, entities, recordedCommit) {
   const chunkSize = recordedNodeChunkSize(target);
   for (const [kind, group] of groupNodesByKind(entities)) {
-    for (const entityChunk of chunkUNNPKQUG_cjs.chunk(group, chunkSize)) {
+    for (const entityChunk of chunkX4JBT642_cjs.chunk(group, chunkSize)) {
       const ids = entityChunk.map((entity) => entity.id);
       const closed = await closeOpenReturning(
         target,
@@ -937,7 +1069,7 @@ async function flushNodes(target, schema, graphId, entities, recordedCommit) {
 }
 async function flushEdges(target, schema, graphId, entities, recordedCommit) {
   const chunkSize = recordedEdgeChunkSize(target);
-  for (const entityChunk of chunkUNNPKQUG_cjs.chunk(entities, chunkSize)) {
+  for (const entityChunk of chunkX4JBT642_cjs.chunk(entities, chunkSize)) {
     const ids = entityChunk.map((entity) => entity.id);
     const closed = await closeOpenReturning(
       target,
@@ -1016,7 +1148,7 @@ async function closeRecordedHardDeletedKind(target, schema, graphId, removal, ow
 }
 async function queryConnectedEdgeIds(target, schema, params) {
   const rows = await target.execute(
-    asCompiledRowsSql(drizzleOrm.sql`
+    chunkEOLERH7Y_cjs.asCompiledRowsSql(drizzleOrm.sql`
       SELECT id
       FROM ${schema.edgesTable}
       WHERE graph_id = ${params.graphId}
@@ -1030,6 +1162,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}`;
 }
@@ -1048,22 +1195,32 @@ function edgeParamsIdentityKey(params) {
 function edgeRowIdentityKey(row) {
   return edgeIdentityKey(row.graph_id, row.id);
 }
+function recordedCaptureSealedError(details) {
+  return new chunkDIK74MXX_cjs.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 chunkJIEJCTDS_cjs.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 });
     },
@@ -1072,7 +1229,7 @@ function createRecordedCaptureSession() {
     },
     async flush(target, schema, ownsWriteLock) {
       if (sealed) {
-        throw new chunkJIEJCTDS_cjs.ConfigurationError(
+        throw new chunkDIK74MXX_cjs.ConfigurationError(
           "Recorded-time capture session was already flushed.",
           {},
           {
@@ -1081,8 +1238,9 @@ function createRecordedCaptureSession() {
         );
       }
       sealed = true;
-      if (touched.size === 0) return;
-      const byGraph = chunkUNNPKQUG_cjs.groupBy(touched.values(), (entity) => entity.graphId);
+      if (touched.size === 0) return /* @__PURE__ */ new Map();
+      const recordedByGraph = /* @__PURE__ */ new Map();
+      const byGraph = chunkX4JBT642_cjs.groupBy(touched.values(), (entity) => entity.graphId);
       for (const [graphId, entities] of byGraph) {
         const recordedCommit = await allocateRecordedCommit(
           target,
@@ -1090,6 +1248,7 @@ function createRecordedCaptureSession() {
           graphId,
           ownsWriteLock
         );
+        recordedByGraph.set(graphId, recordedCommit);
         const nodes = entities.filter(
           (entity) => entity.entity === "node"
         );
@@ -1100,24 +1259,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 chunkUNNPKQUG_cjs.createBackendOverlay(target, {
+  const overlay = chunkX4JBT642_cjs.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);
@@ -1125,6 +1289,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);
@@ -1132,6 +1297,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) {
@@ -1141,6 +1307,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(
@@ -1158,17 +1325,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,
@@ -1182,6 +1352,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);
@@ -1189,6 +1360,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);
@@ -1196,6 +1368,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) {
@@ -1205,6 +1378,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(
@@ -1221,22 +1395,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);
@@ -1245,7 +1444,7 @@ function createRecordedTransactionScope(target, schema, ownsWriteLock = false) {
   return {
     backend: createRecordedTransactionBackend(target, session, resolvedSchema),
     async flush() {
-      await chunkRHZWOJVA_cjs.withRecordedRelationsPrecondition(
+      return chunkRSSQKPSZ_cjs.withRecordedRelationsPrecondition(
         session.flush(target, resolvedSchema, ownsWriteLock),
         { dialect: target.dialect, surface: "capture-flush" }
       );
@@ -1265,7 +1464,7 @@ async function runCapturedAutocommit(backend, schema, fn, options) {
 function createRecordedBackend(backend, schema) {
   assertCapturableBackend(backend);
   const capture = (fn) => runCapturedAutocommit(backend, schema, fn);
-  return chunkUNNPKQUG_cjs.createBackendOverlay(backend, {
+  return chunkX4JBT642_cjs.createBackendOverlay(backend, {
     ...rawWriteGuards(backend, "backend"),
     async insertNode(params) {
       return capture((target) => target.insertNode(params));
@@ -1333,15 +1532,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) {
@@ -1358,7 +1570,7 @@ var embeddingFieldsCache = /* @__PURE__ */ new WeakMap();
 function getEmbeddingFields(schema) {
   const cached = embeddingFieldsCache.get(schema);
   if (cached) return cached;
-  const fields = chunkJQGIPGVL_cjs.resolveEmbeddingFields(schema);
+  const fields = chunkH7YNSMA7_cjs.resolveEmbeddingFields(schema);
   embeddingFieldsCache.set(schema, fields);
   return fields;
 }
@@ -1397,6 +1609,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) {
@@ -1426,48 +1697,12 @@ 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 = chunkJQGIPGVL_cjs.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 ?? chunkJQGIPGVL_cjs.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 ?? chunkJQGIPGVL_cjs.DEFAULT_SEARCHABLE_LANGUAGE;
+  return fields[0]?.metadata.language ?? chunkH7YNSMA7_cjs.DEFAULT_SEARCHABLE_LANGUAGE;
 }
 function computeFulltextContent(schema, props) {
-  const searchableFields = getSearchableFields(schema);
+  const searchableFields = chunkH7YNSMA7_cjs.getSearchableFields(schema);
   if (searchableFields.length === 0) return void 0;
   const parts = [];
   for (const field of searchableFields) {
@@ -1498,19 +1733,68 @@ async function syncFulltext(ctx, schema, props) {
     });
     return;
   }
-  if (getSearchableFields(schema).length === 0) return;
+  if (chunkH7YNSMA7_cjs.getSearchableFields(schema).length === 0) return;
   await backend.deleteFulltext({
     graphId: ctx.graphId,
     nodeKind: ctx.nodeKind,
     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 = chunkH7YNSMA7_cjs.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) {
     return;
   }
-  if (getSearchableFields(schema).length === 0) {
+  if (chunkH7YNSMA7_cjs.getSearchableFields(schema).length === 0) {
     return;
   }
   await backend.deleteFulltext({
@@ -1572,7 +1856,7 @@ function evaluatePredicate(predicate, props) {
   if (pred.op === "isNull") {
     return value === null || value === void 0;
   }
-  return chunkUNNPKQUG_cjs.isPresent(value);
+  return chunkX4JBT642_cjs.isPresent(value);
 }
 function getKindsForUniquenessCheck(baseKind, scope, registry) {
   if (scope === "kind") {
@@ -1601,7 +1885,7 @@ function checkCardinality(edgeKind, fromKind, fromId, cardinality, existingEdgeC
     }
     case "one": {
       if (existingEdgeCount > 0) {
-        return new chunkJIEJCTDS_cjs.CardinalityError({
+        return new chunkDIK74MXX_cjs.CardinalityError({
           edgeKind,
           fromKind,
           fromId,
@@ -1616,7 +1900,7 @@ function checkCardinality(edgeKind, fromKind, fromId, cardinality, existingEdgeC
     }
     case "oneActive": {
       if (hasActiveEdge) {
-        return new chunkJIEJCTDS_cjs.CardinalityError({
+        return new chunkDIK74MXX_cjs.CardinalityError({
           edgeKind,
           fromKind,
           fromId,
@@ -1630,7 +1914,7 @@ function checkCardinality(edgeKind, fromKind, fromId, cardinality, existingEdgeC
 }
 function checkUniqueEdge(edgeKind, fromKind, fromId, _toKind, _toId, existingCount) {
   if (existingCount > 0) {
-    return new chunkJIEJCTDS_cjs.CardinalityError({
+    return new chunkDIK74MXX_cjs.CardinalityError({
       edgeKind,
       fromKind,
       fromId,
@@ -1642,11 +1926,8 @@ 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) {
-    return new chunkJIEJCTDS_cjs.EndpointError({
+  if (!registry.isAssignableToAny(fromKind, validFromKinds)) {
+    return new chunkDIK74MXX_cjs.EndpointError({
       edgeKind,
       endpoint: "from",
       actualKind: fromKind,
@@ -1654,11 +1935,8 @@ 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) {
-    return new chunkJIEJCTDS_cjs.EndpointError({
+  if (!registry.isAssignableToAny(toKind, validToKinds)) {
+    return new chunkDIK74MXX_cjs.EndpointError({
       edgeKind,
       endpoint: "to",
       actualKind: toKind,
@@ -1670,7 +1948,7 @@ function validateEdgeEndpoints(edgeKind, fromKind, toKind, registration, registr
 function checkDisjointness(nodeId, nodeKind, existingKinds, registry) {
   for (const existingKind of existingKinds) {
     if (registry.areDisjoint(nodeKind, existingKind)) {
-      return new chunkJIEJCTDS_cjs.DisjointError({
+      return new chunkDIK74MXX_cjs.DisjointError({
         nodeId,
         attemptedKind: nodeKind,
         conflictingKind: existingKind
@@ -1707,7 +1985,7 @@ async function checkUniquenessConstraints(ctx, kind, id, props, constraints) {
         key
       });
       if (existing && existing.node_id !== id) {
-        throw new chunkJIEJCTDS_cjs.UniquenessError({
+        throw new chunkDIK74MXX_cjs.UniquenessError({
           constraintName: constraint.name,
           kind: kindToCheck,
           existingId: existing.node_id,
@@ -1738,6 +2016,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)) {
@@ -1783,7 +2091,7 @@ async function updateUniquenessEntries(ctx, kind, id, oldProps, newProps, constr
           key: newKey
         });
         if (existing && existing.node_id !== id) {
-          throw new chunkJIEJCTDS_cjs.UniquenessError({
+          throw new chunkDIK74MXX_cjs.UniquenessError({
             constraintName: constraint.name,
             kind: kindToCheck,
             existingId: existing.node_id,
@@ -1840,7 +2148,7 @@ async function enforceNodeDeleteBehavior(ctx, args, backend, policy) {
   if (connectedEdges.length === 0) return;
   switch (behavior) {
     case "restrict": {
-      throw new chunkJIEJCTDS_cjs.RestrictedDeleteError({
+      throw new chunkDIK74MXX_cjs.RestrictedDeleteError({
         nodeKind: args.kind,
         nodeId: args.id,
         edgeCount: connectedEdges.length,
@@ -1849,6 +2157,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 }));
       }
@@ -1877,8 +2193,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 chunkX4JBT642_cjs.rowPropsToObject(row.props);
 }
 async function applyNodeUpdate(ctx, args, backend) {
   const { kind, id } = args.existing;
@@ -2012,16 +2355,16 @@ exports.DEFAULT_SQL_SCHEMA = DEFAULT_SQL_SCHEMA;
 exports.EMBEDDINGS_CTE_ALIAS = EMBEDDINGS_CTE_ALIAS;
 exports.FULLTEXT_CTE_ALIAS = FULLTEXT_CTE_ALIAS;
 exports.HYBRID_CANDIDATES_CTE_ALIAS = HYBRID_CANDIDATES_CTE_ALIAS;
+exports.advanceRevisionClock = advanceRevisionClock;
 exports.applyNodeHardDelete = applyNodeHardDelete;
 exports.applyNodeInsertSideEffects = applyNodeInsertSideEffects;
+exports.applyNodeInsertSideEffectsBatch = applyNodeInsertSideEffectsBatch;
 exports.applyNodeResurrect = applyNodeResurrect;
 exports.applyNodeSoftDelete = applyNodeSoftDelete;
 exports.applyNodeUpdate = applyNodeUpdate;
-exports.asCompiledRowsSql = asCompiledRowsSql;
-exports.asCompiledSelectSql = asCompiledSelectSql;
-exports.asCompiledStatementSql = asCompiledStatementSql;
 exports.asRecordedInstant = asRecordedInstant;
 exports.assertRecordedCaptureTransactionIsolation = assertRecordedCaptureTransactionIsolation;
+exports.assertRevisionTrackableBackend = assertRevisionTrackableBackend;
 exports.assertValidRecordedInstant = assertValidRecordedInstant;
 exports.checkCardinality = checkCardinality;
 exports.checkDisjointness = checkDisjointness;
@@ -2037,19 +2380,21 @@ exports.createNodeWriteContext = createNodeWriteContext;
 exports.createRecordedBackend = createRecordedBackend;
 exports.createRecordedReadBinding = createRecordedReadBinding;
 exports.createRecordedTransactionScope = createRecordedTransactionScope;
+exports.createRevisionTrackingUnsafeSqlRef = createRevisionTrackingUnsafeSqlRef;
 exports.createSqlSchema = createSqlSchema;
 exports.createUniquenessContext = createUniquenessContext;
 exports.describeCoordinate = describeCoordinate;
 exports.edgeInsertDispatch = edgeInsertDispatch;
+exports.ensureRevisionOrigin = ensureRevisionOrigin;
 exports.generateId = generateId;
 exports.getEdgeRowsByIds = getEdgeRowsByIds;
 exports.getEmbeddingFields = getEmbeddingFields;
 exports.getKindsForUniquenessCheck = getKindsForUniquenessCheck;
 exports.getNodeRowsByIds = getNodeRowsByIds;
-exports.getSearchableFields = getSearchableFields;
 exports.lockRecordedGraphWrite = lockRecordedGraphWrite;
 exports.nodeInsertDispatch = nodeInsertDispatch;
 exports.readRecordedClock = readRecordedClock;
+exports.readRevisionOrigin = readRevisionOrigin;
 exports.recordedBindParamBudget = recordedBindParamBudget;
 exports.recordedCaptureRequiresCallbackTransactionError = recordedCaptureRequiresCallbackTransactionError;
 exports.recordedReadSchemaFor = recordedReadSchemaFor;
@@ -2066,5 +2411,6 @@ exports.uncapturedGraphWriteLock = uncapturedGraphWriteLock;
 exports.validateEdgeEndpoints = validateEdgeEndpoints;
 exports.vectorSlotKey = vectorSlotKey;
 exports.withRecordedCoordinate = withRecordedCoordinate;
-//# sourceMappingURL=chunk-5IQIX7LU.cjs.map
-//# sourceMappingURL=chunk-5IQIX7LU.cjs.map
+exports.withRecordedFlushObserver = withRecordedFlushObserver;
+//# sourceMappingURL=chunk-ZUNQ5BEP.cjs.map
+//# sourceMappingURL=chunk-ZUNQ5BEP.cjs.map