@nicia-ai/typegraph 0.50.0 → 0.51.1

package/dist/resolve-D_H8MHtq.d.ts

@@ -0,0 +1,1805 @@
+import { e as GraphBackend, cn as SqlDialect, B as BackendCapabilities } from './types-6yf0Vv-_.js';
+
+/**
+ * The PILOT capability-bundle registry — DATA ONLY, sibling in spirit to
+ * `backend/member-classes.ts`.
+ *
+ * A bundle is a named set of {@link GraphBackend} member names split into a
+ * required core and a set of graduated extras, with a dialect scope, an
+ * optional declaration source and cross-check mode, a port-surface refusal
+ * code, a per-operation disposition table naming the sites and the extras
+ * each operation requires, and one verdict resolver (`resolve.ts`) plus one
+ * member accessor (`bind.ts`). It is not a re-shaping of `GraphBackend`.
+ *
+ * Two definition kinds, because the measurement has two shapes:
+ *
+ * - A GATED bundle has a non-empty required core (every member required).
+ *   Its resolver returns supported-with-core-member-names or
+ *   unsupported-with-`missing`. Pilot: `claims`, `statementExecution`,
+ *   `recordedRevisionOrigins`.
+ * - A GRADUATED bundle has no required core: every member is an extra with
+ *   its own measured disposition. Its resolver returns the per-extra verdict
+ *   map and no `supported` field at all. Pilot: `uniqueSidecarBatch`,
+ *   `batchPointRead`, `contributionHealth`.
+ *
+ * Deliberately absent, by round-5 ruling (no pilot consumer for either):
+ * `arity` on core members, `requiresBundles` edges, `AnyOfSelection`,
+ * `CapabilityCoreMember`, `AllOfMembers`, `AnyOfMembers`. Both are designed
+ * and seeded for WS5b in the design document's appendix, beside their first
+ * real consumers.
+ *
+ * This is the PILOT of a larger sweep (WS5b): 15 of the 82 optional
+ * `GraphBackend` members are bundled here; the other 67 are classified in
+ * {@link UNBUNDLED_OPTIONAL_MEMBERS} as either `reasoned` (no bundle should
+ * ever own them) or `deferred` (WS5b's seed, with a measured ceiling).
+ */
+
+/**
+ * The keys of `T` that are optional — i.e. `undefined` may stand in for the
+ * member without violating the type. `object extends Pick<T, K>` is true
+ * exactly when `Pick<T, K>` accepts `{}`, which is true exactly when `K` is
+ * optional on `T`.
+ */
+type OptionalKeys<T> = {
+    [K in keyof T]-?: object extends Pick<T, K> ? K : never;
+}[keyof T];
+/**
+ * Every optional `GraphBackend` member — 82 of them, verified equal to the
+ * names parsed from `etc/typegraph-backend.api.md` (§Baselines). Derived,
+ * never hand-written: a member added or removed from `GraphBackend` changes
+ * this type automatically, and the totality proof below fails loudly if the
+ * registry has not kept up.
+ */
+type OptionalGraphBackendMember = OptionalKeys<GraphBackend>;
+/** How an operation degrades — or refuses — when a member it needs is absent. */
+type CapabilityBundleDisposition = 
+/** Absence refuses, with ONE typed error per operation. */
+Readonly<{
+    kind: "refuse";
+    code: string;
+}>
+/** Absence degrades along a named, tested path. Never refuses. */
+ | Readonly<{
+    kind: "fallback";
+    fallback: string;
+}>;
+/**
+ * A graduated extra: present ⇒ a better path, absent ⇒ this exact
+ * disposition. `members` is a list because an extra MAY be an all-or-nothing
+ * group; every pilot extra is single-membered (the measured group,
+ * `indexMaterialization`'s build-claim protocol, is deferred).
+ */
+type CapabilityBundleExtra<Id extends string, M extends OptionalGraphBackendMember> = Readonly<{
+    id: Id;
+    members: readonly M[];
+    /** REQUIRED, and typed — never a bare `fallback: string`. */
+    disposition: CapabilityBundleDisposition;
+}>;
+type CapabilityCrossCheck = 
+/** Presence alone. The default, and 5 of the 6 pilot bundles. */
+"none"
+/**
+ * Declared-but-missing refuses; implements-without-declaring resolves
+ * supported. One-directional. No bundle uses this today — it exists so a
+ * future cross-check has a shape to grow into, one that must carry its own
+ * justification row when adopted.
+ */
+ | "declared-implies-members"
+/**
+ * Disagreement in EITHER direction refuses. `claims` only — the existing
+ * `CONSTRAINT_CLAIM_SURFACE_MISMATCH`, whose bidirectionality carries a
+ * fence-specific justification ("a silent fallback would unfence exactly
+ * the writes the capability exists to fence") that no other family has.
+ */
+ | "bidirectional";
+/** One inventory key an operation row owns. */
+type CapabilityBundleOperationSite = Readonly<{
+    file: string;
+    member: OptionalGraphBackendMember;
+    /**
+     * Disambiguator, required only where one `(file, member)` pair is split
+     * across two or more operation rows. Three pairs need it in the pilot:
+     * `node-operations.ts#checkUniqueBatch`, `guards.ts#executeStatement` and
+     * `migrate-recorded-time.ts#executeStatement`.
+     */
+    lines?: readonly number[];
+    /**
+     * Set when B7's rewiring pass reclassified this site AWAY from `pilot`
+     * instead of rewiring it — additive, optional, and read by nothing but the
+     * inventory/report tooling. `"deferred"` names a site whose receiver family
+     * needs plumbing this batch must not force (WS5b's input); `"reasoned"`
+     * names one this batch decided a verdict must never gate at all. The
+     * `code`/`disposition` above stay the classification data they always were;
+     * this is a SEPARATE fact about the site, not a replacement for either.
+     */
+    rewiring?: Readonly<{
+        class: "deferred" | "reasoned";
+        reason: string;
+    }>;
+}>;
+/** Every caller-visible operation that consumes a bundle. */
+type CapabilityBundleOperation = Readonly<{
+    /** The caller-visible name that lands in `details.operation`. */
+    operation: string;
+    disposition: CapabilityBundleDisposition;
+    /** The extras this operation needs, by id. */
+    requires?: readonly string[];
+    /** Every inventory key this row owns, as `(file, member)` pairs. */
+    sites: readonly CapabilityBundleOperationSite[];
+    /**
+     * Set only where the site itself reads the declaration to decide between
+     * refusing and degrading. One measured instance in the pilot:
+     * `probeContributions` (`store.ts:4406`).
+     */
+    declarationGate?: true;
+}>;
+type CapabilityBundleCommon = Readonly<{
+    /**
+     * The registry's own id namespace is derived from `CAPABILITY_BUNDLES`
+     * below (never hand-written) — but the derivation cannot be fed back into
+     * THIS type: `CapabilityBundleId` is `(typeof CAPABILITY_BUNDLES)[number]
+     * ["id"]`, and `CAPABILITY_BUNDLES` is built from values (`CLAIMS`, …)
+     * whose own type is checked against `CapabilityBundleDefinition` — which
+     * embeds this type. Typing this field `CapabilityBundleId` therefore makes
+     * every bundle constant's type depend on its own initializer
+     * (`TS2502`/`TS2456`, confirmed by compiling the literal design text).
+     * `string` here is the minimal break: each bundle constant still infers
+     * its literal id via `as const`, and `CapabilityBundleId` below is still
+     * wholly derived from `CAPABILITY_BUNDLES`, never hand-written.
+     */
+    id: string;
+    /** Dialects whose first-party factory implements this bundle's core. Default: both. */
+    dialects?: readonly SqlDialect[];
+    /** The `BackendCapabilities` field that DECLARES the bundle, when one exists. */
+    declaration?: keyof BackendCapabilities;
+    /** Read only when not `"none"` (ruling F2). */
+    crossCheck: CapabilityCrossCheck;
+    /** The code the MEMBER ACCESSOR throws when the port disagrees with the verdict (I20). */
+    portSurfaceCode: string;
+    operations: readonly CapabilityBundleOperation[];
+}>;
+/** A bundle with a required core. */
+type GatedBundleDefinition<MCore extends OptionalGraphBackendMember, XId extends string = never, MExtra extends OptionalGraphBackendMember = never> = CapabilityBundleCommon & Readonly<{
+    kind: "gated";
+    /** Every name required. No arity wrapper — no pilot bundle has an `any-of` core. */
+    core: readonly MCore[];
+    extras?: readonly CapabilityBundleExtra<XId, MExtra>[];
+    /** The bundle-wide disposition when the CORE is unsatisfied. */
+    disposition: CapabilityBundleDisposition;
+}>;
+/** A bundle with no required core: every member is a graduated extra. */
+type GraduatedBundleDefinition<XId extends string, MExtra extends OptionalGraphBackendMember> = CapabilityBundleCommon & Readonly<{
+    kind: "graduated";
+    extras: readonly CapabilityBundleExtra<XId, MExtra>[];
+}>;
+type CapabilityBundleDefinition = GatedBundleDefinition<OptionalGraphBackendMember, string, OptionalGraphBackendMember> | GraduatedBundleDefinition<string, OptionalGraphBackendMember>;
+/**
+ * `claimSupport` (`store/claims/backing.ts`) is the ONE bidirectional
+ * cross-check consumer in the tree. Since B7 it delegates to
+ * `resolveBundle`, which runs `resolve.ts`'s `assertClaimsBidirectionalAgreement`
+ * — the check's only remaining owner; there is no second copy left in
+ * `backing.ts` to keep byte-for-byte in sync with.
+ */
+declare const CLAIMS: {
+    readonly id: "claims";
+    readonly kind: "gated";
+    readonly core: readonly ["claimEdgeCardinality", "claimEdgeCardinalityBatch", "purgeEdgeClaims", "hardDeleteUniquesByConcreteKind"];
+    readonly declaration: "constraintClaims";
+    readonly crossCheck: "bidirectional";
+    readonly portSurfaceCode: "CONSTRAINT_CLAIM_SURFACE_MISMATCH";
+    readonly disposition: {
+        readonly kind: "fallback";
+        readonly fallback: "unclaimed writes; the caller's own supported:false branch";
+    };
+    readonly operations: readonly [{
+        readonly operation: "edge claim write";
+        readonly disposition: {
+            readonly kind: "fallback";
+            readonly fallback: "unclaimed writes; the caller's own supported:false branch";
+        };
+        readonly sites: readonly [{
+            readonly file: "store/claims/backing.ts";
+            readonly member: "claimEdgeCardinality";
+        }, {
+            readonly file: "store/claims/backing.ts";
+            readonly member: "claimEdgeCardinalityBatch";
+        }, {
+            readonly file: "store/claims/backing.ts";
+            readonly member: "purgeEdgeClaims";
+        }, {
+            readonly file: "store/claims/backing.ts";
+            readonly member: "hardDeleteUniquesByConcreteKind";
+        }];
+    }];
+};
+/**
+ * Three independently-guarded extras. Measured, `hardDeleteUniquesByNodeIds`'
+ * only standalone site (`node-claims.ts:732`) reaches the member through
+ * `requireDefined` rather than a degrading guard, so — the round-5
+ * enumeration's correction to the round-4 table — its disposition is
+ * `refuse`, not the fallback round 4 assumed from the bundle's name.
+ */
+declare const UNIQUE_SIDECAR_BATCH: {
+    readonly id: "uniqueSidecarBatch";
+    readonly kind: "graduated";
+    readonly crossCheck: "none";
+    readonly portSurfaceCode: "BUNDLE_PORT_SURFACE_MISMATCH";
+    readonly extras: readonly [{
+        readonly id: "insertUniqueBatch";
+        readonly members: readonly ["insertUniqueBatch"];
+        readonly disposition: {
+            readonly kind: "fallback";
+            readonly fallback: "issueClaimsIndividually";
+        };
+    }, {
+        readonly id: "checkUniqueBatch";
+        readonly members: readonly ["checkUniqueBatch"];
+        readonly disposition: {
+            readonly kind: "fallback";
+            readonly fallback: "per-key checkUnique loop";
+        };
+    }, {
+        readonly id: "hardDeleteUniquesByNodeIds";
+        readonly members: readonly ["hardDeleteUniquesByNodeIds"];
+        readonly disposition: {
+            readonly kind: "refuse";
+            readonly code: "UNIQUE_REAP_BY_NODE_IDS_UNSUPPORTED";
+        };
+    }];
+    readonly operations: readonly [{
+        readonly operation: "unique batch probe";
+        readonly disposition: {
+            readonly kind: "fallback";
+            readonly fallback: "per-key checkUnique loop";
+        };
+        readonly requires: readonly ["checkUniqueBatch"];
+        readonly sites: readonly [{
+            readonly file: "store/operations/node-operations.ts";
+            readonly member: "checkUniqueBatch";
+            readonly lines: readonly [1275, 1320];
+        }, {
+            readonly file: "store/operations/node-operations.ts";
+            readonly member: "checkUniqueBatch";
+            readonly lines: readonly [1575, 1593];
+        }];
+    }, {
+        readonly operation: "unique claim issue";
+        readonly disposition: {
+            readonly kind: "fallback";
+            readonly fallback: "issueClaimsIndividually";
+        };
+        readonly requires: readonly ["insertUniqueBatch"];
+        readonly sites: readonly [{
+            readonly file: "store/claims/node-claims.ts";
+            readonly member: "insertUniqueBatch";
+        }];
+    }, {
+        readonly operation: "unique reap by node ids";
+        readonly disposition: {
+            readonly kind: "refuse";
+            readonly code: "UNIQUE_REAP_BY_NODE_IDS_UNSUPPORTED";
+        };
+        readonly requires: readonly ["hardDeleteUniquesByNodeIds"];
+        readonly sites: readonly [{
+            readonly file: "store/claims/node-claims.ts";
+            readonly member: "hardDeleteUniquesByNodeIds";
+        }];
+    }, {
+        readonly operation: "set-based node update";
+        readonly disposition: {
+            readonly kind: "refuse";
+            readonly code: "SET_UPDATE_UNIQUENESS_UNSUPPORTED";
+        };
+        readonly requires: readonly ["hardDeleteUniquesByNodeIds", "insertUniqueBatch", "checkUniqueBatch"];
+        readonly sites: readonly [{
+            readonly file: "store/operations/node-write-pipeline.ts";
+            readonly member: "hardDeleteUniquesByNodeIds";
+        }, {
+            readonly file: "store/operations/node-write-pipeline.ts";
+            readonly member: "insertUniqueBatch";
+        }, {
+            readonly file: "store/operations/node-write-pipeline.ts";
+            readonly member: "checkUniqueBatch";
+        }, {
+            readonly file: "store/operations/node-operations.ts";
+            readonly member: "hardDeleteUniquesByNodeIds";
+        }, {
+            readonly file: "store/operations/node-operations.ts";
+            readonly member: "insertUniqueBatch";
+        }, {
+            readonly file: "store/operations/node-operations.ts";
+            readonly member: "checkUniqueBatch";
+            readonly lines: readonly [1993];
+        }];
+    }, {
+        readonly operation: "resolved node write";
+        readonly disposition: {
+            readonly kind: "refuse";
+            readonly code: "RESOLVED_NODE_UNIQUENESS_UNSUPPORTED";
+        };
+        readonly requires: readonly ["hardDeleteUniquesByNodeIds", "insertUniqueBatch", "checkUniqueBatch"];
+        readonly sites: readonly [{
+            readonly file: "store/claims/resolved-node-claims.ts";
+            readonly member: "checkUniqueBatch";
+            readonly lines: readonly [211];
+        }, {
+            readonly file: "store/claims/resolved-node-claims.ts";
+            readonly member: "checkUniqueBatch";
+            readonly lines: readonly [292];
+        }, {
+            readonly file: "store/claims/resolved-node-claims.ts";
+            readonly member: "hardDeleteUniquesByNodeIds";
+        }, {
+            readonly file: "store/claims/resolved-node-claims.ts";
+            readonly member: "insertUniqueBatch";
+        }];
+    }];
+};
+/** Two independently-guarded extras, both fallback. */
+declare const BATCH_POINT_READ: {
+    readonly id: "batchPointRead";
+    readonly kind: "graduated";
+    readonly crossCheck: "none";
+    readonly portSurfaceCode: "BUNDLE_PORT_SURFACE_MISMATCH";
+    readonly extras: readonly [{
+        readonly id: "getNodes";
+        readonly members: readonly ["getNodes"];
+        readonly disposition: {
+            readonly kind: "fallback";
+            readonly fallback: "per-id getNode";
+        };
+    }, {
+        readonly id: "getEdges";
+        readonly members: readonly ["getEdges"];
+        readonly disposition: {
+            readonly kind: "fallback";
+            readonly fallback: "per-id getEdge";
+        };
+    }];
+    readonly operations: readonly [{
+        readonly operation: "search hydration";
+        readonly disposition: {
+            readonly kind: "fallback";
+            readonly fallback: "per-id getNode";
+        };
+        readonly requires: readonly ["getNodes"];
+        readonly sites: readonly [{
+            readonly file: "store/search.ts";
+            readonly member: "getNodes";
+        }];
+    }, {
+        readonly operation: "import reference validation";
+        readonly disposition: {
+            readonly kind: "fallback";
+            readonly fallback: "per-row getNode in the routing loop";
+        };
+        readonly requires: readonly ["getNodes"];
+        readonly sites: readonly [{
+            readonly file: "interchange/import.ts";
+            readonly member: "getNodes";
+        }];
+    }, {
+        readonly operation: "import edge endpoint hydration";
+        readonly disposition: {
+            readonly kind: "fallback";
+            readonly fallback: "per-row getEdge";
+        };
+        readonly requires: readonly ["getEdges"];
+        readonly sites: readonly [{
+            readonly file: "interchange/import.ts";
+            readonly member: "getEdges";
+        }];
+    }, {
+        readonly operation: "edge batch endpoint priming";
+        readonly disposition: {
+            readonly kind: "fallback";
+            readonly fallback: "skip the priming pass; endpoint validation reads per-row";
+        };
+        readonly requires: readonly ["getNodes"];
+        readonly sites: readonly [{
+            readonly file: "store/operations/edge-operations.ts";
+            readonly member: "getNodes";
+        }];
+    }, {
+        readonly operation: "node create batch priming";
+        readonly disposition: {
+            readonly kind: "fallback";
+            readonly fallback: "skip priming; per-row probes";
+        };
+        readonly requires: readonly ["getNodes"];
+        readonly sites: readonly [{
+            readonly file: "store/operations/node-operations.ts";
+            readonly member: "getNodes";
+        }];
+    }, {
+        readonly operation: "node collection batch load";
+        readonly disposition: {
+            readonly kind: "fallback";
+            readonly fallback: "per-id getNode";
+        };
+        readonly requires: readonly ["getNodes"];
+        readonly sites: readonly [{
+            readonly file: "store/collections/node-collection.ts";
+            readonly member: "getNodes";
+        }];
+    }, {
+        readonly operation: "node batch fetch";
+        readonly disposition: {
+            readonly kind: "fallback";
+            readonly fallback: "per-id getNode";
+        };
+        readonly requires: readonly ["getNodes"];
+        readonly sites: readonly [{
+            readonly file: "store/node-fetch.ts";
+            readonly member: "getNodes";
+        }];
+    }, {
+        readonly operation: "edge batch fetch";
+        readonly disposition: {
+            readonly kind: "fallback";
+            readonly fallback: "per-id getEdge";
+        };
+        readonly requires: readonly ["getEdges"];
+        readonly sites: readonly [{
+            readonly file: "store/edge-fetch.ts";
+            readonly member: "getEdges";
+        }];
+    }, {
+        readonly operation: "identity member hydration";
+        readonly disposition: {
+            readonly kind: "fallback";
+            readonly fallback: "per-id getNode";
+        };
+        readonly requires: readonly ["getNodes"];
+        readonly sites: readonly [{
+            readonly file: "store/store.ts";
+            readonly member: "getNodes";
+        }];
+    }];
+};
+/**
+ * Core `executeStatement`. `IDENTITY_REQUIRES_STATEMENT_EXECUTION` and
+ * `IDENTITY_REQUIRES_ATOMIC_BACKEND` are the existing `details.code` values
+ * at `identity/sql-target.ts:101` and `store/store.ts:921`; the remaining
+ * rows' underlying throws carry no domain code of their own today, so their
+ * `code` here is registry-assigned classification (documented per row).
+ */
+declare const STATEMENT_EXECUTION: {
+    readonly id: "statementExecution";
+    readonly kind: "gated";
+    readonly core: readonly ["executeStatement"];
+    readonly crossCheck: "none";
+    readonly portSurfaceCode: "BUNDLE_PORT_SURFACE_MISMATCH";
+    readonly disposition: {
+        readonly kind: "refuse";
+        readonly code: "IDENTITY_REQUIRES_STATEMENT_EXECUTION";
+    };
+    readonly operations: readonly [{
+        readonly operation: "identity statement execution";
+        readonly disposition: {
+            readonly kind: "refuse";
+            readonly code: "IDENTITY_REQUIRES_STATEMENT_EXECUTION";
+        };
+        readonly sites: readonly [{
+            readonly file: "identity/sql-target.ts";
+            readonly member: "executeStatement";
+            readonly rewiring: {
+                readonly class: "deferred";
+                readonly reason: "requires verdict threading through IdentityServiceContext / the capture session — WS5b input, measured at ~13 files/~35 signatures";
+            };
+        }];
+    }, {
+        readonly operation: "recorded capture statement";
+        readonly disposition: {
+            readonly kind: "refuse";
+            readonly code: "RECORDED_CAPTURE_STATEMENT_UNSUPPORTED";
+        };
+        readonly sites: readonly [{
+            readonly file: "store/recorded-capture/guards.ts";
+            readonly member: "executeStatement";
+            readonly lines: readonly [62, 79];
+            readonly rewiring: {
+                readonly class: "deferred";
+                readonly reason: "requires verdict threading through IdentityServiceContext / the capture session — WS5b input, measured at ~13 files/~35 signatures";
+            };
+        }];
+    }, {
+        readonly operation: "history construction gate";
+        readonly disposition: {
+            readonly kind: "refuse";
+            readonly code: "HISTORY_REQUIRES_STATEMENT_EXECUTION";
+        };
+        readonly sites: readonly [{
+            readonly file: "store/recorded-capture/guards.ts";
+            readonly member: "executeStatement";
+            readonly lines: readonly [251];
+        }];
+    }, {
+        readonly operation: "revision tracking construction gate";
+        readonly disposition: {
+            readonly kind: "refuse";
+            readonly code: "REVISION_TRACKING_REQUIRES_STATEMENT_EXECUTION";
+        };
+        readonly sites: readonly [{
+            readonly file: "store/recorded-capture/guards.ts";
+            readonly member: "executeStatement";
+            readonly lines: readonly [299];
+        }];
+    }, {
+        readonly operation: "history-unsafe raw write overlay";
+        readonly disposition: {
+            readonly kind: "fallback";
+            readonly fallback: "omit the overriding member; the port's own absence stands";
+        };
+        readonly sites: readonly [{
+            readonly file: "store/recorded-capture/guards.ts";
+            readonly member: "executeStatement";
+            readonly lines: readonly [219];
+            readonly rewiring: {
+                readonly class: "reasoned";
+                readonly reason: "genuinely a port-surface presence test; re-keying it on a verdict changes behavior in both directions (a phantom-rejecting stub one way, a raw-write escape on a history-enabled store the other — a safety regression), and adding a non-throwing gated accessor to the frozen binder surface for ONE site is the over-generalization anti-pattern";
+            };
+        }];
+    }, {
+        readonly operation: "identity construction gate";
+        readonly disposition: {
+            readonly kind: "refuse";
+            readonly code: "IDENTITY_REQUIRES_ATOMIC_BACKEND";
+        };
+        readonly sites: readonly [{
+            readonly file: "store/store.ts";
+            readonly member: "executeStatement";
+            readonly lines: readonly [921];
+        }, {
+            readonly file: "store/store.ts";
+            readonly member: "executeStatement";
+            readonly lines: readonly [928];
+        }];
+    }, {
+        readonly operation: "validity window repair";
+        readonly disposition: {
+            readonly kind: "refuse";
+            readonly code: "VALIDITY_WINDOW_REPAIR_REQUIRES_STATEMENT_EXECUTION";
+        };
+        readonly sites: readonly [{
+            readonly file: "backend/repair-validity-windows.ts";
+            readonly member: "executeStatement";
+        }];
+    }, {
+        readonly operation: "recorded-time migration";
+        readonly disposition: {
+            readonly kind: "refuse";
+            readonly code: "RECORDED_TIME_MIGRATION_REQUIRES_STATEMENT_EXECUTION";
+        };
+        readonly sites: readonly [{
+            readonly file: "backend/migrate-recorded-time.ts";
+            readonly member: "executeStatement";
+            readonly lines: readonly [154, 161, 801];
+            readonly rewiring: {
+                readonly class: "deferred";
+                readonly reason: "the delete path's public Pick-typed backend cannot reach resolveBundle, and the shared module-private helpers make a single-path rewire two owners";
+            };
+        }];
+    }];
+};
+/**
+ * Four extras, one per public `Store` method, each read alone. Three refuse
+ * with their own existing error; `probeContributions` is the pilot's one
+ * `declarationGate` row — fallback to `{ entries: [] }` when
+ * `capabilities.contributions` is undeclared, refuse when it is declared.
+ */
+declare const CONTRIBUTION_HEALTH: {
+    readonly id: "contributionHealth";
+    readonly kind: "graduated";
+    readonly declaration: "contributions";
+    readonly crossCheck: "none";
+    readonly portSurfaceCode: "BUNDLE_PORT_SURFACE_MISMATCH";
+    readonly extras: readonly [{
+        readonly id: "verifyContributions";
+        readonly members: readonly ["verifyContributions"];
+        readonly disposition: {
+            readonly kind: "refuse";
+            readonly code: "CONTRIBUTION_VERIFY_UNSUPPORTED";
+        };
+    }, {
+        readonly id: "repairContributions";
+        readonly members: readonly ["repairContributions"];
+        readonly disposition: {
+            readonly kind: "refuse";
+            readonly code: "CONTRIBUTION_REPAIR_UNSUPPORTED";
+        };
+    }, {
+        readonly id: "rebuildContribution";
+        readonly members: readonly ["rebuildContribution"];
+        readonly disposition: {
+            readonly kind: "refuse";
+            readonly code: "CONTRIBUTION_REBUILD_UNSUPPORTED";
+        };
+    }, {
+        readonly id: "probeContributions";
+        readonly members: readonly ["probeContributions"];
+        readonly disposition: {
+            readonly kind: "fallback";
+            readonly fallback: "{entries: []}";
+        };
+    }];
+    readonly operations: readonly [{
+        readonly operation: "contribution verify";
+        readonly disposition: {
+            readonly kind: "refuse";
+            readonly code: "CONTRIBUTION_VERIFY_UNSUPPORTED";
+        };
+        readonly requires: readonly ["verifyContributions"];
+        readonly sites: readonly [{
+            readonly file: "store/store.ts";
+            readonly member: "verifyContributions";
+        }];
+    }, {
+        readonly operation: "contribution repair";
+        readonly disposition: {
+            readonly kind: "refuse";
+            readonly code: "CONTRIBUTION_REPAIR_UNSUPPORTED";
+        };
+        readonly requires: readonly ["repairContributions"];
+        readonly sites: readonly [{
+            readonly file: "store/store.ts";
+            readonly member: "repairContributions";
+        }];
+    }, {
+        readonly operation: "contribution rebuild";
+        readonly disposition: {
+            readonly kind: "refuse";
+            readonly code: "CONTRIBUTION_REBUILD_UNSUPPORTED";
+        };
+        readonly requires: readonly ["rebuildContribution"];
+        readonly sites: readonly [{
+            readonly file: "store/store.ts";
+            readonly member: "rebuildContribution";
+        }];
+    }, {
+        readonly operation: "contribution probe";
+        readonly disposition: {
+            readonly kind: "fallback";
+            readonly fallback: "{entries: []}";
+        };
+        readonly requires: readonly ["probeContributions"];
+        readonly sites: readonly [{
+            readonly file: "store/store.ts";
+            readonly member: "probeContributions";
+        }];
+        readonly declarationGate: true;
+    }];
+};
+/**
+ * Core `ensureRevisionOriginsTable`, both refusals existing typed throws
+ * (registry-assigned codes; neither underlying throw carries a domain code
+ * of its own today).
+ */
+declare const RECORDED_REVISION_ORIGINS: {
+    readonly id: "recordedRevisionOrigins";
+    readonly kind: "gated";
+    readonly core: readonly ["ensureRevisionOriginsTable"];
+    readonly crossCheck: "none";
+    readonly portSurfaceCode: "BUNDLE_PORT_SURFACE_MISMATCH";
+    readonly disposition: {
+        readonly kind: "refuse";
+        readonly code: "REVISION_TRACKING_REQUIRES_REVISION_ORIGINS";
+    };
+    readonly operations: readonly [{
+        readonly operation: "revision tracking construction gate";
+        readonly disposition: {
+            readonly kind: "refuse";
+            readonly code: "REVISION_TRACKING_REQUIRES_REVISION_ORIGINS";
+        };
+        readonly sites: readonly [{
+            readonly file: "store/recorded-capture/guards.ts";
+            readonly member: "ensureRevisionOriginsTable";
+        }];
+    }, {
+        readonly operation: "revision origin bootstrap";
+        readonly disposition: {
+            readonly kind: "refuse";
+            readonly code: "REVISION_ORIGIN_BOOTSTRAP_UNSUPPORTED";
+        };
+        readonly sites: readonly [{
+            readonly file: "store/recorded-capture/clock.ts";
+            readonly member: "ensureRevisionOriginsTable";
+        }];
+    }];
+};
+/** The pilot registry: six bundles, 15 members, 30 operation rows. */
+declare const CAPABILITY_BUNDLES: readonly [{
+    readonly id: "claims";
+    readonly kind: "gated";
+    readonly core: readonly ["claimEdgeCardinality", "claimEdgeCardinalityBatch", "purgeEdgeClaims", "hardDeleteUniquesByConcreteKind"];
+    readonly declaration: "constraintClaims";
+    readonly crossCheck: "bidirectional";
+    readonly portSurfaceCode: "CONSTRAINT_CLAIM_SURFACE_MISMATCH";
+    readonly disposition: {
+        readonly kind: "fallback";
+        readonly fallback: "unclaimed writes; the caller's own supported:false branch";
+    };
+    readonly operations: readonly [{
+        readonly operation: "edge claim write";
+        readonly disposition: {
+            readonly kind: "fallback";
+            readonly fallback: "unclaimed writes; the caller's own supported:false branch";
+        };
+        readonly sites: readonly [{
+            readonly file: "store/claims/backing.ts";
+            readonly member: "claimEdgeCardinality";
+        }, {
+            readonly file: "store/claims/backing.ts";
+            readonly member: "claimEdgeCardinalityBatch";
+        }, {
+            readonly file: "store/claims/backing.ts";
+            readonly member: "purgeEdgeClaims";
+        }, {
+            readonly file: "store/claims/backing.ts";
+            readonly member: "hardDeleteUniquesByConcreteKind";
+        }];
+    }];
+}, {
+    readonly id: "uniqueSidecarBatch";
+    readonly kind: "graduated";
+    readonly crossCheck: "none";
+    readonly portSurfaceCode: "BUNDLE_PORT_SURFACE_MISMATCH";
+    readonly extras: readonly [{
+        readonly id: "insertUniqueBatch";
+        readonly members: readonly ["insertUniqueBatch"];
+        readonly disposition: {
+            readonly kind: "fallback";
+            readonly fallback: "issueClaimsIndividually";
+        };
+    }, {
+        readonly id: "checkUniqueBatch";
+        readonly members: readonly ["checkUniqueBatch"];
+        readonly disposition: {
+            readonly kind: "fallback";
+            readonly fallback: "per-key checkUnique loop";
+        };
+    }, {
+        readonly id: "hardDeleteUniquesByNodeIds";
+        readonly members: readonly ["hardDeleteUniquesByNodeIds"];
+        readonly disposition: {
+            readonly kind: "refuse";
+            readonly code: "UNIQUE_REAP_BY_NODE_IDS_UNSUPPORTED";
+        };
+    }];
+    readonly operations: readonly [{
+        readonly operation: "unique batch probe";
+        readonly disposition: {
+            readonly kind: "fallback";
+            readonly fallback: "per-key checkUnique loop";
+        };
+        readonly requires: readonly ["checkUniqueBatch"];
+        readonly sites: readonly [{
+            readonly file: "store/operations/node-operations.ts";
+            readonly member: "checkUniqueBatch";
+            readonly lines: readonly [1275, 1320];
+        }, {
+            readonly file: "store/operations/node-operations.ts";
+            readonly member: "checkUniqueBatch";
+            readonly lines: readonly [1575, 1593];
+        }];
+    }, {
+        readonly operation: "unique claim issue";
+        readonly disposition: {
+            readonly kind: "fallback";
+            readonly fallback: "issueClaimsIndividually";
+        };
+        readonly requires: readonly ["insertUniqueBatch"];
+        readonly sites: readonly [{
+            readonly file: "store/claims/node-claims.ts";
+            readonly member: "insertUniqueBatch";
+        }];
+    }, {
+        readonly operation: "unique reap by node ids";
+        readonly disposition: {
+            readonly kind: "refuse";
+            readonly code: "UNIQUE_REAP_BY_NODE_IDS_UNSUPPORTED";
+        };
+        readonly requires: readonly ["hardDeleteUniquesByNodeIds"];
+        readonly sites: readonly [{
+            readonly file: "store/claims/node-claims.ts";
+            readonly member: "hardDeleteUniquesByNodeIds";
+        }];
+    }, {
+        readonly operation: "set-based node update";
+        readonly disposition: {
+            readonly kind: "refuse";
+            readonly code: "SET_UPDATE_UNIQUENESS_UNSUPPORTED";
+        };
+        readonly requires: readonly ["hardDeleteUniquesByNodeIds", "insertUniqueBatch", "checkUniqueBatch"];
+        readonly sites: readonly [{
+            readonly file: "store/operations/node-write-pipeline.ts";
+            readonly member: "hardDeleteUniquesByNodeIds";
+        }, {
+            readonly file: "store/operations/node-write-pipeline.ts";
+            readonly member: "insertUniqueBatch";
+        }, {
+            readonly file: "store/operations/node-write-pipeline.ts";
+            readonly member: "checkUniqueBatch";
+        }, {
+            readonly file: "store/operations/node-operations.ts";
+            readonly member: "hardDeleteUniquesByNodeIds";
+        }, {
+            readonly file: "store/operations/node-operations.ts";
+            readonly member: "insertUniqueBatch";
+        }, {
+            readonly file: "store/operations/node-operations.ts";
+            readonly member: "checkUniqueBatch";
+            readonly lines: readonly [1993];
+        }];
+    }, {
+        readonly operation: "resolved node write";
+        readonly disposition: {
+            readonly kind: "refuse";
+            readonly code: "RESOLVED_NODE_UNIQUENESS_UNSUPPORTED";
+        };
+        readonly requires: readonly ["hardDeleteUniquesByNodeIds", "insertUniqueBatch", "checkUniqueBatch"];
+        readonly sites: readonly [{
+            readonly file: "store/claims/resolved-node-claims.ts";
+            readonly member: "checkUniqueBatch";
+            readonly lines: readonly [211];
+        }, {
+            readonly file: "store/claims/resolved-node-claims.ts";
+            readonly member: "checkUniqueBatch";
+            readonly lines: readonly [292];
+        }, {
+            readonly file: "store/claims/resolved-node-claims.ts";
+            readonly member: "hardDeleteUniquesByNodeIds";
+        }, {
+            readonly file: "store/claims/resolved-node-claims.ts";
+            readonly member: "insertUniqueBatch";
+        }];
+    }];
+}, {
+    readonly id: "batchPointRead";
+    readonly kind: "graduated";
+    readonly crossCheck: "none";
+    readonly portSurfaceCode: "BUNDLE_PORT_SURFACE_MISMATCH";
+    readonly extras: readonly [{
+        readonly id: "getNodes";
+        readonly members: readonly ["getNodes"];
+        readonly disposition: {
+            readonly kind: "fallback";
+            readonly fallback: "per-id getNode";
+        };
+    }, {
+        readonly id: "getEdges";
+        readonly members: readonly ["getEdges"];
+        readonly disposition: {
+            readonly kind: "fallback";
+            readonly fallback: "per-id getEdge";
+        };
+    }];
+    readonly operations: readonly [{
+        readonly operation: "search hydration";
+        readonly disposition: {
+            readonly kind: "fallback";
+            readonly fallback: "per-id getNode";
+        };
+        readonly requires: readonly ["getNodes"];
+        readonly sites: readonly [{
+            readonly file: "store/search.ts";
+            readonly member: "getNodes";
+        }];
+    }, {
+        readonly operation: "import reference validation";
+        readonly disposition: {
+            readonly kind: "fallback";
+            readonly fallback: "per-row getNode in the routing loop";
+        };
+        readonly requires: readonly ["getNodes"];
+        readonly sites: readonly [{
+            readonly file: "interchange/import.ts";
+            readonly member: "getNodes";
+        }];
+    }, {
+        readonly operation: "import edge endpoint hydration";
+        readonly disposition: {
+            readonly kind: "fallback";
+            readonly fallback: "per-row getEdge";
+        };
+        readonly requires: readonly ["getEdges"];
+        readonly sites: readonly [{
+            readonly file: "interchange/import.ts";
+            readonly member: "getEdges";
+        }];
+    }, {
+        readonly operation: "edge batch endpoint priming";
+        readonly disposition: {
+            readonly kind: "fallback";
+            readonly fallback: "skip the priming pass; endpoint validation reads per-row";
+        };
+        readonly requires: readonly ["getNodes"];
+        readonly sites: readonly [{
+            readonly file: "store/operations/edge-operations.ts";
+            readonly member: "getNodes";
+        }];
+    }, {
+        readonly operation: "node create batch priming";
+        readonly disposition: {
+            readonly kind: "fallback";
+            readonly fallback: "skip priming; per-row probes";
+        };
+        readonly requires: readonly ["getNodes"];
+        readonly sites: readonly [{
+            readonly file: "store/operations/node-operations.ts";
+            readonly member: "getNodes";
+        }];
+    }, {
+        readonly operation: "node collection batch load";
+        readonly disposition: {
+            readonly kind: "fallback";
+            readonly fallback: "per-id getNode";
+        };
+        readonly requires: readonly ["getNodes"];
+        readonly sites: readonly [{
+            readonly file: "store/collections/node-collection.ts";
+            readonly member: "getNodes";
+        }];
+    }, {
+        readonly operation: "node batch fetch";
+        readonly disposition: {
+            readonly kind: "fallback";
+            readonly fallback: "per-id getNode";
+        };
+        readonly requires: readonly ["getNodes"];
+        readonly sites: readonly [{
+            readonly file: "store/node-fetch.ts";
+            readonly member: "getNodes";
+        }];
+    }, {
+        readonly operation: "edge batch fetch";
+        readonly disposition: {
+            readonly kind: "fallback";
+            readonly fallback: "per-id getEdge";
+        };
+        readonly requires: readonly ["getEdges"];
+        readonly sites: readonly [{
+            readonly file: "store/edge-fetch.ts";
+            readonly member: "getEdges";
+        }];
+    }, {
+        readonly operation: "identity member hydration";
+        readonly disposition: {
+            readonly kind: "fallback";
+            readonly fallback: "per-id getNode";
+        };
+        readonly requires: readonly ["getNodes"];
+        readonly sites: readonly [{
+            readonly file: "store/store.ts";
+            readonly member: "getNodes";
+        }];
+    }];
+}, {
+    readonly id: "statementExecution";
+    readonly kind: "gated";
+    readonly core: readonly ["executeStatement"];
+    readonly crossCheck: "none";
+    readonly portSurfaceCode: "BUNDLE_PORT_SURFACE_MISMATCH";
+    readonly disposition: {
+        readonly kind: "refuse";
+        readonly code: "IDENTITY_REQUIRES_STATEMENT_EXECUTION";
+    };
+    readonly operations: readonly [{
+        readonly operation: "identity statement execution";
+        readonly disposition: {
+            readonly kind: "refuse";
+            readonly code: "IDENTITY_REQUIRES_STATEMENT_EXECUTION";
+        };
+        readonly sites: readonly [{
+            readonly file: "identity/sql-target.ts";
+            readonly member: "executeStatement";
+            readonly rewiring: {
+                readonly class: "deferred";
+                readonly reason: "requires verdict threading through IdentityServiceContext / the capture session — WS5b input, measured at ~13 files/~35 signatures";
+            };
+        }];
+    }, {
+        readonly operation: "recorded capture statement";
+        readonly disposition: {
+            readonly kind: "refuse";
+            readonly code: "RECORDED_CAPTURE_STATEMENT_UNSUPPORTED";
+        };
+        readonly sites: readonly [{
+            readonly file: "store/recorded-capture/guards.ts";
+            readonly member: "executeStatement";
+            readonly lines: readonly [62, 79];
+            readonly rewiring: {
+                readonly class: "deferred";
+                readonly reason: "requires verdict threading through IdentityServiceContext / the capture session — WS5b input, measured at ~13 files/~35 signatures";
+            };
+        }];
+    }, {
+        readonly operation: "history construction gate";
+        readonly disposition: {
+            readonly kind: "refuse";
+            readonly code: "HISTORY_REQUIRES_STATEMENT_EXECUTION";
+        };
+        readonly sites: readonly [{
+            readonly file: "store/recorded-capture/guards.ts";
+            readonly member: "executeStatement";
+            readonly lines: readonly [251];
+        }];
+    }, {
+        readonly operation: "revision tracking construction gate";
+        readonly disposition: {
+            readonly kind: "refuse";
+            readonly code: "REVISION_TRACKING_REQUIRES_STATEMENT_EXECUTION";
+        };
+        readonly sites: readonly [{
+            readonly file: "store/recorded-capture/guards.ts";
+            readonly member: "executeStatement";
+            readonly lines: readonly [299];
+        }];
+    }, {
+        readonly operation: "history-unsafe raw write overlay";
+        readonly disposition: {
+            readonly kind: "fallback";
+            readonly fallback: "omit the overriding member; the port's own absence stands";
+        };
+        readonly sites: readonly [{
+            readonly file: "store/recorded-capture/guards.ts";
+            readonly member: "executeStatement";
+            readonly lines: readonly [219];
+            readonly rewiring: {
+                readonly class: "reasoned";
+                readonly reason: "genuinely a port-surface presence test; re-keying it on a verdict changes behavior in both directions (a phantom-rejecting stub one way, a raw-write escape on a history-enabled store the other — a safety regression), and adding a non-throwing gated accessor to the frozen binder surface for ONE site is the over-generalization anti-pattern";
+            };
+        }];
+    }, {
+        readonly operation: "identity construction gate";
+        readonly disposition: {
+            readonly kind: "refuse";
+            readonly code: "IDENTITY_REQUIRES_ATOMIC_BACKEND";
+        };
+        readonly sites: readonly [{
+            readonly file: "store/store.ts";
+            readonly member: "executeStatement";
+            readonly lines: readonly [921];
+        }, {
+            readonly file: "store/store.ts";
+            readonly member: "executeStatement";
+            readonly lines: readonly [928];
+        }];
+    }, {
+        readonly operation: "validity window repair";
+        readonly disposition: {
+            readonly kind: "refuse";
+            readonly code: "VALIDITY_WINDOW_REPAIR_REQUIRES_STATEMENT_EXECUTION";
+        };
+        readonly sites: readonly [{
+            readonly file: "backend/repair-validity-windows.ts";
+            readonly member: "executeStatement";
+        }];
+    }, {
+        readonly operation: "recorded-time migration";
+        readonly disposition: {
+            readonly kind: "refuse";
+            readonly code: "RECORDED_TIME_MIGRATION_REQUIRES_STATEMENT_EXECUTION";
+        };
+        readonly sites: readonly [{
+            readonly file: "backend/migrate-recorded-time.ts";
+            readonly member: "executeStatement";
+            readonly lines: readonly [154, 161, 801];
+            readonly rewiring: {
+                readonly class: "deferred";
+                readonly reason: "the delete path's public Pick-typed backend cannot reach resolveBundle, and the shared module-private helpers make a single-path rewire two owners";
+            };
+        }];
+    }];
+}, {
+    readonly id: "contributionHealth";
+    readonly kind: "graduated";
+    readonly declaration: "contributions";
+    readonly crossCheck: "none";
+    readonly portSurfaceCode: "BUNDLE_PORT_SURFACE_MISMATCH";
+    readonly extras: readonly [{
+        readonly id: "verifyContributions";
+        readonly members: readonly ["verifyContributions"];
+        readonly disposition: {
+            readonly kind: "refuse";
+            readonly code: "CONTRIBUTION_VERIFY_UNSUPPORTED";
+        };
+    }, {
+        readonly id: "repairContributions";
+        readonly members: readonly ["repairContributions"];
+        readonly disposition: {
+            readonly kind: "refuse";
+            readonly code: "CONTRIBUTION_REPAIR_UNSUPPORTED";
+        };
+    }, {
+        readonly id: "rebuildContribution";
+        readonly members: readonly ["rebuildContribution"];
+        readonly disposition: {
+            readonly kind: "refuse";
+            readonly code: "CONTRIBUTION_REBUILD_UNSUPPORTED";
+        };
+    }, {
+        readonly id: "probeContributions";
+        readonly members: readonly ["probeContributions"];
+        readonly disposition: {
+            readonly kind: "fallback";
+            readonly fallback: "{entries: []}";
+        };
+    }];
+    readonly operations: readonly [{
+        readonly operation: "contribution verify";
+        readonly disposition: {
+            readonly kind: "refuse";
+            readonly code: "CONTRIBUTION_VERIFY_UNSUPPORTED";
+        };
+        readonly requires: readonly ["verifyContributions"];
+        readonly sites: readonly [{
+            readonly file: "store/store.ts";
+            readonly member: "verifyContributions";
+        }];
+    }, {
+        readonly operation: "contribution repair";
+        readonly disposition: {
+            readonly kind: "refuse";
+            readonly code: "CONTRIBUTION_REPAIR_UNSUPPORTED";
+        };
+        readonly requires: readonly ["repairContributions"];
+        readonly sites: readonly [{
+            readonly file: "store/store.ts";
+            readonly member: "repairContributions";
+        }];
+    }, {
+        readonly operation: "contribution rebuild";
+        readonly disposition: {
+            readonly kind: "refuse";
+            readonly code: "CONTRIBUTION_REBUILD_UNSUPPORTED";
+        };
+        readonly requires: readonly ["rebuildContribution"];
+        readonly sites: readonly [{
+            readonly file: "store/store.ts";
+            readonly member: "rebuildContribution";
+        }];
+    }, {
+        readonly operation: "contribution probe";
+        readonly disposition: {
+            readonly kind: "fallback";
+            readonly fallback: "{entries: []}";
+        };
+        readonly requires: readonly ["probeContributions"];
+        readonly sites: readonly [{
+            readonly file: "store/store.ts";
+            readonly member: "probeContributions";
+        }];
+        readonly declarationGate: true;
+    }];
+}, {
+    readonly id: "recordedRevisionOrigins";
+    readonly kind: "gated";
+    readonly core: readonly ["ensureRevisionOriginsTable"];
+    readonly crossCheck: "none";
+    readonly portSurfaceCode: "BUNDLE_PORT_SURFACE_MISMATCH";
+    readonly disposition: {
+        readonly kind: "refuse";
+        readonly code: "REVISION_TRACKING_REQUIRES_REVISION_ORIGINS";
+    };
+    readonly operations: readonly [{
+        readonly operation: "revision tracking construction gate";
+        readonly disposition: {
+            readonly kind: "refuse";
+            readonly code: "REVISION_TRACKING_REQUIRES_REVISION_ORIGINS";
+        };
+        readonly sites: readonly [{
+            readonly file: "store/recorded-capture/guards.ts";
+            readonly member: "ensureRevisionOriginsTable";
+        }];
+    }, {
+        readonly operation: "revision origin bootstrap";
+        readonly disposition: {
+            readonly kind: "refuse";
+            readonly code: "REVISION_ORIGIN_BOOTSTRAP_UNSUPPORTED";
+        };
+        readonly sites: readonly [{
+            readonly file: "store/recorded-capture/clock.ts";
+            readonly member: "ensureRevisionOriginsTable";
+        }];
+    }];
+}];
+type CapabilityBundleId = (typeof CAPABILITY_BUNDLES)[number]["id"];
+/** No bundle should ever own this member; the reason is the fact to preserve. */
+type ReasonedUnbundledMember = Readonly<{
+    kind: "reasoned";
+    reason: string;
+    /** Measured receiver-scoped access count (§Baselines). May be 0. */
+    accesses: number;
+}>;
+/** The 15 WS5b bundle ids, retained from the round-4 sweep table. */
+type Ws5bBundleId = "batchEntityWrite" | "endpointSetRead" | "heterogeneousEndpointSetRead" | "vectorOperations" | "hybridSearch" | "vectorSlotContributions" | "fulltextOperations" | "fulltextProvisioning" | "databaseExtensions" | "contributionProvisioning" | "indexMaterialization" | "ddlExecution" | "temporaryStatements" | "rawStatementReuse" | "trustedImport";
+/** WS5b's residue: this bundle owns it, and the access count may not grow. */
+type DeferredUnbundledMember = Readonly<{
+    kind: "deferred";
+    workstream: "WS5b";
+    bundle: Ws5bBundleId;
+    /** Measured receiver-scoped access count (§Baselines) — the ceiling. */
+    ceiling: number;
+}>;
+type UnbundledOptionalMember = ReasonedUnbundledMember | DeferredUnbundledMember;
+/**
+ * The 20 `reasoned` + 47 `deferred` members — 61 + 190 = 251 accesses
+ * (B9's scanner corrected two `reasoned` counts: `tableNames` 22→23,
+ * `ensureIdentityTables` 3→4; #520 then added `recordedTableDdl` with one
+ * access), 15 + 67 = 82 members total with the pilot's 15.
+ */
+declare const UNBUNDLED_OPTIONAL_MEMBERS: {
+    readonly bootstrapTables: {
+        readonly kind: "reasoned";
+        readonly reason: "One-shot provisioning hook consulted by createStore before any capability question exists; it has no operation that could refuse or degrade.";
+        readonly accesses: 3;
+    };
+    readonly tableNames: {
+        readonly kind: "reasoned";
+        readonly reason: "Not a capability — a name map the compiler reads on every backend. Absence is impossible in practice and meaningless as a decision.";
+        readonly accesses: 23;
+    };
+    readonly commitSchemaVersionIfKindsEmpty: {
+        readonly kind: "reasoned";
+        readonly reason: "Schema-version write fence, a SchemaCommitBackend role member. Its absence is dispositioned by the schema manager's own gate, which is a write-pipeline decision, not a feature-family one.";
+        readonly accesses: 1;
+    };
+    readonly commitSchemaVersionWithPreflight: {
+        readonly kind: "reasoned";
+        readonly reason: "Same schema-version write-fence family as commitSchemaVersionIfKindsEmpty.";
+        readonly accesses: 2;
+    };
+    readonly lockSchemaVersionForWrite: {
+        readonly kind: "reasoned";
+        readonly reason: "Same family; also the one schema member on TransactionBackend, so bundling it would re-open the accessor's B-1 port-typing question for no pilot consumer.";
+        readonly accesses: 1;
+    };
+    readonly schemaWriteTransaction: {
+        readonly kind: "reasoned";
+        readonly reason: "Same family — and it returns a narrowed transaction backend, so it is a port constructor rather than an operation.";
+        readonly accesses: 4;
+    };
+    readonly ensureIdentityTables: {
+        readonly kind: "reasoned";
+        readonly reason: "Identity DDL, gated by the identity construction gate (store.ts:918-935), which is the write-fence design's decision and must stay one owner there.";
+        readonly accesses: 4;
+    };
+    readonly identityTableDdl: {
+        readonly kind: "reasoned";
+        readonly reason: "Same identity-DDL family as ensureIdentityTables.";
+        readonly accesses: 2;
+    };
+    readonly recordedTableDdl: {
+        readonly kind: "reasoned";
+        readonly reason: "Recorded-time migration DDL factory; its only consumer has its own typed capability refusal, so it is a provisioning port rather than a feature-family operation.";
+        readonly accesses: 1;
+    };
+    readonly ensureKindRemovalsTable: {
+        readonly kind: "reasoned";
+        readonly reason: "Kind-removal provisioning; the removal path's own gate is a schema-lifecycle decision with a single consumer (materialize-removals.ts) and no second theory to consolidate.";
+        readonly accesses: 3;
+    };
+    readonly getAllKindRemovals: {
+        readonly kind: "reasoned";
+        readonly reason: "Same kind-removal family as ensureKindRemovalsTable.";
+        readonly accesses: 2;
+    };
+    readonly getPendingKindRemovals: {
+        readonly kind: "reasoned";
+        readonly reason: "Same kind-removal family as ensureKindRemovalsTable.";
+        readonly accesses: 4;
+    };
+    readonly recordKindRemoval: {
+        readonly kind: "reasoned";
+        readonly reason: "Same kind-removal family as ensureKindRemovalsTable.";
+        readonly accesses: 4;
+    };
+    readonly ensureReconciliationMarkersTable: {
+        readonly kind: "reasoned";
+        readonly reason: "Reconciliation-marker family; single consumer, single gate, same reasoning.";
+        readonly accesses: 2;
+    };
+    readonly getReconciliationMarker: {
+        readonly kind: "reasoned";
+        readonly reason: "Same reconciliation-marker family.";
+        readonly accesses: 2;
+    };
+    readonly setReconciliationMarker: {
+        readonly kind: "reasoned";
+        readonly reason: "Same reconciliation-marker family.";
+        readonly accesses: 2;
+    };
+    readonly readConstraintFenceViolations: {
+        readonly kind: "reasoned";
+        readonly reason: "Read-only fence audit with exactly one caller and a documented \"absent ⇒ the report is unavailable\" contract (history-store-backend.ts:105-108); no operation degrades or refuses on it.";
+        readonly accesses: 1;
+    };
+    readonly ensureContributionMaterializationsTable: {
+        readonly kind: "reasoned";
+        readonly reason: "Zero consumers in src/** outside the backend implementations — measured, not inferred. A member no code path consults has no measurable arity or disposition.";
+        readonly accesses: 0;
+    };
+    readonly getContributionMaterialization: {
+        readonly kind: "reasoned";
+        readonly reason: "Same zero-consumer family as ensureContributionMaterializationsTable.";
+        readonly accesses: 0;
+    };
+    readonly recordContributionMaterialization: {
+        readonly kind: "reasoned";
+        readonly reason: "Zero consumers outside the backend implementations; its only in-tree use is a backend implementation calling its own member (backend/drizzle/contribution-materializations.ts:1588), which the scanner excludes by scope.";
+        readonly accesses: 0;
+    };
+    readonly assertRuntimeContributionsInitialized: {
+        readonly kind: "deferred";
+        readonly workstream: "WS5b";
+        readonly bundle: "contributionProvisioning";
+        readonly ceiling: 1;
+    };
+    readonly assertVectorSlotInitialized: {
+        readonly kind: "deferred";
+        readonly workstream: "WS5b";
+        readonly bundle: "vectorSlotContributions";
+        readonly ceiling: 1;
+    };
+    readonly assertVectorSlotsInitialized: {
+        readonly kind: "deferred";
+        readonly workstream: "WS5b";
+        readonly bundle: "vectorSlotContributions";
+        readonly ceiling: 1;
+    };
+    readonly claimIndexMaterialization: {
+        readonly kind: "deferred";
+        readonly workstream: "WS5b";
+        readonly bundle: "indexMaterialization";
+        readonly ceiling: 2;
+    };
+    readonly compileSql: {
+        readonly kind: "deferred";
+        readonly workstream: "WS5b";
+        readonly bundle: "rawStatementReuse";
+        readonly ceiling: 9;
+    };
+    readonly createVectorIndex: {
+        readonly kind: "deferred";
+        readonly workstream: "WS5b";
+        readonly bundle: "vectorOperations";
+        readonly ceiling: 4;
+    };
+    readonly deleteEdgesBatch: {
+        readonly kind: "deferred";
+        readonly workstream: "WS5b";
+        readonly bundle: "batchEntityWrite";
+        readonly ceiling: 5;
+    };
+    readonly deleteEmbedding: {
+        readonly kind: "deferred";
+        readonly workstream: "WS5b";
+        readonly bundle: "vectorOperations";
+        readonly ceiling: 8;
+    };
+    readonly deleteEmbeddingBatch: {
+        readonly kind: "deferred";
+        readonly workstream: "WS5b";
+        readonly bundle: "vectorOperations";
+        readonly ceiling: 4;
+    };
+    readonly deleteFulltext: {
+        readonly kind: "deferred";
+        readonly workstream: "WS5b";
+        readonly bundle: "fulltextOperations";
+        readonly ceiling: 11;
+    };
+    readonly deleteFulltextBatch: {
+        readonly kind: "deferred";
+        readonly workstream: "WS5b";
+        readonly bundle: "fulltextOperations";
+        readonly ceiling: 6;
+    };
+    readonly deleteVectorSlotContribution: {
+        readonly kind: "deferred";
+        readonly workstream: "WS5b";
+        readonly bundle: "vectorSlotContributions";
+        readonly ceiling: 0;
+    };
+    readonly dropVectorIndex: {
+        readonly kind: "deferred";
+        readonly workstream: "WS5b";
+        readonly bundle: "vectorOperations";
+        readonly ceiling: 0;
+    };
+    readonly ensureExtension: {
+        readonly kind: "deferred";
+        readonly workstream: "WS5b";
+        readonly bundle: "databaseExtensions";
+        readonly ceiling: 2;
+    };
+    readonly ensureFulltextTable: {
+        readonly kind: "deferred";
+        readonly workstream: "WS5b";
+        readonly bundle: "fulltextProvisioning";
+        readonly ceiling: 1;
+    };
+    readonly ensureIndexMaterializationsTable: {
+        readonly kind: "deferred";
+        readonly workstream: "WS5b";
+        readonly bundle: "indexMaterialization";
+        readonly ceiling: 2;
+    };
+    readonly ensureRuntimeContributions: {
+        readonly kind: "deferred";
+        readonly workstream: "WS5b";
+        readonly bundle: "contributionProvisioning";
+        readonly ceiling: 2;
+    };
+    readonly ensureTrigramExtension: {
+        readonly kind: "deferred";
+        readonly workstream: "WS5b";
+        readonly bundle: "databaseExtensions";
+        readonly ceiling: 2;
+    };
+    readonly ensureVectorSlotContribution: {
+        readonly kind: "deferred";
+        readonly workstream: "WS5b";
+        readonly bundle: "vectorSlotContributions";
+        readonly ceiling: 4;
+    };
+    readonly ensureVectorSlotContributions: {
+        readonly kind: "deferred";
+        readonly workstream: "WS5b";
+        readonly bundle: "vectorSlotContributions";
+        readonly ceiling: 1;
+    };
+    readonly executeDdl: {
+        readonly kind: "deferred";
+        readonly workstream: "WS5b";
+        readonly bundle: "ddlExecution";
+        readonly ceiling: 13;
+    };
+    readonly executeRaw: {
+        readonly kind: "deferred";
+        readonly workstream: "WS5b";
+        readonly bundle: "rawStatementReuse";
+        readonly ceiling: 7;
+    };
+    readonly executeTemporaryStatement: {
+        readonly kind: "deferred";
+        readonly workstream: "WS5b";
+        readonly bundle: "temporaryStatements";
+        readonly ceiling: 3;
+    };
+    readonly findEdgesByEndpointSet: {
+        readonly kind: "deferred";
+        readonly workstream: "WS5b";
+        readonly bundle: "endpointSetRead";
+        readonly ceiling: 1;
+    };
+    readonly findEdgesByHeterogeneousEndpointSet: {
+        readonly kind: "deferred";
+        readonly workstream: "WS5b";
+        readonly bundle: "heterogeneousEndpointSetRead";
+        readonly ceiling: 1;
+    };
+    readonly fulltextSearch: {
+        readonly kind: "deferred";
+        readonly workstream: "WS5b";
+        readonly bundle: "fulltextOperations";
+        readonly ceiling: 4;
+    };
+    readonly fulltextStrategy: {
+        readonly kind: "deferred";
+        readonly workstream: "WS5b";
+        readonly bundle: "fulltextOperations";
+        readonly ceiling: 2;
+    };
+    readonly getIndexMaterialization: {
+        readonly kind: "deferred";
+        readonly workstream: "WS5b";
+        readonly bundle: "indexMaterialization";
+        readonly ceiling: 3;
+    };
+    readonly getIndexMaterializations: {
+        readonly kind: "deferred";
+        readonly workstream: "WS5b";
+        readonly bundle: "indexMaterialization";
+        readonly ceiling: 2;
+    };
+    readonly hardDeleteEdgesBatch: {
+        readonly kind: "deferred";
+        readonly workstream: "WS5b";
+        readonly bundle: "batchEntityWrite";
+        readonly ceiling: 5;
+    };
+    readonly hybridSearch: {
+        readonly kind: "deferred";
+        readonly workstream: "WS5b";
+        readonly bundle: "hybridSearch";
+        readonly ceiling: 2;
+    };
+    readonly insertEdgeNoReturn: {
+        readonly kind: "deferred";
+        readonly workstream: "WS5b";
+        readonly bundle: "batchEntityWrite";
+        readonly ceiling: 4;
+    };
+    readonly insertEdgesBatch: {
+        readonly kind: "deferred";
+        readonly workstream: "WS5b";
+        readonly bundle: "batchEntityWrite";
+        readonly ceiling: 4;
+    };
+    readonly insertEdgesBatchReturning: {
+        readonly kind: "deferred";
+        readonly workstream: "WS5b";
+        readonly bundle: "batchEntityWrite";
+        readonly ceiling: 4;
+    };
+    readonly insertNodeNoReturn: {
+        readonly kind: "deferred";
+        readonly workstream: "WS5b";
+        readonly bundle: "batchEntityWrite";
+        readonly ceiling: 4;
+    };
+    readonly insertNodesBatch: {
+        readonly kind: "deferred";
+        readonly workstream: "WS5b";
+        readonly bundle: "batchEntityWrite";
+        readonly ceiling: 4;
+    };
+    readonly insertNodesBatchReturning: {
+        readonly kind: "deferred";
+        readonly workstream: "WS5b";
+        readonly bundle: "batchEntityWrite";
+        readonly ceiling: 4;
+    };
+    readonly recordIndexMaterialization: {
+        readonly kind: "deferred";
+        readonly workstream: "WS5b";
+        readonly bundle: "indexMaterialization";
+        readonly ceiling: 6;
+    };
+    readonly releaseIndexMaterializationClaim: {
+        readonly kind: "deferred";
+        readonly workstream: "WS5b";
+        readonly bundle: "indexMaterialization";
+        readonly ceiling: 2;
+    };
+    readonly trustedImport: {
+        readonly kind: "deferred";
+        readonly workstream: "WS5b";
+        readonly bundle: "trustedImport";
+        readonly ceiling: 1;
+    };
+    readonly updateNodeSet: {
+        readonly kind: "deferred";
+        readonly workstream: "WS5b";
+        readonly bundle: "batchEntityWrite";
+        readonly ceiling: 6;
+    };
+    readonly upsertEmbedding: {
+        readonly kind: "deferred";
+        readonly workstream: "WS5b";
+        readonly bundle: "vectorOperations";
+        readonly ceiling: 10;
+    };
+    readonly upsertEmbeddingBatch: {
+        readonly kind: "deferred";
+        readonly workstream: "WS5b";
+        readonly bundle: "vectorOperations";
+        readonly ceiling: 4;
+    };
+    readonly upsertFulltext: {
+        readonly kind: "deferred";
+        readonly workstream: "WS5b";
+        readonly bundle: "fulltextOperations";
+        readonly ceiling: 9;
+    };
+    readonly upsertFulltextBatch: {
+        readonly kind: "deferred";
+        readonly workstream: "WS5b";
+        readonly bundle: "fulltextOperations";
+        readonly ceiling: 6;
+    };
+    readonly vectorSearch: {
+        readonly kind: "deferred";
+        readonly workstream: "WS5b";
+        readonly bundle: "vectorOperations";
+        readonly ceiling: 4;
+    };
+    readonly vectorStrategy: {
+        readonly kind: "deferred";
+        readonly workstream: "WS5b";
+        readonly bundle: "vectorOperations";
+        readonly ceiling: 9;
+    };
+};
+/**
+ * The appendix's 15 WS5b bundles, as (bundle id → member names) — written
+ * INDEPENDENTLY of `UNBUNDLED_OPTIONAL_MEMBERS`'s `deferred` entries, so the
+ * totality proof below is not a tautology: grouping the `deferred` entries
+ * by `bundle` must reproduce this table exactly.
+ */
+declare const WS5B_SEED_BUNDLES: {
+    readonly batchEntityWrite: readonly ["insertNodesBatch", "insertNodesBatchReturning", "insertEdgesBatch", "insertEdgesBatchReturning", "deleteEdgesBatch", "hardDeleteEdgesBatch", "insertNodeNoReturn", "insertEdgeNoReturn", "updateNodeSet"];
+    readonly endpointSetRead: readonly ["findEdgesByEndpointSet"];
+    readonly heterogeneousEndpointSetRead: readonly ["findEdgesByHeterogeneousEndpointSet"];
+    readonly vectorOperations: readonly ["upsertEmbedding", "deleteEmbedding", "upsertEmbeddingBatch", "deleteEmbeddingBatch", "vectorSearch", "vectorStrategy", "createVectorIndex", "dropVectorIndex"];
+    readonly hybridSearch: readonly ["hybridSearch"];
+    readonly vectorSlotContributions: readonly ["assertVectorSlotsInitialized", "assertVectorSlotInitialized", "ensureVectorSlotContributions", "ensureVectorSlotContribution", "deleteVectorSlotContribution"];
+    readonly fulltextOperations: readonly ["upsertFulltext", "deleteFulltext", "upsertFulltextBatch", "deleteFulltextBatch", "fulltextSearch", "fulltextStrategy"];
+    readonly fulltextProvisioning: readonly ["ensureFulltextTable"];
+    readonly databaseExtensions: readonly ["ensureExtension", "ensureTrigramExtension"];
+    readonly contributionProvisioning: readonly ["ensureRuntimeContributions", "assertRuntimeContributionsInitialized"];
+    readonly indexMaterialization: readonly ["getIndexMaterialization", "recordIndexMaterialization", "getIndexMaterializations", "ensureIndexMaterializationsTable", "claimIndexMaterialization", "releaseIndexMaterializationClaim"];
+    readonly ddlExecution: readonly ["executeDdl"];
+    readonly temporaryStatements: readonly ["executeTemporaryStatement"];
+    readonly rawStatementReuse: readonly ["executeRaw", "compileSql"];
+    readonly trustedImport: readonly ["trustedImport"];
+};
+
+/**
+ * A bundle's extras, as a type-level map from extra id to the UNION of
+ * member names that extra covers — derived from the definition's `extras`
+ * array by `const` inference, never hand-written.
+ */
+type CapabilityExtraSpec = Readonly<Record<string, OptionalGraphBackendMember>>;
+/**
+ * One extra's verdict. `present: true` carries the member NAMES, not the
+ * member functions (ruling B1) — the names are what the accessor binds
+ * from, at the site, off the port.
+ */
+type ExtraVerdict<M extends OptionalGraphBackendMember> = Readonly<{
+    present: true;
+    members: readonly M[];
+}> | Readonly<{
+    present: false;
+    missing: readonly M[];
+    disposition: CapabilityBundleDisposition;
+}>;
+/** The verdict map: one entry per extra id, never a boolean. */
+type ExtraVerdicts<X extends CapabilityExtraSpec> = Readonly<{
+    [K in keyof X]: ExtraVerdict<X[K]>;
+}>;
+type GatedBundleVerdict<MCore extends OptionalGraphBackendMember, X extends CapabilityExtraSpec> = Readonly<{
+    supported: true;
+    bundle: string;
+    /** The core, guaranteed present. Names, not functions. */
+    members: readonly MCore[];
+    extras: ExtraVerdicts<X>;
+    /** The `present: false` keys of `extras`. */
+    missingExtras: readonly (keyof X)[];
+}> | Readonly<{
+    supported: false;
+    bundle: string;
+    missing: readonly MCore[];
+    /** Why it is unsupported: the bundle's own `disposition`, verbatim. */
+    disposition: CapabilityBundleDisposition;
+}>;
+/** No `supported` field: a graduated bundle has no bundle-level verdict. */
+type GraduatedBundleVerdict<X extends CapabilityExtraSpec> = Readonly<{
+    bundle: string;
+    extras: ExtraVerdicts<X>;
+    missingExtras: readonly (keyof X)[];
+}>;
+/**
+ * Recovers the id→members map from a definition's `extras` TUPLE (not
+ * `readonly CapabilityBundleExtra<XId, MExtra>[]` — over the array type the
+ * id→members association is erased and `ExtraVerdicts<X>` degenerates to an
+ * index signature).
+ */
+type SpecOf<XS extends readonly CapabilityBundleExtra<string, OptionalGraphBackendMember>[]> = {
+    [K in XS[number] as K["id"]]: K["members"][number];
+};
+type ExtrasOf<D extends CapabilityBundleDefinition> = SpecOf<NonNullable<D["extras"]>>;
+type ExtraMember<D extends CapabilityBundleDefinition, X extends keyof ExtrasOf<D>> = Extract<ExtrasOf<D>[X], OptionalGraphBackendMember>;
+/**
+ * The definition union and the return-type mapping. Structural, matching
+ * `bundle-registry.ts`'s `BundleMembers` helper's own lesson: reading `core`
+ * off `D` directly (rather than re-matching `GatedBundleDefinition`) avoids
+ * an unmatched `infer` silently widening to the member constraint.
+ */
+type BundleVerdictOf<D extends CapabilityBundleDefinition> = D extends ({
+    kind: "graduated";
+    extras: infer XS extends readonly CapabilityBundleExtra<string, OptionalGraphBackendMember>[];
+}) ? GraduatedBundleVerdict<SpecOf<XS>> : D extends ({
+    kind: "gated";
+    core: readonly (infer MCore extends OptionalGraphBackendMember)[];
+    extras?: infer XS extends readonly CapabilityBundleExtra<string, OptionalGraphBackendMember>[] | undefined;
+}) ? GatedBundleVerdict<MCore, SpecOf<XS extends (readonly CapabilityBundleExtra<string, OptionalGraphBackendMember>[]) ? XS : []>> : never;
+/**
+ * Resolved ONCE, at construction or entry, against the top-level backend —
+ * never against a `TransactionBackend` (I15's `@ts-expect-error` row).
+ *
+ * Rules: the member surface is read always; the declaration is read only
+ * when the definition names one AND `crossCheck !== "none"` (only `claims`
+ * qualifies in the pilot registry); a gated bundle's core must be complete
+ * or the bundle is unsupported with `missing`; a graduated bundle has no
+ * bundle-level verdict, only per-extra verdicts. `missingExtras` is built by
+ * the SAME fold that builds `extras` (one pass, one owner).
+ */
+declare function resolveBundle<const D extends CapabilityBundleDefinition>(backend: GraphBackend, definition: D): BundleVerdictOf<D>;
+/** The literal operation names a bundle's `operations` table declares. */
+type OperationNames<D extends CapabilityBundleDefinition> = D["operations"][number]["operation"];
+/** The extras a named operation `requires`, read from the ROW — never re-spelled at the call site. */
+type RequiredExtrasOf<D extends CapabilityBundleDefinition, Op extends OperationNames<D>> = Extract<D["operations"][number], {
+    operation: Op;
+}> extends ({
+    requires: infer R extends readonly string[];
+}) ? R[number] : never;
+/**
+ * The registry's row lookup plus the presence fold, extracted verbatim from
+ * {@link requireExtras}'s body (ruling B8 spec item 3): the ONE owner of
+ * "what this operation requires" that both `requireExtras`'s default throw
+ * and a call site's own `refuse` callback consult.
+ *
+ * `operation` is the literal key of the bundle's `operations` tuple, so the
+ * required extras are looked up TYPE-LEVEL from the registry — no second
+ * spelling of `requires` at the call site.
+ *
+ * @throws {ConfigurationError} naming the unknown operation when `operation`
+ *   is not a row of `definition.operations`.
+ */
+declare function missingRequiredExtras<const D extends CapabilityBundleDefinition, Op extends OperationNames<D>>(definition: D, verdict: BundleVerdictOf<D>, operation: Op): readonly string[];
+/**
+ * The refusal for an operation whose `requires` extras are absent — how a
+ * GRADUATED bundle refuses where the tree refuses today: the row names the
+ * operation and the extras, this asserts they are present, and
+ * {@link bindExtra} (`bind.ts`) binds them off the port.
+ *
+ * `refuse`, when supplied, is called instead of the registry-coded throw
+ * below — this is how a call site keeps its OWN existing error text (message,
+ * `details` shape, order relative to other refusals) while the registry
+ * stays the one owner of "what this operation requires" (ruling B8 spec item
+ * 3). Omitting it keeps the default behavior byte-identical to before this
+ * parameter existed.
+ *
+ * @throws {ConfigurationError} naming the row's own `code` when one or more
+ *   required extras is absent from the verdict and no `refuse` callback is
+ *   supplied; otherwise calls `refuse(missing)`, which never returns.
+ */
+declare function requireExtras<const D extends CapabilityBundleDefinition, Op extends OperationNames<D>>(definition: D, verdict: BundleVerdictOf<D>, operation: Op, refuse?: (missing: readonly string[]) => never): asserts verdict is BundleVerdictOf<D> & {
+    extras: {
+        [K in RequiredExtrasOf<D, Op> & keyof ExtrasOf<D>]: Extract<ExtraVerdict<ExtraMember<D, K>>, {
+            present: true;
+        }>;
+    };
+};
+declare function claimsVerdict(backend: GraphBackend): BundleVerdictOf<typeof CLAIMS>;
+declare function uniqueSidecarBatchVerdict(backend: GraphBackend): BundleVerdictOf<typeof UNIQUE_SIDECAR_BATCH>;
+declare function batchPointReadVerdict(backend: GraphBackend): BundleVerdictOf<typeof BATCH_POINT_READ>;
+declare function statementExecutionVerdict(backend: GraphBackend): BundleVerdictOf<typeof STATEMENT_EXECUTION>;
+declare function contributionHealthVerdict(backend: GraphBackend): BundleVerdictOf<typeof CONTRIBUTION_HEALTH>;
+declare function recordedRevisionOriginsVerdict(backend: GraphBackend): BundleVerdictOf<typeof RECORDED_REVISION_ORIGINS>;
+/**
+ * A memoized, at-most-once resolution of the `claims` bundle's verdict
+ * against ONE backend.
+ *
+ * Eager resolution at store construction is forbidden: T14's
+ * contradictory-declaration backends must still be able to construct a store
+ * and create nodes — only a constrained edge write may legally reach the
+ * bidirectional cross-check's throw, and it must do so lazily, at the first
+ * write that needs the verdict.
+ *
+ * A cached verdict cannot go stale because `GraphBackend` is deep-frozen (B1):
+ * nothing can flip `capabilities.constraintClaims` or add/remove a claim
+ * member on a backend object after this thunk has already resolved it, so
+ * "resolve once and reuse forever" is exactly as safe as "resolve every
+ * time" — for one backend object, they observe the same immutable answer.
+ */
+type ClaimsVerdictThunk = () => BundleVerdictOf<typeof CLAIMS>;
+/**
+ * Mints — or returns the already-minted — {@link ClaimsVerdictThunk} for
+ * `backend`.
+ *
+ * The thunk resolves {@link resolveBundle}`(backend, CLAIMS)` on its first
+ * call and caches the outcome, INCLUDING a thrown `ConfigurationError`: a
+ * refusal is cached and re-thrown on every subsequent call, never
+ * re-resolved. Both layers — interning here, memoization inside the thunk —
+ * are required: interning alone would still let two independently-memoized
+ * thunks exist for one backend if a caller ignored the shared one; memoizing
+ * alone would still let two different call sites mint two different thunks
+ * that could disagree about whether they had already resolved.
+ */
+declare function createClaimsVerdictThunk(backend: GraphBackend): ClaimsVerdictThunk;
+
+export { batchPointReadVerdict as A, BATCH_POINT_READ as B, type CapabilityBundleId as C, type DeferredUnbundledMember as D, type ExtraMember as E, claimsVerdict as F, type GatedBundleDefinition as G, contributionHealthVerdict as H, createClaimsVerdictThunk as I, missingRequiredExtras as J, recordedRevisionOriginsVerdict as K, requireExtras as L, resolveBundle as M, statementExecutionVerdict as N, type OptionalGraphBackendMember as O, uniqueSidecarBatchVerdict as P, RECORDED_REVISION_ORIGINS as R, STATEMENT_EXECUTION as S, UNIQUE_SIDECAR_BATCH as U, WS5B_SEED_BUNDLES as W, type ExtrasOf as a, type BundleVerdictOf as b, type ExtraVerdict as c, CLAIMS as d, CONTRIBUTION_HEALTH as e, CAPABILITY_BUNDLES as f, type CapabilityBundleDefinition as g, type CapabilityBundleDisposition as h, type CapabilityBundleExtra as i, type CapabilityBundleOperation as j, type CapabilityBundleOperationSite as k, type CapabilityCrossCheck as l, type CapabilityExtraSpec as m, type ClaimsVerdictThunk as n, type ExtraVerdicts as o, type GatedBundleVerdict as p, type GraduatedBundleDefinition as q, type GraduatedBundleVerdict as r, type OperationNames as s, type OptionalKeys as t, type ReasonedUnbundledMember as u, type RequiredExtrasOf as v, type SpecOf as w, UNBUNDLED_OPTIONAL_MEMBERS as x, type UnbundledOptionalMember as y, type Ws5bBundleId as z };