@nicia-ai/typegraph 0.44.0 → 0.46.0

package/dist/{types-Cjvkj0jA.d.ts → types-HkveCCx0.d.cts}

@@ -375,6 +375,31 @@ type TableContribution = Readonly<{
      * signature.
      */
     createDdl: readonly string[];
+    /**
+     * Idempotent (`DROP ... IF EXISTS`) statements that tear this
+     * contribution's storage down, ordered so that running the list
+     * leaves nothing behind. Declaring it is what makes a contribution
+     * *rebuildable*: the destructive
+     * `store.rebuildContribution()` path drops through these statements
+     * before re-running {@link createDdl}, which is the only repair for a
+     * table provisioned at a shape the current `createDdl` no longer
+     * produces.
+     *
+     * Optional because it is a capability, not an invariant. A
+     * contribution whose content cannot be reconstructed from data
+     * TypeGraph already stores has no business advertising a rebuild —
+     * dropping it would destroy the only copy — and a third-party
+     * strategy that predates this field keeps compiling and is reported
+     * as not rebuildable rather than silently rebuilt through a
+     * synthesized `DROP`. Backends surface the resulting gap as
+     * `capabilities.contributions.rebuild`.
+     *
+     * The rebuild visits a strategy's `runtimeEnsure` contributions, the
+     * same set the boot ensure provisions — so a companion table a strategy
+     * declares outside that set is neither dropped nor recreated, and must
+     * not be something the recreated storage depends on.
+     */
+    dropDdl?: readonly string[];
     /**
      * When `true`, the post-schema-load focused ensure
      * (`loadActiveSchemaWithBootstrap`) materializes this contribution
@@ -492,6 +517,14 @@ type FulltextStrategy = Readonly<{
      * Replaces the former `generateDdl(tableName)`: DDL is now one field
      * of a contribution rather than the strategy's whole storage
      * surface. (Public API change — see #129.)
+     *
+     * Declare `dropDdl` on each contribution to opt the strategy into the
+     * destructive `store.rebuildContribution("fulltext")` path — the only
+     * repair for storage provisioned at a shape `createDdl` no longer
+     * produces. Fulltext content is reconstructed from the node rows, so a
+     * rebuild loses nothing; a strategy that omits `dropDdl` is reported
+     * as not rebuildable instead of being dropped through a synthesized
+     * statement.
      */
     ownedTables: (this: void, primaryTableName: string) => readonly StrategyTableContribution[];
     /**
@@ -572,7 +605,17 @@ type DialectCapabilities = Readonly<{
      */
     emitNotMaterializedHint: boolean;
     /**
-     * Whether recursive CTEs should enforce worktable-first join ordering.
+     * Whether a traversal must pin its frontier ahead of the edge table with
+     * `CROSS JOIN`, because the engine reads FROM order as a join-order directive
+     * rather than costing the orderings itself.
+     *
+     * Set for engines whose planner has no useful statistics for the driving
+     * relation and can therefore choose to enumerate candidate edges instead —
+     * once per frontier row. Two traversal shapes need the pin: a recursive term,
+     * whose driving relation is the worktable, and an identity-expanded step,
+     * which reaches the edge through `COALESCE` over an outer join and so exposes
+     * no direct frontier-to-edge equality. Every other traversal joins on the
+     * frontier's own columns and is left to the planner.
      */
     forceRecursiveWorktableOuterJoinOrder: boolean;
     /**
@@ -777,6 +820,13 @@ interface DialectAdapter {
      * PostgreSQL: jsonb_typeof(column #> path) = 'number'
      */
     readonly jsonPathIsNumber: (this: void, column: SqlFragment, pointer: JsonPointer) => SqlFragment;
+    /**
+     * Replaces top-level JSON object properties while preserving explicit JSON
+     * null values. This is the token-level dialect seam used by set-based node
+     * mutation; callers validate the patch against the node schema before SQL
+     * compilation.
+     */
+    readonly jsonSetProperties: (this: void, column: SqlFragment, patch: Readonly<Record<string, JsonValue>>, unsetProperties?: readonly string[]) => SqlFragment;
     /**
      * Null-safe equality: `TRUE` when both sides are equal OR both are NULL.
      * Unlike `=`, a NULL on either side does not yield NULL/unknown.
@@ -1038,6 +1088,14 @@ type SqlTableNames = Readonly<{
     recordedClock?: string | undefined;
     /** Durable per-graph revision-origin table name (default: "typegraph_revision_origins") */
     revisionOrigins?: string | undefined;
+    /** Identity assertion ledger (default: "typegraph_identity_assertions") */
+    identityAssertions?: string | undefined;
+    /** Recorded identity assertion relation */
+    recordedIdentityAssertions?: string | undefined;
+    /** Derived current identity closure */
+    identityClosure?: string | undefined;
+    /** Derived separation relation over identity classes */
+    identitySeparation?: string | undefined;
     /** Node fulltext table name (default: "typegraph_node_fulltext") */
     fulltext: string;
     /** Node uniques table name (default: "typegraph_node_uniques") */
@@ -1056,6 +1114,10 @@ type ResolvedSqlTableNames = Readonly<{
     recordedClock: string;
     /** Durable per-graph revision-origin table name */
     revisionOrigins: string;
+    identityAssertions: string;
+    recordedIdentityAssertions: string;
+    identityClosure: string;
+    identitySeparation: string;
     /** Node fulltext table name */
     fulltext: string;
     /** Node uniques table name */
@@ -1076,6 +1138,14 @@ type SqlSchemaFields = Readonly<{
     recordedClockTable: SqlFragment;
     /** Get a `SqlFragment` reference to the durable per-graph revision origins. */
     revisionOriginsTable: SqlFragment;
+    /** Get a `SqlFragment` reference to the identity assertion ledger. */
+    identityAssertionsTable: SqlFragment;
+    /** Get a `SqlFragment` reference to the recorded identity assertion relation. */
+    recordedIdentityAssertionsTable: SqlFragment;
+    /** Get a `SqlFragment` reference to the derived identity closure. */
+    identityClosureTable: SqlFragment;
+    /** Get a `SqlFragment` reference to the derived identity separation relation. */
+    identitySeparationTable: SqlFragment;
     /** Get a `SqlFragment` reference to the fulltext table. */
     fulltextTable: SqlFragment;
 }>;
@@ -1095,6 +1165,10 @@ declare abstract class SqlSchema implements SqlSchemaFields {
     abstract readonly recordedEdgesTable: SqlFragment;
     abstract readonly recordedClockTable: SqlFragment;
     abstract readonly revisionOriginsTable: SqlFragment;
+    abstract readonly identityAssertionsTable: SqlFragment;
+    abstract readonly recordedIdentityAssertionsTable: SqlFragment;
+    abstract readonly identityClosureTable: SqlFragment;
+    abstract readonly identitySeparationTable: SqlFragment;
     abstract readonly fulltextTable: SqlFragment;
 }
 /**
@@ -1311,6 +1385,10 @@ type VectorStrategy = Readonly<{
     buildUpsertBatch?: (this: void, slot: VectorSlot, params: UpsertEmbeddingBatchParams, timestamp: string) => readonly SqlFragment[];
     /** Emits the statement(s) that delete a single embedding from the slot. */
     buildDelete: (this: void, slot: VectorSlot, params: DeleteEmbeddingParams) => readonly SqlFragment[];
+    /** Emits one set-based delete for many node ids in a vector slot. */
+    buildDeleteBatch: (this: void, slot: VectorSlot, params: Omit<DeleteEmbeddingParams, "nodeId"> & Readonly<{
+        nodeIds: readonly string[];
+    }>) => readonly SqlFragment[];
     /**
      * Raw DDL statement(s) that drop the slot's entire physical storage
      * (table + ANN index, and any engine-managed shadow tables). Used by the
@@ -1810,6 +1888,185 @@ type OntologyRelation = Readonly<{
  */
 declare function isMetaEdge(value: unknown): value is MetaEdge;
 
+/** Brand key for GraphDef */
+declare const GRAPH_DEF_BRAND: "__graphDef";
+/**
+ * An edge entry in the graph definition.
+ * Can be:
+ * - EdgeType directly (constrained or unconstrained)
+ * - EdgeRegistration object (always works, can override/narrow defaults)
+ */
+type EdgeEntry = EdgeRegistration | AnyEdgeType;
+/**
+ * Normalized edge map type - all entries become EdgeRegistration.
+ * For bare EdgeTypes, constrained endpoints are extracted from the type;
+ * unconstrained edges fall back to all node types in the graph.
+ */
+type NormalizedEdges<TNodes extends Record<string, NodeRegistration>, TEdges extends Record<string, EdgeEntry>> = {
+    [K in keyof TEdges]: TEdges[K] extends EdgeRegistration ? TEdges[K] : TEdges[K] extends AnyEdgeType ? EdgeRegistration<TEdges[K], TEdges[K]["from"] extends readonly (infer N extends NodeType)[] ? N : TNodes[keyof TNodes]["type"], TEdges[K]["to"] extends readonly (infer N extends NodeType)[] ? N : TNodes[keyof TNodes]["type"]> : never;
+};
+/** Durable graph-level configuration for the TypeGraph Identity Profile. */
+type GraphIdentityConfig = Readonly<{
+    /** Whether equal ids in different kinds implicitly join one identity class. */
+    sameIdAcrossKinds: "fold" | "ignore";
+}>;
+/**
+ * Configuration for defineGraph.
+ */
+type GraphDefConfig<TNodes extends Record<string, NodeRegistration>, TEdges extends Record<string, EdgeEntry>, TOntology extends readonly OntologyRelation[], TIdentity extends GraphIdentityConfig | undefined> = Readonly<{
+    /** Unique identifier for this graph */
+    id: string;
+    /** Node registrations */
+    nodes: TNodes;
+    /** Edge registrations or EdgeTypes with built-in domain/range */
+    edges: TEdges;
+    /** Ontology relations */
+    ontology?: TOntology;
+    /** Graph-wide defaults */
+    defaults?: GraphDefaults;
+    /** Enables the TypeGraph Identity Profile for this graph. */
+    identity?: TIdentity;
+    /**
+     * Index declarations attached to this graph.
+     *
+     * Accepts the outputs of `defineNodeIndex` / `defineEdgeIndex` (which
+     * already return `IndexDeclaration` values) or pre-built declarations
+     * reconstructed from a stored schema or graph extension.
+     *
+     * Validated at definition time: every index must reference a `kind`
+     * that exists in `nodes` / `edges`, and index `name`s must be unique
+     * within the graph.
+     *
+     * Index DDL is **not** generated by `defineGraph`. Indexes flow into
+     * `SerializedSchema.indexes` so they can later be materialized via
+     * `store.materializeIndexes()` — lifting the storage concern out of
+     * the schema-version commit path.
+     */
+    indexes?: readonly IndexDeclaration[];
+}>;
+/**
+ * A graph definition.
+ *
+ * This is a compile-time artifact that describes the structure of a graph.
+ * Use `createStore()` to create a runtime store from this definition.
+ */
+type GraphDef<TNodes extends Record<string, NodeRegistration> = Record<string, NodeRegistration>, TEdges extends Record<string, EdgeRegistration> = Record<string, EdgeRegistration>, TOntology extends readonly OntologyRelation[] = readonly OntologyRelation[], TIdentity extends GraphIdentityConfig | undefined = GraphIdentityConfig | undefined> = Readonly<{
+    [GRAPH_DEF_BRAND]: true;
+    id: string;
+    nodes: TNodes;
+    edges: TEdges;
+    ontology: TOntology;
+    /** Durable graph-level opt-in to the TypeGraph Identity Profile. */
+    identity: TIdentity;
+    defaults: Readonly<{
+        onNodeDelete: DeleteBehavior;
+        temporalMode: TemporalMode;
+    }>;
+    /**
+     * Index declarations attached to this graph. Preserves whatever the
+     * caller passed to `defineGraph` (including an explicit empty array)
+     * for introspection purposes.
+     *
+     * The serialized canonical form is order-canonicalized (sorted by
+     * `name`) and treats `undefined` and `[]` as the same "no slice" form
+     * — an empty array does not bump the schema hash, since indexes are
+     * an unordered set keyed by name and `[]` carries no semantic meaning
+     * that an absent slice doesn't.
+     */
+    indexes: readonly IndexDeclaration[] | undefined;
+    /**
+     * Graph extension this graph was merged with, if any. Set by
+     * `mergeGraphExtension`; never set by `defineGraph` directly.
+     * Exists solely so re-serialization is stable — the rest of the
+     * system reads the merged kinds through `nodes` / `edges` /
+     * `ontology` and never inspects this field. Absent on graphs that
+     * have never been extended; legacy graphs hash byte-identically.
+     */
+    extension: GraphExtension | undefined;
+    /**
+     * Soft-deprecated kind names attached to this graph. Set by the
+     * loader from the persisted schema and by `store.deprecateKinds(...)`
+     * / `store.undeprecateKinds(...)`. A purely informational signal
+     * surfaced for introspection — does not gate reads, writes, or
+     * queries. Defaults to the empty set on freshly-defined graphs.
+     */
+    deprecatedKinds: ReadonlySet<string>;
+}>;
+/**
+ * Extract node kind names from a GraphDef.
+ */
+type NodeKinds<G extends GraphDef> = keyof G["nodes"] & string;
+/**
+ * Extract edge kind names from a GraphDef.
+ */
+type EdgeKinds<G extends GraphDef> = keyof G["edges"] & string;
+/**
+ * Get a NodeType from a GraphDef by kind name.
+ */
+type GetNodeType<G extends GraphDef, K extends NodeKinds<G>> = G["nodes"][K]["type"];
+/**
+ * Get an EdgeType from a GraphDef by kind name.
+ */
+type GetEdgeType<G extends GraphDef, K extends EdgeKinds<G>> = G["edges"][K]["type"];
+/**
+ * Get all NodeTypes from a GraphDef.
+ */
+type AllNodeTypes<G extends GraphDef> = {
+    [K in NodeKinds<G>]: G["nodes"][K]["type"];
+}[NodeKinds<G>];
+/**
+ * Get all EdgeTypes from a GraphDef.
+ */
+type AllEdgeTypes<G extends GraphDef> = {
+    [K in EdgeKinds<G>]: G["edges"][K]["type"];
+}[EdgeKinds<G>];
+/**
+ * Creates a graph definition.
+ *
+ * @example
+ * ```typescript
+ * const graph = defineGraph({
+ *   id: "my_graph",
+ *   nodes: {
+ *     Person: { type: Person },
+ *     Company: { type: Company },
+ *   },
+ *   edges: {
+ *     // Traditional EdgeRegistration syntax
+ *     worksAt: {
+ *       type: worksAt,
+ *       from: [Person],
+ *       to: [Company],
+ *       cardinality: "many",
+ *     },
+ *     // Or use EdgeType directly if it has from/to defined
+ *     knows,  // EdgeType with built-in domain/range
+ *   },
+ *   ontology: [
+ *     subClassOf(Company, Organization),
+ *     disjointWith(Person, Organization),
+ *   ],
+ *   defaults: {
+ *     onNodeDelete: "restrict",
+ *     temporalMode: "current",
+ *   },
+ * });
+ * ```
+ */
+declare function defineGraph<const TNodes extends Record<string, NodeRegistration<NodeType>>, const TEdges extends Record<string, EdgeEntry>, const TOntology extends readonly OntologyRelation[], const TIdentity extends GraphIdentityConfig | undefined = undefined>(config: GraphDefConfig<TNodes, TEdges, TOntology, TIdentity>): GraphDef<TNodes, NormalizedEdges<TNodes, TEdges>, TOntology, TIdentity>;
+/**
+ * Checks if a value is a GraphDef.
+ */
+declare function isGraphDef(value: unknown): value is GraphDef;
+/**
+ * Gets all node kind names from a GraphDef.
+ */
+declare function getNodeKinds<G extends GraphDef>(graph: G): readonly (keyof G["nodes"] & string)[];
+/**
+ * Gets all edge kind names from a GraphDef.
+ */
+declare function getEdgeKinds<G extends GraphDef>(graph: G): readonly (keyof G["edges"] & string)[];
+
 /**
  * JSON Schema type (subset used by Zod toJSONSchema).
  *
@@ -1937,6 +2194,8 @@ type SerializedSchema = Readonly<{
         onNodeDelete: DeleteBehavior;
         temporalMode: TemporalMode;
     }>;
+    /** Durable opt-in to the TypeGraph Identity Profile. */
+    identity?: GraphIdentityConfig;
     /**
      * Index declarations attached to the graph.
      *
@@ -2047,6 +2306,48 @@ type FilteredApproximateSearch = Readonly<{
      */
     guaranteesFullPage: boolean;
 }>;
+/**
+ * Whether an engine exposes a PER-SEARCH knob for the ANN candidate frontier —
+ * the parameter {@link VectorSearchParams.efSearch} maps onto.
+ *
+ * Declared, never inferred: `efSearch` is an accepted option, so a backend that
+ * cannot apply it must refuse it rather than ignore it (AGENTS.md contract
+ * discipline). This capability is what the shared refusal predicate reads, and
+ * what a caller reads to know whether passing `efSearch` will be honored.
+ *
+ * - **pgvector**: `hnsw.ef_search`, applied per search with `SET LOCAL` inside
+ *   the search's own transaction — hence `requiresTransactionScope`, since a
+ *   session-wide `SET` would leak the override into concurrent searches.
+ * - **sqlite-vec**: `tunable: false`. A vec0 KNN takes `k` and nothing else;
+ *   there is no frontier to widen.
+ * - **libSQL DiskANN**: `tunable: false`. `vector_top_k(idx, q, k)` is a table
+ *   function with no per-query parameters; DiskANN's `search_l` is fixed at
+ *   index-creation time.
+ */
+type VectorSearchFrontierTuning = Readonly<{
+    tunable: true;
+    /** Engine-native parameter `efSearch` maps to (`"hnsw.ef_search"`). */
+    parameter: string;
+    /**
+     * The one index type whose search honors the parameter. `efSearch` on a
+     * slot of any other index type is refused, not ignored: an IVFFlat or
+     * brute-force slot would silently discard it.
+     */
+    indexType: VectorIndexType;
+    /**
+     * `true` when applying the parameter needs a transaction to scope it to
+     * the one search. A backend that reports `transactions: false` refuses
+     * `efSearch` rather than leaking a session-wide setting.
+     */
+    requiresTransactionScope: boolean;
+}> | Readonly<{
+    tunable: false;
+    /**
+     * Why this engine has no per-search frontier knob — surfaced in the
+     * refusal's details so the state is named rather than implied.
+     */
+    reason: string;
+}>;
 /**
  * Vector search capabilities.
  */
@@ -2067,6 +2368,14 @@ type VectorCapabilities = Readonly<{
      * an engine promise it does not keep.
      */
     filteredApproximateSearch: FilteredApproximateSearch;
+    /**
+     * Whether a per-search ANN frontier override (`efSearch`) can be applied.
+     * See {@link VectorSearchFrontierTuning}.
+     *
+     * Required, so a new vector strategy must state whether it honors the
+     * option instead of inheriting silence — the exact defect this closes.
+     */
+    searchFrontierTuning: VectorSearchFrontierTuning;
 }>;
 /**
  * Query modes for fulltext search.
@@ -2112,6 +2421,46 @@ type GraphAnalyticsCapabilities = Readonly<{
     supported: boolean;
     mathFunctions: boolean;
 }>;
+/**
+ * How much of the contribution health lifecycle a backend can serve.
+ *
+ * The three rungs escalate — probe (read-only) → repair
+ * (non-destructive) → rebuild (destructive) — and each is declared
+ * separately because a backend can genuinely stop at any of them. A
+ * backend that provisions contributions but cannot probe its own catalog
+ * is a real gap, and the honest answer to `store.probeContributions()`
+ * there is a refusal, not `ready`: "assessed and healthy" and "never
+ * looked" must never share a return value.
+ */
+type ContributionCapabilities = Readonly<{
+    /**
+     * Whether strategy-owned contribution tables are provisioned and
+     * attested by durable markers on this backend at all. `false` means
+     * there is nothing to assess, and the probe reports no entries rather
+     * than refusing.
+     */
+    supported: boolean;
+    /**
+     * Whether the backend can cross its durable markers against the live
+     * catalog — `store.probeContributions()` and
+     * `store.verifyContributions()`. False with `supported: true` is the
+     * declared gap: both refuse with `ConfigurationError`.
+     */
+    probe: boolean;
+    /**
+     * Whether the backend can run the destructive drop → recreate →
+     * repopulate → stamp rebuild (`store.rebuildContribution()`). Requires
+     * both a strategy that declares `dropDdl` and a transactional schema
+     * fence to run it under; false means `rebuildContribution` refuses.
+     *
+     * Describes the fulltext projection only. `rebuildContribution("vector")`
+     * refuses on every backend regardless of this flag — embeddings exist
+     * only in the storage a rebuild would drop, so there is nothing to
+     * reconstruct them from — and `reembedVectorField` is the sanctioned
+     * destructive path there.
+     */
+    rebuild: boolean;
+}>;
 
 /**
  * Backend capabilities that vary by dialect.
@@ -2151,6 +2500,12 @@ type BackendCapabilities = Readonly<{
     fulltext?: FulltextCapabilities | undefined;
     /** Whole-graph analytics capabilities (undefined when unavailable). */
     graphAnalytics?: GraphAnalyticsCapabilities | undefined;
+    /**
+     * How far up the contribution health ladder this backend goes
+     * (undefined on a backend with no contribution machinery at all,
+     * equivalent to every member `false`).
+     */
+    contributions?: ContributionCapabilities | undefined;
 }>;
 /** Keeps session-scoped analytics honest when a required SQL feature is absent. */
 declare function normalizeGraphAnalyticsCapabilities(capabilities: BackendCapabilities): BackendCapabilities;
