@nicia-ai/typegraph 0.55.0 → 0.56.0

package/dist/{chunk-IDQZI6GL.js → chunk-XH75W3O5.js}

@@ -1,4 +1,4 @@
-import { CLAIMS, UNIQUE_SIDECAR_BATCH, BATCH_POINT_READ, STATEMENT_EXECUTION, CONTRIBUTION_HEALTH, RECORDED_REVISION_ORIGINS } from './chunk-YVKPUSHS.js';
+import { CLAIMS, UNIQUE_SIDECAR_BATCH, BATCH_POINT_READ, STATEMENT_EXECUTION, CONTRIBUTION_HEALTH, RECORDED_REVISION_ORIGINS } from './chunk-75KH6Y2W.js';
 import { ConfigurationError } from './chunk-ADOABE3R.js';
 import { requireDefined, createDataKeyedBag } from './chunk-QD2JFTSL.js';
 
@@ -198,5 +198,5 @@ function assertRecursiveTraversal(verdict, operation) {
 }
 
 export { assertRecursiveTraversal, assumeRecursiveTraversalSupported, batchPointReadVerdict, claimsVerdict, contributionHealthVerdict, createClaimsVerdictThunk, missingRequiredExtras, recordedRevisionOriginsVerdict, recursiveTraversalUnsupportedError, requireExtras, resolveBundle, resolveRecursiveTraversal, statementExecutionVerdict, uniqueSidecarBatchVerdict };
-//# sourceMappingURL=chunk-IDQZI6GL.js.map
-//# sourceMappingURL=chunk-IDQZI6GL.js.map
+//# sourceMappingURL=chunk-XH75W3O5.js.map
+//# sourceMappingURL=chunk-XH75W3O5.js.map

