@nicia-ai/typegraph 0.65.0 → 0.66.0

package/dist/{chunk-BBOMNH44.js → chunk-BABP4D5B.js}

@@ -1,4 +1,4 @@
-import { createSqlSchema } from './chunk-AD3NLSV5.js';
+import { createSqlSchema } from './chunk-TU22BFMP.js';
 
 // src/backend/table-names.ts
 var LEGACY_EMBEDDINGS_TABLE_NAME = "typegraph_node_embeddings";
@@ -16,5 +16,5 @@ function resolvedTableNames(backend, override) {
 }
 
 export { LEGACY_EMBEDDINGS_TABLE_NAME, resolvedTableNames };
-//# sourceMappingURL=chunk-BBOMNH44.js.map
-//# sourceMappingURL=chunk-BBOMNH44.js.map
+//# sourceMappingURL=chunk-BABP4D5B.js.map
+//# sourceMappingURL=chunk-BABP4D5B.js.map

package/dist/{chunk-BBOMNH44.js.map → chunk-BABP4D5B.js.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/backend/table-names.ts"],"names":[],"mappings":";;;AAiBO,IAAM,4BAAA,GAA+B;AAE5C,SAAS,0BACP,QAAA,EACwB;AACxB,EAAA,IAAI,QAAA,KAAa,MAAA,EAAW,OAAO,EAAC;AACpC,EAAA,OAAO,MAAA,CAAO,WAAA;AAAA,IACZ,MAAA,CAAO,OAAA,CAAQ,QAAQ,CAAA,CAAE,MAAA,CAAO,CAAC,GAAG,SAAS,CAAA,KAAM,SAAA,KAAc,MAAS;AAAA,GAC5E;AACF;AAYO,SAAS,kBAAA,CACd,SACA,QAAA,EACuB;AACvB,EAAA,OAAO,eAAA,CAAgB;AAAA,IACrB,GAAG,OAAA,CAAQ,UAAA;AAAA,IACX,GAAG,0BAA0B,QAAQ;AAAA,GACtC,CAAA,CAAE,MAAA;AACL","file":"chunk-BBOMNH44.js","sourcesContent":["/**\n * The one owner of \"which physical relations does this offline operation\n * touch?\" for the maintenance entrypoints that accept a `tableNames` override.\n */\nimport {\n  createSqlSchema,\n  type ResolvedSqlTableNames,\n  type SqlTableNames,\n} from \"../query/compiler/schema\";\nimport type { GraphBackend } from \"./types\";\n\n/**\n * Physical name of the legacy single shared embeddings table, dropped in\n * the cross-backend vector cutover (the clean cut of #157). Strategies now\n * own per-`(nodeKind, fieldPath)` typed storage. Retained only so the\n * one-time migration utility can address and drain the old table.\n */\nexport const LEGACY_EMBEDDINGS_TABLE_NAME = \"typegraph_node_embeddings\";\n\nfunction definedTableNameOverrides(\n  override: Partial<SqlTableNames> | undefined,\n): Partial<SqlTableNames> {\n  if (override === undefined) return {};\n  return Object.fromEntries(\n    Object.entries(override).filter(([, tableName]) => tableName !== undefined),\n  );\n}\n\n/**\n * Resolves the relations an offline maintenance call targets.\n *\n * An override is a PATCH over the backend's own names. This matches the\n * `Partial<SqlTableNames>` input contract: naming only `nodes`, for example,\n * must not silently retarget edges and recorded relations to the built-in\n * defaults. `migrateLegacyRecordedTime` and\n * `repairInvertedValidityWindows` share this owner so an offline write can never\n * resolve the same partial override two different ways.\n */\nexport function resolvedTableNames(\n  backend: Pick<GraphBackend, \"tableNames\">,\n  override: Partial<SqlTableNames> | undefined,\n): ResolvedSqlTableNames {\n  return createSqlSchema({\n    ...backend.tableNames,\n    ...definedTableNameOverrides(override),\n  }).tables;\n}\n"]}
+{"version":3,"sources":["../src/backend/table-names.ts"],"names":[],"mappings":";;;AAiBO,IAAM,4BAAA,GAA+B;AAE5C,SAAS,0BACP,QAAA,EACwB;AACxB,EAAA,IAAI,QAAA,KAAa,MAAA,EAAW,OAAO,EAAC;AACpC,EAAA,OAAO,MAAA,CAAO,WAAA;AAAA,IACZ,MAAA,CAAO,OAAA,CAAQ,QAAQ,CAAA,CAAE,MAAA,CAAO,CAAC,GAAG,SAAS,CAAA,KAAM,SAAA,KAAc,MAAS;AAAA,GAC5E;AACF;AAYO,SAAS,kBAAA,CACd,SACA,QAAA,EACuB;AACvB,EAAA,OAAO,eAAA,CAAgB;AAAA,IACrB,GAAG,OAAA,CAAQ,UAAA;AAAA,IACX,GAAG,0BAA0B,QAAQ;AAAA,GACtC,CAAA,CAAE,MAAA;AACL","file":"chunk-BABP4D5B.js","sourcesContent":["/**\n * The one owner of \"which physical relations does this offline operation\n * touch?\" for the maintenance entrypoints that accept a `tableNames` override.\n */\nimport {\n  createSqlSchema,\n  type ResolvedSqlTableNames,\n  type SqlTableNames,\n} from \"../query/compiler/schema\";\nimport type { GraphBackend } from \"./types\";\n\n/**\n * Physical name of the legacy single shared embeddings table, dropped in\n * the cross-backend vector cutover (the clean cut of #157). Strategies now\n * own per-`(nodeKind, fieldPath)` typed storage. Retained only so the\n * one-time migration utility can address and drain the old table.\n */\nexport const LEGACY_EMBEDDINGS_TABLE_NAME = \"typegraph_node_embeddings\";\n\nfunction definedTableNameOverrides(\n  override: Partial<SqlTableNames> | undefined,\n): Partial<SqlTableNames> {\n  if (override === undefined) return {};\n  return Object.fromEntries(\n    Object.entries(override).filter(([, tableName]) => tableName !== undefined),\n  );\n}\n\n/**\n * Resolves the relations an offline maintenance call targets.\n *\n * An override is a PATCH over the backend's own names. This matches the\n * `Partial<SqlTableNames>` input contract: naming only `nodes`, for example,\n * must not silently retarget edges and recorded relations to the built-in\n * defaults. `migrateLegacyRecordedTime` and\n * `repairInvertedValidityWindows` share this owner so an offline write can never\n * resolve the same partial override two different ways.\n */\nexport function resolvedTableNames(\n  backend: Pick<GraphBackend, \"tableNames\">,\n  override: Partial<SqlTableNames> | undefined,\n): ResolvedSqlTableNames {\n  return createSqlSchema({\n    ...backend.tableNames,\n    ...definedTableNameOverrides(override),\n  }).tables;\n}\n"]}