@@ -2276,11 +2631,69 @@ type UpdateNodeParams = Readonly<{
     kind: string;
     id: string;
     props: Readonly<Record<string, unknown>>;
+    /** Applied when resurrecting a tombstone; omitted means the resurrection instant. */
+    validFrom?: string | null;
     validTo?: string;
+    /**
+     * The effective `valid_from` this write ASSERTS the target row already
+     * carries, stated only by a caller whose decision DEPENDED on it.
+     *
+     * `(graph_id, kind, id)` does not pin a row across time. A caller that
+     * validated the document's window against the bound it probed — interchange
+     * import's `onConflict: "update"` is the case — decided what to write from a
+     * value a concurrent `hardDelete` + recreate can replace between the probe
+     * and the write, so a predicate on identity alone lets that decision land on
+     * a row it was never computed for: the document's stated `validFrom` is
+     * ignored, or a `valid_to` is persisted below the new row's `valid_from`.
+     * Stating the bound here puts it in the UPDATE's own `WHERE`, which is the
+     * only placement the race cannot slip past.
+     *
+     * NULL-SAFE: `null` asserts the row has NO lower bound (`IS NULL`), a string
+     * asserts equality, and omitting it asserts nothing. `null` and `undefined`
+     * are therefore NOT interchangeable here — see `expectedValidFromPredicate`.
+     *
+     * A backend MUST apply the predicate when it is present, on the same terms as
+     * {@link UpdateEdgeParams.kind}: silently ignoring it re-opens the window the
+     * caller stated it to close. A write whose stated bound does not match affects
+     * zero rows and surfaces as a `no_row_returned` `DatabaseOperationError`.
+     */
+    expectedValidFrom?: string | null;
     incrementVersion?: boolean;
     /** If true, clears deleted_at (un-deletes the node). Used by upsert. */
     clearDeleted?: boolean;
 }>;
