@nicia-ai/typegraph 0.44.0 → 0.46.0

package/dist/{chunk-FSXTPBRN.js → chunk-NQ6BRJBE.js}

@@ -1,56 +1,14 @@
-import { groupBy, chunk } from './chunk-35S6P5ZU.js';
-import { createSqlSchema } from './chunk-MIJKEVV7.js';
-import { createBackendOverlay, rowPropsToObject, rowPropsToJsonText } from './chunk-FMMIX6N4.js';
-import { parseRecordedInstant, createRecordedInstant, RECORDED_MAX_REVISION } from './chunk-2L54C2C2.js';
-import { withRecordedRelationsPrecondition } from './chunk-B75XRV3O.js';
-import { nowIso, canonicalizeDatabaseTimestamp } from './chunk-KCO5EFJU.js';
-import { typeGraphGlobalSymbol, sql, asCompiledRowsSql, likeEscapeClause, asCompiledStatementSql, LIKE_ESCAPE_CHARACTER } from './chunk-6DCB664D.js';
-import { resolveFieldTypeInfoAtJsonPointer } from './chunk-SNXVDZAJ.js';
-import { requireDefined, isPresent } from './chunk-QMQLUA66.js';
-import { resolveEmbeddingFields, getSearchableFields, DEFAULT_SEARCHABLE_LANGUAGE } from './chunk-PC2UBAUB.js';
-import { ConfigurationError, UnsupportedPredicateError, CompilerInvariantError, CardinalityError, EndpointError, DisjointError, UniquenessError, RestrictedDeleteError } from './chunk-4MB3AQAQ.js';
-import { normalizeJsonPointer, joinJsonPointers, jsonPointer } from './chunk-G6Q5UM7U.js';
+import { withRecordedRelationsPrecondition, groupBy, chunk } from './chunk-JZUR7ZWE.js';
+import { createSqlSchema } from './chunk-MSY7FSX4.js';
+import { inheritSerializedTransactionResource, createBackendOverlay, rowPropsToJsonText } from './chunk-AKLS3BYZ.js';
+import { nowIso, optionalRecordedInstantParts, createRecordedInstant, parseRecordedInstant, RECORDED_MAX_REVISION, canonicalizeDatabaseTimestamp } from './chunk-DLNROMQ7.js';
+import { sql, asCompiledRowsSql, likeEscapeClause, asCompiledStatementSql, LIKE_ESCAPE_CHARACTER } from './chunk-PQBQG7IM.js';
+import { resolveFieldTypeInfoAtJsonPointer } from './chunk-W6OG3HDG.js';
+import { ConfigurationError, UnsupportedPredicateError, CompilerInvariantError } from './chunk-J3WZ3FA2.js';
+import { normalizeJsonPointer, joinJsonPointers, jsonPointer } from './chunk-FWJKWH6U.js';
+import { requireDefined, isPresent } from './chunk-DYATYRY4.js';
 import { nanoid } from 'nanoid';
 