package/dist/{chunk-EVGZ2TRQ.js → chunk-BE75G3M5.js}

@@ -1,4 +1,4 @@
-import { CLAIMS, UNIQUE_SIDECAR_BATCH, BATCH_POINT_READ, ENDPOINT_SET_READ, STATEMENT_EXECUTION, CONTRIBUTION_HEALTH, RECORDED_REVISION_ORIGINS } from './chunk-AD3NLSV5.js';
+import { CLAIMS, UNIQUE_SIDECAR_BATCH, BATCH_POINT_READ, ENDPOINT_SET_READ, STATEMENT_EXECUTION, CONTRIBUTION_HEALTH, RECORDED_REVISION_ORIGINS } from './chunk-TU22BFMP.js';
 import { requireDefined, createDataKeyedBag } from './chunk-QD2JFTSL.js';
 import { ConfigurationError } from './chunk-GMKPIYHY.js';
 
@@ -187,5 +187,5 @@ function requireCatalog(backend, operation) {
 }
 
 export { REVISION_COLUMN_KINDS, WALL_TIME_COLUMN_KINDS, batchPointReadVerdict, claimsVerdict, contributionHealthVerdict, createClaimsVerdictThunk, endpointSetReadVerdict, missingRequiredExtras, recordedRevisionOriginsVerdict, requireCatalog, requireExtras, resolveBundle, statementExecutionVerdict, uniqueSidecarBatchVerdict };
-//# sourceMappingURL=chunk-EVGZ2TRQ.js.map
-//# sourceMappingURL=chunk-EVGZ2TRQ.js.map
+//# sourceMappingURL=chunk-BE75G3M5.js.map
+//# sourceMappingURL=chunk-BE75G3M5.js.map

