@nicia-ai/typegraph 0.39.0 → 0.40.0

package/dist/chunk-YIX3BEBR.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/store/row-mappers.ts","../src/store/operations/write-transaction.ts","../src/store/constraints.ts","../src/store/operations/node-operations.ts"],"names":["rowPropsToObject","filterReservedKeys","RESERVED_NODE_KEYS","RESERVED_EDGE_KEYS","runOptionallyInTransaction","lockRecordedGraphWrite","uncapturedGraphWriteLock","advanceRevisionClock","checkDisjointness","checkCardinality","checkUniqueEdge","KindNotFoundError","ValidationError","NodeConstraintNotFoundError","checkWherePredicate","computeUniqueKey","getKindsForUniquenessCheck","createBackendOverlay","validateNodeProps","validateOptionalCanonicalIsoDate","checkUniquenessConstraints","createUniquenessContext","applyNodeInsertSideEffectsBatch","createNodeWriteContext","applyNodeInsertSideEffects","canonicalEqual","NodeNotFoundError","row","applyNodeUpdate","isLiveNodeRow","generateId","runInsertNoReturn","nodeInsertDispatch","DatabaseOperationError","runInsertBatch","runInsertBatchReturning","applyNodeSoftDelete","applyNodeHardDelete","UniquenessError","NodeIndexNotFoundError","ConfigurationError","getDialect","resolveJsonPointer","createSqlSchema","DEFAULT_SQL_SCHEMA","sql","compileNodeIndexFieldKeys","compileIndexWhere","asCompiledRowsSql","getNodeRowsByIds","requireDefined"],"mappings":"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","file":"chunk-YIX3BEBR.cjs","sourcesContent":["/**\n * Row Mappers for Store\n *\n * Transforms database rows into typed Node and Edge objects.\n */\nimport {\n  type EdgeRow as BackendEdgeRow,\n  type NodeRow as BackendNodeRow,\n  rowPropsToObject,\n} from \"../backend/types\";\nimport {\n  filterReservedKeys,\n  RESERVED_EDGE_KEYS,\n  RESERVED_NODE_KEYS,\n} from \"./reserved-keys\";\nimport { type Edge, type EdgeMeta, type Node, type NodeMeta } from \"./types\";\n\n/**\n * Raw node row from database (without graph_id).\n * Derived from BackendNodeRow so BackendNodeRow is assignable without casts.\n */\nexport type NodeRow = Omit<BackendNodeRow, \"graph_id\">;\n\n/**\n * Raw edge row from database (without graph_id).\n * Derived from BackendEdgeRow so BackendEdgeRow is assignable without casts.\n */\nexport type EdgeRow = Omit<BackendEdgeRow, \"graph_id\">;\n\n/**\n * Converts null to undefined for consistent typing.\n * Database backends return null for missing values, but our types use undefined.\n */\nfunction nullToUndefined<T>(value: T | null | undefined): T | undefined {\n  return value === null ? undefined : value;\n}\n\n/**\n * Transforms a database row into a typed Node object.\n *\n * Props are spread at top level, metadata goes under `meta`.\n * Reserved keys (id, kind, meta) in props are filtered out to prevent collisions.\n * Null values from database are normalized to undefined.\n */\nexport function rowToNode(row: NodeRow): Node {\n  const rawProps = rowPropsToObject(row.props);\n  const props = filterReservedKeys(rawProps, RESERVED_NODE_KEYS);\n  return {\n    kind: row.kind,\n    id: row.id as Node[\"id\"],\n    meta: rowToNodeMeta(row),\n    ...props,\n  };\n}\n\nexport function rowToNodeMeta(\n  row: Pick<\n    NodeRow,\n    | \"version\"\n    | \"valid_from\"\n    | \"valid_to\"\n    | \"created_at\"\n    | \"updated_at\"\n    | \"deleted_at\"\n  >,\n): NodeMeta {\n  return {\n    version: row.version,\n    validFrom: nullToUndefined(row.valid_from),\n    validTo: nullToUndefined(row.valid_to),\n    createdAt: row.created_at,\n    updatedAt: row.updated_at,\n    deletedAt: nullToUndefined(row.deleted_at),\n  };\n}\n\n/**\n * Transforms a database row into a typed Edge object.\n *\n * Props are spread at top level, metadata goes under `meta`.\n * Reserved keys in props are filtered out to prevent collisions.\n * Null values from database are normalized to undefined.\n */\nexport function rowToEdge(row: EdgeRow): Edge {\n  const rawProps = rowPropsToObject(row.props);\n  const props = filterReservedKeys(rawProps, RESERVED_EDGE_KEYS);\n  return {\n    id: row.id,\n    kind: row.kind,\n    fromKind: row.from_kind,\n    fromId: row.from_id,\n    toKind: row.to_kind,\n    toId: row.to_id,\n    meta: rowToEdgeMeta(row),\n    ...props,\n  } as Edge;\n}\n\nexport function rowToEdgeMeta(\n  row: Pick<\n    EdgeRow,\n    \"valid_from\" | \"valid_to\" | \"created_at\" | \"updated_at\" | \"deleted_at\"\n  >,\n): EdgeMeta {\n  return {\n    validFrom: nullToUndefined(row.valid_from),\n    validTo: nullToUndefined(row.valid_to),\n    createdAt: row.created_at,\n    updatedAt: row.updated_at,\n    deletedAt: nullToUndefined(row.deleted_at),\n  };\n}\n","/**\n * Shared transaction boundary for graph-entity mutations.\n *\n * A node/edge mutation is a cascade of steps — the core row write plus its\n * integrity side effects (uniqueness, embeddings, fulltext) or its delete\n * behavior (restrict / cascade / disconnect). Those steps are individually\n * atomic but not collectively atomic, so the cascade runs inside one top-level\n * transaction whether or not recorded-time capture is enabled: a mid-cascade\n * failure then rolls back the whole operation instead of leaving a half-applied\n * write (e.g. an inserted node whose uniqueness/embedding/fulltext rows were\n * never written, or a uniqueness conflict that leaves an orphaned node row).\n * Under history capture the per-graph write lock is additionally taken inside\n * that transaction so recorded capture serializes.\n *\n * Both {@link NodeOperationContext} and {@link EdgeOperationContext} route their\n * mutations through this one helper, replacing the byte-identical per-file\n * copies that previously drifted independently.\n */\nimport {\n  type GraphBackend,\n  runOptionallyInTransaction,\n  type TransactionBackend,\n} from \"../../backend/types\";\nimport { type SqlSchema } from \"../../query/compiler/schema\";\nimport {\n  advanceRevisionClock,\n  lockRecordedGraphWrite,\n} from \"../recorded-capture\";\nimport {\n  type GraphWriteLock,\n  uncapturedGraphWriteLock,\n} from \"../recorded-capture/clock\";\nimport { type OperationHookContext } from \"../types\";\n\n/**\n * The slice of an operation context {@link runInWriteTransaction} needs: the\n * graph id (for the capture lock) and whether recorded-time capture is on.\n * Both {@link NodeOperationContext} and {@link EdgeOperationContext} satisfy it.\n */\nexport type WriteTransactionContext = Readonly<{\n  graphId: string;\n  historyEnabled: boolean;\n  revisionTrackingEnabled: boolean;\n  revisionSchema: SqlSchema;\n}>;\n\n/**\n * Runs a graph-entity mutation cascade inside a single top-level transaction.\n *\n * On a transactional backend the cascade shares one transaction so it commits\n * or rolls back atomically. A nested {@link TransactionBackend} (already inside\n * `store.transaction(...)`) omits `.transaction`, so\n * {@link runOptionallyInTransaction} runs `fn` directly against it rather than\n * opening a nested transaction. Non-transactional backends (Cloudflare D1,\n * `drizzle-orm/neon-http`) also run `fn` directly — they cannot offer\n * atomicity, which is documented on the store's write surface.\n *\n * Under history capture the per-graph write lock is taken inside the\n * transaction before any row work, matching the acquire order the recorded\n * clock lock depends on to avoid a circular wait.\n */\nexport function runInWriteTransaction<T>(\n  ctx: WriteTransactionContext,\n  backend: GraphBackend | TransactionBackend,\n  fn: (\n    target: GraphBackend | TransactionBackend,\n    lock: GraphWriteLock,\n  ) => Promise<T>,\n): Promise<T> {\n  const ownsWriteLock =\n    \"transaction\" in backend && backend.capabilities.transactions;\n  return runOptionallyInTransaction(backend, async (target) => {\n    const lock =\n      ctx.historyEnabled || ctx.revisionTrackingEnabled ?\n        await lockRecordedGraphWrite(target, ctx.graphId)\n      : uncapturedGraphWriteLock();\n    const result = await fn(target, lock);\n    // History capture advances the same clock when it flushes its recorded\n    // after-images. Live stores opt into revisions independently, so advance\n    // only there and only after every row/sidecar write succeeded.\n    if (ctx.revisionTrackingEnabled && !ctx.historyEnabled) {\n      await advanceRevisionClock(\n        target,\n        ctx.revisionSchema,\n        ctx.graphId,\n        ownsWriteLock,\n      );\n    }\n    return result;\n  });\n}\n\n/**\n * The slice of an operation context {@link runHookedWriteOperation} needs:\n * the {@link WriteTransactionContext} plus the hook wrapper. Both\n * `NodeOperationContext` and `EdgeOperationContext` satisfy it.\n */\nexport type HookedWriteOperationContext = WriteTransactionContext &\n  Readonly<{\n    withOperationHooks: <T>(\n      ctx: OperationHookContext,\n      fn: () => Promise<T>,\n    ) => Promise<T>;\n  }>;\n\n/**\n * The one sanctioned composition for a hooked, non-batch write operation:\n * operation hooks WRAP the write transaction, so `onOperationEnd` observes a\n * durably committed result and a failed COMMIT surfaces through `onError` —\n * a hook that fired inside the transaction would report success for a write\n * the rollback then discards. Every hooked node/edge mutation routes through\n * this helper; composing `withOperationHooks` and `runInWriteTransaction` by\n * hand invites exactly the inverted nesting this exists to prevent.\n * (Batch operations skip hooks deliberately and call\n * {@link runInWriteTransaction} directly.)\n */\nexport function runHookedWriteOperation<T>(\n  ctx: HookedWriteOperationContext,\n  opContext: OperationHookContext,\n  backend: GraphBackend | TransactionBackend,\n  body: (\n    target: GraphBackend | TransactionBackend,\n    lock: GraphWriteLock,\n  ) => Promise<T>,\n): Promise<T> {\n  return ctx.withOperationHooks(opContext, () =>\n    runInWriteTransaction(ctx, backend, body),\n  );\n}\n","/**\n * Constraint Checking for Store Operations\n *\n * Handles checking disjointness and cardinality constraints.\n */\nimport { type GraphBackend, type TransactionBackend } from \"../backend/types\";\nimport {\n  checkCardinality,\n  checkDisjointness,\n  checkUniqueEdge,\n} from \"../constraints\";\nimport { type KindRegistry } from \"../registry/kind-registry\";\n\n/**\n * Context for constraint operations.\n */\nexport type ConstraintContext = Readonly<{\n  graphId: string;\n  registry: KindRegistry;\n  backend: GraphBackend | TransactionBackend;\n}>;\n\n/**\n * Checks disjointness constraints for a node.\n *\n * Ensures that a node with a given ID doesn't exist in any disjoint kinds.\n *\n * @throws ValidationError if disjointness constraint is violated\n */\nexport async function checkDisjointnessConstraint(\n  ctx: ConstraintContext,\n  kind: string,\n  id: string,\n): Promise<void> {\n  // Get all kinds that are disjoint with this kind\n  const disjointKinds = ctx.registry.getDisjointKinds(kind);\n\n  // For each disjoint kind, check if a node with this ID exists\n  for (const disjointKind of disjointKinds) {\n    const existing = await ctx.backend.getNode(ctx.graphId, disjointKind, id);\n    if (existing && !existing.deleted_at) {\n      const error = checkDisjointness(id, kind, [disjointKind], ctx.registry);\n      if (error) throw error;\n    }\n  }\n}\n\n/**\n * Checks cardinality constraints for an edge.\n *\n * @throws CardinalityError if cardinality constraint is violated\n */\nexport async function checkCardinalityConstraint(\n  ctx: ConstraintContext,\n  edgeKind: string,\n  cardinality: \"many\" | \"one\" | \"unique\" | \"oneActive\",\n  fromKind: string,\n  fromId: string,\n  toKind: string,\n  toId: string,\n  validTo: string | undefined,\n): Promise<void> {\n  switch (cardinality) {\n    case \"many\": {\n      // No constraint - allow any number of edges\n      return;\n    }\n\n    case \"one\": {\n      // At most one edge of this kind from this source\n      const count = await ctx.backend.countEdgesFrom({\n        graphId: ctx.graphId,\n        edgeKind,\n        fromKind,\n        fromId,\n      });\n      const error = checkCardinality(\n        edgeKind,\n        fromKind,\n        fromId,\n        \"one\",\n        count,\n        false,\n      );\n      if (error) throw error;\n      return;\n    }\n\n    case \"unique\": {\n      // At most one edge between this specific source-target pair\n      const exists = await ctx.backend.edgeExistsBetween({\n        graphId: ctx.graphId,\n        edgeKind,\n        fromKind,\n        fromId,\n        toKind,\n        toId,\n      });\n      const error = checkUniqueEdge(\n        edgeKind,\n        fromKind,\n        fromId,\n        toKind,\n        toId,\n        exists ? 1 : 0,\n      );\n      if (error) throw error;\n      return;\n    }\n\n    case \"oneActive\": {\n      // At most one active edge (valid_to IS NULL) from this source\n      // Only check if the new edge will be active (validTo is not set)\n      if (validTo !== undefined) {\n        // New edge is already ended, no active constraint to check\n        return;\n      }\n      const count = await ctx.backend.countEdgesFrom({\n        graphId: ctx.graphId,\n        edgeKind,\n        fromKind,\n        fromId,\n        activeOnly: true,\n      });\n      const error = checkCardinality(\n        edgeKind,\n        fromKind,\n        fromId,\n        \"oneActive\",\n        count,\n        count > 0,\n      );\n      if (error) throw error;\n      return;\n    }\n  }\n}\n","/**\n * Node Operations for Store\n *\n * Handles node CRUD operations: create, update, delete.\n */\nimport {\n  createBackendOverlay,\n  type GraphBackend,\n  type InsertNodeParams,\n  isLiveNodeRow,\n  type NodeRow as BackendNodeRow,\n  rowPropsToObject,\n  type TransactionBackend,\n  type UniqueRow,\n} from \"../../backend/types\";\nimport {\n  checkWherePredicate,\n  computeUniqueKey,\n  getKindsForUniquenessCheck,\n} from \"../../constraints\";\nimport { type GraphDef } from \"../../core/define-graph\";\nimport {\n  type KindEntity,\n  type NodeType,\n  type UniqueConstraint,\n} from \"../../core/types\";\nimport {\n  ConfigurationError,\n  DatabaseOperationError,\n  KindNotFoundError,\n  NodeConstraintNotFoundError,\n  NodeIndexNotFoundError,\n  NodeNotFoundError,\n  UniquenessError,\n  ValidationError,\n} from \"../../errors\";\nimport { validateNodeProps } from \"../../errors/validation\";\nimport {\n  compileIndexWhere,\n  compileNodeIndexFieldKeys,\n  type IndexCompilationContext,\n} from \"../../indexes/compiler\";\nimport { type NodeIndexDeclaration } from \"../../indexes/types\";\nimport { type ValueType } from \"../../query/ast\";\nimport {\n  createSqlSchema,\n  DEFAULT_SQL_SCHEMA,\n  type SqlSchema,\n} from \"../../query/compiler/schema\";\nimport { getDialect } from \"../../query/dialect\";\nimport { type DialectAdapter } from \"../../query/dialect/types\";\nimport { type JsonPointer, resolveJsonPointer } from \"../../query/json-pointer\";\nimport { sql, type SqlFragment } from \"../../query/sql-fragment\";\nimport { asCompiledRowsSql } from \"../../query/sql-intent\";\nimport { type KindRegistry } from \"../../registry/kind-registry\";\nimport { canonicalEqual } from \"../../schema/canonical\";\nimport { validateOptionalCanonicalIsoDate } from \"../../utils/date\";\nimport { generateId } from \"../../utils/id\";\nimport { requireDefined } from \"../../utils/presence\";\nimport { type UpsertDirtyCheck } from \"../collections/coalesce\";\nimport {\n  checkDisjointnessConstraint,\n  type ConstraintContext,\n} from \"../constraints\";\nimport {\n  nodeInsertDispatch,\n  runInsertBatch,\n  runInsertBatchReturning,\n  runInsertNoReturn,\n} from \"../insert-dispatch\";\nimport { getNodeRowsByIds } from \"../node-fetch\";\nimport { type GraphWriteLock } from \"../recorded-capture/clock\";\nimport { type NodeRow, rowToNode } from \"../row-mappers\";\nimport {\n  type CreateNodeInput,\n  type GetOrCreateAction,\n  type Node,\n  type NodeBulkFindByIndexOptions,\n  type NodeGetOrCreateByConstraintOptions,\n  type OperationHookContext,\n  type UpdateNodeInput,\n} from \"../types\";\nimport {\n  checkUniquenessConstraints,\n  createUniquenessContext,\n} from \"../uniqueness\";\nimport {\n  applyNodeHardDelete,\n  applyNodeInsertSideEffects,\n  applyNodeInsertSideEffectsBatch,\n  applyNodeSoftDelete,\n  applyNodeUpdate,\n  createNodeWriteContext,\n} from \"./node-write-pipeline\";\nimport {\n  runHookedWriteOperation,\n  runInWriteTransaction,\n} from \"./write-transaction\";\n\n// ============================================================\n// Types\n// ============================================================\n\nexport type NodeOperationContext<G extends GraphDef> = Readonly<{\n  graph: G;\n  graphId: string;\n  historyEnabled: boolean;\n  revisionTrackingEnabled: boolean;\n  revisionSchema: SqlSchema;\n  registry: KindRegistry;\n  createOperationContext: (\n    operation: \"create\" | \"update\" | \"delete\",\n    entity: KindEntity,\n    kind: string,\n    id: string,\n  ) => OperationHookContext;\n  withOperationHooks: <T>(\n    ctx: OperationHookContext,\n    fn: () => Promise<T>,\n  ) => Promise<T>;\n}>;\n\ntype NodeCreatePrepared = Readonly<{\n  kind: string;\n  id: string;\n  nodeKind: NodeType;\n  validatedProps: Record<string, unknown>;\n  uniqueConstraints: readonly UniqueConstraint[];\n  insertParams: InsertNodeParams;\n}>;\n\ntype CachedNodeRow = Awaited<ReturnType<GraphBackend[\"getNode\"]>>;\ntype CachedUniqueRow = Awaited<ReturnType<GraphBackend[\"checkUnique\"]>>;\n\n// ============================================================\n// Helper Functions\n// ============================================================\n\nfunction getNodeRegistration<G extends GraphDef>(graph: G, kind: string) {\n  const registration = graph.nodes[kind];\n  if (registration === undefined) throw new KindNotFoundError(kind, \"node\");\n  return registration;\n}\n\nconst CACHE_KEY_SEPARATOR = \"\\u0000\";\n\nfunction buildNodeCacheKey(graphId: string, kind: string, id: string): string {\n  return `${graphId}${CACHE_KEY_SEPARATOR}${kind}${CACHE_KEY_SEPARATOR}${id}`;\n}\n\nfunction buildUniqueCacheKey(\n  graphId: string,\n  nodeKind: string,\n  constraintName: string,\n  key: string,\n): string {\n  return `${graphId}${CACHE_KEY_SEPARATOR}${nodeKind}${CACHE_KEY_SEPARATOR}${constraintName}${CACHE_KEY_SEPARATOR}${key}`;\n}\n\nfunction createNodeAlreadyExistsError(\n  kind: string,\n  id: string,\n): ValidationError {\n  return new ValidationError(\n    `Node already exists: ${kind}/${id}`,\n    {\n      entityType: \"node\",\n      kind,\n      operation: \"create\",\n      id,\n      issues: [{ path: \"id\", message: \"A node with this ID already exists\" }],\n    },\n    { suggestion: `Use a different ID or update the existing node.` },\n  );\n}\n\nfunction buildInsertNodeParams(\n  graphId: string,\n  kind: string,\n  id: string,\n  props: Record<string, unknown>,\n  validFrom: string | undefined,\n  validTo: string | undefined,\n): InsertNodeParams {\n  const insertParams: {\n    graphId: string;\n    kind: string;\n    id: string;\n    props: Record<string, unknown>;\n    validFrom?: string;\n    validTo?: string;\n  } = {\n    graphId,\n    kind,\n    id,\n    props,\n  };\n  if (validFrom !== undefined) insertParams.validFrom = validFrom;\n  if (validTo !== undefined) insertParams.validTo = validTo;\n  return insertParams;\n}\n\nfunction createPendingUniqueRow(\n  graphId: string,\n  nodeKind: string,\n  constraintName: string,\n  key: string,\n  nodeId: string,\n): UniqueRow {\n  return {\n    graph_id: graphId,\n    node_kind: nodeKind,\n    constraint_name: constraintName,\n    key,\n    node_id: nodeId,\n    concrete_kind: nodeKind,\n    deleted_at: undefined,\n  };\n}\n\nfunction resolveConstraint<G extends GraphDef>(\n  graph: G,\n  kind: string,\n  constraintName: string,\n): UniqueConstraint {\n  const registration = getNodeRegistration(graph, kind);\n  const constraints = registration.unique ?? [];\n  const constraint = constraints.find(\n    (candidate) => candidate.name === constraintName,\n  );\n  if (constraint === undefined) {\n    throw new NodeConstraintNotFoundError(constraintName, kind);\n  }\n  return constraint;\n}\n\n// ============================================================\n// Batch Validation Cache\n//\n// During batch operations, multiple items may reference the same\n// nodes/unique keys. This cache avoids redundant backend lookups\n// and tracks pending (not-yet-flushed) inserts so that later items\n// in the batch can see earlier ones during validation.\n// ============================================================\n\nexport function createNodeBatchValidationBackend(\n  graphId: string,\n  registry: KindRegistry,\n  backend: GraphBackend | TransactionBackend,\n): Readonly<{\n  backend: GraphBackend | TransactionBackend;\n  registerPendingNode: (params: InsertNodeParams) => void;\n  registerPendingUniqueEntries: (\n    kind: string,\n    id: string,\n    props: Record<string, unknown>,\n    constraints: readonly UniqueConstraint[],\n  ) => void;\n  registerAppliedNodeUpdate: (\n    kind: string,\n    id: string,\n    oldProps: Record<string, unknown>,\n    newProps: Record<string, unknown>,\n    constraints: readonly UniqueConstraint[],\n  ) => void;\n  seedNodeRow: (kind: string, id: string, row: CachedNodeRow) => void;\n  seedUniqueRow: (\n    kind: string,\n    constraintName: string,\n    key: string,\n    row: CachedUniqueRow,\n  ) => void;\n}> {\n  const nodeCache = new Map<string, CachedNodeRow>();\n  const pendingNodes = new Map<string, NonNullable<CachedNodeRow>>();\n  const uniqueCache = new Map<string, CachedUniqueRow>();\n  const pendingUniqueOwners = new Map<string, string>();\n\n  async function getNodeCached(\n    lookupGraphId: string,\n    kind: string,\n    id: string,\n  ): Promise<CachedNodeRow> {\n    const cacheKey = buildNodeCacheKey(lookupGraphId, kind, id);\n    const pendingNode = pendingNodes.get(cacheKey);\n    if (pendingNode !== undefined) return pendingNode;\n    if (nodeCache.has(cacheKey)) return nodeCache.get(cacheKey);\n    const existing = await backend.getNode(lookupGraphId, kind, id);\n    nodeCache.set(cacheKey, existing);\n    return existing;\n  }\n\n  async function checkUniqueCached(\n    params: Parameters<GraphBackend[\"checkUnique\"]>[0],\n  ): Promise<CachedUniqueRow> {\n    const cacheKey = buildUniqueCacheKey(\n      params.graphId,\n      params.nodeKind,\n      params.constraintName,\n      params.key,\n    );\n    const pendingOwner = pendingUniqueOwners.get(cacheKey);\n    if (pendingOwner !== undefined) {\n      return createPendingUniqueRow(\n        params.graphId,\n        params.nodeKind,\n        params.constraintName,\n        params.key,\n        pendingOwner,\n      );\n    }\n    if (uniqueCache.has(cacheKey)) return uniqueCache.get(cacheKey);\n    const existing = await backend.checkUnique(params);\n    uniqueCache.set(cacheKey, existing);\n    return existing;\n  }\n\n  function registerPendingNode(params: InsertNodeParams): void {\n    const cacheKey = buildNodeCacheKey(params.graphId, params.kind, params.id);\n    pendingNodes.set(cacheKey, {\n      graph_id: params.graphId,\n      kind: params.kind,\n      id: params.id,\n      props: JSON.stringify(params.props),\n      version: 1,\n      // The simulated cached row only needs a NodeRow-shaped valid_from\n      // (string | undefined, never null) for existence/uniqueness checks,\n      // which don't inspect its value — normalize import's explicit-NULL\n      // sentinel away rather than widen this cache's row shape.\n      valid_from: params.validFrom ?? undefined,\n      valid_to: params.validTo,\n      created_at: \"\",\n      updated_at: \"\",\n      deleted_at: undefined,\n    });\n  }\n\n  function registerPendingUniqueEntries(\n    kind: string,\n    id: string,\n    props: Record<string, unknown>,\n    constraints: readonly UniqueConstraint[],\n  ): void {\n    for (const constraint of constraints) {\n      if (!checkWherePredicate(constraint, props)) continue;\n\n      const key = computeUniqueKey(\n        props,\n        constraint.fields,\n        constraint.collation,\n      );\n      const concreteEntryKey = buildUniqueCacheKey(\n        graphId,\n        kind,\n        constraint.name,\n        key,\n      );\n      pendingUniqueOwners.set(concreteEntryKey, id);\n\n      if (constraint.scope !== \"kind\") {\n        const kindsToCheck = getKindsForUniquenessCheck(\n          kind,\n          constraint.scope,\n          registry,\n        );\n        for (const kindToCheck of kindsToCheck) {\n          const inheritedEntryKey = buildUniqueCacheKey(\n            graphId,\n            kindToCheck,\n            constraint.name,\n            key,\n          );\n          pendingUniqueOwners.set(inheritedEntryKey, id);\n        }\n      }\n    }\n  }\n\n  // Reflects a completed in-slice node update in the uniqueness caches so a\n  // later row's pre-check sees the post-update reservation state — the state\n  // the sequential path's per-row backend read would observe. The batch path\n  // primes the caches ONCE before routing, but an in-slice update mutates the\n  // real backend's uniqueness rows directly; without reconciling here a later\n  // create either (a) claims a value this update just freed yet gets rejected\n  // against the stale reservation, or (b) passes the stale \"free\" cache for a\n  // value this update just took and then violates the real constraint at\n  // flush, aborting the whole import. Mirrors updateUniquenessEntries' key\n  // diff: for each constraint whose key changed, the released old key becomes\n  // free and the reserved new key becomes owned by this node, across every\n  // kind the constraint's scope checks.\n  function registerAppliedNodeUpdate(\n    kind: string,\n    id: string,\n    oldProps: Record<string, unknown>,\n    newProps: Record<string, unknown>,\n    constraints: readonly UniqueConstraint[],\n  ): void {\n    for (const constraint of constraints) {\n      const oldApplies = checkWherePredicate(constraint, oldProps);\n      const newApplies = checkWherePredicate(constraint, newProps);\n      const oldKey =\n        oldApplies ?\n          computeUniqueKey(oldProps, constraint.fields, constraint.collation)\n        : undefined;\n      const newKey =\n        newApplies ?\n          computeUniqueKey(newProps, constraint.fields, constraint.collation)\n        : undefined;\n      if (oldKey === newKey) continue;\n\n      const kindsToCheck = getKindsForUniquenessCheck(\n        kind,\n        constraint.scope,\n        registry,\n      );\n\n      if (oldKey !== undefined) {\n        for (const kindToCheck of kindsToCheck) {\n          const cacheKey = buildUniqueCacheKey(\n            graphId,\n            kindToCheck,\n            constraint.name,\n            oldKey,\n          );\n          // This node released the key on the real backend, so it is now\n          // free. Clear any pending reservation and record the known-free\n          // state (overwriting a stale seeded owner) so a later create's\n          // pre-check sees a vacancy instead of a redundant backend read.\n          pendingUniqueOwners.delete(cacheKey);\n          uniqueCache.set(cacheKey, undefined);\n        }\n      }\n      if (newKey !== undefined) {\n        for (const kindToCheck of kindsToCheck) {\n          const cacheKey = buildUniqueCacheKey(\n            graphId,\n            kindToCheck,\n            constraint.name,\n            newKey,\n          );\n          // This node now holds the key on the real backend. A pending owner\n          // shadows the seeded uniqueCache entry (checkUniqueCached consults\n          // it first), matching registerPendingUniqueEntries' reservation.\n          pendingUniqueOwners.set(cacheKey, id);\n        }\n      }\n    }\n  }\n\n  // Seed functions let batch preparation prime the caches from one\n  // getNodes / checkUniqueBatch round trip instead of a per-row probe.\n  // Seeding an absent result (`undefined`) is meaningful — it marks the\n  // key as known-missing so the per-row check skips the backend read.\n  // Existing entries are never overwritten: a pending registration or an\n  // earlier lookup always wins.\n  function seedNodeRow(kind: string, id: string, row: CachedNodeRow): void {\n    const cacheKey = buildNodeCacheKey(graphId, kind, id);\n    if (nodeCache.has(cacheKey)) return;\n    nodeCache.set(cacheKey, row);\n  }\n\n  function seedUniqueRow(\n    kind: string,\n    constraintName: string,\n    key: string,\n    row: CachedUniqueRow,\n  ): void {\n    const cacheKey = buildUniqueCacheKey(graphId, kind, constraintName, key);\n    if (uniqueCache.has(cacheKey)) return;\n    uniqueCache.set(cacheKey, row);\n  }\n\n  const validationBackend = createBackendOverlay(backend, {\n    getNode: getNodeCached,\n    checkUnique: checkUniqueCached,\n  } satisfies Partial<GraphBackend | TransactionBackend>);\n\n  return {\n    backend: validationBackend,\n    registerPendingNode,\n    registerPendingUniqueEntries,\n    registerAppliedNodeUpdate,\n    seedNodeRow,\n    seedUniqueRow,\n  };\n}\n\n// ============================================================\n// Shared Create Pipeline\n// ============================================================\n\n/**\n * The synchronous half of create preparation: kind resolution, Zod\n * validation, and date validation. Produces everything the async\n * constraint checks need, so batch preparation can validate every input\n * first and then prime the validation caches with batched reads before\n * running {@link finishNodeCreatePreparation} per row.\n */\n/**\n * Internal create options threaded from operations that validated props\n * BEFORE calling into the create path. Never exposed on the public store\n * surface.\n */\ntype NodeCreateInternalOptions = Readonly<{\n  /** `input.props` is already the output of `validateNodeProps`. */\n  propsPreValidated?: boolean;\n}>;\n\nexport type NodeCreateDraft = Readonly<{\n  kind: string;\n  id: string;\n  nodeKind: NodeType;\n  uniqueConstraints: readonly UniqueConstraint[];\n  validatedProps: Record<string, unknown>;\n  validFrom: string | undefined;\n  validTo: string | undefined;\n}>;\n\nfunction draftNodeCreate<G extends GraphDef>(\n  ctx: NodeOperationContext<G>,\n  input: CreateNodeInput,\n  id: string,\n  options?: NodeCreateInternalOptions,\n): NodeCreateDraft {\n  const kind = input.kind;\n  const registration = getNodeRegistration(ctx.graph, kind);\n  const nodeKind = registration.type;\n\n  // getOrCreate / findByConstraint variants validate props up front (the\n  // key computation needs the PARSED shape), then hand the validated\n  // object here — re-running the full Zod parse on it would double the\n  // validation cost of every create leg for no additional safety (hooks\n  // wrap the transaction and cannot transform inputs in between).\n  const validatedProps =\n    options?.propsPreValidated === true ?\n      input.props\n    : validateNodeProps(nodeKind.schema, input.props, {\n        kind,\n        operation: \"create\",\n      });\n\n  return {\n    kind,\n    id,\n    nodeKind,\n    uniqueConstraints: registration.unique ?? [],\n    validatedProps,\n    validFrom: validateOptionalCanonicalIsoDate(input.validFrom, \"validFrom\"),\n    validTo: validateOptionalCanonicalIsoDate(input.validTo, \"validTo\"),\n  };\n}\n\n/** The async half: existence, disjointness, and uniqueness checks. */\nasync function finishNodeCreatePreparation<G extends GraphDef>(\n  ctx: NodeOperationContext<G>,\n  draft: NodeCreateDraft,\n  backend: GraphBackend | TransactionBackend,\n): Promise<NodeCreatePrepared> {\n  const { kind, id, validatedProps, uniqueConstraints } = draft;\n\n  const existingNode = await backend.getNode(ctx.graphId, kind, id);\n  if (existingNode && !existingNode.deleted_at) {\n    throw createNodeAlreadyExistsError(kind, id);\n  }\n\n  const constraintContext: ConstraintContext = {\n    graphId: ctx.graphId,\n    registry: ctx.registry,\n    backend,\n  };\n  await checkDisjointnessConstraint(constraintContext, kind, id);\n\n  await checkUniquenessConstraints(\n    createUniquenessContext(ctx.graphId, ctx.registry, backend),\n    kind,\n    id,\n    validatedProps,\n    uniqueConstraints,\n  );\n\n  return {\n    kind,\n    id,\n    nodeKind: draft.nodeKind,\n    validatedProps,\n    uniqueConstraints,\n    insertParams: buildInsertNodeParams(\n      ctx.graphId,\n      kind,\n      id,\n      validatedProps,\n      draft.validFrom,\n      draft.validTo,\n    ),\n  };\n}\n\nasync function validateAndPrepareNodeCreate<G extends GraphDef>(\n  ctx: NodeOperationContext<G>,\n  input: CreateNodeInput,\n  id: string,\n  backend: GraphBackend | TransactionBackend,\n  options?: NodeCreateInternalOptions,\n): Promise<NodeCreatePrepared> {\n  return finishNodeCreatePreparation(\n    ctx,\n    draftNodeCreate(ctx, input, id, options),\n    backend,\n  );\n}\n\n/**\n * Batched {@link finalizeNodeCreate}: applies every prepared create's\n * side effects through the batch pipeline (one uniqueness batch, one\n * fulltext/embedding batch per kind) instead of a per-row statement fan.\n */\nasync function finalizeNodeCreateBatch<G extends GraphDef>(\n  ctx: NodeOperationContext<G>,\n  preparedCreates: readonly NodeCreatePrepared[],\n  backend: GraphBackend | TransactionBackend,\n  lock: GraphWriteLock,\n): Promise<void> {\n  await applyNodeInsertSideEffectsBatch(\n    createNodeWriteContext(ctx.graphId, ctx.registry, lock),\n    preparedCreates.map((prepared) => ({\n      kind: prepared.kind,\n      id: prepared.id,\n      schema: prepared.nodeKind.schema,\n      props: prepared.validatedProps,\n      uniqueConstraints: prepared.uniqueConstraints,\n    })),\n    backend,\n  );\n}\n\nasync function finalizeNodeCreate<G extends GraphDef>(\n  ctx: NodeOperationContext<G>,\n  prepared: NodeCreatePrepared,\n  backend: GraphBackend | TransactionBackend,\n  lock: GraphWriteLock,\n): Promise<void> {\n  await applyNodeInsertSideEffects(\n    createNodeWriteContext(ctx.graphId, ctx.registry, lock),\n    {\n      kind: prepared.kind,\n      id: prepared.id,\n      schema: prepared.nodeKind.schema,\n      props: prepared.validatedProps,\n      uniqueConstraints: prepared.uniqueConstraints,\n    },\n    backend,\n  );\n}\n\n// ============================================================\n// Shared Update Pipeline\n//\n// executeNodeUpdate wraps this in operation hooks.\n// executeNodeUpsertUpdate calls it directly (no hooks) for\n// getOrCreate resurrections.\n// ============================================================\n\n/**\n * The exact props an update would persist: the caller's partial input merged\n * over the current props and run through the kind's Zod schema (defaults\n * applied, values normalized). Also returns the resolved registration so\n * callers need not look it up again. Operates on PARSED props so both the write\n * path (which parses the row) and the coalesce dirty-check (which may compare\n * against a batch-local running value, never a row) share one validation.\n */\nfunction computeNodeUpdate<G extends GraphDef>(\n  ctx: NodeOperationContext<G>,\n  kind: string,\n  id: string,\n  existingProps: Record<string, unknown>,\n  inputProps: Partial<Record<string, unknown>>,\n) {\n  const registration = getNodeRegistration(ctx.graph, kind);\n  const validatedProps = validateNodeProps(\n    registration.type.schema,\n    { ...existingProps, ...inputProps },\n    { kind, operation: \"update\", id },\n  );\n  return { registration, validatedProps };\n}\n\n/**\n * Row-based wrapper over {@link computeNodeUpdate} for the write path. Reads the\n * kind/id off the row (a `getNode(kind, id)` result always carries the\n * requested kind), matching {@link resolveEdgeUpdateProps}.\n */\nfunction resolveNodeUpdateProps<G extends GraphDef>(\n  ctx: NodeOperationContext<G>,\n  existing: Pick<NodeRow, \"kind\" | \"id\" | \"props\">,\n  inputProps: Partial<Record<string, unknown>>,\n) {\n  const existingProps = rowPropsToObject(existing.props);\n  const { registration, validatedProps } = computeNodeUpdate(\n    ctx,\n    existing.kind,\n    existing.id,\n    existingProps,\n    inputProps,\n  );\n  return { registration, existingProps, validatedProps };\n}\n\n/**\n * The coalesce dirty-check: returns the props an `upsertById` would persist and\n * whether they equal `existingProps` (so the write can be skipped). Compares on\n * the storage-normalized representation (validated, key-order-independent), so\n * it answers exactly \"would the persisted JSON differ?\". `existingProps` is the\n * PARSED current props — the row's, or the batch-local running value for a\n * repeated id in `bulkUpsertById`.\n */\nexport function nodeUpsertDirtyCheck<G extends GraphDef>(\n  ctx: NodeOperationContext<G>,\n  kind: string,\n  id: string,\n  existingProps: Record<string, unknown>,\n  inputProps: Record<string, unknown>,\n): UpsertDirtyCheck {\n  const { validatedProps } = computeNodeUpdate(\n    ctx,\n    kind,\n    id,\n    existingProps,\n    inputProps,\n  );\n  return {\n    validatedProps,\n    unchanged: canonicalEqual(validatedProps, existingProps),\n  };\n}\n\nasync function performNodeUpdate<G extends GraphDef>(\n  ctx: NodeOperationContext<G>,\n  input: UpdateNodeInput,\n  backend: GraphBackend | TransactionBackend,\n  lock: GraphWriteLock,\n  options?: Readonly<{ clearDeleted?: boolean }>,\n): Promise<Node> {\n  const { kind, id } = input;\n\n  const existing = await backend.getNode(ctx.graphId, kind, id);\n  if (!existing) throw new NodeNotFoundError(kind, id);\n\n  const { registration, validatedProps } = resolveNodeUpdateProps(\n    ctx,\n    existing,\n    input.props,\n  );\n  const nodeKind = registration.type;\n\n  const validTo = validateOptionalCanonicalIsoDate(input.validTo, \"validTo\");\n\n  const writeContext = createNodeWriteContext(ctx.graphId, ctx.registry, lock);\n  const shared = {\n    schema: nodeKind.schema,\n    validatedProps,\n    uniqueConstraints: registration.unique ?? [],\n    ...(validTo !== undefined && { validTo }),\n  };\n\n  // A resurrecting upsert (clearDeleted) may target a tombstoned row; a plain\n  // update must prove the row live — see NodeUpdateTarget.\n  if (options?.clearDeleted) {\n    const row = await applyNodeUpdate(\n      writeContext,\n      { ...shared, existing, clearDeleted: true },\n      backend,\n    );\n    return rowToNode(row);\n  }\n\n  if (!isLiveNodeRow(existing)) throw new NodeNotFoundError(kind, id);\n  const row = await applyNodeUpdate(\n    writeContext,\n    { ...shared, existing },\n    backend,\n  );\n  return rowToNode(row);\n}\n\n// ============================================================\n// Shared Batch Preparation\n//\n// Both returning and non-returning batch creates share the same\n// validate-and-register loop. This extracts it.\n// ============================================================\n\n/**\n * Primes the batch validation caches with batched reads: one `getNodes`\n * per kind for existence probes and one `checkUniqueBatch` per\n * (constraint, kind) for uniqueness pre-checks. The per-row checks in\n * {@link finishNodeCreatePreparation} then hit memory instead of issuing\n * one probe per row. Backends without the batch primitives skip priming\n * and keep the per-row fallback.\n */\nexport async function primeBatchValidationCaches(\n  ctx: Readonly<{ graphId: string; registry: KindRegistry }>,\n  drafts: readonly NodeCreateDraft[],\n  backend: GraphBackend | TransactionBackend,\n  seams: Readonly<{\n    seedNodeRow: (kind: string, id: string, row: CachedNodeRow) => void;\n    seedUniqueRow: (\n      kind: string,\n      constraintName: string,\n      key: string,\n      row: CachedUniqueRow,\n    ) => void;\n  }>,\n): Promise<void> {\n  if (backend.getNodes !== undefined) {\n    const idsByKind = new Map<string, Set<string>>();\n    for (const draft of drafts) {\n      const ids = idsByKind.get(draft.kind) ?? new Set<string>();\n      ids.add(draft.id);\n      idsByKind.set(draft.kind, ids);\n    }\n    for (const [kind, ids] of idsByKind) {\n      const orderedIds = [...ids];\n      const rows = await backend.getNodes(ctx.graphId, kind, orderedIds);\n      const rowsById = new Map(rows.map((row) => [row.id, row]));\n      for (const id of orderedIds) {\n        seams.seedNodeRow(kind, id, rowsById.get(id));\n      }\n    }\n  }\n\n  if (backend.checkUniqueBatch !== undefined) {\n    interface ProbeGroup {\n      nodeKind: string;\n      constraintName: string;\n      keys: Set<string>;\n    }\n    const groups = new Map<string, ProbeGroup>();\n    for (const draft of drafts) {\n      for (const constraint of draft.uniqueConstraints) {\n        if (!checkWherePredicate(constraint, draft.validatedProps)) continue;\n        const key = computeUniqueKey(\n          draft.validatedProps,\n          constraint.fields,\n          constraint.collation,\n        );\n        const kindsToCheck = getKindsForUniquenessCheck(\n          draft.kind,\n          constraint.scope,\n          ctx.registry,\n        );\n        for (const kindToCheck of kindsToCheck) {\n          const groupKey = kindToCheck + CACHE_KEY_SEPARATOR + constraint.name;\n          const group = groups.get(groupKey) ?? {\n            nodeKind: kindToCheck,\n            constraintName: constraint.name,\n            keys: new Set<string>(),\n          };\n          group.keys.add(key);\n          groups.set(groupKey, group);\n        }\n      }\n    }\n    for (const group of groups.values()) {\n      const orderedKeys = [...group.keys];\n      const rows = await backend.checkUniqueBatch({\n        graphId: ctx.graphId,\n        nodeKind: group.nodeKind,\n        constraintName: group.constraintName,\n        keys: orderedKeys,\n      });\n      const rowsByKey = new Map(rows.map((row) => [row.key, row]));\n      for (const key of orderedKeys) {\n        seams.seedUniqueRow(\n          group.nodeKind,\n          group.constraintName,\n          key,\n          rowsByKey.get(key),\n        );\n      }\n    }\n  }\n}\n\nasync function prepareBatchCreates<G extends GraphDef>(\n  ctx: NodeOperationContext<G>,\n  inputs: readonly CreateNodeInput[],\n  backend: GraphBackend | TransactionBackend,\n  options?: NodeCreateInternalOptions,\n): Promise<{\n  preparedCreates: NodeCreatePrepared[];\n  batchInsertParams: InsertNodeParams[];\n}> {\n  const {\n    backend: validationBackend,\n    registerPendingNode,\n    registerPendingUniqueEntries,\n    seedNodeRow,\n    seedUniqueRow,\n  } = createNodeBatchValidationBackend(ctx.graphId, ctx.registry, backend);\n\n  // Pass 1 (synchronous): validate every input and assign ids. This\n  // surfaces a later row's validation error before an earlier row's\n  // constraint error — both fail the whole batch, so ordering across\n  // error categories is not part of the contract.\n  const drafts = inputs.map((input) =>\n    draftNodeCreate(ctx, input, input.id ?? generateId(), options),\n  );\n\n  await primeBatchValidationCaches(ctx, drafts, backend, {\n    seedNodeRow,\n    seedUniqueRow,\n  });\n\n  // Pass 2: per-row constraint checks against the primed caches, in input\n  // order, registering pendings so later rows see earlier ones.\n  const preparedCreates: NodeCreatePrepared[] = [];\n  for (const draft of drafts) {\n    const prepared = await finishNodeCreatePreparation(\n      ctx,\n      draft,\n      validationBackend,\n    );\n    preparedCreates.push(prepared);\n    registerPendingNode(prepared.insertParams);\n    registerPendingUniqueEntries(\n      prepared.kind,\n      prepared.id,\n      prepared.validatedProps,\n      prepared.uniqueConstraints,\n    );\n  }\n\n  const batchInsertParams = preparedCreates.map(\n    (prepared) => prepared.insertParams,\n  );\n\n  return { preparedCreates, batchInsertParams };\n}\n\n// ============================================================\n// Shared Constraint Lookup\n//\n// Both single and bulk find/getOrCreate operations need to look up\n// unique constraint entries across all applicable kinds.\n// ============================================================\n\nasync function findUniqueRowAcrossKinds(\n  backend: GraphBackend | TransactionBackend,\n  graphId: string,\n  constraintName: string,\n  key: string,\n  kindsToCheck: readonly string[],\n  includeDeleted: boolean,\n): Promise<\n  | { node_id: string; concrete_kind: string; deleted_at: string | undefined }\n  | undefined\n> {\n  for (const kindToCheck of kindsToCheck) {\n    const row = await backend.checkUnique({\n      graphId,\n      nodeKind: kindToCheck,\n      constraintName,\n      key,\n      includeDeleted,\n    });\n    if (row !== undefined) return row;\n  }\n  return undefined;\n}\n\ninterface UniqueMatchRow {\n  node_id: string;\n  concrete_kind: string;\n  deleted_at: string | undefined;\n}\n\nasync function batchCheckUniqueAcrossKinds(\n  backend: GraphBackend | TransactionBackend,\n  graphId: string,\n  constraintName: string,\n  uniqueKeys: readonly string[],\n  kindsToCheck: readonly string[],\n  includeDeleted: boolean,\n): Promise<Map<string, UniqueMatchRow>> {\n  const existingByKey = new Map<string, UniqueMatchRow>();\n\n  for (const kindToCheck of kindsToCheck) {\n    if (backend.checkUniqueBatch === undefined) {\n      for (const key of uniqueKeys) {\n        if (existingByKey.has(key)) continue;\n        const row = await backend.checkUnique({\n          graphId,\n          nodeKind: kindToCheck,\n          constraintName,\n          key,\n          includeDeleted,\n        });\n        if (row !== undefined) {\n          existingByKey.set(row.key, row);\n        }\n      }\n    } else {\n      const rows = await backend.checkUniqueBatch({\n        graphId,\n        nodeKind: kindToCheck,\n        constraintName,\n        keys: uniqueKeys,\n        includeDeleted,\n      });\n      for (const row of rows) {\n        if (!existingByKey.has(row.key)) {\n          existingByKey.set(row.key, row);\n        }\n      }\n    }\n  }\n\n  return existingByKey;\n}\n\n// ============================================================\n// Node Create Operations\n// ============================================================\n\nasync function executeNodeCreateInternal<G extends GraphDef>(\n  ctx: NodeOperationContext<G>,\n  input: CreateNodeInput,\n  backend: GraphBackend | TransactionBackend,\n  options?: Readonly<{ returnRow?: boolean }> & NodeCreateInternalOptions,\n): Promise<Node | undefined> {\n  const kind = input.kind;\n  const id = input.id ?? generateId();\n  const opContext = ctx.createOperationContext(\"create\", \"node\", kind, id);\n  const shouldReturnRow = options?.returnRow ?? true;\n\n  return runHookedWriteOperation(\n    ctx,\n    opContext,\n    backend,\n    async (target, lock) => {\n      const prepared = await validateAndPrepareNodeCreate(\n        ctx,\n        input,\n        id,\n        target,\n        options,\n      );\n\n      let row: BackendNodeRow | undefined;\n      if (shouldReturnRow) {\n        row = await target.insertNode(prepared.insertParams);\n      } else {\n        await runInsertNoReturn(\n          nodeInsertDispatch(target),\n          prepared.insertParams,\n        );\n      }\n\n      await finalizeNodeCreate(ctx, prepared, target, lock);\n\n      if (row === undefined) return;\n      return rowToNode(row);\n    },\n  );\n}\n\nexport async function executeNodeCreate<G extends GraphDef>(\n  ctx: NodeOperationContext<G>,\n  input: CreateNodeInput,\n  backend: GraphBackend | TransactionBackend,\n  options?: NodeCreateInternalOptions,\n): Promise<Node> {\n  const result = await executeNodeCreateInternal(ctx, input, backend, {\n    returnRow: true,\n    ...options,\n  });\n  if (!result) {\n    throw new DatabaseOperationError(\n      \"Node create failed: expected created node row\",\n      { operation: \"insert\", entity: \"node\" },\n    );\n  }\n  return result;\n}\n\nexport async function executeNodeCreateNoReturn<G extends GraphDef>(\n  ctx: NodeOperationContext<G>,\n  input: CreateNodeInput,\n  backend: GraphBackend | TransactionBackend,\n): Promise<void> {\n  await executeNodeCreateInternal(ctx, input, backend, { returnRow: false });\n}\n\n/**\n * Executes batched node creates without returning inserted node payloads.\n *\n * Note: `withOperationHooks` is intentionally skipped for batch throughput.\n * Per-item hooks would negate the performance benefit of batching.\n */\nexport async function executeNodeCreateNoReturnBatch<G extends GraphDef>(\n  ctx: NodeOperationContext<G>,\n  inputs: readonly CreateNodeInput[],\n  backend: GraphBackend | TransactionBackend,\n): Promise<void> {\n  if (inputs.length === 0) return;\n\n  await runInWriteTransaction(ctx, backend, async (target, lock) => {\n    const { preparedCreates, batchInsertParams } = await prepareBatchCreates(\n      ctx,\n      inputs,\n      target,\n    );\n\n    await runInsertBatch(nodeInsertDispatch(target), batchInsertParams);\n\n    await finalizeNodeCreateBatch(ctx, preparedCreates, target, lock);\n  });\n}\n\n/**\n * Executes batched node creates and returns the inserted node payloads.\n *\n * Uses batch validation caching and a single multi-row INSERT with RETURNING\n * when the backend supports it. Falls back to sequential inserts otherwise.\n *\n * Note: `withOperationHooks` is intentionally skipped for batch throughput.\n * Per-item hooks would negate the performance benefit of batching.\n */\nexport async function executeNodeCreateBatch<G extends GraphDef>(\n  ctx: NodeOperationContext<G>,\n  inputs: readonly CreateNodeInput[],\n  backend: GraphBackend | TransactionBackend,\n  options?: NodeCreateInternalOptions,\n): Promise<readonly Node[]> {\n  if (inputs.length === 0) return [];\n\n  return runInWriteTransaction(ctx, backend, async (target, lock) => {\n    const { preparedCreates, batchInsertParams } = await prepareBatchCreates(\n      ctx,\n      inputs,\n      target,\n      options,\n    );\n\n    const rows = await runInsertBatchReturning(\n      nodeInsertDispatch(target),\n      batchInsertParams,\n    );\n\n    await finalizeNodeCreateBatch(ctx, preparedCreates, target, lock);\n\n    return rows.map((row) => rowToNode(row));\n  });\n}\n\n// ============================================================\n// Node Update Operations\n// ============================================================\n\nexport async function executeNodeUpdate<G extends GraphDef>(\n  ctx: NodeOperationContext<G>,\n  input: UpdateNodeInput,\n  backend: GraphBackend | TransactionBackend,\n  options?: Readonly<{ clearDeleted?: boolean }>,\n): Promise<Node> {\n  const opContext = ctx.createOperationContext(\n    \"update\",\n    \"node\",\n    input.kind,\n    input.id,\n  );\n  return runHookedWriteOperation(ctx, opContext, backend, (target, lock) =>\n    performNodeUpdate(ctx, input, target, lock, options),\n  );\n}\n\n/**\n * Executes a node update for upsert — bypasses operation hooks\n * and allows updating soft-deleted nodes when clearDeleted is set.\n */\nexport async function executeNodeUpsertUpdate<G extends GraphDef>(\n  ctx: NodeOperationContext<G>,\n  input: UpdateNodeInput,\n  backend: GraphBackend | TransactionBackend,\n  options?: Readonly<{ clearDeleted?: boolean }>,\n): Promise<Node> {\n  return runInWriteTransaction(ctx, backend, (target, lock) =>\n    performNodeUpdate(ctx, input, target, lock, options),\n  );\n}\n\n// ============================================================\n// Node Delete Operations\n// ============================================================\n\nexport async function executeNodeDelete<G extends GraphDef>(\n  ctx: NodeOperationContext<G>,\n  kind: string,\n  id: string,\n  backend: GraphBackend | TransactionBackend,\n): Promise<void> {\n  // Gate outside hooks and transaction (matching edge deletes): an absent or\n  // already-tombstoned node is a no-op, so it neither fires hooks nor opens a\n  // write transaction (empty transactions are costly on libsql). The cascade\n  // re-reads inside the transaction, so a node concurrently deleted between\n  // this gate and the write lock is still handled correctly.\n  const gate = await backend.getNode(ctx.graphId, kind, id);\n  if (!gate || gate.deleted_at) return;\n\n  const opContext = ctx.createOperationContext(\"delete\", \"node\", kind, id);\n\n  return runHookedWriteOperation(\n    ctx,\n    opContext,\n    backend,\n    async (target, lock) => {\n      const registration = getNodeRegistration(ctx.graph, kind);\n      // This preflight is NOT removable round-trip fat: the soft-delete\n      // pipeline consumes the pre-image (uniqueness entries are keyed by\n      // props-derived constraint keys), and this in-transaction read is\n      // the concurrency-correct source for it.\n      const preflight = await target.getNode(ctx.graphId, kind, id);\n      if (!preflight || !isLiveNodeRow(preflight)) return;\n\n      // The cascade (connected edges, uniques, embeddings, fulltext, node) is\n      // not individually atomic, so it runs in one write transaction. Under\n      // recorded-time capture this also collapses the cascade into a single\n      // recorded commit instant instead of one instant per sub-write.\n      await applyNodeSoftDelete(\n        createNodeWriteContext(ctx.graphId, ctx.registry, lock),\n        {\n          existing: preflight,\n          schema: registration.type.schema,\n          uniqueConstraints: registration.unique ?? [],\n          onDelete: registration.onDelete,\n        },\n        target,\n      );\n    },\n  );\n}\n\n/**\n * Executes a node hard delete operation (permanent removal).\n *\n * Unlike soft delete, this permanently removes the node and all\n * associated data (uniqueness entries, embeddings) from the database.\n */\nexport async function executeNodeHardDelete<G extends GraphDef>(\n  ctx: NodeOperationContext<G>,\n  kind: string,\n  id: string,\n  backend: GraphBackend | TransactionBackend,\n): Promise<void> {\n  // Gate outside hooks and transaction so an absent node neither fires hooks\n  // nor opens an empty transaction (see executeNodeDelete). The cascade\n  // re-reads inside the transaction.\n  const gate = await backend.getNode(ctx.graphId, kind, id);\n  if (!gate) return;\n\n  const opContext = ctx.createOperationContext(\"delete\", \"node\", kind, id);\n\n  return runHookedWriteOperation(\n    ctx,\n    opContext,\n    backend,\n    async (target, lock) => {\n      const registration = getNodeRegistration(ctx.graph, kind);\n      // No in-transaction preflight (unlike soft delete, whose pipeline\n      // consumes the pre-image for uniqueness-key cleanup): every hard\n      // cascade member is id-keyed and idempotent — the delete-behavior\n      // check re-reads edges itself, `hardDeleteNode` deletes by primary\n      // key, and embeddings clean up by id — so a node concurrently\n      // removed between the gate and the write lock makes each statement\n      // a 0-row no-op.\n\n      // The cascade (edges, node, embeddings) is not individually atomic, so\n      // it runs in one write transaction. Embeddings live in strategy-owned\n      // per-`(kind, field)` tables, so they are cleaned up here rather than\n      // in the backend's graph-agnostic `hardDeleteNode` cascade.\n      await applyNodeHardDelete(\n        createNodeWriteContext(ctx.graphId, ctx.registry, lock),\n        {\n          kind,\n          id,\n          schema: registration.type.schema,\n          onDelete: registration.onDelete,\n        },\n        target,\n      );\n    },\n  );\n}\n\n// ============================================================\n// Get-Or-Create Operations\n// ============================================================\n\nexport async function executeNodeGetOrCreateByConstraint<G extends GraphDef>(\n  ctx: NodeOperationContext<G>,\n  kind: string,\n  constraintName: string,\n  props: Record<string, unknown>,\n  backend: GraphBackend | TransactionBackend,\n  options?: NodeGetOrCreateByConstraintOptions,\n): Promise<Readonly<{ node: Node; action: GetOrCreateAction }>> {\n  const ifExists = options?.ifExists ?? \"return\";\n\n  const registration = getNodeRegistration(ctx.graph, kind);\n  const nodeKind = registration.type;\n  const validatedProps = validateNodeProps(nodeKind.schema, props, {\n    kind,\n    operation: \"create\",\n  });\n\n  const constraint = resolveConstraint(ctx.graph, kind, constraintName);\n\n  if (!checkWherePredicate(constraint, validatedProps)) {\n    const node = await executeNodeCreate(\n      ctx,\n      { kind, props: validatedProps },\n      backend,\n      { propsPreValidated: true },\n    );\n    return { node, action: \"created\" };\n  }\n\n  const key = computeUniqueKey(\n    validatedProps,\n    constraint.fields,\n    constraint.collation,\n  );\n\n  const kindsToCheck = getKindsForUniquenessCheck(\n    kind,\n    constraint.scope,\n    ctx.registry,\n  );\n\n  // The probe runs outside any transaction (the found path is a pure read),\n  // and each write leg opens its own hooked transaction. A concurrent create\n  // can therefore reserve the key between the probe and the create — that\n  // surfaces as UniquenessError, and the caller retries the probe once to\n  // converge on the row the winner created.\n  async function attempt(): Promise<\n    Readonly<{ node: Node; action: GetOrCreateAction }>\n  > {\n    const existingUniqueRow = await findUniqueRowAcrossKinds(\n      backend,\n      ctx.graphId,\n      constraint.name,\n      key,\n      kindsToCheck,\n      true,\n    );\n\n    if (existingUniqueRow === undefined) {\n      const node = await executeNodeCreate(\n        ctx,\n        { kind, props: validatedProps },\n        backend,\n        { propsPreValidated: true },\n      );\n      return { node, action: \"created\" };\n    }\n\n    // Fetch using concrete_kind (may differ from requested kind\n    // when scope is \"kindWithSubClasses\" and the match is on a sibling/parent kind)\n    const existingRow = await backend.getNode(\n      ctx.graphId,\n      existingUniqueRow.concrete_kind,\n      existingUniqueRow.node_id,\n    );\n\n    if (existingRow === undefined) {\n      const node = await executeNodeCreate(\n        ctx,\n        { kind, props: validatedProps },\n        backend,\n        { propsPreValidated: true },\n      );\n      return { node, action: \"created\" };\n    }\n\n    const isSoftDeleted = existingRow.deleted_at !== undefined;\n\n    if (isSoftDeleted || ifExists === \"update\") {\n      const concreteKind = existingUniqueRow.concrete_kind;\n      const node = await executeNodeUpsertUpdate(\n        ctx,\n        {\n          kind: concreteKind,\n          id: existingRow.id as UpdateNodeInput[\"id\"],\n          props: validatedProps,\n        },\n        backend,\n        { clearDeleted: isSoftDeleted },\n      );\n      return { node, action: isSoftDeleted ? \"resurrected\" : \"updated\" };\n    }\n\n    return { node: rowToNode(existingRow), action: \"found\" };\n  }\n\n  try {\n    return await attempt();\n  } catch (error) {\n    if (!(error instanceof UniquenessError)) throw error;\n    return attempt();\n  }\n}\n\n// ============================================================\n// Find-By-Constraint Operations\n// ============================================================\n\nexport async function executeNodeFindByConstraint<G extends GraphDef>(\n  ctx: NodeOperationContext<G>,\n  kind: string,\n  constraintName: string,\n  props: Record<string, unknown>,\n  backend: GraphBackend | TransactionBackend,\n): Promise<Node | undefined> {\n  const registration = getNodeRegistration(ctx.graph, kind);\n  const nodeKind = registration.type;\n  const validatedProps = validateNodeProps(nodeKind.schema, props, {\n    kind,\n    operation: \"create\",\n  });\n\n  const constraint = resolveConstraint(ctx.graph, kind, constraintName);\n  if (!checkWherePredicate(constraint, validatedProps)) return undefined;\n\n  const key = computeUniqueKey(\n    validatedProps,\n    constraint.fields,\n    constraint.collation,\n  );\n\n  const kindsToCheck = getKindsForUniquenessCheck(\n    kind,\n    constraint.scope,\n    ctx.registry,\n  );\n\n  const existingUniqueRow = await findUniqueRowAcrossKinds(\n    backend,\n    ctx.graphId,\n    constraint.name,\n    key,\n    kindsToCheck,\n    false,\n  );\n\n  if (existingUniqueRow === undefined) return undefined;\n\n  const existingRow = await backend.getNode(\n    ctx.graphId,\n    existingUniqueRow.concrete_kind,\n    existingUniqueRow.node_id,\n  );\n\n  if (existingRow === undefined || existingRow.deleted_at !== undefined)\n    return undefined;\n\n  return rowToNode(existingRow);\n}\n\n// ============================================================\n// Bulk Find-By-Constraint\n// ============================================================\n\n/**\n * Validates all items and computes unique constraint keys.\n * Shared by both bulk find and bulk getOrCreate.\n */\nfunction validateAndComputeKeys(\n  nodeKind: NodeType,\n  kind: string,\n  constraint: UniqueConstraint,\n  items: readonly Readonly<{ props: Record<string, unknown> }>[],\n): { validatedProps: Record<string, unknown>; key: string | undefined }[] {\n  const validated: {\n    validatedProps: Record<string, unknown>;\n    key: string | undefined;\n  }[] = [];\n\n  for (const item of items) {\n    const validatedProps = validateNodeProps(nodeKind.schema, item.props, {\n      kind,\n      operation: \"create\",\n    });\n    const applies = checkWherePredicate(constraint, validatedProps);\n    const key =\n      applies ?\n        computeUniqueKey(\n          validatedProps,\n          constraint.fields,\n          constraint.collation,\n        )\n      : undefined;\n    validated.push({ validatedProps, key });\n  }\n\n  return validated;\n}\n\nfunction collectUniqueKeys(\n  validated: readonly { key: string | undefined }[],\n): string[] {\n  return [\n    ...new Set(\n      validated\n        .map((entry) => entry.key)\n        .filter((key): key is string => key !== undefined),\n    ),\n  ];\n}\n\nexport async function executeNodeBulkFindByConstraint<G extends GraphDef>(\n  ctx: NodeOperationContext<G>,\n  kind: string,\n  constraintName: string,\n  items: readonly Readonly<{ props: Record<string, unknown> }>[],\n  backend: GraphBackend | TransactionBackend,\n): Promise<(Node | undefined)[]> {\n  if (items.length === 0) return [];\n\n  const registration = getNodeRegistration(ctx.graph, kind);\n  const nodeKind = registration.type;\n  const constraint = resolveConstraint(ctx.graph, kind, constraintName);\n\n  const validated = validateAndComputeKeys(nodeKind, kind, constraint, items);\n  const uniqueKeys = collectUniqueKeys(validated);\n\n  const kindsToCheck = getKindsForUniquenessCheck(\n    kind,\n    constraint.scope,\n    ctx.registry,\n  );\n\n  const existingByKey =\n    uniqueKeys.length > 0 ?\n      await batchCheckUniqueAcrossKinds(\n        backend,\n        ctx.graphId,\n        constraint.name,\n        uniqueKeys,\n        kindsToCheck,\n        false,\n      )\n    : new Map<string, { node_id: string; concrete_kind: string }>();\n\n  // Assemble results, deduplicating keys seen within the batch\n  const results: (Node | undefined)[] = Array.from({ length: items.length });\n  const seenKeys = new Map<string, number>();\n\n  for (const [index, { key }] of validated.entries()) {\n    if (key === undefined) {\n      results[index] = undefined;\n      continue;\n    }\n\n    const previousIndex = seenKeys.get(key);\n    if (previousIndex !== undefined) {\n      results[index] = results[previousIndex];\n      continue;\n    }\n    seenKeys.set(key, index);\n\n    const existing = existingByKey.get(key);\n    if (existing === undefined) {\n      results[index] = undefined;\n      continue;\n    }\n\n    const existingRow = await backend.getNode(\n      ctx.graphId,\n      existing.concrete_kind,\n      existing.node_id,\n    );\n\n    if (existingRow === undefined || existingRow.deleted_at !== undefined) {\n      results[index] = undefined;\n      continue;\n    }\n\n    results[index] = rowToNode(existingRow);\n  }\n\n  return results;\n}\n\n// ============================================================\n// Bulk Find-By-Index\n// ============================================================\n\n/**\n * Resolves a declared node index by name, validating the kind first.\n *\n * @throws {KindNotFoundError} when the node kind is not registered\n * @throws {NodeIndexNotFoundError} when no node index of that name exists\n */\nfunction resolveNodeIndex<G extends GraphDef>(\n  graph: G,\n  kind: string,\n  indexName: string,\n): NodeIndexDeclaration {\n  getNodeRegistration(graph, kind);\n\n  const declaration = graph.indexes?.find(\n    (candidate) =>\n      candidate.entity === \"node\" &&\n      candidate.kind === kind &&\n      candidate.name === indexName,\n  );\n\n  if (declaration?.entity !== \"node\") {\n    throw new NodeIndexNotFoundError(indexName, kind);\n  }\n\n  // GIN-family indexes serve containment / substring predicates, not the\n  // equality probes bulkFindByIndex compiles — targeting one here would\n  // silently probe with the wrong extraction semantics.\n  if (declaration.method !== undefined) {\n    throw new ConfigurationError(\n      `bulkFindByIndex cannot probe index \"${indexName}\" (method ` +\n        `\"${declaration.method}\"): only btree indexes serve equality probes.`,\n      { indexName, kind, method: declaration.method },\n    );\n  }\n\n  return declaration;\n}\n\nconst INDEX_PROBE_EXPECTED_TYPEOF: Partial<Record<ValueType, string>> = {\n  string: \"string\",\n  number: \"number\",\n  boolean: \"boolean\",\n};\n\n/**\n * Validates a single probe value against its declared index-field type.\n * Missing/null values are valid (null probes); only a present, scalar\n * value of the wrong type is rejected.\n */\nfunction validateIndexProbeValue(\n  value: unknown,\n  valueType: ValueType | undefined,\n  pointer: JsonPointer,\n  kind: string,\n): void {\n  if (value === undefined || value === null) return;\n\n  // Index keys are scalar; a non-scalar probe can't be bound and must fail\n  // with a typed error rather than a cryptic driver bind error downstream.\n  if (\n    typeof value !== \"string\" &&\n    typeof value !== \"number\" &&\n    typeof value !== \"boolean\" &&\n    !(value instanceof Date)\n  ) {\n    throw indexProbeTypeError(\n      pointer,\n      kind,\n      \"a scalar (string, number, boolean, or Date)\",\n      value,\n    );\n  }\n\n  if (valueType === \"date\") {\n    if (value instanceof Date || typeof value === \"string\") return;\n    throw indexProbeTypeError(\n      pointer,\n      kind,\n      \"date (Date or ISO string)\",\n      value,\n    );\n  }\n\n  const expected = INDEX_PROBE_EXPECTED_TYPEOF[valueType ?? \"unknown\"];\n  if (expected === undefined) return;\n  if (typeof value !== expected) {\n    throw indexProbeTypeError(pointer, kind, expected, value);\n  }\n}\n\nfunction indexProbeTypeError(\n  pointer: JsonPointer,\n  kind: string,\n  expected: string,\n  value: unknown,\n): ValidationError {\n  return new ValidationError(\n    `Index probe value for \"${pointer}\" on node kind \"${kind}\" has an incompatible type`,\n    {\n      entityType: \"node\",\n      kind,\n      issues: [\n        {\n          path: pointer,\n          message: `Expected ${expected}, received ${typeof value}`,\n          code: \"invalid_type\",\n        },\n      ],\n    },\n  );\n}\n\n/** Coerces a non-null probe value into a driver-bindable scalar. */\nfunction coerceIndexProbeBind(\n  value: unknown,\n  adapter: DialectAdapter,\n): unknown {\n  return adapter.bindValue(normalizeProbeScalar(value as ProbeScalar));\n}\n\ntype ProbeScalar = string | number | boolean | Date;\n\n/**\n * Canonical scalar form of a validated probe value, shared by the dedup key\n * and the bound SQL value so the two can never drift (a Date and its ISO\n * string normalize identically — and produce identical predicates).\n */\nfunction normalizeProbeScalar(value: ProbeScalar): string | number | boolean {\n  return value instanceof Date ? value.toISOString() : value;\n}\n\nconst PROBE_NULL_TAG = 0;\nconst PROBE_VALUE_TAG = 1;\n\n/**\n * Stable dedup key for a probe tuple. Each slot is tagged so a null/undefined\n * value can never collide with a string that happens to equal a sentinel -\n * null maps to [0], a present scalar to [1, normalized].\n */\nfunction canonicalIndexProbeKey(probe: readonly unknown[]): string {\n  return JSON.stringify(\n    probe.map((value) =>\n      value === undefined || value === null ?\n        [PROBE_NULL_TAG]\n      : [PROBE_VALUE_TAG, normalizeProbeScalar(value as ProbeScalar)],\n    ),\n  );\n}\n\n/**\n * Batched candidate retrieval against a declared node index.\n *\n * Emits a single query against the nodes table: each input's indexed-field\n * values become a probe predicate (null-safe equality, reusing the index's\n * own extraction expressions so the planner can use the physical index), and\n * a `CASE` selector tags each matched row with the deduped probe group it\n * satisfies. Rows are grouped back to input positions in order; each input's\n * candidate set is ordered by node id.\n */\nexport async function executeNodeBulkFindByIndex<G extends GraphDef>(\n  ctx: NodeOperationContext<G>,\n  kind: string,\n  indexName: string,\n  items: readonly Readonly<{ props: Record<string, unknown> }>[],\n  backend: GraphBackend | TransactionBackend,\n  options?: NodeBulkFindByIndexOptions,\n): Promise<Node[][]> {\n  if (items.length === 0) return [];\n\n  const index = resolveNodeIndex(ctx.graph, kind, indexName);\n\n  if (index.fields.length === 0) {\n    throw new ConfigurationError(\n      `bulkFindByIndex requires an index with at least one prop-based field on index \"${indexName}\" (node kind \"${kind}\")`,\n      { indexName, kind },\n      {\n        suggestion:\n          \"bulkFindByIndex probes by prop values from each item; an index declared with only keySystemColumns/coveringFields (no fields) has nothing to probe by.\",\n      },\n    );\n  }\n\n  // Date-typed lookup keys can't satisfy the cross-backend parity guarantee:\n  // SQLite compares stored ISO text byte-wise while Postgres compares\n  // timestamptz instants, so equal instants in different ISO forms diverge.\n  // Declare the gap rather than return backend-dependent results.\n  if (index.fieldValueTypes.includes(\"date\")) {\n    throw new ConfigurationError(\n      `bulkFindByIndex does not support date-typed key fields on index \"${indexName}\" (node kind \"${kind}\")`,\n      { indexName, kind },\n      {\n        suggestion:\n          \"Date index keys compare differently across SQLite and PostgreSQL. Use a string-encoded key field, or query date predicates via store.query(...).where(...).\",\n      },\n    );\n  }\n\n  const limitPerInput = options?.limitPerInput;\n  if (\n    limitPerInput !== undefined &&\n    (!Number.isInteger(limitPerInput) || limitPerInput <= 0)\n  ) {\n    throw new ValidationError(\n      \"bulkFindByIndex limitPerInput must be a positive integer\",\n      {\n        entityType: \"node\",\n        kind,\n        issues: [\n          {\n            path: \"limitPerInput\",\n            message: `Expected a positive integer, received ${String(limitPerInput)}`,\n            code: \"invalid_value\",\n          },\n        ],\n      },\n    );\n  }\n\n  const adapter = getDialect(backend.dialect);\n\n  // 1. Extract + validate each input's indexed-field probe tuple.\n  const probes: unknown[][] = items.map((item) =>\n    index.fields.map((pointer, position) => {\n      const value = resolveJsonPointer(item.props, pointer);\n      validateIndexProbeValue(\n        value,\n        index.fieldValueTypes[position],\n        pointer,\n        kind,\n      );\n      return value;\n    }),\n  );\n\n  // 2. Dedupe probe tuples; map each distinct tuple to its input positions.\n  const groupByKey = new Map<string, number>();\n  const groupProbes: unknown[][] = [];\n  const groupToInputs: number[][] = [];\n  for (const [inputIndex, probe] of probes.entries()) {\n    const key = canonicalIndexProbeKey(probe);\n    const existing = groupByKey.get(key);\n    if (existing === undefined) {\n      groupByKey.set(key, groupProbes.length);\n      groupProbes.push(probe);\n      groupToInputs.push([inputIndex]);\n      continue;\n    }\n    groupToInputs[existing]?.push(inputIndex);\n  }\n\n  // 3. Build probe predicates shared by the CASE selector and WHERE filter.\n  const schema =\n    backend.tableNames ?\n      createSqlSchema(backend.tableNames)\n    : DEFAULT_SQL_SCHEMA;\n  const compileContext: IndexCompilationContext = {\n    dialect: backend.dialect,\n    propsColumn: sql.raw(`\"props\"`),\n    systemColumn: (column) => sql.raw(`\"${column}\"`),\n  };\n  const fieldKeys = compileNodeIndexFieldKeys(index, compileContext);\n\n  const groupPredicates = groupProbes.map(\n    (probe) =>\n      sql`(${sql.join(\n        fieldKeys.map((fieldKey, position) => {\n          const value = probe[position];\n          if (value === undefined || value === null) {\n            return sql`${fieldKey} IS NULL`;\n          }\n          return adapter.nullSafeEquals(\n            fieldKey,\n            sql`${coerceIndexProbeBind(value, adapter)}`,\n          );\n        }),\n        sql` AND `,\n      )})`,\n  );\n\n  const caseBranches = groupPredicates.map(\n    (predicate, group) => sql`WHEN ${predicate} THEN ${sql.raw(String(group))}`,\n  );\n  const probeIndexExpr = sql`CASE ${sql.join(caseBranches, sql` `)} ELSE NULL END`;\n\n  const conditions: SqlFragment[] = [\n    sql`\"graph_id\" = ${ctx.graphId}`,\n    sql`\"kind\" = ${kind}`,\n    sql`\"deleted_at\" IS NULL`,\n  ];\n  if (index.where !== undefined) {\n    conditions.push(compileIndexWhere(compileContext, index.where));\n  }\n  conditions.push(sql`(${sql.join(groupPredicates, sql` OR `)})`);\n  const whereClause = sql.join(conditions, sql` AND `);\n\n  // The probe matching runs against the nodes table; rows are hydrated\n  // separately via the backend's normalized node reads so the returned\n  // shape is identical to every other node API (props/timestamp\n  // normalization is backend-owned, not re-derived from raw driver rows).\n  const probedSelect = sql`SELECT \"id\", ${probeIndexExpr} AS probe_idx FROM ${schema.nodesTable} WHERE ${whereClause}`;\n\n  // limitPerInput caps each input's candidates per probe group. When the\n  // backend supports window functions we cap in SQL (`ROW_NUMBER()`), which\n  // also avoids transferring excess ids on low-selectivity keys. Otherwise we\n  // degrade gracefully: fetch all matching ids and cap per group in JS before\n  // hydration — the cap stays correct, only the id transfer is unbounded.\n  const capInSql =\n    limitPerInput !== undefined && backend.capabilities.windowFunctions;\n\n  const query =\n    capInSql ?\n      sql`SELECT \"id\", probe_idx FROM (SELECT \"id\", probe_idx, ROW_NUMBER() OVER (PARTITION BY probe_idx ORDER BY \"id\") AS probe_rank FROM (${probedSelect}) AS probed) AS ranked WHERE probe_rank <= ${limitPerInput} ORDER BY probe_idx, \"id\"`\n    : sql`${probedSelect} ORDER BY probe_idx, \"id\"`;\n\n  // 4. Execute, hydrate matched nodes, and group back to input positions.\n  const rawMatches = await backend.execute<ProbeMatch>(\n    asCompiledRowsSql(query),\n  );\n  const matches =\n    limitPerInput !== undefined && !capInSql ?\n      capMatchesPerGroup(rawMatches, limitPerInput)\n    : rawMatches;\n\n  const nodesById = await hydrateNodesById(\n    backend,\n    ctx.graphId,\n    kind,\n    matches.map((match) => match.id),\n  );\n\n  const results: Node[][] = Array.from({ length: items.length }, () => []);\n  for (const match of matches) {\n    const node = nodesById.get(match.id);\n    if (node === undefined) continue;\n    const inputs = groupToInputs[match.probe_idx];\n    if (inputs === undefined) continue;\n    for (const inputIndex of inputs) {\n      results[inputIndex]?.push(node);\n    }\n  }\n\n  return results;\n}\n\ntype ProbeMatch = Readonly<{ id: string; probe_idx: number }>;\n\n/**\n * Caps matches to the first `limitPerInput` per probe group (the JS-side\n * equivalent of the `ROW_NUMBER()` window). Relies on `matches` already being\n * ordered by `(probe_idx, id)`, so the kept rows are the lowest ids per group.\n */\nfunction capMatchesPerGroup(\n  matches: readonly ProbeMatch[],\n  limitPerInput: number,\n): ProbeMatch[] {\n  const perGroupCount = new Map<number, number>();\n  const capped: ProbeMatch[] = [];\n  for (const match of matches) {\n    const count = perGroupCount.get(match.probe_idx) ?? 0;\n    if (count >= limitPerInput) continue;\n    perGroupCount.set(match.probe_idx, count + 1);\n    capped.push(match);\n  }\n  return capped;\n}\n\n/** Hydrates live nodes by id via the backend's normalized node reads. */\nasync function hydrateNodesById(\n  backend: GraphBackend | TransactionBackend,\n  graphId: string,\n  kind: string,\n  ids: readonly string[],\n): Promise<Map<string, Node>> {\n  const rowsById = await getNodeRowsByIds(backend, graphId, kind, ids);\n  const nodesById = new Map<string, Node>();\n  for (const [id, row] of rowsById) {\n    if (row.deleted_at !== undefined) continue;\n    nodesById.set(id, rowToNode(row));\n  }\n  return nodesById;\n}\n\n// ============================================================\n// Bulk Get-Or-Create-By-Constraint\n// ============================================================\n\nexport async function executeNodeBulkGetOrCreateByConstraint<\n  G extends GraphDef,\n>(\n  ctx: NodeOperationContext<G>,\n  kind: string,\n  constraintName: string,\n  items: readonly Readonly<{ props: Record<string, unknown> }>[],\n  backend: GraphBackend | TransactionBackend,\n  options?: NodeGetOrCreateByConstraintOptions,\n): Promise<Readonly<{ node: Node; action: GetOrCreateAction }>[]> {\n  if (items.length === 0) return [];\n\n  const ifExists = options?.ifExists ?? \"return\";\n  const registration = getNodeRegistration(ctx.graph, kind);\n  const nodeKind = registration.type;\n  const constraint = resolveConstraint(ctx.graph, kind, constraintName);\n\n  // Step 1: Validate all props and compute keys\n  const validated = validateAndComputeKeys(nodeKind, kind, constraint, items);\n  const uniqueKeys = collectUniqueKeys(validated);\n\n  const kindsToCheck = getKindsForUniquenessCheck(\n    kind,\n    constraint.scope,\n    ctx.registry,\n  );\n\n  // Step 2: Batch-check existing keys\n  const existingByKey =\n    uniqueKeys.length > 0 ?\n      await batchCheckUniqueAcrossKinds(\n        backend,\n        ctx.graphId,\n        constraint.name,\n        uniqueKeys,\n        kindsToCheck,\n        true,\n      )\n    : new Map<\n        string,\n        {\n          node_id: string;\n          concrete_kind: string;\n          deleted_at: string | undefined;\n        }\n      >();\n\n  // Step 3: Partition into toCreate, toFetch, and duplicates\n  const toCreate: { index: number; input: CreateNodeInput }[] = [];\n  const toFetch: {\n    index: number;\n    nodeId: string;\n    concreteKind: string;\n    validatedProps: Record<string, unknown>;\n    isSoftDeleted: boolean;\n  }[] = [];\n  const duplicateOf: { index: number; sourceIndex: number }[] = [];\n  const seenKeys = new Map<string, number>();\n\n  for (const [index, { validatedProps, key }] of validated.entries()) {\n    if (key === undefined) {\n      toCreate.push({ index, input: { kind, props: validatedProps } });\n      continue;\n    }\n\n    const previousIndex = seenKeys.get(key);\n    if (previousIndex !== undefined) {\n      duplicateOf.push({ index, sourceIndex: previousIndex });\n      continue;\n    }\n\n    seenKeys.set(key, index);\n\n    const existing = existingByKey.get(key);\n    if (existing === undefined) {\n      toCreate.push({ index, input: { kind, props: validatedProps } });\n    } else {\n      toFetch.push({\n        index,\n        nodeId: existing.node_id,\n        concreteKind: existing.concrete_kind,\n        validatedProps,\n        isSoftDeleted: existing.deleted_at !== undefined,\n      });\n    }\n  }\n\n  type Result = Readonly<{ node: Node; action: GetOrCreateAction }>;\n  const results: Result[] = Array.from({ length: items.length });\n\n  // Step 4: Execute creates\n  if (toCreate.length > 0) {\n    const createInputs = toCreate.map((entry) => entry.input);\n    const createdNodes = await executeNodeCreateBatch(\n      ctx,\n      createInputs,\n      backend,\n      { propsPreValidated: true },\n    );\n    for (const [batchIndex, entry] of toCreate.entries()) {\n      results[entry.index] = {\n        node: requireDefined(createdNodes[batchIndex]),\n        action: \"created\",\n      };\n    }\n  }\n\n  // Step 5: Handle existing nodes (fetch/update/resurrect)\n  for (const entry of toFetch) {\n    const { index, concreteKind, validatedProps, isSoftDeleted, nodeId } =\n      entry;\n\n    const existingRow = await backend.getNode(\n      ctx.graphId,\n      concreteKind,\n      nodeId,\n    );\n\n    if (existingRow === undefined) {\n      const node = await executeNodeCreate(\n        ctx,\n        { kind, props: validatedProps },\n        backend,\n        { propsPreValidated: true },\n      );\n      results[index] = { node, action: \"created\" };\n      continue;\n    }\n\n    if (isSoftDeleted || ifExists === \"update\") {\n      const node = await executeNodeUpsertUpdate(\n        ctx,\n        {\n          kind: concreteKind,\n          id: existingRow.id as UpdateNodeInput[\"id\"],\n          props: validatedProps,\n        },\n        backend,\n        { clearDeleted: isSoftDeleted },\n      );\n      results[index] = {\n        node,\n        action: isSoftDeleted ? \"resurrected\" : \"updated\",\n      };\n    } else {\n      results[index] = { node: rowToNode(existingRow), action: \"found\" };\n    }\n  }\n\n  // Step 6: Resolve within-batch duplicates by copying the first occurrence's result\n  for (const { index, sourceIndex } of duplicateOf) {\n    const sourceResult = requireDefined(results[sourceIndex]);\n    results[index] = { node: sourceResult.node, action: \"found\" };\n  }\n\n  return results;\n}\n"]}

