@nicia-ai/typegraph 0.49.0 → 0.51.0

package/dist/chunk-ZGVTNKTX.cjs

@@ -0,0 +1,217 @@
+'use strict';
+
+var chunkNUQ2YFFH_cjs = require('./chunk-NUQ2YFFH.cjs');
+var chunkX4GDXBOP_cjs = require('./chunk-X4GDXBOP.cjs');
+var chunkN66HCGCY_cjs = require('./chunk-N66HCGCY.cjs');
+
+// src/backend/capabilities/resolve.ts
+function resolveExtras(backend, extras) {
+  const verdicts = chunkN66HCGCY_cjs.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 chunkX4GDXBOP_cjs.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 chunkX4GDXBOP_cjs.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 } = chunkN66HCGCY_cjs.requireDefined(
+    definition.operations.find(
+      (candidate) => candidate.operation === operation
+    )
+  );
+  if (disposition.kind === "refuse") {
+    throw new chunkX4GDXBOP_cjs.ConfigurationError(
+      `Operation "${operation}" on capability bundle "${definition.id}" requires ${missing.join(", ")}.`,
+      { code: disposition.code, bundle: definition.id, operation, missing }
+    );
+  }
+  throw new chunkX4GDXBOP_cjs.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, chunkNUQ2YFFH_cjs.CLAIMS);
+}
+function uniqueSidecarBatchVerdict(backend) {
+  return resolveBundle(backend, chunkNUQ2YFFH_cjs.UNIQUE_SIDECAR_BATCH);
+}
+function batchPointReadVerdict(backend) {
+  return resolveBundle(backend, chunkNUQ2YFFH_cjs.BATCH_POINT_READ);
+}
+function statementExecutionVerdict(backend) {
+  return resolveBundle(backend, chunkNUQ2YFFH_cjs.STATEMENT_EXECUTION);
+}
+function contributionHealthVerdict(backend) {
+  return resolveBundle(backend, chunkNUQ2YFFH_cjs.CONTRIBUTION_HEALTH);
+}
+function recordedRevisionOriginsVerdict(backend) {
+  return resolveBundle(backend, chunkNUQ2YFFH_cjs.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, chunkNUQ2YFFH_cjs.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 chunkX4GDXBOP_cjs.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);
+}
+
+exports.assertRecursiveTraversal = assertRecursiveTraversal;
+exports.assumeRecursiveTraversalSupported = assumeRecursiveTraversalSupported;
+exports.batchPointReadVerdict = batchPointReadVerdict;
+exports.claimsVerdict = claimsVerdict;
+exports.contributionHealthVerdict = contributionHealthVerdict;
+exports.createClaimsVerdictThunk = createClaimsVerdictThunk;
+exports.missingRequiredExtras = missingRequiredExtras;
+exports.recordedRevisionOriginsVerdict = recordedRevisionOriginsVerdict;
+exports.recursiveTraversalUnsupportedError = recursiveTraversalUnsupportedError;
+exports.requireExtras = requireExtras;
+exports.resolveBundle = resolveBundle;
+exports.resolveRecursiveTraversal = resolveRecursiveTraversal;
+exports.statementExecutionVerdict = statementExecutionVerdict;
+exports.uniqueSidecarBatchVerdict = uniqueSidecarBatchVerdict;
+//# sourceMappingURL=chunk-ZGVTNKTX.cjs.map
+//# sourceMappingURL=chunk-ZGVTNKTX.cjs.map

package/dist/chunk-ZGVTNKTX.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/backend/capabilities/resolve.ts","../src/backend/capabilities/recursive-traversal.ts"],"names":["createDataKeyedBag","ConfigurationError","requireDefined","CLAIMS","UNIQUE_SIDECAR_BATCH","BATCH_POINT_READ","STATEMENT_EXECUTION","CONTRIBUTION_HEALTH","RECORDED_REVISION_ORIGINS"],"mappings":"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","file":"chunk-ZGVTNKTX.cjs","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/core/index.cjs

@@ -1,97 +1,98 @@
 'use strict';
 