package/dist/{chunk-EVGZ2TRQ.js.map → chunk-BE75G3M5.js.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/backend/capabilities/resolve.ts","../src/backend/capabilities/catalog.ts"],"names":[],"mappings":"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","file":"chunk-EVGZ2TRQ.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  ENDPOINT_SET_READ,\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 seven 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 endpointSetReadVerdict(\n  backend: GraphBackend,\n): BundleVerdictOf<typeof ENDPOINT_SET_READ> {\n  return resolveBundle(backend, ENDPOINT_SET_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 backend's optional catalog-introspection surface: physical-schema\n * probes a store path consults directly, spelled once per dialect by the\n * two bundled profiles instead of a `dialect === \"postgres\"` branch at each\n * call site.\n *\n * Every member is a read-only probe except `dropInvalidIndex`, which issues\n * the one DDL statement that heals a crashed concurrent index build.\n * Nothing here writes a graph row, a sidecar row, or a status row.\n */\nimport { ConfigurationError } from \"../../errors\";\nimport { type GraphBackend } from \"../types\";\n\n/**\n * A physical index's presence and, on engines that can leave a build\n * half-finished, whether the leftover is usable.\n *\n * `invalid` is PostgreSQL's `pg_index.indisvalid = false` — an interrupted\n * `CREATE INDEX CONCURRENTLY` leaves a same-named index behind that a later\n * `IF NOT EXISTS` build would otherwise accept silently. SQLite has no such\n * state: `invalid` is always `false` there, and `exists` alone is the whole\n * answer.\n */\nexport type IndexState = Readonly<{\n  /** The physical SQL index name that was probed. */\n  name: string;\n  /** Whether an index with this name exists in the engine catalog. */\n  exists: boolean;\n  /** PostgreSQL's invalid-build leftover flag; always `false` on SQLite. */\n  invalid: boolean;\n}>;\n\n/**\n * A physical column's declared type, reduced to the family the two callers\n * that classify a recorded-time column actually distinguish: an integer\n * counter, text (SQLite's affinity for a wall-clock column stored as an\n * ISO-8601 string), PostgreSQL's exact `timestamp with time zone`, or\n * anything else. Kept this coarse on purpose — no caller needs a finer\n * classification, and each dialect's own probe decides which of these a\n * given declared type maps to, using that engine's own type rules (exact\n * match on PostgreSQL, affinity on SQLite).\n *\n * PostgreSQL's own normalizer never reports `\"text\"` — a declared `text`\n * column on that dialect falls through to `\"other\"`, since nothing\n * PostgreSQL-side stores a recorded-time column that way. That asymmetry is\n * why a revision or wall-time comparison must compare against\n * {@link REVISION_COLUMN_KINDS} / {@link WALL_TIME_COLUMN_KINDS} rather than\n * a single literal: the two dialects agree on the revision kind but not on\n * the wall-time one.\n */\nexport type NormalizedColumnKind =\n  \"integer\" | \"text\" | \"timestamp-with-time-zone\" | \"other\";\n\n/**\n * The `columnTypes` kinds that count as a revision counter. Both dialects\n * normalize one to `\"integer\"`, so this is a single-member set today — named\n * and exported so a caller compares against ONE owned set instead of\n * re-spelling `=== \"integer\"` inline. Consumed by\n * `store/recorded-capture/schema-version.ts`'s `isCompatibleColumnKind`,\n * which replaced that file's dialect-branching `isCompatibleColumnType` and\n * its SQLite-affinity twin (`hasSqliteAffinity`) with this owned set.\n */\nexport const REVISION_COLUMN_KINDS: readonly NormalizedColumnKind[] = [\n  \"integer\",\n];\n\n/**\n * The `columnTypes` kinds that count as a wall-clock timestamp. SQLite\n * stores one as an ISO-8601 string (`\"text\"`); PostgreSQL stores one as\n * `timestamp with time zone` (`\"timestamp-with-time-zone\"`) and never\n * normalizes a declared column to `\"text\"` at all — so this set stays exact\n * on both dialects without a caller ever branching on `dialect`. Consumed\n * by `store/recorded-capture/schema-version.ts`'s `isCompatibleColumnKind`,\n * alongside {@link REVISION_COLUMN_KINDS}.\n */\nexport const WALL_TIME_COLUMN_KINDS: readonly NormalizedColumnKind[] = [\n  \"text\",\n  \"timestamp-with-time-zone\",\n];\n\n/**\n * One physical column's name, normalized type family, and raw declared\n * type — trimmed and lower-cased, but otherwise exactly what the engine's\n * own catalog reports (`\"bigint\"`, `\"timestamp with time zone\"`, a SQLite\n * declared type such as `\"integer\"` or `\"text\"`, and so on). `kind` is what\n * a comparison should classify against; `declaredType` is what a\n * diagnostic should show a human, since `kind` discards the declared\n * spelling entirely.\n */\nexport type CatalogColumn = Readonly<{\n  name: string;\n  kind: NormalizedColumnKind;\n  declaredType: string;\n}>;\n\n/** One physical table's catalog presence. See {@link BackendCatalogProbes.tablesExist}. */\nexport type TableState = Readonly<{\n  /** The physical SQL table name that was probed. */\n  name: string;\n  /** Whether a table with this name exists in the engine catalog. */\n  exists: boolean;\n}>;\n\n/**\n * The three facts index materialization used to keep in its own\n * dialect-keyed record: whether this engine can build an index\n * concurrently (without blocking readers/writers), whether a concurrent\n * build can be interrupted into a usable-but-invalid leftover, and whether\n * it offers the GIN index family fulltext/trigram indexing needs.\n */\nexport type CatalogIndexBehavior = Readonly<{\n  concurrentBuilds: boolean;\n  hasInvalidIndexState: boolean;\n  supportsGinFamily: boolean;\n}>;\n\n/**\n * Physical-schema introspection a store path consults directly: table and\n * index presence, PostgreSQL's invalid-index leftover state and its\n * self-heal, normalized column types, and the per-dialect index-build\n * facts above.\n *\n * Optional: a custom backend that omits it loses the store paths that\n * consult it directly — index materialization (`store.materializeIndexes()`\n * refuses only once its empty-candidate short circuit and the status-table\n * ensure step have already run; `store.materializeSystemIndexes()`, which\n * has no candidate short circuit, refuses only once that same status-table\n * ensure step has run), the recorded-time schema check, and the\n * recorded-time migration's column read.\n */\nexport type BackendCatalogProbes = Readonly<{\n  /**\n   * Whether a table with this physical name exists in the engine catalog —\n   * on PostgreSQL, anything an unqualified `DELETE`/`ANALYZE` against the\n   * name could hit (ordinary and partitioned tables, views, materialized\n   * views, foreign tables), matching the dialect operation strategy's own\n   * DDL-target probe. A caller that means specifically \"is this a TABLE\",\n   * as opposed to any relation an unqualified statement could resolve to,\n   * wants {@link BackendCatalogProbes.tablesExist} instead — its narrower\n   * predicate excludes views, materialized views, and foreign tables.\n   */\n  tableExists: (this: void, name: string) => Promise<boolean>;\n  /**\n   * The catalog state of each named physical TABLE, one entry per input\n   * name (an absent name reports `exists: false`), resolved in one round\n   * trip. On PostgreSQL this is ordinary and partitioned tables only\n   * (`relkind IN ('r', 'p')`) — narrower than {@link tableExists}, which\n   * also matches views, materialized views, and foreign tables. A caller\n   * gating bulk, table-scoped work (a preload ahead of table DDL, say)\n   * wants this member so it gets one round trip and the strict predicate,\n   * rather than looping {@link tableExists} or accepting its wider match.\n   */\n  tablesExist: (\n    this: void,\n    names: readonly string[],\n  ) => Promise<readonly TableState[]>;\n  /**\n   * The catalog state of each named physical index, one entry per input\n   * name (an absent index reports `exists: false`), resolved in one\n   * round trip.\n   */\n  indexStates: (\n    this: void,\n    names: readonly string[],\n  ) => Promise<readonly IndexState[]>;\n  /**\n   * Drops the named index if — and only if — it is a PostgreSQL INVALID\n   * leftover from an interrupted `CREATE INDEX CONCURRENTLY`. A no-op on\n   * an engine whose `indexBehavior.hasInvalidIndexState` is `false`, and\n   * a no-op for a valid or absent index on every engine.\n   *\n   * A ROOT-BACKEND operation on an engine with an invalid-index state:\n   * PostgreSQL refuses `DROP INDEX CONCURRENTLY` inside a transaction\n   * block, so there the `catalog` a `transaction()` handle exposes throws a\n   * typed `ConfigurationError` from this member instead of attempting the\n   * DDL. An engine whose `indexBehavior.hasInvalidIndexState` is `false`\n   * (SQLite) has no invalid leftover to ever drop and stays a no-op in\n   * both scopes — every other member here stays a plain read on that same\n   * transaction-scoped bag regardless of engine.\n   */\n  dropInvalidIndex: (this: void, name: string) => Promise<void>;\n  /** Every column's name and normalized type family for one physical table. */\n  columnTypes: (this: void, table: string) => Promise<readonly CatalogColumn[]>;\n  /** This engine's index-build facts. See {@link CatalogIndexBehavior}. */\n  indexBehavior: CatalogIndexBehavior;\n}>;\n\n/**\n * THE refusal for a store path that needs the backend's catalog probes and\n * finds them absent, naming the missing port so a caller can add it — or\n * switch to a bundled backend — instead of chasing a `TypeError` two calls\n * deep into `materializeIndexes` or a recorded-time migration.\n */\nexport function requireCatalog(\n  backend: Pick<GraphBackend, \"catalog\">,\n  operation: string,\n): BackendCatalogProbes {\n  const catalog = backend.catalog;\n  if (catalog === undefined) {\n    throw new ConfigurationError(\n      `${operation} requires the backend's catalog probes, but this backend declares no \\`catalog\\`.`,\n      { code: \"CATALOG_UNAVAILABLE\", operation },\n      {\n        suggestion:\n          \"Implement `catalog` on this backend, or use a built-in SQLite or PostgreSQL backend.\",\n      },\n    );\n  }\n  return catalog;\n}\n"]}
+{"version":3,"sources":["../src/backend/capabilities/resolve.ts","../src/backend/capabilities/catalog.ts"],"names":[],"mappings":"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","file":"chunk-BE75G3M5.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  ENDPOINT_SET_READ,\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 seven 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 endpointSetReadVerdict(\n  backend: GraphBackend,\n): BundleVerdictOf<typeof ENDPOINT_SET_READ> {\n  return resolveBundle(backend, ENDPOINT_SET_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 backend's optional catalog-introspection surface: physical-schema\n * probes a store path consults directly, spelled once per dialect by the\n * two bundled profiles instead of a `dialect === \"postgres\"` branch at each\n * call site.\n *\n * Every member is a read-only probe except `dropInvalidIndex`, which issues\n * the one DDL statement that heals a crashed concurrent index build.\n * Nothing here writes a graph row, a sidecar row, or a status row.\n */\nimport { ConfigurationError } from \"../../errors\";\nimport { type GraphBackend } from \"../types\";\n\n/**\n * A physical index's presence and, on engines that can leave a build\n * half-finished, whether the leftover is usable.\n *\n * `invalid` is PostgreSQL's `pg_index.indisvalid = false` — an interrupted\n * `CREATE INDEX CONCURRENTLY` leaves a same-named index behind that a later\n * `IF NOT EXISTS` build would otherwise accept silently. SQLite has no such\n * state: `invalid` is always `false` there, and `exists` alone is the whole\n * answer.\n */\nexport type IndexState = Readonly<{\n  /** The physical SQL index name that was probed. */\n  name: string;\n  /** Whether an index with this name exists in the engine catalog. */\n  exists: boolean;\n  /** PostgreSQL's invalid-build leftover flag; always `false` on SQLite. */\n  invalid: boolean;\n}>;\n\n/**\n * A physical column's declared type, reduced to the family the two callers\n * that classify a recorded-time column actually distinguish: an integer\n * counter, text (SQLite's affinity for a wall-clock column stored as an\n * ISO-8601 string), PostgreSQL's exact `timestamp with time zone`, or\n * anything else. Kept this coarse on purpose — no caller needs a finer\n * classification, and each dialect's own probe decides which of these a\n * given declared type maps to, using that engine's own type rules (exact\n * match on PostgreSQL, affinity on SQLite).\n *\n * PostgreSQL's own normalizer never reports `\"text\"` — a declared `text`\n * column on that dialect falls through to `\"other\"`, since nothing\n * PostgreSQL-side stores a recorded-time column that way. That asymmetry is\n * why a revision or wall-time comparison must compare against\n * {@link REVISION_COLUMN_KINDS} / {@link WALL_TIME_COLUMN_KINDS} rather than\n * a single literal: the two dialects agree on the revision kind but not on\n * the wall-time one.\n */\nexport type NormalizedColumnKind =\n  \"integer\" | \"text\" | \"timestamp-with-time-zone\" | \"other\";\n\n/**\n * The `columnTypes` kinds that count as a revision counter. Both dialects\n * normalize one to `\"integer\"`, so this is a single-member set today — named\n * and exported so a caller compares against ONE owned set instead of\n * re-spelling `=== \"integer\"` inline. Consumed by\n * `store/recorded-capture/schema-version.ts`'s `isCompatibleColumnKind`,\n * which replaced that file's dialect-branching `isCompatibleColumnType` and\n * its SQLite-affinity twin (`hasSqliteAffinity`) with this owned set.\n */\nexport const REVISION_COLUMN_KINDS: readonly NormalizedColumnKind[] = [\n  \"integer\",\n];\n\n/**\n * The `columnTypes` kinds that count as a wall-clock timestamp. SQLite\n * stores one as an ISO-8601 string (`\"text\"`); PostgreSQL stores one as\n * `timestamp with time zone` (`\"timestamp-with-time-zone\"`) and never\n * normalizes a declared column to `\"text\"` at all — so this set stays exact\n * on both dialects without a caller ever branching on `dialect`. Consumed\n * by `store/recorded-capture/schema-version.ts`'s `isCompatibleColumnKind`,\n * alongside {@link REVISION_COLUMN_KINDS}.\n */\nexport const WALL_TIME_COLUMN_KINDS: readonly NormalizedColumnKind[] = [\n  \"text\",\n  \"timestamp-with-time-zone\",\n];\n\n/**\n * One physical column's name, normalized type family, and raw declared\n * type — trimmed and lower-cased, but otherwise exactly what the engine's\n * own catalog reports (`\"bigint\"`, `\"timestamp with time zone\"`, a SQLite\n * declared type such as `\"integer\"` or `\"text\"`, and so on). `kind` is what\n * a comparison should classify against; `declaredType` is what a\n * diagnostic should show a human, since `kind` discards the declared\n * spelling entirely.\n */\nexport type CatalogColumn = Readonly<{\n  name: string;\n  kind: NormalizedColumnKind;\n  declaredType: string;\n}>;\n\n/** One physical table's catalog presence. See {@link BackendCatalogProbes.tablesExist}. */\nexport type TableState = Readonly<{\n  /** The physical SQL table name that was probed. */\n  name: string;\n  /** Whether a table with this name exists in the engine catalog. */\n  exists: boolean;\n}>;\n\n/**\n * The three facts index materialization used to keep in its own\n * dialect-keyed record: whether this engine can build an index\n * concurrently (without blocking readers/writers), whether a concurrent\n * build can be interrupted into a usable-but-invalid leftover, and whether\n * it offers the GIN index family fulltext/trigram indexing needs.\n */\nexport type CatalogIndexBehavior = Readonly<{\n  concurrentBuilds: boolean;\n  hasInvalidIndexState: boolean;\n  supportsGinFamily: boolean;\n}>;\n\n/**\n * Physical-schema introspection a store path consults directly: table and\n * index presence, PostgreSQL's invalid-index leftover state and its\n * self-heal, normalized column types, and the per-dialect index-build\n * facts above.\n *\n * Optional: a custom backend that omits it loses the store paths that\n * consult it directly — index materialization (`store.materializeIndexes()`\n * refuses only once its empty-candidate short circuit and the status-table\n * ensure step have already run; `store.materializeSystemIndexes()`, which\n * has no candidate short circuit, refuses only once that same status-table\n * ensure step has run), the recorded-time schema check, and the\n * recorded-time migration's column read.\n */\nexport type BackendCatalogProbes = Readonly<{\n  /**\n   * Whether a table with this physical name exists in the engine catalog —\n   * on PostgreSQL, anything an unqualified `DELETE`/`ANALYZE` against the\n   * name could hit (ordinary and partitioned tables, views, materialized\n   * views, foreign tables), matching the dialect operation strategy's own\n   * DDL-target probe. A caller that means specifically \"is this a TABLE\",\n   * as opposed to any relation an unqualified statement could resolve to,\n   * wants {@link BackendCatalogProbes.tablesExist} instead — its narrower\n   * predicate excludes views, materialized views, and foreign tables.\n   */\n  tableExists: (this: void, name: string) => Promise<boolean>;\n  /**\n   * The catalog state of each named physical TABLE, one entry per input\n   * name (an absent name reports `exists: false`), resolved in one round\n   * trip. On PostgreSQL this is ordinary and partitioned tables only\n   * (`relkind IN ('r', 'p')`) — narrower than {@link tableExists}, which\n   * also matches views, materialized views, and foreign tables. A caller\n   * gating bulk, table-scoped work (a preload ahead of table DDL, say)\n   * wants this member so it gets one round trip and the strict predicate,\n   * rather than looping {@link tableExists} or accepting its wider match.\n   */\n  tablesExist: (\n    this: void,\n    names: readonly string[],\n  ) => Promise<readonly TableState[]>;\n  /**\n   * The catalog state of each named physical index, one entry per input\n   * name (an absent index reports `exists: false`), resolved in one\n   * round trip.\n   */\n  indexStates: (\n    this: void,\n    names: readonly string[],\n  ) => Promise<readonly IndexState[]>;\n  /**\n   * Drops the named index if — and only if — it is a PostgreSQL INVALID\n   * leftover from an interrupted `CREATE INDEX CONCURRENTLY`. A no-op on\n   * an engine whose `indexBehavior.hasInvalidIndexState` is `false`, and\n   * a no-op for a valid or absent index on every engine.\n   *\n   * A ROOT-BACKEND operation on an engine with an invalid-index state:\n   * PostgreSQL refuses `DROP INDEX CONCURRENTLY` inside a transaction\n   * block, so there the `catalog` a `transaction()` handle exposes throws a\n   * typed `ConfigurationError` from this member instead of attempting the\n   * DDL. An engine whose `indexBehavior.hasInvalidIndexState` is `false`\n   * (SQLite) has no invalid leftover to ever drop and stays a no-op in\n   * both scopes — every other member here stays a plain read on that same\n   * transaction-scoped bag regardless of engine.\n   */\n  dropInvalidIndex: (this: void, name: string) => Promise<void>;\n  /** Every column's name and normalized type family for one physical table. */\n  columnTypes: (this: void, table: string) => Promise<readonly CatalogColumn[]>;\n  /** This engine's index-build facts. See {@link CatalogIndexBehavior}. */\n  indexBehavior: CatalogIndexBehavior;\n}>;\n\n/**\n * THE refusal for a store path that needs the backend's catalog probes and\n * finds them absent, naming the missing port so a caller can add it — or\n * switch to a bundled backend — instead of chasing a `TypeError` two calls\n * deep into `materializeIndexes` or a recorded-time migration.\n */\nexport function requireCatalog(\n  backend: Pick<GraphBackend, \"catalog\">,\n  operation: string,\n): BackendCatalogProbes {\n  const catalog = backend.catalog;\n  if (catalog === undefined) {\n    throw new ConfigurationError(\n      `${operation} requires the backend's catalog probes, but this backend declares no \\`catalog\\`.`,\n      { code: \"CATALOG_UNAVAILABLE\", operation },\n      {\n        suggestion:\n          \"Implement `catalog` on this backend, or use a built-in SQLite or PostgreSQL backend.\",\n      },\n    );\n  }\n  return catalog;\n}\n"]}