-// src/store/types.ts
-var AUTO_REFRESH_STATISTICS_ROW_THRESHOLD = 1e3;
-var TRANSACTION_RUNTIME = typeGraphGlobalSymbol(
-  "transaction-runtime-v1"
-);
-
-// src/store/runtime-port.ts
-var STORE_RUNTIME = typeGraphGlobalSymbol("store-runtime-v1");
-function storeRuntime(store) {
-  const runtime = store[STORE_RUNTIME];
-  if (runtime === void 0) {
-    throw new TypeError(
-      "Cannot access this Store's runtime port. The Store may come from an incompatible TypeGraph version."
-    );
-  }
-  return runtime;
-}
-function storeBackend(store) {
-  return storeRuntime(store).backend;
-}
-function transactionBackend(transaction) {
-  const runtime = transaction[TRANSACTION_RUNTIME];
-  if (runtime === void 0) {
-    throw new TypeError(
-      "Cannot access this transaction's runtime port. The transaction may come from an incompatible TypeGraph version."
-    );
-  }
-  return runtime.backend;
-}
-function transactionNodeOperationHookRunner(transaction) {
-  const runtime = transaction[TRANSACTION_RUNTIME];
-  if (runtime === void 0) {
-    throw new TypeError(
-      "Cannot access this transaction's runtime port. The transaction may come from an incompatible TypeGraph version."
-    );
-  }
-  return runtime.runNodeOperationHooks;
-}
-
 // src/query/compiler/temporal.ts
 var pinnedReadInstant;
 function withPinnedReadInstant(emit) {
@@ -74,6 +32,7 @@ function currentReadInstantFor(mode) {
 }
 function compileTemporalFilter(options) {
   const { mode, asOf, tableAlias, currentTimestamp, recordedAsOf } = options;
+  const recorded = optionalRecordedInstantParts(recordedAsOf, "recordedAsOf");
   const prefix = tableAlias ? sql.raw(`${tableAlias}.`) : sql.raw("");
   const deletedAt = sql`${prefix}deleted_at`;
   const validFrom = sql`${prefix}valid_from`;
@@ -81,7 +40,7 @@ function compileTemporalFilter(options) {
   const validFilter = (() => {
     switch (mode) {
       case "current": {
-        const now = recordedAsOf === void 0 ? currentTimestamp ?? currentReadInstant() : sql`${parseRecordedInstant(recordedAsOf, "recordedAsOf").recordedAt}`;
+        const now = recorded === void 0 ? currentTimestamp ?? currentReadInstant() : sql`${recorded.recordedAt}`;
         return sql`${deletedAt} IS NULL AND (${validFrom} IS NULL OR ${validFrom} <= ${now}) AND (${validTo} IS NULL OR ${validTo} > ${now})`;
       }
       case "asOf": {
@@ -101,14 +60,11 @@ function compileTemporalFilter(options) {
       }
     }
   })();
-  if (recordedAsOf === void 0) return validFilter;
+  if (recorded === void 0) return validFilter;
   const recordedFrom = sql`${prefix}recorded_from`;
   const recordedTo = sql`${prefix}recorded_to`;
-  const recordedRevision = parseRecordedInstant(
-    recordedAsOf,
-    "recordedAsOf"
-  ).revision;
-  return sql`(${validFilter}) AND ${recordedFrom} <= ${recordedRevision} AND ${recordedRevision} < ${recordedTo}`;
+  const { revision } = recorded;
+  return sql`(${validFilter}) AND ${recordedFrom} <= ${revision} AND ${revision} < ${recordedTo}`;
 }
 function extractTemporalOptions(ast, tableAlias) {
   return {
@@ -1068,10 +1024,22 @@ async function writeRecordedClock(target, schema, graphId, parts) {
       INSERT INTO ${schema.recordedClockTable} (graph_id, revision, recorded_at)
       VALUES (${graphId}, ${parts.revision}, ${parts.recordedAt})
       ON CONFLICT (graph_id) DO UPDATE
-      SET revision = ${parts.revision}, recorded_at = ${parts.recordedAt}
+      SET revision = excluded.revision, recorded_at = excluded.recorded_at
+      WHERE ${schema.recordedClockTable}.revision < excluded.revision
     `
   );
 }
+async function assertRecordedClockAdvanced(target, schema, graphId, revision) {
+  const stored = await readRecordedClockParts(target, schema, graphId);
+  if (stored?.revision === revision) return;
+  throw new ConfigurationError(
+    "Recorded commit allocation was refused: the supplied previous revision was stale, so the write would have moved the graph's revision clock backward.",
+    { graphId, allocatedRevision: revision, storedRevision: stored?.revision },
+    {
+      suggestion: "Read the previous revision inside the same transaction that allocates the commit (omit previousRevision), or hold the per-graph write lock across the read and the allocation."
+    }
+  );
+}
 async function lockRecordedClock(target, schema, graphId, ownsWriteLock) {
   switch (target.dialect) {
     case "postgres": {
@@ -1112,6 +1080,9 @@ async function allocateRecordedCommit(target, schema, graphId, ownsWriteLock, pr
   }
   const instant = createRecordedInstant(revision, recordedAt);
   await writeRecordedClock(target, schema, graphId, { revision, recordedAt });
+  if (previousRevision !== void 0) {
+    await assertRecordedClockAdvanced(target, schema, graphId, revision);
+  }
   return { instant, revision, recordedAt };
 }
 async function advanceRevisionClock(target, schema, graphId, ownsWriteLock, previousRevision) {
@@ -1137,6 +1108,7 @@ var GRAPH_BACKEND_PROJECTION_KEYS = [
   "insertNodesBatch",
   "insertNodesBatchReturning",
   "updateNode",
+  "updateNodeSet",
   "deleteNode",
   "hardDeleteNode",
   "getNode",
@@ -1159,10 +1131,12 @@ var GRAPH_BACKEND_PROJECTION_KEYS = [
   "countNodesByKind",
   "findEdgesByKind",
   "findEdgesByEndpointSet",
+  "findEdgesByHeterogeneousEndpointSet",
   "countEdgesByKind",
   "insertUnique",
   "insertUniqueBatch",
   "deleteUnique",
+  "hardDeleteUniquesByNodeIds",
   "checkUnique",
   "checkUniqueBatch",
   "getActiveSchema",
@@ -1170,11 +1144,13 @@ var GRAPH_BACKEND_PROJECTION_KEYS = [
   "commitSchemaVersion",
   "commitSchemaVersionIfKindsEmpty",
   "lockSchemaVersionForWrite",
+  "commitSchemaVersionWithPreflight",
   "setActiveVersion",
   "schemaWriteTransaction",
   "upsertEmbedding",
   "upsertEmbeddingBatch",
   "deleteEmbedding",
+  "deleteEmbeddingBatch",
   "vectorSearch",
   "createVectorIndex",
   "dropVectorIndex",
@@ -1207,7 +1183,12 @@ var GRAPH_BACKEND_PROJECTION_KEYS = [
   "assertVectorSlotsInitialized",
   "deleteVectorSlotContribution",
   "verifyContributions",
+  "repairContributions",
+  "probeContributions",
+  "rebuildContribution",
   "ensureFulltextTable",
+  "ensureIdentityTables",
+  "identityTableDdl",
   "getReconciliationMarker",
   "setReconciliationMarker",
   "clearGraph",
@@ -1228,7 +1209,9 @@ function projectBackendMembers(backend, keys) {
     if (!Reflect.has(backend, key)) return [];
     return [[key, Reflect.get(backend, key)]];
   });
-  return Object.fromEntries(entries);
+  const projection = Object.fromEntries(entries);
+  inheritSerializedTransactionResource(projection, backend);
+  return projection;
 }
 function createGraphBackendProjection(backend) {
   return projectBackendMembers(backend, GRAPH_BACKEND_PROJECTION_KEYS);
@@ -1269,6 +1252,7 @@ async function runInsertBatch(dispatch, params) {
   }
 }
 async function runInsertBatchReturning(dispatch, params) {
+  if (params.length === 0) return [];
   if (dispatch.batchReturning !== void 0) {
     return dispatch.batchReturning(params);
   }
@@ -1279,6 +1263,174 @@ async function runInsertBatchReturning(dispatch, params) {
   return rows;
 }
 
+// src/identity/historical-sql.ts
+var IDENTITY_ASSERTION_COLUMNS = sql.raw(
+  [
+    "graph_id",
+    "id",
+    "rel",
+    "a_kind",
+    "a_id",
+    "b_kind",
+    "b_id",
+    "valid_from",
+    "valid_to",
+    "created_at",
+    "updated_at",
+    "deleted_at",
+    "ended_by_kind",
+    "ended_by_id"
+  ].join(", ")
+);
+function identitySqlCoordinate(coordinate, currentInstant) {
+  return {
+    validMode: coordinate?.valid.mode ?? "current",
+    validAsOf: coordinate?.valid.asOf,
+    recorded: optionalRecordedInstantParts(
+      coordinate?.recorded?.asOf,
+      "recorded.asOf"
+    ),
+    currentInstant: typeof currentInstant === "string" ? sql`${currentInstant}` : currentInstant
+  };
+}
+function validityInstant(coordinate) {
+  if (coordinate.validMode === "asOf" && coordinate.validAsOf !== void 0) {
+    return sql`${coordinate.validAsOf}`;
+  }
+  if (coordinate.recorded !== void 0) {
+    return sql`${coordinate.recorded.recordedAt}`;
+  }
+  return coordinate.currentInstant;
+}
+function qualifiedColumn(alias, column) {
+  return sql`${sql.identifier(alias)}.${sql.identifier(column)}`;
+}
+function identityNodeVisibilitySql(coordinate, alias) {
+  const deletedAt = qualifiedColumn(alias, "deleted_at");
+  if (coordinate.validMode === "includeTombstones") return sql`1 = 1`;
+  if (coordinate.validMode === "includeEnded") {
+    return sql`${deletedAt} IS NULL`;
+  }
+  const validFrom = qualifiedColumn(alias, "valid_from");
+  const validTo = qualifiedColumn(alias, "valid_to");
+  const instant = validityInstant(coordinate);
+  return sql`
+    ${deletedAt} IS NULL
+    AND (${validFrom} IS NULL OR ${validFrom} <= ${instant})
+    AND (${validTo} IS NULL OR ${validTo} > ${instant})
+  `;
+}
+function structuralFoldVisibilitySql(coordinate, alias) {
+  const deletedAt = qualifiedColumn(alias, "deleted_at");
+  if (coordinate.recorded !== void 0) return sql`${deletedAt} IS NULL`;
+  if (coordinate.validMode !== "asOf") return sql`${deletedAt} IS NULL`;
+  const createdAt = qualifiedColumn(alias, "created_at");
+  const instant = validityInstant(coordinate);
+  return sql`${createdAt} <= ${instant} AND (${deletedAt} IS NULL OR ${deletedAt} > ${instant})`;
+}
+function identityNodeSnapshotSource(schema, graphId, coordinate) {
+  const table = coordinate.recorded === void 0 ? schema.nodesTable : schema.recordedNodesTable;
+  const recordedFilter = coordinate.recorded === void 0 ? sql`` : sql`
+      AND recorded_from <= ${coordinate.recorded.revision}
+      AND recorded_to > ${coordinate.recorded.revision}
+    `;
+  return sql`
+    SELECT kind, id, valid_from, valid_to, created_at, deleted_at
+    FROM ${table}
+    WHERE graph_id = ${graphId}
+      ${recordedFilter}
+  `;
+}
+function identityAssertionSnapshotSource(schema, graphId, coordinate, relation) {
+  const table = coordinate.recorded === void 0 ? schema.identityAssertionsTable : schema.recordedIdentityAssertionsTable;
+  const recordedFilter = coordinate.recorded === void 0 ? sql`` : sql`
+      AND recorded_from <= ${coordinate.recorded.revision}
+      AND recorded_to > ${coordinate.recorded.revision}
+    `;
+  const relationFilter = relation === void 0 ? sql`` : sql`AND rel = ${relation}`;
+  const instant = validityInstant(coordinate);
+  return sql`
+    SELECT ${IDENTITY_ASSERTION_COLUMNS}
+    FROM ${table}
+    WHERE graph_id = ${graphId}
+      ${recordedFilter}
+      AND deleted_at IS NULL
+      ${relationFilter}
+      AND valid_from <= ${instant}
+      AND (valid_to IS NULL OR valid_to > ${instant})
+  `;
+}
+function historicalIdentityReconstructionCtes(input) {
+  const nodes = identityNodeSnapshotSource(
+    input.schema,
+    input.graphId,
+    input.coordinate
+  );
+  const assertions = identityAssertionSnapshotSource(
+    input.schema,
+    input.graphId,
+    input.coordinate,
+    "same"
+  );
+  const sameIdEdges = input.sameIdAcrossKinds === "fold" ? sql`
+        UNION ALL
+        SELECT left_node.kind, left_node.id, right_node.kind, right_node.id
+        FROM node_snapshot left_node
+        JOIN node_snapshot right_node
+          ON right_node.id = left_node.id
+         AND right_node.kind <> left_node.kind
+        WHERE ${structuralFoldVisibilitySql(input.coordinate, "left_node")}
+          AND ${structuralFoldVisibilitySql(input.coordinate, "right_node")}
+      ` : sql``;
+  return sql`
+    node_snapshot(kind, id, valid_from, valid_to, created_at, deleted_at) AS (
+      ${nodes}
+    ),
+    same_assertions(a_kind, a_id, b_kind, b_id) AS (
+      SELECT a_kind, a_id, b_kind, b_id FROM (${assertions}) identity_assertions
+    ),
+    identity_edges(a_kind, a_id, b_kind, b_id) AS (
+      SELECT a_kind, a_id, b_kind, b_id FROM same_assertions
+      UNION ALL
+      SELECT b_kind, b_id, a_kind, a_id FROM same_assertions
+      ${sameIdEdges}
+    ),
+    seeds(seed_kind, seed_id) AS (
+      ${input.seedSource}
+    ),
+    identity_members(seed_kind, seed_id, kind, id) AS (
+      SELECT seeds.seed_kind, seeds.seed_id, seeds.seed_kind, seeds.seed_id
+      FROM seeds
+      JOIN node_snapshot n
+        ON n.kind = seeds.seed_kind AND n.id = seeds.seed_id
+      WHERE ${identityNodeVisibilitySql(input.coordinate, "n")}
+      UNION
+      SELECT member.seed_kind, member.seed_id, edge.b_kind, edge.b_id
+      FROM identity_members member
+      JOIN identity_edges edge
+        ON edge.a_kind = member.kind
+       AND edge.a_id = member.id
+    )
+  `;
+}
+var IDENTITY_PEER_CLASS_COLUMNS = sql.raw(
+  ["seed_kind", "seed_id", "kind", "id"].join(", ")
+);
+function historicalIdentityPeerClassQuery(input) {
+  const reconstruction = historicalIdentityReconstructionCtes({
+    ...input,
+    seedSource: sql`SELECT DISTINCT a_kind, a_id FROM identity_edges`
+  });
+  return sql`
+    WITH RECURSIVE
+    ${reconstruction}
+    SELECT member.seed_kind, member.seed_id, member.kind, member.id
+    FROM identity_members member
+    JOIN node_snapshot n ON n.kind = member.kind AND n.id = member.id
+    WHERE ${identityNodeVisibilitySql(input.coordinate, "n")}
+  `;
+}
+
 // src/query/compiler/predicates.ts
 var COMPARISON_OP_SQL = {
   eq: "=",
@@ -2058,8 +2210,31 @@ var RECORDED_EDGE_COLUMNS = [
   "tx_id",
   "meta"
 ];
+var RECORDED_IDENTITY_ASSERTION_COLUMNS = [
+  "history_id",
+  "graph_id",
+  "id",
+  "rel",
+  "a_kind",
+  "a_id",
+  "b_kind",
+  "b_id",
+  "valid_from",
+  "valid_to",
+  "created_at",
+  "updated_at",
+  "deleted_at",
+  "ended_by_kind",
+  "ended_by_id",
+  "recorded_from",
+  "recorded_to",
+  "op"
+];
 var RECORDED_NODE_COLUMN_LIST = sql.raw(RECORDED_NODE_COLUMNS.join(", "));
 var RECORDED_EDGE_COLUMN_LIST = sql.raw(RECORDED_EDGE_COLUMNS.join(", "));
+var RECORDED_IDENTITY_ASSERTION_COLUMN_LIST = sql.raw(
+  RECORDED_IDENTITY_ASSERTION_COLUMNS.join(", ")
+);
 var RECORDED_BIND_PARAM_BUDGET = 900;
 function recordedBindParamBudget(target) {
   const budget = target.capabilities.maxBindParameters ?? RECORDED_BIND_PARAM_BUDGET;
@@ -2113,6 +2288,26 @@ var recordedEdgeCells = {
   to_kind: (row) => sql`${row.to_kind}`,
   to_id: (row) => sql`${row.to_id}`
 };
+var recordedIdentityAssertionCells = {
+  history_id: () => sql`${generateId()}`,
+  graph_id: (row) => sql`${row.graph_id}`,
+  id: (row) => sql`${row.id}`,
+  rel: (row) => sql`${row.rel}`,
+  a_kind: (row) => sql`${row.a_kind}`,
+  a_id: (row) => sql`${row.a_id}`,
+  b_kind: (row) => sql`${row.b_kind}`,
+  b_id: (row) => sql`${row.b_id}`,
+  valid_from: (row) => sql`${row.valid_from}`,
+  valid_to: (row) => sql`${row.valid_to ?? sql.raw("NULL")}`,
+  created_at: (row) => sql`${row.created_at}`,
+  updated_at: (row) => sql`${row.updated_at}`,
+  deleted_at: (row) => sql`${row.deleted_at ?? sql.raw("NULL")}`,
+  ended_by_kind: (row) => sql`${row.ended_by_kind ?? sql.raw("NULL")}`,
+  ended_by_id: (row) => sql`${row.ended_by_id ?? sql.raw("NULL")}`,
+  recorded_from: (_row, recordedRevision) => sql`${recordedRevision}`,
+  recorded_to: () => sql`${RECORDED_MAX_REVISION}`,
+  op: (_row, _recordedRevision, operation) => sql`${operation}`
+};
 function recordedValuesTuple(columns, cells, row, recordedRevision, operation) {
   const tuple = columns.map(
     (column) => cells[column](row, recordedRevision, operation)
@@ -2144,6 +2339,9 @@ function recordedNodeChunkSize(target) {
 function recordedEdgeChunkSize(target) {
   return recordedChunkSize(target, RECORDED_EDGE_COLUMNS.length);
 }
+function recordedIdentityAssertionChunkSize(target) {
+  return recordedChunkSize(target, RECORDED_IDENTITY_ASSERTION_COLUMNS.length);
+}
 function insertRecordedNodeRows(target, table, inserts, recordedRevision) {
   return insertRecordedRows(
     target,
@@ -2166,6 +2364,17 @@ function insertRecordedEdgeRows(target, table, inserts, recordedRevision) {
     recordedRevision
   );
 }
+function insertRecordedIdentityAssertionRows(target, table, inserts, recordedRevision) {
+  return insertRecordedRows(
+    target,
+    table,
+    RECORDED_IDENTITY_ASSERTION_COLUMN_LIST,
+    RECORDED_IDENTITY_ASSERTION_COLUMNS,
+    recordedIdentityAssertionCells,
+    inserts,
+    recordedRevision
+  );
+}
 
 // src/store/recorded-capture/flush.ts
 function entityKey(entity) {
@@ -2176,6 +2385,9 @@ function entityKey(entity) {
     case "edge": {
       return `edge\0${entity.graphId}\0${entity.id}`;
     }
+    case "identity": {
+      return `identity\0${entity.graphId}\0${entity.id}`;
+    }
   }
 }
 async function closeOpenReturning(target, table, graphId, ids, recordedRevision, kind) {
@@ -2277,6 +2489,42 @@ async function flushEdges(target, schema, graphId, entities, recordedRevision) {
     );
   }
 }
+async function getIdentityAssertionRowsByIds(target, schema, graphId, ids) {
+  if (ids.length === 0) return /* @__PURE__ */ new Map();
+  const rows = await target.execute(
+    asCompiledRowsSql(sql`
+      SELECT ${IDENTITY_ASSERTION_COLUMNS}
+      FROM ${schema.identityAssertionsTable}
+      WHERE graph_id = ${graphId}
+        AND id IN (${sqlValueList(ids)})
+    `)
+  );
+  return new Map(rows.map((row) => [row.id, row]));
+}
+async function flushIdentityAssertions(target, schema, graphId, entities, recordedRevision) {
+  if (entities.length === 0) return;
+  const chunkSize = recordedIdentityAssertionChunkSize(target);
+  for (const entityChunk of chunk(entities, chunkSize)) {
+    const ids = entityChunk.map((entity) => entity.id);
+    const closed = await closeOpenReturning(
+      target,
+      schema.recordedIdentityAssertionsTable,
+      graphId,
+      ids,
+      recordedRevision
+    );
+    const afterById = await resolveAfterImages(
+      entityChunk,
+      (missing) => getIdentityAssertionRowsByIds(target, schema, graphId, missing)
+    );
+    await insertRecordedIdentityAssertionRows(
+      target,
+      schema.recordedIdentityAssertionsTable,
+      recordedInsertsFor(afterById, closed),
+      recordedRevision
+    );
+  }
+}
 async function closeOpenByKind(target, table, graphId, kind, recordedRevision) {
   await executeStatement(
     target,
@@ -2381,7 +2629,19 @@ function isCompatibleColumnType(dialect, declaredType, kind) {
   if (dialect === "sqlite") return hasSqliteAffinity(declaredType, kind);
   return kind === "revision" ? declaredType === "bigint" : declaredType === "timestamp with time zone";
 }
-function requiredRecordedColumns(schema) {
+function requiredRecordedColumns(schema, includeIdentity) {
+  const identityColumns = includeIdentity ? [
+    {
+      table: schema.tables.recordedIdentityAssertions,
+      column: "recorded_from",
+      kind: "revision"
+    },
+    {
+      table: schema.tables.recordedIdentityAssertions,
+      column: "recorded_to",
+      kind: "revision"
+    }
+  ] : [];
   return [
     {
       table: schema.tables.recordedNodes,
@@ -2412,11 +2672,12 @@ function requiredRecordedColumns(schema) {
       table: schema.tables.recordedClock,
       column: "recorded_at",
       kind: "wall-time"
-    }
+    },
+    ...identityColumns
   ];
 }
-async function assertCurrentRecordedSchema(backend, schema) {
-  const requirements = requiredRecordedColumns(schema);
+async function assertCurrentRecordedSchema(backend, schema, includeIdentity = false) {
+  const requirements = requiredRecordedColumns(schema, includeIdentity);
   const tables = [...new Set(requirements.map((entry) => entry.table))];
   const columnTypes = new Map(
     await Promise.all(
@@ -2425,6 +2686,20 @@ async function assertCurrentRecordedSchema(backend, schema) {
       )
     )
   );
+  const recordedIdentityTable = schema.tables.recordedIdentityAssertions;
+  if (includeIdentity && (columnTypes.get(recordedIdentityTable)?.size ?? 0) === 0) {
+    throw new ConfigurationError(
+      "Recorded identity history is not provisioned for this database.",
+      {
+        code: "RECORDED_IDENTITY_SCHEMA_MISSING",
+        dialect: backend.dialect,
+        table: recordedIdentityTable
+      },
+      {
+        suggestion: "Restore the missing recorded identity ledger from backup. If this is confirmed first-time identity enablement with no identity history to preserve, provision the relation through the backend's privileged setup path before reopening with history: true."
+      }
+    );
+  }
   const incompatible = requirements.flatMap((requirement) => {
     const actual = columnTypes.get(requirement.table)?.get(requirement.column);
     if (actual !== void 0 && isCompatibleColumnType(backend.dialect, actual, requirement.kind)) {
@@ -2512,6 +2787,9 @@ function createRecordedCaptureSession() {
     touchEdge(graphId, id, afterImage) {
       touch({ entity: "edge", graphId, id, afterImage });
     },
+    touchIdentityAssertion(graphId, id, afterImage) {
+      touch({ entity: "identity", graphId, id, afterImage });
+    },
     async flush(target, schema, ownsWriteLock) {
       if (sealed) {
         throw new ConfigurationError(
@@ -2540,6 +2818,9 @@ function createRecordedCaptureSession() {
         const edges = entities.filter(
           (entity) => entity.entity === "edge"
         );
+        const identityAssertions = entities.filter(
+          (entity) => entity.entity === "identity"
+        );
         await flushNodes(
           target,
           schema,
@@ -2554,12 +2835,33 @@ function createRecordedCaptureSession() {
           edges,
           recordedCommit.revision
         );
+        await flushIdentityAssertions(
+          target,
+          schema,
+          graphId,
+          identityAssertions,
+          recordedCommit.revision
+        );
       }
       touched.clear();
       return recordedByGraph;
     }
   };
 }
+var recordedIdentityBindings = /* @__PURE__ */ new WeakMap();
+function ignoreIdentityTouch() {
+  return;
+}
+async function withRecordedIdentityMutationTarget(target, fn) {
+  const binding = recordedIdentityBindings.get(target);
+  if (binding === void 0) {
+    return fn(target, ignoreIdentityTouch);
+  }
+  binding.session.assertOpen();
+  return fn(binding.target, (graphId, id, afterImage) => {
+    binding.session.touchIdentityAssertion(graphId, id, afterImage);
+  });
+}
 function createRecordedTransactionBackend(target, session, schema) {
   const nodeDispatch = nodeInsertDispatch(target);
   const edgeDispatch = edgeInsertDispatch(target);
@@ -2628,6 +2930,17 @@ function createRecordedTransactionBackend(target, session, schema) {
       session.touchNode(params.graphId, params.kind, params.id, row);
       return row;
     },
+    ...target.updateNodeSet === void 0 ? {} : {
+      async updateNodeSet(params) {
+        session.assertOpen();
+        await lockGraph(params.graphId);
+        const result = await requireDefined(target.updateNodeSet)(params);
+        for (const row of result.rows) {
+          session.touchNode(row.graph_id, row.kind, row.id, row);
+        }
+        return result;
+      }
+    },
     async deleteNode(params) {
       session.assertOpen();
       await lockGraph(params.graphId);
@@ -2732,6 +3045,8 @@ function createRecordedTransactionBackend(target, session, schema) {
     }
   });
   registerRecordedGraphLockMemo(overlay, graphLocks);
+  recordedIdentityBindings.set(overlay, { target, session });
+  recordedIdentityBindings.set(target, { target, session });
   return overlay;
 }
 function createRecordedTransactionScope(target, schema, ownsWriteLock = false) {
@@ -2791,6 +3106,20 @@ function createRecordedBackend(backend, schema) {
     async updateNode(params) {
       return capture((target) => target.updateNode(params));
     },
+    ...backend.updateNodeSet === void 0 ? {} : {
+      async updateNodeSet(params) {
+        return capture((target) => {
+          const updateNodeSet = target.updateNodeSet;
+          if (updateNodeSet === void 0) {
+            throw new ConfigurationError(
+              "Recorded updateNodeSet capability disappeared inside a transaction",
+              { operation: "updateNodeSet" }
+            );
+          }
+          return updateNodeSet(params);
+        });
+      }
+    },
     async deleteNode(params) {
       await capture((target) => target.deleteNode(params));
     },
@@ -2861,791 +3190,28 @@ function createRecordedBackend(backend, schema) {
   });
 }
 
-// src/store/embedding-sync.ts
-var embeddingFieldsCache = /* @__PURE__ */ new WeakMap();
-function getEmbeddingFields(schema) {
-  const cached = embeddingFieldsCache.get(schema);
-  if (cached) return cached;
-  const fields = resolveEmbeddingFields(schema);
-  embeddingFieldsCache.set(schema, fields);
-  return fields;
-}
-async function syncEmbeddings(ctx, schema, props) {
-  const { backend } = ctx;
-  if (!backend.upsertEmbedding || !backend.deleteEmbedding) {
-    return;
-  }
-  const embeddingFields = getEmbeddingFields(schema);
-  if (embeddingFields.length === 0) {
-    return;
-  }
-  for (const field of embeddingFields) {
-    const value = props[field.fieldPath];
-    if (isValidEmbeddingValue(value)) {
-      await backend.upsertEmbedding({
-        graphId: ctx.graphId,
-        nodeKind: ctx.nodeKind,
-        nodeId: ctx.nodeId,
-        fieldPath: field.fieldPath,
-        embedding: value,
-        dimensions: field.dimensions,
-        metric: field.metric,
-        indexType: field.indexType
-      });
-    } else if (value === void 0) {
-      await backend.deleteEmbedding({
-        graphId: ctx.graphId,
-        nodeKind: ctx.nodeKind,
-        nodeId: ctx.nodeId,
-        fieldPath: field.fieldPath,
-        dimensions: field.dimensions,
-        metric: field.metric,
-        indexType: field.indexType
-      });
-    }
-  }
-}
-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) {
-    return;
-  }
-  const embeddingFields = getEmbeddingFields(schema);
-  if (embeddingFields.length === 0) {
-    return;
-  }
-  for (const field of embeddingFields) {
-    await backend.deleteEmbedding({
-      graphId: ctx.graphId,
-      nodeKind: ctx.nodeKind,
-      nodeId: ctx.nodeId,
-      fieldPath: field.fieldPath,
-      dimensions: field.dimensions,
-      metric: field.metric,
-      indexType: field.indexType
-    });
-  }
-}
-function isValidEmbeddingValue(value) {
-  if (!Array.isArray(value)) {
-    return false;
-  }
-  return value.every((n) => typeof n === "number" && Number.isFinite(n));
-}
-
-// src/store/fulltext-sync.ts
-var FIELD_SEPARATOR = "\n";
-function resolveCombinedLanguage(fields) {
-  return fields[0]?.metadata.language ?? DEFAULT_SEARCHABLE_LANGUAGE;
-}
-function computeFulltextContent(schema, props) {
-  const searchableFields = getSearchableFields(schema);
-  if (searchableFields.length === 0) return void 0;
-  const parts = [];
-  for (const field of searchableFields) {
-    const value = props[field.fieldPath];
-    if (typeof value === "string" && value.length > 0) {
-      parts.push(value);
-    }
-  }
-  if (parts.length === 0) return void 0;
-  return {
-    content: parts.join(FIELD_SEPARATOR),
-    language: resolveCombinedLanguage(searchableFields)
-  };
-}
-async function syncFulltext(ctx, schema, props) {
-  const { backend } = ctx;
-  if (!backend.upsertFulltext || !backend.deleteFulltext) {
-    return;
-  }
-  const computed = computeFulltextContent(schema, props);
-  if (computed !== void 0) {
-    await backend.upsertFulltext({
-      graphId: ctx.graphId,
-      nodeKind: ctx.nodeKind,
-      nodeId: ctx.nodeId,
-      content: computed.content,
-      language: computed.language
-    });
-    return;
-  }
-  if (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 = 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) {
-    return;
-  }
-  await backend.deleteFulltext({
-    graphId: ctx.graphId,
-    nodeKind: ctx.nodeKind,
-    nodeId: ctx.nodeId
-  });
-}
-
-// src/constraints/index.ts
-var UNIQUE_KEY_SEPARATOR = "";
-var UNIQUE_KEY_NULL_MARKER = "";
-function computeUniqueKey(props, fields, collation) {
-  const values = fields.map((field) => {
-    const value = props[field];
-    if (value === void 0 || value === null) {
-      return UNIQUE_KEY_NULL_MARKER;
-    }
-    const stringValue = typeof value === "string" ? value : typeof value === "number" || typeof value === "boolean" ? value.toString() : JSON.stringify(value);
-    return collation === "caseInsensitive" ? stringValue.toLowerCase() : stringValue;
-  });
-  return values.join(UNIQUE_KEY_SEPARATOR);
-}
-function checkWherePredicate(constraint, props) {
-  if (!constraint.where) {
-    return true;
-  }
-  const predicateBuilder = buildPredicateContext(props);
-  const predicate2 = constraint.where(predicateBuilder);
-  return evaluatePredicate(predicate2, props);
-}
-function buildPredicateContext(props) {
-  const context = {};
-  for (const key of Object.keys(props)) {
-    context[key] = {
-      isNull: () => ({
-        __type: "unique_predicate",
-        field: key,
-        op: "isNull"
-      }),
-      isNotNull: () => ({
-        __type: "unique_predicate",
-        field: key,
-        op: "isNotNull"
-      })
-    };
-  }
-  return context;
-}
-function evaluatePredicate(predicate2, props) {
-  if (typeof predicate2 !== "object" || predicate2 === null || !("__type" in predicate2)) {
-    return true;
-  }
-  const pred = predicate2;
-  if (pred.__type !== "unique_predicate") {
-    return true;
-  }
-  const value = props[pred.field];
-  if (pred.op === "isNull") {
-    return value === null || value === void 0;
-  }
-  return isPresent(value);
-}
-function getKindsForUniquenessCheck(baseKind, scope, registry) {
-  if (scope === "kind") {
-    return [baseKind];
-  }
-  const root = findRootAncestor(baseKind, registry);
-  return registry.expandSubClasses(root);
-}
-function findRootAncestor(kind, registry) {
-  const ancestors = registry.getAncestors(kind);
-  if (ancestors.size === 0) {
-    return kind;
-  }
-  for (const ancestor of ancestors) {
-    if (registry.getAncestors(ancestor).size === 0) {
-      return ancestor;
-    }
-  }
-  const firstAncestor = [...ancestors][0];
-  return firstAncestor ? findRootAncestor(firstAncestor, registry) : kind;
-}
-function checkCardinality(edgeKind, fromKind, fromId, cardinality, existingEdgeCount, hasActiveEdge) {
-  switch (cardinality) {
-    case "many": {
-      return void 0;
-    }
-    case "one": {
-      if (existingEdgeCount > 0) {
-        return new CardinalityError({
-          edgeKind,
-          fromKind,
-          fromId,
-          cardinality: "one",
-          existingCount: existingEdgeCount
-        });
-      }
-      return void 0;
-    }
-    case "unique": {
-      return void 0;
-    }
-    case "oneActive": {
-      if (hasActiveEdge) {
-        return new CardinalityError({
-          edgeKind,
-          fromKind,
-          fromId,
-          cardinality: "oneActive",
-          existingCount: 1
-        });
-      }
-      return void 0;
-    }
-  }
-}
-function checkUniqueEdge(edgeKind, fromKind, fromId, _toKind, _toId, existingCount) {
-  if (existingCount > 0) {
-    return new CardinalityError({
-      edgeKind,
-      fromKind,
-      fromId,
-      cardinality: "unique",
-      existingCount
-    });
-  }
-  return void 0;
-}
-function validateEdgeEndpoints(edgeKind, fromKind, toKind, registration, registry) {
-  const validFromKinds = registration.from.map((node) => node.kind);
-  if (!registry.isAssignableToAny(fromKind, validFromKinds)) {
-    return new EndpointError({
-      edgeKind,
-      endpoint: "from",
-      actualKind: fromKind,
-      expectedKinds: validFromKinds
-    });
-  }
-  const validToKinds = registration.to.map((node) => node.kind);
-  if (!registry.isAssignableToAny(toKind, validToKinds)) {
-    return new EndpointError({
-      edgeKind,
-      endpoint: "to",
-      actualKind: toKind,
-      expectedKinds: validToKinds
-    });
-  }
-  return void 0;
-}
-function checkDisjointness(nodeId, nodeKind, existingKinds, registry) {
-  for (const existingKind of existingKinds) {
-    if (registry.areDisjoint(nodeKind, existingKind)) {
-      return new DisjointError({
-        nodeId,
-        attemptedKind: nodeKind,
-        conflictingKind: existingKind
-      });
-    }
-  }
-  return void 0;
-}
-
-// src/store/uniqueness.ts
-function createUniquenessContext(graphId, registry, backend) {
-  return { graphId, registry, backend };
-}
-async function checkUniquenessConstraints(ctx, kind, id, props, constraints) {
-  for (const constraint of constraints) {
-    if (!checkWherePredicate(constraint, props)) {
-      continue;
-    }
-    const key = computeUniqueKey(
-      props,
-      constraint.fields,
-      constraint.collation
-    );
-    const kindsToCheck = getKindsForUniquenessCheck(
-      kind,
-      constraint.scope,
-      ctx.registry
-    );
-    for (const kindToCheck of kindsToCheck) {
-      const existing = await ctx.backend.checkUnique({
-        graphId: ctx.graphId,
-        nodeKind: kindToCheck,
-        constraintName: constraint.name,
-        key
-      });
-      if (existing && existing.node_id !== id) {
-        throw new UniquenessError({
-          constraintName: constraint.name,
-          kind: kindToCheck,
-          existingId: existing.node_id,
-          newId: id,
-          fields: constraint.fields
-        });
-      }
-    }
-  }
-}
-async function insertUniquenessEntries(ctx, kind, id, props, constraints) {
-  for (const constraint of constraints) {
-    if (!checkWherePredicate(constraint, props)) {
-      continue;
-    }
-    const key = computeUniqueKey(
-      props,
-      constraint.fields,
-      constraint.collation
-    );
-    await ctx.backend.insertUnique({
-      graphId: ctx.graphId,
-      nodeKind: kind,
-      constraintName: constraint.name,
-      key,
-      nodeId: id,
-      concreteKind: kind
-    });
-  }
-}
-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)) {
-      continue;
-    }
-    const key = computeUniqueKey(
-      props,
-      constraint.fields,
-      constraint.collation
-    );
-    await ctx.backend.deleteUnique({
-      graphId: ctx.graphId,
-      nodeKind: kind,
-      constraintName: constraint.name,
-      key
-    });
-  }
-}
-async function updateUniquenessEntries(ctx, kind, id, oldProps, newProps, constraints) {
-  const pending = [];
-  for (const constraint of constraints) {
-    const oldApplies = checkWherePredicate(constraint, oldProps);
-    const newApplies = checkWherePredicate(constraint, newProps);
-    const oldKey = oldApplies ? computeUniqueKey(oldProps, constraint.fields, constraint.collation) : void 0;
-    const newKey = newApplies ? computeUniqueKey(newProps, constraint.fields, constraint.collation) : void 0;
-    if (!oldApplies && !newApplies) {
-      continue;
-    }
-    if (oldApplies && newApplies && oldKey === newKey) {
-      continue;
-    }
-    if (newApplies && newKey !== void 0) {
-      const kindsToCheck = getKindsForUniquenessCheck(
-        kind,
-        constraint.scope,
-        ctx.registry
-      );
-      for (const kindToCheck of kindsToCheck) {
-        const existing = await ctx.backend.checkUnique({
-          graphId: ctx.graphId,
-          nodeKind: kindToCheck,
-          constraintName: constraint.name,
-          key: newKey
-        });
-        if (existing && existing.node_id !== id) {
-          throw new UniquenessError({
-            constraintName: constraint.name,
-            kind: kindToCheck,
-            existingId: existing.node_id,
-            newId: id,
-            fields: constraint.fields
-          });
-        }
-      }
-    }
-    pending.push({ constraintName: constraint.name, oldKey, newKey });
-  }
-  for (const mutation of pending) {
-    if (mutation.oldKey !== void 0) {
-      await ctx.backend.deleteUnique({
-        graphId: ctx.graphId,
-        nodeKind: kind,
-        constraintName: mutation.constraintName,
-        key: mutation.oldKey
-      });
-    }
-  }
-  for (const mutation of pending) {
-    if (mutation.newKey !== void 0) {
-      await ctx.backend.insertUnique({
-        graphId: ctx.graphId,
-        nodeKind: kind,
-        constraintName: mutation.constraintName,
-        key: mutation.newKey,
-        nodeId: id,
-        concreteKind: kind
-      });
-    }
-  }
-}
-
-// src/store/operations/node-write-pipeline.ts
-function createNodeWriteContext(graphId, registry, lock) {
-  return { graphId, registry, lock };
-}
-function uniquenessContext(ctx, backend) {
-  return createUniquenessContext(ctx.graphId, ctx.registry, backend);
-}
-function nodeSyncContext(ctx, kind, id, backend) {
-  return { graphId: ctx.graphId, nodeKind: kind, nodeId: id, backend };
-}
-async function enforceNodeDeleteBehavior(ctx, args, backend, policy) {
-  if (policy?.enforceDeleteBehavior === false) return;
-  const behavior = args.onDelete ?? "restrict";
-  const connectedEdges = await backend.findEdgesConnectedTo({
-    graphId: ctx.graphId,
-    nodeKind: args.kind,
-    nodeId: args.id
-  });
-  if (connectedEdges.length === 0) return;
-  switch (behavior) {
-    case "restrict": {
-      throw new RestrictedDeleteError({
-        nodeKind: args.kind,
-        nodeId: args.id,
-        edgeCount: connectedEdges.length,
-        edgeKinds: [...new Set(connectedEdges.map((edge) => edge.kind))]
-      });
-    }
-    case "cascade":
-    case "disconnect": {
-      const batchDelete = args.mode === "hard" ? backend.hardDeleteEdgesBatch : backend.deleteEdgesBatch;
-      if (batchDelete !== void 0) {
-        await batchDelete({
-          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 }));
-      }
-      break;
-    }
-  }
-}
-async function applyNodeInsertSideEffects(ctx, args, backend) {
-  await insertUniquenessEntries(
-    uniquenessContext(ctx, backend),
-    args.kind,
-    args.id,
-    args.props,
-    args.uniqueConstraints
-  );
-  await Promise.all([
-    syncEmbeddings(
-      nodeSyncContext(ctx, args.kind, args.id, backend),
-      args.schema,
-      args.props
-    ),
-    syncFulltext(
-      nodeSyncContext(ctx, args.kind, args.id, backend),
-      args.schema,
-      args.props
-    )
-  ]);
-}
-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 rowPropsToObject(row.props);
-}
-async function applyNodeUpdate(ctx, args, backend) {
-  const { kind, id } = args.existing;
-  if (args.existing.deleted_at === void 0) {
-    await updateUniquenessEntries(
-      uniquenessContext(ctx, backend),
-      kind,
-      id,
-      parseRowProps(args.existing),
-      args.validatedProps,
-      args.uniqueConstraints
-    );
-  } else {
-    await checkUniquenessConstraints(
-      uniquenessContext(ctx, backend),
-      kind,
-      id,
-      args.validatedProps,
-      args.uniqueConstraints
-    );
-    await insertUniquenessEntries(
-      uniquenessContext(ctx, backend),
-      kind,
-      id,
-      args.validatedProps,
-      args.uniqueConstraints
-    );
-  }
-  const updateParams = {
-    graphId: ctx.graphId,
-    kind,
-    id,
-    props: args.validatedProps,
-    incrementVersion: true
-  };
-  if (args.validTo !== void 0) updateParams.validTo = args.validTo;
-  if (args.clearDeleted) updateParams.clearDeleted = true;
-  const row = await backend.updateNode(updateParams);
-  await Promise.all([
-    syncEmbeddings(
-      nodeSyncContext(ctx, kind, id, backend),
-      args.schema,
-      args.validatedProps
-    ),
-    syncFulltext(
-      nodeSyncContext(ctx, kind, id, backend),
-      args.schema,
-      args.validatedProps
-    )
-  ]);
-  return row;
-}
-async function applyNodeSoftDelete(ctx, args, backend, policy) {
-  const { kind, id } = args.existing;
-  await enforceNodeDeleteBehavior(
-    ctx,
-    { kind, id, mode: "soft", onDelete: args.onDelete },
-    backend,
-    policy
-  );
-  await backend.deleteNode({
-    graphId: ctx.graphId,
-    kind,
-    id
-  });
-  await deleteUniquenessEntries(
-    uniquenessContext(ctx, backend),
-    kind,
-    parseRowProps(args.existing),
-    args.uniqueConstraints
-  );
-  await deleteNodeEmbeddings(
-    nodeSyncContext(ctx, kind, id, backend),
-    args.schema
-  );
-  await deleteNodeFulltext(
-    nodeSyncContext(ctx, kind, id, backend),
-    args.schema
-  );
-}
-async function applyNodeHardDelete(ctx, args, backend) {
-  await enforceNodeDeleteBehavior(
-    ctx,
-    { kind: args.kind, id: args.id, mode: "hard", onDelete: args.onDelete },
-    backend
-  );
-  await backend.hardDeleteNode({
-    graphId: ctx.graphId,
-    kind: args.kind,
-    id: args.id
-  });
-  await deleteNodeEmbeddings(
-    nodeSyncContext(ctx, args.kind, args.id, backend),
-    args.schema
-  );
-}
-async function applyNodeResurrect(ctx, args, backend) {
-  const { kind, id } = args.existing;
-  const props = parseRowProps(args.existing);
-  await checkUniquenessConstraints(
-    uniquenessContext(ctx, backend),
-    kind,
-    id,
-    props,
-    args.uniqueConstraints
-  );
-  await insertUniquenessEntries(
-    uniquenessContext(ctx, backend),
-    kind,
-    id,
-    props,
-    args.uniqueConstraints
-  );
-  const row = await backend.updateNode({
-    graphId: ctx.graphId,
-    kind,
-    id,
-    props,
-    incrementVersion: true,
-    clearDeleted: true
-  });
-  await Promise.all([
-    syncEmbeddings(nodeSyncContext(ctx, kind, id, backend), args.schema, props),
-    syncFulltext(nodeSyncContext(ctx, kind, id, backend), args.schema, props)
-  ]);
-  return row;
+// src/utils/compare.ts
+function compareStrings(left, right) {
+  if (left < right) return -1;
+  return left > right ? 1 : 0;
+}
+function compareCodePoints(left, right) {
+  if (left === right) return 0;
+  let leftIndex = 0;
+  let rightIndex = 0;
+  while (leftIndex < left.length && rightIndex < right.length) {
+    const leftPoint = requireDefined(left.codePointAt(leftIndex));
+    const rightPoint = requireDefined(right.codePointAt(rightIndex));
+    if (leftPoint !== rightPoint) return leftPoint < rightPoint ? -1 : 1;
+    leftIndex += leftPoint > 65535 ? 2 : 1;
+    rightIndex += rightPoint > 65535 ? 2 : 1;
+  }
+  const leftExhausted = leftIndex >= left.length;
+  const rightExhausted = rightIndex >= right.length;
+  if (leftExhausted && rightExhausted) return 0;
+  return leftExhausted ? -1 : 1;
 }
 
-export { AUTO_REFRESH_STATISTICS_ROW_THRESHOLD, CURRENT_READ_INSTANT_PLACEHOLDER, STORE_RUNTIME, TRANSACTION_RUNTIME, advanceRevisionClock, applyNodeHardDelete, applyNodeInsertSideEffects, applyNodeInsertSideEffectsBatch, applyNodeResurrect, applyNodeSoftDelete, applyNodeUpdate, arrayField, assertCurrentRecordedSchema, assertRecordedCaptureTransactionIsolation, assertRevisionTrackableBackend, baseField, buildFieldBuilderForTypeInfo, buildPredicateIndex, checkCardinality, checkDisjointness, checkUniqueEdge, checkUniquenessConstraints, checkWherePredicate, closeRecordedHardDeletedKind, compileFieldValue, compileKindFilter, compilePredicateClauses, compilePredicateExpression, compileTemporalFilter, computeFulltextContent, computeUniqueKey, createFulltextAccessor, createGraphBackendProjection, createNodeWriteContext, createRecordedBackend, createRecordedTransactionScope, createUniquenessContext, currentReadInstant, currentReadInstantFor, dateField, edgeInsertDispatch, ensureRevisionOrigin, exists, extractFulltextMatchPredicates, extractTemporalOptions, extractVectorSimilarityPredicates, fieldRef, generateId, getEdgeRowsByIds, getEmbeddingFields, getFieldPointer, getHybridTargetAlias, getKindsForUniquenessCheck, getNodeKindsForAlias, getNodeRowsByIds, getPredicatesForAlias, inSubquery, isParameterRef, lockRecordedGraphWrite, nodeInsertDispatch, notExists, notInSubquery, numberField, objectField, param, projectBackendMembers, readRecordedClock, readRevisionOrigin, recordedBindParamBudget, recordedCaptureRequiresCallbackTransactionError, resolveParameterValueType, runInsertBatch, runInsertBatchReturning, runInsertNoReturn, sqlValueList, storeBackend, storeRuntime, stringField, throwHistoryUnsafeSqlAccess, throwRevisionTrackingUnsafeSqlAccess, transactionBackend, transactionNodeOperationHookRunner, uncapturedGraphWriteLock, validateEdgeEndpoints, withPinnedReadInstant, withRecordedFlushObserver };
-//# sourceMappingURL=chunk-FSXTPBRN.js.map
-//# sourceMappingURL=chunk-FSXTPBRN.js.map
+export { CURRENT_READ_INSTANT_PLACEHOLDER, IDENTITY_ASSERTION_COLUMNS, IDENTITY_PEER_CLASS_COLUMNS, advanceRevisionClock, arrayField, assertCurrentRecordedSchema, assertRecordedCaptureTransactionIsolation, assertRevisionTrackableBackend, baseField, buildFieldBuilderForTypeInfo, buildPredicateIndex, closeRecordedHardDeletedKind, compareCodePoints, compareStrings, compileFieldValue, compileKindFilter, compilePredicateClauses, compilePredicateExpression, compileTemporalFilter, createFulltextAccessor, createGraphBackendProjection, createRecordedBackend, createRecordedTransactionScope, currentReadInstant, currentReadInstantFor, dateField, edgeInsertDispatch, ensureRevisionOrigin, exists, extractFulltextMatchPredicates, extractTemporalOptions, extractVectorSimilarityPredicates, fieldRef, generateId, getEdgeRowsByIds, getFieldPointer, getHybridTargetAlias, getNodeKindsForAlias, getNodeRowsByIds, getPredicatesForAlias, historicalIdentityPeerClassQuery, historicalIdentityReconstructionCtes, identityAssertionSnapshotSource, identityNodeSnapshotSource, identityNodeVisibilitySql, identitySqlCoordinate, inSubquery, isParameterRef, lockRecordedGraphWrite, nodeInsertDispatch, notExists, notInSubquery, numberField, objectField, param, projectBackendMembers, readRecordedClock, readRevisionOrigin, recordedBindParamBudget, recordedCaptureRequiresCallbackTransactionError, resolveParameterValueType, runInsertBatch, runInsertBatchReturning, runInsertNoReturn, sqlValueList, stringField, throwHistoryUnsafeSqlAccess, throwRevisionTrackingUnsafeSqlAccess, uncapturedGraphWriteLock, withPinnedReadInstant, withRecordedFlushObserver, withRecordedIdentityMutationTarget };
+//# sourceMappingURL=chunk-NQ6BRJBE.js.map
+//# sourceMappingURL=chunk-NQ6BRJBE.js.map