@nicia-ai/typegraph 0.33.0 → 0.35.0

package/dist/chunk-CZQ3FO2Q.js

@@ -0,0 +1,2320 @@
+import { asCompiledRowsSql, asCompiledStatementSql } from './chunk-UT3S4SEN.js';
+import { createBackendOverlay, isPresent, rowPropsToObject, groupBy, chunk, sqlValueList, rowPropsToJsonText } from './chunk-JBTOYDMN.js';
+import { validateCanonicalIsoDate, withRecordedRelationsPrecondition, nowIso } from './chunk-I7ZUZKFD.js';
+import { MAX_PG_IDENTIFIER_LENGTH, sqlNull } from './chunk-OHMP6N2J.js';
+import { resolveEmbeddingFields, getSearchableFields, DEFAULT_SEARCHABLE_LANGUAGE } from './chunk-KBGQIPRQ.js';
+import { ConfigurationError, ValidationError, CardinalityError, EndpointError, DisjointError, UniquenessError, RestrictedDeleteError } from './chunk-MP2JQKSG.js';
+import { sql } 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 }
+  };
+}
+var SqlSchemaDescriptor = class {
+  // Private field gives SqlSchema nominal identity; runtime checks use instanceof.
+  #brand = true;
+  tables;
+  nodesTable;
+  edgesTable;
+  recordedNodesTable;
+  recordedEdgesTable;
+  recordedClockTable;
+  revisionOriginsTable;
+  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.revisionOriginsTable = fields.revisionOriginsTable;
+    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",
+  revisionOrigins: "typegraph_revision_origins",
+  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,
+    revisionOrigins: names.revisionOrigins ?? DEFAULT_TABLE_NAMES.revisionOrigins,
+    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 quoteIdentifier(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.revisionOrigins, "revisionOrigins");
+  validateTableName(tables.fulltext, "fulltext");
+  validateTableName(tables.uniques, "uniques");
+  return freezeSqlSchema({
+    tables: Object.freeze(tables),
+    nodesTable: sql.raw(quoteIdentifier(tables.nodes)),
+    edgesTable: sql.raw(quoteIdentifier(tables.edges)),
+    recordedNodesTable: sql.raw(quoteIdentifier(tables.recordedNodes)),
+    recordedEdgesTable: sql.raw(quoteIdentifier(tables.recordedEdges)),
+    recordedClockTable: sql.raw(quoteIdentifier(tables.recordedClock)),
+    revisionOriginsTable: sql.raw(quoteIdentifier(tables.revisionOrigins)),
+    fulltextTable: sql.raw(quoteIdentifier(tables.fulltext))
+  });
+}
+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,
+    revisionOriginsTable: schema.revisionOriginsTable,
+    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";
+function generateId() {
+  return nanoid();
+}
+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);
+}
+function requireCaptureStatements(target) {
+  if (target.executeStatement === 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."
+      }
+    );
+  }
+}
+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 revisionTrackingUnsafeRawWriteError(surface) {
+  return new ConfigurationError(
+    `${surface} is not available when revision tracking is enabled because raw SQL writes bypass the revision anchor.`,
+    { code: "REVISION_TRACKING_RAW_SQL_DISABLED" },
+    {
+      suggestion: "Run graph writes through store.nodes/store.edges (or tx.nodes/tx.edges inside a transaction), so TypeGraph can advance the revision anchor."
+    }
+  );
+}
+function failHistoryUnsafeSqlRef() {
+  throw historyUnsafeRawWriteError("tx.sql");
+}
+function failRevisionTrackingUnsafeSqlRef() {
+  throw revisionTrackingUnsafeRawWriteError("tx.sql");
+}
+function createHistoryUnsafeSqlRef() {
+  return createUnsafeSqlRef(failHistoryUnsafeSqlRef);
+}
+function createRevisionTrackingUnsafeSqlRef() {
+  return createUnsafeSqlRef(failRevisionTrackingUnsafeSqlRef);
+}
+function createUnsafeSqlRef(fail) {
+  return new Proxy(
+    function unsafeSqlRef() {
+      return fail();
+    },
+    {
+      get() {
+        return fail();
+      },
+      apply() {
+        return fail();
+      },
+      set() {
+        return fail();
+      },
+      defineProperty() {
+        return fail();
+      },
+      deleteProperty() {
+        return fail();
+      },
+      // Enumeration / inspection traps too, so spreading (`{...tx.sql}`),
+      // `Object.keys`, `in`, and prototype reads also fail loudly rather than
+      // silently yielding an empty object that reads as "no raw handle".
+      has() {
+        return fail();
+      },
+      ownKeys() {
+        return fail();
+      },
+      getOwnPropertyDescriptor() {
+        return fail();
+      },
+      getPrototypeOf() {
+        return fail();
+      }
+    }
+  );
+}
+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."
+      }
+    );
+  }
+}
+function assertRevisionTrackableBackend(backend) {
+  if (!backend.capabilities.transactions) {
+    throw new ConfigurationError(
+      "revisionTracking: true requires a backend with transaction support.",
+      { dialect: backend.dialect },
+      {
+        suggestion: "Use a transactional SQLite/PostgreSQL backend or leave revision tracking disabled."
+      }
+    );
+  }
+  if (backend.executeStatement === void 0) {
+    throw new ConfigurationError(
+      "revisionTracking: true requires a backend that supports executeStatement.",
+      { dialect: backend.dialect },
+      {
+        suggestion: "Use a built-in SQLite/PostgreSQL backend, or implement executeStatement so TypeGraph can advance the revision clock."
+      }
+    );
+  }
+  if (backend.tableNames === void 0) {
+    throw new ConfigurationError(
+      "revisionTracking: true requires a backend that exposes tableNames.",
+      { dialect: backend.dialect },
+      {
+        suggestion: "Use a built-in SQLite/PostgreSQL backend, or set tableNames so TypeGraph can address the revision clock relation."
+      }
+    );
+  }
+  if (backend.ensureRevisionOriginsTable === void 0) {
+    throw new ConfigurationError(
+      "revisionTracking: true requires a backend that can bootstrap revision origins.",
+      { dialect: backend.dialect },
+      {
+        suggestion: "Use a built-in SQLite/PostgreSQL backend, or implement ensureRevisionOriginsTable so TypeGraph can durably namespace revision anchors."
+      }
+    );
+  }
+}
+
+// src/store/recorded-capture/clock.ts
+var RECORDED_MIN = "1970-01-01T00:00:00.000Z";
+var RECORDED_MAX_TIME = new Date(RECORDED_MAX).getTime();
+var RECORDED_CLOCK_ADVISORY_LOCK_NAMESPACE = "typegraph:recorded-clock";
+var RECORDED_GRAPH_WRITE_ADVISORY_LOCK_NAMESPACE = "typegraph:recorded-graph-write";
+function graphAdvisoryLockSql(namespace, graphId) {
+  return sql`
+    SELECT pg_advisory_xact_lock(
+      hashtext(${namespace}),
+      hashtext(${graphId})
+    )
+  `;
+}
+function recordedClockAdvisoryLockSql(graphId) {
+  return graphAdvisoryLockSql(RECORDED_CLOCK_ADVISORY_LOCK_NAMESPACE, graphId);
+}
+function recordedGraphWriteAdvisoryLockSql(graphId) {
+  return graphAdvisoryLockSql(
+    RECORDED_GRAPH_WRITE_ADVISORY_LOCK_NAMESPACE,
+    graphId
+  );
+}
+var GRAPH_WRITE_LOCK_EVIDENCE = Object.freeze({});
+function graphWriteLockEvidence() {
+  return GRAPH_WRITE_LOCK_EVIDENCE;
+}
+function uncapturedGraphWriteLock() {
+  return graphWriteLockEvidence();
+}
+function createRecordedGraphLockMemo() {
+  return /* @__PURE__ */ new Map();
+}
+var recordedGraphLockMemos = /* @__PURE__ */ new WeakMap();
+function registerRecordedGraphLockMemo(backend, memo) {
+  recordedGraphLockMemos.set(backend, memo);
+}
+async function acquireRecordedGraphWriteLock(target, graphId) {
+  await target.execute(
+    asCompiledRowsSql(recordedGraphWriteAdvisoryLockSql(graphId))
+  );
+}
+async function lockRecordedGraphWrite(target, graphId, memo) {
+  if (target.dialect !== "postgres") return graphWriteLockEvidence();
+  const effectiveMemo = memo ?? recordedGraphLockMemos.get(target);
+  if (effectiveMemo === void 0) {
+    await acquireRecordedGraphWriteLock(target, graphId);
+    return graphWriteLockEvidence();
+  }
+  let pending = effectiveMemo.get(graphId);
+  if (pending === void 0) {
+    pending = acquireRecordedGraphWriteLock(target, graphId).catch(
+      (error) => {
+        effectiveMemo.delete(graphId);
+        throw error;
+      }
+    );
+    effectiveMemo.set(graphId, pending);
+  }
+  await pending;
+  return graphWriteLockEvidence();
+}
+function failInvalidClockTimestamp(value) {
+  throw new ConfigurationError(
+    "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 readRevisionOrigin(target, schema, graphId) {
+  const rows = await target.execute(
+    asCompiledRowsSql(sql`
+      SELECT origin
+      FROM ${schema.revisionOriginsTable}
+      WHERE graph_id = ${graphId}
+    `)
+  );
+  const first = rows[0];
+  if (first === void 0) return void 0;
+  if (typeof first.origin !== "string" || first.origin.length === 0) {
+    throw new ConfigurationError(
+      "Revision origin row contained an invalid origin",
+      { graphId, origin: first.origin }
+    );
+  }
+  return first.origin;
+}
+async function ensureRevisionOrigin(target, schema, graphId) {
+  const ensureTable = target.ensureRevisionOriginsTable;
+  if (ensureTable === void 0) {
+    throw new ConfigurationError(
+      "Revision tracking requires a backend that can bootstrap revision origins.",
+      { dialect: target.dialect },
+      {
+        suggestion: "Use a built-in SQLite/PostgreSQL backend, or implement ensureRevisionOriginsTable on the custom backend."
+      }
+    );
+  }
+  await ensureTable();
+  const existing = await readRevisionOrigin(target, schema, graphId);
+  if (existing !== void 0) return existing;
+  await executeStatement(
+    target,
+    sql`
+      INSERT INTO ${schema.revisionOriginsTable} (graph_id, origin)
+      VALUES (${graphId}, ${generateId()})
+      ON CONFLICT (graph_id) DO NOTHING
+    `
+  );
+  const origin = await readRevisionOrigin(target, schema, graphId);
+  if (origin !== void 0) return origin;
+  throw new ConfigurationError(
+    "Revision origin was not persisted after initialization.",
+    { graphId, dialect: target.dialect }
+  );
+}
+async function writeRecordedClock(target, schema, graphId, recordedAt) {
+  await executeStatement(
+    target,
+    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, previousRevision) {
+  await lockRecordedClock(target, schema, graphId, ownsWriteLock);
+  const previous = previousRevision ?? 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;
+}
+async function advanceRevisionClock(target, schema, graphId, ownsWriteLock, previousRevision) {
+  return allocateRecordedCommit(
+    target,
+    schema,
+    graphId,
+    ownsWriteLock,
+    previousRevision
+  );
+}
+
+// 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;
+}
+
+// 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/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)
+  });
+}
+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`${rowPropsToJsonText(row.props)}`,
+    valid_from: (row) => sql`${sqlNull(row.valid_from)}`,
+    valid_to: (row) => sql`${sqlNull(row.valid_to)}`,
+    created_at: (row) => sql`${row.created_at}`,
+    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
+var RECORDED_FLUSH_OBSERVER = /* @__PURE__ */ Symbol("typegraph.recordedFlushObserver");
+function readRecordedFlushObserver(options) {
+  return options?.[RECORDED_FLUSH_OBSERVER];
+}
+function stripRecordedFlushObserver(options) {
+  if (options === void 0) return void 0;
+  const { [RECORDED_FLUSH_OBSERVER]: _observer, ...backendOptions } = options;
+  return backendOptions;
+}
+function withRecordedFlushObserver(options, observer) {
+  return {
+    ...stripRecordedFlushObserver(options),
+    [RECORDED_FLUSH_OBSERVER]: observer
+  };
+}
+function nodeIdentityKey(graphId, kind, id) {
+  return `${graphId}\0${kind}\0${id}`;
+}
+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 /* @__PURE__ */ new Map();
+      const recordedByGraph = /* @__PURE__ */ new Map();
+      const byGraph = groupBy(touched.values(), (entity) => entity.graphId);
+      for (const [graphId, entities] of byGraph) {
+        const recordedCommit = await allocateRecordedCommit(
+          target,
+          schema,
+          graphId,
+          ownsWriteLock
+        );
+        recordedByGraph.set(graphId, recordedCommit);
+        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();
+      return recordedByGraph;
+    }
+  };
+}
+function createRecordedTransactionBackend(target, session, schema) {
+  const nodeDispatch = nodeInsertDispatch(target);
+  const edgeDispatch = edgeInsertDispatch(target);
+  const graphLocks = createRecordedGraphLockMemo();
+  async function lockGraph(graphId) {
+    await lockRecordedGraphWrite(target, graphId, graphLocks);
+  }
+  async function lockGraphs(params) {
+    const graphIds = [
+      ...new Set(params.map((parameter) => parameter.graphId))
+    ].toSorted();
+    for (const graphId of graphIds) {
+      await lockRecordedGraphWrite(target, graphId, graphLocks);
+    }
+  }
+  const overlay = createBackendOverlay(target, {
+    ...rawWriteGuards(target, "tx.backend"),
+    async insertNode(params) {
+      await lockGraph(params.graphId);
+      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 lockGraph(params.graphId);
+        await runInsertNoReturn(nodeDispatch, params);
+        session.touchNode(params.graphId, params.kind, params.id);
+      }
+    },
+    ...target.insertNodesBatch === void 0 ? {} : {
+      async insertNodesBatch(params) {
+        await lockGraphs(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) {
+        await lockGraphs(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) {
+      await lockGraph(params.graphId);
+      const row = await target.updateNode(params);
+      session.touchNode(params.graphId, params.kind, params.id, row);
+      return row;
+    },
+    async deleteNode(params) {
+      await lockGraph(params.graphId);
+      await target.deleteNode(params);
+      session.touchNode(params.graphId, params.kind, params.id);
+    },
+    async hardDeleteNode(params) {
+      await lockGraph(params.graphId);
+      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) {
+      await lockGraph(params.graphId);
+      const row = await target.insertEdge(params);
+      session.touchEdge(params.graphId, params.id, row);
+      return row;
+    },
+    ...target.insertEdgeNoReturn === void 0 ? {} : {
+      async insertEdgeNoReturn(params) {
+        await lockGraph(params.graphId);
+        await runInsertNoReturn(edgeDispatch, params);
+        session.touchEdge(params.graphId, params.id);
+      }
+    },
+    ...target.insertEdgesBatch === void 0 ? {} : {
+      async insertEdgesBatch(params) {
+        await lockGraphs(params);
+        await runInsertBatch(edgeDispatch, params);
+        for (const edge of params) {
+          session.touchEdge(edge.graphId, edge.id);
+        }
+      }
+    },
+    ...target.insertEdgesBatchReturning === void 0 ? {} : {
+      async insertEdgesBatchReturning(params) {
+        await lockGraphs(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) {
+      await lockGraph(params.graphId);
+      const row = await target.updateEdge(params);
+      session.touchEdge(params.graphId, params.id, row);
+      return row;
+    },
+    async deleteEdge(params) {
+      await lockGraph(params.graphId);
+      await target.deleteEdge(params);
+      session.touchEdge(params.graphId, params.id);
+    },
+    async hardDeleteEdge(params) {
+      await lockGraph(params.graphId);
+      await target.hardDeleteEdge(params);
+      session.touchEdge(params.graphId, params.id);
+    },
+    ...target.deleteEdgesBatch === void 0 ? {} : {
+      async deleteEdgesBatch(params) {
+        await lockGraph(params.graphId);
+        await target.deleteEdgesBatch(params);
+        for (const id of params.ids) {
+          session.touchEdge(params.graphId, id);
+        }
+      }
+    },
+    ...target.hardDeleteEdgesBatch === void 0 ? {} : {
+      async hardDeleteEdgesBatch(params) {
+        await lockGraph(params.graphId);
+        await target.hardDeleteEdgesBatch(params);
+        for (const id of params.ids) {
+          session.touchEdge(params.graphId, id);
+        }
+      }
+    }
+  });
+  registerRecordedGraphLockMemo(overlay, graphLocks);
+  return overlay;
+}
+function createRecordedTransactionScope(target, schema, ownsWriteLock = false) {
+  requireCaptureStatements(target);
+  const session = createRecordedCaptureSession();
+  const resolvedSchema = schema ?? requireRecordedSchema(target);
+  return {
+    backend: createRecordedTransactionBackend(target, session, resolvedSchema),
+    async flush() {
+      return 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));
+    },
+    ...backend.deleteEdgesBatch === void 0 ? {} : {
+      async deleteEdgesBatch(params) {
+        await capture((target) => target.deleteEdgesBatch(params));
+      }
+    },
+    ...backend.hardDeleteEdgesBatch === void 0 ? {} : {
+      async hardDeleteEdgesBatch(params) {
+        await capture((target) => target.hardDeleteEdgesBatch(params));
+      }
+    },
+    async transaction(fn, options) {
+      const observer = readRecordedFlushObserver(options);
+      const backendOptions = stripRecordedFlushObserver(options);
+      assertRequestedRecordedIsolation(backend, backendOptions);
+      return backend.transaction(async (target) => {
+        await assertRecordedCaptureTransactionIsolation(target);
+        const scope = createRecordedTransactionScope(target, schema, true);
+        const result = await fn(scope.backend, createHistoryUnsafeSqlRef());
+        const instants = await scope.flush();
+        observer?.(instants);
+        return result;
+      }, backendOptions);
+    },
+    ...backend.adoptTransaction === void 0 ? {} : {
+      adoptTransaction(externalTx) {
+        throw recordedCaptureRequiresCallbackTransactionError({
+          externalTxType: typeof externalTx
+        });
+      }
+    }
+  });
+}
+
+// src/store/embedding-sync.ts
+var embeddingFieldsCache = /* @__PURE__ */ new WeakMap();
+function getEmbeddingFields(schema) {
+  const cached = embeddingFieldsCache.get(schema);
+  if (cached) return cached;
+  const fields = resolveEmbeddingFields(schema);
+  embeddingFieldsCache.set(schema, fields);
+  return fields;
+}
+async function syncEmbeddings(ctx, schema, props) {
+  const { backend } = ctx;
+  if (!backend.upsertEmbedding || !backend.deleteEmbedding) {
+    return;
+  }
+  const embeddingFields = getEmbeddingFields(schema);
+  if (embeddingFields.length === 0) {
+    return;
+  }
+  for (const field of embeddingFields) {
+    const value = props[field.fieldPath];
+    if (isValidEmbeddingValue(value)) {
+      await backend.upsertEmbedding({
+        graphId: ctx.graphId,
+        nodeKind: ctx.nodeKind,
+        nodeId: ctx.nodeId,
+        fieldPath: field.fieldPath,
+        embedding: value,
+        dimensions: field.dimensions,
+        metric: field.metric,
+        indexType: field.indexType
+      });
+    } else if (value === void 0) {
+      await backend.deleteEmbedding({
+        graphId: ctx.graphId,
+        nodeKind: ctx.nodeKind,
+        nodeId: ctx.nodeId,
+        fieldPath: field.fieldPath,
+        dimensions: field.dimensions,
+        metric: field.metric,
+        indexType: field.indexType
+      });
+    }
+  }
+}
+async function syncEmbeddingsBatchForKind(args, schema, items) {
+  const { graphId, nodeKind, backend } = args;
+  if (!backend.upsertEmbedding || !backend.deleteEmbedding) {
+    return;
+  }
+  const embeddingFields = getEmbeddingFields(schema);
+  if (embeddingFields.length === 0) {
+    return;
+  }
+  for (const field of embeddingFields) {
+    const rows = [];
+    const deletionIds = [];
+    for (const item of items) {
+      const value = item.props[field.fieldPath];
+      if (isValidEmbeddingValue(value)) {
+        rows.push({ nodeId: item.nodeId, embedding: value });
+      } else if (value === void 0) {
+        deletionIds.push(item.nodeId);
+      }
+    }
+    if (rows.length > 0) {
+      if (backend.upsertEmbeddingBatch === void 0) {
+        for (const row of rows) {
+          await backend.upsertEmbedding({
+            graphId,
+            nodeKind,
+            nodeId: row.nodeId,
+            fieldPath: field.fieldPath,
+            embedding: row.embedding,
+            dimensions: field.dimensions,
+            metric: field.metric,
+            indexType: field.indexType
+          });
+        }
+      } else {
+        await backend.upsertEmbeddingBatch({
+          graphId,
+          nodeKind,
+          fieldPath: field.fieldPath,
+          dimensions: field.dimensions,
+          metric: field.metric,
+          indexType: field.indexType,
+          rows
+        });
+      }
+    }
+    for (const nodeId of deletionIds) {
+      await backend.deleteEmbedding({
+        graphId,
+        nodeKind,
+        nodeId,
+        fieldPath: field.fieldPath,
+        dimensions: field.dimensions,
+        metric: field.metric,
+        indexType: field.indexType
+      });
+    }
+  }
+}
+async function deleteNodeEmbeddings(ctx, schema) {
+  const { backend } = ctx;
+  if (!backend.deleteEmbedding) {
+    return;
+  }
+  const embeddingFields = getEmbeddingFields(schema);
+  if (embeddingFields.length === 0) {
+    return;
+  }
+  for (const field of embeddingFields) {
+    await backend.deleteEmbedding({
+      graphId: ctx.graphId,
+      nodeKind: ctx.nodeKind,
+      nodeId: ctx.nodeId,
+      fieldPath: field.fieldPath,
+      dimensions: field.dimensions,
+      metric: field.metric,
+      indexType: field.indexType
+    });
+  }
+}
+function isValidEmbeddingValue(value) {
+  if (!Array.isArray(value)) {
+    return false;
+  }
+  return value.every((n) => typeof n === "number" && Number.isFinite(n));
+}
+
+// src/store/fulltext-sync.ts
+var FIELD_SEPARATOR = "\n";
+function resolveCombinedLanguage(fields) {
+  return fields[0]?.metadata.language ?? DEFAULT_SEARCHABLE_LANGUAGE;
+}
+function computeFulltextContent(schema, props) {
+  const searchableFields = getSearchableFields(schema);
+  if (searchableFields.length === 0) return void 0;
+  const parts = [];
+  for (const field of searchableFields) {
+    const value = props[field.fieldPath];
+    if (typeof value === "string" && value.length > 0) {
+      parts.push(value);
+    }
+  }
+  if (parts.length === 0) return void 0;
+  return {
+    content: parts.join(FIELD_SEPARATOR),
+    language: resolveCombinedLanguage(searchableFields)
+  };
+}
+async function syncFulltext(ctx, schema, props) {
+  const { backend } = ctx;
+  if (!backend.upsertFulltext || !backend.deleteFulltext) {
+    return;
+  }
+  const computed = computeFulltextContent(schema, props);
+  if (computed !== void 0) {
+    await backend.upsertFulltext({
+      graphId: ctx.graphId,
+      nodeKind: ctx.nodeKind,
+      nodeId: ctx.nodeId,
+      content: computed.content,
+      language: computed.language
+    });
+    return;
+  }
+  if (getSearchableFields(schema).length === 0) return;
+  await backend.deleteFulltext({
+    graphId: ctx.graphId,
+    nodeKind: ctx.nodeKind,
+    nodeId: ctx.nodeId
+  });
+}
+async function syncFulltextBatchForKind(args, schema, items) {
+  const { graphId, nodeKind, backend } = args;
+  if (!backend.upsertFulltext || !backend.deleteFulltext) {
+    return;
+  }
+  const rows = [];
+  const emptyContentIds = [];
+  const hasSearchableFields = getSearchableFields(schema).length > 0;
+  for (const item of items) {
+    const computed = computeFulltextContent(schema, item.props);
+    if (computed !== void 0) {
+      rows.push({
+        nodeId: item.nodeId,
+        content: computed.content,
+        language: computed.language
+      });
+    } else if (hasSearchableFields) {
+      emptyContentIds.push(item.nodeId);
+    }
+  }
+  if (rows.length > 0) {
+    if (backend.upsertFulltextBatch === void 0) {
+      for (const row of rows) {
+        await backend.upsertFulltext({
+          graphId,
+          nodeKind,
+          nodeId: row.nodeId,
+          content: row.content,
+          language: row.language
+        });
+      }
+    } else {
+      await backend.upsertFulltextBatch({ graphId, nodeKind, rows });
+    }
+  }
+  if (emptyContentIds.length > 0) {
+    if (backend.deleteFulltextBatch === void 0) {
+      for (const nodeId of emptyContentIds) {
+        await backend.deleteFulltext({ graphId, nodeKind, nodeId });
+      }
+    } else {
+      await backend.deleteFulltextBatch({
+        graphId,
+        nodeKind,
+        nodeIds: emptyContentIds
+      });
+    }
+  }
+}
+async function deleteNodeFulltext(ctx, schema) {
+  const { backend } = ctx;
+  if (!backend.deleteFulltext) {
+    return;
+  }
+  if (getSearchableFields(schema).length === 0) {
+    return;
+  }
+  await backend.deleteFulltext({
+    graphId: ctx.graphId,
+    nodeKind: ctx.nodeKind,
+    nodeId: ctx.nodeId
+  });
+}
+
+// src/constraints/index.ts
+var UNIQUE_KEY_SEPARATOR = "";
+var UNIQUE_KEY_NULL_MARKER = "";
+function computeUniqueKey(props, fields, collation) {
+  const values = fields.map((field) => {
+    const value = props[field];
+    if (value === void 0 || value === null) {
+      return UNIQUE_KEY_NULL_MARKER;
+    }
+    const stringValue = typeof value === "string" ? value : typeof value === "number" || typeof value === "boolean" ? value.toString() : JSON.stringify(value);
+    return collation === "caseInsensitive" ? stringValue.toLowerCase() : stringValue;
+  });
+  return values.join(UNIQUE_KEY_SEPARATOR);
+}
+function checkWherePredicate(constraint, props) {
+  if (!constraint.where) {
+    return true;
+  }
+  const predicateBuilder = buildPredicateContext(props);
+  const 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);
+  if (!registry.isAssignableToAny(fromKind, validFromKinds)) {
+    return new EndpointError({
+      edgeKind,
+      endpoint: "from",
+      actualKind: fromKind,
+      expectedKinds: validFromKinds
+    });
+  }
+  const validToKinds = registration.to.map((node) => node.kind);
+  if (!registry.isAssignableToAny(toKind, validToKinds)) {
+    return new EndpointError({
+      edgeKind,
+      endpoint: "to",
+      actualKind: toKind,
+      expectedKinds: validToKinds
+    });
+  }
+  return void 0;
+}
+function checkDisjointness(nodeId, nodeKind, existingKinds, registry) {
+  for (const existingKind of existingKinds) {
+    if (registry.areDisjoint(nodeKind, existingKind)) {
+      return new DisjointError({
+        nodeId,
+        attemptedKind: nodeKind,
+        conflictingKind: existingKind
+      });
+    }
+  }
+  return void 0;
+}
+
+// src/store/uniqueness.ts
+function createUniquenessContext(graphId, registry, backend) {
+  return { graphId, registry, backend };
+}
+async function checkUniquenessConstraints(ctx, kind, id, props, constraints) {
+  for (const constraint of constraints) {
+    if (!checkWherePredicate(constraint, props)) {
+      continue;
+    }
+    const key = computeUniqueKey(
+      props,
+      constraint.fields,
+      constraint.collation
+    );
+    const kindsToCheck = getKindsForUniquenessCheck(
+      kind,
+      constraint.scope,
+      ctx.registry
+    );
+    for (const kindToCheck of kindsToCheck) {
+      const existing = await ctx.backend.checkUnique({
+        graphId: ctx.graphId,
+        nodeKind: kindToCheck,
+        constraintName: constraint.name,
+        key
+      });
+      if (existing && existing.node_id !== id) {
+        throw new UniquenessError({
+          constraintName: constraint.name,
+          kind: kindToCheck,
+          existingId: existing.node_id,
+          newId: id,
+          fields: constraint.fields
+        });
+      }
+    }
+  }
+}
+async function insertUniquenessEntries(ctx, kind, id, props, constraints) {
+  for (const constraint of constraints) {
+    if (!checkWherePredicate(constraint, props)) {
+      continue;
+    }
+    const key = computeUniqueKey(
+      props,
+      constraint.fields,
+      constraint.collation
+    );
+    await ctx.backend.insertUnique({
+      graphId: ctx.graphId,
+      nodeKind: kind,
+      constraintName: constraint.name,
+      key,
+      nodeId: id,
+      concreteKind: kind
+    });
+  }
+}
+async function insertUniquenessEntriesBatch(ctx, items) {
+  const entries = [];
+  for (const item of items) {
+    for (const constraint of item.constraints) {
+      if (!checkWherePredicate(constraint, item.props)) {
+        continue;
+      }
+      entries.push({
+        graphId: ctx.graphId,
+        nodeKind: item.kind,
+        constraintName: constraint.name,
+        key: computeUniqueKey(
+          item.props,
+          constraint.fields,
+          constraint.collation
+        ),
+        nodeId: item.id,
+        concreteKind: item.kind
+      });
+    }
+  }
+  if (entries.length === 0) return;
+  if (ctx.backend.insertUniqueBatch !== void 0) {
+    await ctx.backend.insertUniqueBatch(entries);
+    return;
+  }
+  for (const entry of entries) {
+    await ctx.backend.insertUnique(entry);
+  }
+}
+async function deleteUniquenessEntries(ctx, kind, props, constraints) {
+  for (const constraint of constraints) {
+    if (!checkWherePredicate(constraint, props)) {
+      continue;
+    }
+    const key = computeUniqueKey(
+      props,
+      constraint.fields,
+      constraint.collation
+    );
+    await ctx.backend.deleteUnique({
+      graphId: ctx.graphId,
+      nodeKind: kind,
+      constraintName: constraint.name,
+      key
+    });
+  }
+}
+async function updateUniquenessEntries(ctx, kind, id, oldProps, newProps, constraints) {
+  const pending = [];
+  for (const constraint of constraints) {
+    const oldApplies = checkWherePredicate(constraint, oldProps);
+    const newApplies = checkWherePredicate(constraint, newProps);
+    const oldKey = oldApplies ? computeUniqueKey(oldProps, constraint.fields, constraint.collation) : void 0;
+    const newKey = newApplies ? computeUniqueKey(newProps, constraint.fields, constraint.collation) : void 0;
+    if (!oldApplies && !newApplies) {
+      continue;
+    }
+    if (oldApplies && newApplies && oldKey === newKey) {
+      continue;
+    }
+    if (newApplies && newKey !== void 0) {
+      const kindsToCheck = getKindsForUniquenessCheck(
+        kind,
+        constraint.scope,
+        ctx.registry
+      );
+      for (const kindToCheck of kindsToCheck) {
+        const existing = await ctx.backend.checkUnique({
+          graphId: ctx.graphId,
+          nodeKind: kindToCheck,
+          constraintName: constraint.name,
+          key: newKey
+        });
+        if (existing && existing.node_id !== id) {
+          throw new UniquenessError({
+            constraintName: constraint.name,
+            kind: kindToCheck,
+            existingId: existing.node_id,
+            newId: id,
+            fields: constraint.fields
+          });
+        }
+      }
+    }
+    pending.push({ constraintName: constraint.name, oldKey, newKey });
+  }
+  for (const mutation of pending) {
+    if (mutation.oldKey !== void 0) {
+      await ctx.backend.deleteUnique({
+        graphId: ctx.graphId,
+        nodeKind: kind,
+        constraintName: mutation.constraintName,
+        key: mutation.oldKey
+      });
+    }
+  }
+  for (const mutation of pending) {
+    if (mutation.newKey !== void 0) {
+      await ctx.backend.insertUnique({
+        graphId: ctx.graphId,
+        nodeKind: kind,
+        constraintName: mutation.constraintName,
+        key: mutation.newKey,
+        nodeId: id,
+        concreteKind: kind
+      });
+    }
+  }
+}
+
+// src/store/operations/node-write-pipeline.ts
+function createNodeWriteContext(graphId, registry, lock) {
+  return { graphId, registry, lock };
+}
+function uniquenessContext(ctx, backend) {
+  return createUniquenessContext(ctx.graphId, ctx.registry, backend);
+}
+function nodeSyncContext(ctx, kind, id, backend) {
+  return { graphId: ctx.graphId, nodeKind: kind, nodeId: id, backend };
+}
+async function enforceNodeDeleteBehavior(ctx, args, backend, policy) {
+  if (policy?.enforceDeleteBehavior === false) return;
+  const behavior = args.onDelete ?? "restrict";
+  const connectedEdges = await backend.findEdgesConnectedTo({
+    graphId: ctx.graphId,
+    nodeKind: args.kind,
+    nodeId: args.id
+  });
+  if (connectedEdges.length === 0) return;
+  switch (behavior) {
+    case "restrict": {
+      throw new RestrictedDeleteError({
+        nodeKind: args.kind,
+        nodeId: args.id,
+        edgeCount: connectedEdges.length,
+        edgeKinds: [...new Set(connectedEdges.map((edge) => edge.kind))]
+      });
+    }
+    case "cascade":
+    case "disconnect": {
+      const batchDelete = args.mode === "hard" ? backend.hardDeleteEdgesBatch : backend.deleteEdgesBatch;
+      if (batchDelete !== void 0) {
+        await batchDelete.call(backend, {
+          graphId: ctx.graphId,
+          ids: connectedEdges.map((edge) => edge.id)
+        });
+        break;
+      }
+      for (const edge of connectedEdges) {
+        await (args.mode === "hard" ? backend.hardDeleteEdge({ graphId: ctx.graphId, id: edge.id }) : backend.deleteEdge({ graphId: ctx.graphId, id: edge.id }));
+      }
+      break;
+    }
+  }
+}
+async function applyNodeInsertSideEffects(ctx, args, backend) {
+  await insertUniquenessEntries(
+    uniquenessContext(ctx, backend),
+    args.kind,
+    args.id,
+    args.props,
+    args.uniqueConstraints
+  );
+  await Promise.all([
+    syncEmbeddings(
+      nodeSyncContext(ctx, args.kind, args.id, backend),
+      args.schema,
+      args.props
+    ),
+    syncFulltext(
+      nodeSyncContext(ctx, args.kind, args.id, backend),
+      args.schema,
+      args.props
+    )
+  ]);
+}
+async function applyNodeInsertSideEffectsBatch(ctx, items, backend) {
+  if (items.length === 0) return;
+  await insertUniquenessEntriesBatch(
+    uniquenessContext(ctx, backend),
+    items.map((item) => ({
+      kind: item.kind,
+      id: item.id,
+      props: item.props,
+      constraints: item.uniqueConstraints
+    }))
+  );
+  const byKind = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    const group = byKind.get(item.kind) ?? { schema: item.schema, rows: [] };
+    group.rows.push({ nodeId: item.id, props: item.props });
+    byKind.set(item.kind, group);
+  }
+  await Promise.all(
+    [...byKind.entries()].flatMap(([kind, group]) => {
+      const syncArguments = { graphId: ctx.graphId, nodeKind: kind, backend };
+      return [
+        syncEmbeddingsBatchForKind(syncArguments, group.schema, group.rows),
+        syncFulltextBatchForKind(syncArguments, group.schema, group.rows)
+      ];
+    })
+  );
+}
+function parseRowProps(row) {
+  return rowPropsToObject(row.props);
+}
+async function applyNodeUpdate(ctx, args, backend) {
+  const { kind, id } = args.existing;
+  if (args.existing.deleted_at === void 0) {
+    await updateUniquenessEntries(
+      uniquenessContext(ctx, backend),
+      kind,
+      id,
+      parseRowProps(args.existing),
+      args.validatedProps,
+      args.uniqueConstraints
+    );
+  } else {
+    await checkUniquenessConstraints(
+      uniquenessContext(ctx, backend),
+      kind,
+      id,
+      args.validatedProps,
+      args.uniqueConstraints
+    );
+    await insertUniquenessEntries(
+      uniquenessContext(ctx, backend),
+      kind,
+      id,
+      args.validatedProps,
+      args.uniqueConstraints
+    );
+  }
+  const updateParams = {
+    graphId: ctx.graphId,
+    kind,
+    id,
+    props: args.validatedProps,
+    incrementVersion: true
+  };
+  if (args.validTo !== void 0) updateParams.validTo = args.validTo;
+  if (args.clearDeleted) updateParams.clearDeleted = true;
+  const row = await backend.updateNode(updateParams);
+  await Promise.all([
+    syncEmbeddings(
+      nodeSyncContext(ctx, kind, id, backend),
+      args.schema,
+      args.validatedProps
+    ),
+    syncFulltext(
+      nodeSyncContext(ctx, kind, id, backend),
+      args.schema,
+      args.validatedProps
+    )
+  ]);
+  return row;
+}
+async function applyNodeSoftDelete(ctx, args, backend, policy) {
+  const { kind, id } = args.existing;
+  await enforceNodeDeleteBehavior(
+    ctx,
+    { kind, id, mode: "soft", onDelete: args.onDelete },
+    backend,
+    policy
+  );
+  await backend.deleteNode({
+    graphId: ctx.graphId,
+    kind,
+    id
+  });
+  await deleteUniquenessEntries(
+    uniquenessContext(ctx, backend),
+    kind,
+    parseRowProps(args.existing),
+    args.uniqueConstraints
+  );
+  await deleteNodeEmbeddings(
+    nodeSyncContext(ctx, kind, id, backend),
+    args.schema
+  );
+  await deleteNodeFulltext(
+    nodeSyncContext(ctx, kind, id, backend),
+    args.schema
+  );
+}
+async function applyNodeHardDelete(ctx, args, backend) {
+  await enforceNodeDeleteBehavior(
+    ctx,
+    { kind: args.kind, id: args.id, mode: "hard", onDelete: args.onDelete },
+    backend
+  );
+  await backend.hardDeleteNode({
+    graphId: ctx.graphId,
+    kind: args.kind,
+    id: args.id
+  });
+  await deleteNodeEmbeddings(
+    nodeSyncContext(ctx, args.kind, args.id, backend),
+    args.schema
+  );
+}
+async function applyNodeResurrect(ctx, args, backend) {
+  const { kind, id } = args.existing;
+  const props = parseRowProps(args.existing);
+  await checkUniquenessConstraints(
+    uniquenessContext(ctx, backend),
+    kind,
+    id,
+    props,
+    args.uniqueConstraints
+  );
+  await insertUniquenessEntries(
+    uniquenessContext(ctx, backend),
+    kind,
+    id,
+    props,
+    args.uniqueConstraints
+  );
+  const row = await backend.updateNode({
+    graphId: ctx.graphId,
+    kind,
+    id,
+    props,
+    incrementVersion: true,
+    clearDeleted: true
+  });
+  await Promise.all([
+    syncEmbeddings(nodeSyncContext(ctx, kind, id, backend), args.schema, props),
+    syncFulltext(nodeSyncContext(ctx, kind, id, backend), args.schema, props)
+  ]);
+  return row;
+}
+
+export { ALIAS_CTE_PREFIX, DEFAULT_SQL_SCHEMA, EMBEDDINGS_CTE_ALIAS, FULLTEXT_CTE_ALIAS, HYBRID_CANDIDATES_CTE_ALIAS, advanceRevisionClock, applyNodeHardDelete, applyNodeInsertSideEffects, applyNodeInsertSideEffectsBatch, applyNodeResurrect, applyNodeSoftDelete, applyNodeUpdate, asRecordedInstant, assertRecordedCaptureTransactionIsolation, assertRevisionTrackableBackend, assertValidRecordedInstant, checkCardinality, checkDisjointness, checkUniqueEdge, checkUniquenessConstraints, checkWherePredicate, closeRecordedHardDeletedKind, computeFulltextContent, computeUniqueKey, coordinateContext, createHistoryUnsafeSqlRef, createNodeWriteContext, createRecordedBackend, createRecordedReadBinding, createRecordedTransactionScope, createRevisionTrackingUnsafeSqlRef, createSqlSchema, createUniquenessContext, describeCoordinate, edgeInsertDispatch, ensureRevisionOrigin, generateId, getEdgeRowsByIds, getEmbeddingFields, getKindsForUniquenessCheck, getNodeRowsByIds, lockRecordedGraphWrite, nodeInsertDispatch, readRecordedClock, readRevisionOrigin, recordedBindParamBudget, recordedCaptureRequiresCallbackTransactionError, recordedReadSchemaFor, recordedReadSqlSchema, recordedRelation, requireExternalRecordedReadSource, requireRecordedReadBinding, requireSqlSchema, resolveReadCoordinate, runInsertBatch, runInsertBatchReturning, runInsertNoReturn, uncapturedGraphWriteLock, validateEdgeEndpoints, vectorSlotKey, withRecordedCoordinate, withRecordedFlushObserver };
+//# sourceMappingURL=chunk-CZQ3FO2Q.js.map
+//# sourceMappingURL=chunk-CZQ3FO2Q.js.map