package/dist/{chunk-FXGZT3WO.cjs → chunk-BX42F7IJ.cjs}

@@ -2,10 +2,10 @@
 
 var chunk6YKISECL_cjs = require('./chunk-6YKISECL.cjs');
 var chunkICOTLZBV_cjs = require('./chunk-ICOTLZBV.cjs');
-var chunkSNDJUTMB_cjs = require('./chunk-SNDJUTMB.cjs');
-var chunkBWQA3POT_cjs = require('./chunk-BWQA3POT.cjs');
-var chunkJRWKRBI5_cjs = require('./chunk-JRWKRBI5.cjs');
-var chunkOC5ROP7V_cjs = require('./chunk-OC5ROP7V.cjs');
+var chunkEBQX7MYL_cjs = require('./chunk-EBQX7MYL.cjs');
+var chunk6B3LQUYG_cjs = require('./chunk-6B3LQUYG.cjs');
+var chunk5JOCIMQ3_cjs = require('./chunk-5JOCIMQ3.cjs');
+var chunk6JRVV2SS_cjs = require('./chunk-6JRVV2SS.cjs');
 var chunk7D2ZLF4O_cjs = require('./chunk-7D2ZLF4O.cjs');
 var chunk5ICDVLI3_cjs = require('./chunk-5ICDVLI3.cjs');
 var chunkL4L4AV6F_cjs = require('./chunk-L4L4AV6F.cjs');