+/**
+ * Parameters for updating a set of live nodes selected by a compiled
+ * TypeGraph query.
+ *
+ * The candidate query must expose the named node-id column from the same graph
+ * and kind. The backend independently fences the rows it writes to
+ * `graphId` and `kind`; constructing the matching candidate query remains the
+ * caller's responsibility.
+ * Property values replace top-level keys, including preserving an explicit
+ * JSON `null` value.
+ *
+ * This is a storage primitive: callers that expose it as a graph mutation are
+ * responsible for schema validation and for synchronizing uniqueness,
+ * fulltext, and vector sidecars. The result contains after-images only; callers
+ * that need previous property values must freeze the candidate set and retain
+ * its before-images in the same transaction before invoking this method.
+ */
+type UpdateNodeSetParams = Readonly<{
+    graphId: string;
+    kind: string;
+    patch: Readonly<Record<string, JsonValue>>;
+    /** Top-level properties to remove (the storage form of an `undefined` patch value). */
+    unsetProperties?: readonly string[];
+    candidateIds: CompiledSelectSql;
+    /** Projected SQL column holding the candidate node id (for example `n_id`). */
+    candidateIdColumn: string;
+}>;
+/** The after-images changed by {@link GraphBackend.updateNodeSet}. */
+type UpdateNodeSetResult = Readonly<{
+    affectedCount: number;
+    rows: readonly NodeRow[];
+}>;
 /**
  * Parameters for deleting a node (soft delete).
  */
