@nicia-ai/typegraph 0.50.0 → 0.51.0

package/dist/chunk-XORONCV3.js

@@ -0,0 +1,202 @@
+import { CLAIMS, UNIQUE_SIDECAR_BATCH, BATCH_POINT_READ, STATEMENT_EXECUTION, CONTRIBUTION_HEALTH, RECORDED_REVISION_ORIGINS } from './chunk-LKZDQ2B4.js';
+import { ConfigurationError } from './chunk-YDEJQWOL.js';
+import { requireDefined, createDataKeyedBag } from './chunk-DYATYRY4.js';
+
+// src/backend/capabilities/resolve.ts
+function resolveExtras(backend, extras) {
+  const verdicts = createDataKeyedBag();
+  const missingExtras = [];
+  for (const extra of extras) {
+    const missing = extra.members.filter(
+      (member) => backend[member] === void 0
+    );
+    if (missing.length === 0) {
+      verdicts[extra.id] = { present: true, members: extra.members };
+    } else {
+      verdicts[extra.id] = {
+        present: false,
+        missing,
+        disposition: extra.disposition
+      };
+      missingExtras.push(extra.id);
+    }
+  }
+  return {
+    extras: verdicts,
+    missingExtras
+  };
+}
+function assertClaimsBidirectionalAgreement(backend, definition) {
+  if (definition.declaration === void 0) return;
+  const declared = backend.capabilities[definition.declaration] === true;
+  const present = definition.core.filter(
+    (member) => backend[member] !== void 0
+  );
+  if (declared && present.length === definition.core.length) return;
+  if (!declared && present.length === 0) return;
+  const missing = definition.core.filter(
+    (member) => backend[member] === void 0
+  );
+  const declarationName = definition.declaration;
+  throw new ConfigurationError(
+    declared ? `This backend declares \`${declarationName}: true\` but does not implement ${missing.join(", ")}. A declared constraint would then be written without the fence the declaration promises.` : `This backend implements ${present.join(", ")} but does not declare \`${declarationName}: true\`. Claim support is read from the declaration, so these members would never be called.`,
+    { code: definition.portSurfaceCode, missing, present },
+    {
+      suggestion: declared ? `Implement the missing members, or drop \`${declarationName}\` from the backend's capabilities.` : `Declare \`${declarationName}: true\` in the backend's capabilities, or drop the claim members.`
+    }
+  );
+}
+function resolveBundle(backend, definition) {
+  const extras = definition.extras ?? [];
+  const { extras: extraVerdicts, missingExtras } = resolveExtras(
+    backend,
+    extras
+  );
+  if (definition.crossCheck === "bidirectional") {
+    const memberSet = definition.kind === "gated" ? definition.core : extras.flatMap((extra) => extra.members);
+    assertClaimsBidirectionalAgreement(backend, {
+      ...definition.declaration === void 0 ? {} : { declaration: definition.declaration },
+      core: memberSet,
+      portSurfaceCode: definition.portSurfaceCode
+    });
+  }
+  if (definition.kind === "graduated") {
+    return {
+      bundle: definition.id,
+      extras: extraVerdicts,
+      missingExtras
+    };
+  }
+  const missing = definition.core.filter(
+    (member) => backend[member] === void 0
+  );
+  if (missing.length > 0) {
+    return {
+      supported: false,
+      bundle: definition.id,
+      missing,
+      disposition: definition.disposition
+    };
+  }
+  return {
+    supported: true,
+    bundle: definition.id,
+    members: definition.core,
+    extras: extraVerdicts,
+    missingExtras
+  };
+}
+function missingRequiredExtras(definition, verdict, operation) {
+  const row = definition.operations.find(
+    (candidate) => candidate.operation === operation
+  );
+  if (row === void 0) {
+    throw new ConfigurationError(
+      `Unknown operation "${operation}" for capability bundle "${definition.id}".`,
+      { bundle: definition.id, operation }
+    );
+  }
+  const required = row.requires ?? [];
+  const extras = "extras" in verdict ? verdict.extras : void 0;
+  return required.filter(
+    (id) => extras === void 0 || extras[id]?.present !== true
+  );
+}
+function requireExtras(definition, verdict, operation, refuse) {
+  const missing = missingRequiredExtras(definition, verdict, operation);
+  if (missing.length === 0) return;
+  if (refuse !== void 0) refuse(missing);
+  const { disposition } = requireDefined(
+    definition.operations.find(
+      (candidate) => candidate.operation === operation
+    )
+  );
+  if (disposition.kind === "refuse") {
+    throw new ConfigurationError(
+      `Operation "${operation}" on capability bundle "${definition.id}" requires ${missing.join(", ")}.`,
+      { code: disposition.code, bundle: definition.id, operation, missing }
+    );
+  }
+  throw new ConfigurationError(
+    `Operation "${operation}" on capability bundle "${definition.id}" requires ${missing.join(", ")}, and the registry names no refusal code for this fallback-dispositioned row.`,
+    { bundle: definition.id, operation, missing }
+  );
+}
+function claimsVerdict(backend) {
+  return resolveBundle(backend, CLAIMS);
+}
+function uniqueSidecarBatchVerdict(backend) {
+  return resolveBundle(backend, UNIQUE_SIDECAR_BATCH);
+}
+function batchPointReadVerdict(backend) {
+  return resolveBundle(backend, BATCH_POINT_READ);
+}
+function statementExecutionVerdict(backend) {
+  return resolveBundle(backend, STATEMENT_EXECUTION);
+}
+function contributionHealthVerdict(backend) {
+  return resolveBundle(backend, CONTRIBUTION_HEALTH);
+}
+function recordedRevisionOriginsVerdict(backend) {
+  return resolveBundle(backend, RECORDED_REVISION_ORIGINS);
+}
+var CLAIMS_VERDICT_THUNKS = /* @__PURE__ */ new WeakMap();
+function createClaimsVerdictThunk(backend) {
+  const existing = CLAIMS_VERDICT_THUNKS.get(backend);
+  if (existing !== void 0) return existing;
+  let memo;
+  const thunk = () => {
+    if (memo === void 0) {
+      try {
+        memo = { state: "resolved", verdict: resolveBundle(backend, CLAIMS) };
+      } catch (error) {
+        memo = { state: "thrown", error };
+        throw error;
+      }
+    }
+    if (memo.state === "thrown") throw memo.error;
+    return memo.verdict;
+  };
+  CLAIMS_VERDICT_THUNKS.set(backend, thunk);
+  return thunk;
+}
+
+// src/backend/capabilities/recursive-traversal.ts
+function resolveRecursiveTraversal(capabilities) {
+  const declared = capabilities.recursiveTraversal;
+  if (declared === void 0) {
+    return { supported: true };
+  }
+  if (declared.supported) {
+    return { supported: true };
+  }
+  return {
+    supported: false,
+    reason: declared.reason ?? "backend declares recursiveTraversal: { supported: false }"
+  };
+}
+function assumeRecursiveTraversalSupported(reason) {
+  return { supported: true };
+}
+function recursiveTraversalUnsupportedError(verdict, operation) {
+  return new ConfigurationError(
+    `${operation} requires recursive traversal, but this backend declares recursiveTraversal: { supported: false }.`,
+    {
+      code: "RECURSIVE_TRAVERSAL_UNSUPPORTED",
+      capability: "recursiveTraversal",
+      operation,
+      reason: verdict.reason
+    },
+    {
+      suggestion: "Use a backend that supports recursive traversal, or avoid this query shape."
+    }
+  );
+}
+function assertRecursiveTraversal(verdict, operation) {
+  if (verdict.supported) return;
+  throw recursiveTraversalUnsupportedError(verdict, operation);
+}
+
+export { assertRecursiveTraversal, assumeRecursiveTraversalSupported, batchPointReadVerdict, claimsVerdict, contributionHealthVerdict, createClaimsVerdictThunk, missingRequiredExtras, recordedRevisionOriginsVerdict, recursiveTraversalUnsupportedError, requireExtras, resolveBundle, resolveRecursiveTraversal, statementExecutionVerdict, uniqueSidecarBatchVerdict };
+//# sourceMappingURL=chunk-XORONCV3.js.map
+//# sourceMappingURL=chunk-XORONCV3.js.map