-var chunkTZEGUG6D_cjs = require('../chunk-TZEGUG6D.cjs');
-var chunk26YKDNUD_cjs = require('../chunk-26YKDNUD.cjs');
-var chunkBFUOME67_cjs = require('../chunk-BFUOME67.cjs');
-require('../chunk-FQPEMEWX.cjs');
-var chunk2QGYQBS2_cjs = require('../chunk-2QGYQBS2.cjs');
-require('../chunk-TQHGE7UC.cjs');
+var chunkBZ5MVITP_cjs = require('../chunk-BZ5MVITP.cjs');
+var chunkPS3TUWJM_cjs = require('../chunk-PS3TUWJM.cjs');
+var chunk7B7I7YAW_cjs = require('../chunk-7B7I7YAW.cjs');
+require('../chunk-CRZ56SZU.cjs');
+var chunkDWUDZ66O_cjs = require('../chunk-DWUDZ66O.cjs');
+require('../chunk-M5MSP3BI.cjs');
 var chunkHAHNRASW_cjs = require('../chunk-HAHNRASW.cjs');
-require('../chunk-6NGW27EO.cjs');
-require('../chunk-MRDBBHIZ.cjs');
+require('../chunk-VLBTRXA2.cjs');
+require('../chunk-RWUWTJQY.cjs');
+require('../chunk-X4GDXBOP.cjs');
 require('../chunk-N66HCGCY.cjs');
 
 
 
 Object.defineProperty(exports, "createExternalRef", {
   enumerable: true,
-  get: function () { return chunkTZEGUG6D_cjs.createExternalRef; }
+  get: function () { return chunkBZ5MVITP_cjs.createExternalRef; }
 });
 Object.defineProperty(exports, "externalRef", {
   enumerable: true,
-  get: function () { return chunkTZEGUG6D_cjs.externalRef; }
+  get: function () { return chunkBZ5MVITP_cjs.externalRef; }
 });
 Object.defineProperty(exports, "getExternalRefTable", {
   enumerable: true,
-  get: function () { return chunkTZEGUG6D_cjs.getExternalRefTable; }
+  get: function () { return chunkBZ5MVITP_cjs.getExternalRefTable; }
 });
 Object.defineProperty(exports, "isExternalRefSchema", {
   enumerable: true,
-  get: function () { return chunkTZEGUG6D_cjs.isExternalRefSchema; }
+  get: function () { return chunkBZ5MVITP_cjs.isExternalRefSchema; }
 });
 Object.defineProperty(exports, "metaEdge", {
   enumerable: true,
-  get: function () { return chunkTZEGUG6D_cjs.metaEdge; }
+  get: function () { return chunkBZ5MVITP_cjs.metaEdge; }
 });
 Object.defineProperty(exports, "defineEdge", {
   enumerable: true,
-  get: function () { return chunk26YKDNUD_cjs.defineEdge; }
+  get: function () { return chunkPS3TUWJM_cjs.defineEdge; }
 });
 Object.defineProperty(exports, "defineNode", {
   enumerable: true,
-  get: function () { return chunk26YKDNUD_cjs.defineNode; }
+  get: function () { return chunkPS3TUWJM_cjs.defineNode; }
 });
 Object.defineProperty(exports, "asEdgeId", {
   enumerable: true,
-  get: function () { return chunkBFUOME67_cjs.asEdgeId; }
+  get: function () { return chunk7B7I7YAW_cjs.asEdgeId; }
 });
 Object.defineProperty(exports, "asNodeId", {
   enumerable: true,
-  get: function () { return chunkBFUOME67_cjs.asNodeId; }
+  get: function () { return chunk7B7I7YAW_cjs.asNodeId; }
 });
 Object.defineProperty(exports, "defineGraph", {
   enumerable: true,
-  get: function () { return chunkBFUOME67_cjs.defineGraph; }
+  get: function () { return chunk7B7I7YAW_cjs.defineGraph; }
 });
 Object.defineProperty(exports, "getEdgeKinds", {
   enumerable: true,
-  get: function () { return chunkBFUOME67_cjs.getEdgeKinds; }
+  get: function () { return chunk7B7I7YAW_cjs.getEdgeKinds; }
 });
 Object.defineProperty(exports, "getNodeKinds", {
   enumerable: true,
-  get: function () { return chunkBFUOME67_cjs.getNodeKinds; }
+  get: function () { return chunk7B7I7YAW_cjs.getNodeKinds; }
 });
 Object.defineProperty(exports, "isEdgeType", {
   enumerable: true,
-  get: function () { return chunkBFUOME67_cjs.isEdgeType; }
+  get: function () { return chunk7B7I7YAW_cjs.isEdgeType; }
 });
 Object.defineProperty(exports, "isEdgeTypeWithEndpoints", {
   enumerable: true,
-  get: function () { return chunkBFUOME67_cjs.isEdgeTypeWithEndpoints; }
+  get: function () { return chunk7B7I7YAW_cjs.isEdgeTypeWithEndpoints; }
 });
 Object.defineProperty(exports, "isGraphDef", {
   enumerable: true,
-  get: function () { return chunkBFUOME67_cjs.isGraphDef; }
+  get: function () { return chunk7B7I7YAW_cjs.isGraphDef; }
 });
 Object.defineProperty(exports, "isNodeType", {
   enumerable: true,
-  get: function () { return chunkBFUOME67_cjs.isNodeType; }
+  get: function () { return chunk7B7I7YAW_cjs.isNodeType; }
 });
 Object.defineProperty(exports, "asRecordedInstant", {
   enumerable: true,
-  get: function () { return chunk2QGYQBS2_cjs.asRecordedInstant; }
+  get: function () { return chunkDWUDZ66O_cjs.asRecordedInstant; }
 });
 Object.defineProperty(exports, "compareRecordedInstants", {
   enumerable: true,
-  get: function () { return chunk2QGYQBS2_cjs.compareRecordedInstants; }
+  get: function () { return chunkDWUDZ66O_cjs.compareRecordedInstants; }
 });
 Object.defineProperty(exports, "recordedInstantRevision", {
   enumerable: true,
-  get: function () { return chunk2QGYQBS2_cjs.recordedInstantRevision; }
+  get: function () { return chunkDWUDZ66O_cjs.recordedInstantRevision; }
 });
 Object.defineProperty(exports, "recordedInstantWallTime", {
   enumerable: true,
-  get: function () { return chunk2QGYQBS2_cjs.recordedInstantWallTime; }
+  get: function () { return chunkDWUDZ66O_cjs.recordedInstantWallTime; }
 });
 Object.defineProperty(exports, "DEFAULT_SEARCHABLE_LANGUAGE", {
   enumerable: true,

package/dist/core/index.d.cts

@@ -1,8 +1,8 @@
 import { z } from 'zod';
-import { bi as KindAnnotations, dg as NodeType, dr as EdgeType, b9 as InferenceType, dN as MetaEdge } from '../types-BqFZTQmV.cjs';
-export { ds as AllEdgeTypes, dt as AllNodeTypes, dh as AnyEdgeType, C as Cardinality, l as Collation, S as DeleteBehavior, dw as EdgeId, dx as EdgeKinds, dy as EdgeProps, dz as EdgeRegistration, dA as EdgeTypeWithEndpoints, aa as EndpointExistence, dC as GetEdgeType, dD as GetNodeType, d8 as GraphDef, dE as GraphDefaults, aR as GraphIdentityConfig, b0 as IndexEntity, bh as JsonValue, bj as KindEntity, dP as NodeId, dQ as NodeKinds, dR as NodeProps, dS as NodeRegistration, bt as NullCheckOp, ce as TemporalMode, d_ as UniqueConstraint, cn as UniquenessScope, d$ as asEdgeId, e0 as asNodeId, e2 as defineGraph, e3 as getEdgeKinds, e4 as getNodeKinds, e5 as isEdgeType, e6 as isEdgeTypeWithEndpoints, e7 as isGraphDef, e9 as isNodeType } from '../types-BqFZTQmV.cjs';
-export { D as DEFAULT_SEARCHABLE_LANGUAGE, b as EmbeddingSchema, c as EmbeddingValue, S as SearchableMetadata, d as SearchableOptions, e as SearchableSchema, f as embedding, g as getEmbeddingDimensions, h as getSearchableMetadata, i as isEmbeddingSchema, j as isSearchableSchema, r as resolveGraphVectorSlots, s as searchable } from '../searchable-DHJMh_nj.cjs';
-export { R as RecordedInstant, a as asRecordedInstant, c as compareRecordedInstants, r as recordedInstantRevision, b as recordedInstantWallTime } from '../temporal-5GqpYCk2.cjs';
+import { bx as KindAnnotations, dF as NodeType, e4 as EdgeType, bp as InferenceType, fb as MetaEdge } from '../types-6yf0Vv-_.cjs';
+export { e5 as AllEdgeTypes, e6 as AllNodeTypes, dG as AnyEdgeType, n as Cardinality, s as Collation, a5 as DeleteBehavior, eq as EdgeId, er as EdgeKinds, eu as EdgeProps, ev as EdgeRegistration, ew as EdgeTypeWithEndpoints, as as EndpointExistence, eH as GetEdgeType, eI as GetNodeType, d as GraphDef, eK as GraphDefaults, G as GraphIdentityConfig, bg as IndexEntity, bw as JsonValue, K as KindEntity, fi as NodeId, fl as NodeKinds, fo as NodeProps, fp as NodeRegistration, bH as NullCheckOp, T as TemporalMode, fQ as UniqueConstraint, cH as UniquenessScope, fY as asEdgeId, fZ as asNodeId, f$ as defineGraph, g0 as getEdgeKinds, g2 as getNodeKinds, g4 as isEdgeType, g5 as isEdgeTypeWithEndpoints, g6 as isGraphDef, g8 as isNodeType } from '../types-6yf0Vv-_.cjs';
+export { D as DEFAULT_SEARCHABLE_LANGUAGE, b as EmbeddingSchema, c as EmbeddingValue, S as SearchableMetadata, d as SearchableOptions, e as SearchableSchema, f as embedding, g as getEmbeddingDimensions, h as getSearchableMetadata, i as isEmbeddingSchema, j as isSearchableSchema, r as resolveGraphVectorSlots, s as searchable } from '../searchable-ClgET_i7.cjs';
+export { R as RecordedInstant, a as asRecordedInstant, c as compareRecordedInstants, r as recordedInstantRevision, b as recordedInstantWallTime } from '../temporal-CpyEiRY8.cjs';
 
 /**
  * Options for defining a node type.

package/dist/core/index.d.ts

@@ -1,8 +1,8 @@
 import { z } from 'zod';
-import { bi as KindAnnotations, dg as NodeType, dr as EdgeType, b9 as InferenceType, dN as MetaEdge } from '../types-BqFZTQmV.js';
-export { ds as AllEdgeTypes, dt as AllNodeTypes, dh as AnyEdgeType, C as Cardinality, l as Collation, S as DeleteBehavior, dw as EdgeId, dx as EdgeKinds, dy as EdgeProps, dz as EdgeRegistration, dA as EdgeTypeWithEndpoints, aa as EndpointExistence, dC as GetEdgeType, dD as GetNodeType, d8 as GraphDef, dE as GraphDefaults, aR as GraphIdentityConfig, b0 as IndexEntity, bh as JsonValue, bj as KindEntity, dP as NodeId, dQ as NodeKinds, dR as NodeProps, dS as NodeRegistration, bt as NullCheckOp, ce as TemporalMode, d_ as UniqueConstraint, cn as UniquenessScope, d$ as asEdgeId, e0 as asNodeId, e2 as defineGraph, e3 as getEdgeKinds, e4 as getNodeKinds, e5 as isEdgeType, e6 as isEdgeTypeWithEndpoints, e7 as isGraphDef, e9 as isNodeType } from '../types-BqFZTQmV.js';
-export { D as DEFAULT_SEARCHABLE_LANGUAGE, b as EmbeddingSchema, c as EmbeddingValue, S as SearchableMetadata, d as SearchableOptions, e as SearchableSchema, f as embedding, g as getEmbeddingDimensions, h as getSearchableMetadata, i as isEmbeddingSchema, j as isSearchableSchema, r as resolveGraphVectorSlots, s as searchable } from '../searchable-bpE1bBfc.js';
-export { R as RecordedInstant, a as asRecordedInstant, c as compareRecordedInstants, r as recordedInstantRevision, b as recordedInstantWallTime } from '../temporal-CbnLzTmM.js';
+import { bx as KindAnnotations, dF as NodeType, e4 as EdgeType, bp as InferenceType, fb as MetaEdge } from '../types-6yf0Vv-_.js';
+export { e5 as AllEdgeTypes, e6 as AllNodeTypes, dG as AnyEdgeType, n as Cardinality, s as Collation, a5 as DeleteBehavior, eq as EdgeId, er as EdgeKinds, eu as EdgeProps, ev as EdgeRegistration, ew as EdgeTypeWithEndpoints, as as EndpointExistence, eH as GetEdgeType, eI as GetNodeType, d as GraphDef, eK as GraphDefaults, G as GraphIdentityConfig, bg as IndexEntity, bw as JsonValue, K as KindEntity, fi as NodeId, fl as NodeKinds, fo as NodeProps, fp as NodeRegistration, bH as NullCheckOp, T as TemporalMode, fQ as UniqueConstraint, cH as UniquenessScope, fY as asEdgeId, fZ as asNodeId, f$ as defineGraph, g0 as getEdgeKinds, g2 as getNodeKinds, g4 as isEdgeType, g5 as isEdgeTypeWithEndpoints, g6 as isGraphDef, g8 as isNodeType } from '../types-6yf0Vv-_.js';
+export { D as DEFAULT_SEARCHABLE_LANGUAGE, b as EmbeddingSchema, c as EmbeddingValue, S as SearchableMetadata, d as SearchableOptions, e as SearchableSchema, f as embedding, g as getEmbeddingDimensions, h as getSearchableMetadata, i as isEmbeddingSchema, j as isSearchableSchema, r as resolveGraphVectorSlots, s as searchable } from '../searchable-C_UREI9K.js';
+export { R as RecordedInstant, a as asRecordedInstant, c as compareRecordedInstants, r as recordedInstantRevision, b as recordedInstantWallTime } from '../temporal-y0Aep9Su.js';
 
 /**
  * Options for defining a node type.

package/dist/core/index.js

@@ -1,12 +1,13 @@
-export { createExternalRef, externalRef, getExternalRefTable, isExternalRefSchema, metaEdge } from '../chunk-MYKHJI2J.js';
-export { defineEdge, defineNode } from '../chunk-SHFBB23Q.js';
-export { asEdgeId, asNodeId, defineGraph, getEdgeKinds, getNodeKinds, isEdgeType, isEdgeTypeWithEndpoints, isGraphDef, isNodeType } from '../chunk-HEV35TGT.js';
-import '../chunk-GLHXM7C4.js';
-export { asRecordedInstant, compareRecordedInstants, recordedInstantRevision, recordedInstantWallTime } from '../chunk-DZAICA5J.js';
-import '../chunk-5K2BKEBD.js';
+export { createExternalRef, externalRef, getExternalRefTable, isExternalRefSchema, metaEdge } from '../chunk-2DWTBNSH.js';
+export { defineEdge, defineNode } from '../chunk-LI4K2KEJ.js';
+export { asEdgeId, asNodeId, defineGraph, getEdgeKinds, getNodeKinds, isEdgeType, isEdgeTypeWithEndpoints, isGraphDef, isNodeType } from '../chunk-M3VTS3F6.js';
+import '../chunk-RVUL2HXY.js';
+export { asRecordedInstant, compareRecordedInstants, recordedInstantRevision, recordedInstantWallTime } from '../chunk-6NKSE5AU.js';
+import '../chunk-K46SDNQD.js';
 export { DEFAULT_SEARCHABLE_LANGUAGE, embedding, getEmbeddingDimensions, getSearchableMetadata, isEmbeddingSchema, isSearchableSchema, resolveGraphVectorSlots, searchable } from '../chunk-PC2UBAUB.js';
-import '../chunk-XVWOYKIK.js';
-import '../chunk-ZLONH2UD.js';
+import '../chunk-FZHF5UWR.js';
+import '../chunk-HZUB5CON.js';
+import '../chunk-YDEJQWOL.js';
 import '../chunk-DYATYRY4.js';
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/dist/{ddl-D_oW-EVO.d.ts → ddl-BvcbgzHo.d.ts}

@@ -1,6 +1,6 @@
-import { aK as FulltextStrategy } from './types-BqFZTQmV.js';
-import { P as PostgresTables } from './postgres-CcL4bAHS.js';
-import { S as SqliteTables } from './sqlite-D7Oz0SQh.js';
+import { F as FulltextStrategy } from './types-6yf0Vv-_.js';
+import { P as PostgresTables } from './postgres-BPLSVyHM.js';
+import { S as SqliteTables } from './sqlite-MZA3oZNB.js';
 
 /**
  * Declare the connection this backend serializes on, when TypeGraph cannot

package/dist/{ddl-BL1NZLMY.d.cts → ddl-Ufebz5q5.d.cts}

@@ -1,6 +1,6 @@
-import { aK as FulltextStrategy } from './types-BqFZTQmV.cjs';
-import { P as PostgresTables } from './postgres-DMj39MEu.cjs';
-import { S as SqliteTables } from './sqlite-YppHrNFb.cjs';
+import { F as FulltextStrategy } from './types-6yf0Vv-_.cjs';
+import { P as PostgresTables } from './postgres-CqvtFC2y.cjs';
+import { S as SqliteTables } from './sqlite-D1mXO9Kp.cjs';
 
 /**
  * Declare the connection this backend serializes on, when TypeGraph cannot

package/dist/graph-extension/index.cjs

@@ -1,10 +1,11 @@
 'use strict';
 
-var chunkMKJ4KXL5_cjs = require('../chunk-MKJ4KXL5.cjs');
-var chunkGYEG3ZLZ_cjs = require('../chunk-GYEG3ZLZ.cjs');
+var chunk6KQEICJ6_cjs = require('../chunk-6KQEICJ6.cjs');
+var chunkRJMHU2MG_cjs = require('../chunk-RJMHU2MG.cjs');
 require('../chunk-XUO3KQFO.cjs');
-require('../chunk-6NGW27EO.cjs');
-require('../chunk-MRDBBHIZ.cjs');
+require('../chunk-VLBTRXA2.cjs');
+require('../chunk-RWUWTJQY.cjs');
+require('../chunk-X4GDXBOP.cjs');
 require('../chunk-A7J2YDDI.cjs');
 require('../chunk-N66HCGCY.cjs');
 
@@ -12,67 +13,67 @@ require('../chunk-N66HCGCY.cjs');
 
 Object.defineProperty(exports, "defineGraphExtension", {
   enumerable: true,
-  get: function () { return chunkMKJ4KXL5_cjs.defineGraphExtension; }
+  get: function () { return chunk6KQEICJ6_cjs.defineGraphExtension; }
 });
 Object.defineProperty(exports, "CURRENT_GRAPH_EXTENSION_VERSION", {
   enumerable: true,
-  get: function () { return chunkGYEG3ZLZ_cjs.CURRENT_GRAPH_EXTENSION_VERSION; }
+  get: function () { return chunkRJMHU2MG_cjs.CURRENT_GRAPH_EXTENSION_VERSION; }
 });
 Object.defineProperty(exports, "GRAPH_EXTENSION_ISSUE_CODES", {
   enumerable: true,
-  get: function () { return chunkGYEG3ZLZ_cjs.GRAPH_EXTENSION_ISSUE_CODES; }
+  get: function () { return chunkRJMHU2MG_cjs.GRAPH_EXTENSION_ISSUE_CODES; }
 });
 Object.defineProperty(exports, "GRAPH_EXTENSION_TOP_LEVEL_KEYS", {
   enumerable: true,
-  get: function () { return chunkGYEG3ZLZ_cjs.GRAPH_EXTENSION_TOP_LEVEL_KEYS; }
+  get: function () { return chunkRJMHU2MG_cjs.GRAPH_EXTENSION_TOP_LEVEL_KEYS; }
 });
 Object.defineProperty(exports, "GraphExtensionError", {
   enumerable: true,
-  get: function () { return chunkGYEG3ZLZ_cjs.GraphExtensionError; }
+  get: function () { return chunkRJMHU2MG_cjs.GraphExtensionError; }
 });
 Object.defineProperty(exports, "GraphExtensionUnresolvedEndpointError", {
   enumerable: true,
-  get: function () { return chunkGYEG3ZLZ_cjs.GraphExtensionUnresolvedEndpointError; }
+  get: function () { return chunkRJMHU2MG_cjs.GraphExtensionUnresolvedEndpointError; }
 });
 Object.defineProperty(exports, "GraphExtensionUnresolvedOntologyEndpointError", {
   enumerable: true,
-  get: function () { return chunkGYEG3ZLZ_cjs.GraphExtensionUnresolvedOntologyEndpointError; }
+  get: function () { return chunkRJMHU2MG_cjs.GraphExtensionUnresolvedOntologyEndpointError; }
 });
 Object.defineProperty(exports, "GraphExtensionValidationError", {
   enumerable: true,
-  get: function () { return chunkGYEG3ZLZ_cjs.GraphExtensionValidationError; }
+  get: function () { return chunkRJMHU2MG_cjs.GraphExtensionValidationError; }
 });
 Object.defineProperty(exports, "GraphExtensionVersionUnsupportedError", {
   enumerable: true,
-  get: function () { return chunkGYEG3ZLZ_cjs.GraphExtensionVersionUnsupportedError; }
+  get: function () { return chunkRJMHU2MG_cjs.GraphExtensionVersionUnsupportedError; }
 });
 Object.defineProperty(exports, "INCOMPATIBLE_CHANGE_TYPES", {
   enumerable: true,
-  get: function () { return chunkGYEG3ZLZ_cjs.INCOMPATIBLE_CHANGE_TYPES; }
+  get: function () { return chunkRJMHU2MG_cjs.INCOMPATIBLE_CHANGE_TYPES; }
 });
 Object.defineProperty(exports, "IncompatibleChangeError", {
   enumerable: true,
-  get: function () { return chunkGYEG3ZLZ_cjs.IncompatibleChangeError; }
+  get: function () { return chunkRJMHU2MG_cjs.IncompatibleChangeError; }
 });
 Object.defineProperty(exports, "KindCollisionError", {
   enumerable: true,
-  get: function () { return chunkGYEG3ZLZ_cjs.KindCollisionError; }
+  get: function () { return chunkRJMHU2MG_cjs.KindCollisionError; }
 });
 Object.defineProperty(exports, "KindHasReferentsError", {
   enumerable: true,
-  get: function () { return chunkGYEG3ZLZ_cjs.KindHasReferentsError; }
+  get: function () { return chunkRJMHU2MG_cjs.KindHasReferentsError; }
 });
 Object.defineProperty(exports, "LEGACY_GRAPH_EXTENSION_VERSION", {
   enumerable: true,
-  get: function () { return chunkGYEG3ZLZ_cjs.LEGACY_GRAPH_EXTENSION_VERSION; }
+  get: function () { return chunkRJMHU2MG_cjs.LEGACY_GRAPH_EXTENSION_VERSION; }
 });
 Object.defineProperty(exports, "RemoveCompileTimeKindError", {
   enumerable: true,
-  get: function () { return chunkGYEG3ZLZ_cjs.RemoveCompileTimeKindError; }
+  get: function () { return chunkRJMHU2MG_cjs.RemoveCompileTimeKindError; }
 });
 Object.defineProperty(exports, "validateGraphExtension", {
   enumerable: true,
-  get: function () { return chunkGYEG3ZLZ_cjs.validateGraphExtension; }
+  get: function () { return chunkRJMHU2MG_cjs.validateGraphExtension; }
 });
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map

package/dist/graph-extension/index.d.cts

@@ -1,9 +1,7 @@
-import { aP as GraphExtension, bj as KindEntity } from '../types-BqFZTQmV.cjs';
-export { du as CURRENT_GRAPH_EXTENSION_VERSION, ab as ExtensionArrayItemType, ac as ExtensionArrayProperty, ad as ExtensionBooleanProperty, ae as ExtensionEdgeDef, af as ExtensionEdgeIndex, ag as ExtensionEmbeddingModifier, ah as ExtensionEnumProperty, ai as ExtensionIndex, aj as ExtensionIndexWhere, ak as ExtensionNodeDef, al as ExtensionNodeIndex, am as ExtensionNumberProperty, an as ExtensionObjectFieldProperty, ao as ExtensionObjectProperty, ap as ExtensionOntologyRelation, ar as ExtensionPropertyType, as as ExtensionSearchableModifier, at as ExtensionStringProperty, au as ExtensionUniqueConstraint, av as ExtensionUniqueWhere, eu as GRAPH_EXTENSION_TOP_LEVEL_KEYS, ev as GraphExtensionTopLevelKey, aQ as GraphExtensionVersion, dL as LEGACY_GRAPH_EXTENSION_VERSION } from '../types-BqFZTQmV.cjs';
-import { aj as TypeGraphError, w as ErrorCategory } from '../index-COs_z6nV.cjs';
+import { b3 as GraphExtension, fO as TypeGraphError, eD as ErrorCategory, K as KindEntity } from '../types-6yf0Vv-_.cjs';
+export { e8 as CURRENT_GRAPH_EXTENSION_VERSION, at as ExtensionArrayItemType, au as ExtensionArrayProperty, av as ExtensionBooleanProperty, aw as ExtensionEdgeDef, ax as ExtensionEdgeIndex, ay as ExtensionEmbeddingModifier, az as ExtensionEnumProperty, aA as ExtensionIndex, aB as ExtensionIndexWhere, aC as ExtensionNodeDef, aD as ExtensionNodeIndex, aE as ExtensionNumberProperty, aF as ExtensionObjectFieldProperty, aG as ExtensionObjectProperty, aH as ExtensionOntologyRelation, aJ as ExtensionPropertyType, aK as ExtensionSearchableModifier, aL as ExtensionStringProperty, aM as ExtensionUniqueConstraint, aN as ExtensionUniqueWhere, gx as GRAPH_EXTENSION_TOP_LEVEL_KEYS, gy as GraphExtensionTopLevelKey, b4 as GraphExtensionVersion, f4 as LEGACY_GRAPH_EXTENSION_VERSION } from '../types-6yf0Vv-_.cjs';
 import { R as Result } from '../result-DWo6mUVz.cjs';
 import 'zod';
-import '../materialize-indexes-DTtAnvfY.cjs';
 
 /**
  * Validates and freezes a graph-extension document.

package/dist/graph-extension/index.d.ts

@@ -1,9 +1,7 @@
-import { aP as GraphExtension, bj as KindEntity } from '../types-BqFZTQmV.js';
-export { du as CURRENT_GRAPH_EXTENSION_VERSION, ab as ExtensionArrayItemType, ac as ExtensionArrayProperty, ad as ExtensionBooleanProperty, ae as ExtensionEdgeDef, af as ExtensionEdgeIndex, ag as ExtensionEmbeddingModifier, ah as ExtensionEnumProperty, ai as ExtensionIndex, aj as ExtensionIndexWhere, ak as ExtensionNodeDef, al as ExtensionNodeIndex, am as ExtensionNumberProperty, an as ExtensionObjectFieldProperty, ao as ExtensionObjectProperty, ap as ExtensionOntologyRelation, ar as ExtensionPropertyType, as as ExtensionSearchableModifier, at as ExtensionStringProperty, au as ExtensionUniqueConstraint, av as ExtensionUniqueWhere, eu as GRAPH_EXTENSION_TOP_LEVEL_KEYS, ev as GraphExtensionTopLevelKey, aQ as GraphExtensionVersion, dL as LEGACY_GRAPH_EXTENSION_VERSION } from '../types-BqFZTQmV.js';
-import { aj as TypeGraphError, w as ErrorCategory } from '../index-D7d1u2gr.js';
+import { b3 as GraphExtension, fO as TypeGraphError, eD as ErrorCategory, K as KindEntity } from '../types-6yf0Vv-_.js';
+export { e8 as CURRENT_GRAPH_EXTENSION_VERSION, at as ExtensionArrayItemType, au as ExtensionArrayProperty, av as ExtensionBooleanProperty, aw as ExtensionEdgeDef, ax as ExtensionEdgeIndex, ay as ExtensionEmbeddingModifier, az as ExtensionEnumProperty, aA as ExtensionIndex, aB as ExtensionIndexWhere, aC as ExtensionNodeDef, aD as ExtensionNodeIndex, aE as ExtensionNumberProperty, aF as ExtensionObjectFieldProperty, aG as ExtensionObjectProperty, aH as ExtensionOntologyRelation, aJ as ExtensionPropertyType, aK as ExtensionSearchableModifier, aL as ExtensionStringProperty, aM as ExtensionUniqueConstraint, aN as ExtensionUniqueWhere, gx as GRAPH_EXTENSION_TOP_LEVEL_KEYS, gy as GraphExtensionTopLevelKey, b4 as GraphExtensionVersion, f4 as LEGACY_GRAPH_EXTENSION_VERSION } from '../types-6yf0Vv-_.js';
 import { R as Result } from '../result-DWo6mUVz.js';
 import 'zod';
-import '../materialize-indexes-DJ3ykH59.js';
 
 /**
  * Validates and freezes a graph-extension document.