package/dist/{chunk-X6RDQ5NB.cjs → chunk-YX3H63VV.cjs}

@@ -309,6 +309,11 @@ function renderSqlInline(fragment, dialect) {
   return parts.join("");
 }
 
+// src/query/dialect/like-escape.ts
+var LIKE_ESCAPE_CHARACTER = "\\";
+var likeEscapeClause = sql`ESCAPE '\\'`;
+
+exports.LIKE_ESCAPE_CHARACTER = LIKE_ESCAPE_CHARACTER;
 exports.Placeholder = Placeholder;
 exports.annIndexScanTypes = annIndexScanTypes;
 exports.asCompiledRowsSql = asCompiledRowsSql;
@@ -321,6 +326,7 @@ exports.inlineSqlStringLiteral = inlineSqlStringLiteral;
 exports.isRawExecutable = isRawExecutable;
 exports.isSqlFragment = isSqlFragment;
 exports.isSqlPlaceholder = isSqlPlaceholder;
+exports.likeEscapeClause = likeEscapeClause;
 exports.markAnnIndexScan = markAnnIndexScan;
 exports.markForceCustomPlan = markForceCustomPlan;
 exports.renderPostgres = renderPostgres;
@@ -331,5 +337,5 @@ exports.shouldForceCustomPlan = shouldForceCustomPlan;
 exports.sql = sql;
 exports.throwUnsupportedSqlChunk = throwUnsupportedSqlChunk;
 exports.typeGraphGlobalSymbol = typeGraphGlobalSymbol;