package/dist/chunk-XORONCV3.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/backend/capabilities/resolve.ts","../src/backend/capabilities/recursive-traversal.ts"],"names":[],"mappings":"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","file":"chunk-XORONCV3.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-2Q45FAIE.js → chunk-YT2IVFAI.js}

@@ -1,14 +1,14 @@
-import { META_EDGE_BRAND, getTypeName, defineEdge, defineNode } from './chunk-7OWE7WD6.js';
-import { separationRebuildRequired, hasAssertionsTouchingKinds, lockIdentityGraph, lockIdentityEnablementNodes, purgeAssertionsWithUnregisteredKinds, deleteAssertionsTouchingKinds, rebuildIdentityClosureForContext } from './chunk-GVYVGGPJ.js';
-import { lockRecordedGraphWrite, withRecordedIdentityMutationTarget } from './chunk-FX5ZW6PN.js';
-import { canonicalEqual, sortedReplacer, isMissingTableError, errorChain, isPostgresConcurrentDdlRaceError } from './chunk-IRPYOHRC.js';
-import { createSqlSchema, requireSqlSchema } from './chunk-Y55DLLEG.js';
-import { getNodeKinds, getEdgeKinds, autoDeriveVectorIndexes, mergeVectorIndexes } from './chunk-DI6VC62F.js';
-import { captureWherePredicate } from './chunk-5LKOVCPP.js';
+import { META_EDGE_BRAND, getTypeName, defineEdge, defineNode } from './chunk-LI4K2KEJ.js';
+import { separationRebuildRequired, hasAssertionsTouchingKinds, lockIdentityGraph, lockIdentityEnablementNodes, purgeAssertionsWithUnregisteredKinds, deleteAssertionsTouchingKinds, rebuildIdentityClosureForContext } from './chunk-WFSYYU4W.js';
+import { lockRecordedGraphWrite, withRecordedIdentityMutationTarget } from './chunk-VAAC7L57.js';
+import { canonicalEqual, sortedReplacer, isMissingTableError, errorChain, isPostgresConcurrentDdlRaceError } from './chunk-QG5VEOKX.js';
+import { createSqlSchema, requireSqlSchema, resolveWriteFencePlan, requireWriteFence } from './chunk-LKZDQ2B4.js';
+import { getNodeKinds, getEdgeKinds, autoDeriveVectorIndexes, mergeVectorIndexes } from './chunk-M3VTS3F6.js';
+import { captureWherePredicate } from './chunk-RVUL2HXY.js';
 import { nowIso } from './chunk-K46SDNQD.js';
