@nicia-ai/typegraph 0.33.0 → 0.34.0

package/dist/{chunk-WLP6TKFB.js → chunk-WLRIWYHQ.js}

@@ -1,307 +1,25 @@
 import { quoteIdentifier, EMPTY_REQUIRED_COLUMNS, addRequiredColumn, markSelectiveFieldAsRequired, markFieldRefAsRequired, NODE_COLUMNS, shouldProjectColumn, mapSelectiveSystemFieldToColumn, isIdFieldRef, isAggregateExpr, EDGE_COLUMNS } from './chunk-3EUKJEQ3.js';
-import { loadAndMergeGraphExtensionDocument, ensureSchema, loadAndVerifyGraph, mergeGraphExtension, commitNewSchemaVersion, applyDeprecatedKinds, loadActiveSchemaWithBootstrap, parseSerializedSchema, computeClosuresFromOntology, createEmptyClosures, KindRegistry, extensionKindNames, serializeSchemaProperties, buildGraphExtensionOntologyKeySet, compileTimeOntologyKey, getTypeName, validateNodeProps, validateEdgeProps } from './chunk-XVUJY72M.js';
-import { validateCanonicalIsoDate, nowIso, isKnownKind, validateOptionalCanonicalIsoDate, getNodeKinds, getEdgeKinds } from './chunk-QBYTJSAY.js';
-import { generateIndexDDL } from './chunk-PIHXFF73.js';
-import { NODE_META_KEYS, EDGE_META_KEYS } from './chunk-6NRFUHMS.js';
-import { createSchemaIntrospector, getSearchableMetadata, DEFAULT_SEARCHABLE_LANGUAGE } from './chunk-IZ4PCL47.js';
-import { resolveEmbeddingFields } from './chunk-454I6GDF.js';
-import { IncompatibleChangeError, filterReservedKeys, RESERVED_NODE_KEYS, RESERVED_EDGE_KEYS, RemoveCompileTimeKindError, KindHasReferentsError, validateProjectionField } from './chunk-YCV72E6L.js';
-import { isParameterRef, fieldRef, buildFieldBuilderForTypeInfo, stringField, createFulltextAccessor, runOptionallyInTransaction, createEdgeRowMapper, createNodeRowMapper, baseField, objectField, arrayField, dateField, numberField, createBackendOverlay, POSTGRES_ROW_MAPPER_CONFIG, SQLITE_ROW_MAPPER_CONFIG, compileKindFilter, chunk, sqlValueList, isPresent, groupBy, buildPredicateIndex, compileFieldValue, extractVectorSimilarityPredicates, extractFulltextMatchPredicates, compilePredicateExpression, getPredicatesForAlias, getNodeKindsForAlias, getHybridTargetAlias, compilePredicateClauses } from './chunk-PYD3UCDU.js';
-import { withRecordedRelationsPrecondition, sortedReplacer, canonicalEqual, isMissingTableError } from './chunk-GYVBEZAO.js';
-import { getDialect, assertVectorMinScore, compileNodeIndexFieldKeys, compileIndexWhere, vectorScoreExpression, vectorMinScoreCondition, sqlNull } from './chunk-C4C4Q7A6.js';
-import { MAX_PG_IDENTIFIER_LENGTH, DEFAULT_PAGINATION_LIMIT, DEFAULT_STREAM_BATCH_SIZE, sha256Hex, SQLITE_PATH_DELIMITER, PG_ARRAY_START, PG_ARRAY_END, PG_PATH_ELEMENT_SEPARATOR, fnv1aBase36 } from './chunk-2YMGNYXY.js';
-import { ConfigurationError, UnsupportedPredicateError, ValidationError, KindNotFoundError, EndpointError, EagerMaterializationError, CompilerInvariantError, DatabaseOperationError, EdgeNotFoundError, NodeIndexNotFoundError, NodeConstraintNotFoundError, EndpointNotFoundError, RestrictedDeleteError, CardinalityError, UniquenessError, DisjointError, NodeNotFoundError } from './chunk-TQOYM4LN.js';
+import { createEdgeRowMapper, createNodeRowMapper, POSTGRES_ROW_MAPPER_CONFIG, SQLITE_ROW_MAPPER_CONFIG } from './chunk-QV245VMN.js';
+import { runHookedWriteOperation, runInWriteTransaction } from './chunk-6SCVW4AS.js';
+import { loadAndMergeGraphExtensionDocument, ensureSchema, loadAndVerifyGraph, mergeGraphExtension, commitNewSchemaVersion, applyDeprecatedKinds, loadActiveSchemaWithBootstrap, parseSerializedSchema, computeClosuresFromOntology, createEmptyClosures, KindRegistry, extensionKindNames, serializeSchemaProperties, buildGraphExtensionOntologyKeySet, compileTimeOntologyKey, getTypeName, validateNodeProps, validateEdgeProps } from './chunk-K2TGS3EN.js';
+import { sortedReplacer, canonicalEqual } from './chunk-UR7W5YQK.js';
+import { isKnownKind, getNodeKinds, getEdgeKinds } from './chunk-CHXTTSC6.js';
+import { generateIndexDDL } from './chunk-SHLY4MCM.js';
+import { getDialect, assertVectorMinScore, compileNodeIndexFieldKeys, compileIndexWhere, vectorScoreExpression, vectorMinScoreCondition } from './chunk-KUTNI6SI.js';
+import { NODE_META_KEYS, EDGE_META_KEYS } from './chunk-4DIBPQNJ.js';
+import { sha256Hex, fnv1aBase36 } from './chunk-K34OPSJK.js';
+import { createSchemaIntrospector } from './chunk-BVTWD66D.js';
+import { IncompatibleChangeError, filterReservedKeys, RESERVED_NODE_KEYS, RESERVED_EDGE_KEYS, RemoveCompileTimeKindError, KindHasReferentsError, validateProjectionField } from './chunk-ZURTTSCM.js';
+import { compareStrings } from './chunk-4S2FXGBJ.js';
+import { resolveReadCoordinate, withRecordedCoordinate, describeCoordinate, coordinateContext, DEFAULT_SQL_SCHEMA, requireSqlSchema, recordedReadSchemaFor, asCompiledSelectSql, getSearchableFields, createSqlSchema, requireExternalRecordedReadSource, createRecordedReadBinding, createRecordedBackend, readRecordedClock, asRecordedInstant, recordedCaptureRequiresCallbackTransactionError, assertRecordedCaptureTransactionIsolation, createRecordedTransactionScope, lockRecordedGraphWrite, createHistoryUnsafeSqlRef, generateId, vectorSlotKey, getEmbeddingFields, computeFulltextContent, recordedReadSqlSchema, requireRecordedReadBinding, asCompiledRowsSql, getKindsForUniquenessCheck, checkWherePredicate, computeUniqueKey, applyNodeHardDelete, createNodeWriteContext, applyNodeSoftDelete, runInsertBatch, nodeInsertDispatch, runInsertBatchReturning, edgeInsertDispatch, getNodeRowsByIds, getEdgeRowsByIds, applyNodeUpdate, applyNodeInsertSideEffects, checkCardinality, checkUniqueEdge, validateEdgeEndpoints, assertValidRecordedInstant, checkUniquenessConstraints, createUniquenessContext, recordedBindParamBudget, checkDisjointness, closeRecordedHardDeletedKind, asCompiledStatementSql, EMBEDDINGS_CTE_ALIAS, FULLTEXT_CTE_ALIAS, HYBRID_CANDIDATES_CTE_ALIAS, ALIAS_CTE_PREFIX } from './chunk-A7SZZFAG.js';
+import { isParameterRef, fieldRef, buildFieldBuilderForTypeInfo, stringField, createFulltextAccessor, runOptionallyInTransaction, baseField, objectField, arrayField, dateField, numberField, isLiveNodeRow, createBackendOverlay, compileKindFilter, chunk, sqlValueList, buildPredicateIndex, compileFieldValue, extractVectorSimilarityPredicates, extractFulltextMatchPredicates, compilePredicateExpression, getPredicatesForAlias, getNodeKindsForAlias, getHybridTargetAlias, compilePredicateClauses } from './chunk-V3QNTB7Z.js';
+import { nowIso, validateOptionalCanonicalIsoDate } from './chunk-XXVEULWX.js';
+import { withRecordedRelationsPrecondition, isMissingTableError } from './chunk-2MRAX3UE.js';
+import { DEFAULT_PAGINATION_LIMIT, DEFAULT_STREAM_BATCH_SIZE, SQLITE_PATH_DELIMITER, PG_ARRAY_START, PG_ARRAY_END, PG_PATH_ELEMENT_SEPARATOR, MAX_PG_IDENTIFIER_LENGTH } from './chunk-2EBMPJBO.js';
+import { resolveEmbeddingFields } from './chunk-Z5XBMDXU.js';
+import { ConfigurationError, UnsupportedPredicateError, ValidationError, KindNotFoundError, EndpointError, EagerMaterializationError, CompilerInvariantError, UniquenessError, DatabaseOperationError, CardinalityError, EdgeNotFoundError, NodeIndexNotFoundError, NodeConstraintNotFoundError, NodeNotFoundError, EndpointNotFoundError } from './chunk-TQOYM4LN.js';
 import { jsonPointer, parseJsonPointer, resolveJsonPointer } from './chunk-K5P5OZXS.js';
