@nicia-ai/typegraph 0.32.0 → 0.34.0

package/dist/chunk-5IQIX7LU.cjs

@@ -0,0 +1,2070 @@
+'use strict';
+
+var chunkUNNPKQUG_cjs = require('./chunk-UNNPKQUG.cjs');
+var chunkYC6PWTHY_cjs = require('./chunk-YC6PWTHY.cjs');
+var chunkRHZWOJVA_cjs = require('./chunk-RHZWOJVA.cjs');
+var chunkYAZE7QZR_cjs = require('./chunk-YAZE7QZR.cjs');
+var chunkNAUA4PW5_cjs = require('./chunk-NAUA4PW5.cjs');
+var chunkJQGIPGVL_cjs = require('./chunk-JQGIPGVL.cjs');
+var chunkJIEJCTDS_cjs = require('./chunk-JIEJCTDS.cjs');
+var drizzleOrm = require('drizzle-orm');
+var nanoid = require('nanoid');
+
+// src/core/temporal.ts
+var RECORDED_MAX = "9999-12-31T23:59:59.999Z";
+function assertValidRecordedInstant(value, path) {
+  chunkYC6PWTHY_cjs.validateCanonicalIsoDate(value, path);
+  if (value >= RECORDED_MAX) {
+    throw new chunkJIEJCTDS_cjs.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 chunkJIEJCTDS_cjs.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 chunkJIEJCTDS_cjs.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) {
+    chunkYC6PWTHY_cjs.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 chunkJIEJCTDS_cjs.ConfigurationError(`${label} table name cannot be empty`);
+  }
+  if (name.length > chunkNAUA4PW5_cjs.MAX_PG_IDENTIFIER_LENGTH) {
+    throw new chunkJIEJCTDS_cjs.ConfigurationError(
+      `${label} table name exceeds maximum length of ${chunkNAUA4PW5_cjs.MAX_PG_IDENTIFIER_LENGTH} characters`
+    );
+  }
+  if (!VALID_IDENTIFIER_PATTERN.test(name)) {
+    throw new chunkJIEJCTDS_cjs.ConfigurationError(
+      `${label} table name "${name}" is not a valid SQL identifier. Table names must start with a letter or underscore and contain only letters, digits, underscores, or dollar signs.`
+    );
+  }
+}
+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 chunkJIEJCTDS_cjs.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: drizzleOrm.sql.raw(quoteIdentifier(tables.nodes)),
+    edgesTable: drizzleOrm.sql.raw(quoteIdentifier(tables.edges)),
+    recordedNodesTable: drizzleOrm.sql.raw(quoteIdentifier(tables.recordedNodes)),
+    recordedEdgesTable: drizzleOrm.sql.raw(quoteIdentifier(tables.recordedEdges)),
+    recordedClockTable: drizzleOrm.sql.raw(quoteIdentifier(tables.recordedClock)),
+    fulltextTable: drizzleOrm.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 chunkJIEJCTDS_cjs.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 chunkJIEJCTDS_cjs.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 chunkJIEJCTDS_cjs.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";
+function generateId() {
+  return nanoid.nanoid();
+}
+function requireRecordedSchema(target) {
+  if (target.tableNames === void 0) {
+    throw new chunkJIEJCTDS_cjs.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 chunkJIEJCTDS_cjs.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 chunkJIEJCTDS_cjs.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(drizzleOrm.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 chunkJIEJCTDS_cjs.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 chunkJIEJCTDS_cjs.ConfigurationError(
+    `${surface} is not available when history capture is enabled because raw SQL writes bypass recorded-time capture.`,
+    { code: "RECORDED_CAPTURE_RAW_SQL_DISABLED" },
+    {
+      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 chunkJIEJCTDS_cjs.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 chunkJIEJCTDS_cjs.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 chunkJIEJCTDS_cjs.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 chunkJIEJCTDS_cjs.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";
+var RECORDED_GRAPH_WRITE_ADVISORY_LOCK_NAMESPACE = "typegraph:recorded-graph-write";
+function graphAdvisoryLockSql(namespace, graphId) {
+  return drizzleOrm.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();
+}
+async function lockRecordedGraphWrite(target, graphId) {
+  if (target.dialect !== "postgres") return graphWriteLockEvidence();
+  await target.execute(
+    asCompiledRowsSql(recordedGraphWriteAdvisoryLockSql(graphId))
+  );
+  return graphWriteLockEvidence();
+}
+async function lockRecordedGraphWrites(target, graphIds) {
+  if (target.dialect !== "postgres") return;
+  const uniqueGraphIds = [...new Set(graphIds)].toSorted();
+  for (const graphId of uniqueGraphIds) {
+    await lockRecordedGraphWrite(target, graphId);
+  }
+}
+function failInvalidClockTimestamp(value) {
+  throw new chunkJIEJCTDS_cjs.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(chunkYC6PWTHY_cjs.nowIso());
+  return previous === void 0 ? wallTime : Math.max(wallTime, Date.parse(previous) + 1);
+}
+async function readRecordedClock(target, schema, graphId) {
+  const rows = await target.execute(
+    asCompiledRowsSql(drizzleOrm.sql`
+      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,
+    drizzleOrm.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,
+    drizzleOrm.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 chunkJIEJCTDS_cjs.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;
+}
+
+// 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 = drizzleOrm.sql.raw(RECORDED_NODE_COLUMNS.join(", "));
+var RECORDED_EDGE_COLUMN_LIST = drizzleOrm.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 chunkJIEJCTDS_cjs.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: () => drizzleOrm.sql`${generateId()}`,
+    graph_id: (row) => drizzleOrm.sql`${row.graph_id}`,
+    id: (row) => drizzleOrm.sql`${row.id}`,
+    kind: (row) => drizzleOrm.sql`${row.kind}`,
+    props: (row) => drizzleOrm.sql`${row.props}`,
+    valid_from: (row) => drizzleOrm.sql`${chunkYAZE7QZR_cjs.sqlNull(row.valid_from)}`,
+    valid_to: (row) => drizzleOrm.sql`${chunkYAZE7QZR_cjs.sqlNull(row.valid_to)}`,
+    created_at: (row) => drizzleOrm.sql`${row.created_at}`,
+    updated_at: (row) => drizzleOrm.sql`${row.updated_at}`,
+    deleted_at: (row) => drizzleOrm.sql`${chunkYAZE7QZR_cjs.sqlNull(row.deleted_at)}`,
+    recorded_from: (_row, recordedCommit) => drizzleOrm.sql`${recordedCommit}`,
+    recorded_to: () => drizzleOrm.sql`${RECORDED_MAX}`,
+    op: (_row, _recordedCommit, operation) => drizzleOrm.sql`${operation}`,
+    schema_version: () => drizzleOrm.sql`NULL`,
+    tx_id: () => drizzleOrm.sql`NULL`,
+    meta: () => drizzleOrm.sql`${RECORDED_HISTORY_META}`
+  };
+}
+var recordedNodeCells = {
+  ...recordedCommonCells(),
+  version: (row) => drizzleOrm.sql`${row.version}`
+};
+var recordedEdgeCells = {
+  ...recordedCommonCells(),
+  from_kind: (row) => drizzleOrm.sql`${row.from_kind}`,
+  from_id: (row) => drizzleOrm.sql`${row.from_id}`,
+  to_kind: (row) => drizzleOrm.sql`${row.to_kind}`,
+  to_id: (row) => drizzleOrm.sql`${row.to_id}`
+};
+function recordedValuesTuple(columns, cells, row, recordedCommit, operation) {
+  const tuple = columns.map(
+    (column) => cells[column](row, recordedCommit, operation)
+  );
+  return drizzleOrm.sql`(${drizzleOrm.sql.join(tuple, drizzleOrm.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,
+    drizzleOrm.sql`
+      INSERT INTO ${table} (${columnList})
+      VALUES ${drizzleOrm.sql.join(values, drizzleOrm.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 ? drizzleOrm.sql`` : drizzleOrm.sql`AND kind = ${kind}`;
+  const rows = await target.execute(
+    asCompiledRowsSql(drizzleOrm.sql`
+      UPDATE ${table}
+      SET recorded_to = ${recordedCommit}
+      WHERE graph_id = ${graphId}
+        ${kindFilter}
+        AND recorded_to = ${RECORDED_MAX}
+        AND id IN (${chunkUNNPKQUG_cjs.sqlValueList(ids)})
+      RETURNING id, deleted_at
+    `)
+  );
+  return new Map(rows.map((row) => [row.id, chunkUNNPKQUG_cjs.isPresent(row.deleted_at)]));
+}
+function recordedOp(hadOpenRow, priorRowWasTombstone, after) {
+  if (chunkUNNPKQUG_cjs.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 chunkUNNPKQUG_cjs.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 chunkUNNPKQUG_cjs.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,
+    drizzleOrm.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,
+    drizzleOrm.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(drizzleOrm.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 chunkJIEJCTDS_cjs.ConfigurationError(
+        "Recorded-time capture session is sealed: a graph write happened after the transaction's capture was flushed.",
+        { entity: entity.entity, graphId: entity.graphId, id: entity.id },
+        {
+          suggestion: "Perform all writes inside the withRecordedTransaction callback; do not reuse the transaction context after it returns."
+        }
+      );
+    }
+    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 chunkJIEJCTDS_cjs.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 = chunkUNNPKQUG_cjs.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);
+  async function lockGraph(graphId) {
+    await lockRecordedGraphWrite(target, graphId);
+  }
+  async function lockGraphs(params) {
+    await lockRecordedGraphWrites(
+      target,
+      params.map((parameter) => parameter.graphId)
+    );
+  }
+  return chunkUNNPKQUG_cjs.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);
+    }
+  });
+}
+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 chunkRHZWOJVA_cjs.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 chunkUNNPKQUG_cjs.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/embedding-sync.ts
+var embeddingFieldsCache = /* @__PURE__ */ new WeakMap();
+function getEmbeddingFields(schema) {
+  const cached = embeddingFieldsCache.get(schema);
+  if (cached) return cached;
+  const fields = chunkJQGIPGVL_cjs.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 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 searchableFieldsCache = /* @__PURE__ */ new WeakMap();
+function getSearchableFields(schema) {
+  const cached = searchableFieldsCache.get(schema);
+  if (cached) return cached;
+  const fields = computeSearchableFields(schema);
+  searchableFieldsCache.set(schema, fields);
+  return fields;
+}
+function computeSearchableFields(schema) {
+  if (schema.type !== "object") return [];
+  const def = schema.def;
+  const shape = def.shape;
+  if (!shape) return [];
+  const fields = [];
+  for (const [fieldPath, fieldSchema] of Object.entries(shape)) {
+    const metadata = chunkJQGIPGVL_cjs.getSearchableMetadata(fieldSchema);
+    if (metadata !== void 0) {
+      fields.push({ fieldPath, metadata });
+    }
+  }
+  warnIfConflictingLanguages(fields);
+  return fields;
+}
+function warnIfConflictingLanguages(fields) {
+  if (fields.length < 2) return;
+  const languages = new Set(fields.map((field) => field.metadata.language));
+  if (languages.size < 2) return;
+  if (typeof console === "undefined" || typeof console.warn !== "function") {
+    return;
+  }
+  const fieldSummary = fields.map((field) => `${field.fieldPath}=${field.metadata.language}`).join(", ");
+  const winning = fields[0]?.metadata.language ?? chunkJQGIPGVL_cjs.DEFAULT_SEARCHABLE_LANGUAGE;
+  console.warn(
+    `[typegraph] searchable() fields declare conflicting languages (${fieldSummary}). The first field's language ("${winning}") is recorded on the fulltext row; true multilingual indexing requires a dedicated node kind per language.`
+  );
+}
+var FIELD_SEPARATOR = "\n";
+function resolveCombinedLanguage(fields) {
+  return fields[0]?.metadata.language ?? chunkJQGIPGVL_cjs.DEFAULT_SEARCHABLE_LANGUAGE;
+}
+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 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 chunkUNNPKQUG_cjs.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 chunkJIEJCTDS_cjs.CardinalityError({
+          edgeKind,
+          fromKind,
+          fromId,
+          cardinality: "one",
+          existingCount: existingEdgeCount
+        });
+      }
+      return void 0;
+    }
+    case "unique": {
+      return void 0;
+    }
+    case "oneActive": {
+      if (hasActiveEdge) {
+        return new chunkJIEJCTDS_cjs.CardinalityError({
+          edgeKind,
+          fromKind,
+          fromId,
+          cardinality: "oneActive",
+          existingCount: 1
+        });
+      }
+      return void 0;
+    }
+  }
+}
+function checkUniqueEdge(edgeKind, fromKind, fromId, _toKind, _toId, existingCount) {
+  if (existingCount > 0) {
+    return new chunkJIEJCTDS_cjs.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 chunkJIEJCTDS_cjs.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 chunkJIEJCTDS_cjs.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 chunkJIEJCTDS_cjs.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 chunkJIEJCTDS_cjs.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 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 chunkJIEJCTDS_cjs.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 chunkJIEJCTDS_cjs.RestrictedDeleteError({
+        nodeKind: args.kind,
+        nodeId: args.id,
+        edgeCount: connectedEdges.length,
+        edgeKinds: [...new Set(connectedEdges.map((edge) => edge.kind))]
+      });
+    }
+    case "cascade":
+    case "disconnect": {
+      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
+    )
+  ]);
+}
+function parseRowProps(row) {
+  return JSON.parse(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;
+}
+
+exports.ALIAS_CTE_PREFIX = ALIAS_CTE_PREFIX;
+exports.DEFAULT_SQL_SCHEMA = DEFAULT_SQL_SCHEMA;
+exports.EMBEDDINGS_CTE_ALIAS = EMBEDDINGS_CTE_ALIAS;
+exports.FULLTEXT_CTE_ALIAS = FULLTEXT_CTE_ALIAS;
+exports.HYBRID_CANDIDATES_CTE_ALIAS = HYBRID_CANDIDATES_CTE_ALIAS;
+exports.applyNodeHardDelete = applyNodeHardDelete;
+exports.applyNodeInsertSideEffects = applyNodeInsertSideEffects;
+exports.applyNodeResurrect = applyNodeResurrect;
+exports.applyNodeSoftDelete = applyNodeSoftDelete;
+exports.applyNodeUpdate = applyNodeUpdate;
+exports.asCompiledRowsSql = asCompiledRowsSql;
+exports.asCompiledSelectSql = asCompiledSelectSql;
+exports.asCompiledStatementSql = asCompiledStatementSql;
+exports.asRecordedInstant = asRecordedInstant;
+exports.assertRecordedCaptureTransactionIsolation = assertRecordedCaptureTransactionIsolation;
+exports.assertValidRecordedInstant = assertValidRecordedInstant;
+exports.checkCardinality = checkCardinality;
+exports.checkDisjointness = checkDisjointness;
+exports.checkUniqueEdge = checkUniqueEdge;
+exports.checkUniquenessConstraints = checkUniquenessConstraints;
+exports.checkWherePredicate = checkWherePredicate;
+exports.closeRecordedHardDeletedKind = closeRecordedHardDeletedKind;
+exports.computeFulltextContent = computeFulltextContent;
+exports.computeUniqueKey = computeUniqueKey;
+exports.coordinateContext = coordinateContext;
+exports.createHistoryUnsafeSqlRef = createHistoryUnsafeSqlRef;
+exports.createNodeWriteContext = createNodeWriteContext;
+exports.createRecordedBackend = createRecordedBackend;
+exports.createRecordedReadBinding = createRecordedReadBinding;
+exports.createRecordedTransactionScope = createRecordedTransactionScope;
+exports.createSqlSchema = createSqlSchema;
+exports.createUniquenessContext = createUniquenessContext;
+exports.describeCoordinate = describeCoordinate;
+exports.edgeInsertDispatch = edgeInsertDispatch;
+exports.generateId = generateId;
+exports.getEdgeRowsByIds = getEdgeRowsByIds;
+exports.getEmbeddingFields = getEmbeddingFields;
+exports.getKindsForUniquenessCheck = getKindsForUniquenessCheck;
+exports.getNodeRowsByIds = getNodeRowsByIds;
+exports.getSearchableFields = getSearchableFields;
+exports.lockRecordedGraphWrite = lockRecordedGraphWrite;
+exports.nodeInsertDispatch = nodeInsertDispatch;
+exports.readRecordedClock = readRecordedClock;
+exports.recordedBindParamBudget = recordedBindParamBudget;
+exports.recordedCaptureRequiresCallbackTransactionError = recordedCaptureRequiresCallbackTransactionError;
+exports.recordedReadSchemaFor = recordedReadSchemaFor;
+exports.recordedReadSqlSchema = recordedReadSqlSchema;
+exports.recordedRelation = recordedRelation;
+exports.requireExternalRecordedReadSource = requireExternalRecordedReadSource;
+exports.requireRecordedReadBinding = requireRecordedReadBinding;
+exports.requireSqlSchema = requireSqlSchema;
+exports.resolveReadCoordinate = resolveReadCoordinate;
+exports.runInsertBatch = runInsertBatch;
+exports.runInsertBatchReturning = runInsertBatchReturning;
+exports.runInsertNoReturn = runInsertNoReturn;
+exports.uncapturedGraphWriteLock = uncapturedGraphWriteLock;
+exports.validateEdgeEndpoints = validateEdgeEndpoints;
+exports.vectorSlotKey = vectorSlotKey;
+exports.withRecordedCoordinate = withRecordedCoordinate;
+//# sourceMappingURL=chunk-5IQIX7LU.cjs.map
+//# sourceMappingURL=chunk-5IQIX7LU.cjs.map