@@ -585,7 +585,7 @@ async function computeSchemaHash(schema) {
     ...schema.extension === void 0 ? {} : { extension: schema.extension },
     ...schema.deprecatedKinds === void 0 ? {} : { deprecatedKinds: schema.deprecatedKinds }
   };
-  const json = JSON.stringify(hashable, chunkJRWKRBI5_cjs.sortedReplacer);
+  const json = JSON.stringify(hashable, chunk5JOCIMQ3_cjs.sortedReplacer);
   return chunkZY4GXIVN_cjs.sha256Hex(json);
 }
 
@@ -641,7 +641,7 @@ function computeSchemaDiff(before, after) {
   };
 }
 function diffGraphAnnotations(before, after) {
-  if (chunkJRWKRBI5_cjs.canonicalEqual(before ?? {}, after ?? {})) return void 0;
+  if (chunk5JOCIMQ3_cjs.canonicalEqual(before ?? {}, after ?? {})) return void 0;
   return {
     type: before === void 0 ? "added" : after === void 0 ? "removed" : "modified",
     severity: "safe",
@@ -734,7 +734,7 @@ var SUBSCHEMA_MAP_KEYWORDS = /* @__PURE__ */ new Set([
 ]);
 var DEPENDENT_REQUIRED_KEYWORD = "dependentRequired";
 function canonicalKey(value) {
-  return JSON.stringify(value, chunkJRWKRBI5_cjs.sortedReplacer);
+  return JSON.stringify(value, chunk5JOCIMQ3_cjs.sortedReplacer);
 }
 function sortedByCanonicalForm(items) {
   return items.toSorted(
@@ -786,7 +786,7 @@ function normalizedSubschemaMap(value) {
   return normalized;
 }
 function propertySchemasEqual(before, after) {
-  return chunkJRWKRBI5_cjs.canonicalEqual(
+  return chunk5JOCIMQ3_cjs.canonicalEqual(
     orderNormalizedSchema(before),
     orderNormalizedSchema(after)
   );
@@ -811,14 +811,14 @@ function getSerializedEdgePairs(edge) {
   return pairs;
 }
 function endpointKindsEqual(before, after) {
-  return chunkJRWKRBI5_cjs.canonicalEqual(before?.toSorted(), after?.toSorted());
+  return chunk5JOCIMQ3_cjs.canonicalEqual(before?.toSorted(), after?.toSorted());
 }
 function targetKindsBySourceEqual(before, after) {
   if (before === void 0 && after === void 0) return true;
   if (before === void 0 || after === void 0) return false;
   const beforeKeys = Object.keys(before).toSorted();
   const afterKeys = Object.keys(after).toSorted();
-  if (!chunkJRWKRBI5_cjs.canonicalEqual(beforeKeys, afterKeys)) return false;
+  if (!chunk5JOCIMQ3_cjs.canonicalEqual(beforeKeys, afterKeys)) return false;
   for (const key of beforeKeys) {
     if (!endpointKindsEqual(before[key], after[key])) return false;
   }
@@ -851,7 +851,7 @@ function diffNodeDef(name, before, after) {
       after
     });
   }
-  if (!chunkJRWKRBI5_cjs.canonicalEqual(before.uniqueConstraints, after.uniqueConstraints)) {
+  if (!chunk5JOCIMQ3_cjs.canonicalEqual(before.uniqueConstraints, after.uniqueConstraints)) {
     changes.push({
       type: "modified",
       kind: name,
@@ -949,7 +949,7 @@ function classifyPropertyChanges(kind, before, after) {
   for (const [property, beforeProperty] of Object.entries(beforeProps)) {
     const afterProperty = afterProps[property];
     if (afterProperty === void 0) continue;
-    if (chunkJRWKRBI5_cjs.canonicalEqual(beforeProperty, afterProperty)) continue;
+    if (chunk5JOCIMQ3_cjs.canonicalEqual(beforeProperty, afterProperty)) continue;
     if (isBreakingPropertyChange(beforeProperty, afterProperty)) {
       breakingProps.push(property);
     }
@@ -1128,7 +1128,7 @@ function isMatchIdentityChange(change) {
 function annotationsChanged(before, after) {
   if (before === void 0 && after === void 0) return false;
   if (before === void 0 || after === void 0) return true;
-  return !chunkJRWKRBI5_cjs.canonicalEqual(before, after);
+  return !chunk5JOCIMQ3_cjs.canonicalEqual(before, after);
 }
 function diffOntology(before, after) {
   const changes = [];
@@ -1227,7 +1227,7 @@ function diffIndexes(before, after) {
   for (const [name, beforeIndex] of beforeByName) {
     const afterIndex = afterByName.get(name);
     if (!afterIndex) continue;
-    if (!chunkJRWKRBI5_cjs.canonicalEqual(beforeIndex, afterIndex)) {
+    if (!chunk5JOCIMQ3_cjs.canonicalEqual(beforeIndex, afterIndex)) {
       changes.push({
         type: "modified",
         name,
@@ -1257,7 +1257,7 @@ function diffExtension(before, after) {
       details: "Graph extension document was removed"
     };
   }
-  if (chunkJRWKRBI5_cjs.canonicalEqual(before, after)) return void 0;
+  if (chunk5JOCIMQ3_cjs.canonicalEqual(before, after)) return void 0;
   return {
     type: "modified",
     severity: "safe",
@@ -1651,7 +1651,7 @@ function extensionKindNames(document) {
 function mergeGraphExtension(graph, document) {
   const existingDocument = graph.extension ?? Object.freeze({});
   const unionDocument = unionDocuments(existingDocument, document);
-  if (graph.extension !== void 0 && chunkJRWKRBI5_cjs.canonicalEqual(unionDocument, existingDocument)) {
+  if (graph.extension !== void 0 && chunk5JOCIMQ3_cjs.canonicalEqual(unionDocument, existingDocument)) {
     return graph;
   }
   const validatedUnion = chunkHQU2SE74_cjs.unwrap(chunkHQU2SE74_cjs.validateGraphExtension(unionDocument));
@@ -2245,7 +2245,7 @@ async function ensureIdentitySchemaStorage(backend, schema, options) {
     options.graphId,
     missingTables
   );
-  const rebuildRequired = await chunkSNDJUTMB_cjs.separationRebuildRequired(
+  const rebuildRequired = await chunkEBQX7MYL_cjs.separationRebuildRequired(
     backend,
     schema,
     options.graphId,
@@ -2316,7 +2316,7 @@ function markIdentityDdlRace(error) {
   return error;
 }
 function isIdentityDdlRace(error) {
-  for (const link of chunkOC5ROP7V_cjs.errorChain(error)) {
+  for (const link of chunk6JRVV2SS_cjs.errorChain(error)) {
     if (typeof link === "object" && link !== null && IDENTITY_DDL_RACES.has(link)) {
       return true;
     }
@@ -2328,7 +2328,7 @@ async function executeIdentityDdl(execute, statements) {
     try {
       await execute(statement);
     } catch (error) {
-      if (chunkOC5ROP7V_cjs.isPostgresConcurrentDdlRaceError(error)) {
+      if (chunk6JRVV2SS_cjs.isPostgresConcurrentDdlRaceError(error)) {
         throw markIdentityDdlRace(error);
       }
       throw error;
@@ -2344,8 +2344,8 @@ async function withIdentityDdlRaceRetry(attempt) {
   }
 }
 async function lockIdentityDdl(target) {
-  const plan = chunkOC5ROP7V_cjs.resolveWriteFencePlan(target);
-  const fence = chunkOC5ROP7V_cjs.requireWriteFence(plan, "identity DDL", "keyed");
+  const plan = chunk6JRVV2SS_cjs.resolveWriteFencePlan(target);
+  const fence = chunk6JRVV2SS_cjs.requireWriteFence(plan, "identity DDL", "keyed");
   switch (fence.kind) {
     case "lock":
     case "row": {
@@ -2383,7 +2383,7 @@ async function identityKindCascadeNeeded(backend, schema, graphId, droppedNodeKi
     provisionMissing: false
   });
   if (missingTables.length > 0) return false;
-  return chunkSNDJUTMB_cjs.hasAssertionsTouchingKinds(backend, schema, graphId, droppedNodeKinds);
+  return chunkEBQX7MYL_cjs.hasAssertionsTouchingKinds(backend, schema, graphId, droppedNodeKinds);
 }
 function assertIdentityStoragePresent(graphId, missingTables) {
   if (missingTables.length === 0) return;
@@ -2406,13 +2406,13 @@ function identitySchemaCommitPreflight(ctx, options) {
       ctx.graphId,
       options.provisionDerivedRelations ?? []
     );
-    await chunkBWQA3POT_cjs.lockRecordedGraphWrite(target, ctx.graphId);
-    await chunkSNDJUTMB_cjs.lockIdentityGraph(target, ctx.graphId);
+    await chunk6B3LQUYG_cjs.lockRecordedGraphWrite(target, ctx.graphId);
+    await chunkEBQX7MYL_cjs.lockIdentityGraph(target, ctx.graphId);
     if (options.enablement) {
-      await chunkSNDJUTMB_cjs.lockIdentityEnablementNodes(target, ctx.schema);
-      await chunkBWQA3POT_cjs.withRecordedIdentityMutationTarget(
+      await chunkEBQX7MYL_cjs.lockIdentityEnablementNodes(target, ctx.schema);
+      await chunk6B3LQUYG_cjs.withRecordedIdentityMutationTarget(
         target,
-        (rawTarget, touch) => chunkSNDJUTMB_cjs.purgeAssertionsWithUnregisteredKinds(
+        (rawTarget, touch) => chunkEBQX7MYL_cjs.purgeAssertionsWithUnregisteredKinds(
           rawTarget,
           ctx.schema,
           ctx.graphId,
@@ -2423,9 +2423,9 @@ function identitySchemaCommitPreflight(ctx, options) {
     }
     const droppedNodeKinds = options.droppedNodeKinds ?? [];
     if (droppedNodeKinds.length > 0) {
-      await chunkBWQA3POT_cjs.withRecordedIdentityMutationTarget(
+      await chunk6B3LQUYG_cjs.withRecordedIdentityMutationTarget(
         target,
-        (rawTarget, touch) => chunkSNDJUTMB_cjs.deleteAssertionsTouchingKinds(
+        (rawTarget, touch) => chunkEBQX7MYL_cjs.deleteAssertionsTouchingKinds(
           rawTarget,
           ctx.schema,
           ctx.graphId,
@@ -2434,7 +2434,7 @@ function identitySchemaCommitPreflight(ctx, options) {
         )
       );
     }
-    await chunkSNDJUTMB_cjs.rebuildIdentityClosureForContext({ ...ctx, backend: target });
+    await chunkEBQX7MYL_cjs.rebuildIdentityClosureForContext({ ...ctx, backend: target });
   };
 }
 async function provisionDerivedRelationsInCommit(target, graphId, ddl) {
@@ -2448,11 +2448,11 @@ async function provisionDerivedRelationsInCommit(target, graphId, ddl) {
 }
 function identityKindCascadePreflight(ctx, droppedNodeKinds) {
   return async (target) => {
-    await chunkBWQA3POT_cjs.lockRecordedGraphWrite(target, ctx.graphId);
-    await chunkSNDJUTMB_cjs.lockIdentityGraph(target, ctx.graphId);
-    await chunkBWQA3POT_cjs.withRecordedIdentityMutationTarget(
+    await chunk6B3LQUYG_cjs.lockRecordedGraphWrite(target, ctx.graphId);
+    await chunkEBQX7MYL_cjs.lockIdentityGraph(target, ctx.graphId);
+    await chunk6B3LQUYG_cjs.withRecordedIdentityMutationTarget(
       target,
-      (rawTarget, touch) => chunkSNDJUTMB_cjs.deleteAssertionsTouchingKinds(
+      (rawTarget, touch) => chunkEBQX7MYL_cjs.deleteAssertionsTouchingKinds(
         rawTarget,
         ctx.schema,
         ctx.graphId,
@@ -3159,7 +3159,7 @@ async function loadActiveSchemaWithBootstrap(backend, graphId) {
   try {
     return await backend.getActiveSchema(graphId);
   } catch (error) {
-    if (backend.bootstrapTables && chunkOC5ROP7V_cjs.isMissingTableError(error)) {
+    if (backend.bootstrapTables && chunk6JRVV2SS_cjs.isMissingTableError(error)) {
       await backend.bootstrapTables();
       return await backend.getActiveSchema(graphId);
     }
@@ -3355,7 +3355,7 @@ async function readActiveSchemaPure(backend, graphId) {
   try {
     activeRow = await backend.getActiveSchema(graphId);
   } catch (error) {
-    if (chunkOC5ROP7V_cjs.isMissingTableError(error)) {
+    if (chunk6JRVV2SS_cjs.isMissingTableError(error)) {
       throw schemaNotInitializedError(graphId, error);
     }
     throw error;
@@ -3552,7 +3552,7 @@ function assertGraphEdgeMatchIdentitySupport(backend, graph) {
   for (const [kind, registration] of Object.entries(graph.edges)) {
     const identity = registration.matchIdentity;
     if (identity === void 0) continue;
-    chunkSNDJUTMB_cjs.assertEdgeMatchIdentityBackendSupport(identity, backend.capabilities, kind);
+    chunkEBQX7MYL_cjs.assertEdgeMatchIdentityBackendSupport(identity, backend.capabilities, kind);
   }
 }
 function edgeKindsRequiringMatchIdentityMaterialization(target, storedSchema) {
@@ -3597,7 +3597,7 @@ function edgeMatchIdentityRekeyPopulatedError(graphId, currentVersion, edgeKinds
 }
 async function prepareIdentityKindCascade(backend, target, options) {
   if (options.droppedNodeKinds.length === 0) return void 0;
-  const schema = options.schema === void 0 ? chunkOC5ROP7V_cjs.createSqlSchema(backend.tableNames) : chunkOC5ROP7V_cjs.requireSqlSchema(options.schema, "The schema option");
+  const schema = options.schema === void 0 ? chunk6JRVV2SS_cjs.createSqlSchema(backend.tableNames) : chunk6JRVV2SS_cjs.requireSqlSchema(options.schema, "The schema option");
   if (options.probeBeforeCascade) {
     const needed = await identityKindCascadeNeeded(
       backend,
@@ -3613,7 +3613,7 @@ async function prepareIdentityKindCascade(backend, target, options) {
   );
 }
 async function prepareIdentitySchemaCommit(backend, target, options) {
-  const schema = options.schema === void 0 ? chunkOC5ROP7V_cjs.createSqlSchema(backend.tableNames) : chunkOC5ROP7V_cjs.requireSqlSchema(options.schema, "The schema option");
+  const schema = options.schema === void 0 ? chunk6JRVV2SS_cjs.createSqlSchema(backend.tableNames) : chunk6JRVV2SS_cjs.requireSqlSchema(options.schema, "The schema option");
   const registry = buildKindRegistry(target);
   const provisioning = await ensureIdentitySchemaStorage(backend, schema, {
     graphId: target.id,
@@ -3839,5 +3839,5 @@ exports.serializeSchema = serializeSchema;
 exports.serializeSchemaProperties = serializeSchemaProperties;
 exports.stripGraphExtension = stripGraphExtension;
 exports.subClassOf = subClassOf;
-//# sourceMappingURL=chunk-FXGZT3WO.cjs.map
-//# sourceMappingURL=chunk-FXGZT3WO.cjs.map
+//# sourceMappingURL=chunk-BX42F7IJ.cjs.map
+//# sourceMappingURL=chunk-BX42F7IJ.cjs.map