-import { sql, Placeholder } from 'drizzle-orm';
-import { nanoid } from 'nanoid';
-
-// src/core/temporal.ts
-var RECORDED_MAX = "9999-12-31T23:59:59.999Z";
-function assertValidRecordedInstant(value, path) {
-  validateCanonicalIsoDate(value, path);
-  if (value >= RECORDED_MAX) {
-    throw new ValidationError(
-      `${path} must be before the recorded-time open sentinel ${RECORDED_MAX}.`,
-      {
-        issues: [
-          {
-            path,
-            message: `Expected a timestamp before ${RECORDED_MAX}, got "${value}"`
-          }
-        ]
-      },
-      {
-        suggestion: "Use a real recorded-time commit instant, not the open-interval sentinel."
-      }
-    );
-  }
-}
-function asRecordedInstant(value) {
-  assertValidRecordedInstant(value, "asRecordedInstant");
-  return value;
-}
-function resolveReadCoordinate(mode, asOf, suggestion) {
-  if (mode !== "asOf" && asOf !== void 0) {
-    throw new ValidationError(
-      `Temporal mode "${mode}" does not take an asOf timestamp.`,
-      {
-        issues: [
-          {
-            path: "asOf",
-            message: `asOf is only valid with mode "asOf", not "${mode}"`
-          }
-        ]
-      },
-      {
-        suggestion: 'Pin an instant with store.asOf(timestamp) or store.view({ mode: "asOf", asOf }); drop asOf for other modes.'
-      }
-    );
-  }
-  assertValidAsOf(
-    mode,
-    asOf,
-    suggestion === void 0 ? void 0 : { suggestion }
-  );
-  return { valid: asOf === void 0 ? { mode } : { mode, asOf } };
-}
-function withRecordedCoordinate(coordinate, recordedAsOf) {
-  assertValidRecordedInstant(recordedAsOf, "asOfRecorded");
-  return {
-    ...coordinate,
-    recorded: { asOf: recordedAsOf }
-  };
-}
-function assertValidAsOf(mode, asOf, options) {
-  if (mode === "asOf" && asOf === void 0) {
-    throw new ValidationError(
-      'Temporal mode "asOf" requires a timestamp',
-      {
-        issues: [
-          { path: "asOf", message: "Timestamp is required for asOf mode" }
-        ]
-      },
-      {
-        suggestion: options?.suggestion ?? 'Provide an ISO-8601 timestamp for asOf mode, e.g. "2026-01-01T00:00:00.000Z".'
-      }
-    );
-  }
-  if (asOf !== void 0) {
-    validateCanonicalIsoDate(asOf, "asOf");
-  }
-}
-function describeCoordinate(coordinate) {
-  const { mode, asOf } = coordinate.valid;
-  const valid = asOf === void 0 ? `mode "${mode}"` : `mode "${mode}" asOf ${asOf}`;
-  return coordinate.recorded === void 0 ? valid : `${valid}, recorded asOf ${coordinate.recorded.asOf}`;
-}
-function coordinateContext(coordinate) {
-  const { mode, asOf } = coordinate.valid;
-  return {
-    temporalMode: mode,
-    ...asOf !== void 0 && { asOf },
-    ...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;
-  tables;
-  nodesTable;
-  edgesTable;
-  recordedNodesTable;
-  recordedEdgesTable;
-  recordedClockTable;
-  fulltextTable;
-  constructor(fields) {
-    this.tables = fields.tables;
-    this.nodesTable = fields.nodesTable;
-    this.edgesTable = fields.edgesTable;
-    this.recordedNodesTable = fields.recordedNodesTable;
-    this.recordedEdgesTable = fields.recordedEdgesTable;
-    this.recordedClockTable = fields.recordedClockTable;
-    this.fulltextTable = fields.fulltextTable;
-    void this.#brand;
-    Object.freeze(this);
-  }
-};
-var DEFAULT_TABLE_NAMES = {
-  nodes: "typegraph_nodes",
-  edges: "typegraph_edges",
-  recordedNodes: "typegraph_recorded_nodes",
-  recordedEdges: "typegraph_recorded_edges",
-  recordedClock: "typegraph_recorded_clock",
-  fulltext: "typegraph_node_fulltext",
-  uniques: "typegraph_node_uniques"
-};
-function resolveTableNames(names) {
-  return {
-    nodes: names.nodes ?? DEFAULT_TABLE_NAMES.nodes,
-    edges: names.edges ?? DEFAULT_TABLE_NAMES.edges,
-    recordedNodes: names.recordedNodes ?? DEFAULT_TABLE_NAMES.recordedNodes,
-    recordedEdges: names.recordedEdges ?? DEFAULT_TABLE_NAMES.recordedEdges,
-    recordedClock: names.recordedClock ?? DEFAULT_TABLE_NAMES.recordedClock,
-    fulltext: names.fulltext ?? DEFAULT_TABLE_NAMES.fulltext,
-    uniques: names.uniques ?? DEFAULT_TABLE_NAMES.uniques
-  };
-}
-var VALID_IDENTIFIER_PATTERN = /^[a-z_][a-z0-9_$]*$/i;
-function validateTableName(name, label) {
-  if (!name || name.length === 0) {
-    throw new ConfigurationError(`${label} table name cannot be empty`);
-  }
-  if (name.length > MAX_PG_IDENTIFIER_LENGTH) {
-    throw new ConfigurationError(
-      `${label} table name exceeds maximum length of ${MAX_PG_IDENTIFIER_LENGTH} characters`
-    );
-  }
-  if (!VALID_IDENTIFIER_PATTERN.test(name)) {
-    throw new 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.`
-    );
-  }
-}
-function quoteIdentifier2(name) {
-  return `"${name.replaceAll('"', '""')}"`;
-}
-function freezeSqlSchema(fields) {
-  return new SqlSchemaDescriptor(fields);
-}
-function isSqlSchema(schema) {
-  return schema instanceof SqlSchemaDescriptor && Object.isFrozen(schema);
-}
-function requireSqlSchema(schema, surface = "SqlSchema") {
-  if (isSqlSchema(schema)) return schema;
-  throw new ConfigurationError(
-    `${surface} must be created with createSqlSchema(...).`,
-    { code: "INVALID_SQL_SCHEMA", surface },
-    {
-      suggestion: "Pass the result of createSqlSchema(...) instead of a plain schema-shaped object."
-    }
-  );
-}
-function createSqlSchema(names = {}) {
-  const tables = resolveTableNames(names);
-  validateTableName(tables.nodes, "nodes");
-  validateTableName(tables.edges, "edges");
-  validateTableName(tables.recordedNodes, "recordedNodes");
-  validateTableName(tables.recordedEdges, "recordedEdges");
-  validateTableName(tables.recordedClock, "recordedClock");
-  validateTableName(tables.fulltext, "fulltext");
-  validateTableName(tables.uniques, "uniques");
-  return freezeSqlSchema({
-    tables: Object.freeze(tables),
-    nodesTable: sql.raw(quoteIdentifier2(tables.nodes)),
-    edgesTable: sql.raw(quoteIdentifier2(tables.edges)),
-    recordedNodesTable: sql.raw(quoteIdentifier2(tables.recordedNodes)),
-    recordedEdgesTable: sql.raw(quoteIdentifier2(tables.recordedEdges)),
-    recordedClockTable: sql.raw(quoteIdentifier2(tables.recordedClock)),
-    fulltextTable: sql.raw(quoteIdentifier2(tables.fulltext))
-  });
-}
-var EXTERNAL_RECORDED_READ_SOURCE = /* @__PURE__ */ Symbol(
-  "ExternalRecordedReadSource"
-);
-var TYPEGRAPH_RECORDED_READ_SOURCE = /* @__PURE__ */ Symbol(
-  "TypeGraphRecordedReadSource"
-);
-function recordedRelation(options) {
-  const schema = requireSqlSchema(options.schema, "recordedRelation schema");
-  return Object.freeze({
-    source: "external",
-    schema,
-    [EXTERNAL_RECORDED_READ_SOURCE]: true
-  });
-}
-function requireExternalRecordedReadSource(source) {
-  if (source === void 0) return void 0;
-  if (isExternalRecordedReadSource(source)) return source;
-  throw new ConfigurationError(
-    "recordedRead must be created with recordedRelation({ schema }).",
-    { code: "INVALID_RECORDED_READ_SOURCE" },
-    {
-      suggestion: "Pass { recordedRead: recordedRelation({ schema }) } for an externally populated recorded relation. Use { history: true } when TypeGraph should capture writes."
-    }
-  );
-}
-function isExternalRecordedReadSource(source) {
-  if (typeof source !== "object" || source === null) return false;
-  const candidate = source;
-  return candidate.source === "external" && candidate[EXTERNAL_RECORDED_READ_SOURCE] === true && isSqlSchema(candidate.schema) && Object.isFrozen(candidate);
-}
-function createRecordedReadBinding(schema) {
-  const readSchema = requireSqlSchema(schema, "recorded read binding schema");
-  return Object.freeze({
-    source: "typegraph-capture",
-    schema: readSchema,
-    [TYPEGRAPH_RECORDED_READ_SOURCE]: true
-  });
-}
-function requireRecordedReadBinding(binding, surface) {
-  if (isRecordedReadBinding(binding)) return binding;
-  if (binding !== void 0) {
-    throw new ConfigurationError(
-      "Recorded-time reads require a recorded read relation created by TypeGraph.",
-      { code: "INVALID_RECORDED_READ_BINDING", surface },
-      {
-        suggestion: "Use createStore(graph, backend, { history: true }) or { recordedRead: recordedRelation({ schema }) } instead of passing a plain object."
-      }
-    );
-  }
-  throw new ConfigurationError(
-    "Recorded-time reads require a recorded read relation.",
-    { code: "RECORDED_READ_REQUIRES_BINDING", surface },
-    {
-      suggestion: "Create the store with createStore(graph, backend, { history: true }) to bind TypeGraph's built-in captured relation, or pass { recordedRead: recordedRelation({ schema }) } for an externally populated recorded relation."
-    }
-  );
-}
-function isTypeGraphRecordedReadSource(source) {
-  if (typeof source !== "object" || source === null) return false;
-  const candidate = source;
-  return candidate.source === "typegraph-capture" && candidate[TYPEGRAPH_RECORDED_READ_SOURCE] === true && isSqlSchema(candidate.schema) && Object.isFrozen(candidate);
-}
-function isRecordedReadBinding(binding) {
-  return isExternalRecordedReadSource(binding) || isTypeGraphRecordedReadSource(binding);
-}
-function recordedReadSqlSchema(binding) {
-  const { schema } = requireRecordedReadBinding(
-    binding,
-    "recorded-read-schema"
-  );
-  return freezeSqlSchema({
-    tables: schema.tables,
-    nodesTable: schema.recordedNodesTable,
-    edgesTable: schema.recordedEdgesTable,
-    recordedNodesTable: schema.recordedNodesTable,
-    recordedEdgesTable: schema.recordedEdgesTable,
-    recordedClockTable: schema.recordedClockTable,
-    fulltextTable: schema.fulltextTable
-  });
-}
-function recordedReadSchemaFor(schema, recordedAsOf, binding, surface) {
-  const baseSchema = requireSqlSchema(schema, `${surface} schema`);
-  if (recordedAsOf === void 0) return baseSchema;
-  return recordedReadSqlSchema(requireRecordedReadBinding(binding, surface));
-}
-var DEFAULT_SQL_SCHEMA = createSqlSchema();
-function vectorSlotKey(nodeKind, fieldPath) {
-  return `${nodeKind}\0${fieldPath}`;
-}
-var ALIAS_CTE_PREFIX = "cte_";
-var EMBEDDINGS_CTE_ALIAS = "cte_embeddings";
-var FULLTEXT_CTE_ALIAS = "cte_fulltext";
-var HYBRID_CANDIDATES_CTE_ALIAS = "cte_relevance_candidates";
+import { Placeholder, sql } from 'drizzle-orm';
 
 // src/store/collection-surface.ts
 var CURRENT_ONLY_READ_NAMES = [
@@ -4632,7 +4350,7 @@ function compileStandardQueryWithCteStrategy(ast, graphId, ctx) {
     ...vectorPredicate === void 0 ? {} : { vectorPredicate },
     ...fulltextPredicate === void 0 ? {} : { fulltextPredicate }
   });
-  const groupBy2 = buildStandardGroupBy({ ast, dialect });
+  const groupBy = buildStandardGroupBy({ ast, dialect });
   const having2 = buildStandardHaving({ ast, ctx });
   const orderBy = selectStandardOrderBy({
     ast,
@@ -4649,7 +4367,7 @@ function compileStandardQueryWithCteStrategy(ast, graphId, ctx) {
   return emitStandardQuerySql({
     ctes,
     fromClause,
-    ...groupBy2 === void 0 ? {} : { groupBy: groupBy2 },
+    ...groupBy === void 0 ? {} : { groupBy },
     ...having2 === void 0 ? {} : { having: having2 },
     ...orderBy === void 0 ? {} : { orderBy },
     ...limitOffset === void 0 ? {} : { limitOffset },
@@ -4657,9 +4375,6 @@ function compileStandardQueryWithCteStrategy(ast, graphId, ctx) {
     projection
   });
 }
-function generateId() {
-  return nanoid();
-}
 
 // src/utils/path.ts
 function parseSqlitePath(path) {
@@ -5249,9 +4964,9 @@ function buildSelectiveFields(accessedFields, options) {
       valueType: typeInfo?.valueType
     };
   }).toSorted((a, b) => {
-    const aliasCompare = a.alias.localeCompare(b.alias);
+    const aliasCompare = compareStrings(a.alias, b.alias);
     if (aliasCompare !== 0) return aliasCompare;
-    return a.field.localeCompare(b.field);
+    return compareStrings(a.field, b.field);
   });
 }
 function buildAliasKindMap(state) {
@@ -5471,7 +5186,7 @@ function buildAliasPlans(state, selectiveFields, schemaIntrospector) {
       systemOutputNames: new Set(systemFields.map((f) => f.outputName))
     });
   }
-  return plans.toSorted((a, b) => a.alias.localeCompare(b.alias));
+  return plans.toSorted((a, b) => compareStrings(a.alias, b.alias));
 }
 function buildSelectiveContext(row, plans, traversals) {
   const context = {};
@@ -6896,9 +6611,9 @@ var ExecutableQuery = class _ExecutableQuery {
       add(traversal.edgeAlias);
     }
     return result.toSorted((a, b) => {
-      const aliasCompare = a.alias.localeCompare(b.alias);
+      const aliasCompare = compareStrings(a.alias, b.alias);
       if (aliasCompare !== 0) return aliasCompare;
-      return a.field.localeCompare(b.field);
+      return compareStrings(a.field, b.field);
     });
   }
   async #tryOptimizedPaginate(cursorData, direction, pageLimit, fetchLimit, cursor, isBackward) {
@@ -6979,7 +6694,7 @@ var ExecutableQuery = class _ExecutableQuery {
     };
   }
   #recordOrderByFieldsForPagination(tracker) {