-import { defineNodeIndex, defineEdgeIndex } from './chunk-ZRJTM7MT.js';
+import { defineNodeIndex, defineEdgeIndex } from './chunk-LZMQ3SFK.js';
 import { sha256Hex } from './chunk-K34OPSJK.js';
-import { asCompiledRowsSql, sql } from './chunk-46UGOVRW.js';
+import { asCompiledRowsSql, sql } from './chunk-7QFRK6PU.js';
 import { resolveGraphVectorSlots, embedding, searchable } from './chunk-PC2UBAUB.js';
 import { LEGACY_GRAPH_EXTENSION_VERSION, computeClosuresFromOntology, unwrap, validateGraphExtension, KindCollisionError, GraphExtensionUnresolvedEndpointError, isExternalIri, GraphExtensionUnresolvedOntologyEndpointError, RemoveCompileTimeKindError, KindHasReferentsError, KindRegistry, createEmptyClosures, validateOntologyRelations, computeClosuresFromNamedOntology } from './chunk-XZW2CTNO.js';
 import { ALL_META_EDGE_NAMES, META_EDGE_IMPLIES, META_EDGE_INVERSE_OF, META_EDGE_PART_OF, META_EDGE_HAS_PART, META_EDGE_DISJOINT_WITH, META_EDGE_DIFFERENT_FROM, META_EDGE_SAME_AS, META_EDGE_EQUIVALENT_TO, META_EDGE_RELATED_TO, META_EDGE_BROADER, META_EDGE_NARROWER, META_EDGE_SUB_CLASS_OF } from './chunk-JXXDZTMN.js';
@@ -2109,12 +2109,21 @@ async function withIdentityDdlRaceRetry(attempt) {
   }
 }
 async function lockIdentityDdl(target) {
-  if (target.dialect !== "postgres") return;
-  await target.execute(
-    asCompiledRowsSql(sql`
-      SELECT pg_advisory_xact_lock(hashtext(${IDENTITY_DDL_LOCK_KEY}), 0)
-    `)
-  );
+  const plan = resolveWriteFencePlan(target);
+  const fence = requireWriteFence(plan, "identity DDL", "advisory-lock");
+  switch (fence.kind) {
+    case "lock": {
+      await target.execute(
+        asCompiledRowsSql(sql`
+          SELECT pg_advisory_xact_lock(hashtext(${IDENTITY_DDL_LOCK_KEY}), 0)
+        `)
+      );
+      return;
+    }
+    case "engine-serialized": {
+      return;
+    }
+  }
 }
 var IDENTITY_DDL_LOCK_KEY = "typegraph:identity-ddl";
 function identityDerivedUpgradeUnsupportedError(graphId, missingPorts) {
@@ -3246,5 +3255,5 @@ async function getCommittedSchemaVersion(backend, graphId) {
 }
 
 export { applyDeprecatedKinds, assertSchemaCurrent, broader, buildGraphExtensionOntologyKeySet, buildKindRegistry, buildValidatedKindRegistry, classifySchemaChanges, commitNewSchemaVersion, commitNewSchemaVersionIfKindsEmpty, commitNewSchemaVersionWithPreflight, compileTimeOntologyKey, computeSchemaDiff, computeSchemaHash, core, deserializeWherePredicate, differentFrom, disjointWith, ensureIdentitySchemaStorage, ensureSchema, equivalentTo, extensionKindNames, getActiveSchema, getCommittedSchemaVersion, getMigrationActions, getSchemaChanges, hasPart, identityKindCascadeNeeded, identitySchemaCommitPreflight, implies, initializeSchema, inverseOf, isBackwardsCompatible, isSchemaInitialized, loadActiveSchemaWithBootstrap, loadAndMergeGraphExtensionDocument, loadAndVerifyGraph, mergeGraphExtension, migrateSchema, narrower, parseSerializedSchema, partOf, planRemovals, relatedTo, requiresMigration, rollbackSchema, sameAs, serializeIndexDeclaration, serializeSchema, serializeSchemaProperties, stripGraphExtension, subClassOf };
-//# sourceMappingURL=chunk-2Q45FAIE.js.map
-//# sourceMappingURL=chunk-2Q45FAIE.js.map
+//# sourceMappingURL=chunk-YT2IVFAI.js.map
+//# sourceMappingURL=chunk-YT2IVFAI.js.map