package/dist/{chunk-IDQZI6GL.js.map → chunk-XH75W3O5.js.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/backend/capabilities/resolve.ts","../src/backend/capabilities/recursive-traversal.ts"],"names":[],"mappings":"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","file":"chunk-IDQZI6GL.js","sourcesContent":["/**\n * The bundle verdict resolver — generalizing `claimSupport`\n * (`store/claims/backing.ts`).\n *\n * Resolution splits in two (ruling B1): the VERDICT — the support decision,\n * resolved once against `GraphBackend` and threaded — and the BINDING\n * (`bind.ts`) — the actual member functions, bound at the call site off\n * whichever port the site holds. A verdict carries names, never functions\n * (I19), so it crosses transaction boundaries safely.\n */\nimport { ConfigurationError } from \"../../errors\";\nimport { createDataKeyedBag } from \"../../utils/object\";\nimport { requireDefined } from \"../../utils/presence\";\nimport { type BackendCapabilities, type GraphBackend } from \"../types\";\nimport {\n  BATCH_POINT_READ,\n  type CapabilityBundleDefinition,\n  type CapabilityBundleDisposition,\n  type CapabilityBundleExtra,\n  CLAIMS,\n  CONTRIBUTION_HEALTH,\n  type OptionalGraphBackendMember,\n  RECORDED_REVISION_ORIGINS,\n  STATEMENT_EXECUTION,\n  UNIQUE_SIDECAR_BATCH,\n} from \"./bundle-registry\";\n\n/**\n * A bundle's extras, as a type-level map from extra id to the UNION of\n * member names that extra covers — derived from the definition's `extras`\n * array by `const` inference, never hand-written.\n */\nexport type CapabilityExtraSpec = Readonly<\n  Record<string, OptionalGraphBackendMember>\n>;\n\n/**\n * One extra's verdict. `present: true` carries the member NAMES, not the\n * member functions (ruling B1) — the names are what the accessor binds\n * from, at the site, off the port.\n */\nexport type ExtraVerdict<M extends OptionalGraphBackendMember> =\n  | Readonly<{ present: true; members: readonly M[] }>\n  | Readonly<{\n      present: false;\n      missing: readonly M[];\n      disposition: CapabilityBundleDisposition;\n    }>;\n\n/** The verdict map: one entry per extra id, never a boolean. */\nexport type ExtraVerdicts<X extends CapabilityExtraSpec> = Readonly<{\n  [K in keyof X]: ExtraVerdict<X[K]>;\n}>;\n\nexport type GatedBundleVerdict<\n  MCore extends OptionalGraphBackendMember,\n  X extends CapabilityExtraSpec,\n> =\n  | Readonly<{\n      supported: true;\n      bundle: string;\n      /** The core, guaranteed present. Names, not functions. */\n      members: readonly MCore[];\n      extras: ExtraVerdicts<X>;\n      /** The `present: false` keys of `extras`. */\n      missingExtras: readonly (keyof X)[];\n    }>\n  | Readonly<{\n      supported: false;\n      bundle: string;\n      missing: readonly MCore[];\n      /** Why it is unsupported: the bundle's own `disposition`, verbatim. */\n      disposition: CapabilityBundleDisposition;\n    }>;\n\n/** No `supported` field: a graduated bundle has no bundle-level verdict. */\nexport type GraduatedBundleVerdict<X extends CapabilityExtraSpec> = Readonly<{\n  bundle: string;\n  extras: ExtraVerdicts<X>;\n  missingExtras: readonly (keyof X)[];\n}>;\n\n/**\n * Recovers the id→members map from a definition's `extras` TUPLE (not\n * `readonly CapabilityBundleExtra<XId, MExtra>[]` — over the array type the\n * id→members association is erased and `ExtraVerdicts<X>` degenerates to an\n * index signature).\n */\nexport type SpecOf<\n  XS extends readonly CapabilityBundleExtra<\n    string,\n    OptionalGraphBackendMember\n  >[],\n> = { [K in XS[number] as K[\"id\"]]: K[\"members\"][number] };\n\nexport type ExtrasOf<D extends CapabilityBundleDefinition> = SpecOf<\n  NonNullable<D[\"extras\"]>\n>;\nexport type ExtraMember<\n  D extends CapabilityBundleDefinition,\n  X extends keyof ExtrasOf<D>,\n> = Extract<ExtrasOf<D>[X], OptionalGraphBackendMember>;\n\n/**\n * The definition union and the return-type mapping. Structural, matching\n * `bundle-registry.ts`'s `BundleMembers` helper's own lesson: reading `core`\n * off `D` directly (rather than re-matching `GatedBundleDefinition`) avoids\n * an unmatched `infer` silently widening to the member constraint.\n */\nexport type BundleVerdictOf<D extends CapabilityBundleDefinition> =\n  D extends (\n    {\n      kind: \"graduated\";\n      extras: infer XS extends readonly CapabilityBundleExtra<\n        string,\n        OptionalGraphBackendMember\n      >[];\n    }\n  ) ?\n    GraduatedBundleVerdict<SpecOf<XS>>\n  : D extends (\n    {\n      kind: \"gated\";\n      core: readonly (infer MCore extends OptionalGraphBackendMember)[];\n      extras?: infer XS extends\n        | readonly CapabilityBundleExtra<string, OptionalGraphBackendMember>[]\n        | undefined;\n    }\n  ) ?\n    GatedBundleVerdict<\n      MCore,\n      SpecOf<\n        XS extends (\n          readonly CapabilityBundleExtra<string, OptionalGraphBackendMember>[]\n        ) ?\n          XS\n        : []\n      >\n    >\n  : never;\n\nfunction resolveExtras<\n  const XS extends readonly CapabilityBundleExtra<\n    string,\n    OptionalGraphBackendMember\n  >[],\n>(\n  backend: GraphBackend,\n  extras: XS,\n): Readonly<{\n  extras: ExtraVerdicts<SpecOf<XS>>;\n  missingExtras: readonly (keyof SpecOf<XS>)[];\n}> {\n  const verdicts =\n    createDataKeyedBag<ExtraVerdict<OptionalGraphBackendMember>>();\n  const missingExtras: string[] = [];\n  for (const extra of extras) {\n    const missing = extra.members.filter(\n      (member) => backend[member] === undefined,\n    );\n    if (missing.length === 0) {\n      verdicts[extra.id] = { present: true, members: extra.members };\n    } else {\n      verdicts[extra.id] = {\n        present: false,\n        missing,\n        disposition: extra.disposition,\n      };\n      missingExtras.push(extra.id);\n    }\n  }\n  return {\n    extras: verdicts as ExtraVerdicts<SpecOf<XS>>,\n    missingExtras: missingExtras,\n  };\n}\n\n/**\n * The `claims` bidirectional cross-check (ruling F2), reproducing\n * `store/claims/backing.ts`'s pre-B7 message text, code and suggestion\n * BYTE-FOR-BYTE. B7 made `claimSupport` (`backing.ts`) delegate to\n * {@link resolveBundle}, so this is now the ONLY place the check runs — there\n * is no second copy left to keep in sync. `bidirectional` is `claims`-only by\n * design (§5.2.1): the two trailing sentences below name \"claim\"/\"fence\"\n * vocabulary that is specific to that one bundle, and a future bundle raising\n * `crossCheck` to `\"bidirectional\"` must carry its own justification row and,\n * with it, its own message pair here.\n *\n * @throws {ConfigurationError} when the declaration and the member surface\n *   disagree in either direction.\n */\nfunction assertClaimsBidirectionalAgreement(\n  backend: GraphBackend,\n  definition: Readonly<{\n    declaration?: keyof BackendCapabilities;\n    core: readonly OptionalGraphBackendMember[];\n    portSurfaceCode: string;\n  }>,\n): void {\n  if (definition.declaration === undefined) return;\n  const declared = backend.capabilities[definition.declaration] === true;\n  const present = definition.core.filter(\n    (member) => backend[member] !== undefined,\n  );\n  if (declared && present.length === definition.core.length) return;\n  if (!declared && present.length === 0) return;\n\n  const missing = definition.core.filter(\n    (member) => backend[member] === undefined,\n  );\n  const declarationName = definition.declaration;\n  throw new ConfigurationError(\n    declared ?\n      `This backend declares \\`${declarationName}: true\\` but does not implement ${missing.join(\", \")}. ` +\n        \"A declared constraint would then be written without the fence the declaration promises.\"\n    : `This backend implements ${present.join(\", \")} but does not declare \\`${declarationName}: true\\`. ` +\n        \"Claim support is read from the declaration, so these members would never be called.\",\n    { code: definition.portSurfaceCode, missing, present },\n    {\n      suggestion:\n        declared ?\n          `Implement the missing members, or drop \\`${declarationName}\\` from the backend's capabilities.`\n        : `Declare \\`${declarationName}: true\\` in the backend's capabilities, or drop the claim members.`,\n    },\n  );\n}\n\n/**\n * Resolved ONCE, at construction or entry, against the top-level backend —\n * never against a `TransactionBackend` (I15's `@ts-expect-error` row).\n *\n * Rules: the member surface is read always; the declaration is read only\n * when the definition names one AND `crossCheck !== \"none\"` (only `claims`\n * qualifies in the pilot registry); a gated bundle's core must be complete\n * or the bundle is unsupported with `missing`; a graduated bundle has no\n * bundle-level verdict, only per-extra verdicts. `missingExtras` is built by\n * the SAME fold that builds `extras` (one pass, one owner).\n */\nexport function resolveBundle<const D extends CapabilityBundleDefinition>(\n  backend: GraphBackend,\n  definition: D,\n): BundleVerdictOf<D> {\n  const extras = (definition.extras ?? []) as readonly CapabilityBundleExtra<\n    string,\n    OptionalGraphBackendMember\n  >[];\n  const { extras: extraVerdicts, missingExtras } = resolveExtras(\n    backend,\n    extras,\n  );\n\n  // Rule 1: the declaration is read whenever `crossCheck !== \"none\"`,\n  // regardless of kind — a graduated bundle's \"core\" for this purpose is the\n  // union of every extra's members, since it has no core of its own. Only\n  // `claims` (gated) exercises this in the pilot registry, but the check\n  // itself must not silently no-op for a hypothetical graduated bidirectional\n  // bundle (T11's mutation pins exactly this).\n  if (definition.crossCheck === \"bidirectional\") {\n    const memberSet =\n      definition.kind === \"gated\" ?\n        definition.core\n      : extras.flatMap((extra) => extra.members);\n    assertClaimsBidirectionalAgreement(backend, {\n      ...(definition.declaration === undefined ?\n        {}\n      : { declaration: definition.declaration }),\n      core: memberSet,\n      portSurfaceCode: definition.portSurfaceCode,\n    });\n  }\n\n  if (definition.kind === \"graduated\") {\n    return {\n      bundle: definition.id,\n      extras: extraVerdicts,\n      missingExtras,\n    } as unknown as BundleVerdictOf<D>;\n  }\n\n  const missing = definition.core.filter(\n    (member) => backend[member] === undefined,\n  );\n  if (missing.length > 0) {\n    return {\n      supported: false,\n      bundle: definition.id,\n      missing,\n      disposition: definition.disposition,\n    } as unknown as BundleVerdictOf<D>;\n  }\n  return {\n    supported: true,\n    bundle: definition.id,\n    members: definition.core,\n    extras: extraVerdicts,\n    missingExtras,\n  } as unknown as BundleVerdictOf<D>;\n}\n\n/** The literal operation names a bundle's `operations` table declares. */\nexport type OperationNames<D extends CapabilityBundleDefinition> =\n  D[\"operations\"][number][\"operation\"];\n\n/** The extras a named operation `requires`, read from the ROW — never re-spelled at the call site. */\nexport type RequiredExtrasOf<\n  D extends CapabilityBundleDefinition,\n  Op extends OperationNames<D>,\n> =\n  Extract<D[\"operations\"][number], { operation: Op }> extends (\n    { requires: infer R extends readonly string[] }\n  ) ?\n    R[number]\n  : never;\n\n/**\n * The registry's row lookup plus the presence fold, extracted verbatim from\n * {@link requireExtras}'s body (ruling B8 spec item 3): the ONE owner of\n * \"what this operation requires\" that both `requireExtras`'s default throw\n * and a call site's own `refuse` callback consult.\n *\n * `operation` is the literal key of the bundle's `operations` tuple, so the\n * required extras are looked up TYPE-LEVEL from the registry — no second\n * spelling of `requires` at the call site.\n *\n * @throws {ConfigurationError} naming the unknown operation when `operation`\n *   is not a row of `definition.operations`.\n */\nexport function missingRequiredExtras<\n  const D extends CapabilityBundleDefinition,\n  Op extends OperationNames<D>,\n>(\n  definition: D,\n  verdict: BundleVerdictOf<D>,\n  operation: Op,\n): readonly string[] {\n  const row = definition.operations.find(\n    (candidate) => candidate.operation === operation,\n  );\n  if (row === undefined) {\n    throw new ConfigurationError(\n      `Unknown operation \"${operation}\" for capability bundle \"${definition.id}\".`,\n      { bundle: definition.id, operation },\n    );\n  }\n  const required = row.requires ?? [];\n  const extras:\n    | Readonly<Record<string, ExtraVerdict<OptionalGraphBackendMember>>>\n    | undefined = \"extras\" in verdict ? verdict.extras : undefined;\n  return required.filter(\n    (id) => extras === undefined || extras[id]?.present !== true,\n  );\n}\n\n/**\n * The refusal for an operation whose `requires` extras are absent — how a\n * GRADUATED bundle refuses where the tree refuses today: the row names the\n * operation and the extras, this asserts they are present, and\n * {@link bindExtra} (`bind.ts`) binds them off the port.\n *\n * `refuse`, when supplied, is called instead of the registry-coded throw\n * below — this is how a call site keeps its OWN existing error text (message,\n * `details` shape, order relative to other refusals) while the registry\n * stays the one owner of \"what this operation requires\" (ruling B8 spec item\n * 3). Omitting it keeps the default behavior byte-identical to before this\n * parameter existed.\n *\n * @throws {ConfigurationError} naming the row's own `code` when one or more\n *   required extras is absent from the verdict and no `refuse` callback is\n *   supplied; otherwise calls `refuse(missing)`, which never returns.\n */\nexport function requireExtras<\n  const D extends CapabilityBundleDefinition,\n  Op extends OperationNames<D>,\n>(\n  definition: D,\n  verdict: BundleVerdictOf<D>,\n  operation: Op,\n  refuse?: (missing: readonly string[]) => never,\n): asserts verdict is BundleVerdictOf<D> & {\n  extras: {\n    [K in RequiredExtrasOf<D, Op> & keyof ExtrasOf<D>]: Extract<\n      ExtraVerdict<ExtraMember<D, K>>,\n      { present: true }\n    >;\n  };\n} {\n  const missing = missingRequiredExtras(definition, verdict, operation);\n  if (missing.length === 0) return;\n\n  if (refuse !== undefined) refuse(missing);\n\n  // `missingRequiredExtras` already threw the unknown-operation error above\n  // when the row would be undefined, so `requireDefined` here is a redundant\n  // (never-failing) narrowing, not a second lookup that could disagree.\n  const { disposition } = requireDefined(\n    definition.operations.find(\n      (candidate) => candidate.operation === operation,\n    ),\n  );\n  if (disposition.kind === \"refuse\") {\n    throw new ConfigurationError(\n      `Operation \"${operation}\" on capability bundle \"${definition.id}\" requires ${missing.join(\", \")}.`,\n      { code: disposition.code, bundle: definition.id, operation, missing },\n    );\n  }\n  // No pilot row reaches this: every row with a non-empty `requires` in the\n  // registry disposes `refuse` (a graduated bundle's fallback rows never\n  // name `requires` — the fallback IS the degrade path). Kept as a named,\n  // typed refusal rather than a silent pass so a future `fallback` +\n  // `requires` row cannot pass `requireExtras` unnoticed.\n  throw new ConfigurationError(\n    `Operation \"${operation}\" on capability bundle \"${definition.id}\" requires ${missing.join(\", \")}, and the registry names no refusal code for this fallback-dispositioned row.`,\n    { bundle: definition.id, operation, missing },\n  );\n}\n\n// ---------------------------------------------------------------------------\n// The six named verdict accessors — GraphBackend-only, no exceptions (I15).\n// ---------------------------------------------------------------------------\n\nexport function claimsVerdict(\n  backend: GraphBackend,\n): BundleVerdictOf<typeof CLAIMS> {\n  return resolveBundle(backend, CLAIMS);\n}\n\nexport function uniqueSidecarBatchVerdict(\n  backend: GraphBackend,\n): BundleVerdictOf<typeof UNIQUE_SIDECAR_BATCH> {\n  return resolveBundle(backend, UNIQUE_SIDECAR_BATCH);\n}\n\nexport function batchPointReadVerdict(\n  backend: GraphBackend,\n): BundleVerdictOf<typeof BATCH_POINT_READ> {\n  return resolveBundle(backend, BATCH_POINT_READ);\n}\n\nexport function statementExecutionVerdict(\n  backend: GraphBackend,\n): BundleVerdictOf<typeof STATEMENT_EXECUTION> {\n  return resolveBundle(backend, STATEMENT_EXECUTION);\n}\n\nexport function contributionHealthVerdict(\n  backend: GraphBackend,\n): BundleVerdictOf<typeof CONTRIBUTION_HEALTH> {\n  return resolveBundle(backend, CONTRIBUTION_HEALTH);\n}\n\nexport function recordedRevisionOriginsVerdict(\n  backend: GraphBackend,\n): BundleVerdictOf<typeof RECORDED_REVISION_ORIGINS> {\n  return resolveBundle(backend, RECORDED_REVISION_ORIGINS);\n}\n\n// ---------------------------------------------------------------------------\n// The claims verdict THUNK — the reference implementation of §5.2.3's INTENT\n// (one owner, at-most-once resolution, no re-derivation) moved to WHEN it\n// resolves rather than IF (ruling B7 refinement 2).\n// ---------------------------------------------------------------------------\n\n/**\n * A memoized, at-most-once resolution of the `claims` bundle's verdict\n * against ONE backend.\n *\n * Eager resolution at store construction is forbidden: T14's\n * contradictory-declaration backends must still be able to construct a store\n * and create nodes — only a constrained edge write may legally reach the\n * bidirectional cross-check's throw, and it must do so lazily, at the first\n * write that needs the verdict.\n *\n * A cached verdict cannot go stale because `GraphBackend` is deep-frozen (B1):\n * nothing can flip `capabilities.constraintClaims` or add/remove a claim\n * member on a backend object after this thunk has already resolved it, so\n * \"resolve once and reuse forever\" is exactly as safe as \"resolve every\n * time\" — for one backend object, they observe the same immutable answer.\n */\nexport type ClaimsVerdictThunk = () => BundleVerdictOf<typeof CLAIMS>;\n\n/**\n * Interning: the same backend object always gets back the SAME thunk object.\n * This is what makes \"one shared thunk per backend\" structural rather than a\n * convention every population site has to honor — a second call to\n * {@link createClaimsVerdictThunk} for a backend already minted cannot produce\n * a second, independently-memoized verdict.\n */\nconst CLAIMS_VERDICT_THUNKS = new WeakMap<GraphBackend, ClaimsVerdictThunk>();\n\n/**\n * Mints — or returns the already-minted — {@link ClaimsVerdictThunk} for\n * `backend`.\n *\n * The thunk resolves {@link resolveBundle}`(backend, CLAIMS)` on its first\n * call and caches the outcome, INCLUDING a thrown `ConfigurationError`: a\n * refusal is cached and re-thrown on every subsequent call, never\n * re-resolved. Both layers — interning here, memoization inside the thunk —\n * are required: interning alone would still let two independently-memoized\n * thunks exist for one backend if a caller ignored the shared one; memoizing\n * alone would still let two different call sites mint two different thunks\n * that could disagree about whether they had already resolved.\n */\nexport function createClaimsVerdictThunk(\n  backend: GraphBackend,\n): ClaimsVerdictThunk {\n  const existing = CLAIMS_VERDICT_THUNKS.get(backend);\n  if (existing !== undefined) return existing;\n\n  type Memo =\n    | Readonly<{ state: \"resolved\"; verdict: BundleVerdictOf<typeof CLAIMS> }>\n    | Readonly<{ state: \"thrown\"; error: unknown }>;\n  let memo: Memo | undefined;\n\n  const thunk: ClaimsVerdictThunk = () => {\n    if (memo === undefined) {\n      try {\n        memo = { state: \"resolved\", verdict: resolveBundle(backend, CLAIMS) };\n      } catch (error) {\n        memo = { state: \"thrown\", error };\n        throw error;\n      }\n    }\n    if (memo.state === \"thrown\") throw memo.error;\n    return memo.verdict;\n  };\n\n  CLAIMS_VERDICT_THUNKS.set(backend, thunk);\n  return thunk;\n}\n","/**\n * The `recursiveTraversal` capability: whether this engine can compute a\n * BOUNDED TRANSITIVE CLOSURE of a relation in one round trip — the traversal\n * primitive, not the SQL syntax.\n */\nimport { ConfigurationError } from \"../../errors\";\nimport { type BackendCapabilities } from \"../types\";\n\n/**\n * Whether this engine can compute a BOUNDED TRANSITIVE CLOSURE of a relation\n * in one round trip — the traversal primitive, not the SQL syntax. A SQL\n * engine satisfies it with `WITH RECURSIVE`; a graph-native engine satisfies\n * it with a native expansion operator. What the capability promises is the\n * SEMANTICS: given a seed set, a step relation, and a hop bound, the engine\n * returns the reachable set (optionally with depth and path) without the\n * client issuing one statement per hop.\n *\n * Absent means SUPPORTED. Every engine TypeGraph ships supports it, and every\n * custom backend already has the six emission sites run against it\n * unconditionally: making absence mean `false` would refuse traversals that\n * work today. This mirrors `returning`, not `constraintClaims` — absence is\n * only allowed to mean \"false\" where absence is SAFE, and here it is not. A\n * backend that genuinely lacks the primitive must say so.\n */\nexport type RecursiveTraversalCapability = Readonly<{\n  supported: boolean;\n  /**\n   * Why the engine lacks it — surfaced in every refusal's details so the\n   * state is named rather than implied. Required when `supported: false` and\n   * forbidden when `true`, so the union cannot carry a dangling reason.\n   */\n  reason?: string;\n}>;\n\n/**\n * The brand. Declared but never exported, and never assigned at runtime — it\n * exists only so that an object literal outside this module is not assignable\n * to {@link RecursiveTraversalVerdict}. Compare `VectorSlot`'s construction\n * discipline: the type is public, the constructor is the seam.\n */\ndeclare const RECURSIVE_TRAVERSAL_VERDICT: unique symbol;\n\n/**\n * The decision, branded so it can only originate from this module's\n * constructors. Round 1 made the verdict a required *field*, which forces a\n * token, not a verdict: any caller could satisfy it by writing\n * `{ supported: true }` inline, and nothing tied the value to the resolver.\n * The brand closes that at the type level.\n */\nexport type RecursiveTraversalVerdict = Readonly<\n  { [RECURSIVE_TRAVERSAL_VERDICT]: true } & (\n    { supported: true } | { supported: false; reason: string }\n  )\n>;\n\n/** THE one reader of `capabilities.recursiveTraversal`, and THE one constructor. */\nexport function resolveRecursiveTraversal(\n  capabilities: BackendCapabilities,\n): RecursiveTraversalVerdict {\n  const declared = capabilities.recursiveTraversal;\n  if (declared === undefined) {\n    return { supported: true } as RecursiveTraversalVerdict;\n  }\n  if (declared.supported) {\n    return { supported: true } as RecursiveTraversalVerdict;\n  }\n  // A raw custom-backend object may never have passed the §4 assert\n  // (`assertBundledCapabilityDeclarations`), so `reason` is not guaranteed to\n  // be present even though the type says it is. Naming the state explicitly\n  // beats a default that would hide a contradictory declaration.\n  return {\n    supported: false,\n    reason:\n      declared.reason ??\n      \"backend declares recursiveTraversal: { supported: false }\",\n  } as RecursiveTraversalVerdict;\n}\n\n/**\n * The ONE sanctioned way to obtain a verdict without a backend: the query\n * compiler's public entry point `compileQuery(ast, graphId, \"postgres\")`\n * takes no backend at all, so it has no capabilities to resolve from. The\n * reason string is required and is echoed in nothing — it exists so the call\n * site states why it is allowed to assume.\n */\nexport function assumeRecursiveTraversalSupported(\n  reason: string,\n): RecursiveTraversalVerdict {\n  // `reason` is intentionally unused in the returned verdict: it documents\n  // the assumption at the call site rather than becoming part of the value.\n  void reason;\n  return { supported: true } as RecursiveTraversalVerdict;\n}\n\n/** THE one refusal builder. */\nexport function recursiveTraversalUnsupportedError(\n  verdict: Extract<RecursiveTraversalVerdict, { supported: false }>,\n  operation: string,\n): ConfigurationError {\n  return new ConfigurationError(\n    `${operation} requires recursive traversal, but this backend declares recursiveTraversal: { supported: false }.`,\n    {\n      code: \"RECURSIVE_TRAVERSAL_UNSUPPORTED\",\n      capability: \"recursiveTraversal\",\n      operation,\n      reason: verdict.reason,\n    },\n    {\n      suggestion:\n        \"Use a backend that supports recursive traversal, or avoid this query shape.\",\n    },\n  );\n}\n\n/** THE one assertion: refuses when the verdict says the engine cannot. */\nexport function assertRecursiveTraversal(\n  verdict: RecursiveTraversalVerdict,\n  operation: string,\n): asserts verdict is Extract<RecursiveTraversalVerdict, { supported: true }> {\n  if (verdict.supported) return;\n  throw recursiveTraversalUnsupportedError(verdict, operation);\n}\n"]}
+{"version":3,"sources":["../src/backend/capabilities/resolve.ts","../src/backend/capabilities/recursive-traversal.ts"],"names":[],"mappings":"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","file":"chunk-XH75W3O5.js","sourcesContent":["/**\n * The bundle verdict resolver — generalizing `claimSupport`\n * (`store/claims/backing.ts`).\n *\n * Resolution splits in two (ruling B1): the VERDICT — the support decision,\n * resolved once against `GraphBackend` and threaded — and the BINDING\n * (`bind.ts`) — the actual member functions, bound at the call site off\n * whichever port the site holds. A verdict carries names, never functions\n * (I19), so it crosses transaction boundaries safely.\n */\nimport { ConfigurationError } from \"../../errors\";\nimport { createDataKeyedBag } from \"../../utils/object\";\nimport { requireDefined } from \"../../utils/presence\";\nimport { type BackendCapabilities, type GraphBackend } from \"../types\";\nimport {\n  BATCH_POINT_READ,\n  type CapabilityBundleDefinition,\n  type CapabilityBundleDisposition,\n  type CapabilityBundleExtra,\n  CLAIMS,\n  CONTRIBUTION_HEALTH,\n  type OptionalGraphBackendMember,\n  RECORDED_REVISION_ORIGINS,\n  STATEMENT_EXECUTION,\n  UNIQUE_SIDECAR_BATCH,\n} from \"./bundle-registry\";\n\n/**\n * A bundle's extras, as a type-level map from extra id to the UNION of\n * member names that extra covers — derived from the definition's `extras`\n * array by `const` inference, never hand-written.\n */\nexport type CapabilityExtraSpec = Readonly<\n  Record<string, OptionalGraphBackendMember>\n>;\n\n/**\n * One extra's verdict. `present: true` carries the member NAMES, not the\n * member functions (ruling B1) — the names are what the accessor binds\n * from, at the site, off the port.\n */\nexport type ExtraVerdict<M extends OptionalGraphBackendMember> =\n  | Readonly<{ present: true; members: readonly M[] }>\n  | Readonly<{\n      present: false;\n      missing: readonly M[];\n      disposition: CapabilityBundleDisposition;\n    }>;\n\n/** The verdict map: one entry per extra id, never a boolean. */\nexport type ExtraVerdicts<X extends CapabilityExtraSpec> = Readonly<{\n  [K in keyof X]: ExtraVerdict<X[K]>;\n}>;\n\nexport type GatedBundleVerdict<\n  MCore extends OptionalGraphBackendMember,\n  X extends CapabilityExtraSpec,\n> =\n  | Readonly<{\n      supported: true;\n      bundle: string;\n      /** The core, guaranteed present. Names, not functions. */\n      members: readonly MCore[];\n      extras: ExtraVerdicts<X>;\n      /** The `present: false` keys of `extras`. */\n      missingExtras: readonly (keyof X)[];\n    }>\n  | Readonly<{\n      supported: false;\n      bundle: string;\n      missing: readonly MCore[];\n      /** Why it is unsupported: the bundle's own `disposition`, verbatim. */\n      disposition: CapabilityBundleDisposition;\n    }>;\n\n/** No `supported` field: a graduated bundle has no bundle-level verdict. */\nexport type GraduatedBundleVerdict<X extends CapabilityExtraSpec> = Readonly<{\n  bundle: string;\n  extras: ExtraVerdicts<X>;\n  missingExtras: readonly (keyof X)[];\n}>;\n\n/**\n * Recovers the id→members map from a definition's `extras` TUPLE (not\n * `readonly CapabilityBundleExtra<XId, MExtra>[]` — over the array type the\n * id→members association is erased and `ExtraVerdicts<X>` degenerates to an\n * index signature).\n */\nexport type SpecOf<\n  XS extends readonly CapabilityBundleExtra<\n    string,\n    OptionalGraphBackendMember\n  >[],\n> = { [K in XS[number] as K[\"id\"]]: K[\"members\"][number] };\n\nexport type ExtrasOf<D extends CapabilityBundleDefinition> = SpecOf<\n  NonNullable<D[\"extras\"]>\n>;\nexport type ExtraMember<\n  D extends CapabilityBundleDefinition,\n  X extends keyof ExtrasOf<D>,\n> = Extract<ExtrasOf<D>[X], OptionalGraphBackendMember>;\n\n/**\n * The definition union and the return-type mapping. Structural, matching\n * `bundle-registry.ts`'s `BundleMembers` helper's own lesson: reading `core`\n * off `D` directly (rather than re-matching `GatedBundleDefinition`) avoids\n * an unmatched `infer` silently widening to the member constraint.\n */\nexport type BundleVerdictOf<D extends CapabilityBundleDefinition> =\n  D extends (\n    {\n      kind: \"graduated\";\n      extras: infer XS extends readonly CapabilityBundleExtra<\n        string,\n        OptionalGraphBackendMember\n      >[];\n    }\n  ) ?\n    GraduatedBundleVerdict<SpecOf<XS>>\n  : D extends (\n    {\n      kind: \"gated\";\n      core: readonly (infer MCore extends OptionalGraphBackendMember)[];\n      extras?: infer XS extends\n        | readonly CapabilityBundleExtra<string, OptionalGraphBackendMember>[]\n        | undefined;\n    }\n  ) ?\n    GatedBundleVerdict<\n      MCore,\n      SpecOf<\n        XS extends (\n          readonly CapabilityBundleExtra<string, OptionalGraphBackendMember>[]\n        ) ?\n          XS\n        : []\n      >\n    >\n  : never;\n\nfunction resolveExtras<\n  const XS extends readonly CapabilityBundleExtra<\n    string,\n    OptionalGraphBackendMember\n  >[],\n>(\n  backend: GraphBackend,\n  extras: XS,\n): Readonly<{\n  extras: ExtraVerdicts<SpecOf<XS>>;\n  missingExtras: readonly (keyof SpecOf<XS>)[];\n}> {\n  const verdicts =\n    createDataKeyedBag<ExtraVerdict<OptionalGraphBackendMember>>();\n  const missingExtras: string[] = [];\n  for (const extra of extras) {\n    const missing = extra.members.filter(\n      (member) => backend[member] === undefined,\n    );\n    if (missing.length === 0) {\n      verdicts[extra.id] = { present: true, members: extra.members };\n    } else {\n      verdicts[extra.id] = {\n        present: false,\n        missing,\n        disposition: extra.disposition,\n      };\n      missingExtras.push(extra.id);\n    }\n  }\n  return {\n    extras: verdicts as ExtraVerdicts<SpecOf<XS>>,\n    missingExtras: missingExtras,\n  };\n}\n\n/**\n * The `claims` bidirectional cross-check (ruling F2), reproducing\n * `store/claims/backing.ts`'s pre-B7 message text, code and suggestion\n * BYTE-FOR-BYTE. B7 made `claimSupport` (`backing.ts`) delegate to\n * {@link resolveBundle}, so this is now the ONLY place the check runs — there\n * is no second copy left to keep in sync. `bidirectional` is `claims`-only by\n * design (§5.2.1): the two trailing sentences below name \"claim\"/\"fence\"\n * vocabulary that is specific to that one bundle, and a future bundle raising\n * `crossCheck` to `\"bidirectional\"` must carry its own justification row and,\n * with it, its own message pair here.\n *\n * @throws {ConfigurationError} when the declaration and the member surface\n *   disagree in either direction.\n */\nfunction assertClaimsBidirectionalAgreement(\n  backend: GraphBackend,\n  definition: Readonly<{\n    declaration?: keyof BackendCapabilities;\n    core: readonly OptionalGraphBackendMember[];\n    portSurfaceCode: string;\n  }>,\n): void {\n  if (definition.declaration === undefined) return;\n  const declared = backend.capabilities[definition.declaration] === true;\n  const present = definition.core.filter(\n    (member) => backend[member] !== undefined,\n  );\n  if (declared && present.length === definition.core.length) return;\n  if (!declared && present.length === 0) return;\n\n  const missing = definition.core.filter(\n    (member) => backend[member] === undefined,\n  );\n  const declarationName = definition.declaration;\n  throw new ConfigurationError(\n    declared ?\n      `This backend declares \\`${declarationName}: true\\` but does not implement ${missing.join(\", \")}. ` +\n        \"A declared constraint would then be written without the fence the declaration promises.\"\n    : `This backend implements ${present.join(\", \")} but does not declare \\`${declarationName}: true\\`. ` +\n        \"Claim support is read from the declaration, so these members would never be called.\",\n    { code: definition.portSurfaceCode, missing, present },\n    {\n      suggestion:\n        declared ?\n          `Implement the missing members, or drop \\`${declarationName}\\` from the backend's capabilities.`\n        : `Declare \\`${declarationName}: true\\` in the backend's capabilities, or drop the claim members.`,\n    },\n  );\n}\n\n/**\n * Resolved ONCE, at construction or entry, against the top-level backend —\n * never against a `TransactionBackend` (I15's `@ts-expect-error` row).\n *\n * Rules: the member surface is read always; the declaration is read only\n * when the definition names one AND `crossCheck !== \"none\"` (only `claims`\n * qualifies in the pilot registry); a gated bundle's core must be complete\n * or the bundle is unsupported with `missing`; a graduated bundle has no\n * bundle-level verdict, only per-extra verdicts. `missingExtras` is built by\n * the SAME fold that builds `extras` (one pass, one owner).\n */\nexport function resolveBundle<const D extends CapabilityBundleDefinition>(\n  backend: GraphBackend,\n  definition: D,\n): BundleVerdictOf<D> {\n  const extras = (definition.extras ?? []) as readonly CapabilityBundleExtra<\n    string,\n    OptionalGraphBackendMember\n  >[];\n  const { extras: extraVerdicts, missingExtras } = resolveExtras(\n    backend,\n    extras,\n  );\n\n  // Rule 1: the declaration is read whenever `crossCheck !== \"none\"`,\n  // regardless of kind — a graduated bundle's \"core\" for this purpose is the\n  // union of every extra's members, since it has no core of its own. Only\n  // `claims` (gated) exercises this in the pilot registry, but the check\n  // itself must not silently no-op for a hypothetical graduated bidirectional\n  // bundle (T11's mutation pins exactly this).\n  if (definition.crossCheck === \"bidirectional\") {\n    const memberSet =\n      definition.kind === \"gated\" ?\n        definition.core\n      : extras.flatMap((extra) => extra.members);\n    assertClaimsBidirectionalAgreement(backend, {\n      ...(definition.declaration === undefined ?\n        {}\n      : { declaration: definition.declaration }),\n      core: memberSet,\n      portSurfaceCode: definition.portSurfaceCode,\n    });\n  }\n\n  if (definition.kind === \"graduated\") {\n    return {\n      bundle: definition.id,\n      extras: extraVerdicts,\n      missingExtras,\n    } as unknown as BundleVerdictOf<D>;\n  }\n\n  const missing = definition.core.filter(\n    (member) => backend[member] === undefined,\n  );\n  if (missing.length > 0) {\n    return {\n      supported: false,\n      bundle: definition.id,\n      missing,\n      disposition: definition.disposition,\n    } as unknown as BundleVerdictOf<D>;\n  }\n  return {\n    supported: true,\n    bundle: definition.id,\n    members: definition.core,\n    extras: extraVerdicts,\n    missingExtras,\n  } as unknown as BundleVerdictOf<D>;\n}\n\n/** The literal operation names a bundle's `operations` table declares. */\nexport type OperationNames<D extends CapabilityBundleDefinition> =\n  D[\"operations\"][number][\"operation\"];\n\n/** The extras a named operation `requires`, read from the ROW — never re-spelled at the call site. */\nexport type RequiredExtrasOf<\n  D extends CapabilityBundleDefinition,\n  Op extends OperationNames<D>,\n> =\n  Extract<D[\"operations\"][number], { operation: Op }> extends (\n    { requires: infer R extends readonly string[] }\n  ) ?\n    R[number]\n  : never;\n\n/**\n * The registry's row lookup plus the presence fold, extracted verbatim from\n * {@link requireExtras}'s body (ruling B8 spec item 3): the ONE owner of\n * \"what this operation requires\" that both `requireExtras`'s default throw\n * and a call site's own `refuse` callback consult.\n *\n * `operation` is the literal key of the bundle's `operations` tuple, so the\n * required extras are looked up TYPE-LEVEL from the registry — no second\n * spelling of `requires` at the call site.\n *\n * @throws {ConfigurationError} naming the unknown operation when `operation`\n *   is not a row of `definition.operations`.\n */\nexport function missingRequiredExtras<\n  const D extends CapabilityBundleDefinition,\n  Op extends OperationNames<D>,\n>(\n  definition: D,\n  verdict: BundleVerdictOf<D>,\n  operation: Op,\n): readonly string[] {\n  const row = definition.operations.find(\n    (candidate) => candidate.operation === operation,\n  );\n  if (row === undefined) {\n    throw new ConfigurationError(\n      `Unknown operation \"${operation}\" for capability bundle \"${definition.id}\".`,\n      { bundle: definition.id, operation },\n    );\n  }\n  const required = row.requires ?? [];\n  const extras:\n    | Readonly<Record<string, ExtraVerdict<OptionalGraphBackendMember>>>\n    | undefined = \"extras\" in verdict ? verdict.extras : undefined;\n  return required.filter(\n    (id) => extras === undefined || extras[id]?.present !== true,\n  );\n}\n\n/**\n * The refusal for an operation whose `requires` extras are absent — how a\n * GRADUATED bundle refuses where the tree refuses today: the row names the\n * operation and the extras, this asserts they are present, and\n * {@link bindExtra} (`bind.ts`) binds them off the port.\n *\n * `refuse`, when supplied, is called instead of the registry-coded throw\n * below — this is how a call site keeps its OWN existing error text (message,\n * `details` shape, order relative to other refusals) while the registry\n * stays the one owner of \"what this operation requires\" (ruling B8 spec item\n * 3). Omitting it keeps the default behavior byte-identical to before this\n * parameter existed.\n *\n * @throws {ConfigurationError} naming the row's own `code` when one or more\n *   required extras is absent from the verdict and no `refuse` callback is\n *   supplied; otherwise calls `refuse(missing)`, which never returns.\n */\nexport function requireExtras<\n  const D extends CapabilityBundleDefinition,\n  Op extends OperationNames<D>,\n>(\n  definition: D,\n  verdict: BundleVerdictOf<D>,\n  operation: Op,\n  refuse?: (missing: readonly string[]) => never,\n): asserts verdict is BundleVerdictOf<D> & {\n  extras: {\n    [K in RequiredExtrasOf<D, Op> & keyof ExtrasOf<D>]: Extract<\n      ExtraVerdict<ExtraMember<D, K>>,\n      { present: true }\n    >;\n  };\n} {\n  const missing = missingRequiredExtras(definition, verdict, operation);\n  if (missing.length === 0) return;\n\n  if (refuse !== undefined) refuse(missing);\n\n  // `missingRequiredExtras` already threw the unknown-operation error above\n  // when the row would be undefined, so `requireDefined` here is a redundant\n  // (never-failing) narrowing, not a second lookup that could disagree.\n  const { disposition } = requireDefined(\n    definition.operations.find(\n      (candidate) => candidate.operation === operation,\n    ),\n  );\n  if (disposition.kind === \"refuse\") {\n    throw new ConfigurationError(\n      `Operation \"${operation}\" on capability bundle \"${definition.id}\" requires ${missing.join(\", \")}.`,\n      { code: disposition.code, bundle: definition.id, operation, missing },\n    );\n  }\n  // No pilot row reaches this: every row with a non-empty `requires` in the\n  // registry disposes `refuse` (a graduated bundle's fallback rows never\n  // name `requires` — the fallback IS the degrade path). Kept as a named,\n  // typed refusal rather than a silent pass so a future `fallback` +\n  // `requires` row cannot pass `requireExtras` unnoticed.\n  throw new ConfigurationError(\n    `Operation \"${operation}\" on capability bundle \"${definition.id}\" requires ${missing.join(\", \")}, and the registry names no refusal code for this fallback-dispositioned row.`,\n    { bundle: definition.id, operation, missing },\n  );\n}\n\n// ---------------------------------------------------------------------------\n// The six named verdict accessors — GraphBackend-only, no exceptions (I15).\n// ---------------------------------------------------------------------------\n\nexport function claimsVerdict(\n  backend: GraphBackend,\n): BundleVerdictOf<typeof CLAIMS> {\n  return resolveBundle(backend, CLAIMS);\n}\n\nexport function uniqueSidecarBatchVerdict(\n  backend: GraphBackend,\n): BundleVerdictOf<typeof UNIQUE_SIDECAR_BATCH> {\n  return resolveBundle(backend, UNIQUE_SIDECAR_BATCH);\n}\n\nexport function batchPointReadVerdict(\n  backend: GraphBackend,\n): BundleVerdictOf<typeof BATCH_POINT_READ> {\n  return resolveBundle(backend, BATCH_POINT_READ);\n}\n\nexport function statementExecutionVerdict(\n  backend: GraphBackend,\n): BundleVerdictOf<typeof STATEMENT_EXECUTION> {\n  return resolveBundle(backend, STATEMENT_EXECUTION);\n}\n\nexport function contributionHealthVerdict(\n  backend: GraphBackend,\n): BundleVerdictOf<typeof CONTRIBUTION_HEALTH> {\n  return resolveBundle(backend, CONTRIBUTION_HEALTH);\n}\n\nexport function recordedRevisionOriginsVerdict(\n  backend: GraphBackend,\n): BundleVerdictOf<typeof RECORDED_REVISION_ORIGINS> {\n  return resolveBundle(backend, RECORDED_REVISION_ORIGINS);\n}\n\n// ---------------------------------------------------------------------------\n// The claims verdict THUNK — the reference implementation of §5.2.3's INTENT\n// (one owner, at-most-once resolution, no re-derivation) moved to WHEN it\n// resolves rather than IF (ruling B7 refinement 2).\n// ---------------------------------------------------------------------------\n\n/**\n * A memoized, at-most-once resolution of the `claims` bundle's verdict\n * against ONE backend.\n *\n * Eager resolution at store construction is forbidden: T14's\n * contradictory-declaration backends must still be able to construct a store\n * and create nodes — only a constrained edge write may legally reach the\n * bidirectional cross-check's throw, and it must do so lazily, at the first\n * write that needs the verdict.\n *\n * A cached verdict cannot go stale because `GraphBackend` is deep-frozen (B1):\n * nothing can flip `capabilities.constraintClaims` or add/remove a claim\n * member on a backend object after this thunk has already resolved it, so\n * \"resolve once and reuse forever\" is exactly as safe as \"resolve every\n * time\" — for one backend object, they observe the same immutable answer.\n */\nexport type ClaimsVerdictThunk = () => BundleVerdictOf<typeof CLAIMS>;\n\n/**\n * Interning: the same backend object always gets back the SAME thunk object.\n * This is what makes \"one shared thunk per backend\" structural rather than a\n * convention every population site has to honor — a second call to\n * {@link createClaimsVerdictThunk} for a backend already minted cannot produce\n * a second, independently-memoized verdict.\n */\nconst CLAIMS_VERDICT_THUNKS = new WeakMap<GraphBackend, ClaimsVerdictThunk>();\n\n/**\n * Mints — or returns the already-minted — {@link ClaimsVerdictThunk} for\n * `backend`.\n *\n * The thunk resolves {@link resolveBundle}`(backend, CLAIMS)` on its first\n * call and caches the outcome, INCLUDING a thrown `ConfigurationError`: a\n * refusal is cached and re-thrown on every subsequent call, never\n * re-resolved. Both layers — interning here, memoization inside the thunk —\n * are required: interning alone would still let two independently-memoized\n * thunks exist for one backend if a caller ignored the shared one; memoizing\n * alone would still let two different call sites mint two different thunks\n * that could disagree about whether they had already resolved.\n */\nexport function createClaimsVerdictThunk(\n  backend: GraphBackend,\n): ClaimsVerdictThunk {\n  const existing = CLAIMS_VERDICT_THUNKS.get(backend);\n  if (existing !== undefined) return existing;\n\n  type Memo =\n    | Readonly<{ state: \"resolved\"; verdict: BundleVerdictOf<typeof CLAIMS> }>\n    | Readonly<{ state: \"thrown\"; error: unknown }>;\n  let memo: Memo | undefined;\n\n  const thunk: ClaimsVerdictThunk = () => {\n    if (memo === undefined) {\n      try {\n        memo = { state: \"resolved\", verdict: resolveBundle(backend, CLAIMS) };\n      } catch (error) {\n        memo = { state: \"thrown\", error };\n        throw error;\n      }\n    }\n    if (memo.state === \"thrown\") throw memo.error;\n    return memo.verdict;\n  };\n\n  CLAIMS_VERDICT_THUNKS.set(backend, thunk);\n  return thunk;\n}\n","/**\n * The `recursiveTraversal` capability: whether this engine can compute a\n * BOUNDED TRANSITIVE CLOSURE of a relation in one round trip — the traversal\n * primitive, not the SQL syntax.\n */\nimport { ConfigurationError } from \"../../errors\";\nimport { type BackendCapabilities } from \"../types\";\n\n/**\n * Whether this engine can compute a BOUNDED TRANSITIVE CLOSURE of a relation\n * in one round trip — the traversal primitive, not the SQL syntax. A SQL\n * engine satisfies it with `WITH RECURSIVE`; a graph-native engine satisfies\n * it with a native expansion operator. What the capability promises is the\n * SEMANTICS: given a seed set, a step relation, and a hop bound, the engine\n * returns the reachable set (optionally with depth and path) without the\n * client issuing one statement per hop.\n *\n * Absent means SUPPORTED. Every engine TypeGraph ships supports it, and every\n * custom backend already has the six emission sites run against it\n * unconditionally: making absence mean `false` would refuse traversals that\n * work today. This mirrors `returning`, not `constraintClaims` — absence is\n * only allowed to mean \"false\" where absence is SAFE, and here it is not. A\n * backend that genuinely lacks the primitive must say so.\n */\nexport type RecursiveTraversalCapability = Readonly<{\n  supported: boolean;\n  /**\n   * Why the engine lacks it — surfaced in every refusal's details so the\n   * state is named rather than implied. Required when `supported: false` and\n   * forbidden when `true`, so the union cannot carry a dangling reason.\n   */\n  reason?: string;\n}>;\n\n/**\n * The brand. Declared but never exported, and never assigned at runtime — it\n * exists only so that an object literal outside this module is not assignable\n * to {@link RecursiveTraversalVerdict}. Compare `VectorSlot`'s construction\n * discipline: the type is public, the constructor is the seam.\n */\ndeclare const RECURSIVE_TRAVERSAL_VERDICT: unique symbol;\n\n/**\n * The decision, branded so it can only originate from this module's\n * constructors. Round 1 made the verdict a required *field*, which forces a\n * token, not a verdict: any caller could satisfy it by writing\n * `{ supported: true }` inline, and nothing tied the value to the resolver.\n * The brand closes that at the type level.\n */\nexport type RecursiveTraversalVerdict = Readonly<\n  { [RECURSIVE_TRAVERSAL_VERDICT]: true } & (\n    { supported: true } | { supported: false; reason: string }\n  )\n>;\n\n/** THE one reader of `capabilities.recursiveTraversal`, and THE one constructor. */\nexport function resolveRecursiveTraversal(\n  capabilities: BackendCapabilities,\n): RecursiveTraversalVerdict {\n  const declared = capabilities.recursiveTraversal;\n  if (declared === undefined) {\n    return { supported: true } as RecursiveTraversalVerdict;\n  }\n  if (declared.supported) {\n    return { supported: true } as RecursiveTraversalVerdict;\n  }\n  // A raw custom-backend object may never have passed the §4 assert\n  // (`assertBundledCapabilityDeclarations`), so `reason` is not guaranteed to\n  // be present even though the type says it is. Naming the state explicitly\n  // beats a default that would hide a contradictory declaration.\n  return {\n    supported: false,\n    reason:\n      declared.reason ??\n      \"backend declares recursiveTraversal: { supported: false }\",\n  } as RecursiveTraversalVerdict;\n}\n\n/**\n * The ONE sanctioned way to obtain a verdict without a backend: the query\n * compiler's public entry point `compileQuery(ast, graphId, \"postgres\")`\n * takes no backend at all, so it has no capabilities to resolve from. The\n * reason string is required and is echoed in nothing — it exists so the call\n * site states why it is allowed to assume.\n */\nexport function assumeRecursiveTraversalSupported(\n  reason: string,\n): RecursiveTraversalVerdict {\n  // `reason` is intentionally unused in the returned verdict: it documents\n  // the assumption at the call site rather than becoming part of the value.\n  void reason;\n  return { supported: true } as RecursiveTraversalVerdict;\n}\n\n/** THE one refusal builder. */\nexport function recursiveTraversalUnsupportedError(\n  verdict: Extract<RecursiveTraversalVerdict, { supported: false }>,\n  operation: string,\n): ConfigurationError {\n  return new ConfigurationError(\n    `${operation} requires recursive traversal, but this backend declares recursiveTraversal: { supported: false }.`,\n    {\n      code: \"RECURSIVE_TRAVERSAL_UNSUPPORTED\",\n      capability: \"recursiveTraversal\",\n      operation,\n      reason: verdict.reason,\n    },\n    {\n      suggestion:\n        \"Use a backend that supports recursive traversal, or avoid this query shape.\",\n    },\n  );\n}\n\n/** THE one assertion: refuses when the verdict says the engine cannot. */\nexport function assertRecursiveTraversal(\n  verdict: RecursiveTraversalVerdict,\n  operation: string,\n): asserts verdict is Extract<RecursiveTraversalVerdict, { supported: true }> {\n  if (verdict.supported) return;\n  throw recursiveTraversalUnsupportedError(verdict, operation);\n}\n"]}