-//# sourceMappingURL=chunk-X6RDQ5NB.cjs.map
-//# sourceMappingURL=chunk-X6RDQ5NB.cjs.map
+//# sourceMappingURL=chunk-YX3H63VV.cjs.map
+//# sourceMappingURL=chunk-YX3H63VV.cjs.map

package/dist/chunk-YX3H63VV.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/utils/global-symbol.ts","../src/query/dialect/profile.ts","../src/query/sql-intent.ts","../src/query/sql-fragment.ts","../src/query/dialect/like-escape.ts"],"names":["ConfigurationError"],"mappings":"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","file":"chunk-YX3H63VV.cjs","sourcesContent":["type TypeGraphGlobalSymbolName =\n  | \"sql-fragment\"\n  | \"sql-placeholder\"\n  | \"sql-intent-registry\"\n  | \"internal-temporary-writes-v1\"\n  | \"external-recorded-read-source-v1\"\n  | \"sql-schema-v1\"\n  | \"store-runtime-v1\"\n  | \"typegraph-recorded-read-source-v1\"\n  | \"transaction-runtime-v1\";\n\n/** Returns a process-wide symbol shared across ESM/CJS package instances. */\nexport function typeGraphGlobalSymbol<TSymbol extends symbol>(\n  name: TypeGraphGlobalSymbolName,\n): TSymbol {\n  return Symbol.for(`@nicia-ai/typegraph/${name}`) as TSymbol;\n}\n","import { type SqlDialect } from \"./types\";\n\nexport type SqlDialectProfile = Readonly<{\n  bindValue: (value: unknown) => unknown;\n  booleanLiteralString: (value: boolean) => string;\n  placeholder: (index: number) => string;\n}>;\n\nconst SQL_DIALECT_PROFILES = {\n  postgres: {\n    bindValue: (value: unknown) => value,\n    booleanLiteralString: (value: boolean) => (value ? \"TRUE\" : \"FALSE\"),\n    placeholder: (index: number) => `$${index}`,\n  },\n  sqlite: {\n    bindValue: (value: unknown) =>\n      typeof value === \"boolean\" ?\n        value ? 1\n        : 0\n      : value,\n    booleanLiteralString: (value: boolean) => (value ? \"1\" : \"0\"),\n    placeholder: () => \"?\",\n  },\n} satisfies Record<SqlDialect, SqlDialectProfile>;\n\nconst SQL_STRING_LITERAL_RENDERERS = {\n  postgres: (value: string) => {\n    if (value.includes(\"\\\\\")) {\n      return `E'${value.replaceAll(\"\\\\\", \"\\\\\\\\\").replaceAll(\"'\", \"''\")}'`;\n    }\n    return `'${value.replaceAll(\"'\", \"''\")}'`;\n  },\n  sqlite: (value: string) => `'${value.replaceAll(\"'\", \"''\")}'`,\n} satisfies Record<SqlDialect, (value: string) => string>;\n\n/** Returns the primitive rendering and binding rules for a SQL dialect. */\nexport function getSqlDialectProfile(dialect: SqlDialect): SqlDialectProfile {\n  return SQL_DIALECT_PROFILES[dialect];\n}\n\n/** Maps a JavaScript value to the representation expected by a SQL driver. */\nexport function bindSqlValue(value: unknown, dialect: SqlDialect): unknown {\n  if (value instanceof Date) return value.toISOString();\n  return getSqlDialectProfile(dialect).bindValue(value);\n}\n\n/** Renders one SQL string literal using the dialect's escaping rules. */\nexport function inlineSqlStringLiteral(\n  value: string,\n  dialect: SqlDialect,\n): string {\n  return SQL_STRING_LITERAL_RENDERERS[dialect](value);\n}\n","import { typeGraphGlobalSymbol } from \"../utils/global-symbol\";\nimport { type SqlFragment } from \"./sql-fragment\";\n\ndeclare const SqlIntentBrand: unique symbol;\n\nexport type SqlIntent = \"rows\" | \"statement\" | \"temporary-statement\";\n\nexport type IntentSql<I extends SqlIntent> = SqlFragment &\n  Readonly<{ [SqlIntentBrand]: I }>;\n\nexport type CompiledRowsSql = IntentSql<\"rows\">;\nexport type CompiledSelectSql = CompiledRowsSql;\nexport type CompiledStatementSql = IntentSql<\"statement\">;\nexport type CompiledTemporaryStatementSql = IntentSql<\"temporary-statement\">;\n\nexport function asCompiledRowsSql(query: SqlFragment): CompiledRowsSql {\n  return query as CompiledRowsSql;\n}\n\nexport function asCompiledSelectSql(query: SqlFragment): CompiledSelectSql {\n  return asCompiledRowsSql(query);\n}\n\nexport function asCompiledStatementSql(\n  query: SqlFragment,\n): CompiledStatementSql {\n  return query as CompiledStatementSql;\n}\n\n/**\n * Marks an internal statement that may write only connection-local temporary\n * state. This is intentionally separate from the public raw-statement intent:\n * history-enabled stores block arbitrary raw writes but iterative graph\n * operations still need to manage ephemeral working tables.\n */\nexport function asCompiledTemporaryStatementSql(\n  query: SqlFragment,\n): CompiledTemporaryStatementSql {\n  return query as CompiledTemporaryStatementSql;\n}\n\n/**\n * Statements whose good plan depends on the bound parameter values —\n * e.g. an id-array membership filter where the array cardinality varies\n * per call. PostgreSQL's prepared-statement machinery switches to a\n * generic (parameter-blind) plan after five executions, which for these\n * statements is catastrophically wrong (measured 21ms -> 310ms on the\n * subgraph edge fetch). Marked statements are executed unnamed so every\n * call is planned against the actual parameters; the re-parse cost is\n * ~1ms, the generic-plan cliff it avoids is 10-300ms.\n */\ntype SqlIntentRegistry = Readonly<{\n  annIndexScanQueries: WeakMap<SqlFragment, readonly string[]>;\n  forceCustomPlanQueries: WeakSet<SqlFragment>;\n}>;\n\nconst SQL_INTENT_REGISTRY: unique symbol = typeGraphGlobalSymbol(\n  \"sql-intent-registry\",\n);\nconst globalWithSqlIntentRegistry = globalThis as typeof globalThis &\n  Readonly<{\n    [SQL_INTENT_REGISTRY]?: SqlIntentRegistry;\n  }>;\nconst sqlIntentRegistry =\n  globalWithSqlIntentRegistry[SQL_INTENT_REGISTRY] ??\n  (() => {\n    const registry: SqlIntentRegistry = {\n      annIndexScanQueries: new WeakMap(),\n      forceCustomPlanQueries: new WeakSet(),\n    };\n    Object.defineProperty(globalWithSqlIntentRegistry, SQL_INTENT_REGISTRY, {\n      configurable: false,\n      enumerable: false,\n      value: registry,\n      writable: false,\n    });\n    return registry;\n  })();\n\nexport function markForceCustomPlan(query: SqlFragment): void {\n  sqlIntentRegistry.forceCustomPlanQueries.add(query);\n}\n\nexport function shouldForceCustomPlan(query: SqlFragment): boolean {\n  return sqlIntentRegistry.forceCustomPlanQueries.has(query);\n}\n\n/**\n * Statements whose plan includes an engine ANN index scan (the inline\n * `.similarTo(..., { approximate: true })` branch). The PostgreSQL\n * backend wraps their execution with the same pgvector GUC overrides\n * the search facade applies (`hnsw.iterative_scan = strict_order` /\n * `ivfflat.iterative_scan = relaxed_order` on pgvector >= 0.8), so a\n * filtered approximate query keeps scanning past the default ef_search\n * frontier instead of starving. Carries the slot index types so the\n * backend knows which GUCs apply. Backends without GUC semantics\n * ignore the brand.\n */\nexport function markAnnIndexScan(\n  query: SqlFragment,\n  indexTypes: readonly string[],\n): void {\n  sqlIntentRegistry.annIndexScanQueries.set(query, indexTypes);\n}\n\nexport function annIndexScanTypes(\n  query: SqlFragment,\n): readonly string[] | undefined {\n  return sqlIntentRegistry.annIndexScanQueries.get(query);\n}\n\n/** @internal Copies execution semantics when immutable fragments are composed. */\nexport function copySqlIntents(\n  target: SqlFragment,\n  sources: readonly SqlFragment[],\n): void {\n  if (sources.some((source) => shouldForceCustomPlan(source))) {\n    markForceCustomPlan(target);\n  }\n\n  const indexTypes = new Set<string>();\n  for (const source of sources) {\n    for (const indexType of annIndexScanTypes(source) ?? []) {\n      indexTypes.add(indexType);\n    }\n  }\n  if (indexTypes.size > 0) markAnnIndexScan(target, [...indexTypes]);\n}\n\n/**\n * Whether a compiled statement can be run as raw text (`executeRaw`) without\n * losing execution semantics. Both brands above ride on the SQL *object* and\n * are honored only by `backend.execute`: the force-custom-plan flag makes\n * PostgreSQL re-plan against the actual parameters (opposed to reusing a\n * cached statement), and the ANN-scan brand drives the pgvector iterative-scan\n * GUC wrapper. A statement carrying either must not be flattened to text and\n * cached — callers fall back to `backend.execute`. Keeping this predicate\n * beside the brands means a future brand updates one place, not every caller.\n */\nexport function isRawExecutable(query: SqlFragment): boolean {\n  return (\n    !shouldForceCustomPlan(query) && annIndexScanTypes(query) === undefined\n  );\n}\n","import { ConfigurationError } from \"../errors\";\nimport { typeGraphGlobalSymbol } from \"../utils/global-symbol\";\nimport {\n  bindSqlValue,\n  getSqlDialectProfile,\n  inlineSqlStringLiteral,\n} from \"./dialect/profile\";\nimport { type SqlDialect } from \"./dialect/types\";\nimport { copySqlIntents } from \"./sql-intent\";\n\n/** Nominal identity shared by every package entrypoint. */\nconst SQL_FRAGMENT_BRAND: unique symbol = typeGraphGlobalSymbol(\"sql-fragment\");\nconst SQL_PLACEHOLDER_BRAND: unique symbol =\n  typeGraphGlobalSymbol(\"sql-placeholder\");\n\nexport type SqlTextChunk = Readonly<{\n  kind: \"text\";\n  value: string;\n}>;\n\nexport type SqlParameterChunk = Readonly<{\n  kind: \"parameter\";\n  value: unknown;\n}>;\n\nexport type SqlIdentifierChunk = Readonly<{\n  kind: \"identifier\";\n  value: string;\n}>;\n\nexport type SqlPlaceholderChunk = Readonly<{\n  kind: \"placeholder\";\n  value: Placeholder;\n}>;\n\n/** One immutable unit in a database-independent SQL fragment. */\nexport type SqlChunk =\n  SqlTextChunk | SqlParameterChunk | SqlIdentifierChunk | SqlPlaceholderChunk;\n\n/**\n * An immutable, database-independent SQL expression.\n *\n * Fragments contain syntax and bound values as separate nodes. A database\n * adapter renders the same fragment with its native placeholder convention at\n * the final execution boundary.\n */\nexport type SqlFragment = Readonly<{\n  [SQL_FRAGMENT_BRAND]: true;\n  append: (fragment: SqlFragment) => SqlFragment;\n  chunks: readonly SqlChunk[];\n}>;\n\n/** A named value resolved when a prepared statement is executed. */\nexport class Placeholder {\n  readonly [SQL_PLACEHOLDER_BRAND] = true as const;\n  readonly name: string;\n\n  constructor(name: string) {\n    this.name = name;\n    Object.freeze(this);\n  }\n}\n\nclass SqlFragmentValue implements SqlFragment {\n  readonly [SQL_FRAGMENT_BRAND] = true as const;\n\n  readonly chunks: readonly SqlChunk[];\n\n  constructor(chunks: readonly SqlChunk[]) {\n    this.chunks = Object.freeze([...chunks]);\n    Object.freeze(this);\n  }\n\n  append(fragment: SqlFragment): SqlFragment {\n    return createFragment(\n      [...this.chunks, ...getChunks(fragment)],\n      [this, fragment],\n    );\n  }\n}\n\nfunction createFragment(\n  chunks: readonly SqlChunk[],\n  intentSources: readonly SqlFragment[] = [],\n): SqlFragment {\n  const fragment = new SqlFragmentValue(chunks);\n  copySqlIntents(fragment, intentSources);\n  return fragment;\n}\n\nfunction getChunks(fragment: SqlFragment): readonly SqlChunk[] {\n  if (!isSqlFragment(fragment)) {\n    throw new ConfigurationError(\n      \"Expected a SQL fragment created by TypeGraph's sql helper\",\n    );\n  }\n  return fragment.chunks;\n}\n\n/** Returns whether a value is a TypeGraph-owned SQL fragment. */\nexport function isSqlFragment(value: unknown): value is SqlFragment {\n  return (\n    typeof value === \"object\" &&\n    value !== null &&\n    SQL_FRAGMENT_BRAND in value &&\n    value[SQL_FRAGMENT_BRAND] === true &&\n    \"chunks\" in value &&\n    Array.isArray(value.chunks) &&\n    \"append\" in value &&\n    typeof value.append === \"function\"\n  );\n}\n\n/** Returns whether a value is a TypeGraph named SQL placeholder. */\nexport function isSqlPlaceholder(value: unknown): value is Placeholder {\n  return (\n    typeof value === \"object\" &&\n    value !== null &&\n    SQL_PLACEHOLDER_BRAND in value &&\n    value[SQL_PLACEHOLDER_BRAND] === true &&\n    \"name\" in value &&\n    typeof value.name === \"string\"\n  );\n}\n\n/** @internal Enforces exhaustive handling at every fragment boundary. */\nexport function throwUnsupportedSqlChunk(chunk: never): never {\n  throw new ConfigurationError(\"Unsupported SQL fragment chunk\", { chunk });\n}\n\nfunction textNode(value: string): SqlTextChunk {\n  return Object.freeze({ kind: \"text\", value });\n}\n\nfunction parameterNode(value: unknown): SqlParameterChunk {\n  return Object.freeze({ kind: \"parameter\", value });\n}\n\nfunction identifierNode(value: string): SqlIdentifierChunk {\n  return Object.freeze({ kind: \"identifier\", value });\n}\n\nfunction placeholderNode(value: Placeholder): SqlPlaceholderChunk {\n  return Object.freeze({ kind: \"placeholder\", value });\n}\n\nfunction templateSql(\n  strings: TemplateStringsArray,\n  ...values: readonly unknown[]\n): SqlFragment {\n  const chunks: SqlChunk[] = [];\n  const intentSources: SqlFragment[] = [];\n\n  for (const [index, text] of strings.entries()) {\n    if (text.length > 0) chunks.push(textNode(text));\n\n    if (index >= values.length) continue;\n    const value = values[index];\n    if (isSqlFragment(value)) {\n      chunks.push(...getChunks(value));\n      intentSources.push(value);\n    } else if (isSqlPlaceholder(value)) {\n      chunks.push(placeholderNode(value));\n    } else {\n      chunks.push(parameterNode(value));\n    }\n  }\n\n  return createFragment(chunks, intentSources);\n}\n\nfunction rawSql(value: string): SqlFragment {\n  return createFragment(value.length === 0 ? [] : [textNode(value)]);\n}\n\nfunction identifierSql(value: string): SqlFragment {\n  return createFragment([identifierNode(value)]);\n}\n\nfunction joinSql(\n  fragments: readonly SqlFragment[],\n  separator: SqlFragment = EMPTY_SQL,\n): SqlFragment {\n  const chunks: SqlChunk[] = [];\n  const intentSources: SqlFragment[] = [separator];\n\n  for (const [index, fragment] of fragments.entries()) {\n    if (index > 0) chunks.push(...getChunks(separator));\n    chunks.push(...getChunks(fragment));\n    intentSources.push(fragment);\n  }\n\n  return createFragment(chunks, intentSources);\n}\n\nfunction placeholderSql(name: string): SqlFragment {\n  return createFragment([placeholderNode(new Placeholder(name))]);\n}\n\nconst EMPTY_SQL = createFragment([]);\n\n/** TypeGraph's database-independent SQL template and composition helpers. */\nexport type SqlTag = Readonly<{\n  empty: () => SqlFragment;\n  identifier: (value: string) => SqlFragment;\n  join: (\n    fragments: readonly SqlFragment[],\n    separator?: SqlFragment,\n  ) => SqlFragment;\n  placeholder: (name: string) => SqlFragment;\n  raw: (value: string) => SqlFragment;\n}> &\n  ((\n    strings: TemplateStringsArray,\n    ...values: readonly unknown[]\n  ) => SqlFragment);\n\n/** TypeGraph's database-independent SQL template and composition helpers. */\nexport const sql: SqlTag = Object.assign(templateSql, {\n  empty: function empty(): SqlFragment {\n    return EMPTY_SQL;\n  },\n  identifier: identifierSql,\n  join: joinSql,\n  placeholder: placeholderSql,\n  raw: rawSql,\n});\n\n/** A rendered statement and its ordered bound parameters. */\nexport type RenderedSql = Readonly<{\n  sql: string;\n  params: readonly unknown[];\n}>;\n\nfunction quotedIdentifier(identifier: string): string {\n  return `\"${identifier.replaceAll('\"', '\"\"')}\"`;\n}\n\nfunction resolvedPlaceholder(\n  placeholder: Placeholder,\n  bindings: Readonly<Record<string, unknown>> | undefined,\n  dialect: SqlDialect,\n): unknown {\n  if (bindings === undefined) return placeholder;\n\n  if (!Object.hasOwn(bindings, placeholder.name)) {\n    throw new ConfigurationError(\n      `Missing binding for parameter \"${placeholder.name}\"`,\n      { parameterName: placeholder.name },\n    );\n  }\n  return bindSqlValue(bindings[placeholder.name], dialect);\n}\n\n/**\n * Renders a fragment for a database adapter.\n *\n * Named placeholders remain in `params` when `bindings` is omitted, allowing\n * a prepared template to resolve them later. Passing `bindings` resolves every\n * placeholder eagerly.\n */\nexport function renderSql(\n  fragment: SqlFragment,\n  dialect: SqlDialect,\n  bindings?: Readonly<Record<string, unknown>>,\n): RenderedSql {\n  const parts: string[] = [];\n  const params: unknown[] = [];\n  const profile = getSqlDialectProfile(dialect);\n\n  for (const node of getChunks(fragment)) {\n    switch (node.kind) {\n      case \"text\": {\n        parts.push(node.value);\n        break;\n      }\n      case \"identifier\": {\n        parts.push(quotedIdentifier(node.value));\n        break;\n      }\n      case \"parameter\": {\n        params.push(bindSqlValue(node.value, dialect));\n        parts.push(profile.placeholder(params.length));\n        break;\n      }\n      case \"placeholder\": {\n        params.push(resolvedPlaceholder(node.value, bindings, dialect));\n        parts.push(profile.placeholder(params.length));\n        break;\n      }\n      default: {\n        throwUnsupportedSqlChunk(node);\n      }\n    }\n  }\n\n  return Object.freeze({\n    sql: parts.join(\"\"),\n    params: Object.freeze(params),\n  });\n}\n\n/** Renders a fragment using SQLite's `?` placeholders. */\nexport function renderSqlite(\n  fragment: SqlFragment,\n  bindings?: Readonly<Record<string, unknown>>,\n): RenderedSql {\n  return renderSql(fragment, \"sqlite\", bindings);\n}\n\n/** Renders a fragment using PostgreSQL's numbered placeholders. */\nexport function renderPostgres(\n  fragment: SqlFragment,\n  bindings?: Readonly<Record<string, unknown>>,\n): RenderedSql {\n  return renderSql(fragment, \"postgres\", bindings);\n}\n\nfunction inlineLiteral(value: unknown, dialect: SqlDialect): string {\n  if (value === undefined || value === null) return \"NULL\";\n  if (typeof value === \"string\") return inlineSqlStringLiteral(value, dialect);\n  if (typeof value === \"number\") {\n    if (!Number.isFinite(value)) {\n      throw new ConfigurationError(\"Cannot inline a non-finite SQL number\", {\n        value,\n      });\n    }\n    return String(value);\n  }\n  if (typeof value === \"bigint\") return String(value);\n  if (typeof value === \"boolean\") {\n    return getSqlDialectProfile(dialect).booleanLiteralString(value);\n  }\n  if (value instanceof Date) {\n    return inlineSqlStringLiteral(value.toISOString(), dialect);\n  }\n\n  throw new ConfigurationError(\"Cannot inline this SQL parameter value\", {\n    value,\n  });\n}\n\n/**\n * Renders a fragment with safe scalar literals instead of bound parameters.\n *\n * This is intentionally limited to DDL paths whose drivers cannot bind values.\n * Application queries should always use {@link renderSql}.\n */\nexport function renderSqlInline(\n  fragment: SqlFragment,\n  dialect: SqlDialect,\n): string {\n  const parts: string[] = [];\n\n  for (const node of getChunks(fragment)) {\n    switch (node.kind) {\n      case \"text\": {\n        parts.push(node.value);\n        break;\n      }\n      case \"identifier\": {\n        parts.push(quotedIdentifier(node.value));\n        break;\n      }\n      case \"parameter\": {\n        parts.push(inlineLiteral(node.value, dialect));\n        break;\n      }\n      case \"placeholder\": {\n        throw new ConfigurationError(\n          `Cannot inline unresolved SQL placeholder \"${node.value.name}\"`,\n          { parameterName: node.value.name },\n        );\n      }\n      default: {\n        throwUnsupportedSqlChunk(node);\n      }\n    }\n  }\n\n  return parts.join(\"\");\n}\n","/**\n * Shared LIKE-escape clause for the query compiler.\n *\n * The compiler builds `contains` / `startsWith` / `endsWith` patterns by\n * escaping the literal `%`, `_`, and `\\` in user input with a backslash (see\n * the pattern builders in `compiler/predicates.ts`). For that escaping to take\n * effect the emitted `LIKE` / `ILIKE` must declare backslash as its escape\n * character. PostgreSQL's default LIKE escape is already backslash, so this\n * clause is a no-op there; SQLite has *no* default escape character, so without\n * it an escaped `\\%` matches a literal backslash followed by any character —\n * silently diverging from Postgres. Emitting it on every compiled predicate\n * makes the two backends match by construction.\n */\nimport { sql, type SqlFragment } from \"../sql-fragment\";\n\n/**\n * The backslash escape character used by the JS pattern builder\n * (`compileStringPattern` in `compiler/predicates.ts`) to prefix the literal\n * `%`, `_`, and `\\` in user input. It must match the character declared by\n * {@link likeEscapeClause}: the builder prefixes wildcards with this character,\n * and the clause tells SQL to treat it as the escape. Both are backslash.\n */\nexport const LIKE_ESCAPE_CHARACTER = \"\\\\\";\n\n/**\n * `ESCAPE '\\'` clause appended to every compiled `LIKE` / `ILIKE` predicate,\n * declaring {@link LIKE_ESCAPE_CHARACTER} as the escape character. The single\n * backslash inside the quotes is a literal in both PostgreSQL (with\n * `standard_conforming_strings`, the default) and SQLite.\n */\nexport const likeEscapeClause: SqlFragment = sql`ESCAPE '\\\\'`;\n"]}

