@nicia-ai/typegraph 0.45.0 → 0.46.0

package/dist/{types-Ch9a0Dx6.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;
     /**
@@ -1045,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") */
@@ -1063,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 */
@@ -1083,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;
 }>;
@@ -1102,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;
 }
 /**
@@ -1821,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).
  *
@@ -1948,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.
      *
@@ -2058,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.
  */
@@ -2078,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.
@@ -2123,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.
@@ -2162,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;
@@ -2287,7 +2631,33 @@ 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;
@@ -2371,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;
 }>;
 /**
@@ -2381,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).
@@ -2396,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<{
@@ -2514,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;
 }>;
@@ -2989,6 +3436,122 @@ 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
@@ -3035,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.
  *
@@ -3199,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.
@@ -3312,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.
@@ -3525,6 +4172,61 @@ type GraphBackend = Readonly<{
      * 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`
@@ -3700,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.
  */
@@ -4407,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;
 }>;
@@ -4880,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 SerializedOntology 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 SerializedSchema as H, type IndexDeclaration as I, type JsonPointer as J, type KindEntity as K, type SerializedNodeDef as L, type SerializedEdgeDef as M, type NodeRegistration as N, type OntologyRelation as O, type IndexEntity as P, type QueryAst as Q, type RelationalIndexDeclaration as R, type SqlDialect as S, type TemporalMode as T, type SerializedMetaEdge as U, type VectorStrategy as V, type SerializedOntologyRelation as W, type SerializedClosures as X, type SchemaHash as Y, type NullCheckOp as Z, type JsonSchema as _, type ContributionDiagnosticState as a, type NodeEntityWriteBackend as a$, type SerializedUniqueConstraint as a0, type InferenceType as a1, type EdgeType as a2, type AggregateExpr as a3, type FieldRef as a4, type ComparisonOp as a5, type AggregateComparisonPredicate as a6, type TraversalDirection as a7, type AdapterBackendTransactions as a8, type BackendIdentity as a9, type FulltextCapabilities as aA, type FulltextOperationBackend as aB, type FulltextQueryMode as aC, type FulltextSearchParams as aD, type FulltextSearchResult as aE, type GraphAnalyticsCapabilities as aF, type GraphEntityReadBackend as aG, type GraphEntityWriteBackend as aH, type GraphExtensionVersion as aI, type GraphLifecycleBackend as aJ, type HardDeleteUniquesByNodeIdsParams as aK, type HybridFusionOptions as aL, type IndexMaterializationBackend as aM, type IntentSql as aN, type JsonPointerFor as aO, type JsonPointerInput as aP, type JsonPointerSegment as aQ, type JsonPointerSegments as aR, type JsonPointerSegmentsFor as aS, type JsonValue as aT, type KindAnnotations as aU, LEGACY_GRAPH_EXTENSION_VERSION as aV, type LockSchemaVersionForWriteParams as aW, MAX_JSON_POINTER_DEPTH as aX, type MetaEdge as aY, type MetaEdgeProperties as aZ, type NodeEntityReadBackend as a_, type BackendLifecycle as aa, type BackendMaintenance as ab, type BackendTransactions as ac, CURRENT_GRAPH_EXTENSION_VERSION as ad, type Cardinality as ae, type Collation as af, type CommitSchemaVersionExpected as ag, type CommitSchemaVersionIfKindsEmptyResult as ah, type CommitSchemaVersionParams as ai, type CompiledRowsSql as aj, type CompiledSelectSql as ak, type CompiledStatementSql as al, type ContributionMaterializationBackend as am, DEFAULT_SQL_SCHEMA as an, type DeleteFulltextBatchParams as ao, type EdgeEntityReadBackend as ap, type EdgeEntityWriteBackend as aq, type EdgeId as ar, type EdgeProps as as, type EdgeTypeWithEndpoints as at, type EndpointExistence as au, type ExternalRecordedReadSource as av, type FilteredApproximateSearch as aw, type FilteredApproximateSearchMode as ax, type FindEdgesByHeterogeneousEndpointSetParams as ay, type FulltextBatchRow as az, type ContributionRepairEntry as b, renderPostgres as b$, type NodeId as b0, type NodeProps as b1, type OrderSpec as b2, type ParameterRef as b3, Placeholder as b4, type PopulatedSchemaKind as b5, type QueryExecutionBackend as b6, type RawQueryExecutionBackend as b7, type RawStatementExecutionBackend as b8, type RecordedRelationOptions as b9, type TransactionReadBackend as bA, type TraversalExpansion as bB, type TrustedImportOptions as bC, type TrustedImportSession as bD, type UniqueConstraint as bE, type UniqueConstraintBackend as bF, type UniquenessScope as bG, type UpdateNodeSetParams as bH, type UpdateNodeSetResult as bI, type UpsertFulltextBatchParams as bJ, type VectorCapabilities as bK, type VectorOperationBackend as bL, asEdgeId as bM, asNodeId as bN, buildVectorCapabilities as bO, createSqlSchema as bP, fts5Strategy as bQ, isEdgeType as bR, isEdgeTypeWithEndpoints as bS, isMetaEdge as bT, isNodeType as bU, isSqlFragment as bV, joinJsonPointers as bW, jsonPointer as bX, normalizeJsonPointer as bY, parseJsonPointer as bZ, recordedRelation as b_, type RemovalMaterializationBackend as ba, type RenderedSql as bb, type ResolveJsonPointer as bc, type ResolveJsonPointerSegments as bd, type ResolvedSqlTableNames as be, type RowProps as bf, type SchemaCommitBackend as bg, type SchemaKindEmptinessProbe as bh, type SchemaReadBackend as bi, type SchemaWriteFenceBackend as bj, type SetActiveVersionParams as bk, type SortDirection as bl, type SqlChunk as bm, type SqlFragment as bn, type SqlIdentifierChunk as bo, type SqlIntent as bp, type SqlParameterChunk as bq, type SqlPlaceholderChunk as br, SqlSchema as bs, type SqlTableNames as bt, type SqlTag as bu, type SqlTextChunk as bv, type StrategyTableContribution as bw, type TableContribution as bx, type TransactionBackend as by, type TransactionOptions as bz, type ContributionRepairResult as c, type ExtensionIndexWhere as c$, renderSql as c0, renderSqlInline as c1, renderSqlite as c2, rowPropsToJsonText as c3, rowPropsToObject as c4, sql as c5, tsvectorStrategy as c6, type ExtensionNodeDef as c7, type ExtensionEdgeDef as c8, type ExtensionOntologyRelation as c9, type ContributionMaterializationIdentity as cA, type ContributionMaterializationRow as cB, type CountEdgesByKindParams as cC, type CountEdgesFromParams as cD, type CountNodesByKindParams as cE, type CreateVectorIndexParams as cF, D1_MAX_BIND_PARAMETERS as cG, DURABLE_OBJECT_MAX_BIND_PARAMETERS as cH, type DeleteEdgeParams as cI, type DeleteEdgesBatchParams as cJ, type DeleteEmbeddingParams as cK, type DeleteFulltextParams as cL, type DeleteNodeParams as cM, type DeleteUniqueParams as cN, type DialectAdapter as cO, type DialectCapabilities as cP, type DialectRecursiveQueryStrategy as cQ, type DialectStandardQueryStrategy as cR, type DialectVectorPredicateStrategy as cS, type DropVectorIndexParams as cT, type EdgeExistsBetweenParams as cU, type ExtensionArrayItemType as cV, type ExtensionArrayProperty as cW, type ExtensionBooleanProperty as cX, type ExtensionEdgeIndex as cY, type ExtensionEmbeddingModifier as cZ, type ExtensionEnumProperty as c_, type ExtensionIndex as ca, type ValueType as cb, type PredicateExpression as cc, type VectorMetricType as cd, type Traversal as ce, type NodePredicate as cf, type ProjectedField as cg, type AggregateOrderSpec as ch, type GroupBySpec as ci, type RecursiveCyclePolicy as cj, type VectorSlotMap as ck, type RecordedReadBinding as cl, type SelectiveField as cm, type ComposableQuery as cn, type SetOperationType as co, type SetOperation as cp, type NodeRow as cq, type EdgeRow as cr, type VectorMetric as cs, ALL_FULLTEXT_MODES as ct, ALL_META_EDGE_NAMES as cu, BASE_CONTRIBUTION_OWNER as cv, type CheckUniqueBatchParams as cw, type CheckUniqueParams as cx, type ClaimIndexMaterializationParams as cy, type CompiledTemporaryStatementSql as cz, type NodeType as d, isTombstonedNodeRow as d$, type ExtensionNodeIndex as d0, type ExtensionNumberProperty as d1, type ExtensionObjectFieldProperty as d2, type ExtensionObjectProperty as d3, type ExtensionPropertyModifiers as d4, type ExtensionPropertyType as d5, type ExtensionSearchableModifier as d6, type ExtensionStringProperty as d7, type ExtensionUniqueConstraint as d8, type ExtensionUniqueWhere as d9, POSTGRES_MAX_BIND_PARAMETERS as dA, type RecordContributionMaterializationParams as dB, type RecordIndexMaterializationParams as dC, type RecordKindRemovalParams as dD, type RelationalIndexMethod as dE, type ReleaseIndexMaterializationClaimParams as dF, SQLITE_CAPABILITIES as dG, SQLITE_MAX_BIND_PARAMETERS as dH, type SqlCompilationBackend as dI, type TombstonedNodeRow as dJ, type UniqueRow as dK, type UpdateEdgeParams as dL, type UpdateNodeParams as dM, type UpsertEmbeddingBatchParams as dN, type UpsertEmbeddingBatchRow as dO, type UpsertEmbeddingParams as dP, type UpsertFulltextParams as dQ, VECTOR_CONTRIBUTION_PREFIX as dR, type VectorIndexType as dS, type VectorSearchParams as dT, type VectorSearchResult as dU, assertFiniteEmbedding as dV, assertVectorMinScore as dW, assertVectorSearchLimit as dX, buildFulltextCapabilities as dY, isLiveNodeRow as dZ, isSqlPlaceholder as d_, FULLTEXT_CONTRIBUTION_NAME as da, type FindEdgesByEndpointSetParams as db, type FindEdgesByKindParams as dc, type FindEdgesConnectedToParams as dd, type FindNodesByKindParams as de, type GraphReadBackend as df, type HardDeleteEdgeParams as dg, type HardDeleteNodeParams as dh, type HybridSearchParams as di, type HybridSearchRow as dj, type InListParameterOptions as dk, type IndexDeclarationBase as dl, type IndexMaterializationRow as dm, type IndexWhereLiteral as dn, type IndexWhereOp as dp, type IndexWhereOperand as dq, type InsertEdgeParams as dr, type InsertNodeParams as ds, type InsertSchemaParams as dt, type InsertUniqueParams as du, type KindRemovalRow as dv, type LiveNodeRow as dw, MODERN_SQLITE_MAX_BIND_PARAMETERS as dx, type MetaEdgeName as dy, POSTGRES_CAPABILITIES as dz, type AnyEdgeType as e, normalizeGraphAnalyticsCapabilities as e0, quoteIdentifier as e1, shortHash as e2, vectorMinScoreCondition as e3, vectorPhysicalName as e4, vectorScoreExpression as e5, GRAPH_EXTENSION_TOP_LEVEL_KEYS as e6, type GraphExtensionTopLevelKey as e7, type GraphDefaults as f, type EdgeIndexDeclaration as g, type NodeIndexDeclaration as h, type EdgeIndexConfig as i, type EdgeIndexDirection as j, type EdgeIndexWhereBuilder as k, type IndexOrigin as l, type IndexScope as m, type IndexWhereExpression as n, type IndexWhereFieldBuilder as o, type IndexWhereInput as p, type NodeIndexConfig as q, type NodeIndexWhereBuilder as r, type SystemColumnName as s, type VectorIndexDeclaration as t, type VectorIndexImplementation as u, type VectorIndexMetric as v, type VectorIndexParams as w, type VectorSlot as x, type SchemaVersionRow as y, type GraphBackend 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 };