package/dist/{chunk-T7LSSV7J.cjs → chunk-XXEFDJHY.cjs}

@@ -1,9 +1,9 @@
 'use strict';
 
-var chunkTKFQLKH2_cjs = require('./chunk-TKFQLKH2.cjs');
+var chunkCYKHSH5O_cjs = require('./chunk-CYKHSH5O.cjs');
 var chunk5X46XWNH_cjs = require('./chunk-5X46XWNH.cjs');
-var chunkFYMYLZGX_cjs = require('./chunk-FYMYLZGX.cjs');
-var chunkECYEWFEH_cjs = require('./chunk-ECYEWFEH.cjs');
+var chunkZXXGMQC3_cjs = require('./chunk-ZXXGMQC3.cjs');
+var chunkJ34FSPSC_cjs = require('./chunk-J34FSPSC.cjs');
 var chunkOJHFXL7Y_cjs = require('./chunk-OJHFXL7Y.cjs');
 var chunkNI2XPJQ2_cjs = require('./chunk-NI2XPJQ2.cjs');
 var chunkRNI64RB4_cjs = require('./chunk-RNI64RB4.cjs');
@@ -100,7 +100,7 @@ function spanningDifferentAssertion(assertions, first, second) {
 // src/identity/sql-target.ts
 var MAX_REFERENCE_CHUNK_SIZE = 200;
 function identityChunkSize(target, input) {
-  const parameterLimit = chunkTKFQLKH2_cjs.recordedBindParamBudget(target);
+  const parameterLimit = chunkCYKHSH5O_cjs.recordedBindParamBudget(target);
   const chunkSize = Math.floor(
     (parameterLimit - input.fixedParameters) / input.parametersPerItem
   );
@@ -198,8 +198,8 @@ function publicNodeRef(ref) {
   return ref;
 }
 async function lockIdentityGraph(target, graphId) {
-  const plan = chunkECYEWFEH_cjs.resolveWriteFencePlan(target);
-  const fence = chunkECYEWFEH_cjs.requireWriteFence(plan, "identity graph lock", "advisory-lock");
+  const plan = chunkJ34FSPSC_cjs.resolveWriteFencePlan(target);
+  const fence = chunkJ34FSPSC_cjs.requireWriteFence(plan, "identity graph lock", "advisory-lock");
   switch (fence.kind) {
     case "lock": {
       await target.execute(
@@ -218,8 +218,8 @@ async function lockIdentityGraph(target, graphId) {
   }
 }
 async function lockIdentityEnablementNodes(target, schema) {
-  const plan = chunkECYEWFEH_cjs.resolveWriteFencePlan(target);
-  const fence = chunkECYEWFEH_cjs.requireWriteFence(
+  const plan = chunkJ34FSPSC_cjs.resolveWriteFencePlan(target);
+  const fence = chunkJ34FSPSC_cjs.requireWriteFence(
     plan,
     "identity enablement drain",
     "table-lock"
@@ -238,10 +238,10 @@ async function lockIdentityEnablementNodes(target, schema) {
   }
 }
 async function loadNodeSnapshot(target, schema, graphId, coordinate) {
-  const sqlCoordinate = chunkTKFQLKH2_cjs.identitySqlCoordinate(coordinate, chunkNI2XPJQ2_cjs.nowIso());
+  const sqlCoordinate = chunkCYKHSH5O_cjs.identitySqlCoordinate(coordinate, chunkNI2XPJQ2_cjs.nowIso());
   const rows = await target.execute(
     chunkAYQBEVQY_cjs.asCompiledRowsSql(
-      chunkTKFQLKH2_cjs.identityNodeSnapshotSource(schema, graphId, sqlCoordinate)
+      chunkCYKHSH5O_cjs.identityNodeSnapshotSource(schema, graphId, sqlCoordinate)
     )
   );
   return rows.map((row) => ({
@@ -322,7 +322,7 @@ async function loadCurrentStructuralClasses(target, schema, graphId, references)
 }
 async function loadCurrentVisibleMembers(target, schema, graphId, ref) {
   const now = chunkNI2XPJQ2_cjs.nowIso();
-  const coordinate = chunkTKFQLKH2_cjs.identitySqlCoordinate(void 0, now);
+  const coordinate = chunkCYKHSH5O_cjs.identitySqlCoordinate(void 0, now);
   const rows = await target.execute(
     chunkAYQBEVQY_cjs.asCompiledRowsSql(chunkAYQBEVQY_cjs.sql`
       WITH anchor AS (
@@ -348,7 +348,7 @@ async function loadCurrentVisibleMembers(target, schema, graphId, ref) {
       WHERE n.graph_id = ${graphId}
         AND n.kind = m.kind
         AND n.id = m.id
-        AND ${chunkTKFQLKH2_cjs.identityNodeVisibilitySql(coordinate, "n")}
+        AND ${chunkCYKHSH5O_cjs.identityNodeVisibilitySql(coordinate, "n")}
     `)
   );
   const members = rows.map((row) => ({ kind: row.kind, id: row.id })).toSorted((left, right) => compareReferences(left, right));
@@ -397,18 +397,18 @@ async function loadHistoricalClasses(target, schema, graphId, references, coordi
     return combined;
   }
   const currentInstant = chunkNI2XPJQ2_cjs.nowIso();
-  const sqlCoordinate = chunkTKFQLKH2_cjs.identitySqlCoordinate(coordinate, currentInstant);
+  const sqlCoordinate = chunkCYKHSH5O_cjs.identitySqlCoordinate(coordinate, currentInstant);
   const seeds = chunkAYQBEVQY_cjs.sql.join(
     uniqueReferences.map((ref) => chunkAYQBEVQY_cjs.sql`(${ref.kind}, ${ref.id})`),
     chunkAYQBEVQY_cjs.sql`, `
   );
-  const reconstruction = chunkTKFQLKH2_cjs.historicalIdentityReconstructionCtes({
+  const reconstruction = chunkCYKHSH5O_cjs.historicalIdentityReconstructionCtes({
     schema,
     graphId,
     coordinate: sqlCoordinate,
     seedSource: chunkAYQBEVQY_cjs.sql`VALUES ${seeds}`,
     sameIdAcrossKinds,
-    recursiveTraversal: chunkFYMYLZGX_cjs.resolveRecursiveTraversal(target.capabilities)
+    recursiveTraversal: chunkZXXGMQC3_cjs.resolveRecursiveTraversal(target.capabilities)
   });
   const rows = await target.execute(
     chunkAYQBEVQY_cjs.asCompiledRowsSql(chunkAYQBEVQY_cjs.sql`
@@ -416,7 +416,7 @@ async function loadHistoricalClasses(target, schema, graphId, references, coordi
       ${reconstruction}
       SELECT member.seed_kind, member.seed_id,
              member.kind AS member_kind, member.id AS member_id,
-             CASE WHEN ${chunkTKFQLKH2_cjs.identityNodeVisibilitySql(sqlCoordinate, "n")}
+             CASE WHEN ${chunkCYKHSH5O_cjs.identityNodeVisibilitySql(sqlCoordinate, "n")}
                THEN 1 ELSE 0 END AS is_visible
       FROM identity_members member
       JOIN node_snapshot n ON n.kind = member.kind AND n.id = member.id
@@ -467,10 +467,10 @@ function visibleMembersAtCoordinate(ctx, ref) {
   );
 }
 async function loadAssertions(target, schema, graphId, coordinate, currentInstant) {
-  const source = chunkTKFQLKH2_cjs.identityAssertionSnapshotSource(
+  const source = chunkCYKHSH5O_cjs.identityAssertionSnapshotSource(
     schema,
     graphId,
-    chunkTKFQLKH2_cjs.identitySqlCoordinate(coordinate, currentInstant),
+    chunkCYKHSH5O_cjs.identitySqlCoordinate(coordinate, currentInstant),
     void 0
   );
   const rows = await target.execute(
@@ -509,10 +509,10 @@ async function loadAssertionsTouching(target, schema, graphId, references, coord
     }
     return [...byId.values()];
   }
-  const source = chunkTKFQLKH2_cjs.identityAssertionSnapshotSource(
+  const source = chunkCYKHSH5O_cjs.identityAssertionSnapshotSource(
     schema,
     graphId,
-    chunkTKFQLKH2_cjs.identitySqlCoordinate(coordinate, chunkNI2XPJQ2_cjs.nowIso()),
+    chunkCYKHSH5O_cjs.identitySqlCoordinate(coordinate, chunkNI2XPJQ2_cjs.nowIso()),
     relation
   );
   const aMatches = referenceCondition(
@@ -527,7 +527,7 @@ async function loadAssertionsTouching(target, schema, graphId, references, coord
   );
   const rows = await target.execute(
     chunkAYQBEVQY_cjs.asCompiledRowsSql(chunkAYQBEVQY_cjs.sql`
-      SELECT ${chunkTKFQLKH2_cjs.IDENTITY_ASSERTION_COLUMNS}
+      SELECT ${chunkCYKHSH5O_cjs.IDENTITY_ASSERTION_COLUMNS}
       FROM (${source}) identity_assertions
       WHERE ${aMatches} OR ${bMatches}
     `)
@@ -1235,10 +1235,10 @@ function owedProbeChunkSize(target) {
   });
 }
 function liveDifferentSource(schema, graphId) {
-  return chunkTKFQLKH2_cjs.identityAssertionSnapshotSource(
+  return chunkCYKHSH5O_cjs.identityAssertionSnapshotSource(
     schema,
     graphId,
-    chunkTKFQLKH2_cjs.identitySqlCoordinate(void 0, chunkNI2XPJQ2_cjs.nowIso()),
+    chunkCYKHSH5O_cjs.identitySqlCoordinate(void 0, chunkNI2XPJQ2_cjs.nowIso()),
     "different"
   );
 }
@@ -1427,7 +1427,7 @@ async function validateCurrentRelation(ctx, target, relation, operation, a, b) {
 async function currentAssertionForPair(target, schema, graphId, relation, a, b) {
   const rows = await target.execute(
     chunkAYQBEVQY_cjs.asCompiledRowsSql(chunkAYQBEVQY_cjs.sql`
-      SELECT ${chunkTKFQLKH2_cjs.IDENTITY_ASSERTION_COLUMNS}
+      SELECT ${chunkCYKHSH5O_cjs.IDENTITY_ASSERTION_COLUMNS}
       FROM ${schema.identityAssertionsTable}
       WHERE graph_id = ${graphId}
         AND rel = ${relation}
@@ -1446,7 +1446,7 @@ async function assertionForExactWindow(target, schema, graphId, relation, a, b,
   const validToMatch = window.validTo === void 0 ? chunkAYQBEVQY_cjs.sql`valid_to IS NULL` : chunkAYQBEVQY_cjs.sql`valid_to = ${window.validTo}`;
   const rows = await target.execute(
     chunkAYQBEVQY_cjs.asCompiledRowsSql(chunkAYQBEVQY_cjs.sql`
-      SELECT ${chunkTKFQLKH2_cjs.IDENTITY_ASSERTION_COLUMNS}
+      SELECT ${chunkCYKHSH5O_cjs.IDENTITY_ASSERTION_COLUMNS}
       FROM ${schema.identityAssertionsTable}
       WHERE graph_id = ${graphId}
         AND rel = ${relation}
@@ -1478,7 +1478,7 @@ async function insertAssertion(target, schema, graphId, relation, a, b, operatio
 function buildAssertionRow(graphId, relation, a, b, timestamp, options) {
   return {
     graph_id: graphId,
-    id: options?.id ?? chunkTKFQLKH2_cjs.generateId(),
+    id: options?.id ?? chunkCYKHSH5O_cjs.generateId(),
     rel: relation,
     a_kind: a.kind,
     a_id: a.id,
@@ -1533,7 +1533,7 @@ function windowOverlapSql(alias, lowerBoundary, upperBoundary) {
   `;
 }
 async function loadIdentityWindowLedger(input) {
-  chunkFYMYLZGX_cjs.assertRecursiveTraversal(
+  chunkZXXGMQC3_cjs.assertRecursiveTraversal(
     input.recursiveTraversal,
     "identity window ledger read"
   );
@@ -1647,7 +1647,7 @@ async function loadIdentityWindowLedger(input) {
             WHERE assertion.graph_id = ${graphId}
               AND ${windowOverlapSql("assertion", lowerBoundary, upperBoundary)}
           )
-          SELECT 'assertion' AS row_type, ${chunkTKFQLKH2_cjs.IDENTITY_ASSERTION_COLUMNS},
+          SELECT 'assertion' AS row_type, ${chunkCYKHSH5O_cjs.IDENTITY_ASSERTION_COLUMNS},
                  NULL AS node_kind, NULL AS node_id,
                  NULL AS node_created_at, NULL AS node_deleted_at
           FROM selected_assertions
@@ -1793,7 +1793,7 @@ async function createIdentityWindowValidator(ctx, target, requests, operationIns
     requests,
     operationInstant,
     sameIdAcrossKinds: ctx.sameIdAcrossKinds,
-    recursiveTraversal: chunkFYMYLZGX_cjs.resolveRecursiveTraversal(target.capabilities)
+    recursiveTraversal: chunkZXXGMQC3_cjs.resolveRecursiveTraversal(target.capabilities)
   });
   if (ignoredAssertionIds.size > 0) {
     const retained = ledger.assertions.filter(
@@ -1856,7 +1856,7 @@ async function insertAssertionRows(target, schema, rows) {
     await executeIdentityStatement(
       target,
       chunkAYQBEVQY_cjs.sql`
-        INSERT INTO ${schema.identityAssertionsTable} (${chunkTKFQLKH2_cjs.IDENTITY_ASSERTION_COLUMNS}) VALUES ${chunkAYQBEVQY_cjs.sql.join(values, chunkAYQBEVQY_cjs.sql`, `)}
+        INSERT INTO ${schema.identityAssertionsTable} (${chunkCYKHSH5O_cjs.IDENTITY_ASSERTION_COLUMNS}) VALUES ${chunkAYQBEVQY_cjs.sql.join(values, chunkAYQBEVQY_cjs.sql`, `)}
       `
     );
   }
@@ -1877,7 +1877,7 @@ async function loadAssertionsByIds(target, schema, graphId, ids) {
     );
     const rows = await target.execute(
       chunkAYQBEVQY_cjs.asCompiledRowsSql(chunkAYQBEVQY_cjs.sql`
-        SELECT ${chunkTKFQLKH2_cjs.IDENTITY_ASSERTION_COLUMNS}
+        SELECT ${chunkCYKHSH5O_cjs.IDENTITY_ASSERTION_COLUMNS}
         FROM ${schema.identityAssertionsTable}
         WHERE graph_id = ${graphId} AND id IN (${idList})
       `)
@@ -2511,7 +2511,7 @@ async function bulkAssertWindowedPairs(ctx, target, relation, pairs, touch, oper
 async function findCurrentAssertionById(target, schema, graphId, id) {
   const rows = await target.execute(
     chunkAYQBEVQY_cjs.asCompiledRowsSql(chunkAYQBEVQY_cjs.sql`
-      SELECT ${chunkTKFQLKH2_cjs.IDENTITY_ASSERTION_COLUMNS}
+      SELECT ${chunkCYKHSH5O_cjs.IDENTITY_ASSERTION_COLUMNS}
       FROM ${schema.identityAssertionsTable}
       WHERE graph_id = ${graphId}
         AND id = ${id}
@@ -2562,7 +2562,7 @@ async function retractCurrentAssertions(ctx, target, ids, touch, resolveValidTo)
     );
     const rows = await target.execute(
       chunkAYQBEVQY_cjs.asCompiledRowsSql(chunkAYQBEVQY_cjs.sql`
-        SELECT ${chunkTKFQLKH2_cjs.IDENTITY_ASSERTION_COLUMNS}
+        SELECT ${chunkCYKHSH5O_cjs.IDENTITY_ASSERTION_COLUMNS}
         FROM ${ctx.schema.identityAssertionsTable}
         WHERE graph_id = ${ctx.graphId}
           AND id IN (${placeholders})
@@ -2663,7 +2663,7 @@ async function retractPlannedAssertions(ctx, target, retractions, touch) {
 }
 async function runIdentityMutation(ctx, fn) {
   let touched = false;
-  return chunkTKFQLKH2_cjs.runInWriteTransaction(
+  return chunkCYKHSH5O_cjs.runInWriteTransaction(
     {
       graphId: ctx.graphId,
       schemaVersion: ctx.schemaVersion,
@@ -2674,7 +2674,7 @@ async function runIdentityMutation(ctx, fn) {
     ctx.backend,
     async (target) => {
       await lockIdentityGraph(target, ctx.graphId);
-      return chunkTKFQLKH2_cjs.withRecordedIdentityMutationTarget(
+      return chunkCYKHSH5O_cjs.withRecordedIdentityMutationTarget(
         target,
         (rawTarget, touch) => fn(
           rawTarget,
@@ -3115,7 +3115,7 @@ function rethrowTaggedWithAssertion(error, assertionId, progress) {
 async function importIdentityAssertionsIntoTarget(ctx, target, assertions, mode, ignoredAssertionIds = /* @__PURE__ */ new Set()) {
   let created = 0;
   let skipped = 0;
-  await chunkTKFQLKH2_cjs.withRecordedIdentityMutationTarget(target, async (rawTarget, touch) => {
+  await chunkCYKHSH5O_cjs.withRecordedIdentityMutationTarget(target, async (rawTarget, touch) => {
     const operationInstant = chunkNI2XPJQ2_cjs.nowIso();
     const normalized = assertions.map((assertion) => ({
       assertion,
@@ -3365,7 +3365,7 @@ async function rebuildIdentityClosureForContext(ctx) {
   requireAtomicIdentityBackend(ctx.backend, ctx.graphId);
   async function rebuildAtTarget(target) {
     await lockIdentityGraph(target, ctx.graphId);
-    await chunkTKFQLKH2_cjs.withRecordedIdentityMutationTarget(target, async (rawTarget) => {
+    await chunkCYKHSH5O_cjs.withRecordedIdentityMutationTarget(target, async (rawTarget) => {
       const activeKinds = identityActiveKinds(ctx.registry);
       const snapshot = await loadSnapshot(
         rawTarget,
@@ -3557,7 +3557,7 @@ async function assertAffectedIdentityClassesConsistent(ctx, target, seeds) {
   await lockIdentityGraph(target, ctx.graphId);
   const observed = await findAffectedClassInconsistency(ctx, target, seeds);
   if (observed === void 0) return;
-  await chunkTKFQLKH2_cjs.withRecordedIdentityMutationTarget(target, async (rawTarget) => {
+  await chunkCYKHSH5O_cjs.withRecordedIdentityMutationTarget(target, async (rawTarget) => {
     await replaceClosure(
       rawTarget,
       ctx.schema,
@@ -3587,7 +3587,7 @@ async function deleteAssertionsTouchingKinds(target, schema, graphId, kinds, tou
     );
     const rows = await target.execute(
       chunkAYQBEVQY_cjs.asCompiledRowsSql(chunkAYQBEVQY_cjs.sql`
-        SELECT ${chunkTKFQLKH2_cjs.IDENTITY_ASSERTION_COLUMNS}
+        SELECT ${chunkCYKHSH5O_cjs.IDENTITY_ASSERTION_COLUMNS}
         FROM ${schema.identityAssertionsTable}
         WHERE graph_id = ${graphId}
           AND (a_kind IN (${kindList2}) OR b_kind IN (${kindList2}))
@@ -3724,7 +3724,7 @@ async function liveNodeKindsSharingIds(ctx, target, ids) {
 async function foldIdentityForCreatedNodes(ctx, target, references) {
   if (references.length === 0 || ctx.sameIdAcrossKinds === "ignore") return;
   await lockIdentityGraph(target, ctx.graphId);
-  await chunkTKFQLKH2_cjs.withRecordedIdentityMutationTarget(target, async (rawTarget) => {
+  await chunkCYKHSH5O_cjs.withRecordedIdentityMutationTarget(target, async (rawTarget) => {
     const liveKindsById = await liveNodeKindsSharingIds(
       ctx,
       rawTarget,
@@ -3792,7 +3792,7 @@ async function readNodeDeletionInstant(target, schema, graphId, ref) {
 async function requireNodeValidityEndCompatible(ctx, target, ref, validTo) {
   const rows = await target.execute(
     chunkAYQBEVQY_cjs.asCompiledRowsSql(chunkAYQBEVQY_cjs.sql`
-      SELECT ${chunkTKFQLKH2_cjs.IDENTITY_ASSERTION_COLUMNS}
+      SELECT ${chunkCYKHSH5O_cjs.IDENTITY_ASSERTION_COLUMNS}
       FROM ${ctx.schema.identityAssertionsTable}
       WHERE graph_id = ${ctx.graphId}
         AND deleted_at IS NULL
@@ -3819,7 +3819,7 @@ async function requireNodeValidityEndCompatible(ctx, target, ref, validTo) {
 }
 async function detachIdentityForNode(ctx, target, ref, mode) {
   await lockIdentityGraph(target, ctx.graphId);
-  await chunkTKFQLKH2_cjs.withRecordedIdentityMutationTarget(target, async (rawTarget, touch) => {
+  await chunkCYKHSH5O_cjs.withRecordedIdentityMutationTarget(target, async (rawTarget, touch) => {
     const touchesNode = chunkAYQBEVQY_cjs.sql`
       (
             (a_kind = ${ref.kind} AND a_id = ${ref.id})
@@ -3829,7 +3829,7 @@ async function detachIdentityForNode(ctx, target, ref, mode) {
     const scope = mode === "hard" ? chunkAYQBEVQY_cjs.sql`` : chunkAYQBEVQY_cjs.sql`AND valid_to IS NULL AND deleted_at IS NULL`;
     const rows = await rawTarget.execute(
       chunkAYQBEVQY_cjs.asCompiledRowsSql(chunkAYQBEVQY_cjs.sql`
-        SELECT ${chunkTKFQLKH2_cjs.IDENTITY_ASSERTION_COLUMNS}
+        SELECT ${chunkCYKHSH5O_cjs.IDENTITY_ASSERTION_COLUMNS}
         FROM ${ctx.schema.identityAssertionsTable}
         WHERE graph_id = ${ctx.graphId}
           ${scope}
@@ -3941,5 +3941,5 @@ exports.requireNodeValidityEndCompatible = requireNodeValidityEndCompatible;
 exports.separationRebuildRequired = separationRebuildRequired;
 exports.toTransferAssertion = toTransferAssertion;
 exports.validateIdentityForContext = validateIdentityForContext;
-//# sourceMappingURL=chunk-T7LSSV7J.cjs.map
-//# sourceMappingURL=chunk-T7LSSV7J.cjs.map
+//# sourceMappingURL=chunk-XXEFDJHY.cjs.map
+//# sourceMappingURL=chunk-XXEFDJHY.cjs.map