package/dist/chunk-YYLMXERH.js

@@ -0,0 +1,211 @@
+import { MAX_PG_IDENTIFIER_LENGTH } from './chunk-2EBMPJBO.js';
+import { typeGraphGlobalSymbol, sql, isSqlFragment } from './chunk-6N7QBIWN.js';
+import { ConfigurationError } from './chunk-DPNA466P.js';
+
+// src/query/compiler/schema.ts
+var SQL_SCHEMA_BRAND = typeGraphGlobalSymbol("sql-schema-v1");
+var SqlSchema = class {
+};
+var SqlSchemaDescriptor = class extends SqlSchema {
+  tables;
+  nodesTable;
+  edgesTable;
+  recordedNodesTable;
+  recordedEdgesTable;
+  recordedClockTable;
+  revisionOriginsTable;
+  fulltextTable;
+  constructor(fields) {
+    super();
+    Object.defineProperty(this, SQL_SCHEMA_BRAND, {
+      configurable: false,
+      enumerable: false,
+      value: true,
+      writable: false
+    });
+    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;
+    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 freezeSqlSchema(fields) {
+  return new SqlSchemaDescriptor(fields);
+}
+function isSqlSchema(schema) {
+  if (typeof schema !== "object" || schema === null) return false;
+  const candidate = schema;
+  return candidate[SQL_SCHEMA_BRAND] === true && typeof candidate["tables"] === "object" && candidate["tables"] !== null && Object.isFrozen(candidate["tables"]) && isSqlFragment(candidate["nodesTable"]) && isSqlFragment(candidate["edgesTable"]) && isSqlFragment(candidate["recordedNodesTable"]) && isSqlFragment(candidate["recordedEdgesTable"]) && isSqlFragment(candidate["recordedClockTable"]) && isSqlFragment(candidate["revisionOriginsTable"]) && isSqlFragment(candidate["fulltextTable"]) && Object.isFrozen(candidate);
+}
+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.identifier(tables.nodes),
+    edgesTable: sql.identifier(tables.edges),
+    recordedNodesTable: sql.identifier(tables.recordedNodes),
+    recordedEdgesTable: sql.identifier(tables.recordedEdges),
+    recordedClockTable: sql.identifier(tables.recordedClock),
+    revisionOriginsTable: sql.identifier(tables.revisionOrigins),
+    fulltextTable: sql.identifier(tables.fulltext)
+  });
+}
+var EXTERNAL_RECORDED_READ_SOURCE = typeGraphGlobalSymbol(
+  "external-recorded-read-source-v1"
+);
+var TYPEGRAPH_RECORDED_READ_SOURCE = typeGraphGlobalSymbol(
+  "typegraph-recorded-read-source-v1"
+);
+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";
+
+export { ALIAS_CTE_PREFIX, DEFAULT_SQL_SCHEMA, EMBEDDINGS_CTE_ALIAS, FULLTEXT_CTE_ALIAS, HYBRID_CANDIDATES_CTE_ALIAS, createRecordedReadBinding, createSqlSchema, recordedReadSchemaFor, recordedReadSqlSchema, recordedRelation, requireExternalRecordedReadSource, requireRecordedReadBinding, requireSqlSchema, vectorSlotKey };
+//# sourceMappingURL=chunk-YYLMXERH.js.map
+//# sourceMappingURL=chunk-YYLMXERH.js.map