-    for (const spec of this.#state.orderBy) {
+    for (const spec of this.#paginationOrderBy()) {
       const field2 = spec.field;
       if (field2.path.length === 1 && field2.path[0] !== "props" && field2.jsonPointer === void 0) {
         tracker.record(field2.alias, field2.path[0], true);
@@ -7004,7 +6719,7 @@ var ExecutableQuery = class _ExecutableQuery {
       row,
       selectiveFields
     );
-    return buildCursorFromRow(contextRow, this.#state.orderBy, direction);
+    return buildCursorFromRow(contextRow, this.#paginationOrderBy(), direction);
   }
   #buildCursorContextFromSelectiveRow(row, selectiveFields) {
     const outputNameByAliasField = /* @__PURE__ */ new Map();
@@ -7021,7 +6736,7 @@ var ExecutableQuery = class _ExecutableQuery {
       }
     }
     const cursorContext = {};
-    for (const spec of this.#state.orderBy) {
+    for (const spec of this.#paginationOrderBy()) {
       const alias = spec.field.alias;
       const jsonPointer2 = spec.field.jsonPointer;
       if (jsonPointer2 === void 0) {
@@ -7102,6 +6817,32 @@ var ExecutableQuery = class _ExecutableQuery {
     }
     return this.#state.traversals.find((t) => t.nodeAlias === alias)?.nodeKinds;
   }
+  /**
+   * The ORDER BY used for keyset pagination: the caller's ORDER BY plus a final
+   * unique tiebreaker on the start alias's `id`. Without a unique final key, a
+   * non-unique sort (e.g. `orderBy("p", "age")` with many equal ages) makes the
+   * keyset predicate `age > lastAge` skip every not-yet-returned equal-age row,
+   * silently losing data across pages. The start node's `id` is unique and
+   * always projected, so appending it gives a total order that page boundaries
+   * can split cleanly. Skipped when the caller already orders by the start
+   * alias's `id` (the sort is already total). Every pagination read of ORDER BY
+   * — the emitted sort, the cursor predicate, cursor encoding, and cursor
+   * validation — routes through here so the extra column stays consistent across
+   * the standard and selective-field-optimized paths.
+   */
+  #paginationOrderBy() {
+    const orderBy = this.#state.orderBy;
+    const startAlias = this.#state.startAlias;
+    const alreadyTotal = orderBy.some(
+      (spec) => spec.field.alias === startAlias && spec.field.path.length === 1 && spec.field.path[0] === "id" && spec.field.jsonPointer === void 0
+    );
+    if (alreadyTotal) return orderBy;
+    const tiebreaker = {
+      field: { __type: "field_ref", alias: startAlias, path: ["id"] },
+      direction: "asc"
+    };
+    return [...orderBy, tiebreaker];
+  }
   /**
    * Executes a paginated query using cursor-based keyset pagination.
    *
@@ -7140,7 +6881,7 @@ var ExecutableQuery = class _ExecutableQuery {
     let cursorData;
     if (cursor) {
       cursorData = decodeCursor(cursor);
-      validateCursorColumns(cursorData, this.#state.orderBy);
+      validateCursorColumns(cursorData, this.#paginationOrderBy());
     }
     const fetchLimit = limit + 1;
     const direction = isBackward ? "backward" : "forward";
@@ -7172,7 +6913,7 @@ var ExecutableQuery = class _ExecutableQuery {
     return buildPaginatedResult(
       data,
       orderedRows,
-      this.#state.orderBy,
+      this.#paginationOrderBy(),
       limit,
       hasMore,
       isBackward,
@@ -7218,7 +6959,7 @@ var ExecutableQuery = class _ExecutableQuery {
    */
   async #executeWithCursor(cursorData, direction, limit, options) {
     const ast = this.toAst();
-    let orderBy = this.#state.orderBy;
+    let orderBy = this.#paginationOrderBy();
     if (direction === "backward") {
       orderBy = orderBy.map((spec) => ({
         ...spec,
@@ -7229,7 +6970,7 @@ var ExecutableQuery = class _ExecutableQuery {
     if (cursorData) {
       const cursorPredicate = buildCursorPredicate(
         cursorData,
-        this.#state.orderBy,
+        this.#paginationOrderBy(),
         direction,
         this.#state.startAlias
       );
@@ -8947,101 +8688,6 @@ function createQueryBuilderWithContext(graphId, registry, options) {
   return new QueryBuilder(config, initialState);
 }
 
-// src/store/fulltext-sync.ts
-var searchableFieldsCache = /* @__PURE__ */ new WeakMap();
-function getSearchableFields(schema) {
-  const cached = searchableFieldsCache.get(schema);
-  if (cached) return cached;
-  const fields = computeSearchableFields(schema);
-  searchableFieldsCache.set(schema, fields);
-  return fields;
-}
-function computeSearchableFields(schema) {
-  if (schema.type !== "object") return [];
-  const def = schema.def;
-  const shape = def.shape;
-  if (!shape) return [];
-  const fields = [];
-  for (const [fieldPath, fieldSchema] of Object.entries(shape)) {
-    const metadata = getSearchableMetadata(fieldSchema);
-    if (metadata !== void 0) {
-      fields.push({ fieldPath, metadata });
-    }
-  }
-  warnIfConflictingLanguages(fields);
-  return fields;
-}
-function warnIfConflictingLanguages(fields) {
-  if (fields.length < 2) return;
-  const languages = new Set(fields.map((field2) => field2.metadata.language));
-  if (languages.size < 2) return;
-  if (typeof console === "undefined" || typeof console.warn !== "function") {
-    return;
-  }
-  const fieldSummary = fields.map((field2) => `${field2.fieldPath}=${field2.metadata.language}`).join(", ");
-  const winning = fields[0]?.metadata.language ?? DEFAULT_SEARCHABLE_LANGUAGE;
-  console.warn(
-    `[typegraph] searchable() fields declare conflicting languages (${fieldSummary}). The first field's language ("${winning}") is recorded on the fulltext row; true multilingual indexing requires a dedicated node kind per language.`
-  );
-}
-var FIELD_SEPARATOR = "\n";
-function resolveCombinedLanguage(fields) {
-  return fields[0]?.metadata.language ?? DEFAULT_SEARCHABLE_LANGUAGE;
-}
-function computeFulltextContent(schema, props) {
-  const searchableFields = getSearchableFields(schema);
-  if (searchableFields.length === 0) return void 0;
-  const parts = [];
-  for (const field2 of searchableFields) {
-    const value = props[field2.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 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/store/fulltext-rebuild.ts
 var DEFAULT_PAGE_SIZE = 500;
 var DEFAULT_MAX_SKIPPED_IDS = 1e4;
@@ -9215,78 +8861,6 @@ function processPage(schema, rows) {
   return { toUpsert, toDelete, skipped, skippedIds };
 }
 
-// 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 field2 of embeddingFields) {
-    const value = props[field2.fieldPath];
-    if (isValidEmbeddingValue(value)) {
-      await backend.upsertEmbedding({
-        graphId: ctx.graphId,
-        nodeKind: ctx.nodeKind,
-        nodeId: ctx.nodeId,
-        fieldPath: field2.fieldPath,
-        embedding: value,
-        dimensions: field2.dimensions,
-        metric: field2.metric,
-        indexType: field2.indexType
-      });
-    } else if (value === void 0) {
-      await backend.deleteEmbedding({
-        graphId: ctx.graphId,
-        nodeKind: ctx.nodeKind,
-        nodeId: ctx.nodeId,
-        fieldPath: field2.fieldPath,
-        dimensions: field2.dimensions,
-        metric: field2.metric,
-        indexType: field2.indexType
-      });
-    }
-  }
-}
-async function deleteNodeEmbeddings(ctx, schema) {
-  const { backend } = ctx;
-  if (!backend.deleteEmbedding) {
-    return;
-  }
-  const embeddingFields = getEmbeddingFields(schema);
-  if (embeddingFields.length === 0) {
-    return;
-  }
-  for (const field2 of embeddingFields) {
-    await backend.deleteEmbedding({
-      graphId: ctx.graphId,
-      nodeKind: ctx.nodeKind,
-      nodeId: ctx.nodeId,
-      fieldPath: field2.fieldPath,
-      dimensions: field2.dimensions,
-      metric: field2.metric,
-      indexType: field2.indexType
-    });
-  }
-}
-function isValidEmbeddingValue(value) {
-  if (!Array.isArray(value)) {
-    return false;
-  }
-  return value.every((n) => typeof n === "number" && Number.isFinite(n));
-}
-
 // src/store/search.ts
 function resolveSearchSlot(ctx, nodeKind, fieldPath) {
   const nodeType = ctx.registry.getNodeType(nodeKind);
@@ -9512,7 +9086,7 @@ async function executeHybridSearch(ctx, nodeKind, options) {
     fused.set(row.nodeId, entry2);
   }
   const ranked = [...fused.values()].toSorted(
-    (a, b) => b.fusedScore - a.fusedScore || a.nodeId.localeCompare(b.nodeId)
+    (a, b) => b.fusedScore - a.fusedScore || compareStrings(a.nodeId, b.nodeId)
   ).slice(0, options.limit);
   const ids = ranked.map((entry2) => entry2.nodeId);
   const nodeMap = await fetchNodesByIds(backend, graphId, nodeKind, ids);
@@ -10631,33 +10205,6 @@ function createGraphAlgorithms(params) {
   };
 }
 
-// src/store/row-fetch.ts
-async function getRowsByIds(ids, policy) {
-  const rowsById = /* @__PURE__ */ new Map();
-  if (ids.length === 0) return rowsById;
-  if (policy.batch !== void 0) {
-    const rows2 = await policy.batch(ids);
-    for (const row of rows2) {
-      rowsById.set(row.id, row);
-    }
-    return rowsById;
-  }
-  const uniqueIds = [...new Set(ids)];
-  const rows = await Promise.all(uniqueIds.map((id) => policy.one(id)));
-  for (const row of rows) {
-    if (row !== void 0) rowsById.set(row.id, row);
-  }
-  return rowsById;
-}
-
-// src/store/edge-fetch.ts
-async function getEdgeRowsByIds(backend, graphId, ids) {
-  return getRowsByIds(ids, {
-    batch: backend.getEdges === void 0 ? void 0 : (batchIds) => backend.getEdges(graphId, batchIds),
-    one: (id) => backend.getEdge(graphId, id)
-  });
-}
-
 // src/store/collections/edge-collection.ts
 function narrowEdge(edge) {
   return edge;
@@ -10989,14 +10536,6 @@ function createEdgeCollection(config) {
   };
 }
 
-// src/store/node-fetch.ts
-async function getNodeRowsByIds(backend, graphId, kind, ids) {
-  return getRowsByIds(ids, {
-    batch: backend.getNodes === void 0 ? void 0 : (batchIds) => backend.getNodes(graphId, kind, batchIds),
-    one: (id) => backend.getNode(graphId, kind, id)
-  });
-}
-
 // src/store/collections/node-collection.ts
 function narrowNode(node) {
   return node;
@@ -11269,20 +10808,14 @@ function createNodeCollection(config) {
       return results.map((bucket) => narrowNodes(bucket));
     },
     async getOrCreateByConstraint(constraintName, props, options) {
-      const execute = async (target) => {
-        const result = await executeGetOrCreateByConstraint(
-          kind,
-          constraintName,
-          props,
-          target,
-          options
-        );
-        return result;
-      };
-      if (backend.capabilities.transactions && "transaction" in backend) {
-        return backend.transaction(async (txBackend) => execute(txBackend));
-      }
-      return execute(backend);
+      const result = await executeGetOrCreateByConstraint(
+        kind,
+        constraintName,
+        props,
+        backend,
+        options
+      );
+      return result;
     },
     async bulkGetOrCreateByConstraint(constraintName, items, options) {
       if (items.length === 0) return [];
@@ -11734,990 +11267,25 @@ async function computeIndexSignature(dialect, targetTableName, declaration) {
   const json = JSON.stringify(hashable, sortedReplacer);
   return sha256Hex(json, 16);
 }
-
-// src/store/insert-dispatch.ts
-function nodeInsertDispatch(backend) {
-  return {
-    one: (params) => backend.insertNode(params),
-    oneNoReturn: backend.insertNodeNoReturn === void 0 ? void 0 : (params) => backend.insertNodeNoReturn(params),
-    batch: backend.insertNodesBatch === void 0 ? void 0 : (params) => backend.insertNodesBatch(params),
-    batchReturning: backend.insertNodesBatchReturning === void 0 ? void 0 : (params) => backend.insertNodesBatchReturning(params)
-  };
-}
-function edgeInsertDispatch(backend) {
-  return {
-    one: (params) => backend.insertEdge(params),
-    oneNoReturn: backend.insertEdgeNoReturn === void 0 ? void 0 : (params) => backend.insertEdgeNoReturn(params),
-    batch: backend.insertEdgesBatch === void 0 ? void 0 : (params) => backend.insertEdgesBatch(params),
-    batchReturning: backend.insertEdgesBatchReturning === void 0 ? void 0 : (params) => backend.insertEdgesBatchReturning(params)
-  };
-}
-async function runInsertNoReturn(dispatch, params) {
-  if (dispatch.oneNoReturn !== void 0) {
-    await dispatch.oneNoReturn(params);
-    return;
-  }
-  await dispatch.one(params);
-}
-async function runInsertBatch(dispatch, params) {
-  if (params.length === 0) return;
-  if (dispatch.batch !== void 0) {
-    await dispatch.batch(params);
-    return;
-  }
-  for (const insertParams of params) {
-    await runInsertNoReturn(dispatch, insertParams);
-  }
-}
-async function runInsertBatchReturning(dispatch, params) {
-  if (dispatch.batchReturning !== void 0) {
-    return dispatch.batchReturning(params);
-  }
-  const rows = [];
-  for (const insertParams of params) {
-    rows.push(await dispatch.one(insertParams));
-  }
-  return rows;
-}
-function requireRecordedSchema(target) {
-  if (target.tableNames === void 0) {
-    throw new ConfigurationError(
-      "Recorded-time capture requires the backend to expose tableNames.",
-      { dialect: target.dialect },
-      {
-        suggestion: "Use a built-in SQLite/PostgreSQL backend, or set tableNames on the custom backend so recorded-time capture targets the configured relations."
-      }
-    );
-  }
-  return createSqlSchema(target.tableNames);
+var ENTITY_KINDS = ["node", "edge"];
+function buildPendingKindRemoval(args) {
+  return { ...args, removedAt: void 0, error: void 0 };
 }
-function requireCaptureStatements(target) {
-  if (target.executeStatement === void 0) {
+async function materializeRemovals(context, options = {}) {
+  const { backend, graphId } = context;
+  if (backend.executeDdl === void 0 || backend.recordKindRemoval === void 0 || backend.getPendingKindRemovals === void 0) {
     throw new ConfigurationError(
-      "Recorded-time capture requires backend.executeStatement support on the transaction backend.",
-      { dialect: target.dialect },
-      {
-        suggestion: "Use the built-in SQLite/PostgreSQL backends or provide executeStatement on the custom backend's transaction target."
-      }
+      "store.materializeRemovals() requires a backend with kind-removal primitives (executeDdl, recordKindRemoval, getPendingKindRemovals). The bundled SQLite and Postgres backends provide them.",
+      { code: "MATERIALIZE_REMOVALS_BACKEND_UNSUPPORTED" }
     );
   }
-}
-async function executeStatement(target, query) {
-  requireCaptureStatements(target);
-  await target.executeStatement(asCompiledStatementSql(query));
-}
-function unsupportedPostgresIsolationError(isolationLevel) {
-  return new ConfigurationError(
-    "Recorded-time capture on PostgreSQL requires read_committed isolation.",
-    { isolationLevel: isolationLevel ?? "unknown" },
-    {
-      suggestion: "Omit the transaction isolation option or use read_committed. PostgreSQL repeatable_read/serializable snapshots cannot safely allocate the per-graph recorded clock inside the captured transaction."
-    }
-  );
-}
-function isSupportedRecordedIsolationLevel(isolationLevel) {
-  return isolationLevel === void 0 || isolationLevel === "read_committed" || isolationLevel === "read_uncommitted";
-}
-function assertRequestedRecordedIsolation(backend, options) {
-  if (backend.dialect !== "postgres") return;
-  const isolationLevel = options?.isolationLevel;
-  if (isSupportedRecordedIsolationLevel(isolationLevel)) return;
-  throw unsupportedPostgresIsolationError(isolationLevel);
-}
-function normalizeIsolationLevel(value) {
-  if (typeof value !== "string") return void 0;
-  return value.replaceAll(" ", "_").toLowerCase();
-}
-async function assertRecordedCaptureTransactionIsolation(target) {
-  if (target.dialect !== "postgres") return;
-  const rows = await target.execute(
-    asCompiledRowsSql(sql`
-      SELECT current_setting('transaction_isolation') AS transaction_isolation
-    `)
-  );
-  const isolationLevel = normalizeIsolationLevel(
-    rows[0]?.transaction_isolation
-  );
-  if (isSupportedRecordedIsolationLevel(isolationLevel)) return;
-  throw unsupportedPostgresIsolationError(isolationLevel);
-}
-function recordedCaptureRequiresCallbackTransactionError(details) {
-  return new ConfigurationError(
-    "withTransaction() has no recorded-time capture flush point when history is enabled.",
-    details,
-    {
-      suggestion: "Use store.withRecordedTransaction(externalTx, async (tx) => ...) so TypeGraph can flush capture before the caller commits."
-    }
-  );
-}
-function historyUnsafeRawWriteError(surface) {
-  return new ConfigurationError(
-    `${surface} is not available when history capture is enabled because raw SQL writes bypass recorded-time capture.`,
-    { code: "RECORDED_CAPTURE_RAW_SQL_DISABLED" },
-    {
-      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 failHistoryUnsafeSqlRef() {
-  throw historyUnsafeRawWriteError("tx.sql");
-}
-function createHistoryUnsafeSqlRef() {
-  return new Proxy(
-    function historyUnsafeSqlRef() {
-      return failHistoryUnsafeSqlRef();
-    },
-    {
-      get() {
-        return failHistoryUnsafeSqlRef();
-      },
-      apply() {
-        return failHistoryUnsafeSqlRef();
-      },
-      set() {
-        return failHistoryUnsafeSqlRef();
-      },
-      defineProperty() {
-        return failHistoryUnsafeSqlRef();
-      },
-      deleteProperty() {
-        return failHistoryUnsafeSqlRef();
-      },
-      // 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();
-      },
-      ownKeys() {
-        return failHistoryUnsafeSqlRef();
-      },
-      getOwnPropertyDescriptor() {
-        return failHistoryUnsafeSqlRef();
-      },
-      getPrototypeOf() {
-        return failHistoryUnsafeSqlRef();
-      }
-    }
-  );
-}
-function rawWriteGuards(target, prefix) {
-  return {
-    ...target.executeStatement === void 0 ? {} : {
-      executeStatement(_query) {
-        return Promise.reject(
-          historyUnsafeRawWriteError(`${prefix}.executeStatement`)
-        );
-      }
-    },
-    ...target.executeDdl === void 0 ? {} : {
-      executeDdl(_ddl) {
-        return Promise.reject(
-          historyUnsafeRawWriteError(`${prefix}.executeDdl`)
-        );
-      }
-    }
-  };
-}
-function assertCapturableBackend(backend) {
-  if (!backend.capabilities.transactions) {
-    throw new ConfigurationError(
-      "history: true requires a backend with transaction support.",
-      { dialect: backend.dialect },
-      {
-        suggestion: "Use a transactional SQLite/PostgreSQL backend or disable recorded-time capture for this store."
-      }
-    );
-  }
-  if (backend.executeStatement === void 0) {
-    throw new ConfigurationError(
-      "history: true requires a backend that supports executeStatement.",
-      { dialect: backend.dialect },
-      {
-        suggestion: "Use a built-in SQLite/PostgreSQL backend, or implement executeStatement on the custom backend so recorded-time capture can write history rows."
-      }
-    );
-  }
-  if (backend.capabilities.returning === false) {
-    throw new ConfigurationError(
-      "history: true requires a backend that supports UPDATE \u2026 RETURNING.",
-      { dialect: backend.dialect },
-      {
-        suggestion: "Use a built-in SQLite/PostgreSQL backend, or run recorded-time capture on a backend whose engine supports UPDATE \u2026 RETURNING \u2014 capture closes recorded intervals with a RETURNING statement on its hot path."
-      }
-    );
-  }
-  if (backend.tableNames === void 0) {
-    throw new ConfigurationError(
-      "history: true requires a backend that exposes tableNames.",
-      { dialect: backend.dialect },
-      {
-        suggestion: "Use a built-in SQLite/PostgreSQL backend, or set tableNames on the custom backend so recorded-time capture can resolve the recorded relations instead of silently falling back to defaults."
-      }
-    );
-  }
-}
-
-// src/store/recorded-capture/clock.ts
-var RECORDED_MIN = "1970-01-01T00:00:00.000Z";
-var RECORDED_MAX_TIME = new Date(RECORDED_MAX).getTime();
-var RECORDED_CLOCK_ADVISORY_LOCK_NAMESPACE = "typegraph:recorded-clock";
-function recordedClockAdvisoryLockSql(graphId) {
-  return sql`
-    SELECT pg_advisory_xact_lock(
-      hashtext(${RECORDED_CLOCK_ADVISORY_LOCK_NAMESPACE}),
-      hashtext(${graphId})
-    )
-  `;
-}
-function failInvalidClockTimestamp(value) {
-  throw new ConfigurationError(
-    "Recorded clock row contained an invalid timestamp",
-    { value }
-  );
-}
-var ZONELESS_DATETIME_PATTERN = /^\d{4}-\d{2}-\d{2}[ T]\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?$/;
-var OFFSET_DATETIME_PATTERN = /^(\d{4}-\d{2}-\d{2})[ T](\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?)(Z|[+-]\d{2}(?::?\d{2})?)$/i;
-function normalizeOffsetDesignator(offset) {
-  if (offset.toUpperCase() === "Z") return "Z";
-  if (/^[+-]\d{2}$/.test(offset)) return `${offset}:00`;
-  if (/^[+-]\d{4}$/.test(offset)) {
-    return `${offset.slice(0, 3)}:${offset.slice(3)}`;
-  }
-  return offset;
-}
-function clockTimestampMs(value) {
-  if (ZONELESS_DATETIME_PATTERN.test(value)) {
-    return Date.parse(`${value.replace(" ", "T")}Z`);
-  }
-  const offsetMatch = OFFSET_DATETIME_PATTERN.exec(value);
-  if (offsetMatch) {
-    const [, date, time, offset] = offsetMatch;
-    return Date.parse(`${date}T${time}${normalizeOffsetDesignator(offset)}`);
-  }
-  return Date.parse(value);
-}
-function toCanonicalIso(value) {
-  if (value instanceof Date) {
-    if (Number.isNaN(value.getTime())) return failInvalidClockTimestamp(value);
-    return value.toISOString();
-  }
-  if (typeof value === "string") {
-    const timestamp = clockTimestampMs(value);
-    if (Number.isNaN(timestamp)) return failInvalidClockTimestamp(value);
-    return new Date(timestamp).toISOString();
-  }
-  return failInvalidClockTimestamp(value);
-}
-function nextRecordedCommitTime(previous) {
-  const wallTime = Date.parse(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(sql`
-      SELECT recorded_at
-      FROM ${schema.recordedClockTable}
-      WHERE graph_id = ${graphId}
-    `)
-  );
-  const first = rows[0];
-  return first === void 0 ? void 0 : toCanonicalIso(first.recorded_at);
-}
-async function writeRecordedClock(target, schema, graphId, recordedAt) {
-  await executeStatement(
-    target,
-    sql`
-      INSERT INTO ${schema.recordedClockTable} (graph_id, recorded_at)
-      VALUES (${graphId}, ${recordedAt})
-      ON CONFLICT (graph_id) DO UPDATE SET recorded_at = ${recordedAt}
-    `
-  );
-}
-async function lockRecordedClock(target, schema, graphId, ownsWriteLock) {
-  if (target.dialect === "postgres") {
-    await target.execute(
-      asCompiledRowsSql(recordedClockAdvisoryLockSql(graphId))
-    );
-    return;
-  }
-  if (ownsWriteLock) return;
-  await executeStatement(
-    target,
-    sql`
-      INSERT INTO ${schema.recordedClockTable} (graph_id, recorded_at)
-      VALUES (${graphId}, ${RECORDED_MIN})
-      ON CONFLICT (graph_id) DO UPDATE SET recorded_at = recorded_at
-    `
-  );
-}
-async function allocateRecordedCommit(target, schema, graphId, ownsWriteLock) {
-  await lockRecordedClock(target, schema, graphId, ownsWriteLock);
-  const previous = await readRecordedClock(target, schema, graphId);
-  const recordedCommitTime = nextRecordedCommitTime(previous);
-  if (!Number.isFinite(recordedCommitTime) || recordedCommitTime >= RECORDED_MAX_TIME) {
-    throw new ConfigurationError(
-      `Recorded commit clock reached the open sentinel ${RECORDED_MAX}`,
-      { graphId, recordedCommitTime },
-      {
-        suggestion: "Use a graph with a normal recorded-time clock; the open sentinel is reserved for relation intervals."
-      }
-    );
-  }
-  const recordedCommit = new Date(recordedCommitTime).toISOString();
-  await writeRecordedClock(target, schema, graphId, recordedCommit);
-  return recordedCommit;
-}
-var RECORDED_HISTORY_META = "{}";
-var RECORDED_NODE_COLUMNS = [
-  "history_id",
-  "graph_id",
-  "kind",
-  "id",
-  "props",
-  "version",
-  "valid_from",
-  "valid_to",
-  "created_at",
-  "updated_at",
-  "deleted_at",
-  "recorded_from",
-  "recorded_to",
-  "op",
-  "schema_version",
-  "tx_id",
-  "meta"
-];
-var RECORDED_EDGE_COLUMNS = [
-  "history_id",
-  "graph_id",
-  "id",
-  "kind",
-  "from_kind",
-  "from_id",
-  "to_kind",
-  "to_id",
-  "props",
-  "valid_from",
-  "valid_to",
-  "created_at",
-  "updated_at",
-  "deleted_at",
-  "recorded_from",
-  "recorded_to",
-  "op",
-  "schema_version",
-  "tx_id",
-  "meta"
-];
-var RECORDED_NODE_COLUMN_LIST = sql.raw(RECORDED_NODE_COLUMNS.join(", "));
-var RECORDED_EDGE_COLUMN_LIST = sql.raw(RECORDED_EDGE_COLUMNS.join(", "));
-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 ConfigurationError(
-      `backend capabilities.maxBindParameters must be a positive integer, got: ${String(budget)}`,
-      {
-        code: "INVALID_BACKEND_CAPABILITY",
-        capability: "maxBindParameters",
-        value: budget
-      }
-    );
-  }
-  return budget;
-}
-function recordedChunkSize(target, columnCount) {
-  const budget = recordedBindParamBudget(target);
-  return Math.max(1, Math.floor(budget / columnCount));
-}
-function recordedCommonCells() {
-  return {
-    history_id: () => sql`${generateId()}`,
-    graph_id: (row) => sql`${row.graph_id}`,
-    id: (row) => sql`${row.id}`,
-    kind: (row) => sql`${row.kind}`,
-    props: (row) => sql`${row.props}`,
-    valid_from: (row) => sql`${sqlNull(row.valid_from)}`,
-    valid_to: (row) => sql`${sqlNull(row.valid_to)}`,
-    created_at: (row) => sql`${row.created_at}`,
-    updated_at: (row) => sql`${row.updated_at}`,
-    deleted_at: (row) => sql`${sqlNull(row.deleted_at)}`,
-    recorded_from: (_row, recordedCommit) => sql`${recordedCommit}`,
-    recorded_to: () => sql`${RECORDED_MAX}`,
-    op: (_row, _recordedCommit, operation) => sql`${operation}`,
-    schema_version: () => sql`NULL`,
-    tx_id: () => sql`NULL`,
-    meta: () => sql`${RECORDED_HISTORY_META}`
-  };
-}
-var recordedNodeCells = {
-  ...recordedCommonCells(),
-  version: (row) => sql`${row.version}`
-};
-var recordedEdgeCells = {
-  ...recordedCommonCells(),
-  from_kind: (row) => sql`${row.from_kind}`,
-  from_id: (row) => sql`${row.from_id}`,
-  to_kind: (row) => sql`${row.to_kind}`,
-  to_id: (row) => sql`${row.to_id}`
-};
-function recordedValuesTuple(columns, cells, row, recordedCommit, operation) {
-  const tuple = columns.map(
-    (column) => cells[column](row, recordedCommit, operation)
-  );
-  return sql`(${sql.join(tuple, sql`, `)})`;
-}
-async function insertRecordedRows(target, table, columnList, columns, cells, inserts, recordedCommit) {
-  if (inserts.length === 0) return;
-  const values = inserts.map(
-    (insert) => recordedValuesTuple(
-      columns,
-      cells,
-      insert.row,
-      recordedCommit,
-      insert.operation
-    )
-  );
-  await executeStatement(
-    target,
-    sql`
-      INSERT INTO ${table} (${columnList})
-      VALUES ${sql.join(values, sql`, `)}
-    `
-  );
-}
-function recordedNodeChunkSize(target) {
-  return recordedChunkSize(target, RECORDED_NODE_COLUMNS.length);
-}
-function recordedEdgeChunkSize(target) {
-  return recordedChunkSize(target, RECORDED_EDGE_COLUMNS.length);
-}
-function insertRecordedNodeRows(target, table, inserts, recordedCommit) {
-  return insertRecordedRows(
-    target,
-    table,
-    RECORDED_NODE_COLUMN_LIST,
-    RECORDED_NODE_COLUMNS,
-    recordedNodeCells,
-    inserts,
-    recordedCommit
-  );
-}
-function insertRecordedEdgeRows(target, table, inserts, recordedCommit) {
-  return insertRecordedRows(
-    target,
-    table,
-    RECORDED_EDGE_COLUMN_LIST,
-    RECORDED_EDGE_COLUMNS,
-    recordedEdgeCells,
-    inserts,
-    recordedCommit
-  );
-}
-
-// src/store/recorded-capture/flush.ts
-function entityKey(entity) {
-  switch (entity.entity) {
-    case "node": {
-      return `node\0${entity.graphId}\0${entity.kind}\0${entity.id}`;
-    }
-    case "edge": {
-      return `edge\0${entity.graphId}\0${entity.id}`;
-    }
-  }
-}
-async function closeOpenReturning(target, table, graphId, ids, recordedCommit, kind) {
-  const kindFilter = kind === void 0 ? sql`` : sql`AND kind = ${kind}`;
-  const rows = await target.execute(
-    asCompiledRowsSql(sql`
-      UPDATE ${table}
-      SET recorded_to = ${recordedCommit}
-      WHERE graph_id = ${graphId}
-        ${kindFilter}
-        AND recorded_to = ${RECORDED_MAX}
-        AND id IN (${sqlValueList(ids)})
-      RETURNING id, deleted_at
-    `)
-  );
-  return new Map(rows.map((row) => [row.id, isPresent(row.deleted_at)]));
-}
-function recordedOp(hadOpenRow, priorRowWasTombstone, after) {
-  if (isPresent(after.deleted_at)) return "delete";
-  if (!hadOpenRow || priorRowWasTombstone) return "create";
-  return "update";
-}
-function groupNodesByKind(entities) {
-  const byKind = /* @__PURE__ */ new Map();
-  for (const entity of entities) {
-    const group = byKind.get(entity.kind) ?? [];
-    group.push(entity);
-    byKind.set(entity.kind, group);
-  }
-  return byKind;
-}
-async function resolveAfterImages(entities, readMissing) {
-  const afterById = /* @__PURE__ */ new Map();
-  const needRead = [];
-  for (const entity of entities) {
-    if (entity.afterImage === void 0) {
-      needRead.push(entity.id);
-    } else {
-      afterById.set(entity.id, entity.afterImage);
-    }
-  }
-  if (needRead.length > 0) {
-    for (const [id, row] of await readMissing(needRead)) afterById.set(id, row);
-  }
-  return afterById;
-}
-function recordedInsertsFor(afterById, closed) {
-  return [...afterById.values()].map((row) => ({
-    row,
-    operation: recordedOp(closed.has(row.id), closed.get(row.id) ?? false, row)
-  }));
-}
-async function flushNodes(target, schema, graphId, entities, recordedCommit) {
-  const chunkSize = recordedNodeChunkSize(target);
-  for (const [kind, group] of groupNodesByKind(entities)) {
-    for (const entityChunk of chunk(group, chunkSize)) {
-      const ids = entityChunk.map((entity) => entity.id);
-      const closed = await closeOpenReturning(
-        target,
-        schema.recordedNodesTable,
-        graphId,
-        ids,
-        recordedCommit,
-        kind
-      );
-      const afterById = await resolveAfterImages(
-        entityChunk,
-        (missing) => getNodeRowsByIds(target, graphId, kind, missing)
-      );
-      await insertRecordedNodeRows(
-        target,
-        schema.recordedNodesTable,
-        recordedInsertsFor(afterById, closed),
-        recordedCommit
-      );
-    }
-  }
-}
-async function flushEdges(target, schema, graphId, entities, recordedCommit) {
-  const chunkSize = recordedEdgeChunkSize(target);
-  for (const entityChunk of chunk(entities, chunkSize)) {
-    const ids = entityChunk.map((entity) => entity.id);
-    const closed = await closeOpenReturning(
-      target,
-      schema.recordedEdgesTable,
-      graphId,
-      ids,
-      recordedCommit
-    );
-    const afterById = await resolveAfterImages(
-      entityChunk,
-      (missing) => getEdgeRowsByIds(target, graphId, missing)
-    );
-    await insertRecordedEdgeRows(
-      target,
-      schema.recordedEdgesTable,
-      recordedInsertsFor(afterById, closed),
-      recordedCommit
-    );
-  }
-}
-async function closeOpenByKind(target, table, graphId, kind, recordedCommit) {
-  await executeStatement(
-    target,
-    sql`
-      UPDATE ${table}
-      SET recorded_to = ${recordedCommit}
-      WHERE graph_id = ${graphId}
-        AND kind = ${kind}
-        AND recorded_to = ${RECORDED_MAX}
-    `
-  );
-}
-async function closeOpenEdgesByNodeKind(target, schema, graphId, nodeKind, recordedCommit) {
-  await executeStatement(
-    target,
-    sql`
-      UPDATE ${schema.recordedEdgesTable}
-      SET recorded_to = ${recordedCommit}
-      WHERE graph_id = ${graphId}
-        AND (from_kind = ${nodeKind} OR to_kind = ${nodeKind})
-        AND recorded_to = ${RECORDED_MAX}
-    `
-  );
-}
-async function closeRecordedHardDeletedKind(target, schema, graphId, removal, ownsWriteLock) {
-  const recordedCommit = await allocateRecordedCommit(
-    target,
-    schema,
-    graphId,
-    ownsWriteLock
-  );
-  if (removal.entity === "node") {
-    await closeOpenByKind(
-      target,
-      schema.recordedNodesTable,
-      graphId,
-      removal.kind,
-      recordedCommit
-    );
-    await closeOpenEdgesByNodeKind(
-      target,
-      schema,
-      graphId,
-      removal.kind,
-      recordedCommit
-    );
-    return;
-  }
-  await closeOpenByKind(
-    target,
-    schema.recordedEdgesTable,
-    graphId,
-    removal.kind,
-    recordedCommit
-  );
-}
-async function queryConnectedEdgeIds(target, schema, params) {
-  const rows = await target.execute(
-    asCompiledRowsSql(sql`
-      SELECT id
-      FROM ${schema.edgesTable}
-      WHERE graph_id = ${params.graphId}
-        AND (
-          (from_kind = ${params.kind} AND from_id = ${params.id})
-          OR (to_kind = ${params.kind} AND to_id = ${params.id})
-        )
-    `)
-  );
-  return rows.map((row) => row.id);
-}
-
-// src/store/recorded-capture.ts
-function nodeIdentityKey(graphId, kind, id) {
-  return `${graphId}\0${kind}\0${id}`;
-}
-function nodeParamsIdentityKey(params) {
-  return nodeIdentityKey(params.graphId, params.kind, params.id);
-}
-function nodeRowIdentityKey(row) {
-  return nodeIdentityKey(row.graph_id, row.kind, row.id);
-}
-function edgeIdentityKey(graphId, id) {
-  return `${graphId}\0${id}`;
-}
-function edgeParamsIdentityKey(params) {
-  return edgeIdentityKey(params.graphId, params.id);
-}
-function edgeRowIdentityKey(row) {
-  return edgeIdentityKey(row.graph_id, row.id);
-}
-function createRecordedCaptureSession() {
-  const touched = /* @__PURE__ */ new Map();
-  let sealed = false;
-  function touch(entity) {
-    if (sealed) {
-      throw new ConfigurationError(
-        "Recorded-time capture session is sealed: a graph write happened after the transaction's capture was flushed.",
-        { entity: entity.entity, graphId: entity.graphId, id: entity.id },
-        {
-          suggestion: "Perform all writes inside the withRecordedTransaction callback; do not reuse the transaction context after it returns."
-        }
-      );
-    }
-    touched.set(entityKey(entity), entity);
-  }
-  return {
-    touchNode(graphId, kind, id, afterImage) {
-      touch({ entity: "node", graphId, kind, id, afterImage });
-    },
-    touchEdge(graphId, id, afterImage) {
-      touch({ entity: "edge", graphId, id, afterImage });
-    },
-    async flush(target, schema, ownsWriteLock) {
-      if (sealed) {
-        throw new ConfigurationError(
-          "Recorded-time capture session was already flushed.",
-          {},
-          {
-            suggestion: "A capture scope flushes once at its terminal point; do not flush it twice."
-          }
-        );
-      }
-      sealed = true;
-      if (touched.size === 0) return;
-      const byGraph = groupBy(touched.values(), (entity) => entity.graphId);
-      for (const [graphId, entities] of byGraph) {
-        const recordedCommit = await allocateRecordedCommit(
-          target,
-          schema,
-          graphId,
-          ownsWriteLock
-        );
-        const nodes = entities.filter(
-          (entity) => entity.entity === "node"
-        );
-        const edges = entities.filter(
-          (entity) => entity.entity === "edge"
-        );
-        await flushNodes(target, schema, graphId, nodes, recordedCommit);
-        await flushEdges(target, schema, graphId, edges, recordedCommit);
-      }
-      touched.clear();
-    }
-  };
-}
-function createRecordedTransactionBackend(target, session, schema) {
-  const nodeDispatch = nodeInsertDispatch(target);
-  const edgeDispatch = edgeInsertDispatch(target);
-  return createBackendOverlay(target, {
-    ...rawWriteGuards(target, "tx.backend"),
-    async insertNode(params) {
-      const row = await target.insertNode(params);
-      session.touchNode(params.graphId, params.kind, params.id, row);
-      return row;
-    },
-    ...target.insertNodeNoReturn === void 0 ? {} : {
-      async insertNodeNoReturn(params) {
-        await runInsertNoReturn(nodeDispatch, params);
-        session.touchNode(params.graphId, params.kind, params.id);
-      }
-    },
-    ...target.insertNodesBatch === void 0 ? {} : {
-      async insertNodesBatch(params) {
-        await runInsertBatch(nodeDispatch, params);
-        for (const node of params) {
-          session.touchNode(node.graphId, node.kind, node.id);
-        }
-      }
-    },
-    ...target.insertNodesBatchReturning === void 0 ? {} : {
-      async insertNodesBatchReturning(params) {
-        const rows = await runInsertBatchReturning(nodeDispatch, params);
-        const rowsByIdentity = new Map(
-          rows.map((row) => [nodeRowIdentityKey(row), row])
-        );
-        for (const node of params) {
-          session.touchNode(
-            node.graphId,
-            node.kind,
-            node.id,
-            rowsByIdentity.get(nodeParamsIdentityKey(node))
-          );
-        }
-        return rows;
-      }
-    },
-    async updateNode(params) {
-      const row = await target.updateNode(params);
-      session.touchNode(params.graphId, params.kind, params.id, row);
-      return row;
-    },
-    async deleteNode(params) {
-      await target.deleteNode(params);
-      session.touchNode(params.graphId, params.kind, params.id);
-    },
-    async hardDeleteNode(params) {
-      const connectedEdgeIds = await queryConnectedEdgeIds(
-        target,
-        schema,
-        params
-      );
-      await target.hardDeleteNode(params);
-      session.touchNode(params.graphId, params.kind, params.id);
-      for (const edgeId of connectedEdgeIds) {
-        session.touchEdge(params.graphId, edgeId);
-      }
-    },
-    async insertEdge(params) {
-      const row = await target.insertEdge(params);
-      session.touchEdge(params.graphId, params.id, row);
-      return row;
-    },
-    ...target.insertEdgeNoReturn === void 0 ? {} : {
-      async insertEdgeNoReturn(params) {
-        await runInsertNoReturn(edgeDispatch, params);
-        session.touchEdge(params.graphId, params.id);
-      }
-    },
-    ...target.insertEdgesBatch === void 0 ? {} : {
-      async insertEdgesBatch(params) {
-        await runInsertBatch(edgeDispatch, params);
-        for (const edge of params) {
-          session.touchEdge(edge.graphId, edge.id);
-        }
-      }
-    },
-    ...target.insertEdgesBatchReturning === void 0 ? {} : {
-      async insertEdgesBatchReturning(params) {
-        const rows = await runInsertBatchReturning(edgeDispatch, params);
-        const rowsByIdentity = new Map(
-          rows.map((row) => [edgeRowIdentityKey(row), row])
-        );
-        for (const edge of params) {
-          session.touchEdge(
-            edge.graphId,
-            edge.id,
-            rowsByIdentity.get(edgeParamsIdentityKey(edge))
-          );
-        }
-        return rows;
-      }
-    },
-    async updateEdge(params) {
-      const row = await target.updateEdge(params);
-      session.touchEdge(params.graphId, params.id, row);
-      return row;
-    },
-    async deleteEdge(params) {
-      await target.deleteEdge(params);
-      session.touchEdge(params.graphId, params.id);
-    },
-    async hardDeleteEdge(params) {
-      await target.hardDeleteEdge(params);
-      session.touchEdge(params.graphId, params.id);
-    }
-  });
-}
-function createRecordedTransactionScope(target, schema, ownsWriteLock = false) {
-  requireCaptureStatements(target);
-  const session = createRecordedCaptureSession();
-  const resolvedSchema = schema ?? requireRecordedSchema(target);
-  return {
-    backend: createRecordedTransactionBackend(target, session, resolvedSchema),
-    async flush() {
-      await withRecordedRelationsPrecondition(
-        session.flush(target, resolvedSchema, ownsWriteLock),
-        { dialect: target.dialect, surface: "capture-flush" }
-      );
-    }
-  };
-}
-async function runCapturedAutocommit(backend, schema, fn, options) {
-  assertRequestedRecordedIsolation(backend, options);
-  return backend.transaction(async (target) => {
-    await assertRecordedCaptureTransactionIsolation(target);
-    const scope = createRecordedTransactionScope(target, schema, true);
-    const result = await fn(scope.backend);
-    await scope.flush();
-    return result;
-  }, options);
-}
-function createRecordedBackend(backend, schema) {
-  assertCapturableBackend(backend);
-  const capture = (fn) => runCapturedAutocommit(backend, schema, fn);
-  return createBackendOverlay(backend, {
-    ...rawWriteGuards(backend, "backend"),
-    async insertNode(params) {
-      return capture((target) => target.insertNode(params));
-    },
-    ...backend.insertNodeNoReturn === void 0 ? {} : {
-      async insertNodeNoReturn(params) {
-        await capture(
-          (target) => runInsertNoReturn(nodeInsertDispatch(target), params)
-        );
-      }
-    },
-    ...backend.insertNodesBatch === void 0 ? {} : {
-      async insertNodesBatch(params) {
-        await capture(
-          (target) => runInsertBatch(nodeInsertDispatch(target), params)
-        );
-      }
-    },
-    ...backend.insertNodesBatchReturning === void 0 ? {} : {
-      async insertNodesBatchReturning(params) {
-        return capture(
-          (target) => runInsertBatchReturning(nodeInsertDispatch(target), params)
-        );
-      }
-    },
-    async updateNode(params) {
-      return capture((target) => target.updateNode(params));
-    },
-    async deleteNode(params) {
-      await capture((target) => target.deleteNode(params));
-    },
-    async hardDeleteNode(params) {
-      await capture((target) => target.hardDeleteNode(params));
-    },
-    async insertEdge(params) {
-      return capture((target) => target.insertEdge(params));
-    },
-    ...backend.insertEdgeNoReturn === void 0 ? {} : {
-      async insertEdgeNoReturn(params) {
-        await capture(
-          (target) => runInsertNoReturn(edgeInsertDispatch(target), params)
-        );
-      }
-    },
-    ...backend.insertEdgesBatch === void 0 ? {} : {
-      async insertEdgesBatch(params) {
-        await capture(
-          (target) => runInsertBatch(edgeInsertDispatch(target), params)
-        );
-      }
-    },
-    ...backend.insertEdgesBatchReturning === void 0 ? {} : {
-      async insertEdgesBatchReturning(params) {
-        return capture(
-          (target) => runInsertBatchReturning(edgeInsertDispatch(target), params)
-        );
-      }
-    },
-    async updateEdge(params) {
-      return capture((target) => target.updateEdge(params));
-    },
-    async deleteEdge(params) {
-      await capture((target) => target.deleteEdge(params));
-    },
-    async hardDeleteEdge(params) {
-      await capture((target) => target.hardDeleteEdge(params));
-    },
-    async transaction(fn, options) {
-      assertRequestedRecordedIsolation(backend, options);
-      return backend.transaction(async (target) => {
-        await assertRecordedCaptureTransactionIsolation(target);
-        const scope = createRecordedTransactionScope(target, schema, true);
-        const result = await fn(scope.backend, createHistoryUnsafeSqlRef());
-        await scope.flush();
-        return result;
-      }, options);
-    },
-    ...backend.adoptTransaction === void 0 ? {} : {
-      adoptTransaction(externalTx) {
-        throw recordedCaptureRequiresCallbackTransactionError({
-          externalTxType: typeof externalTx
-        });
-      }
-    }
-  });
-}
-
-// src/store/materialize-removals.ts
-var ENTITY_KINDS = ["node", "edge"];
-function buildPendingKindRemoval(args) {
-  return { ...args, removedAt: void 0, error: void 0 };
-}
-async function materializeRemovals(context, options = {}) {
-  const { backend, graphId } = context;
-  if (backend.executeDdl === void 0 || backend.recordKindRemoval === void 0 || backend.getPendingKindRemovals === void 0) {
-    throw new ConfigurationError(
-      "store.materializeRemovals() requires a backend with kind-removal primitives (executeDdl, recordKindRemoval, getPendingKindRemovals). The bundled SQLite and Postgres backends provide them.",
-      { code: "MATERIALIZE_REMOVALS_BACKEND_UNSUPPORTED" }
-    );
-  }
-  await ensureFocusedStatusTable(backend, backend.ensureKindRemovalsTable);
-  await reconcilePendingRemovals(context);
-  const reclaimedVectorFields = await reclaimRemovedVectorFieldTables(context);
-  const pending = await backend.getPendingKindRemovals(graphId);
-  const kindFilter = options.kinds === void 0 ? void 0 : new Set(options.kinds);
-  const candidates = pending.filter(
-    (row) => kindFilter === void 0 ? true : kindFilter.has(row.kindName)
+  await ensureFocusedStatusTable(backend, backend.ensureKindRemovalsTable);
+  await reconcilePendingRemovals(context);
+  const reclaimedVectorFields = await reclaimRemovedVectorFieldTables(context);
+  const pending = await backend.getPendingKindRemovals(graphId);
+  const kindFilter = options.kinds === void 0 ? void 0 : new Set(options.kinds);
+  const candidates = pending.filter(
+    (row) => kindFilter === void 0 ? true : kindFilter.has(row.kindName)
   );
   if (candidates.length === 0) return { results: [], reclaimedVectorFields };
   const tableNames = backend.tableNames;
@@ -13023,180 +11591,20 @@ async function reclaimRemovedVectorFieldTables(context) {
     }
   }
   if (results.every((entry2) => entry2.status === "reclaimed")) {
-    if (perBackend === void 0) {
-      perBackend = /* @__PURE__ */ new Map();
-      reclaimCache.set(backend, perBackend);
-    }
-    perBackend.set(cacheKey, results);
-  }
-  return results;
-}
-var reclaimCache = /* @__PURE__ */ new WeakMap();
-function quote(identifier) {
-  return `"${identifier.replaceAll('"', '""')}"`;
-}
-function literal(value) {
-  return `'${value.replaceAll("'", "''")}'`;
-}
-
-// src/constraints/index.ts
-var UNIQUE_KEY_SEPARATOR = "";
-var UNIQUE_KEY_NULL_MARKER = "";
-function computeUniqueKey(props, fields, collation) {
-  const values = fields.map((field2) => {
-    const value = props[field2];
-    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 predicate = constraint.where(predicateBuilder);
-  return evaluatePredicate(predicate, 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(predicate, props) {
-  if (typeof predicate !== "object" || predicate === null || !("__type" in predicate)) {
-    return true;
-  }
-  const pred = predicate;
-  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);
-  const fromValid = validFromKinds.some(
-    (validKind) => registry.isAssignableTo(fromKind, validKind)
-  );
-  if (!fromValid) {
-    return new EndpointError({
-      edgeKind,
-      endpoint: "from",
-      actualKind: fromKind,
-      expectedKinds: validFromKinds
-    });
-  }
-  const validToKinds = registration.to.map((node) => node.kind);
-  const toValid = validToKinds.some(
-    (validKind) => registry.isAssignableTo(toKind, validKind)
-  );
-  if (!toValid) {
-    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
-      });
+    if (perBackend === void 0) {
+      perBackend = /* @__PURE__ */ new Map();
+      reclaimCache.set(backend, perBackend);
     }
+    perBackend.set(cacheKey, results);
   }
-  return void 0;
+  return results;
+}
+var reclaimCache = /* @__PURE__ */ new WeakMap();
+function quote(identifier) {
+  return `"${identifier.replaceAll('"', '""')}"`;
+}
+function literal(value) {
+  return `'${value.replaceAll("'", "''")}'`;
 }
 
 // src/store/constraints.ts
@@ -13483,16 +11891,11 @@ async function executeEdgeCreateInternal(ctx, input, backend, options) {
   const kind = input.kind;
   const id = input.id ?? generateId();
   const opContext = ctx.createOperationContext("create", "edge", kind, id);
-  return ctx.withOperationHooks(opContext, async () => {
-    const prepared = await validateAndPrepareEdgeCreate(
-      ctx,
-      input,
-      id,
-      backend
-    );
+  return runHookedWriteOperation(ctx, opContext, backend, async (target) => {
+    const prepared = await validateAndPrepareEdgeCreate(ctx, input, id, target);
     let row;
     {
-      row = await backend.insertEdge(prepared.insertParams);
+      row = await target.insertEdge(prepared.insertParams);
     }
     if (row === void 0) return;
     return rowToEdge(row);
@@ -13512,93 +11915,64 @@ async function executeEdgeCreateNoReturnBatch(ctx, inputs, backend) {
   if (inputs.length === 0) {
     return;
   }
-  const { backend: validationBackend, registerPendingEdgeForCardinality } = createEdgeBatchValidationBackend(backend);
-  const preparedCreates = [];
-  for (const input of inputs) {
-    const id = input.id ?? generateId();
-    const prepared = await validateAndPrepareEdgeCreate(
-      ctx,
-      input,
-      id,
-      validationBackend
-    );
-    preparedCreates.push(prepared);
-    registerPendingEdgeForCardinality(
-      prepared.insertParams,
-      prepared.cardinality
+  await runInWriteTransaction(ctx, backend, async (target) => {
+    const { backend: validationBackend, registerPendingEdgeForCardinality } = createEdgeBatchValidationBackend(target);
+    const preparedCreates = [];
+    for (const input of inputs) {
+      const id = input.id ?? generateId();
+      const prepared = await validateAndPrepareEdgeCreate(
+        ctx,
+        input,
+        id,
+        validationBackend
+      );
+      preparedCreates.push(prepared);
+      registerPendingEdgeForCardinality(
+        prepared.insertParams,
+        prepared.cardinality
+      );
+    }
+    const batchInsertParams = preparedCreates.map(
+      (prepared) => prepared.insertParams
     );
-  }
-  const batchInsertParams = preparedCreates.map(
-    (prepared) => prepared.insertParams
-  );
-  await runInsertBatch(edgeInsertDispatch(backend), batchInsertParams);
+    await runInsertBatch(edgeInsertDispatch(target), batchInsertParams);
+  });
 }
 async function executeEdgeCreateBatch(ctx, inputs, backend) {
   if (inputs.length === 0) {
     return [];
   }
-  const { backend: validationBackend, registerPendingEdgeForCardinality } = createEdgeBatchValidationBackend(backend);
-  const preparedCreates = [];
-  for (const input of inputs) {
-    const id = input.id ?? generateId();
-    const prepared = await validateAndPrepareEdgeCreate(
-      ctx,
-      input,
-      id,
-      validationBackend
+  return runInWriteTransaction(ctx, backend, async (target) => {
+    const { backend: validationBackend, registerPendingEdgeForCardinality } = createEdgeBatchValidationBackend(target);
+    const preparedCreates = [];
+    for (const input of inputs) {
+      const id = input.id ?? generateId();
+      const prepared = await validateAndPrepareEdgeCreate(
+        ctx,
+        input,
+        id,
+        validationBackend
+      );
+      preparedCreates.push(prepared);
+      registerPendingEdgeForCardinality(
+        prepared.insertParams,
+        prepared.cardinality
+      );
+    }
+    const batchInsertParams = preparedCreates.map(
+      (prepared) => prepared.insertParams
     );
-    preparedCreates.push(prepared);
-    registerPendingEdgeForCardinality(
-      prepared.insertParams,
-      prepared.cardinality
+    const rows = await runInsertBatchReturning(
+      edgeInsertDispatch(target),
+      batchInsertParams
     );
-  }
-  const batchInsertParams = preparedCreates.map(
-    (prepared) => prepared.insertParams
-  );
-  const rows = await runInsertBatchReturning(
-    edgeInsertDispatch(backend),
-    batchInsertParams
-  );
-  return rows.map((row) => rowToEdge(row));
-}
-async function executeEdgeUpdate(ctx, input, backend) {
-  const id = input.id;
-  const existing = await backend.getEdge(ctx.graphId, id);
-  if (!existing || existing.deleted_at) {
-    throw new EdgeNotFoundError("unknown", id);
-  }
-  const opContext = ctx.createOperationContext(
-    "update",
-    "edge",
-    existing.kind,
-    id
-  );
-  return ctx.withOperationHooks(opContext, async () => {
-    const registration = getEdgeRegistration(ctx.graph, existing.kind);
-    const edgeKind = registration.type;
-    const existingProps = JSON.parse(existing.props);
-    const mergedProps = { ...existingProps, ...input.props };
-    const validatedProps = validateEdgeProps(edgeKind.schema, mergedProps, {
-      kind: existing.kind,
-      operation: "update",
-      id
-    });
-    const validTo = validateOptionalCanonicalIsoDate(input.validTo, "validTo");
-    const updateParams = {
-      graphId: ctx.graphId,
-      id,
-      props: validatedProps
-    };
-    if (validTo !== void 0) updateParams.validTo = validTo;
-    const row = await backend.updateEdge(updateParams);
-    return rowToEdge(row);
+    return rows.map((row) => rowToEdge(row));
   });
 }
-async function executeEdgeUpsertUpdate(ctx, input, backend, options) {
+async function performEdgeUpdate(ctx, input, target, options) {
   const id = input.id;
-  const existing = await backend.getEdge(ctx.graphId, id);
-  if (!existing) {
+  const existing = await target.getEdge(ctx.graphId, id);
+  if (!existing || !options?.clearDeleted && existing.deleted_at) {
     throw new EdgeNotFoundError("unknown", id);
   }
   const registration = getEdgeRegistration(ctx.graph, existing.kind);
@@ -13618,40 +11992,55 @@ async function executeEdgeUpsertUpdate(ctx, input, backend, options) {
   };
   if (validTo !== void 0) updateParams.validTo = validTo;
   if (options?.clearDeleted) updateParams.clearDeleted = true;
-  const row = await backend.updateEdge(updateParams);
+  const row = await target.updateEdge(updateParams);
   return rowToEdge(row);
 }
-async function executeEdgeDelete(ctx, id, backend) {
-  const existing = await backend.getEdge(ctx.graphId, id);
-  if (!existing || existing.deleted_at) {
-    return;
+async function executeEdgeUpdate(ctx, input, backend) {
+  const id = input.id;
+  const gate = await backend.getEdge(ctx.graphId, id);
+  if (!gate || gate.deleted_at) {
+    throw new EdgeNotFoundError("unknown", id);
   }
-  const opContext = ctx.createOperationContext(
-    "delete",
-    "edge",
-    existing.kind,
-    id
+  const opContext = ctx.createOperationContext("update", "edge", gate.kind, id);
+  return runHookedWriteOperation(
+    ctx,
+    opContext,
+    backend,
+    (target) => performEdgeUpdate(ctx, input, target)
+  );
+}
+async function executeEdgeUpsertUpdate(ctx, input, backend, options) {
+  return runInWriteTransaction(
+    ctx,
+    backend,
+    (target) => performEdgeUpdate(ctx, input, target, options)
   );
-  return ctx.withOperationHooks(opContext, async () => {
-    await backend.deleteEdge({
+}
+async function executeEdgeDelete(ctx, id, backend) {
+  const gate = await backend.getEdge(ctx.graphId, id);
+  if (!gate || gate.deleted_at) return;
+  const opContext = ctx.createOperationContext("delete", "edge", gate.kind, id);
+  return runHookedWriteOperation(ctx, opContext, backend, async (target) => {
+    const existing = await target.getEdge(ctx.graphId, id);
+    if (!existing || existing.deleted_at) {
+      return;
+    }
+    await target.deleteEdge({
       graphId: ctx.graphId,
       id
     });
   });
 }
 async function executeEdgeHardDelete(ctx, id, backend) {
-  const existing = await backend.getEdge(ctx.graphId, id);
-  if (!existing) {
-    return;
-  }
-  const opContext = ctx.createOperationContext(
-    "delete",
-    "edge",
-    existing.kind,
-    id
-  );
-  return ctx.withOperationHooks(opContext, async () => {
-    await backend.hardDeleteEdge({
+  const gate = await backend.getEdge(ctx.graphId, id);
+  if (!gate) return;
+  const opContext = ctx.createOperationContext("delete", "edge", gate.kind, id);
+  return runHookedWriteOperation(ctx, opContext, backend, async (target) => {
+    const existing = await target.getEdge(ctx.graphId, id);
+    if (!existing) {
+      return;
+    }
+    await target.hardDeleteEdge({
       graphId: ctx.graphId,
       id
     });
@@ -13771,72 +12160,100 @@ async function executeEdgeGetOrCreateByEndpoints(ctx, kind, fromKind, fromId, to
     operation: "create"
   });
   validateMatchOnFields(edgeKind.schema, matchOn, kind);
-  const candidateRows = await backend.findEdgesByKind({
-    graphId: ctx.graphId,
-    kind,
-    fromKind,
-    fromId,
-    toKind,
-    toId,
-    excludeDeleted: false,
-    temporalMode: "includeTombstones"
-  });
-  const { liveRow, deletedRow } = findMatchingEdge(
-    candidateRows,
-    matchOn,
-    validatedProps
-  );
-  if (liveRow === void 0 && deletedRow === void 0) {
-    const input = {
+  if (ifExists === "return") {
+    const probeRows = await backend.findEdgesByKind({
+      graphId: ctx.graphId,
       kind,
       fromKind,
       fromId,
       toKind,
       toId,
-      props: validatedProps
-    };
-    const edge2 = await executeEdgeCreate(ctx, input, backend);
-    return { edge: edge2, action: "created" };
+      excludeDeleted: false,
+      temporalMode: "includeTombstones"
+    });
+    const { liveRow: probedLiveRow } = findMatchingEdge(
+      probeRows,
+      matchOn,
+      validatedProps
+    );
+    if (probedLiveRow !== void 0) {
+      return { edge: rowToEdge(probedLiveRow), action: "found" };
+    }
   }
-  if (liveRow !== void 0) {
-    if (ifExists === "return") {
-      return { edge: rowToEdge(liveRow), action: "found" };
+  async function attempt() {
+    const candidateRows = await backend.findEdgesByKind({
+      graphId: ctx.graphId,
+      kind,
+      fromKind,
+      fromId,
+      toKind,
+      toId,
+      excludeDeleted: false,
+      temporalMode: "includeTombstones"
+    });
+    const { liveRow, deletedRow } = findMatchingEdge(
+      candidateRows,
+      matchOn,
+      validatedProps
+    );
+    if (liveRow === void 0 && deletedRow === void 0) {
+      const input = {
+        kind,
+        fromKind,
+        fromId,
+        toKind,
+        toId,
+        props: validatedProps
+      };
+      const edge2 = await executeEdgeCreate(ctx, input, backend);
+      return { edge: edge2, action: "created" };
     }
-    const edge2 = await executeEdgeUpsertUpdate(
-      ctx,
-      { id: liveRow.id, props: validatedProps },
+    if (liveRow !== void 0) {
+      if (ifExists === "return") {
+        return { edge: rowToEdge(liveRow), action: "found" };
+      }
+      const edge2 = await executeEdgeUpsertUpdate(
+        ctx,
+        { id: liveRow.id, props: validatedProps },
+        backend
+      );
+      return { edge: edge2, action: "updated" };
+    }
+    const cardinality = registration.cardinality ?? "many";
+    if (deletedRow === void 0) {
+      throw new Error("Expected deletedRow to be defined");
+    }
+    const matchedDeletedRow = deletedRow;
+    const effectiveValidTo = matchedDeletedRow.valid_to;
+    const constraintContext = {
+      graphId: ctx.graphId,
+      registry: ctx.registry,
       backend
+    };
+    await checkCardinalityConstraint(
+      constraintContext,
+      kind,
+      cardinality,
+      fromKind,
+      fromId,
+      toKind,
+      toId,
+      effectiveValidTo
     );
-    return { edge: edge2, action: "updated" };
+    const edge = await executeEdgeUpsertUpdate(
+      ctx,
+      { id: matchedDeletedRow.id, props: validatedProps },
+      backend,
+      { clearDeleted: true }
+    );
+    return { edge, action: "resurrected" };
   }
-  const cardinality = registration.cardinality ?? "many";
-  if (deletedRow === void 0) {
-    throw new Error("Expected deletedRow to be defined");
+  try {
+    return await attempt();
+  } catch (error) {
+    if (!(error instanceof CardinalityError)) throw error;
+    return attempt();
   }
-  const matchedDeletedRow = deletedRow;
-  const effectiveValidTo = matchedDeletedRow.valid_to;
-  const constraintContext = {
-    graphId: ctx.graphId,
-    registry: ctx.registry,
-    backend
-  };
-  await checkCardinalityConstraint(
-    constraintContext,
-    kind,
-    cardinality,
-    fromKind,
-    fromId,
-    toKind,
-    toId,
-    effectiveValidTo
-  );
-  const edge = await executeEdgeUpsertUpdate(
-    ctx,
-    { id: matchedDeletedRow.id, props: validatedProps },
-    backend,
-    { clearDeleted: true }
-  );
-  return { edge, action: "resurrected" };
 }
 async function executeEdgeBulkGetOrCreateByEndpoints(ctx, kind, items, backend, options) {
   if (items.length === 0) return [];
@@ -13882,258 +12299,153 @@ async function executeEdgeBulkGetOrCreateByEndpoints(ctx, kind, items, backend,
       uniqueEndpoints.set(entry2.endpointKey, {
         fromKind: entry2.fromKind,
         fromId: entry2.fromId,
-        toKind: entry2.toKind,
-        toId: entry2.toId
-      });
-    }
-  }
-  const rowsByEndpoint = /* @__PURE__ */ new Map();
-  for (const [endpointKey, endpoint] of uniqueEndpoints) {
-    const rows = await backend.findEdgesByKind({
-      graphId: ctx.graphId,
-      kind,
-      fromKind: endpoint.fromKind,
-      fromId: endpoint.fromId,
-      toKind: endpoint.toKind,
-      toId: endpoint.toId,
-      excludeDeleted: false,
-      temporalMode: "includeTombstones"
-    });
-    rowsByEndpoint.set(endpointKey, rows);
-  }
-  const toCreate = [];
-  const toFetch = [];
-  const duplicateOf = [];
-  const seenKeys = /* @__PURE__ */ new Map();
-  for (const [index, entry2] of validated.entries()) {
-    const previousIndex = seenKeys.get(entry2.compositeKey);
-    if (previousIndex !== void 0) {
-      duplicateOf.push({ index, sourceIndex: previousIndex });
-      continue;
-    }
-    seenKeys.set(entry2.compositeKey, index);
-    const candidateRows = rowsByEndpoint.get(entry2.endpointKey) ?? [];
-    const { liveRow, deletedRow } = findMatchingEdge(
-      candidateRows,
-      matchOn,
-      entry2.validatedProps
-    );
-    if (liveRow === void 0 && deletedRow === void 0) {
-      toCreate.push({
-        index,
-        input: {
-          kind,
-          fromKind: entry2.fromKind,
-          fromId: entry2.fromId,
-          toKind: entry2.toKind,
-          toId: entry2.toId,
-          props: entry2.validatedProps
-        }
-      });
-    } else {
-      const bestRow = liveRow ?? deletedRow;
-      if (bestRow === void 0) {
-        throw new Error("Expected at least one of liveRow or deletedRow");
-      }
-      toFetch.push({
-        index,
-        row: bestRow,
-        isDeleted: liveRow === void 0,
-        validatedProps: entry2.validatedProps,
-        fromKind: entry2.fromKind,
-        fromId: entry2.fromId,
-        toKind: entry2.toKind,
-        toId: entry2.toId
-      });
-    }
-  }
-  const results = Array.from({ length: items.length });
-  if (toCreate.length > 0) {
-    const createInputs = toCreate.map((entry2) => entry2.input);
-    const createdEdges = await executeEdgeCreateBatch(
-      ctx,
-      createInputs,
-      backend
-    );
-    for (const [batchIndex, entry2] of toCreate.entries()) {
-      results[entry2.index] = {
-        edge: createdEdges[batchIndex],
-        action: "created"
-      };
-    }
-  }
-  for (const entry2 of toFetch) {
-    if (entry2.isDeleted) {
-      const effectiveValidTo = entry2.row.valid_to;
-      const constraintContext = {
-        graphId: ctx.graphId,
-        registry: ctx.registry,
-        backend
-      };
-      await checkCardinalityConstraint(
-        constraintContext,
-        kind,
-        cardinality,
-        entry2.fromKind,
-        entry2.fromId,
-        entry2.toKind,
-        entry2.toId,
-        effectiveValidTo
-      );
-      const edge = await executeEdgeUpsertUpdate(
-        ctx,
-        { id: entry2.row.id, props: entry2.validatedProps },
-        backend,
-        { clearDeleted: true }
-      );
-      results[entry2.index] = { edge, action: "resurrected" };
-    } else if (ifExists === "update") {
-      const edge = await executeEdgeUpsertUpdate(
-        ctx,
-        { id: entry2.row.id, props: entry2.validatedProps },
-        backend
-      );
-      results[entry2.index] = { edge, action: "updated" };
-    } else {
-      results[entry2.index] = { edge: rowToEdge(entry2.row), action: "found" };
-    }
-  }
-  for (const { index, sourceIndex } of duplicateOf) {
-    const sourceResult = results[sourceIndex];
-    results[index] = { edge: sourceResult.edge, action: "found" };
-  }
-  return results;
-}
-
-// src/store/uniqueness.ts
-async function checkUniquenessConstraints(ctx, kind, id, props, constraints) {
-  for (const constraint of constraints) {
-    if (!checkWherePredicate(constraint, props)) {
-      continue;
+        toKind: entry2.toKind,
+        toId: entry2.toId
+      });
     }
-    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({
+  }
+  async function fetchRowsByEndpoint(reader) {
+    const rowsByEndpoint = /* @__PURE__ */ new Map();
+    for (const [endpointKey, endpoint] of uniqueEndpoints) {
+      const rows = await reader.findEdgesByKind({
         graphId: ctx.graphId,
-        nodeKind: kindToCheck,
-        constraintName: constraint.name,
-        key
+        kind,
+        fromKind: endpoint.fromKind,
+        fromId: endpoint.fromId,
+        toKind: endpoint.toKind,
+        toId: endpoint.toId,
+        excludeDeleted: false,
+        temporalMode: "includeTombstones"
       });
-      if (existing && existing.node_id !== id) {
-        throw new UniquenessError({
-          constraintName: constraint.name,
-          kind: kindToCheck,
-          existingId: existing.node_id,
-          newId: id,
-          fields: constraint.fields
+      rowsByEndpoint.set(endpointKey, rows);
+    }
+    return rowsByEndpoint;
+  }
+  function partitionEntries(rowsByEndpoint) {
+    const toCreate = [];
+    const toFetch = [];
+    const duplicateOf = [];
+    const seenKeys = /* @__PURE__ */ new Map();
+    for (const [index, entry2] of validated.entries()) {
+      const previousIndex = seenKeys.get(entry2.compositeKey);
+      if (previousIndex !== void 0) {
+        duplicateOf.push({ index, sourceIndex: previousIndex });
+        continue;
+      }
+      seenKeys.set(entry2.compositeKey, index);
+      const candidateRows = rowsByEndpoint.get(entry2.endpointKey) ?? [];
+      const { liveRow, deletedRow } = findMatchingEdge(
+        candidateRows,
+        matchOn,
+        entry2.validatedProps
+      );
+      if (liveRow === void 0 && deletedRow === void 0) {
+        toCreate.push({
+          index,
+          input: {
+            kind,
+            fromKind: entry2.fromKind,
+            fromId: entry2.fromId,
+            toKind: entry2.toKind,
+            toId: entry2.toId,
+            props: entry2.validatedProps
+          }
+        });
+      } else {
+        const bestRow = liveRow ?? deletedRow;
+        if (bestRow === void 0) {
+          throw new Error("Expected at least one of liveRow or deletedRow");
+        }
+        toFetch.push({
+          index,
+          row: bestRow,
+          isDeleted: liveRow === void 0,
+          validatedProps: entry2.validatedProps,
+          fromKind: entry2.fromKind,
+          fromId: entry2.fromId,
+          toKind: entry2.toKind,
+          toId: entry2.toId
         });
       }
     }
+    return { toCreate, toFetch, duplicateOf };
   }
-}
-async function insertUniquenessEntries(ctx, kind, id, props, constraints) {
-  for (const constraint of constraints) {
-    if (!checkWherePredicate(constraint, props)) {
-      continue;
+  if (ifExists === "return") {
+    const probe = partitionEntries(await fetchRowsByEndpoint(backend));
+    const allFoundLive = probe.toCreate.length === 0 && probe.toFetch.every((entry2) => !entry2.isDeleted);
+    if (allFoundLive) {
+      const found = Array.from({ length: items.length });
+      for (const entry2 of probe.toFetch) {
+        found[entry2.index] = { edge: rowToEdge(entry2.row), action: "found" };
+      }
+      for (const { index, sourceIndex } of probe.duplicateOf) {
+        found[index] = { edge: found[sourceIndex].edge, action: "found" };
+      }
+      return found;
     }
-    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 deleteUniquenessEntries(ctx, kind, props, constraints) {
-  for (const constraint of constraints) {
-    if (!checkWherePredicate(constraint, props)) {
-      continue;
-    }
-    const key = computeUniqueKey(
-      props,
-      constraint.fields,
-      constraint.collation
+  return runInWriteTransaction(ctx, backend, async (target) => {
+    const { toCreate, toFetch, duplicateOf } = partitionEntries(
+      await fetchRowsByEndpoint(target)
     );
-    await ctx.backend.deleteUnique({
-      graphId: ctx.graphId,
-      nodeKind: kind,
-      constraintName: constraint.name,
-      key
-    });
-  }
-}
-async function updateUniquenessEntries(ctx, kind, id, oldProps, newProps, constraints) {
-  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 (oldApplies && oldKey !== void 0) {
-      await ctx.backend.deleteUnique({
-        graphId: ctx.graphId,
-        nodeKind: kind,
-        constraintName: constraint.name,
-        key: oldKey
-      });
-    }
-    if (newApplies && newKey !== void 0) {
-      const kindsToCheck = getKindsForUniquenessCheck(
-        kind,
-        constraint.scope,
-        ctx.registry
+    const results = Array.from({ length: items.length });
+    if (toCreate.length > 0) {
+      const createInputs = toCreate.map((entry2) => entry2.input);
+      const createdEdges = await executeEdgeCreateBatch(
+        ctx,
+        createInputs,
+        target
       );
-      for (const kindToCheck of kindsToCheck) {
-        const existing = await ctx.backend.checkUnique({
+      for (const [batchIndex, entry2] of toCreate.entries()) {
+        results[entry2.index] = {
+          edge: createdEdges[batchIndex],
+          action: "created"
+        };
+      }
+    }
+    for (const entry2 of toFetch) {
+      if (entry2.isDeleted) {
+        const effectiveValidTo = entry2.row.valid_to;
+        const constraintContext = {
           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
-          });
-        }
+          registry: ctx.registry,
+          backend: target
+        };
+        await checkCardinalityConstraint(
+          constraintContext,
+          kind,
+          cardinality,
+          entry2.fromKind,
+          entry2.fromId,
+          entry2.toKind,
+          entry2.toId,
+          effectiveValidTo
+        );
+        const edge = await executeEdgeUpsertUpdate(
+          ctx,
+          { id: entry2.row.id, props: entry2.validatedProps },
+          target,
+          { clearDeleted: true }
+        );
+        results[entry2.index] = { edge, action: "resurrected" };
+      } else if (ifExists === "update") {
+        const edge = await executeEdgeUpsertUpdate(
+          ctx,
+          { id: entry2.row.id, props: entry2.validatedProps },
+          target
+        );
+        results[entry2.index] = { edge, action: "updated" };
+      } else {
+        results[entry2.index] = { edge: rowToEdge(entry2.row), action: "found" };
       }
-      await ctx.backend.insertUnique({
-        graphId: ctx.graphId,
-        nodeKind: kind,
-        constraintName: constraint.name,
-        key: newKey,
-        nodeId: id,
-        concreteKind: kind
-      });
     }
-  }
+    for (const { index, sourceIndex } of duplicateOf) {
+      const sourceResult = results[sourceIndex];
+      results[index] = { edge: sourceResult.edge, action: "found" };
+    }
+    return results;
+  });
 }
-
-// src/store/operations/node-operations.ts
 function getNodeRegistration(graph, kind) {
   const registration = graph.nodes[kind];
   if (registration === void 0) throw new KindNotFoundError(kind, "node");
@@ -14143,9 +12455,6 @@ var CACHE_KEY_SEPARATOR = "\0";
 function buildNodeCacheKey(graphId, kind, id) {
   return `${graphId}${CACHE_KEY_SEPARATOR}${kind}${CACHE_KEY_SEPARATOR}${id}`;
 }
-function runInTopLevelTransactionForHistory(ctx, backend, fn) {
-  return ctx.historyEnabled ? runOptionallyInTransaction(backend, fn) : fn(backend);
-}
 function buildUniqueCacheKey(graphId, nodeKind, constraintName, key) {
   return `${graphId}${CACHE_KEY_SEPARATOR}${nodeKind}${CACHE_KEY_SEPARATOR}${constraintName}${CACHE_KEY_SEPARATOR}${key}`;
 }
@@ -14195,15 +12504,6 @@ function resolveConstraint(graph, kind, constraintName) {
   }
   return constraint;
 }
-function createUniquenessContext(graphId, registry, backend) {
-  return { graphId, registry, backend };
-}
-function createEmbeddingSyncContext(graphId, nodeKind, nodeId, backend) {
-  return { graphId, nodeKind, nodeId, backend };
-}
-function createFulltextSyncContext(graphId, nodeKind, nodeId, backend) {
-  return { graphId, nodeKind, nodeId, backend };
-}
 function createNodeBatchValidationBackend(graphId, registry, backend) {
   const nodeCache = /* @__PURE__ */ new Map();
   const pendingNodes = /* @__PURE__ */ new Map();
@@ -14345,37 +12645,24 @@ async function validateAndPrepareNodeCreate(ctx, input, id, backend) {
     )
   };
 }
-async function finalizeNodeCreate(ctx, prepared, backend) {
-  await insertUniquenessEntries(
-    createUniquenessContext(ctx.graphId, ctx.registry, backend),
-    prepared.kind,
-    prepared.id,
-    prepared.validatedProps,
-    prepared.uniqueConstraints
-  );
-  await syncEmbeddings(
-    createEmbeddingSyncContext(
-      ctx.graphId,
-      prepared.kind,
-      prepared.id,
-      backend
-    ),
-    prepared.nodeKind.schema,
-    prepared.validatedProps
-  );
-  await syncFulltext(
-    createFulltextSyncContext(ctx.graphId, prepared.kind, prepared.id, backend),
-    prepared.nodeKind.schema,
-    prepared.validatedProps
+async function finalizeNodeCreate(ctx, prepared, backend, lock) {
+  await applyNodeInsertSideEffects(
+    createNodeWriteContext(ctx.graphId, ctx.registry, lock),
+    {
+      kind: prepared.kind,
+      id: prepared.id,
+      schema: prepared.nodeKind.schema,
+      props: prepared.validatedProps,
+      uniqueConstraints: prepared.uniqueConstraints
+    },
+    backend
   );
 }
-async function performNodeUpdate(ctx, input, backend, options) {
+async function performNodeUpdate(ctx, input, backend, lock, options) {
   const { kind, id } = input;
   const registration = getNodeRegistration(ctx.graph, kind);
   const existing = await backend.getNode(ctx.graphId, kind, id);
-  if (!existing || existing.deleted_at && !options?.clearDeleted) {
-    throw new NodeNotFoundError(kind, id);
-  }
+  if (!existing) throw new NodeNotFoundError(kind, id);
   const existingProps = JSON.parse(existing.props);
   const mergedProps = { ...existingProps, ...input.props };
   const nodeKind = registration.type;
@@ -14385,69 +12672,29 @@ async function performNodeUpdate(ctx, input, backend, options) {
     id
   });
   const validTo = validateOptionalCanonicalIsoDate(input.validTo, "validTo");
-  await updateUniquenessEntries(
-    createUniquenessContext(ctx.graphId, ctx.registry, backend),
-    kind,
-    id,
-    existingProps,
+  const writeContext = createNodeWriteContext(ctx.graphId, ctx.registry, lock);
+  const shared = {
+    schema: nodeKind.schema,
     validatedProps,
-    registration.unique ?? []
-  );
-  const updateParams = {
-    graphId: ctx.graphId,
-    kind,
-    id,
-    props: validatedProps,
-    incrementVersion: true
+    uniqueConstraints: registration.unique ?? [],
+    ...validTo !== void 0 && { validTo }
   };
-  if (validTo !== void 0) updateParams.validTo = validTo;
-  if (options?.clearDeleted) updateParams.clearDeleted = true;
-  const row = await backend.updateNode(updateParams);
-  await syncEmbeddings(
-    createEmbeddingSyncContext(ctx.graphId, kind, id, backend),
-    nodeKind.schema,
-    validatedProps
-  );
-  await syncFulltext(
-    createFulltextSyncContext(ctx.graphId, kind, id, backend),
-    nodeKind.schema,
-    validatedProps
+  if (options?.clearDeleted) {
+    const row2 = await applyNodeUpdate(
+      writeContext,
+      { ...shared, existing, clearDeleted: true },
+      backend
+    );
+    return rowToNode(row2);
+  }
+  if (!isLiveNodeRow(existing)) throw new NodeNotFoundError(kind, id);
+  const row = await applyNodeUpdate(
+    writeContext,
+    { ...shared, existing },
+    backend
   );
   return rowToNode(row);
 }
-async function enforceDeleteBehavior(ctx, kind, id, mode, backend, registration) {
-  const deleteBehavior = registration.onDelete ?? "restrict";
-  const connectedEdges = await backend.findEdgesConnectedTo({
-    graphId: ctx.graphId,
-    nodeKind: kind,
-    nodeId: id
-  });
-  if (connectedEdges.length === 0) return;
-  switch (deleteBehavior) {
-    case "restrict": {
-      const edgeKinds = [...new Set(connectedEdges.map((edge) => edge.kind))];
-      throw new RestrictedDeleteError({
-        nodeKind: kind,
-        nodeId: id,
-        edgeCount: connectedEdges.length,
-        edgeKinds
-      });
-    }
-    case "cascade":
-    case "disconnect": {
-      for (const edge of connectedEdges) {
-        await (mode === "hard" ? backend.hardDeleteEdge({
-          graphId: ctx.graphId,
-          id: edge.id
-        }) : backend.deleteEdge({
-          graphId: ctx.graphId,
-          id: edge.id
-        }));
-      }
-      break;
-    }
-  }
-}
 async function prepareBatchCreates(ctx, inputs, backend) {
   const {
     backend: validationBackend,
@@ -14528,9 +12775,11 @@ async function executeNodeCreateInternal(ctx, input, backend, options) {
   const kind = input.kind;
   const id = input.id ?? generateId();
   const opContext = ctx.createOperationContext("create", "node", kind, id);
-  return ctx.withOperationHooks(
+  return runHookedWriteOperation(
+    ctx,
     opContext,
-    () => runInTopLevelTransactionForHistory(ctx, backend, async (target) => {
+    backend,
+    async (target, lock) => {
       const prepared = await validateAndPrepareNodeCreate(
         ctx,
         input,
@@ -14541,10 +12790,10 @@ async function executeNodeCreateInternal(ctx, input, backend, options) {
       {
         row = await target.insertNode(prepared.insertParams);
       }
-      await finalizeNodeCreate(ctx, prepared, target);
+      await finalizeNodeCreate(ctx, prepared, target, lock);
       if (row === void 0) return;
       return rowToNode(row);
-    })
+    }
   );
 }
 async function executeNodeCreate(ctx, input, backend) {
@@ -14559,7 +12808,7 @@ async function executeNodeCreate(ctx, input, backend) {
 }
 async function executeNodeCreateNoReturnBatch(ctx, inputs, backend) {
   if (inputs.length === 0) return;
-  await runInTopLevelTransactionForHistory(ctx, backend, async (target) => {
+  await runInWriteTransaction(ctx, backend, async (target, lock) => {
     const { preparedCreates, batchInsertParams } = await prepareBatchCreates(
       ctx,
       inputs,
@@ -14567,13 +12816,13 @@ async function executeNodeCreateNoReturnBatch(ctx, inputs, backend) {
     );
     await runInsertBatch(nodeInsertDispatch(target), batchInsertParams);
     for (const prepared of preparedCreates) {
-      await finalizeNodeCreate(ctx, prepared, target);
+      await finalizeNodeCreate(ctx, prepared, target, lock);
     }
   });
 }
 async function executeNodeCreateBatch(ctx, inputs, backend) {
   if (inputs.length === 0) return [];
-  return runInTopLevelTransactionForHistory(ctx, backend, async (target) => {
+  return runInWriteTransaction(ctx, backend, async (target, lock) => {
     const { preparedCreates, batchInsertParams } = await prepareBatchCreates(
       ctx,
       inputs,
@@ -14584,7 +12833,7 @@ async function executeNodeCreateBatch(ctx, inputs, backend) {
       batchInsertParams
     );
     for (const prepared of preparedCreates) {
-      await finalizeNodeCreate(ctx, prepared, target);
+      await finalizeNodeCreate(ctx, prepared, target, lock);
     }
     return rows.map((row) => rowToNode(row));
   });
@@ -14596,71 +12845,69 @@ async function executeNodeUpdate(ctx, input, backend, options) {
     input.kind,
     input.id
   );
-  return ctx.withOperationHooks(
+  return runHookedWriteOperation(
+    ctx,
     opContext,
-    () => runInTopLevelTransactionForHistory(
-      ctx,
-      backend,
-      (target) => performNodeUpdate(ctx, input, target, options)
-    )
+    backend,
+    (target, lock) => performNodeUpdate(ctx, input, target, lock, options)
   );
 }
 async function executeNodeUpsertUpdate(ctx, input, backend, options) {
-  return runInTopLevelTransactionForHistory(
+  return runInWriteTransaction(
     ctx,
     backend,
-    (target) => performNodeUpdate(ctx, input, target, options)
+    (target, lock) => performNodeUpdate(ctx, input, target, lock, options)
   );
 }
 async function executeNodeDelete(ctx, kind, id, backend) {
+  const gate = await backend.getNode(ctx.graphId, kind, id);
+  if (!gate || gate.deleted_at) return;
   const opContext = ctx.createOperationContext("delete", "node", kind, id);
-  return ctx.withOperationHooks(opContext, async () => {
-    const registration = getNodeRegistration(ctx.graph, kind);
-    const preflight = await backend.getNode(ctx.graphId, kind, id);
-    if (!preflight || preflight.deleted_at) return;
-    const softDelete = async (target) => {
-      const existing = await target.getNode(ctx.graphId, kind, id);
-      if (!existing || existing.deleted_at) return;
-      const existingProps = JSON.parse(existing.props);
-      await enforceDeleteBehavior(ctx, kind, id, "soft", target, registration);
-      await target.deleteNode({ graphId: ctx.graphId, kind, id });
-      await deleteUniquenessEntries(
-        createUniquenessContext(ctx.graphId, ctx.registry, target),
-        kind,
-        existingProps,
-        registration.unique ?? []
-      );
-      const nodeKind = registration.type;
-      await deleteNodeEmbeddings(
-        createEmbeddingSyncContext(ctx.graphId, kind, id, target),
-        nodeKind.schema
-      );
-      await deleteNodeFulltext(
-        createFulltextSyncContext(ctx.graphId, kind, id, target),
-        nodeKind.schema
+  return runHookedWriteOperation(
+    ctx,
+    opContext,
+    backend,
+    async (target, lock) => {
+      const registration = getNodeRegistration(ctx.graph, kind);
+      const preflight = await target.getNode(ctx.graphId, kind, id);
+      if (!preflight || !isLiveNodeRow(preflight)) return;
+      await applyNodeSoftDelete(
+        createNodeWriteContext(ctx.graphId, ctx.registry, lock),
+        {
+          existing: preflight,
+          schema: registration.type.schema,
+          uniqueConstraints: registration.unique ?? [],
+          onDelete: registration.onDelete
+        },
+        target
       );
-    };
-    await runOptionallyInTransaction(backend, (target) => softDelete(target));
-  });
+    }
+  );
 }
 async function executeNodeHardDelete(ctx, kind, id, backend) {
+  const gate = await backend.getNode(ctx.graphId, kind, id);
+  if (!gate) return;
   const opContext = ctx.createOperationContext("delete", "node", kind, id);
-  return ctx.withOperationHooks(opContext, async () => {
-    const registration = getNodeRegistration(ctx.graph, kind);
-    const preflight = await backend.getNode(ctx.graphId, kind, id);
-    if (!preflight) return;
-    const hardDelete = async (target) => {
-      const existing = await target.getNode(ctx.graphId, kind, id);
-      if (!existing) return;
-      await enforceDeleteBehavior(ctx, kind, id, "hard", target, registration);
-      await target.hardDeleteNode({ graphId: ctx.graphId, kind, id });
-      await deleteNodeEmbeddings(
-        createEmbeddingSyncContext(ctx.graphId, kind, id, target),
-        registration.type.schema
+  return runHookedWriteOperation(
+    ctx,
+    opContext,
+    backend,
+    async (target, lock) => {
+      const registration = getNodeRegistration(ctx.graph, kind);
+      const preflight = await target.getNode(ctx.graphId, kind, id);
+      if (!preflight) return;
+      await applyNodeHardDelete(
+        createNodeWriteContext(ctx.graphId, ctx.registry, lock),
+        {
+          kind,
+          id,
+          schema: registration.type.schema,
+          onDelete: registration.onDelete
+        },
+        target
       );
-    };
-    await runOptionallyInTransaction(backend, (target) => hardDelete(target));
-  });
+    }
+  );
 }
 async function executeNodeGetOrCreateByConstraint(ctx, kind, constraintName, props, backend, options) {
   const ifExists = options?.ifExists ?? "return";
@@ -14689,51 +12936,59 @@ async function executeNodeGetOrCreateByConstraint(ctx, kind, constraintName, pro
     constraint.scope,
     ctx.registry
   );
-  const existingUniqueRow = await findUniqueRowAcrossKinds(
-    backend,
-    ctx.graphId,
-    constraint.name,
-    key,
-    kindsToCheck,
-    true
-  );
-  if (existingUniqueRow === void 0) {
-    const node = await executeNodeCreate(
-      ctx,
-      { kind, props: validatedProps },
-      backend
+  async function attempt() {
+    const existingUniqueRow = await findUniqueRowAcrossKinds(
+      backend,
+      ctx.graphId,
+      constraint.name,
+      key,
+      kindsToCheck,
+      true
     );
-    return { node, action: "created" };
-  }
-  const existingRow = await backend.getNode(
-    ctx.graphId,
-    existingUniqueRow.concrete_kind,
-    existingUniqueRow.node_id
-  );
-  if (existingRow === void 0) {
-    const node = await executeNodeCreate(
-      ctx,
-      { kind, props: validatedProps },
-      backend
+    if (existingUniqueRow === void 0) {
+      const node = await executeNodeCreate(
+        ctx,
+        { kind, props: validatedProps },
+        backend
+      );
+      return { node, action: "created" };
+    }
+    const existingRow = await backend.getNode(
+      ctx.graphId,
+      existingUniqueRow.concrete_kind,
+      existingUniqueRow.node_id
     );
-    return { node, action: "created" };
+    if (existingRow === void 0) {
+      const node = await executeNodeCreate(
+        ctx,
+        { kind, props: validatedProps },
+        backend
+      );
+      return { node, action: "created" };
+    }
+    const isSoftDeleted = existingRow.deleted_at !== void 0;
+    if (isSoftDeleted || ifExists === "update") {
+      const concreteKind = existingUniqueRow.concrete_kind;
+      const node = await executeNodeUpsertUpdate(
+        ctx,
+        {
+          kind: concreteKind,
+          id: existingRow.id,
+          props: validatedProps
+        },
+        backend,
+        { clearDeleted: isSoftDeleted }
+      );
+      return { node, action: isSoftDeleted ? "resurrected" : "updated" };
+    }
+    return { node: rowToNode(existingRow), action: "found" };
   }
-  const isSoftDeleted = existingRow.deleted_at !== void 0;
-  if (isSoftDeleted || ifExists === "update") {
-    const concreteKind = existingUniqueRow.concrete_kind;
-    const node = await executeNodeUpsertUpdate(
-      ctx,
-      {
-        kind: concreteKind,
-        id: existingRow.id,
-        props: validatedProps
-      },
-      backend,
-      { clearDeleted: isSoftDeleted }
-    );
-    return { node, action: isSoftDeleted ? "resurrected" : "updated" };
+  try {
+    return await attempt();
+  } catch (error) {
+    if (!(error instanceof UniquenessError)) throw error;
+    return attempt();
   }
-  return { node: rowToNode(existingRow), action: "found" };
 }
 async function executeNodeFindByConstraint(ctx, kind, constraintName, props, backend) {
   const registration = getNodeRegistration(ctx.graph, kind);
@@ -15347,6 +13602,9 @@ var CAUGHT_UP_VERB_DETAILS = {
 function rowMapperConfigFor(backend) {
   return backend.dialect === "postgres" ? POSTGRES_ROW_MAPPER_CONFIG : SQLITE_ROW_MAPPER_CONFIG;
 }
+function asError(error) {
+  return error instanceof Error ? error : new Error(String(error));
+}
 var Store = class _Store {
   #graph;
   /**
@@ -15660,7 +13918,9 @@ var Store = class _Store {
    * Node operations bound to this store instance.
    */
   get #nodeOperations() {
-    const ctx = this.#createNodeOperationContext();
+    return this.#buildNodeOperations(this.#createNodeOperationContext());
+  }
+  #buildNodeOperations(ctx) {
     return {
       defaultTemporalMode: this.#graph.defaults.temporalMode,
       rowToNode: (row) => rowToNode(row),
@@ -15716,7 +13976,9 @@ var Store = class _Store {
    * Edge operations bound to this store instance.
    */
   get #edgeOperations() {
-    const ctx = this.#createEdgeOperationContext();
+    return this.#buildEdgeOperations(this.#createEdgeOperationContext());
+  }
+  #buildEdgeOperations(ctx) {
     return {
       defaultTemporalMode: this.#graph.defaults.temporalMode,
       rowToEdge: (row) => rowToEdge(row),
@@ -16128,13 +14390,36 @@ var Store = class _Store {
       return invoke({
         nodes: this.nodes,
         edges: this.edges,
-        backend: this.#backend
+        backend: this.#backend,
+        getNodeCollection: (kind) => this.getNodeCollection(kind),
+        // No transaction, no deferral: operations apply as they happen, so
+        // their hooks fire immediately.
+        runNodeOperationHooks: (operation, kind, id, hookedFunction) => this.#withOperationHooks(
+          this.#createOperationContext(operation, "node", kind, id),
+          hookedFunction
+        )
       });
     }
-    return this.#backend.transaction(
-      async (txBackend, sql22) => invoke(this.#buildTransactionContext(txBackend, sql22)),
-      options
-    );
+    const pending = [];
+    const runHooks = this.#createBufferedHookRunner(pending);
+    try {
+      const result = await this.#backend.transaction(
+        async (txBackend, sql17) => invoke(this.#buildTransactionContext(txBackend, sql17, runHooks)),
+        options
+      );
+      for (const outcome of pending) {
+        this.#hooks.onOperationEnd?.(outcome.ctx, {
+          durationMs: outcome.durationMs
+        });
+      }
+      return result;
+    } catch (error) {
+      const failure = asError(error);
+      for (const outcome of pending) {
+        this.#hooks.onError?.(outcome.ctx, failure);
+      }
+      throw error;
+    }
   }
   /**
    * Adopts a caller-owned, already-open Drizzle transaction so the graph
@@ -16234,6 +14519,9 @@ var Store = class _Store {
       backend: txBackend,
       flush: () => Promise.resolve()
     };
+    if (this.#captureEnabled) {
+      await lockRecordedGraphWrite(scope.backend, this.graphId);
+    }
     const invoke = fn;
     const result = await invoke(
       this.#buildTransactionContext(scope.backend, externalTx)
@@ -16251,15 +14539,16 @@ var Store = class _Store {
    * (#140); when history capture is enabled it is replaced with a fail-loud
    * guard because raw graph writes would bypass recorded-time capture.
    */
-  #buildTransactionContext(txBackend, sql22) {
+  #buildTransactionContext(txBackend, sql17, runHooks = this.#immediateHookRunner()) {
     const txNodeOperations = {
-      ...this.#nodeOperations,
+      ...this.#buildNodeOperations(this.#createNodeOperationContext(runHooks)),
       createQuery: () => this.#createQueryForBackend(txBackend)
     };
     const txEdgeOperations = {
-      ...this.#edgeOperations,
+      ...this.#buildEdgeOperations(this.#createEdgeOperationContext(runHooks)),
       createQuery: () => this.#createQueryForBackend(txBackend)
     };
+    const runNodeOperationHooks = (operation, kind, id, fn) => runHooks(this.#createOperationContext(operation, "node", kind, id), fn);
     const nodes = createNodeCollectionsProxy(
       this.#graph,
       this.graphId,
@@ -16274,9 +14563,28 @@ var Store = class _Store {
       txBackend,
       txEdgeOperations
     );
-    if (sql22 === void 0) return { nodes, edges, backend: txBackend };
-    const exposedSql = this.#captureEnabled ? createHistoryUnsafeSqlRef() : sql22;
-    return { nodes, edges, sql: exposedSql, backend: txBackend };
+    const getNodeCollection = (kind) => {
+      if (!Object.hasOwn(this.#graph.nodes, kind)) return void 0;
+      return nodes[kind];
+    };
+    if (sql17 === void 0) {
+      return {
+        nodes,
+        edges,
+        backend: txBackend,
+        getNodeCollection,
+        runNodeOperationHooks
+      };
+    }
+    const exposedSql = this.#captureEnabled ? createHistoryUnsafeSqlRef() : sql17;
+    return {
+      nodes,
+      edges,
+      sql: exposedSql,
+      backend: txBackend,
+      getNodeCollection,
+      runNodeOperationHooks
+    };
   }
   // === Graph Lifecycle ===
   /**
@@ -16937,23 +15245,27 @@ var Store = class _Store {
     await this.#backend.close();
   }
   // === Internal: Operation Contexts ===
-  #createNodeOperationContext() {
+  #immediateHookRunner() {
+    return (ctx, fn) => this.#withOperationHooks(ctx, fn);
+  }
+  #createNodeOperationContext(runHooks = this.#immediateHookRunner()) {
     return {
       graph: this.#graph,
       graphId: this.graphId,
       historyEnabled: this.#captureEnabled,
       registry: this.#registry,
       createOperationContext: (operation, entity, kind, id) => this.#createOperationContext(operation, entity, kind, id),
-      withOperationHooks: (ctx, fn) => this.#withOperationHooks(ctx, fn)
+      withOperationHooks: runHooks
     };
   }
-  #createEdgeOperationContext() {
+  #createEdgeOperationContext(runHooks = this.#immediateHookRunner()) {
     return {
       graph: this.#graph,
       graphId: this.graphId,
+      historyEnabled: this.#captureEnabled,
       registry: this.#registry,
       createOperationContext: (operation, entity, kind, id) => this.#createOperationContext(operation, entity, kind, id),
-      withOperationHooks: (ctx, fn) => this.#withOperationHooks(ctx, fn)
+      withOperationHooks: runHooks
     };
   }
   // === Internal: Hook Helpers ===
@@ -16983,13 +15295,34 @@ var Store = class _Store {
       });
       return result;
     } catch (error) {
-      this.#hooks.onError?.(
-        ctx,
-        error instanceof Error ? error : new Error(String(error))
-      );
+      this.#hooks.onError?.(ctx, asError(error));
       throw error;
     }
   }
+  /**
+   * A hook runner for operations that execute INSIDE an explicit
+   * `store.transaction`: `onOperationStart` (and a failed operation's
+   * `onError`) fire immediately — the attempt and the failure are real when
+   * they happen — but a successful operation's `onOperationEnd` is only
+   * BUFFERED. `transaction()` flushes the buffer after the backend COMMIT
+   * succeeds, or converts every buffered success into `onError` when the
+   * transaction fails, so `onOperationEnd` always means durably committed
+   * even for operations nested in a caller-controlled transaction.
+   */
+  #createBufferedHookRunner(pending) {
+    return async (ctx, fn) => {
+      this.#hooks.onOperationStart?.(ctx);
+      const startTime = Date.now();
+      try {
+        const result = await fn();
+        pending.push({ ctx, durationMs: Date.now() - startTime });
+        return result;
+      } catch (error) {
+        this.#hooks.onError?.(ctx, asError(error));
+        throw error;
+      }
+    };
+  }
   // === Internal: Temporal Filtering ===
   #temporalRowMatcher(options) {
     const { temporalMode, asOf } = resolveTemporalReadParams(
@@ -17100,6 +15433,6 @@ async function createVerifiedStore(graph, backend, options) {
   return [store, result];
 }
 
-export { DEFAULT_SQL_SCHEMA, ExecutableAggregateQuery, ExecutableQuery, MAX_EXPLICIT_RECURSIVE_DEPTH, MAX_RECURSIVE_DEPTH, PreparedQuery, QueryBuilder, RecordedStoreView, StoreSearch, StoreView, UnionableQuery, asCompiledRowsSql, asCompiledSelectSql, asCompiledStatementSql, asRecordedInstant, avg, composeFragments, computeUniqueKey, count, countDistinct, countDistinctEdges, countEdges, createFragment, createQueryBuilder, createSqlSchema, createStore, createStoreWithSchema, createVerifiedStore, defineSubgraphProject, field, generateId, having, havingEq, havingGt, havingGte, havingLt, havingLte, limitFragment, max, min, offsetFragment, orderByFragment, recordedRelation, sum };
-//# sourceMappingURL=chunk-WLP6TKFB.js.map
-//# sourceMappingURL=chunk-WLP6TKFB.js.map
+export { ExecutableAggregateQuery, ExecutableQuery, MAX_EXPLICIT_RECURSIVE_DEPTH, MAX_RECURSIVE_DEPTH, PreparedQuery, QueryBuilder, RecordedStoreView, StoreSearch, StoreView, UnionableQuery, avg, composeFragments, count, countDistinct, countDistinctEdges, countEdges, createFragment, createQueryBuilder, createStore, createStoreWithSchema, createVerifiedStore, defineSubgraphProject, field, having, havingEq, havingGt, havingGte, havingLt, havingLte, limitFragment, max, min, offsetFragment, orderByFragment, sum };
+//# sourceMappingURL=chunk-WLRIWYHQ.js.map
+//# sourceMappingURL=chunk-WLRIWYHQ.js.map