@@ -2328,8 +2741,71 @@ type TrustedImportSession = Readonly<{
 type UpdateEdgeParams = Readonly<{
     graphId: string;
     id: string;
+    /**
+     * The kind this write ASSERTS the target row already carries.
+     *
+     * Edge ids are graph-global while public collections are kind-scoped, so a
+     * kind-scoped write has an expected kind and must not land on a row carrying
+     * a different one. Stating it here puts the predicate in the write
+     * statement's own `WHERE`, which is the only placement a concurrent
+     * `hardDelete` + recreate cannot slip past: a read-then-write pair keyed on
+     * `(graph_id, id)` alone re-resolves that id between the read and the write
+     * under PostgreSQL READ COMMITTED. A write whose stated kind does not match
+     * affects zero rows.
+     *
+     * A backend MUST apply the predicate when it is present — silently ignoring
+     * it re-opens the window the caller stated it to close, and the ignoring
+     * backend looks correct until it is raced.
+     * `tests/edge-write-self-verification.test.ts` asserts the behavior against
+     * the built-in backends.
+     *
+     * Omitted where the operation legitimately spans kinds: the node delete
+     * cascade removes every connected edge whatever its kind, so it states none.
+     * {@link DeleteEdgeParams} and {@link HardDeleteEdgeParams} carry the same
+     * field with the same contract.
+     */
+    kind?: string;
+    /**
+     * The ENDPOINTS this write asserts the target row already carries, stated
+     * only by a write that actually checked them.
+     *
+     * Kind alone does not pin a row's identity. An edge's endpoints are immutable
+     * for a given row, but the ID is not: a concurrent `hardDelete` + recreate
+     * under the SAME kind with DIFFERENT endpoints satisfies a kind-only
+     * predicate, so an upsert that resolved this id BY endpoints could otherwise
+     * write to an edge pointing somewhere it never looked. Carrying them here
+     * closes that, on the same terms and in the same `WHERE` as `kind`.
+     *
+     * All four move together or not at all — they are one assertion. A plain
+     * `update` on a kind-scoped collection states none of them, because it
+     * resolved the edge by id and kind and made no claim about where it points;
+     * predicating on endpoints it never checked would refuse legitimate writes.
+     * The same MUST-apply contract as `kind` binds a backend that receives them.
+     */
+    fromKind?: string;
+    fromId?: string;
+    toKind?: string;
+    toId?: string;
     props: Readonly<Record<string, unknown>>;
+    /**
+     * Applied when resurrecting a tombstone, where it asserts a COMPLETE window:
+     * `validTo` is rewritten alongside it (omitted `validTo` reopens the window).
+     * Omitting `validFrom` on a resurrection leaves the stored window in place.
+     */
+    validFrom?: string | null;
     validTo?: string;
+    /**
+     * The effective `valid_from` this write asserts the target row already
+     * carries. Same three states, same NULL-safety, and the same MUST-apply
+     * contract as {@link UpdateNodeParams.expectedValidFrom}; stated by the same
+     * kind of caller, one whose verdict READ that bound.
+     *
+     * Separate from the immutable-identity components above because it is not
+     * immutable: a resurrection rewrites `valid_from`. It is asserted for the
+     * opposite reason — precisely because it can change, a decision computed from
+     * it must be fenced against it having changed.
+     */
+    expectedValidFrom?: string | null;
     clearDeleted?: boolean;
 }>;
 /**
@@ -2338,6 +2814,8 @@ type UpdateEdgeParams = Readonly<{
 type DeleteEdgeParams = Readonly<{
     graphId: string;
     id: string;
+    /** See {@link UpdateEdgeParams.kind}. */
+    kind?: string;
 }>;
 /**
  * Parameters for hard deleting a node (permanent removal).
@@ -2353,6 +2831,8 @@ type HardDeleteNodeParams = Readonly<{
 type HardDeleteEdgeParams = Readonly<{
     graphId: string;
     id: string;
+    /** See {@link UpdateEdgeParams.kind}. */
+    kind?: string;
 }>;
 /** Parameters for a batched edge delete (soft or hard). */
 type DeleteEdgesBatchParams = Readonly<{
@@ -2471,9 +2951,19 @@ type VectorSearchParams = Readonly<{
      * trades latency for recall. The floor for the over-fetch to fill its
      * candidate set is `efSearch >= limit`; ~2–4× is the high-recall
      * target. Applied transaction-locally (`SET LOCAL`) on the Postgres
-     * HNSW path only. No-op on backends without an HNSW frontier knob
-     * (sqlite-vec) and ignored — with a one-time warning — on Postgres
-     * backends without transactions (e.g. `drizzle-orm/neon-http`).
+     * HNSW path only.
+     *
+     * APPLIED OR REFUSED, never ignored. Read
+     * `capabilities.vector.searchFrontierTuning` to know which you get:
+     *
+     * - `tunable: false` (sqlite-vec, libSQL DiskANN — no per-search frontier
+     *   knob exists): `UnsupportedBackendCapabilityError`.
+     * - a slot whose index type is not the tunable one (pgvector IVFFlat or
+     *   brute-force): `ConfigurationError`.
+     * - `requiresTransactionScope` on a backend reporting
+     *   `transactions: false` (for example `drizzle-orm/neon-http`):
+     *   `UnsupportedBackendCapabilityError`, because `SET LOCAL` has no frame
+     *   to be local to.
      */
     efSearch?: number;
 }>;
@@ -2888,13 +3378,11 @@ type ContributionDiagnosticState = "orphaned-marker" | "missing-marker" | "faile
  * storage, so applying it to a `missing-marker` — where the table is
  * intact and only the bookkeeping is wrong — discards every embedding
  * to fix a marker, and without an `embed` callback it leaves the field
- * empty. For `missing-marker` and `failed-materialization` prefer
- * `ensureVectorSlotContribution(slot, { force: true })`, whose DDL is
- * `CREATE ... IF NOT EXISTS` and never drops. Note also that
- * `ensureRuntimeContributions` does NOT repair a fulltext
- * `orphaned-marker`: it short-circuits on the marker, which still
- * reads as initialized. See the per-state repair tables in the
- * troubleshooting guide.
+ * empty. Prefer `store.repairContributions()` for `missing-marker` and
+ * `failed-materialization`; it resolves the current strategy declarations
+ * internally and keeps the normal signature-drift guard enabled. It reports
+ * `stale` and `orphaned-marker` as `requires-rebuild`. See the per-state
+ * repair table in the troubleshooting guide.
  */
 type ContributionDiagnostic = Readonly<{
     /** Producing strategy, e.g. `"fts5"` / `"tsvector"` / `"pgvector"`. */
@@ -2924,6 +3412,146 @@ type ContributionDiagnostic = Readonly<{
      */
     lastError?: string;
 }>;
+/**
+ * Outcome of one contribution considered by
+ * {@link GraphBackend.repairContributions}.
+ *
+ * Repair targets are always resolved from the backend's current strategy
+ * declarations. The diagnostic is returned for operator context only; callers
+ * never pass diagnostics or physical DDL back into the repair API.
+ */
+type ContributionRepairEntry = Readonly<{
+    diagnostic: ContributionDiagnostic;
+    status: "repaired";
+}> | Readonly<{
+    diagnostic: ContributionDiagnostic;
+    status: "requires-rebuild";
+}> | Readonly<{
+    diagnostic: ContributionDiagnostic;
+    status: "failed";
+    error: string;
+}>;
+/** Result of a contribution repair pass followed by a fresh verification. */
+type ContributionRepairResult = Readonly<{
+    results: readonly ContributionRepairEntry[];
+    remaining: readonly ContributionDiagnostic[];
+}>;
+/**
+ * The search projection a probe entry summarizes. Deliberately the
+ * logical *class* rather than one physical table: a caller asking "is
+ * search ready?" is deciding whether to issue a fulltext or a vector
+ * query, and a per-`(kind, field)` breakdown of pgvector tables answers
+ * a question they did not ask. The physical detail an operator needs to
+ * act is one `verifyContributions()` call away, and
+ * {@link ContributionProbeEntry.detail} names the affected slots.
+ */
+type ContributionProbeContribution = "fulltext" | "vector";
+/**
+ * Readiness of one search projection.
+ *
+ * - `ready` — every contribution backing this projection is attested by
+ *   its durable marker and present in the catalog. Not a promise about
+ *   future coherence: a write that lands after the probe returns is
+ *   outside what any assessment can cover.
+ * - `degraded` — at least one contribution is unusable. Queries against
+ *   this projection will be refused (`StoreNotInitializedError`) or will
+ *   read incomplete storage.
+ *   {@link ContributionProbeEntry.detail} says which and why.
+ * - `building` — **reserved.** No shipped path publishes it. Recording
+ *   an in-flight marker would need a fifth
+ *   {@link ContributionDiagnosticState} and would widen the hot-path
+ *   gate's verdict set; the destructive rebuild instead runs inside one
+ *   transaction, so a concurrent probe observes the state before or
+ *   after it and never a partial one. Reserved rather than removed so a
+ *   future streaming/async materializer can populate it without a
+ *   breaking change — treat it as "not `ready`" today.
+ */
+type ContributionProbeState = "ready" | "degraded" | "building";
+/**
+ * One search projection's readiness, from
+ * {@link GraphBackend.probeContributions}.
+ */
+type ContributionProbeEntry = Readonly<{
+    contribution: ContributionProbeContribution;
+    state: ContributionProbeState;
+    /**
+     * Operator-facing summary of why the projection is not `ready` —
+     * e.g. `"fulltext table \"typegraph_node_fulltext\" is missing
+     * (orphaned-marker)"`. Absent on a `ready` entry.
+     *
+     * Human-readable and not a stable format: route on `state`, and call
+     * `store.verifyContributions()` for the structured per-table
+     * diagnostics this string is derived from.
+     */
+    detail?: string;
+}>;
+/**
+ * Result of {@link GraphBackend.probeContributions}.
+ *
+ * A projection with no declared contributions is omitted rather than
+ * reported `ready`, so an empty `entries` array means "nothing to
+ * assess" — a graph with no `searchable()` or `embedding()` fields, or a
+ * backend with no contribution support — never "assessed and healthy".
+ */
+type ContributionProbeResult = Readonly<{
+    /**
+     * The durable graph revision the assessment was taken at, so a caller
+     * can place this probe in the graph's committed history.
+     *
+     * Graph-global, like the clock it reads: it advances on every committed
+     * capture from any writer, so an advance between two probes means
+     * "something committed in between", never "the write this caller just
+     * made landed". Confirm a specific write by observing the write itself.
+     *
+     * Absent unless the Store is revision-tracked (`revisionTracking:
+     * true` or `history: true`) — the same condition under which
+     * `store.revisionNow()` returns a value. This is the one honest shape:
+     * a store with no durable revision clock has no revision to stamp, and
+     * substituting a wall-clock timestamp or the schema version would be a
+     * materially weaker guarantee wearing the name of a stronger one. The
+     * schema version in particular does not advance on data writes, so it
+     * could not order a probe against a caller's write at all.
+     */
+    graphRevision?: string;
+    entries: readonly ContributionProbeEntry[];
+}>;
+/**
+ * Which search projection {@link GraphBackend.rebuildContribution}
+ * targets. Scoped explicitly at the call site rather than inferred from
+ * a diagnostic: the operation destroys storage, so which storage is the
+ * caller's decision to state, not TypeGraph's to guess.
+ */
+type ContributionRebuildScope = ContributionProbeContribution;
+/**
+ * What a rebuild's `repopulate` callback reconstructed. Reported back so
+ * the rebuild result can distinguish "recreated empty storage" from
+ * "recreated and refilled", which is the difference between a finished
+ * repair and half of one.
+ */
+type ContributionRepopulationStats = Readonly<{
+    /** Nodes scanned. */
+    processed: number;
+    /** Content rows written. */
+    repopulated: number;
+    /** Nodes whose stored `props` could not be read as an object. */
+    skipped: number;
+}>;
+/** Outcome of one destructive contribution rebuild. */
+type ContributionRebuildResult = Readonly<{
+    /** Physical tables dropped and recreated, in the order rebuilt. */
+    rebuilt: readonly string[];
+    /** Nodes scanned while reconstructing content from stored rows. */
+    processed: number;
+    /** Content rows written into the recreated storage. */
+    repopulated: number;
+    /**
+     * Nodes whose stored `props` could not be read as an object, so no
+     * content row could be reconstructed for them. Non-zero means the
+     * rebuilt index is missing those nodes; the IDs come back from
+     * `store.search.rebuildFulltext()`, which reports them individually.
+     */
+    skipped: number;
+}>;
 /**
  * One row of the per-deployment `typegraph_kind_removals` table:
  * a graph-extension kind that has been removed from the schema and whose
@@ -2970,6 +3598,21 @@ type TransactionOptions = Readonly<{
      */
     accessMode?: "read_only" | "read_write";
 }>;
+/**
+ * The physical names of the four Operational Identity relations: the current
+ * assertion ledger, its recorded-time twin, and the two DERIVED relations
+ * (closure, separation) rebuilt from the ledger.
+ *
+ * Named once so the two ports that speak about them —
+ * {@link GraphBackend.ensureIdentityTables} and
+ * {@link GraphBackend.identityTableDdl} — cannot drift apart.
+ */
+type IdentityTableNames = Readonly<{
+    identityAssertions: string;
+    recordedIdentityAssertions: string;
+    identityClosure: string;
+    identitySeparation: string;
+}>;
 /**
  * The GraphBackend interface abstracts database operations.
  *
@@ -3011,6 +3654,7 @@ type GraphBackend = Readonly<{
     insertNodesBatch?: (this: void, params: readonly InsertNodeParams[]) => Promise<void>;
     insertNodesBatchReturning?: (this: void, params: readonly InsertNodeParams[]) => Promise<readonly NodeRow[]>;
     updateNode: (this: void, params: UpdateNodeParams) => Promise<NodeRow>;
+    updateNodeSet?: (this: void, params: UpdateNodeSetParams) => Promise<UpdateNodeSetResult>;
     deleteNode: (this: void, params: DeleteNodeParams) => Promise<void>;
     hardDeleteNode: (this: void, params: HardDeleteNodeParams) => Promise<void>;
     getNode: (this: void, graphId: string, kind: string, id: string) => Promise<NodeRow | undefined>;
@@ -3055,6 +3699,14 @@ type GraphBackend = Readonly<{
      * path is unaffected.
      */
     findEdgesByEndpointSet?: (this: void, params: FindEdgesByEndpointSetParams) => Promise<readonly EdgeRow[]>;
+    /**
+     * Reads several edge kinds from a heterogeneous set of endpoints without
+     * issuing one statement per licensed `(edge kind, endpoint kind)` pair.
+     *
+     * Optional for custom backends. Store-level heterogeneous bulk reads refuse
+     * when it is absent rather than hiding a per-kind/per-endpoint fallback.
+     */
+    findEdgesByHeterogeneousEndpointSet?: (this: void, params: FindEdgesByHeterogeneousEndpointSetParams) => Promise<readonly EdgeRow[]>;
     countEdgesByKind: (this: void, params: CountEdgesByKindParams) => Promise<number>;
     insertUnique: (this: void, params: InsertUniqueParams) => Promise<void>;
     /**
@@ -3065,6 +3717,12 @@ type GraphBackend = Readonly<{
      */
     insertUniqueBatch?: (this: void, entries: readonly InsertUniqueParams[]) => Promise<void>;
     deleteUnique: (this: void, params: DeleteUniqueParams) => Promise<void>;
+    /**
+     * Permanently removes every uniqueness sidecar owned by the specified
+     * concrete nodes. Optional capability used by set-based updates before they
+     * rebuild reservations from the returned node after-images.
+     */
+    hardDeleteUniquesByNodeIds?: (this: void, params: HardDeleteUniquesByNodeIdsParams) => Promise<void>;
     checkUnique: (this: void, params: CheckUniqueParams) => Promise<UniqueRow | undefined>;
     checkUniqueBatch?: (this: void, params: CheckUniqueBatchParams) => Promise<readonly UniqueRow[]>;
     getActiveSchema: (this: void, graphId: string) => Promise<SchemaVersionRow | undefined>;
@@ -3119,11 +3777,32 @@ type GraphBackend = Readonly<{
      * transaction-scoped backend. PostgreSQL locks the active schema row, so a
      * concurrent change either becomes visible at read committed or raises the
      * database's native serialization failure at stronger isolation.
+     *
+     * On rejection the thrown `StaleVersionError` reports the active
+     * version this transaction can observe after the conflict resolves, so
+     * `details.actual` names the version that won rather than the absence the
+     * blocked read momentarily saw.
      */
     lockSchemaVersionForWrite?: (this: void, params: Readonly<{
         graphId: string;
         expectedVersion: number;
     }>) => Promise<void>;
+    /**
+     * Internal schema-lifecycle seam for features whose data preflight must
+     * commit atomically with the schema CAS. The callback runs in the same
+     * write transaction after the schema write fence is acquired and before the
+     * version write; it receives no schema-version write methods, so callers
+     * cannot bypass the CAS.
+     *
+     * The preflight target is a {@link SchemaCommitPreflightBackend}: the
+     * transaction backend plus the schema-write DDL primitive, because a
+     * transition may have to CREATE the storage its own preflight then fills —
+     * and creating it outside this transaction would publish it empty whenever
+     * the commit is refused.
+     *
+     * @internal
+     */
+    commitSchemaVersionWithPreflight?: (this: void, params: CommitSchemaVersionParams, preflight: (target: SchemaCommitPreflightBackend) => Promise<void>) => Promise<SchemaVersionRow>;
     /**
      * Atomically flips the active schema pointer to an existing version,
      * with optimistic compare-and-swap on the currently active version.
@@ -3158,6 +3837,9 @@ type GraphBackend = Readonly<{
      */
     upsertEmbeddingBatch?: (this: void, params: UpsertEmbeddingBatchParams) => Promise<void>;
     deleteEmbedding?: (this: void, params: DeleteEmbeddingParams) => Promise<void>;
+    deleteEmbeddingBatch?: (this: void, params: Omit<DeleteEmbeddingParams, "nodeId"> & Readonly<{
+        nodeIds: readonly string[];
+    }>) => Promise<void>;
     /**
      * KNN search over one `(nodeKind, fieldPath)` slot. Top-k is computed
      * over CURRENT nodes only — non-tombstoned AND inside their validity
@@ -3229,6 +3911,54 @@ type GraphBackend = Readonly<{
      * without replaying all base-table DDL during a merge read.
      */
     ensureRevisionOriginsTable?: (this: void) => Promise<void>;
+    /**
+     * Idempotently ensure ONLY the three Operational Identity relations exist —
+     * the current-assertions table, the recorded-time assertions table, and the
+     * derived closure and separation tables — with their indexes and CHECK
+     * constraints (CREATE TABLE / CREATE INDEX IF NOT EXISTS).
+     *
+     * First enablement of identity on an existing populated deployment attaches
+     * via `createStore` / `createSqliteBackend` / `createPostgresBackend`, none
+     * of which run DDL, so the enablement preflight would otherwise
+     * SELECT/DELETE/INSERT tables that do not exist yet. The store calls this
+     * before the enablement locks and closure rebuild. Focused rather than
+     * `bootstrapTables` for the same concurrency rationale as
+     * {@link ensureRevisionOriginsTable}. Stores call it before opening the
+     * schema-commit transaction so DDL does not re-enter its per-graph lock.
+     * Returns the logical names that were absent before this call. Callers set
+     * `provisionMissing` only for safe first enablement; on an already-enabled
+     * graph, missing ledger tables are deliberately left absent so a failed open
+     * cannot make its next retry silently accept empty replacement storage.
+     *
+     * @internal
+     */
+    ensureIdentityTables?: (this: void, tableNames: IdentityTableNames, options: Readonly<{
+        provisionMissing: boolean;
+    }>) => Promise<readonly string[]>;
+    /**
+     * The idempotent CREATE statements for exactly the identity relations —
+     * the same DDL {@link ensureIdentityTables} issues, handed back as data
+     * instead of executed.
+     *
+     * Pure and synchronous: it executes nothing and probes no catalog, so it is
+     * safe to call from inside an already-open transaction, where invoking a
+     * top-level backend method would re-enter the backend's serialized statement
+     * queue and deadlock. That is the whole point. Provisioning a missing DERIVED
+     * relation (closure, separation) on an already-enabled graph has to CREATE it
+     * and FILL it in one transaction, because a created-but-empty derived
+     * relation is readable and answers every question with "nothing" — for the
+     * separation relation, "nothing" means "not separated", which is exactly the
+     * answer that lets a contradictory merge commit.
+     *
+     * A backend that omits this cannot offer that atomicity. Callers do not fall
+     * back: when a fill is owed, the upgrade is REFUSED with the typed
+     * `IDENTITY_UPGRADE_REQUIRES_ATOMIC_DDL` error naming this port — creating
+     * and filling back-to-back would publish the readable-empty state the
+     * paragraph above forbids.
+     *
+     * @internal
+     */
+    identityTableDdl?: (this: void, tableNames: IdentityTableNames) => readonly string[];
     /**
      * Look up a recorded materialization for a declared index by its
      * physical SQL index name. Returns `undefined` if no row exists.
@@ -3295,11 +4025,11 @@ type GraphBackend = Readonly<{
     assertRuntimeContributionsInitialized?: (this: void, graphId: string) => Promise<void>;
     /**
      * Bootstraps the per-deployment `typegraph_kind_removals` table so
-     * `store.removeKinds()` and `store.materializeRemovals()` can persist
-     * removal status. Mirrors the focused-bootstrap rationale documented
-     * on `ensureIndexMaterializationsTable` — the full `bootstrapTables`
-     * touches every base table and risks Postgres SHARE-lock deadlock
-     * under concurrent replica startup.
+     * `store.evolve()` can check pending removals and the removal verbs can
+     * persist and materialize removal status. Mirrors the focused-bootstrap
+     * rationale documented on `ensureIndexMaterializationsTable` — the full
+     * `bootstrapTables` touches every base table and risks Postgres SHARE-lock
+     * deadlock under concurrent replica startup.
      */
     ensureKindRemovalsTable?: (this: void) => Promise<void>;
     /**
@@ -3430,6 +4160,73 @@ type GraphBackend = Readonly<{
      * Present only on backends that can probe their own catalog.
      */
     verifyContributions?: (this: void, graphId: string, vectorSlots: readonly VectorSlot[]) => Promise<readonly ContributionDiagnostic[]>;
+    /**
+     * Re-audit current contribution declarations and non-destructively repair
+     * `missing-marker` and `failed-materialization` findings. The backend must
+     * resolve every target itself; it must not accept caller-provided physical
+     * identities or DDL. `stale` and `orphaned-marker` findings are returned as
+     * `requires-rebuild` because repairing either can require destructive data
+     * reconstruction.
+     *
+     * Present only on backends that can both probe their catalog and run the
+     * strategy-owned contribution DDL.
+     */
+    repairContributions?: (this: void, graphId: string, vectorSlots: readonly VectorSlot[]) => Promise<ContributionRepairResult>;
+    /**
+     * Read-only readiness probe: the same marker-versus-catalog audit
+     * `verifyContributions` performs, projected onto one entry per search
+     * projection. Shares that method's detection logic exactly — a second
+     * implementation would be free to disagree with the one the hot-path
+     * gate actually consults, and a health check that disagrees with the
+     * gate is worse than none.
+     *
+     * Writes nothing: no DDL, no marker writes, no effect on the
+     * per-instance caches the hot path relies on. Safe on a read path, on
+     * a replica, and under a least-privilege role.
+     *
+     * Present only on backends that can probe their catalog; a backend
+     * that provisions contributions without this method declares the gap
+     * as `capabilities.contributions.probe === false`.
+     */
+    probeContributions?: (this: void, graphId: string, vectorSlots: readonly VectorSlot[]) => Promise<readonly ContributionProbeEntry[]>;
+    /**
+     * Destructively rebuild one search projection for one graph: clear that
+     * graph's rows from the projection's storage, ensure the storage matches
+     * the current `createDdl`, reconstruct the graph's content, and stamp the
+     * durable marker at the current signature.
+     *
+     * This is the repair `repairContributions` deliberately refuses to
+     * perform, and it must never be reachable from it. A `stale`
+     * contribution's table exists at the *old* physical shape, so the
+     * idempotent `CREATE ... IF NOT EXISTS` in the ordinary ensure path
+     * no-ops; re-stamping the marker there would leave it blessing a table
+     * whose shape is wrong, which is exactly what the drift guard exists
+     * to prevent. Only a drop makes the recreate meaningful, and destroying
+     * content is a decision the caller states rather than one a flag named
+     * `force` implies.
+     *
+     * The fulltext projection's storage is one physical table shared by every
+     * graph in the database, while this call is fenced per graph.
+     * Implementations must therefore scope the teardown to `graphId` and may
+     * drop the storage only when doing so destroys no other graph's rows;
+     * when the recorded shape is stale and the drop that would repair it is
+     * not available, they refuse (`shared-storage-in-use`) rather than
+     * re-stamp a shape nothing verified.
+     *
+     * Runs the whole sequence inside one transaction under the same
+     * per-graph fence as a schema commit, so an interrupted rebuild leaves
+     * the contribution exactly as it was rather than attested-but-empty.
+     *
+     * `repopulate` receives that transaction and reconstructs content from
+     * rows TypeGraph already stores. The inversion exists because deciding
+     * *what* content a node contributes needs the schema registry, which
+     * is a Store-layer concern the backend must not reach into.
+     *
+     * @param scope which projection to rebuild. Implementations must
+     *   refuse `"vector"`: embeddings live only in the storage this would
+     *   drop, so there is nothing to reconstruct them from.
+     */
+    rebuildContribution?: (this: void, graphId: string, scope: ContributionRebuildScope, repopulate: (target: TransactionBackend) => Promise<ContributionRepopulationStats>) => Promise<ContributionRebuildResult>;
     /**
      * Bootstraps the fulltext storage table the active `FulltextStrategy`
      * owns. Same focused-bootstrap rationale as the other `ensure*Table`
@@ -3564,16 +4361,16 @@ type AdapterBackend<TNativeTransaction> = GraphBackend & Readonly<{
 }>;
 type BackendIdentity = Pick<GraphBackend, "dialect" | "capabilities" | "tableNames" | "fulltextStrategy" | "vectorStrategy">;
 type NodeEntityReadBackend = Pick<GraphBackend, "getNode" | "getNodes" | "findNodesByKind" | "countNodesByKind">;
-type NodeEntityWriteBackend = Pick<GraphBackend, "insertNode" | "insertNodeNoReturn" | "insertNodesBatch" | "insertNodesBatchReturning" | "updateNode" | "deleteNode" | "hardDeleteNode">;
-type EdgeEntityReadBackend = Pick<GraphBackend, "getEdge" | "getEdges" | "countEdgesFrom" | "edgeExistsBetween" | "findEdgesConnectedTo" | "findEdgesByKind" | "findEdgesByEndpointSet" | "countEdgesByKind">;
+type NodeEntityWriteBackend = Pick<GraphBackend, "insertNode" | "insertNodeNoReturn" | "insertNodesBatch" | "insertNodesBatchReturning" | "updateNode" | "updateNodeSet" | "deleteNode" | "hardDeleteNode">;
+type EdgeEntityReadBackend = Pick<GraphBackend, "getEdge" | "getEdges" | "countEdgesFrom" | "edgeExistsBetween" | "findEdgesConnectedTo" | "findEdgesByKind" | "findEdgesByEndpointSet" | "findEdgesByHeterogeneousEndpointSet" | "countEdgesByKind">;
 type EdgeEntityWriteBackend = Pick<GraphBackend, "insertEdge" | "insertEdgeNoReturn" | "insertEdgesBatch" | "insertEdgesBatchReturning" | "updateEdge" | "deleteEdge" | "deleteEdgesBatch" | "hardDeleteEdge" | "hardDeleteEdgesBatch">;
 type GraphEntityReadBackend = NodeEntityReadBackend & EdgeEntityReadBackend;
 type GraphEntityWriteBackend = NodeEntityWriteBackend & EdgeEntityWriteBackend;
-type UniqueConstraintBackend = Pick<GraphBackend, "insertUnique" | "insertUniqueBatch" | "deleteUnique" | "checkUnique" | "checkUniqueBatch">;
+type UniqueConstraintBackend = Pick<GraphBackend, "insertUnique" | "insertUniqueBatch" | "deleteUnique" | "hardDeleteUniquesByNodeIds" | "checkUnique" | "checkUniqueBatch">;
 type SchemaReadBackend = Pick<GraphBackend, "getActiveSchema" | "getSchemaVersion">;
 type SchemaCommitBackend = Pick<GraphBackend, "commitSchemaVersion" | "commitSchemaVersionIfKindsEmpty" | "setActiveVersion">;
 type SchemaWriteFenceBackend = Pick<GraphBackend, "lockSchemaVersionForWrite">;
-type VectorOperationBackend = Pick<GraphBackend, "upsertEmbedding" | "upsertEmbeddingBatch" | "deleteEmbedding" | "vectorSearch" | "createVectorIndex" | "dropVectorIndex">;
+type VectorOperationBackend = Pick<GraphBackend, "upsertEmbedding" | "upsertEmbeddingBatch" | "deleteEmbedding" | "deleteEmbeddingBatch" | "vectorSearch" | "createVectorIndex" | "dropVectorIndex">;
 type FulltextOperationBackend = Pick<GraphBackend, "upsertFulltext" | "deleteFulltext" | "upsertFulltextBatch" | "deleteFulltextBatch" | "fulltextSearch">;
 type IndexMaterializationBackend = Pick<GraphBackend, "ensureIndexMaterializationsTable" | "getIndexMaterialization" | "getIndexMaterializations" | "recordIndexMaterialization">;
 type ContributionMaterializationBackend = Pick<GraphBackend, "ensureContributionMaterializationsTable" | "getContributionMaterialization" | "recordContributionMaterialization" | "assertRuntimeContributionsInitialized" | "ensureRuntimeContributions" | "ensureFulltextTable">;
@@ -3605,6 +4402,23 @@ type TransactionReadBackend = Readonly<BackendIdentity & GraphEntityReadBackend
  * lifecycle owner rather than an already-open transaction.
  */
 type TransactionBackend = Readonly<BackendIdentity & GraphEntityReadBackend & GraphEntityWriteBackend & UniqueConstraintBackend & SchemaReadBackend & Pick<GraphBackend, "lockSchemaVersionForWrite"> & VectorOperationBackend & FulltextOperationBackend & IndexMaterializationBackend & ContributionMaterializationBackend & RemovalMaterializationBackend & GraphLifecycleBackend & QueryExecutionBackend & RawQueryExecutionBackend & RawStatementExecutionBackend>;
+/**
+ * The target a schema-commit preflight runs against: a transaction backend
+ * that MAY also carry the schema-write DDL primitive.
+ *
+ * Optional, deliberately. Both bundled backends pass the same
+ * {@link SchemaWriteTransactionBackend} their `schemaWriteTransaction` exposes,
+ * so DDL is available there; a custom backend may implement
+ * {@link GraphBackend.commitSchemaVersionWithPreflight} over a transaction that
+ * cannot run DDL. Declaring the port as present-or-absent lets a preflight that
+ * needs it refuse with a typed error naming the capability, instead of calling
+ * `undefined` — or, far worse, skipping the DDL and continuing.
+ *
+ * @internal
+ */
+type SchemaCommitPreflightBackend = TransactionBackend & Readonly<{
+    executeSchemaDdl?: (this: void, ddl: string) => Promise<void>;
+}>;
 /**
  * Parameters for inserting a unique constraint entry.
  */
@@ -3625,6 +4439,12 @@ type DeleteUniqueParams = Readonly<{
     constraintName: string;
     key: string;
 }>;
+/** Parameters for permanently clearing uniqueness sidecars by node identity. */
+type HardDeleteUniquesByNodeIdsParams = Readonly<{
+    graphId: string;
+    concreteKind: string;
+    nodeIds: readonly string[];
+}>;
 /**
  * Parameters for checking a unique constraint.
  */
@@ -3906,6 +4726,29 @@ type FindEdgesByEndpointSetParams = Readonly<{
     /** Timestamp for "current" and "asOf" temporal modes. */
     asOf?: string;
 }>;
+/**
+ * Parameters for reading several edge kinds from several endpoint kinds.
+ *
+ * The endpoint pairs are joined as a relation, so round trips are independent
+ * of the number of licensed edge-kind/endpoint-kind combinations. Large source
+ * sets may still be split to respect the backend's bind-parameter budget.
+ */
+type FindEdgesByHeterogeneousEndpointSetParams = Readonly<{
+    graphId: string;
+    side: EdgeEndpointSide;
+    endpoints: readonly Readonly<{
+        kind: string;
+        id: string;
+    }>[];
+    edgeKinds: readonly string[];
+    limitPerEndpoint?: number;
+    /** If true, exclude deleted edges. Default true. */
+    excludeDeleted?: boolean;
+    /** Temporal mode for filtering by validity period. */
+    temporalMode?: TemporalMode;
+    /** Timestamp for "current" and "asOf" temporal modes. */
+    asOf?: string;
+}>;
 /**
  * Parameters for counting edges by kind.
  */
@@ -4283,6 +5126,8 @@ type Traversal = Readonly<{
     joinEdgeField: "from_id" | "to_id";
     /** If true, use LEFT JOIN instead of INNER JOIN (optional match) */
     optional: boolean;
+    /** Expand this hop through coordinate-visible Operational Identity members. */
+    includeIdentityMembers?: boolean;
     /** Variable-length traversal configuration (for recursive CTEs) */
     variableLength?: VariableLengthSpec;
 }>;
@@ -4756,4 +5601,4 @@ type RelationalIndexDeclaration = NodeIndexDeclaration | EdgeIndexDeclaration;
 type IndexDeclaration = RelationalIndexDeclaration | VectorIndexDeclaration;
 type SystemColumnName = "graph_id" | "kind" | "id" | "from_kind" | "from_id" | "to_kind" | "to_id" | "deleted_at" | "valid_from" | "valid_to" | "created_at" | "updated_at" | "version";
 
-export { type InferenceType as $, type AdapterBackend as A, type BackendCapabilities as B, type ContributionDiagnostic as C, type DeleteBehavior as D, type EdgeRegistration as E, type FulltextStrategy as F, type GraphExtension as G, type SerializedEdgeDef as H, type IndexDeclaration as I, type JsonPointer as J, type KindEntity as K, type IndexEntity as L, type SerializedMetaEdge as M, type NodeRegistration as N, type OntologyRelation as O, type SerializedOntologyRelation as P, type QueryAst as Q, type RelationalIndexDeclaration as R, type SqlDialect as S, type TemporalMode as T, type SerializedClosures as U, type VectorStrategy as V, type SchemaHash as W, type NullCheckOp as X, type JsonSchema as Y, type SerializedOntology as Z, type SerializedUniqueConstraint as _, type ContributionDiagnosticState as a, type ParameterRef as a$, type EdgeType as a0, type AggregateExpr as a1, type FieldRef as a2, type ComparisonOp as a3, type AggregateComparisonPredicate as a4, type TraversalDirection as a5, type AdapterBackendTransactions as a6, type BackendIdentity as a7, type BackendLifecycle as a8, type BackendMaintenance as a9, type FulltextSearchParams as aA, type FulltextSearchResult as aB, type GraphAnalyticsCapabilities as aC, type GraphEntityReadBackend as aD, type GraphEntityWriteBackend as aE, type GraphExtensionVersion as aF, type GraphLifecycleBackend as aG, type HybridFusionOptions as aH, type IndexMaterializationBackend as aI, type IntentSql as aJ, type JsonPointerFor as aK, type JsonPointerInput as aL, type JsonPointerSegment as aM, type JsonPointerSegments as aN, type JsonPointerSegmentsFor as aO, type JsonValue as aP, type KindAnnotations as aQ, LEGACY_GRAPH_EXTENSION_VERSION as aR, type LockSchemaVersionForWriteParams as aS, MAX_JSON_POINTER_DEPTH as aT, type MetaEdge as aU, type MetaEdgeProperties as aV, type NodeEntityReadBackend as aW, type NodeEntityWriteBackend as aX, type NodeId as aY, type NodeProps as aZ, type OrderSpec as a_, type BackendTransactions as aa, CURRENT_GRAPH_EXTENSION_VERSION as ab, type Cardinality as ac, type Collation as ad, type CommitSchemaVersionExpected as ae, type CommitSchemaVersionIfKindsEmptyResult as af, type CommitSchemaVersionParams as ag, type CompiledRowsSql as ah, type CompiledSelectSql as ai, type CompiledStatementSql as aj, type ContributionMaterializationBackend as ak, DEFAULT_SQL_SCHEMA as al, type DeleteFulltextBatchParams as am, type EdgeEntityReadBackend as an, type EdgeEntityWriteBackend as ao, type EdgeId as ap, type EdgeProps as aq, type EdgeTypeWithEndpoints as ar, type EndpointExistence as as, type ExternalRecordedReadSource as at, type FilteredApproximateSearch as au, type FilteredApproximateSearchMode as av, type FulltextBatchRow as aw, type FulltextCapabilities as ax, type FulltextOperationBackend as ay, type FulltextQueryMode as az, type NodeType as b, sql as b$, Placeholder as b0, type PopulatedSchemaKind as b1, type QueryExecutionBackend as b2, type RawQueryExecutionBackend as b3, type RawStatementExecutionBackend as b4, type RecordedRelationOptions as b5, type RemovalMaterializationBackend as b6, type RenderedSql as b7, type ResolveJsonPointer as b8, type ResolveJsonPointerSegments as b9, type UniqueConstraint as bA, type UniqueConstraintBackend as bB, type UniquenessScope as bC, type UpsertFulltextBatchParams as bD, type VectorCapabilities as bE, type VectorOperationBackend as bF, asEdgeId as bG, asNodeId as bH, buildVectorCapabilities as bI, createSqlSchema as bJ, fts5Strategy as bK, isEdgeType as bL, isEdgeTypeWithEndpoints as bM, isMetaEdge as bN, isNodeType as bO, isSqlFragment as bP, joinJsonPointers as bQ, jsonPointer as bR, normalizeJsonPointer as bS, parseJsonPointer as bT, recordedRelation as bU, renderPostgres as bV, renderSql as bW, renderSqlInline as bX, renderSqlite as bY, rowPropsToJsonText as bZ, rowPropsToObject as b_, type ResolvedSqlTableNames as ba, type RowProps as bb, type SchemaCommitBackend as bc, type SchemaKindEmptinessProbe as bd, type SchemaReadBackend as be, type SchemaWriteFenceBackend as bf, type SetActiveVersionParams as bg, type SortDirection as bh, type SqlChunk as bi, type SqlFragment as bj, type SqlIdentifierChunk as bk, type SqlIntent as bl, type SqlParameterChunk as bm, type SqlPlaceholderChunk as bn, SqlSchema as bo, type SqlTableNames as bp, type SqlTag as bq, type SqlTextChunk as br, type StrategyTableContribution as bs, type TableContribution as bt, type TransactionBackend as bu, type TransactionOptions as bv, type TransactionReadBackend as bw, type TraversalExpansion as bx, type TrustedImportOptions as by, type TrustedImportSession as bz, type AnyEdgeType as c, type ExtensionPropertyType as c$, tsvectorStrategy as c0, type ExtensionNodeDef as c1, type ExtensionEdgeDef as c2, type ExtensionOntologyRelation as c3, type ExtensionIndex as c4, type ValueType as c5, type PredicateExpression as c6, type VectorMetricType as c7, type Traversal as c8, type NodePredicate as c9, D1_MAX_BIND_PARAMETERS as cA, DURABLE_OBJECT_MAX_BIND_PARAMETERS as cB, type DeleteEdgeParams as cC, type DeleteEdgesBatchParams as cD, type DeleteEmbeddingParams as cE, type DeleteFulltextParams as cF, type DeleteNodeParams as cG, type DeleteUniqueParams as cH, type DialectAdapter as cI, type DialectCapabilities as cJ, type DialectRecursiveQueryStrategy as cK, type DialectStandardQueryStrategy as cL, type DialectVectorPredicateStrategy as cM, type DropVectorIndexParams as cN, type EdgeExistsBetweenParams as cO, type ExtensionArrayItemType as cP, type ExtensionArrayProperty as cQ, type ExtensionBooleanProperty as cR, type ExtensionEdgeIndex as cS, type ExtensionEmbeddingModifier as cT, type ExtensionEnumProperty as cU, type ExtensionIndexWhere as cV, type ExtensionNodeIndex as cW, type ExtensionNumberProperty as cX, type ExtensionObjectFieldProperty as cY, type ExtensionObjectProperty as cZ, type ExtensionPropertyModifiers as c_, type ProjectedField as ca, type AggregateOrderSpec as cb, type GroupBySpec as cc, type RecursiveCyclePolicy as cd, type NodeRow as ce, type EdgeRow as cf, type VectorSlotMap as cg, type RecordedReadBinding as ch, type SelectiveField as ci, type ComposableQuery as cj, type SetOperationType as ck, type SetOperation as cl, type VectorMetric as cm, ALL_FULLTEXT_MODES as cn, ALL_META_EDGE_NAMES as co, BASE_CONTRIBUTION_OWNER as cp, type CheckUniqueBatchParams as cq, type CheckUniqueParams as cr, type ClaimIndexMaterializationParams as cs, type CompiledTemporaryStatementSql as ct, type ContributionMaterializationIdentity as cu, type ContributionMaterializationRow as cv, type CountEdgesByKindParams as cw, type CountEdgesFromParams as cx, type CountNodesByKindParams as cy, type CreateVectorIndexParams as cz, type GraphDefaults as d, GRAPH_EXTENSION_TOP_LEVEL_KEYS as d$, type ExtensionSearchableModifier as d0, type ExtensionStringProperty as d1, type ExtensionUniqueConstraint as d2, type ExtensionUniqueWhere as d3, FULLTEXT_CONTRIBUTION_NAME as d4, type FindEdgesByKindParams as d5, type FindEdgesConnectedToParams as d6, type FindNodesByKindParams as d7, type GraphReadBackend as d8, type HardDeleteEdgeParams as d9, SQLITE_MAX_BIND_PARAMETERS as dA, type SqlCompilationBackend as dB, type TombstonedNodeRow as dC, type UniqueRow as dD, type UpdateEdgeParams as dE, type UpdateNodeParams as dF, type UpsertEmbeddingBatchParams as dG, type UpsertEmbeddingBatchRow as dH, type UpsertEmbeddingParams as dI, type UpsertFulltextParams as dJ, VECTOR_CONTRIBUTION_PREFIX as dK, type VectorIndexType as dL, type VectorSearchParams as dM, type VectorSearchResult as dN, assertFiniteEmbedding as dO, assertVectorMinScore as dP, assertVectorSearchLimit as dQ, buildFulltextCapabilities as dR, isLiveNodeRow as dS, isSqlPlaceholder as dT, isTombstonedNodeRow as dU, normalizeGraphAnalyticsCapabilities as dV, quoteIdentifier as dW, shortHash as dX, vectorMinScoreCondition as dY, vectorPhysicalName as dZ, vectorScoreExpression as d_, type HardDeleteNodeParams as da, type HybridSearchParams as db, type HybridSearchRow as dc, type InListParameterOptions as dd, type IndexDeclarationBase as de, type IndexMaterializationRow as df, type IndexWhereLiteral as dg, type IndexWhereOp as dh, type IndexWhereOperand as di, type InsertEdgeParams as dj, type InsertNodeParams as dk, type InsertSchemaParams as dl, type InsertUniqueParams as dm, type KindRemovalRow as dn, type LiveNodeRow as dp, MODERN_SQLITE_MAX_BIND_PARAMETERS as dq, type MetaEdgeName as dr, POSTGRES_CAPABILITIES as ds, POSTGRES_MAX_BIND_PARAMETERS as dt, type RecordContributionMaterializationParams as du, type RecordIndexMaterializationParams as dv, type RecordKindRemovalParams as dw, type RelationalIndexMethod as dx, type ReleaseIndexMaterializationClaimParams as dy, SQLITE_CAPABILITIES as dz, type EdgeIndexDeclaration as e, type GraphExtensionTopLevelKey as e0, type NodeIndexDeclaration as f, type EdgeIndexConfig as g, type EdgeIndexDirection as h, type EdgeIndexWhereBuilder as i, type IndexOrigin as j, type IndexScope as k, type IndexWhereExpression as l, type IndexWhereFieldBuilder as m, type IndexWhereInput as n, type NodeIndexConfig as o, type NodeIndexWhereBuilder as p, type SystemColumnName as q, type VectorIndexDeclaration as r, type VectorIndexImplementation as s, type VectorIndexMetric as t, type VectorIndexParams as u, type VectorSlot as v, type SchemaVersionRow as w, type GraphBackend as x, type SerializedSchema as y, type SerializedNodeDef as z };
+export { type EdgeId as $, type AdapterBackend as A, type BackendCapabilities as B, type ContributionDiagnostic as C, type SerializedNodeDef as D, type EdgeIndexDeclaration as E, type FulltextStrategy as F, type GraphIdentityConfig as G, type SerializedEdgeDef as H, type IndexDeclaration as I, type JsonPointer as J, type KindEntity as K, type IndexEntity as L, type SerializedMetaEdge as M, type NodeIndexDeclaration as N, type SerializedOntologyRelation as O, type SerializedClosures as P, type QueryAst as Q, type RelationalIndexDeclaration as R, type SqlDialect as S, type TemporalMode as T, type SchemaHash as U, type VectorStrategy as V, type NullCheckOp as W, type JsonSchema as X, type SerializedOntology as Y, type SerializedUniqueConstraint as Z, type NodeId as _, type ContributionDiagnosticState as a, type GetEdgeType as a$, type JsonValue as a0, type NodeKinds as a1, type GetNodeType as a2, type KindAnnotations as a3, type MetaEdge as a4, type EdgeType as a5, type DeleteBehavior as a6, type GraphExtensionVersion as a7, type ExtensionNodeDef as a8, type ExtensionEdgeDef as a9, type ContributionMaterializationBackend as aA, type ContributionProbeContribution as aB, type ContributionProbeEntry as aC, type ContributionProbeResult as aD, type ContributionProbeState as aE, type ContributionRebuildResult as aF, type ContributionRebuildScope as aG, type ContributionRepopulationStats as aH, DEFAULT_SQL_SCHEMA as aI, type DeleteFulltextBatchParams as aJ, type EdgeEntityReadBackend as aK, type EdgeEntityWriteBackend as aL, type EdgeKinds as aM, type EdgeProps as aN, type EdgeRegistration as aO, type EdgeTypeWithEndpoints as aP, type EndpointExistence as aQ, type ExternalRecordedReadSource as aR, type FilteredApproximateSearch as aS, type FilteredApproximateSearchMode as aT, type FindEdgesByHeterogeneousEndpointSetParams as aU, type FulltextBatchRow as aV, type FulltextCapabilities as aW, type FulltextOperationBackend as aX, type FulltextQueryMode as aY, type FulltextSearchParams as aZ, type FulltextSearchResult as a_, type ExtensionOntologyRelation as aa, type ExtensionIndex as ab, type AggregateExpr as ac, type FieldRef as ad, type ComparisonOp as ae, type AggregateComparisonPredicate as af, type TraversalDirection as ag, type OntologyRelation as ah, type InferenceType as ai, type AdapterBackendTransactions as aj, type AllEdgeTypes as ak, type AllNodeTypes as al, type BackendIdentity as am, type BackendLifecycle as an, type BackendMaintenance as ao, type BackendTransactions as ap, CURRENT_GRAPH_EXTENSION_VERSION as aq, type Cardinality as ar, type Collation as as, type CommitSchemaVersionExpected as at, type CommitSchemaVersionIfKindsEmptyResult as au, type CommitSchemaVersionParams as av, type CompiledRowsSql as aw, type CompiledSelectSql as ax, type CompiledStatementSql as ay, type ContributionCapabilities as az, type ContributionRepairEntry as b, type UpdateNodeSetParams as b$, type GraphAnalyticsCapabilities as b0, type GraphDefaults as b1, type GraphEntityReadBackend as b2, type GraphEntityWriteBackend as b3, type GraphExtension as b4, type GraphLifecycleBackend as b5, type HardDeleteUniquesByNodeIdsParams as b6, type HybridFusionOptions as b7, type IndexMaterializationBackend as b8, type IntentSql as b9, type RowProps as bA, type SchemaCommitBackend as bB, type SchemaKindEmptinessProbe as bC, type SchemaReadBackend as bD, type SchemaWriteFenceBackend as bE, type SetActiveVersionParams as bF, type SortDirection as bG, type SqlChunk as bH, type SqlFragment as bI, type SqlIdentifierChunk as bJ, type SqlIntent as bK, type SqlParameterChunk as bL, type SqlPlaceholderChunk as bM, type SqlTableNames as bN, type SqlTag as bO, type SqlTextChunk as bP, type StrategyTableContribution as bQ, type TableContribution as bR, type TransactionBackend as bS, type TransactionOptions as bT, type TransactionReadBackend as bU, type TraversalExpansion as bV, type TrustedImportOptions as bW, type TrustedImportSession as bX, type UniqueConstraint as bY, type UniqueConstraintBackend as bZ, type UniquenessScope as b_, type JsonPointerFor as ba, type JsonPointerInput as bb, type JsonPointerSegment as bc, type JsonPointerSegments as bd, type JsonPointerSegmentsFor as be, LEGACY_GRAPH_EXTENSION_VERSION as bf, type LockSchemaVersionForWriteParams as bg, MAX_JSON_POINTER_DEPTH as bh, type MetaEdgeProperties as bi, type NodeEntityReadBackend as bj, type NodeEntityWriteBackend as bk, type NodeProps as bl, type NodeRegistration as bm, type OrderSpec as bn, type ParameterRef as bo, Placeholder as bp, type PopulatedSchemaKind as bq, type QueryExecutionBackend as br, type RawQueryExecutionBackend as bs, type RawStatementExecutionBackend as bt, type RecordedRelationOptions as bu, type RemovalMaterializationBackend as bv, type RenderedSql as bw, type ResolveJsonPointer as bx, type ResolveJsonPointerSegments as by, type ResolvedSqlTableNames as bz, type ContributionRepairResult as c, D1_MAX_BIND_PARAMETERS as c$, type UpdateNodeSetResult as c0, type UpsertFulltextBatchParams as c1, type VectorCapabilities as c2, type VectorOperationBackend as c3, type VectorSearchFrontierTuning as c4, asEdgeId as c5, asNodeId as c6, buildVectorCapabilities as c7, createSqlSchema as c8, defineGraph as c9, type NodePredicate as cA, type ProjectedField as cB, type AggregateOrderSpec as cC, type GroupBySpec as cD, type RecursiveCyclePolicy as cE, type VectorSlotMap as cF, type RecordedReadBinding as cG, type SelectiveField as cH, type ComposableQuery as cI, type SetOperationType as cJ, type SetOperation as cK, type NodeRow as cL, type EdgeRow as cM, type VectorMetric as cN, ALL_FULLTEXT_MODES as cO, ALL_META_EDGE_NAMES as cP, BASE_CONTRIBUTION_OWNER as cQ, type CheckUniqueBatchParams as cR, type CheckUniqueParams as cS, type ClaimIndexMaterializationParams as cT, type CompiledTemporaryStatementSql as cU, type ContributionMaterializationIdentity as cV, type ContributionMaterializationRow as cW, type CountEdgesByKindParams as cX, type CountEdgesFromParams as cY, type CountNodesByKindParams as cZ, type CreateVectorIndexParams as c_, fts5Strategy as ca, getEdgeKinds as cb, getNodeKinds as cc, isEdgeType as cd, isEdgeTypeWithEndpoints as ce, isGraphDef as cf, isMetaEdge as cg, isNodeType as ch, isSqlFragment as ci, joinJsonPointers as cj, jsonPointer as ck, normalizeJsonPointer as cl, parseJsonPointer as cm, recordedRelation as cn, renderPostgres as co, renderSql as cp, renderSqlInline as cq, renderSqlite as cr, rowPropsToJsonText as cs, rowPropsToObject as ct, sql as cu, tsvectorStrategy as cv, type ValueType as cw, type PredicateExpression as cx, type VectorMetricType as cy, type Traversal as cz, type GraphDef as d, type ReleaseIndexMaterializationClaimParams as d$, DURABLE_OBJECT_MAX_BIND_PARAMETERS as d0, type DeleteEdgeParams as d1, type DeleteEdgesBatchParams as d2, type DeleteEmbeddingParams as d3, type DeleteFulltextParams as d4, type DeleteNodeParams as d5, type DeleteUniqueParams as d6, type DialectAdapter as d7, type DialectCapabilities as d8, type DialectRecursiveQueryStrategy as d9, type FindNodesByKindParams as dA, type GraphReadBackend as dB, type HardDeleteEdgeParams as dC, type HardDeleteNodeParams as dD, type HybridSearchParams as dE, type HybridSearchRow as dF, type IdentityTableNames as dG, type InListParameterOptions as dH, type IndexDeclarationBase as dI, type IndexMaterializationRow as dJ, type IndexWhereLiteral as dK, type IndexWhereOp as dL, type IndexWhereOperand as dM, type InsertEdgeParams as dN, type InsertNodeParams as dO, type InsertSchemaParams as dP, type InsertUniqueParams as dQ, type KindRemovalRow as dR, type LiveNodeRow as dS, MODERN_SQLITE_MAX_BIND_PARAMETERS as dT, type MetaEdgeName as dU, POSTGRES_CAPABILITIES as dV, POSTGRES_MAX_BIND_PARAMETERS as dW, type RecordContributionMaterializationParams as dX, type RecordIndexMaterializationParams as dY, type RecordKindRemovalParams as dZ, type RelationalIndexMethod as d_, type DialectStandardQueryStrategy as da, type DialectVectorPredicateStrategy as db, type DropVectorIndexParams as dc, type EdgeExistsBetweenParams as dd, type ExtensionArrayItemType as de, type ExtensionArrayProperty as df, type ExtensionBooleanProperty as dg, type ExtensionEdgeIndex as dh, type ExtensionEmbeddingModifier as di, type ExtensionEnumProperty as dj, type ExtensionIndexWhere as dk, type ExtensionNodeIndex as dl, type ExtensionNumberProperty as dm, type ExtensionObjectFieldProperty as dn, type ExtensionObjectProperty as dp, type ExtensionPropertyModifiers as dq, type ExtensionPropertyType as dr, type ExtensionSearchableModifier as ds, type ExtensionStringProperty as dt, type ExtensionUniqueConstraint as du, type ExtensionUniqueWhere as dv, FULLTEXT_CONTRIBUTION_NAME as dw, type FindEdgesByEndpointSetParams as dx, type FindEdgesByKindParams as dy, type FindEdgesConnectedToParams as dz, type EdgeIndexConfig as e, SQLITE_CAPABILITIES as e0, SQLITE_MAX_BIND_PARAMETERS as e1, type SchemaCommitPreflightBackend as e2, type SqlCompilationBackend as e3, type TombstonedNodeRow as e4, type UniqueRow as e5, type UpdateEdgeParams as e6, type UpdateNodeParams as e7, type UpsertEmbeddingBatchParams as e8, type UpsertEmbeddingBatchRow as e9, type UpsertEmbeddingParams as ea, type UpsertFulltextParams as eb, VECTOR_CONTRIBUTION_PREFIX as ec, type VectorIndexType as ed, type VectorSearchParams as ee, type VectorSearchResult as ef, assertFiniteEmbedding as eg, assertVectorMinScore as eh, assertVectorSearchLimit as ei, buildFulltextCapabilities as ej, isLiveNodeRow as ek, isSqlPlaceholder as el, isTombstonedNodeRow as em, normalizeGraphAnalyticsCapabilities as en, quoteIdentifier as eo, shortHash as ep, vectorMinScoreCondition as eq, vectorPhysicalName as er, vectorScoreExpression as es, GRAPH_EXTENSION_TOP_LEVEL_KEYS as et, type GraphExtensionTopLevelKey as eu, type EdgeIndexDirection as f, type EdgeIndexWhereBuilder as g, type IndexOrigin as h, type IndexScope as i, type IndexWhereExpression as j, type IndexWhereFieldBuilder as k, type IndexWhereInput as l, type NodeIndexConfig as m, type NodeIndexWhereBuilder as n, type SystemColumnName as o, type VectorIndexDeclaration as p, type VectorIndexImplementation as q, type VectorIndexMetric as r, type VectorIndexParams as s, type VectorSlot as t, type NodeType as u, type AnyEdgeType as v, SqlSchema as w, type SchemaVersionRow as x, type GraphBackend as y, type SerializedSchema as z };