@nicia-ai/typegraph 0.49.0 → 0.51.0

package/dist/{types-BqFZTQmV.d.cts → types-6yf0Vv-_.d.cts}

@@ -1068,7 +1068,7 @@ declare function renderSqlInline(fragment: SqlFragment, dialect: SqlDialect): st
  * Table names for TypeGraph SQL schema.
  *
  * Carries every customizable physical-table name the backend exposes,
- * including the secondary tables (`uniques`) that the query compiler
+ * including the secondary tables (`uniques`, `edgeClaims`) that the query compiler
  * itself doesn't reference but `materializeRemovals` and other
  * cleanup paths need to address by name. Backends without a
  * `uniques` table (custom embeddings-only stores) leave it as the
@@ -1100,6 +1100,8 @@ type SqlTableNames = Readonly<{
     fulltext: string;
     /** Node uniques table name (default: "typegraph_node_uniques") */
     uniques: string;
+    /** Edge cardinality claim table name (default: "typegraph_edge_claims") */
+    edgeClaims?: string | undefined;
 }>;
 type ResolvedSqlTableNames = Readonly<{
     /** Nodes table name */
@@ -1122,6 +1124,8 @@ type ResolvedSqlTableNames = Readonly<{
     fulltext: string;
     /** Node uniques table name */
     uniques: string;
+    /** Edge cardinality claim table name */
+    edgeClaims: string;
 }>;
 type SqlSchemaFields = Readonly<{
     /** Table names */
@@ -1838,6 +1842,182 @@ type GraphExtension = Readonly<{
 declare const GRAPH_EXTENSION_TOP_LEVEL_KEYS: readonly ["version", "nodes", "edges", "ontology", "indexes"];
 type GraphExtensionTopLevelKey = (typeof GRAPH_EXTENSION_TOP_LEVEL_KEYS)[number];
 
+/**
+ * Schema migration utilities.
+ *
+ * Provides diff detection between schema versions to identify
+ * what has changed and what migrations might be needed.
+ */
+
+/**
+ * Types of changes that can occur in a schema.
+ */
+type ChangeType = "added" | "removed" | "modified" | "renamed";
+/**
+ * Severity of a change for migration purposes.
+ */
+type ChangeSeverity = "safe" | "warning" | "breaking";
+/**
+ * A change to a node definition.
+ */
+type NodeChange = Readonly<{
+    type: ChangeType;
+    kind: string;
+    severity: ChangeSeverity;
+    details: string;
+    before?: SerializedNodeDef | undefined;
+    after?: SerializedNodeDef | undefined;
+}>;
+/**
+ * A change to an edge definition.
+ */
+type EdgeChange = Readonly<{
+    type: ChangeType;
+    kind: string;
+    severity: ChangeSeverity;
+    details: string;
+    before?: SerializedEdgeDef | undefined;
+    after?: SerializedEdgeDef | undefined;
+}>;
+/**
+ * A change to the ontology.
+ */
+type OntologyChange = Readonly<{
+    type: ChangeType;
+    entity: "metaEdge" | "relation";
+    name: string;
+    severity: ChangeSeverity;
+    details: string;
+}>;
+/** A durable graph-level Operational Identity capability change. */
+type IdentityChange = Readonly<{
+    type: ChangeType;
+    severity: ChangeSeverity;
+    details: string;
+}>;
+/**
+ * A change to an index declaration.
+ *
+ * Index changes are always `safe`-severity: index DDL is materialized
+ * separately and never blocks schema-version commits or migrations.
+ * Adding, removing, or modifying an index never invalidates existing
+ * data — it only changes which physical indexes the deployment will
+ * materialize on its next pass.
+ */
+type IndexChange = Readonly<{
+    type: ChangeType;
+    /** Index name (the diffing identity key). */
+    name: string;
+    /**
+     * Whether this index is on a node, edge, or vector field. Vector
+     * index changes flow through the same diff classification as
+     * relational ones.
+     */
+    entity: IndexEntity;
+    severity: ChangeSeverity;
+    details: string;
+    before?: IndexDeclaration | undefined;
+    after?: IndexDeclaration | undefined;
+}>;
+/**
+ * A change to the persisted graph-extension document.
+ *
+ * Graph-extension document changes are committed only through the
+ * graph-extension lifecycle verbs (`evolve` and `removeKinds`), so the
+ * extension-slice change itself is `safe`-severity. The detailed
+ * per-kind effect is captured in the corresponding node/edge/ontology
+ * changes the merged document produced.
+ */
+type ExtensionChange = Readonly<{
+    type: ChangeType;
+    severity: ChangeSeverity;
+    details: string;
+}>;
+/**
+ * Change to the soft-deprecated kind set. `safe`-severity by
+ * construction — deprecation is a metadata signal that doesn't gate
+ * reads, writes, or queries. The `added` and `removed` arrays carry
+ * the per-name deltas so consumers can render granular diffs.
+ */
+type DeprecatedKindsChange = Readonly<{
+    added: readonly string[];
+    removed: readonly string[];
+    severity: ChangeSeverity;
+    details: string;
+}>;
+/**
+ * A complete diff between two schema versions.
+ */
+type SchemaDiff = Readonly<{
+    fromVersion: number;
+    toVersion: number;
+    /** Changes to node definitions */
+    nodes: readonly NodeChange[];
+    /** Changes to edge definitions */
+    edges: readonly EdgeChange[];
+    /** Changes to ontology */
+    ontology: readonly OntologyChange[];
+    /** Change to the graph-level identity capability, if any. */
+    identity?: IdentityChange;
+    /** Changes to index declarations */
+    indexes: readonly IndexChange[];
+    /**
+     * Change to the graph-extension document, if any. `undefined` when
+     * the slice is unchanged on both sides (the common case).
+     */
+    extension?: ExtensionChange;
+    /**
+     * Change to the soft-deprecated kind set, if any. `undefined` when
+     * the set is unchanged on both sides.
+     */
+    deprecatedKinds?: DeprecatedKindsChange;
+    /** Whether any breaking changes exist */
+    hasBreakingChanges: boolean;
+    /** Whether the change is backwards compatible (no breaking changes) */
+    isBackwardsCompatible: boolean;
+    /** Whether any changes exist at all */
+    hasChanges: boolean;
+    /** Summary of changes */
+    summary: string;
+}>;
+/**
+ * Computes the diff between two schema versions.
+ *
+ * @param before - The previous schema version
+ * @param after - The new schema version
+ * @returns A diff describing all changes
+ */
+declare function computeSchemaDiff(before: SerializedSchema, after: SerializedSchema): SchemaDiff;
+/**
+ * Checks if a schema change is backwards compatible.
+ *
+ * A change is backwards compatible if:
+ * - No nodes or edges were removed
+ * - No required properties were added
+ * - No existing properties were removed
+ */
+declare function isBackwardsCompatible(diff: SchemaDiff): boolean;
+/**
+ * How a proposed graph relates to the committed schema.
+ *
+ * - `identical` — a semantic no-op; committing it changes nothing.
+ * - `additive` — changes exist and are all backwards compatible.
+ * - `incompatible` — at least one breaking change; needs a deliberate
+ *   migration decision.
+ */
+type SchemaChangeClassification = "identical" | "additive" | "incompatible";
+/**
+ * Classifies a schema diff into the three outcomes a caller actually branches
+ * on. Pure — no I/O, no DDL. Pair with `getSchemaChanges(backend, graph)` (or
+ * `store.schemaChanges()`) to pre-flight a proposal *before* touching a
+ * privileged, migration-gated path.
+ */
+declare function classifySchemaChanges(diff: SchemaDiff): SchemaChangeClassification;
+/**
+ * Gets a list of actions needed for migration.
+ */
+declare function getMigrationActions(diff: SchemaDiff): readonly string[];
+
 /** Brand key for MetaEdge */
 declare const META_EDGE_BRAND: "__metaEdge";
 /**
@@ -1950,122 +2130,1423 @@ type GraphDefConfig<TNodes extends Record<string, NodeRegistration>, TEdges exte
  * 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;
+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)[];
+
+/**
+ * Index materialization — runs declared index DDL against the live
+ * database and tracks per-deployment status in
+ * `typegraph_index_materializations`.
+ *
+ * Reads `IndexDeclaration[]` from `GraphDef.indexes`, generates DDL via
+ * `generateIndexDDL`, executes via `backend.executeDdl` (Postgres path
+ * uses `CREATE INDEX CONCURRENTLY`, which cannot run inside a
+ * transaction — `executeDdl` runs at the top-level backend, never inside
+ * `transaction(...)`), and upserts a status row per index.
+ *
+ * Caveats baked in to the algorithm:
+ *
+ * - SQL index names are physical, database-global identifiers.
+ *   Cross-graph collisions (two graphs declaring the same name with
+ *   different shapes) surface as a `failed` result with reason
+ *   "signature drift", because the existing recorded signature won't
+ *   match the new one.
+ * - On Postgres, `CREATE INDEX CONCURRENTLY IF NOT EXISTS` does NOT
+ *   prove the existing physical index has the same shape as ours —
+ *   only that something with that name exists. Drift detection here
+ *   relies on TypeGraph's recorded signature, not on PG metadata.
+ * - Failed `CONCURRENTLY` builds leave invalid indexes behind
+ *   (`pg_index.indisvalid = false`). Relational rebuilds self-heal: the
+ *   claim-holding materializer drops an invalid leftover with the
+ *   declaration's name before rebuilding (see dropInvalidIndexLeftover).
+ *   Vector per-field index leftovers remain operator-repair.
+ * - Two materializers racing the SAME index name serialize through a
+ *   durable claim in the status table (see materializeWithClaim) —
+ *   concurrent same-name expression-index CIC builds deadlock on
+ *   Postgres (no safe-snapshot exemption).
+ */
+
+type MaterializeIndexesOptions = Readonly<{
+    /** Restrict to indexes whose `kind` is in this set. */
+    kinds?: readonly string[];
+    /** Stop on the first failure. Default: false (best-effort). */
+    stopOnError?: boolean;
+    /**
+     * Refresh planner statistics (ANALYZE) after at least one index was
+     * created. A fresh index can be ignored by the planner until statistics
+     * exist. Default: true. Applied on non-concurrent builders (SQLite) and
+     * on concurrent builders that serialize same-index builds via the
+     * cross-caller claim primitive (the bundled Postgres backend); a custom
+     * concurrent backend without the primitive skips the refresh — see
+     * refreshStatisticsAfterCreation — and should call
+     * `store.refreshStatistics()` after materializing.
+     */
+    refreshStatistics?: boolean;
+}>;
+/**
+ * Per-index outcome from `materializeIndexes()`.
+ *
+ * Status values:
+ * - `created`: DDL ran successfully and a new physical index now exists.
+ * - `alreadyMaterialized`: status table shows a prior successful
+ *   materialization with the same signature; no DDL ran.
+ * - `failed`: the DDL or status write failed; `error` carries the
+ *   captured exception. Best-effort mode continues to the next index;
+ *   `stopOnError: true` halts.
+ * - `skipped`: the backend can't materialize this index variant in its
+ *   current configuration (e.g. vector indexes against SQLite without
+ *   sqlite-vec, or `indexType: "none"` declared on an embedding). The
+ *   declaration is recognized but intentionally not acted on. Status
+ *   table is NOT updated for skipped entries.
+ */
+type MaterializeIndexesEntry = Readonly<{
+    indexName: string;
+    entity: IndexEntity;
+    kind: string;
+    status: "created" | "alreadyMaterialized" | "failed" | "skipped";
+    error?: Error;
+    /**
+     * Human-readable reason. Required for `skipped`; optional otherwise.
+     */
+    reason?: string;
+}>;
+type MaterializeIndexesResult = Readonly<{
+    results: readonly MaterializeIndexesEntry[];
+}>;
+type MaterializeSystemIndexesOptions = Readonly<{
+    /** Stop on the first failure. Default: false (best-effort). */
+    stopOnError?: boolean;
+    /** Refresh planner statistics after a creation. Default: true. */
+    refreshStatistics?: boolean;
+}>;
+
+/**
+ * TypeGraph Error Hierarchy
+ *
+ * All errors extend TypeGraphError with:
+ * - `code`: Machine-readable error code for programmatic handling
+ * - `category`: Classification for error handling strategies
+ * - `suggestion`: Optional recovery guidance for users
+ * - `details`: Structured context about the error
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await store.nodes.Person.create({ name: "" });
+ * } catch (error) {
+ *   if (isTypeGraphError(error)) {
+ *     console.error(error.toUserMessage());
+ *     if (isUserRecoverable(error)) {
+ *       // Show to user for correction
+ *     }
+ *   }
+ * }
+ * ```
+ */
+
+/**
+ * Error category for programmatic handling.
+ *
+ * - `user`: Caused by invalid input or incorrect usage. Recoverable by fixing input.
+ * - `constraint`: Business rule or schema constraint violation. Recoverable by changing data.
+ * - `system`: Internal error or infrastructure issue. May require investigation or retry.
+ */
+type ErrorCategory = "user" | "constraint" | "system";
+/**
+ * Options for TypeGraphError constructor.
+ */
+type TypeGraphErrorOptions = Readonly<{
+    /** Structured context about the error */
+    details?: Record<string, unknown>;
+    /** Error category for handling strategies */
+    category: ErrorCategory;
+    /** Recovery guidance for users */
+    suggestion?: string;
+    /** Underlying cause of the error */
+    cause?: unknown;
+}>;
+/**
+ * Base error class for all TypeGraph errors.
+ *
+ * Provides structured error information for both programmatic handling
+ * and user-friendly messages.
+ */
+declare class TypeGraphError extends Error {
+    /** Machine-readable error code (e.g., "VALIDATION_ERROR") */
+    readonly code: string;
+    /** Error category for handling strategies */
+    readonly category: ErrorCategory;
+    /** Structured context about the error */
+    readonly details: Readonly<Record<string, unknown>>;
+    /** Recovery guidance for users */
+    readonly suggestion?: string;
+    constructor(message: string, code: string, options: TypeGraphErrorOptions);
+    /**
+     * Returns a user-friendly error message with suggestion if available.
+     */
+    toUserMessage(): string;
+    /**
+     * Returns a detailed string representation for logging.
+     */
+    toLogString(): string;
+}
+/**
+ * Validation issue from Zod or custom validation.
+ */
+type ValidationIssue = Readonly<{
+    /** Path to the invalid field (e.g., "address.city") */
+    path: string;
+    /** Human-readable error message */
+    message: string;
+    /** Zod error code if from Zod validation */
+    code?: string;
+    /**
+     * The identity assertion the issue is about, carried structurally so
+     * consumers (e.g. interchange import error reporting) never have to parse
+     * the human-readable message for it.
+     */
+    assertionId?: string;
+}>;
+/**
+ * The stable {@link ValidationIssue.code} every inverted-validity-window
+ * refusal carries, so a caller can recognize that specific failure without
+ * matching on the message. `ValidationError`'s own code is the family-wide
+ * `VALIDATION_ERROR`, so the discriminator lives on the issue — mirroring the
+ * identity-import window refusal (`IDENTITY_IMPORT_INVALID_WINDOW`).
+ *
+ * A write carrying it was refused because `validTo` precedes the row's
+ * effective `validFrom`: the row would have stopped being true before it
+ * started, observable at no `asOf` coordinate at all. Zero-width windows
+ * (`validTo === validFrom`) are legal and never raise it.
+ */
+declare const INVERTED_VALIDITY_WINDOW_CODE = "INVERTED_VALIDITY_WINDOW";
+/**
+ * The stable {@link ValidationIssue.code} carried by a refusal to accept a
+ * `validFrom` the write cannot apply: the target row is LIVE, and an in-place
+ * update never rewrites a live row's lower bound — that bound is history.
+ * `ValidationError`'s own code is the family-wide `VALIDATION_ERROR`, so the
+ * discriminator lives on the issue — mirroring
+ * {@link INVERTED_VALIDITY_WINDOW_CODE}.
+ *
+ * Only a bound naming a DIFFERENT instant than the row already stores raises it.
+ * Restating the stored bound is legal and writes nothing new, and a resurrection
+ * — which does rewrite `valid_from` — applies a stated bound rather than
+ * refusing it.
+ *
+ * The message names both instants: the one stated and the one the row stores, so
+ * the caller can restate the stored bound without a second read.
+ */
+declare const IMMUTABLE_VALIDITY_LOWER_BOUND_CODE = "IMMUTABLE_VALIDITY_LOWER_BOUND";
+/**
+ * Stable {@link ValidationIssue.code} for an edge-id ownership mismatch.
+ *
+ * Edge ids are graph-global. A collection-scoped write therefore has to prove
+ * that the stored row has the collection's kind and, when the caller supplies
+ * endpoints, the same immutable endpoints. This refusal prevents a collection
+ * from mutating another kind's row and prevents an upsert from silently
+ * ignoring an attempted repoint.
+ */
+declare const EDGE_IDENTITY_MISMATCH_CODE = "EDGE_IDENTITY_MISMATCH";
+/**
+ * The stable {@link ValidationIssue.code} every "this id is already taken"
+ * create refusal carries, whichever way the create found out: its own existence
+ * probe, or the engine refusing the INSERT. `ValidationError`'s own code is the
+ * family-wide `VALIDATION_ERROR`, so the discriminator lives on the issue —
+ * mirroring {@link INVERTED_VALIDITY_WINDOW_CODE}.
+ *
+ * `details.entityType` says whether a node or an edge was refused and
+ * `details.kind` names its kind. `details.id` names the taken id, and is absent
+ * only when the refused statement inserted MORE THAN ONE row: the engine reports
+ * that the statement collided without saying which row did.
+ */
+declare const ENTITY_ALREADY_EXISTS_CODE = "ENTITY_ALREADY_EXISTS";
+/**
+ * Details for ValidationError.
+ */
+type ValidationErrorDetails = Readonly<{
+    /** Type of entity being validated */
+    entityType?: KindEntity;
+    /** Kind/type name of the entity */
+    kind?: string;
+    /** Operation being performed */
+    operation?: "create" | "update" | "delete" | "hardDelete";
+    /** Entity ID if updating */
+    id?: string;
+    /** Individual validation issues */
+    issues: readonly ValidationIssue[];
+}>;
+/**
+ * Thrown when schema validation fails during node or edge operations.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await store.nodes.Person.create({ email: "invalid" });
+ * } catch (error) {
+ *   if (error instanceof ValidationError) {
+ *     console.log(error.details.issues);
+ *     // [{ path: "email", message: "Invalid email" }]
+ *   }
+ * }
+ * ```
+ */
+declare class ValidationError extends TypeGraphError {
+    readonly details: ValidationErrorDetails;
+    constructor(message: string, details: ValidationErrorDetails, options?: {
+        cause?: unknown;
+        suggestion?: string;
+    });
+}
+/**
+ * Details for NodeNotFoundError.
+ */
+type NodeNotFoundErrorDetails = Readonly<{
+    kind: string;
+    id: string;
+}>;
+/**
+ * Thrown when a node is not found.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await store.nodes.Person.get("nonexistent-id");
+ * } catch (error) {
+ *   if (error instanceof NodeNotFoundError) {
+ *     console.log(error.details.kind, error.details.id);
+ *   }
+ * }
+ * ```
+ */
+declare class NodeNotFoundError extends TypeGraphError {
+    readonly details: NodeNotFoundErrorDetails;
+    constructor(kind: string, id: string, options?: {
+        cause?: unknown;
+    });
+}
+/**
+ * Details for EdgeNotFoundError.
+ */
+type EdgeNotFoundErrorDetails = Readonly<{
+    kind: string;
+    id: string;
+}>;
+/**
+ * Thrown when an edge is not found.
+ */
+declare class EdgeNotFoundError extends TypeGraphError {
+    readonly details: EdgeNotFoundErrorDetails;
+    constructor(kind: string, id: string, options?: {
+        cause?: unknown;
+    });
+}
+/**
+ * Details for KindNotFoundError.
+ */
+type KindNotFoundErrorDetails = Readonly<{
+    kindName: string;
+    entity: KindEntity;
+    graphId?: string;
+}>;
+/**
+ * Thrown when an operation references a kind that isn't registered on
+ * the graph — `getNodeCollectionOrThrow` against an unknown kind, a
+ * `materializeIndexes({ kinds })` filter naming a missing kind, an
+ * extension referencing an unresolved endpoint, search facade typos,
+ * etc. Carries the offending `kindName` and `entity` plus the host
+ * `graphId` so logs are unambiguous when multiple stores share a
+ * process.
+ */
+declare class KindNotFoundError extends TypeGraphError {
+    readonly details: KindNotFoundErrorDetails;
+    readonly kindName: string;
+    readonly entity: KindEntity;
+    constructor(kindName: string, entity: KindEntity, options?: Readonly<{
+        graphId?: string;
+        suggestion?: string;
+        cause?: unknown;
+    }>);
+}
+/**
+ * Details for NodeConstraintNotFoundError.
+ */
+type NodeConstraintNotFoundErrorDetails = Readonly<{
+    constraintName: string;
+    kind: string;
+}>;
+/**
+ * Thrown when a uniqueness constraint name is not found on a node kind.
+ */
+declare class NodeConstraintNotFoundError extends TypeGraphError {
+    readonly details: NodeConstraintNotFoundErrorDetails;
+    constructor(constraintName: string, kind: string, options?: {
+        cause?: unknown;
+    });
+}
+/**
+ * Details for NodeIndexNotFoundError.
+ */
+type NodeIndexNotFoundErrorDetails = Readonly<{
+    indexName: string;
+    kind: string;
+}>;
+/**
+ * Thrown when a declared node index name is not found on a node kind.
+ */
+declare class NodeIndexNotFoundError extends TypeGraphError {
+    readonly details: NodeIndexNotFoundErrorDetails;
+    constructor(indexName: string, kind: string, options?: {
+        cause?: unknown;
+    });
+}
+/**
+ * Details for EndpointNotFoundError.
+ */
+type EndpointNotFoundErrorDetails = Readonly<{
+    edgeKind: string;
+    endpoint: "from" | "to";
+    nodeKind: string;
+    nodeId: string;
+}>;
+/**
+ * Thrown when edge endpoint node does not exist or is deleted.
+ */
+declare class EndpointNotFoundError extends TypeGraphError {
+    readonly details: EndpointNotFoundErrorDetails;
+    constructor(details: EndpointNotFoundErrorDetails, options?: {
+        cause?: unknown;
+    });
+}
+/**
+ * Details for EndpointError.
+ */
+type EndpointErrorDetails = Readonly<{
+    edgeKind: string;
+    endpoint: "from" | "to";
+    actualKind: string;
+    expectedKinds: readonly string[];
+}>;
+/**
+ * Thrown when edge endpoint has wrong node type.
+ */
+declare class EndpointError extends TypeGraphError {
+    readonly details: EndpointErrorDetails;
+    constructor(details: EndpointErrorDetails, options?: {
+        cause?: unknown;
+    });
+}
+/**
+ * Details for UniquenessError.
+ */
+type UniquenessErrorDetails = Readonly<{
+    constraintName: string;
+    kind: string;
+    existingId: string;
+    newId: string;
+    fields: readonly string[];
+    /**
+     * The claim row's `node_kind` — the axis this violation was found at.
+     * Optional so a third-party backend implementing the documented "throws
+     * `UniquenessError`" contract keeps working unchanged; when a throw site
+     * omits it, a caller loses only the disambiguation this field exists for,
+     * never correctness of the refusal itself.
+     *
+     * `constraintName` alone cannot tell two disjoint pairs apart — every
+     * `disjointWith` pair shares the single reserved `DISJOINT_CONSTRAINT_NAME`
+     * — so `mapClaimRefusal` (`store/claims/node-claims.ts`) matches on this
+     * field together with `constraintName` and the key, which is exactly the
+     * claim row's primary key and therefore unambiguous.
+     */
+    axis?: string;
+}>;
+/**
+ * Thrown when uniqueness constraint is violated.
+ */
+declare class UniquenessError extends TypeGraphError {
+    readonly details: UniquenessErrorDetails;
+    constructor(details: UniquenessErrorDetails, options?: {
+        cause?: unknown;
+    });
+}
+/**
+ * Details for CardinalityError.
+ */
+type CardinalityErrorDetails = Readonly<{
+    edgeKind: string;
+    fromKind: string;
+    fromId: string;
+    cardinality: string;
+    existingCount: number;
+}>;
+/**
+ * Thrown when cardinality constraint is violated.
+ */
+declare class CardinalityError extends TypeGraphError {
+    readonly details: CardinalityErrorDetails;
+    constructor(details: CardinalityErrorDetails, options?: {
+        cause?: unknown;
+    });
+}
+/**
+ * Details for DisjointError.
+ */
+type DisjointErrorDetails = Readonly<{
+    nodeId: string;
+    attemptedKind: string;
+    conflictingKind: string;
+}>;
+/**
+ * Thrown when disjointness constraint is violated.
+ *
+ * Disjoint types cannot share the same ID - a node cannot be both
+ * a Person and an Organization if they are declared disjoint.
+ */
+declare class DisjointError extends TypeGraphError {
+    readonly details: DisjointErrorDetails;
+    constructor(details: DisjointErrorDetails, options?: {
+        cause?: unknown;
+    });
+}
+type IdentityContradictionErrorDetails = Readonly<{
+    /**
+     * The identity write that could not stand. `merge` is the post-write
+     * affected-class assertion a graph merge runs inside its commit
+     * transaction, which names the whole merge rather than a single assertion
+     * because the contradiction is a property of the state the merge would
+     * leave behind.
+     */
+    operation: "assertSame" | "assertDifferent" | "fold" | "import" | "merge";
+    a: Readonly<{
+        kind: string;
+        id: string;
+    }>;
+    b: Readonly<{
+        kind: string;
+        id: string;
+    }>;
+    reason: "different-assertion" | "same-class" | "disjoint-kinds";
+    conflictingAssertionId?: string;
+    conflictingKinds?: readonly [string, string];
+}>;
+/** Thrown when an identity mutation would make the ledger contradictory. */
+declare class IdentityContradictionError extends TypeGraphError {
+    readonly details: IdentityContradictionErrorDetails;
+    constructor(details: IdentityContradictionErrorDetails, options?: Readonly<{
+        cause?: unknown;
+    }>);
+}
+type IdentityValidityWindowErrorDetails = Readonly<{
+    reason: "future-valid-from" | "future-valid-to" | "inverted" | "overlapping-open-window";
+    validFrom: string;
+    validTo?: string;
+    operationInstant: string;
+}>;
+/** Thrown when an identity assertion validity window cannot be applied. */
+declare class IdentityValidityWindowError extends TypeGraphError {
+    readonly details: IdentityValidityWindowErrorDetails;
+    constructor(details: IdentityValidityWindowErrorDetails);
+}
+type IdentityEndpointValidityErrorDetails = Readonly<{
+    endpoint: Readonly<{
+        kind: string;
+        id: string;
+    }>;
+    assertionWindow: Readonly<{
+        validFrom: string;
+        validTo?: string;
+    }>;
+    endpointWindow: Readonly<{
+        validFrom?: string;
+        validTo?: string;
+        deletedAt?: string;
+    }>;
+}>;
+/** Thrown when an identity endpoint does not exist throughout the assertion window. */
+declare class IdentityEndpointValidityError extends TypeGraphError {
+    readonly details: IdentityEndpointValidityErrorDetails;
+    constructor(details: IdentityEndpointValidityErrorDetails);
+}
+type IdentitySeparationViolationErrorDetails = Readonly<{
+    graphId: string;
+    /**
+     * `"database"` when the CHECK constraint on the separation relation aborted
+     * the write — the backstop firing as designed. `"writer"` when the write was
+     * accepted, which means the relation was provisioned without its constraint
+     * and only the writer's own re-check caught the contradiction.
+     */
+    enforcedBy: "database" | "writer";
+    /** The single class key both endpoints collapsed onto. */
+    classKey: string;
+    /** The `different` assertion whose endpoints landed in one class. */
+    assertionId: string;
+    a: Readonly<{
+        kind: string;
+        id: string;
+    }>;
+    b: Readonly<{
+        kind: string;
+        id: string;
+    }>;
+}>;
+/**
+ * Thrown when the derived separation relation refuses a write that would place
+ * both endpoints of a current `different` assertion in one identity class.
+ *
+ * This is the database-level backstop beneath the plan-time simulation and the
+ * applier's validation. Reaching it means an earlier layer let a contradiction
+ * through: the transaction is aborted rather than committed, but the layer that
+ * should have refused it typed and early is worth investigating.
+ */
+declare class IdentitySeparationViolationError extends TypeGraphError {
+    readonly details: IdentitySeparationViolationErrorDetails;
+    constructor(details: IdentitySeparationViolationErrorDetails, options?: Readonly<{
+        cause?: unknown;
+    }>);
+}
+/**
+ * Details for RestrictedDeleteError.
+ */
+type RestrictedDeleteErrorDetails = Readonly<{
+    nodeKind: string;
+    nodeId: string;
+    edgeCount: number;
+    edgeKinds: readonly string[];
+}>;
+/**
+ * Thrown when deletion is blocked due to existing edges (restrict behavior).
+ */
+declare class RestrictedDeleteError extends TypeGraphError {
+    readonly details: RestrictedDeleteErrorDetails;
+    constructor(details: RestrictedDeleteErrorDetails, options?: {
+        cause?: unknown;
+    });
+}
+/**
+ * Details for VersionConflictError.
+ */
+type VersionConflictErrorDetails = Readonly<{
+    kind: string;
+    id: string;
+    expectedVersion: number;
+    actualVersion: number;
+}>;
+/**
+ * Thrown when optimistic locking detects a concurrent modification.
+ *
+ * This occurs when two operations try to update the same entity simultaneously.
+ * The operation with the stale version fails.
+ */
+declare class VersionConflictError extends TypeGraphError {
+    readonly details: VersionConflictErrorDetails;
+    constructor(details: VersionConflictErrorDetails, options?: {
+        cause?: unknown;
+    });
+}
+/**
+ * Details for SchemaMismatchError.
+ */
+type SchemaMismatchErrorDetails = Readonly<{
+    graphId: string;
+    expectedHash: string;
+    actualHash: string;
+}>;
+/**
+ * Thrown when the schema in code doesn't match the schema in the database.
+ */
+declare class SchemaMismatchError extends TypeGraphError {
+    readonly details: SchemaMismatchErrorDetails;
+    constructor(details: SchemaMismatchErrorDetails, options?: {
+        cause?: unknown;
+    });
+}
+/**
+ * Details for MigrationError.
+ */
+/**
+ * Why a migration operation failed. A stable discriminant so callers can
+ * branch on the outcome instead of matching the message text, which is free
+ * to be reworded in any release.
+ */
+declare const MIGRATION_FAILURE_REASONS: readonly ["schema-behind", "breaking-change", "no-active-version", "version-not-found", "kind-removal"];
+type MigrationFailureReason = (typeof MIGRATION_FAILURE_REASONS)[number];
+/**
+ * Structured context for a {@link MigrationError}, discriminated on `reason`.
+ *
+ * Modelled as a union rather than one shape with optional fields so the
+ * payload a reason promises is the payload it must carry: narrowing on
+ * `reason === "kind-removal"` gives you a non-optional `droppedKinds`, and the
+ * constructor cannot be handed a `kind-removal` without one.
+ *
+ * The common fields are repeated per member rather than factored into a shared
+ * base alias, which would be a hoisted-unexported symbol on the public
+ * entrypoint.
+ */
+type MigrationErrorDetails = Readonly<{
+    graphId: string;
+    fromVersion: number;
+    toVersion: number;
+    /** Stable discriminant — branch on this, not the message. */
+    reason: "schema-behind" | "breaking-change";
+    /**
+     * The structured diff behind the failure. Carries per-change `severity`
+     * alongside `hasChanges` / `hasBreakingChanges`, so a caller can decide
+     * "additive → proceed, incompatible → ask the user" without re-querying.
+     */
+    diff?: SchemaDiff;
+}> | Readonly<{
+    graphId: string;
+    fromVersion: number;
+    toVersion: number;
+    reason: "no-active-version" | "version-not-found";
+}> | Readonly<{
+    graphId: string;
+    fromVersion: number;
+    toVersion: number;
+    reason: "kind-removal";
+    /**
+     * The dropped kinds that still held rows, and so caused the refusal. A
+     * kind the commit drops but that is already empty is permitted and does
+     * NOT appear here. Both lists are sorted; at least one is non-empty.
+     */
+    droppedKinds: Readonly<{
+        nodes: readonly string[];
+        edges: readonly string[];
+    }>;
+}>;
+/**
+ * Thrown when schema migration fails.
+ */
+declare class MigrationError extends TypeGraphError {
+    readonly details: MigrationErrorDetails;
+    constructor(message: string, details: MigrationErrorDetails, options?: {
+        cause?: unknown;
+    });
+}
+/**
+ * Details for EagerMaterializationError.
+ */
+type EagerMaterializationErrorDetails = Readonly<{
+    graphId: string;
+    failedIndexNames: readonly string[];
+}>;
+/**
+ * Thrown by `Store.evolve(extension, { eager })` when the schema
+ * commit succeeded but the follow-on `materializeIndexes()` produced
+ * one or more failed entries.
+ *
+ * Recovery: the schema commit is NOT rolled back. The new `Store` is
+ * fully constructed and (when `options.ref` was supplied) `ref.current`
+ * already points to it — the caller can read the new store via the ref
+ * and decide how to handle the failed indexes (retry, skip, alert).
+ * The full `MaterializeIndexesResult` is attached as `.materialization`.
+ *
+ * @example
+ * ```ts
+ * const ref = { current: store };
+ * try {
+ *   await store.evolve(extension, { ref, eager: {} });
+ * } catch (error) {
+ *   if (error instanceof EagerMaterializationError) {
+ *     // schema is committed; ref.current is the new store
+ *     log.warn(
+ *       { failed: error.failedIndexNames },
+ *       "indexes did not materialize; will retry",
+ *     );
+ *     await ref.current.materializeIndexes();
+ *   } else {
+ *     throw error;
+ *   }
+ * }
+ * ```
+ */
+declare class EagerMaterializationError extends TypeGraphError {
+    readonly details: EagerMaterializationErrorDetails;
+    /**
+     * The full materialization result, including successful and failed
+     * entries. Same shape as `Store.materializeIndexes()` returns.
+     */
+    readonly materialization: MaterializeIndexesResult;
+    constructor(materialization: MaterializeIndexesResult, graphId: string);
+    /**
+     * Names of just the indexes that failed — derived from
+     * `materialization.results` so the two views can never disagree.
+     */
+    get failedIndexNames(): readonly string[];
+}
+/**
+ * Details for StaleVersionError. `actual` is the active version the rejecting
+ * read observed, and is `0` only when the graph genuinely has no active version
+ * (an initial-commit race where another writer initialized first, or a graph
+ * whose schema rows were removed out of band). A concurrent advance always
+ * reports the newly active version, so `0` is a reliable signal of absence
+ * rather than of contention.
+ */
+type StaleVersionErrorDetails = Readonly<{
+    graphId: string;
+    expected: number;
+    actual: number;
+}>;
+/**
+ * Thrown by `commitSchemaVersion`, `setActiveVersion`, and the schema write
+ * fence a schema-managed Store write takes, when the caller's view of the
+ * active schema version is out of date — another writer has already advanced
+ * it.
+ *
+ * Recovery: re-read the active version with `getActiveSchema(graphId)`,
+ * recompute against the new baseline, and retry. This is a routine
+ * concurrency signal, not a bug.
+ */
+declare class StaleVersionError extends TypeGraphError {
+    readonly details: StaleVersionErrorDetails;
+    constructor(details: StaleVersionErrorDetails, options?: {
+        cause?: unknown;
+    });
+}
+/**
+ * Details for SchemaContentConflictError.
+ */
+type SchemaContentConflictErrorDetails = Readonly<{
+    graphId: string;
+    version: number;
+    existingHash: string;
+    incomingHash: string;
+}>;
+/**
+ * Thrown by `commitSchemaVersion` when a row already exists at the
+ * target version with a *different* schema hash — i.e. two writers
+ * committed materially different schemas at the same version number.
+ *
+ * Distinct from `StaleVersionError`: this is not a refetch-and-retry
+ * situation, it's a content disagreement that needs operator
+ * intervention. Typically caused by inconsistent application
+ * deployments writing schemas that hash differently.
+ */
+declare class SchemaContentConflictError extends TypeGraphError {
+    readonly details: SchemaContentConflictErrorDetails;
+    constructor(details: SchemaContentConflictErrorDetails, options?: {
+        cause?: unknown;
+    });
+}
+/**
+ * Thrown when graph configuration is invalid.
+ *
+ * This includes invalid schema definitions, ontology conflicts,
+ * and other configuration issues detected at graph creation time.
+ */
+declare class ConfigurationError extends TypeGraphError {
+    constructor(message: string, details?: Record<string, unknown>, options?: {
+        cause?: unknown;
+        suggestion?: string;
+    });
+}
+/**
+ * Why a destructive contribution rebuild is refused.
+ *
+ * - `vector-source-unavailable` — the projection is vector storage.
+ *   TypeGraph stores caller-supplied embeddings and nothing else: the
+ *   vectors exist only in the table a rebuild would drop, so there is no
+ *   source to reconstruct them from. Dropping anyway would silently
+ *   destroy the embeddings and hand back storage that looks healthy and
+ *   returns nothing. `store.reembedVectorField(kind, fieldPath, {
+ *   embed })` is the sanctioned destructive path — it takes the callback
+ *   that can regenerate what the drop destroys.
+ * - `no-drop-ddl` — the active strategy declares no `dropDdl` for the
+ *   contribution, so TypeGraph does not know how to tear its storage
+ *   down. Synthesizing a `DROP TABLE` from the resolved name would
+ *   guess at a teardown the strategy never sanctioned.
+ * - `no-schema-fence` — the backend exposes no transactional schema
+ *   fence (`schemaWriteTransaction`), so the drop, recreate, refill, and
+ *   stamp could not be made atomic. Running them unfenced could leave
+ *   storage attested but empty, or a concurrent schema writer
+ *   interleaved with the drop.
+ * - `shared-storage-in-use` — the contribution's recorded shape is stale,
+ *   so only recreating its storage repairs it, but that storage is one
+ *   table holding other graphs' rows as well. Their content is derived
+ *   from their own nodes through their own schemas, so this process cannot
+ *   put it back. A rebuild that dropped anyway would leave every other
+ *   graph's search silently empty; one that re-stamped this graph's marker
+ *   without the drop would bless a physical shape nothing verified.
+ */
+type ContributionRebuildRefusal = "vector-source-unavailable" | "no-drop-ddl" | "no-schema-fence" | "shared-storage-in-use";
+/**
+ * Thrown when `store.rebuildContribution()` cannot honor a rebuild.
+ *
+ * A refusal, never a partial attempt: nothing has been dropped when this
+ * throws. The point is that the alternative — proceeding — destroys data
+ * that cannot be reconstructed, so the operation declines instead of
+ * quietly doing less than its name promises.
+ */
+declare class ContributionRebuildUnsupportedError extends TypeGraphError {
+    readonly reason: ContributionRebuildRefusal;
+    constructor(reason: ContributionRebuildRefusal, details?: Readonly<Record<string, unknown>>, options?: {
+        cause?: unknown;
+    });
+}
+/**
+ * Thrown when an iterative graph algorithm exhausts its caller-visible round
+ * budget before reaching its convergence predicate.
+ */
+declare class GraphAlgorithmConvergenceError extends TypeGraphError {
+    constructor(algorithm: string, maxIterations: number, options?: Readonly<{
+        oscillating?: boolean;
+    }>);
+}
+/** Stable reasons a weighted traversal can reject an edge's weight value. */
+type InvalidEdgeWeightReason = "missing" | "negative" | "non_numeric" | "out_of_range";
+/** Details for InvalidEdgeWeightError. */
+type InvalidEdgeWeightErrorDetails = Readonly<{
+    /** Id of the first offending edge, in binary-collation order. */
+    edgeId: string;
+    /** Kind of the offending edge. */
+    edgeKind: string;
+    /** The audited weight property. */
+    property: string;
+    /** Why the weight was rejected. */
+    reason: InvalidEdgeWeightReason;
+    /** The offending value, when one was present and renderable. */
+    value?: string;
+}>;
+/**
+ * Thrown when a weighted graph algorithm finds an edge whose weight property
+ * violates the weighted-traversal contract (missing without a default,
+ * non-numeric, or negative). Raised before any traversal rounds run, so a
+ * weighted call either observes a fully valid weight domain or fails fast.
+ */
+declare class InvalidEdgeWeightError extends TypeGraphError {
+    readonly details: InvalidEdgeWeightErrorDetails;
+    constructor(details: InvalidEdgeWeightErrorDetails);
+}
+/** Thrown when an operation requires a backend capability it does not expose. */
+declare class UnsupportedBackendCapabilityError extends TypeGraphError {
+    constructor(operation: string, capability: string, details?: Readonly<Record<string, unknown>>, suggestion?: string);
+}
+/** Stable reasons an intentionally trusted initial import can be rejected. */
+type TrustedImportErrorReason = "backend_unsupported" | "database_not_empty" | "fulltext_unsupported" | "history_unsupported" | "identity_unsupported" | "invalid_stream" | "revision_tracking_unsupported" | "uniqueness_unsupported" | "vector_unsupported";
+/** Thrown when the trusted initial-import contract is unavailable or violated. */
+declare class TrustedImportError extends TypeGraphError {
+    constructor(message: string, reason: TrustedImportErrorReason, details?: Readonly<Record<string, unknown>>, options?: Readonly<{
+        cause?: unknown;
+        suggestion?: string;
+    }>);
+}
+/**
+ * Thrown to a graph export stream's consumer when the caller's `AbortSignal`
+ * settled the stream instead of it reaching its end.
+ *
+ * Raised only after the export has given back everything it took, so receiving
+ * it means the connection is already usable again. WHAT it took depends on the
+ * backend: an export on one reporting `capabilities.transactions` holds a
+ * repeatable-read snapshot (and, on a serialized connection, that connection's
+ * stream lease), and both are settled before this is thrown; an export on a
+ * backend without transactions holds neither, and its remaining reads are
+ * simply abandoned — its already-delivered chunks were never one snapshot to
+ * begin with. The message says which case applies. `cause` carries the signal's
+ * own `reason` when the caller supplied one.
+ */
+declare class ExportStreamCancelledError extends TypeGraphError {
+    constructor(message: string, details?: Readonly<Record<string, unknown>>, options?: Readonly<{
+        cause?: unknown;
+        suggestion?: string;
+    }>);
+}
+/**
+ * Thrown when an export stream's consumer leaves a delivered chunk
+ * unacknowledged for longer than its configured idle timeout.
+ *
+ * The timeout measures consumer idleness only: it starts when a chunk is
+ * yielded and stops when the consumer asks for the next one. Receiving this
+ * error means the timed-out export has settled its snapshot transaction and
+ * released any serialized connection lease it held. `details.idleTimeoutMs`
+ * carries the configured bound.
+ */
+declare class ExportStreamIdleTimeoutError extends TypeGraphError {
+    constructor(graphId: string, idleTimeoutMs: number, transactional: boolean);
+}
+/**
+ * The stable `details.code` values raised by the recorded-capture guards on a
+ * history- or revision-tracked store. These are the sanctioned branch points
+ * for a portable caller that must pick a transaction strategy without
+ * substring-matching {@link ConfigurationError} messages.
+ *
+ * - `RECORDED_CAPTURE_REQUIRES_CALLBACK_TRANSACTION`: `store.withTransaction`
+ *   was called on a history-enabled store, which has no flush point before the
+ *   caller commits — use `store.withRecordedTransaction` instead.
+ * - `RECORDED_CAPTURE_RAW_SQL_DISABLED`: a raw SQL escape (`tx.sql`,
+ *   `backend.executeStatement`/`executeDdl`) was reached on a history-enabled
+ *   store, where it would bypass recorded-time capture.
+ * - `REVISION_TRACKING_RAW_SQL_DISABLED`: the same raw SQL escape on a
+ *   revision-tracked store, where it would bypass the revision anchor.
+ *
+ * @see isRecordedCaptureGuardError
+ */
+declare const RECORDED_CAPTURE_GUARD_CODES: readonly ["RECORDED_CAPTURE_REQUIRES_CALLBACK_TRANSACTION", "RECORDED_CAPTURE_RAW_SQL_DISABLED", "REVISION_TRACKING_RAW_SQL_DISABLED"];
+/** A stable, branchable code raised by a recorded-capture guard. */
+type RecordedCaptureGuardCode = (typeof RECORDED_CAPTURE_GUARD_CODES)[number];
+/**
+ * A {@link ConfigurationError} narrowed to carry a {@link RecordedCaptureGuardCode}
+ * in `details.code` — the shape {@link isRecordedCaptureGuardError} guarantees.
+ * `C` narrows `details.code` to a single code when the guard was called with a
+ * specific one; it defaults to the full union.
+ */
+type RecordedCaptureGuardError<C extends RecordedCaptureGuardCode = RecordedCaptureGuardCode> = ConfigurationError & Readonly<{
+    details: Readonly<{
+        code: C;
+    }>;
+}>;
+/**
+ * Type guard for the recorded-capture guard errors, so a portable caller can
+ * branch on the invariant a store enforced instead of substring-matching the
+ * message. Pass `code` to narrow to a single guard; omit it to match any.
+ *
+ * Distinguishes "history capture forbids raw SQL here" from "this backend has
+ * no transactions" (the latter carries no guard code — see
+ * `TransactionContext.sqlAvailability` for the capability discriminant).
+ *
+ * Passing `code` also narrows `details.code` to that literal on the guarded
+ * branch, so a caller can read the payload without re-checking.
+ *
+ * @example
+ * ```typescript
+ * // `withTransaction` is a compile error on a history-enabled store, so widen
+ * // to the base Store surface to reach the runtime guard this branches on.
+ * const store: Store<typeof graph> = historyStore;
+ * try {
+ *   store.withTransaction(externalTx);
+ * } catch (error) {
+ *   if (
+ *     isRecordedCaptureGuardError(
+ *       error,
+ *       "RECORDED_CAPTURE_REQUIRES_CALLBACK_TRANSACTION",
+ *     )
+ *   ) {
+ *     // error.details.code is now the literal, not the union.
+ *     await historyStore.withRecordedTransaction(externalTx, run);
+ *   } else {
+ *     throw error;
+ *   }
+ * }
+ * ```
+ */
+declare function isRecordedCaptureGuardError<C extends RecordedCaptureGuardCode>(error: unknown, code: C): error is RecordedCaptureGuardError<C>;
+declare function isRecordedCaptureGuardError(error: unknown): error is RecordedCaptureGuardError;
+/**
+ * Why a store's strategy-owned storage is not usable on the current
+ * connection. Drives the {@link StoreNotInitializedError} message and
+ * is surfaced in `details.reason` for programmatic handling.
+ *
+ * - `missing`: no durable materialization marker exists — the database
+ *   was never initialized for this graph's runtime contributions.
+ * - `stale`: a marker exists but its recorded signature no longer
+ *   matches the resolved contribution DDL (strategy swap or DDL drift).
+ *   The hot path refuses rather than silently re-materializing.
+ * - `failed`: the most recent boot-time materialization attempt
+ *   recorded an error. Boot may retry; the hot path refuses.
+ */
+type StoreNotInitializedReason = "missing" | "stale" | "failed";
+/**
+ * Details for StoreNotInitializedError. `graphId`/`reason` are always
+ * present; callers may merge additional context (e.g. `logicalName`) via
+ * `options.details`.
+ */
+type StoreNotInitializedErrorDetails = Readonly<{
+    graphId: string;
+    reason: StoreNotInitializedReason;
+}> & Readonly<Record<string, unknown>>;
+/**
+ * Thrown when a fulltext- or vector-dependent operation runs against a
+ * connection whose strategy-owned storage has not been durably materialized.
+ *
+ * `createStore()` is a synchronous, zero-I/O attach: it never creates
+ * tables, repairs DDL, or writes materialization markers. The durable
+ * marker is written exclusively by the async boot path
+ * (`createStoreWithSchema`). When a fulltext or embedding read/write — or
+ * an adopted/business transaction — observes no valid marker, it refuses
+ * loudly here instead of lazily emitting DDL on the hot path.
+ */
+declare class StoreNotInitializedError extends TypeGraphError {
+    readonly details: StoreNotInitializedErrorDetails;
+    constructor(graphId: string, reason: StoreNotInitializedReason, options?: {
+        cause?: unknown;
+        details?: Readonly<Record<string, unknown>> & Readonly<{
+            graphId?: never;
+            reason?: never;
+        }>;
+    });
+}
+/** Details for a runtime contribution whose durable marker outlived storage. */
+type ContributionUnavailableErrorDetails = Readonly<{
+    graphId: string;
+    logicalName: "fulltext";
+    physicalName: string;
+    state: "physical-storage-missing";
+}>;
+/**
+ * Thrown when a gated fulltext operation discovers that materialized storage
+ * disappeared after its durable marker recorded successful initialization.
+ */
+declare class ContributionUnavailableError extends TypeGraphError {
+    readonly details: ContributionUnavailableErrorDetails;
+    constructor(graphId: string, physicalName: string, options?: Readonly<{
+        cause?: unknown;
+    }>);
+}
+/**
+ * Details for DatabaseOperationError.
+ */
+type DatabaseOperationErrorDetails = Readonly<{
+    operation: string;
+    entity: string;
     /**
-     * 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.
+     * `"duplicate_key"` means the engine refused the write because the entity's
+     * identity is already taken — the shape a concurrent create of the same new id
+     * produces on an engine that does not serialize the two writers. It is a
+     * *classified* driver failure, so callers that own a better error for the
+     * condition (the create paths, which report it as "already exists") translate
+     * it rather than surfacing it.
      */
-    extension: GraphExtension | undefined;
+    reason?: "no_row_returned" | "duplicate_key";
     /**
-     * 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.
+     * The entities the failed statement tried to insert, carried structurally so a
+     * translating caller never has to parse the driver's message for them. One
+     * element for a single insert; for a batch, every row in the failing chunk —
+     * the engine reports the collision without saying which row lost.
      */
-    deprecatedKinds: ReadonlySet<string>;
+    attempted?: readonly Readonly<{
+        kind: string;
+        id: string;
+    }>[];
 }>;
 /**
- * Extract node kind names from a GraphDef.
- */
-type NodeKinds<G extends GraphDef> = keyof G["nodes"] & string;
+ * Thrown when a database operation fails unexpectedly.
+ *
+ * This indicates a system-level failure in the database backend,
+ * not a user-recoverable error.
+ */
+declare class DatabaseOperationError extends TypeGraphError {
+    readonly details: DatabaseOperationErrorDetails;
+    constructor(message: string, details: DatabaseOperationErrorDetails, options?: {
+        cause?: unknown;
+    });
+}
 /**
- * Extract edge kind names from a GraphDef.
+ * Details for EmbeddingDimensionChangedError.
  */
-type EdgeKinds<G extends GraphDef> = keyof G["edges"] & string;
+type EmbeddingDimensionChangedErrorDetails = Readonly<{
+    kind: string;
+    fieldPath: string;
+    declaredDimensions?: number;
+    storedDimensions?: number;
+}>;
+/**
+ * Thrown when an embedding field's declared dimension no longer matches the
+ * dimension of its materialized per-field storage — i.e. a field's
+ * `embedding(N)` was changed to `embedding(M)`. The stored vectors are invalid
+ * under the new dimension and cannot be converted, only recomputed, so this is
+ * a deliberate app-driven migration: call
+ * `store.reembedVectorField(kind, fieldPath, ...)` to recreate the storage at
+ * the new dimension and re-embed existing rows.
+ */
+declare class EmbeddingDimensionChangedError extends TypeGraphError {
+    readonly details: EmbeddingDimensionChangedErrorDetails;
+    constructor(message: string, details: EmbeddingDimensionChangedErrorDetails, options?: {
+        cause?: unknown;
+    });
+}
 /**
- * Get a NodeType from a GraphDef by kind name.
+ * Thrown when a query predicate cannot be compiled for the target database.
  */
-type GetNodeType<G extends GraphDef, K extends NodeKinds<G>> = G["nodes"][K]["type"];
+declare class UnsupportedPredicateError extends TypeGraphError {
+    constructor(message: string, details?: Readonly<Record<string, unknown>>, options?: {
+        cause?: unknown;
+        suggestion?: string;
+    });
+}
 /**
- * Get an EdgeType from a GraphDef by kind name.
+ * Thrown when a compiler invariant is violated.
+ *
+ * This indicates a bug in the query compiler — the compiler reached
+ * a state that should be unreachable. These errors are not user-recoverable.
  */
-type GetEdgeType<G extends GraphDef, K extends EdgeKinds<G>> = G["edges"][K]["type"];
+declare class CompilerInvariantError extends TypeGraphError {
+    constructor(message: string, details?: Readonly<Record<string, unknown>>, options?: {
+        cause?: unknown;
+    });
+}
 /**
- * Get all NodeTypes from a GraphDef.
+ * Thrown when an operation is attempted on a backend that has been disposed.
+ *
+ * This typically occurs during runtime teardown — for example, when a
+ * Cloudflare Workers test runner resets Durable Object storage while
+ * the TypeGraph backend still has queued operations.
+ */
+declare class BackendDisposedError extends TypeGraphError {
+    constructor(options?: {
+        cause?: unknown;
+    });
+}
+/**
+ * Thrown when a statement is issued on a transaction-scoped backend after
+ * its transaction boundary has already returned.
+ *
+ * The usual source is a callback that lets work escape it. `Promise.all`
+ * rejects on its first rejection while its siblings keep running, so
+ *
+ * ```typescript
+ * await store.transaction(async (tx) => {
+ *   await Promise.all([tx.nodes.Doc.create(a), tx.nodes.Doc.create(b)]);
+ * });
+ * ```
+ *
+ * leaves `b`'s remaining statements in flight when `a` fails. Those
+ * statements have nowhere safe to go: the driver is about to emit `ROLLBACK`
+ * on the same pinned connection and then hand it back to the pool, where a
+ * late arrival would execute inside somebody else's transaction. TypeGraph
+ * refuses them here instead.
+ *
+ * The error is normally invisible — `Promise.all` has already rejected with
+ * the original failure, and discards this one.
  */
-type AllNodeTypes<G extends GraphDef> = {
-    [K in NodeKinds<G>]: G["nodes"][K]["type"];
-}[NodeKinds<G>];
+declare class TransactionClosedError extends TypeGraphError {
+    constructor(options?: {
+        cause?: unknown;
+    });
+}
 /**
- * Get all EdgeTypes from a GraphDef.
+ * Type guard for TypeGraphError.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await store.nodes.Person.create({});
+ * } catch (error) {
+ *   if (isTypeGraphError(error)) {
+ *     console.log(error.code, error.category);
+ *   }
+ * }
+ * ```
  */
-type AllEdgeTypes<G extends GraphDef> = {
-    [K in EdgeKinds<G>]: G["edges"][K]["type"];
-}[EdgeKinds<G>];
+declare function isTypeGraphError(error: unknown): error is TypeGraphError;
 /**
- * Creates a graph definition.
+ * Check if error is recoverable by user action (user or constraint error).
+ *
+ * User-recoverable errors can typically be resolved by:
+ * - Fixing invalid input data
+ * - Using different IDs or values
+ * - Deleting conflicting data first
  *
  * @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",
- *   },
- * });
+ * if (isUserRecoverable(error)) {
+ *   showErrorToUser(error.toUserMessage());
+ * } else {
+ *   logAndAlertOps(error);
+ * }
  * ```
  */
-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>;
+declare function isUserRecoverable(error: unknown): boolean;
 /**
- * Checks if a value is a GraphDef.
+ * Check if error indicates a system/infrastructure issue.
+ *
+ * System errors typically require:
+ * - Retry logic (for transient failures)
+ * - Investigation (for persistent failures)
+ * - Ops team notification
  */
-declare function isGraphDef(value: unknown): value is GraphDef;
+declare function isSystemError(error: unknown): boolean;
 /**
- * Gets all node kind names from a GraphDef.
+ * Check if error is a constraint violation.
  */
-declare function getNodeKinds<G extends GraphDef>(graph: G): readonly (keyof G["nodes"] & string)[];
+declare function isConstraintError(error: unknown): boolean;
 /**
- * Gets all edge kind names from a GraphDef.
+ * Extract suggestion from error if available.
  */
-declare function getEdgeKinds<G extends GraphDef>(graph: G): readonly (keyof G["edges"] & string)[];
+declare function getErrorSuggestion(error: unknown): string | undefined;
+
+/**
+ * The `recursiveTraversal` capability: whether this engine can compute a
+ * BOUNDED TRANSITIVE CLOSURE of a relation in one round trip — the traversal
+ * primitive, not the SQL syntax.
+ */
+
+/**
+ * Whether this engine can compute a BOUNDED TRANSITIVE CLOSURE of a relation
+ * in one round trip — the traversal primitive, not the SQL syntax. A SQL
+ * engine satisfies it with `WITH RECURSIVE`; a graph-native engine satisfies
+ * it with a native expansion operator. What the capability promises is the
+ * SEMANTICS: given a seed set, a step relation, and a hop bound, the engine
+ * returns the reachable set (optionally with depth and path) without the
+ * client issuing one statement per hop.
+ *
+ * Absent means SUPPORTED. Every engine TypeGraph ships supports it, and every
+ * custom backend already has the six emission sites run against it
+ * unconditionally: making absence mean `false` would refuse traversals that
+ * work today. This mirrors `returning`, not `constraintClaims` — absence is
+ * only allowed to mean "false" where absence is SAFE, and here it is not. A
+ * backend that genuinely lacks the primitive must say so.
+ */
+type RecursiveTraversalCapability = Readonly<{
+    supported: boolean;
+    /**
+     * Why the engine lacks it — surfaced in every refusal's details so the
+     * state is named rather than implied. Required when `supported: false` and
+     * forbidden when `true`, so the union cannot carry a dangling reason.
+     */
+    reason?: string;
+}>;
+/**
+ * The brand. Declared but never exported, and never assigned at runtime — it
+ * exists only so that an object literal outside this module is not assignable
+ * to {@link RecursiveTraversalVerdict}. Compare `VectorSlot`'s construction
+ * discipline: the type is public, the constructor is the seam.
+ */
+declare const RECURSIVE_TRAVERSAL_VERDICT: unique symbol;
+/**
+ * The decision, branded so it can only originate from this module's
+ * constructors. Round 1 made the verdict a required *field*, which forces a
+ * token, not a verdict: any caller could satisfy it by writing
+ * `{ supported: true }` inline, and nothing tied the value to the resolver.
+ * The brand closes that at the type level.
+ */
+type RecursiveTraversalVerdict = Readonly<{
+    [RECURSIVE_TRAVERSAL_VERDICT]: true;
+} & ({
+    supported: true;
+} | {
+    supported: false;
+    reason: string;
+})>;
+/** THE one reader of `capabilities.recursiveTraversal`, and THE one constructor. */
+declare function resolveRecursiveTraversal(capabilities: BackendCapabilities): RecursiveTraversalVerdict;
+/**
+ * The ONE sanctioned way to obtain a verdict without a backend: the query
+ * compiler's public entry point `compileQuery(ast, graphId, "postgres")`
+ * takes no backend at all, so it has no capabilities to resolve from. The
+ * reason string is required and is echoed in nothing — it exists so the call
+ * site states why it is allowed to assume.
+ */
+declare function assumeRecursiveTraversalSupported(reason: string): RecursiveTraversalVerdict;
+/** THE one refusal builder. */
+declare function recursiveTraversalUnsupportedError(verdict: Extract<RecursiveTraversalVerdict, {
+    supported: false;
+}>, operation: string): ConfigurationError;
+/** THE one assertion: refuses when the verdict says the engine cannot. */
+declare function assertRecursiveTraversal(verdict: RecursiveTraversalVerdict, operation: string): asserts verdict is Extract<RecursiveTraversalVerdict, {
+    supported: true;
+}>;
 
 /**
  * JSON Schema type (subset used by Zod toJSONSchema).
@@ -2235,6 +3716,91 @@ type SerializedSchema = Readonly<{
  */
 type SchemaHash = string;
 
+/**
+ * The two independent facts a backend can report about concurrent-writer
+ * serialization.
+ */
+type PessimisticLockCapabilities = Readonly<{
+    /** `pg_advisory_xact_lock`-style keyed locks scoped to the transaction. */
+    advisoryLocks: boolean;
+    /** `LOCK TABLE … IN … MODE`-style relation locks. */
+    tableLocks: boolean;
+    /**
+     * The engine serializes concurrent writers by construction (SQLite's single
+     * writer slot). This is what makes "take no lock" CORRECT on SQLite and
+     * WRONG on an engine with neither locks nor a slot.
+     */
+    serializedWriters: boolean;
+}>;
+/**
+ * The decision every lock site consumes, rather than a flag a caller would
+ * have to re-derive.
+ */
+type WriteFencePlan = 
+/** Take the keyed/table lock. */
+Readonly<{
+    kind: "lock";
+    advisoryLocks: true;
+    tableLocks: boolean;
+}>
+/** No lock needed: the engine serializes writers. */
+ | Readonly<{
+    kind: "engine-serialized";
+}>
+/** Neither. Every non-degradable fence refuses. */
+ | Readonly<{
+    kind: "unfenced";
+}>;
+/**
+ * What `resolveWriteFencePlan` needs: the dialect (for the first-party
+ * dialect-derivation arm and for the refusal message) and the declared
+ * capabilities. Structural on purpose — see the module-private first-party
+ * mark below, which is carried out-of-band rather than as a type member.
+ */
+type WriteFenceTarget = Readonly<{
+    dialect: SqlDialect;
+    capabilities: BackendCapabilities;
+}>;
+/**
+ * THE one reader of `capabilities.pessimisticLocks`, and THE one constructor
+ * of a {@link WriteFencePlan}.
+ *
+ * Resolution order:
+ *
+ * 1. **Declared** — use the declaration. Every first-party backend declares
+ *    `pessimisticLocks` (`SQLITE_CAPABILITIES` / `POSTGRES_CAPABILITIES`),
+ *    and a custom backend takes this path by writing one line.
+ * 2. **Absent, first-party factory** — derive from `dialect`
+ *    (`postgres` → `{advisoryLocks:true,tableLocks:true,serializedWriters:false}`,
+ *    `sqlite` → `{advisoryLocks:false,tableLocks:false,serializedWriters:true}`),
+ *    which is exactly what every lock site used to compute inline. After
+ *    A1/A2 land, nothing in-tree reaches this arm — both bundled factories
+ *    declare `pessimisticLocks` unconditionally — so it is reachable only
+ *    from tests that build a backend object bypassing the factories'
+ *    declared capabilities while still carrying the first-party mark.
+ * 3. **Absent, anything else** — `unfenced`. Conservative: an undeclared
+ *    custom backend is by definition uncertified, and inferring lock support
+ *    from `dialect` alone is the unsound inference this capability replaces
+ *    (a Doltgres-shaped backend reporting `dialect: "postgres"` need not
+ *    honor `pg_advisory_xact_lock`).
+ */
+declare function resolveWriteFencePlan(target: WriteFenceTarget): WriteFencePlan;
+/**
+ * THE refusal for a fence that cannot degrade: `unfenced` always refuses,
+ * and a `lock` plan that lacks the table lock an operation requires refuses
+ * too — the declared-advisory-only posture, which T15 exercises as its own
+ * matrix row.
+ *
+ * `engine-serialized` satisfies both requirements: the writer slot is the
+ * fence, whichever shape of lock the caller would otherwise have taken.
+ *
+ * @throws {ConfigurationError} under `unfenced`, and under
+ * `kind: "lock" && tableLocks === false` when `requires === "table-lock"`.
+ */
+declare function requireWriteFence(plan: WriteFencePlan, operation: string, requires: "advisory-lock" | "table-lock"): Extract<WriteFencePlan, {
+    kind: "lock" | "engine-serialized";
+}>;
+
 /**
  * Backend interface types for TypeGraph storage.
  *
@@ -2501,6 +4067,20 @@ type BackendCapabilities = Readonly<{
      * budget applies.
      */
     maxBindParameters?: number;
+    /**
+     * Whether this backend supplies the claim relations that fence declared
+     * constraints (`uniques`, re-keyed onto claim axes, plus
+     * `typegraph_edge_claims`) AND implements the claim members.
+     *
+     * Absent means `false`: the backend predates the claim relations, keeps every
+     * fence it has today, and is listed as such in the parity matrix. Never
+     * INFERRED from member presence — a projection that forwarded `capabilities`
+     * while dropping a method would otherwise yield a verdict read from a
+     * different object than the write goes to. `claimSupport`
+     * (`store/claims/backing.ts`) is the one reader, and it refuses a backend
+     * whose declaration and surface disagree in either direction.
+     */
+    readonly constraintClaims?: boolean;
     /** Vector search capabilities (undefined if not configured) */
     vector?: VectorCapabilities | undefined;
     /** Fulltext search capabilities (undefined if not configured) */
@@ -2513,6 +4093,50 @@ type BackendCapabilities = Readonly<{
      * equivalent to every member `false`).
      */
     contributions?: ContributionCapabilities | undefined;
+    /**
+     * Whether this engine can compute a bounded transitive closure of a
+     * relation in one round trip (a recursive CTE, or a graph-native
+     * expansion operator).
+     *
+     * Absent means SUPPORTED. Every engine TypeGraph ships supports it, and
+     * every custom backend on this release already has every recursion site
+     * run against it unconditionally: making absence mean `false` would
+     * refuse traversals that work today. See
+     * {@link RecursiveTraversalCapability} for the full contract.
+     */
+    recursiveTraversal?: RecursiveTraversalCapability | undefined;
+    /**
+     * Whether this engine can serialize concurrent writers, and how: keyed
+     * advisory locks, relation-level table locks, or a single writer slot that
+     * serializes by construction.
+     *
+     * Absent means `unfenced` for any backend the first-party factories did
+     * not build (`resolveWriteFencePlan`, `src/backend/capabilities/write-fence.ts`):
+     * an undeclared custom backend is refused at construction for Operational
+     * Identity and for TypeGraph-owned recorded-clock allocation
+     * (`history` / `revisionTracking`) rather than silently emitting locks the
+     * engine may not honor. Every first-party backend declares this member
+     * (`SQLITE_CAPABILITIES`, `POSTGRES_CAPABILITIES`), so the refusal is
+     * reachable only by a backend this library did not build.
+     */
+    pessimisticLocks?: PessimisticLockCapabilities | undefined;
+    /**
+     * Who allocates recorded-time revisions. `"typegraph-relations"` (the
+     * default, and every first-party backend) means TypeGraph owns a clock row
+     * and performs the read/advance/write that `lockRecordedClock` fences —
+     * which is undegradable, so an `unfenced` engine is refused at
+     * construction. `"engine-native"` means the engine supplies the recorded
+     * axis itself (WS9's ruled BraidDB posture: pinned-handle `AS OF`).
+     *
+     * TODAY THE ENGINE-NATIVE READ/WRITE PATH DOES NOT EXIST YET (follow-up
+     * F8, owned by WS9). The capture path allocates the TypeGraph clock
+     * unconditionally, so declaring `"engine-native"` and enabling
+     * clock-allocating history/revision tracking is refused at construction by
+     * its own typed error naming the interim state
+     * (`refuseEngineNativeRecordedTimeNotYetImplemented`,
+     * `src/backend/capabilities/recorded-time-ownership.ts`).
+     */
+    recordedTimeOwnership?: "typegraph-relations" | "engine-native";
 }>;
 /** Keeps session-scoped analytics honest when a required SQL feature is absent. */
 declare function normalizeGraphAnalyticsCapabilities(capabilities: BackendCapabilities): BackendCapabilities;
@@ -3659,6 +5283,67 @@ type IdentityTableNames = Readonly<{
     identityClosure: string;
     identitySeparation: string;
 }>;
+/**
+ * The physical names of the three recorded relations. Named once so the
+ * ports that speak about them cannot drift apart — the {@link IdentityTableNames}
+ * precedent.
+ */
+type RecordedTableNames = Readonly<{
+    recordedClock: string;
+    recordedEdges: string;
+    recordedNodes: string;
+}>;
+/**
+ * One recorded relation's provisioning DDL, with the roles the caller needs
+ * SEPARATED rather than positional.
+ */
+type RecordedRelationDdl = Readonly<{
+    /** The single `CREATE TABLE` statement. */
+    createTable: string;
+    /** Its index/constraint statements, in application order. */
+    indexes: readonly string[];
+    /**
+     * The name the ENGINE will have given this relation's PRIMARY KEY constraint
+     * once `createTable` has executed, or `undefined` on an engine that does not
+     * name PK constraints separately (SQLite).
+     *
+     * NOT "the name the DDL text declares": both bundled emitters push an unnamed
+     * inline `PRIMARY KEY (…)` (`ddl.ts:114-118`, `:441-445`), so on PostgreSQL the
+     * server derives `<table>_pkey`. The point of the field is that the derivation
+     * is an ENGINE convention, and the only honest source of it is whoever authored
+     * the DDL for that engine — a migration that reconstructs it bakes one adapter's
+     * convention in.
+     *
+     * The name is returned UNREDUCED. Reducing an over-long identifier is a
+     * separate decision with a separate owner (`shortenedIdentifier`), and it
+     * applies only to the RENAME's target. The source name is the *temporary*
+     * table's PK name, and temp table names are hash-derived and short BY
+     * CONSTRUCTION (`` `__tg_${role}_${shortHash(tableName)}` ``, an 8-char
+     * hash, so `<temp>_pkey` is at most ~21 bytes for any configured table
+     * name) — nowhere near the 63-byte ceiling. So the split is a structural
+     * fact about the temp-name shape, not a claim about PostgreSQL's
+     * truncation semantics: `shortenedIdentifier` is the identity on the
+     * source for every reachable input, and its effect is observable only on
+     * the target.
+     *
+     * A backend must apply this option consistently across name sets: return a
+     * name for both the temporary and final relation, or `undefined` for both.
+     * The migration refuses a mixed pair because silently dropping either name
+     * would leave the swapped relation with a backend-inconsistent constraint.
+     */
+    primaryKeyConstraintName?: string | undefined;
+}>;
+/**
+ * The database-global extensions TypeGraph installs on a caller's behalf.
+ *
+ * The extent is closed on purpose: {@link GraphBackend.ensureExtension}
+ * interpolates the name into DDL, so the allowlist — not the caller — is what
+ * decides the identifier can be trusted. `pg_trgm` backs `method: "trigram"`
+ * index materialization; `vector` backs pgvector storage.
+ */
+declare const DATABASE_EXTENSION_NAMES: readonly ["pg_trgm", "vector"];
+/** A name {@link GraphBackend.ensureExtension} accepts. */
+type DatabaseExtensionName = (typeof DATABASE_EXTENSION_NAMES)[number];
 /**
  * The GraphBackend interface abstracts database operations.
  *
@@ -3769,8 +5454,70 @@ type GraphBackend = Readonly<{
      * rebuild reservations from the returned node after-images.
      */
     hardDeleteUniquesByNodeIds?: (this: void, params: HardDeleteUniquesByNodeIdsParams) => Promise<void>;
+    /**
+     * Permanently removes every uniqueness claim owned by nodes of one concrete
+     * kind, at whatever axis each claim sits on. THE definition of "the claims
+     * this kind owns" — kind removal reaps through it so it can neither leak a
+     * claim whose axis is a sibling kind nor delete a surviving sibling's claim.
+     * Optional capability.
+     */
+    hardDeleteUniquesByConcreteKind?: (this: void, params: HardDeleteUniquesByConcreteKindParams) => Promise<void>;
     checkUnique: (this: void, params: CheckUniqueParams) => Promise<UniqueRow | undefined>;
     checkUniqueBatch?: (this: void, params: CheckUniqueBatchParams) => Promise<readonly UniqueRow[]>;
+    /**
+     * Takes the claim on one edge cardinality axis, in two statements: a
+     * decision-free create-or-lock that reports the committed holder, and — only
+     * when that holder is a different edge — a conditional takeover that succeeds
+     * exactly when the incumbent is no longer an edge the axis and key describe.
+     *
+     * The claim is the FENCE for a declared cardinality: `(kind, from)` and
+     * `(kind, from, to)` are predicates the edges primary key `(graph_id, id)`
+     * cannot enforce, so without this relation two concurrent writers can both
+     * pass the probe and both commit. Read through the `constraintClaims`
+     * capability, never through member presence — see `claimSupport`
+     * (`store/claims/backing.ts`).
+     */
+    claimEdgeCardinality?: (this: void, params: ClaimEdgeCardinalityParams) => Promise<EdgeClaimOutcome>;
+    /**
+     * Batched variant of `claimEdgeCardinality`: one multi-row create-or-lock
+     * statement, then a takeover statement only for the entries a different edge
+     * holds. Outcomes are returned positionally, one per entry.
+     *
+     * Callers must not pass two entries with the same conflict target
+     * (`axis`, `key`): a multi-row upsert cannot affect one row twice.
+     */
+    claimEdgeCardinalityBatch?: (this: void, entries: readonly ClaimEdgeCardinalityParams[]) => Promise<readonly EdgeClaimOutcome[]>;
+    /**
+     * Housekeeping only: drops the claim rows named edges hold, so hard deletes,
+     * kind removal and `clearGraph` do not grow the relation without bound. The
+     * FENCE never depends on it having run — a claim whose holder is no longer
+     * live (or, for `oneActive`, no longer active) is taken over in place.
+     */
+    purgeEdgeClaims?: (this: void, params: PurgeEdgeClaimsParams) => Promise<void>;
+    /**
+     * Read-only diagnostic: the rows that make a declared constraint currently
+     * violated, for a caller (`store.verifyConstraintFences()`) that folds them
+     * onto the claim axes they contend for.
+     *
+     * It reads the ENTITY relations for the two families whose pre-upgrade
+     * violations no claim row records — a database written before the claim
+     * relations existed holds no edge claims at all — and the `uniques` relation
+     * for uniqueness, where a pre-upgrade duplicate is exactly two live rows
+     * sitting at two different `node_kind`s. A scan of a claim relation's primary
+     * key can find neither, which is why this is not one.
+     *
+     * Returns the contending ROWS, not the verdict: the axis a `uniques` row
+     * belongs to is a fold over the graph's subclass component, and the key an
+     * edge's claim sits on is `EDGE_CARDINALITY_SPECS`' — both of which live
+     * above the backend, so a backend that decided either would be a second
+     * spelling of a decision the fence already owns.
+     *
+     * Writes nothing: no DDL, no claim writes. Safe on a replica and under a
+     * least-privilege role. Present only on backends that can run the audit;
+     * `store.verifyConstraintFences()` refuses with a typed error when absent
+     * rather than reporting an empty (and therefore reassuring) result.
+     */
+    readConstraintFenceViolations?: (this: void, params: ReadConstraintFenceViolationsParams) => Promise<ConstraintFenceViolationRows>;
     getActiveSchema: (this: void, graphId: string) => Promise<SchemaVersionRow | undefined>;
     getSchemaVersion: (this: void, graphId: string, version: number) => Promise<SchemaVersionRow | undefined>;
     /**
@@ -3951,6 +5698,12 @@ type GraphBackend = Readonly<{
      * Install the PostgreSQL `pg_trgm` extension under a database-global
      * concurrency fence. Relational trigram index materialization calls this
      * before emitting its index DDL; non-PostgreSQL backends omit it.
+     *
+     * @deprecated The `pg_trgm`-only spelling of {@link GraphBackend.ensureExtension},
+     *   which says the same thing for every extension the library installs. It is
+     *   retained — and still consulted, after `ensureExtension` — so a backend
+     *   written against 0.47 keeps its fence; the bundled PostgreSQL backend
+     *   implements it by delegating. Implement `ensureExtension` in new backends.
      */
     ensureTrigramExtension?: (this: void) => Promise<void>;
     /**
@@ -4011,6 +5764,21 @@ type GraphBackend = Readonly<{
      * @internal
      */
     identityTableDdl?: (this: void, tableNames: IdentityTableNames) => readonly string[];
+    /**
+     * The provisioning DDL for the three recorded relations under the given
+     * physical names, keyed by logical relation. Used only by the offline legacy
+     * preview-schema migration, which builds temp tables, copies, and swaps —
+     * so it is called TWICE per migration, once per name set, and the migration
+     * (not the backend) composes the temp `createTable` with the final `indexes`.
+     *
+     * A backend that omits this cannot be migrated FROM the timestamp-only
+     * preview schema — a schema only the bundled Drizzle backends ever created.
+     * `migrateLegacyRecordedTime` REFUSES with `UnsupportedBackendCapabilityError`
+     * naming this port rather than emitting DDL it cannot author.
+     *
+     * @internal
+     */
+    recordedTableDdl?: (this: void, tableNames: RecordedTableNames) => Readonly<Record<keyof RecordedTableNames, RecordedRelationDdl>>;
     /**
      * Look up a recorded materialization for a declared index by its
      * physical SQL index name. Returns `undefined` if no row exists.
@@ -4394,6 +6162,30 @@ type GraphBackend = Readonly<{
      * statement outside `transaction(...)`.
      */
     executeDdl?: (this: void, ddl: string) => Promise<void>;
+    /**
+     * Installs a database-global extension idempotently, tolerating the
+     * concurrent-install race.
+     *
+     * `CREATE EXTENSION IF NOT EXISTS` is not a concurrency primitive on
+     * PostgreSQL: the existence check cannot see another session's uncommitted
+     * `pg_extension` row, so the loser of a race waits for the winner and is
+     * then handed SQLSTATE 23505 instead of the harmless "already exists"
+     * notice (#446). A backend implementing this member owns that retry, and
+     * may additionally serialize same-extension installers behind a fence of its
+     * own (the bundled PostgreSQL backend takes a transaction advisory lock
+     * keyed on the extension, #475).
+     *
+     * This is the one member the library asks for an extension install; it
+     * supersedes {@link GraphBackend.ensureTrigramExtension}, which said the same
+     * thing for one extension.
+     *
+     * Like `executeDdl`, implementations MUST run the statement at the
+     * top-level backend, never inside `transaction(...)`: the 23505 aborts the
+     * enclosing transaction, so a retry issued inside one would only collect
+     * `25P02` on the way out. That is why this member is absent from
+     * {@link TransactionBackend}.
+     */
+    ensureExtension?: (this: void, name: DatabaseExtensionName) => Promise<void>;
     /** Runs TypeGraph operations inside a backend-owned transaction. */
     transaction: <T>(this: void, fn: (tx: TransactionBackend) => Promise<T>, options?: TransactionOptions) => Promise<T>;
     close: (this: void) => Promise<void>;
@@ -4418,7 +6210,7 @@ type EdgeEntityReadBackend = Pick<GraphBackend, "getEdge" | "getEdges" | "countE
 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" | "hardDeleteUniquesByNodeIds" | "checkUnique" | "checkUniqueBatch">;
+type UniqueConstraintBackend = Pick<GraphBackend, "insertUnique" | "insertUniqueBatch" | "deleteUnique" | "hardDeleteUniquesByNodeIds" | "hardDeleteUniquesByConcreteKind" | "checkUnique" | "checkUniqueBatch">;
 type SchemaReadBackend = Pick<GraphBackend, "getActiveSchema" | "getSchemaVersion">;
 type SchemaCommitBackend = Pick<GraphBackend, "commitSchemaVersion" | "commitSchemaVersionIfKindsEmpty" | "setActiveVersion">;
 type SchemaWriteFenceBackend = Pick<GraphBackend, "lockSchemaVersionForWrite">;
@@ -4453,7 +6245,7 @@ type TransactionReadBackend = Readonly<BackendIdentity & GraphEntityReadBackend
  * deliberately absent: their guarantees depend on the top-level backend or
  * 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>;
+type TransactionBackend = Readonly<BackendIdentity & GraphEntityReadBackend & GraphEntityWriteBackend & UniqueConstraintBackend & Pick<GraphBackend, "claimEdgeCardinality" | "claimEdgeCardinalityBatch" | "purgeEdgeClaims"> & 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.
@@ -4483,13 +6275,34 @@ type InsertUniqueParams = Readonly<{
     concreteKind: string;
 }>;
 /**
- * Parameters for deleting a unique constraint entry.
+ * Parameters for releasing a unique constraint entry.
+ *
+ * Every release is scoped to the claim's OWNER — the pair
+ * `(concreteKind, nodeId)`, because a node id is unique only within its kind.
+ * The two shapes differ only in whether the claim AXIS participates:
+ *
+ *  - **Lifecycle release** (`nodeKind` absent) — "give up every claim this node
+ *    holds for this constraint and key, whatever axis it sits on". Soft delete,
+ *    an update's key-change release and the resurrect diff use it, so a claim
+ *    written under an older axis is still released by newer code.
+ *  - **Compensating release** (`nodeKind` present) — "undo exactly the row I
+ *    just claimed, at the axis I claimed it on". A failed write's rollback uses
+ *    it, so it touches neither a row that predates the write nor one another
+ *    node holds.
  */
 type DeleteUniqueParams = Readonly<{
     graphId: string;
-    nodeKind: string;
+    /**
+     * The claim axis (`uniques.node_kind`) the release is restricted to. Absent
+     * releases the owner's claims at every axis — see the two shapes above.
+     */
+    nodeKind?: string;
     constraintName: string;
     key: string;
+    /** The claim owner's concrete kind (`uniques.concrete_kind`). */
+    concreteKind: string;
+    /** The claim owner's node id (`uniques.node_id`). */
+    nodeId: string;
 }>;
 /** Parameters for permanently clearing uniqueness sidecars by node identity. */
 type HardDeleteUniquesByNodeIdsParams = Readonly<{
@@ -4497,6 +6310,115 @@ type HardDeleteUniquesByNodeIdsParams = Readonly<{
     concreteKind: string;
     nodeIds: readonly string[];
 }>;
+/** Parameters for permanently clearing every uniqueness claim a kind owns. */
+type HardDeleteUniquesByConcreteKindParams = Readonly<{
+    graphId: string;
+    concreteKind: string;
+}>;
+/**
+ * One edge cardinality claim, named by the components its axis, its key and its
+ * holder-liveness predicate are all built from.
+ *
+ * The components are passed RAW rather than pre-rendered: `EDGE_CARDINALITY_SPECS`
+ * (`store/claims/edge-claims.ts`) is the one table that decides which endpoints
+ * the key covers and what a holder must still be, and both the TypeScript probe
+ * and the SQL builder read it. A caller that rendered the axis and key itself
+ * would be a second spelling of that decision.
+ */
+type ClaimEdgeCardinalityParams = Readonly<{
+    graphId: string;
+    /** The declared cardinality; `many` declares nothing and never claims. */
+    cardinality: Exclude<Cardinality, "many">;
+    edgeKind: string;
+    /** The edge that will hold the axis if this claim lands. */
+    edgeId: string;
+    fromKind: string;
+    fromId: string;
+    toKind: string;
+    toId: string;
+}>;
+/**
+ * What a claim statement decided.
+ *
+ * `refused` carries the incumbent so the caller can say which edge holds the
+ * axis; the typed refusal itself is the store's, built from the same
+ * `checkCardinality` / `checkUniqueEdge` owners the probe uses, so a caller
+ * cannot tell which layer refused.
+ */
+type EdgeClaimOutcome = Readonly<{
+    status: "claimed";
+}> | Readonly<{
+    status: "refused";
+    holderEdgeId: string;
+}>;
+/** Parameters for the housekeeping purge of claims held by named edges. */
+type PurgeEdgeClaimsParams = Readonly<{
+    graphId: string;
+    edgeIds: readonly string[];
+}>;
+/** One edge kind's declared cardinality, as the fence audit reads it. */
+type EdgeCardinalityDeclaration = Readonly<{
+    edgeKind: string;
+    /** `many` declares nothing, so it is unrepresentable here. */
+    cardinality: Exclude<Cardinality, "many">;
+}>;
+/**
+ * What a constraint-fence audit asks the database about: the declarations the
+ * graph carries, one list per family.
+ *
+ * The declarations are passed rather than discovered because the backend holds
+ * no schema — and because the `uniqueConstraintNames` restriction is
+ * load-bearing rather than an optimization: the `uniques` relation also holds
+ * disjointness claims, whose `node_kind` is a pair label rather than a kind and
+ * for which no uniqueness axis can be computed. Those rows are covered by
+ * `disjointKindPairs`, from the nodes relation.
+ */
+type ReadConstraintFenceViolationsParams = Readonly<{
+    graphId: string;
+    /** Every unique constraint name the graph declares, in any scope. */
+    uniqueConstraintNames: readonly string[];
+    /** Every declared `disjointWith` pair, each read as one intersection. */
+    disjointKindPairs: readonly (readonly [string, string])[];
+    /** Every edge kind declaring a cardinality other than `many`. */
+    edgeCardinalities: readonly EdgeCardinalityDeclaration[];
+}>;
+/**
+ * One live `uniques` row that shares its `(constraint_name, key)` with at least
+ * one other live row — a candidate, not a verdict: two rows contend only when
+ * their `node_kind`s fold onto ONE claim axis, which the caller decides.
+ */
+type ContendedUniqueRow = Readonly<{
+    nodeKind: string;
+    constraintName: string;
+    key: string;
+    concreteKind: string;
+    nodeId: string;
+}>;
+/**
+ * One live edge that shares its declared cardinality's population with at least
+ * one other live edge. The endpoints are returned whole so the caller can name
+ * the claim key through the one builder that renders it.
+ */
+type ContendedEdgeRow = Readonly<{
+    edgeKind: string;
+    cardinality: Exclude<Cardinality, "many">;
+    edgeId: string;
+    fromKind: string;
+    fromId: string;
+    toKind: string;
+    toId: string;
+}>;
+/** One node id live under BOTH kinds of a declared disjoint pair. */
+type DisjointOverlapRow = Readonly<{
+    kinds: readonly [string, string];
+    nodeId: string;
+}>;
+/** Everything one constraint-fence audit read, per family. */
+type ConstraintFenceViolationRows = Readonly<{
+    contendedUniqueRows: readonly ContendedUniqueRow[];
+    contendedEdgeRows: readonly ContendedEdgeRow[];
+    disjointOverlaps: readonly DisjointOverlapRow[];
+}>;
 /**
  * Parameters for checking a unique constraint.
  */
@@ -5653,4 +7575,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 DialectCapabilities as $, ALL_FULLTEXT_MODES as A, BASE_CONTRIBUTION_OWNER as B, type Cardinality as C, type ContributionProbeEntry as D, type ContributionProbeResult as E, type ContributionProbeState as F, type ContributionRebuildResult as G, type ContributionRebuildScope as H, type IndexDeclaration as I, type ContributionRepairEntry as J, type ContributionRepairResult as K, type ContributionRepopulationStats as L, type CountEdgesByKindParams as M, type CountEdgesFromParams as N, type CountNodesByKindParams as O, type CreateVectorIndexParams as P, D1_MAX_BIND_PARAMETERS as Q, DURABLE_OBJECT_MAX_BIND_PARAMETERS as R, type DeleteBehavior as S, type DeleteEdgeParams as T, type DeleteEdgesBatchParams as U, type DeleteEmbeddingParams as V, type DeleteFulltextBatchParams as W, type DeleteFulltextParams as X, type DeleteNodeParams as Y, type DeleteUniqueParams as Z, type DialectAdapter as _, ALL_META_EDGE_NAMES as a, type IndexDeclarationBase as a$, type DialectRecursiveQueryStrategy as a0, type DialectStandardQueryStrategy as a1, type DialectVectorPredicateStrategy as a2, type DropVectorIndexParams as a3, type EdgeEntityReadBackend as a4, type EdgeEntityWriteBackend as a5, type EdgeExistsBetweenParams as a6, type EdgeIndexDeclaration as a7, type EdgeIndexDirection as a8, type EdgeRow as a9, type FindEdgesByHeterogeneousEndpointSetParams as aA, type FindEdgesByKindParams as aB, type FindEdgesConnectedToParams as aC, type FindNodesByKindParams as aD, type FulltextBatchRow as aE, type FulltextCapabilities as aF, type FulltextOperationBackend as aG, type FulltextQueryMode as aH, type FulltextSearchParams as aI, type FulltextSearchResult as aJ, type FulltextStrategy as aK, type GraphAnalyticsCapabilities as aL, type GraphBackend as aM, type GraphEntityReadBackend as aN, type GraphEntityWriteBackend as aO, type GraphExtension as aP, type GraphExtensionVersion as aQ, type GraphIdentityConfig as aR, type GraphLifecycleBackend as aS, type GraphReadBackend as aT, type HardDeleteEdgeParams as aU, type HardDeleteNodeParams as aV, type HardDeleteUniquesByNodeIdsParams as aW, type HybridSearchParams as aX, type HybridSearchRow as aY, type IdentityTableNames as aZ, type InListParameterOptions as a_, type EndpointExistence as aa, type ExtensionArrayItemType as ab, type ExtensionArrayProperty as ac, type ExtensionBooleanProperty as ad, type ExtensionEdgeDef as ae, type ExtensionEdgeIndex as af, type ExtensionEmbeddingModifier as ag, type ExtensionEnumProperty as ah, type ExtensionIndex as ai, type ExtensionIndexWhere as aj, type ExtensionNodeDef as ak, type ExtensionNodeIndex as al, type ExtensionNumberProperty as am, type ExtensionObjectFieldProperty as an, type ExtensionObjectProperty as ao, type ExtensionOntologyRelation as ap, type ExtensionPropertyModifiers as aq, type ExtensionPropertyType as ar, type ExtensionSearchableModifier as as, type ExtensionStringProperty as at, type ExtensionUniqueConstraint as au, type ExtensionUniqueWhere as av, FULLTEXT_CONTRIBUTION_NAME as aw, type FilteredApproximateSearch as ax, type FilteredApproximateSearchMode as ay, type FindEdgesByEndpointSetParams as az, type AdapterBackend as b, type SetActiveVersionParams as b$, type IndexEntity as b0, type IndexMaterializationBackend as b1, type IndexMaterializationRow as b2, type IndexOrigin as b3, type IndexScope as b4, type IndexWhereExpression as b5, type IndexWhereLiteral as b6, type IndexWhereOp as b7, type IndexWhereOperand as b8, type InferenceType as b9, type RawStatementExecutionBackend as bA, type RecordContributionMaterializationParams as bB, type RecordIndexMaterializationParams as bC, type RecordKindRemovalParams as bD, type RelationalIndexDeclaration as bE, type RelationalIndexMethod as bF, type ReleaseIndexMaterializationClaimParams as bG, type RemovalMaterializationBackend as bH, type RenderedSql as bI, type ResolvedSqlTableNames as bJ, type RowProps as bK, SQLITE_CAPABILITIES as bL, SQLITE_MAX_BIND_PARAMETERS as bM, type SchemaCommitBackend as bN, type SchemaCommitPreflightBackend as bO, type SchemaKindEmptinessProbe as bP, type SchemaReadBackend as bQ, type SchemaVersionRow as bR, type SchemaWriteFenceBackend as bS, type SerializedClosures as bT, type SerializedEdgeDef as bU, type SerializedMetaEdge as bV, type SerializedNodeDef as bW, type SerializedOntology as bX, type SerializedOntologyRelation as bY, type SerializedSchema as bZ, type SerializedUniqueConstraint as b_, type InsertEdgeParams as ba, type InsertNodeParams as bb, type InsertSchemaParams as bc, type InsertUniqueParams as bd, type IntentSql as be, type JsonPointer as bf, type JsonSchema as bg, type JsonValue as bh, type KindAnnotations as bi, type KindEntity as bj, type KindRemovalRow as bk, type LiveNodeRow as bl, type LockSchemaVersionForWriteParams as bm, MODERN_SQLITE_MAX_BIND_PARAMETERS as bn, type MetaEdgeName as bo, type NodeEntityReadBackend as bp, type NodeEntityWriteBackend as bq, type NodeIndexDeclaration as br, type NodeRow as bs, type NullCheckOp as bt, POSTGRES_CAPABILITIES as bu, POSTGRES_MAX_BIND_PARAMETERS as bv, Placeholder as bw, type PopulatedSchemaKind as bx, type QueryExecutionBackend as by, type RawQueryExecutionBackend as bz, type AdapterBackendTransactions as c, renderSqlite as c$, type SqlChunk as c0, type SqlCompilationBackend as c1, type SqlDialect as c2, type SqlFragment as c3, type SqlIdentifierChunk as c4, type SqlIntent as c5, type SqlParameterChunk as c6, type SqlPlaceholderChunk as c7, type SqlTableNames as c8, type SqlTag as c9, type VectorIndexDeclaration as cA, type VectorIndexImplementation as cB, type VectorIndexMetric as cC, type VectorIndexParams as cD, type VectorIndexType as cE, type VectorMetric as cF, type VectorOperationBackend as cG, type VectorSearchFrontierTuning as cH, type VectorSearchParams as cI, type VectorSearchResult as cJ, type VectorSlot as cK, type VectorStrategy as cL, assertFiniteEmbedding as cM, assertVectorMinScore as cN, assertVectorSearchLimit as cO, buildFulltextCapabilities as cP, buildVectorCapabilities as cQ, fts5Strategy as cR, isLiveNodeRow as cS, isSqlFragment as cT, isSqlPlaceholder as cU, isTombstonedNodeRow as cV, normalizeGraphAnalyticsCapabilities as cW, quoteIdentifier as cX, renderPostgres as cY, renderSql as cZ, renderSqlInline as c_, type SqlTextChunk as ca, type StrategyTableContribution as cb, type SystemColumnName as cc, type TableContribution as cd, type TemporalMode as ce, type TombstonedNodeRow as cf, type TransactionBackend as cg, type TransactionOptions as ch, type TransactionReadBackend as ci, type TrustedImportOptions as cj, type TrustedImportSession as ck, type UniqueConstraintBackend as cl, type UniqueRow as cm, type UniquenessScope as cn, type UpdateEdgeParams as co, type UpdateNodeParams as cp, type UpdateNodeSetParams as cq, type UpdateNodeSetResult as cr, type UpsertEmbeddingBatchParams as cs, type UpsertEmbeddingBatchRow as ct, type UpsertEmbeddingParams as cu, type UpsertFulltextBatchParams as cv, type UpsertFulltextParams as cw, VECTOR_CONTRIBUTION_PREFIX as cx, type ValueType as cy, type VectorCapabilities as cz, type BackendCapabilities as d, asEdgeId as d$, rowPropsToJsonText as d0, rowPropsToObject as d1, shortHash as d2, sql as d3, tsvectorStrategy as d4, vectorMinScoreCondition as d5, vectorPhysicalName as d6, vectorScoreExpression as d7, type GraphDef as d8, type QueryAst as d9, type EdgeTypeWithEndpoints as dA, type ExternalRecordedReadSource as dB, type GetEdgeType as dC, type GetNodeType as dD, type GraphDefaults as dE, type HybridFusionOptions as dF, type JsonPointerFor as dG, type JsonPointerInput as dH, type JsonPointerSegment as dI, type JsonPointerSegments as dJ, type JsonPointerSegmentsFor as dK, LEGACY_GRAPH_EXTENSION_VERSION as dL, MAX_JSON_POINTER_DEPTH as dM, type MetaEdge as dN, type MetaEdgeProperties as dO, type NodeId as dP, type NodeKinds as dQ, type NodeProps as dR, type NodeRegistration as dS, type OrderSpec as dT, type ParameterRef as dU, type RecordedRelationOptions as dV, type ResolveJsonPointer as dW, type ResolveJsonPointerSegments as dX, type SortDirection as dY, type TraversalExpansion as dZ, type UniqueConstraint as d_, type EdgeIndexConfig as da, type EdgeIndexWhereBuilder as db, type IndexWhereFieldBuilder as dc, type IndexWhereInput as dd, type NodeIndexConfig as de, type NodeIndexWhereBuilder as df, type NodeType as dg, type AnyEdgeType as dh, SqlSchema as di, type SchemaHash as dj, type AggregateExpr as dk, type FieldRef as dl, type ComparisonOp as dm, type AggregateComparisonPredicate as dn, type TraversalDirection as dp, type OntologyRelation as dq, type EdgeType as dr, type AllEdgeTypes as ds, type AllNodeTypes as dt, CURRENT_GRAPH_EXTENSION_VERSION as du, DEFAULT_SQL_SCHEMA as dv, type EdgeId as dw, type EdgeKinds as dx, type EdgeProps as dy, type EdgeRegistration as dz, type BackendIdentity as e, asNodeId as e0, createSqlSchema as e1, defineGraph as e2, getEdgeKinds as e3, getNodeKinds as e4, isEdgeType as e5, isEdgeTypeWithEndpoints as e6, isGraphDef as e7, isMetaEdge as e8, isNodeType as e9, joinJsonPointers as ea, jsonPointer as eb, normalizeJsonPointer as ec, parseJsonPointer as ed, recordedRelation as ee, type PredicateExpression as ef, type VectorMetricType as eg, type Traversal as eh, type NodePredicate as ei, type ProjectedField as ej, type AggregateOrderSpec as ek, type GroupBySpec as el, type RecursiveCyclePolicy as em, type VectorSlotMap as en, type RecordedReadBinding as eo, type SelectiveField as ep, type ComposableQuery as eq, type SetOperationType as er, type SetOperation as es, type BackendValidityEndMutation as et, GRAPH_EXTENSION_TOP_LEVEL_KEYS as eu, type GraphExtensionTopLevelKey as ev, type BackendLifecycle as f, type BackendMaintenance as g, type BackendTransactions as h, type CheckUniqueBatchParams as i, type CheckUniqueParams as j, type ClaimIndexMaterializationParams as k, type Collation as l, type CommitSchemaVersionExpected as m, type CommitSchemaVersionIfKindsEmptyResult as n, type CommitSchemaVersionParams as o, type CompiledRowsSql as p, type CompiledSelectSql as q, type CompiledStatementSql as r, type CompiledTemporaryStatementSql as s, type ContributionCapabilities as t, type ContributionDiagnostic as u, type ContributionDiagnosticState as v, type ContributionMaterializationBackend as w, type ContributionMaterializationIdentity as x, type ContributionMaterializationRow as y, type ContributionProbeContribution as z };
+export { type CountNodesByKindParams as $, type AdapterBackend as A, type BackendCapabilities as B, type ContributionDiagnostic as C, type ConstraintFenceViolationRows as D, type ContendedEdgeRow as E, type FulltextStrategy as F, type GraphIdentityConfig as G, type ContendedUniqueRow as H, type IndexDeclaration as I, type JsonPointer as J, type KindEntity as K, type ContributionCapabilities as L, type ContributionMaterializationBackend as M, type ContributionMaterializationIdentity as N, type ContributionMaterializationRow as O, type ContributionProbeContribution as P, type QueryAst as Q, type ContributionProbeEntry as R, type ContributionProbeResult as S, type TemporalMode as T, type ContributionProbeState as U, type VectorStrategy as V, type ContributionRebuildResult as W, type ContributionRebuildScope as X, type ContributionRepopulationStats as Y, type CountEdgesByKindParams as Z, type CountEdgesFromParams as _, type ContributionDiagnosticState as a, type FulltextSearchResult as a$, type CreateVectorIndexParams as a0, D1_MAX_BIND_PARAMETERS as a1, DATABASE_EXTENSION_NAMES as a2, DURABLE_OBJECT_MAX_BIND_PARAMETERS as a3, type DatabaseExtensionName as a4, type DeleteBehavior as a5, type DeleteEdgeParams as a6, type DeleteEdgesBatchParams as a7, type DeleteEmbeddingParams as a8, type DeleteFulltextBatchParams as a9, type ExtensionIndex as aA, type ExtensionIndexWhere as aB, type ExtensionNodeDef as aC, type ExtensionNodeIndex as aD, type ExtensionNumberProperty as aE, type ExtensionObjectFieldProperty as aF, type ExtensionObjectProperty as aG, type ExtensionOntologyRelation as aH, type ExtensionPropertyModifiers as aI, type ExtensionPropertyType as aJ, type ExtensionSearchableModifier as aK, type ExtensionStringProperty as aL, type ExtensionUniqueConstraint as aM, type ExtensionUniqueWhere as aN, FULLTEXT_CONTRIBUTION_NAME as aO, type FilteredApproximateSearch as aP, type FilteredApproximateSearchMode as aQ, type FindEdgesByEndpointSetParams as aR, type FindEdgesByHeterogeneousEndpointSetParams as aS, type FindEdgesByKindParams as aT, type FindEdgesConnectedToParams as aU, type FindNodesByKindParams as aV, type FulltextBatchRow as aW, type FulltextCapabilities as aX, type FulltextOperationBackend as aY, type FulltextQueryMode as aZ, type FulltextSearchParams as a_, type DeleteFulltextParams as aa, type DeleteNodeParams as ab, type DeleteUniqueParams as ac, type DialectAdapter as ad, type DialectCapabilities as ae, type DialectRecursiveQueryStrategy as af, type DialectStandardQueryStrategy as ag, type DialectVectorPredicateStrategy as ah, type DisjointOverlapRow as ai, type DropVectorIndexParams as aj, type EdgeCardinalityDeclaration as ak, type EdgeClaimOutcome as al, type EdgeEntityReadBackend as am, type EdgeEntityWriteBackend as an, type EdgeExistsBetweenParams as ao, type EdgeIndexDeclaration as ap, type EdgeIndexDirection as aq, type EdgeRow as ar, type EndpointExistence as as, type ExtensionArrayItemType as at, type ExtensionArrayProperty as au, type ExtensionBooleanProperty as av, type ExtensionEdgeDef as aw, type ExtensionEdgeIndex as ax, type ExtensionEmbeddingModifier as ay, type ExtensionEnumProperty as az, type ContributionRepairEntry as b, type ReleaseIndexMaterializationClaimParams as b$, type GraphAnalyticsCapabilities as b0, type GraphEntityReadBackend as b1, type GraphEntityWriteBackend as b2, type GraphExtension as b3, type GraphExtensionVersion as b4, type GraphLifecycleBackend as b5, type GraphReadBackend as b6, type HardDeleteEdgeParams as b7, type HardDeleteNodeParams as b8, type HardDeleteUniquesByConcreteKindParams as b9, type LockSchemaVersionForWriteParams as bA, MODERN_SQLITE_MAX_BIND_PARAMETERS as bB, type MetaEdgeName as bC, type NodeEntityReadBackend as bD, type NodeEntityWriteBackend as bE, type NodeIndexDeclaration as bF, type NodeRow as bG, type NullCheckOp as bH, POSTGRES_CAPABILITIES as bI, POSTGRES_MAX_BIND_PARAMETERS as bJ, type PessimisticLockCapabilities as bK, Placeholder as bL, type PopulatedSchemaKind as bM, type PurgeEdgeClaimsParams as bN, type QueryExecutionBackend as bO, type RawQueryExecutionBackend as bP, type RawStatementExecutionBackend as bQ, type ReadConstraintFenceViolationsParams as bR, type RecordContributionMaterializationParams as bS, type RecordIndexMaterializationParams as bT, type RecordKindRemovalParams as bU, type RecordedRelationDdl as bV, type RecordedTableNames as bW, type RecursiveTraversalCapability as bX, type RecursiveTraversalVerdict as bY, type RelationalIndexDeclaration as bZ, type RelationalIndexMethod as b_, type HardDeleteUniquesByNodeIdsParams as ba, type HybridSearchParams as bb, type HybridSearchRow as bc, type IdentityTableNames as bd, type InListParameterOptions as be, type IndexDeclarationBase as bf, type IndexEntity as bg, type IndexMaterializationBackend as bh, type IndexMaterializationRow as bi, type IndexOrigin as bj, type IndexScope as bk, type IndexWhereExpression as bl, type IndexWhereLiteral as bm, type IndexWhereOp as bn, type IndexWhereOperand as bo, type InferenceType as bp, type InsertEdgeParams as bq, type InsertNodeParams as br, type InsertSchemaParams as bs, type InsertUniqueParams as bt, type IntentSql as bu, type JsonSchema as bv, type JsonValue as bw, type KindAnnotations as bx, type KindRemovalRow as by, type LiveNodeRow as bz, type ContributionRepairResult as c, type VectorSearchFrontierTuning as c$, type RemovalMaterializationBackend as c0, type RenderedSql as c1, type ResolvedSqlTableNames as c2, type RowProps as c3, SQLITE_CAPABILITIES as c4, SQLITE_MAX_BIND_PARAMETERS as c5, type SchemaCommitBackend as c6, type SchemaCommitPreflightBackend as c7, type SchemaKindEmptinessProbe as c8, type SchemaReadBackend as c9, type TransactionBackend as cA, type TransactionOptions as cB, type TransactionReadBackend as cC, type TrustedImportOptions as cD, type TrustedImportSession as cE, type UniqueConstraintBackend as cF, type UniqueRow as cG, type UniquenessScope as cH, type UpdateEdgeParams as cI, type UpdateNodeParams as cJ, type UpdateNodeSetParams as cK, type UpdateNodeSetResult as cL, type UpsertEmbeddingBatchParams as cM, type UpsertEmbeddingBatchRow as cN, type UpsertEmbeddingParams as cO, type UpsertFulltextBatchParams as cP, type UpsertFulltextParams as cQ, VECTOR_CONTRIBUTION_PREFIX as cR, type ValueType as cS, type VectorCapabilities as cT, type VectorIndexDeclaration as cU, type VectorIndexImplementation as cV, type VectorIndexMetric as cW, type VectorIndexParams as cX, type VectorIndexType as cY, type VectorMetric as cZ, type VectorOperationBackend as c_, type SchemaVersionRow as ca, type SchemaWriteFenceBackend as cb, type SerializedClosures as cc, type SerializedEdgeDef as cd, type SerializedMetaEdge as ce, type SerializedNodeDef as cf, type SerializedOntology as cg, type SerializedOntologyRelation as ch, type SerializedSchema as ci, type SerializedUniqueConstraint as cj, type SetActiveVersionParams as ck, type SqlChunk as cl, type SqlCompilationBackend as cm, type SqlDialect as cn, type SqlFragment as co, type SqlIdentifierChunk as cp, type SqlIntent as cq, type SqlParameterChunk as cr, type SqlPlaceholderChunk as cs, type SqlTableNames as ct, type SqlTag as cu, type SqlTextChunk as cv, type StrategyTableContribution as cw, type SystemColumnName as cx, type TableContribution as cy, type TombstonedNodeRow as cz, type GraphDef as d, type FieldRef as d$, type VectorSearchParams as d0, type VectorSearchResult as d1, type VectorSlot as d2, type WriteFencePlan as d3, assertFiniteEmbedding as d4, assertRecursiveTraversal as d5, assertVectorMinScore as d6, assertVectorSearchLimit as d7, assumeRecursiveTraversalSupported as d8, buildFulltextCapabilities as d9, type EdgeIndexWhereBuilder as dA, type IndexWhereFieldBuilder as dB, type IndexWhereInput as dC, type NodeIndexConfig as dD, type NodeIndexWhereBuilder as dE, type NodeType as dF, type AnyEdgeType as dG, type SchemaDiff as dH, SqlSchema as dI, type SchemaHash as dJ, type ValidationIssue as dK, ValidationError as dL, type ChangeSeverity as dM, type ChangeType as dN, type DeprecatedKindsChange as dO, type EdgeChange as dP, type ExtensionChange as dQ, type IdentityChange as dR, type IndexChange as dS, type NodeChange as dT, type OntologyChange as dU, type SchemaChangeClassification as dV, classifySchemaChanges as dW, computeSchemaDiff as dX, getMigrationActions as dY, isBackwardsCompatible as dZ, type AggregateExpr as d_, buildVectorCapabilities as da, fts5Strategy as db, isLiveNodeRow as dc, isSqlFragment as dd, isSqlPlaceholder as de, isTombstonedNodeRow as df, normalizeGraphAnalyticsCapabilities as dg, quoteIdentifier as dh, recursiveTraversalUnsupportedError as di, renderPostgres as dj, renderSql as dk, renderSqlInline as dl, renderSqlite as dm, requireWriteFence as dn, resolveRecursiveTraversal as dp, resolveWriteFencePlan as dq, rowPropsToJsonText as dr, rowPropsToObject as ds, shortHash as dt, sql as du, tsvectorStrategy as dv, vectorMinScoreCondition as dw, vectorPhysicalName as dx, vectorScoreExpression as dy, type EdgeIndexConfig as dz, type GraphBackend as e, type JsonPointerSegment as e$, type ComparisonOp as e0, type AggregateComparisonPredicate as e1, type TraversalDirection as e2, type OntologyRelation as e3, type EdgeType as e4, type AllEdgeTypes as e5, type AllNodeTypes as e6, BackendDisposedError as e7, CURRENT_GRAPH_EXTENSION_VERSION as e8, CardinalityError as e9, type EndpointErrorDetails as eA, EndpointNotFoundError as eB, type EndpointNotFoundErrorDetails as eC, type ErrorCategory as eD, ExportStreamCancelledError as eE, ExportStreamIdleTimeoutError as eF, type ExternalRecordedReadSource as eG, type GetEdgeType as eH, type GetNodeType as eI, GraphAlgorithmConvergenceError as eJ, type GraphDefaults as eK, type HybridFusionOptions as eL, IMMUTABLE_VALIDITY_LOWER_BOUND_CODE as eM, INVERTED_VALIDITY_WINDOW_CODE as eN, IdentityContradictionError as eO, type IdentityContradictionErrorDetails as eP, IdentityEndpointValidityError as eQ, type IdentityEndpointValidityErrorDetails as eR, IdentitySeparationViolationError as eS, type IdentitySeparationViolationErrorDetails as eT, IdentityValidityWindowError as eU, type IdentityValidityWindowErrorDetails as eV, InvalidEdgeWeightError as eW, type InvalidEdgeWeightErrorDetails as eX, type InvalidEdgeWeightReason as eY, type JsonPointerFor as eZ, type JsonPointerInput as e_, type CardinalityErrorDetails as ea, CompilerInvariantError as eb, ConfigurationError as ec, type ContributionRebuildRefusal as ed, ContributionRebuildUnsupportedError as ee, ContributionUnavailableError as ef, type ContributionUnavailableErrorDetails as eg, DEFAULT_SQL_SCHEMA as eh, DatabaseOperationError as ei, type DatabaseOperationErrorDetails as ej, DisjointError as ek, type DisjointErrorDetails as el, EDGE_IDENTITY_MISMATCH_CODE as em, ENTITY_ALREADY_EXISTS_CODE as en, EagerMaterializationError as eo, type EagerMaterializationErrorDetails as ep, type EdgeId as eq, type EdgeKinds as er, EdgeNotFoundError as es, type EdgeNotFoundErrorDetails as et, type EdgeProps as eu, type EdgeRegistration as ev, type EdgeTypeWithEndpoints as ew, EmbeddingDimensionChangedError as ex, type EmbeddingDimensionChangedErrorDetails as ey, EndpointError as ez, ALL_FULLTEXT_MODES as f, defineGraph as f$, type JsonPointerSegments as f0, type JsonPointerSegmentsFor as f1, KindNotFoundError as f2, type KindNotFoundErrorDetails as f3, LEGACY_GRAPH_EXTENSION_VERSION as f4, MAX_JSON_POINTER_DEPTH as f5, MIGRATION_FAILURE_REASONS as f6, type MaterializeIndexesEntry as f7, type MaterializeIndexesOptions as f8, type MaterializeIndexesResult as f9, SchemaContentConflictError as fA, type SchemaContentConflictErrorDetails as fB, SchemaMismatchError as fC, type SchemaMismatchErrorDetails as fD, type SortDirection as fE, StaleVersionError as fF, type StaleVersionErrorDetails as fG, StoreNotInitializedError as fH, type StoreNotInitializedErrorDetails as fI, type StoreNotInitializedReason as fJ, TransactionClosedError as fK, type TraversalExpansion as fL, TrustedImportError as fM, type TrustedImportErrorReason as fN, TypeGraphError as fO, type TypeGraphErrorOptions as fP, type UniqueConstraint as fQ, UniquenessError as fR, type UniquenessErrorDetails as fS, UnsupportedBackendCapabilityError as fT, UnsupportedPredicateError as fU, type ValidationErrorDetails as fV, VersionConflictError as fW, type VersionConflictErrorDetails as fX, asEdgeId as fY, asNodeId as fZ, createSqlSchema as f_, type MaterializeSystemIndexesOptions as fa, type MetaEdge as fb, type MetaEdgeProperties as fc, MigrationError as fd, type MigrationErrorDetails as fe, type MigrationFailureReason as ff, NodeConstraintNotFoundError as fg, type NodeConstraintNotFoundErrorDetails as fh, type NodeId as fi, NodeIndexNotFoundError as fj, type NodeIndexNotFoundErrorDetails as fk, type NodeKinds as fl, NodeNotFoundError as fm, type NodeNotFoundErrorDetails as fn, type NodeProps as fo, type NodeRegistration as fp, type OrderSpec as fq, type ParameterRef as fr, RECORDED_CAPTURE_GUARD_CODES as fs, type RecordedCaptureGuardCode as ft, type RecordedCaptureGuardError as fu, type RecordedRelationOptions as fv, type ResolveJsonPointer as fw, type ResolveJsonPointerSegments as fx, RestrictedDeleteError as fy, type RestrictedDeleteErrorDetails as fz, ALL_META_EDGE_NAMES as g, getEdgeKinds as g0, getErrorSuggestion as g1, getNodeKinds as g2, isConstraintError as g3, isEdgeType as g4, isEdgeTypeWithEndpoints as g5, isGraphDef as g6, isMetaEdge as g7, isNodeType as g8, isRecordedCaptureGuardError as g9, isSystemError as ga, isTypeGraphError as gb, isUserRecoverable as gc, joinJsonPointers as gd, jsonPointer as ge, normalizeJsonPointer as gf, parseJsonPointer as gg, recordedRelation as gh, type PredicateExpression as gi, type VectorMetricType as gj, type Traversal as gk, type NodePredicate as gl, type ProjectedField as gm, type AggregateOrderSpec as gn, type GroupBySpec as go, type RecursiveCyclePolicy as gp, type VectorSlotMap as gq, type RecordedReadBinding as gr, type SelectiveField as gs, type ComposableQuery as gt, type SetOperationType as gu, type SetOperation as gv, type BackendValidityEndMutation as gw, GRAPH_EXTENSION_TOP_LEVEL_KEYS as gx, type GraphExtensionTopLevelKey as gy, type AdapterBackendTransactions as h, BASE_CONTRIBUTION_OWNER as i, type BackendIdentity as j, type BackendLifecycle as k, type BackendMaintenance as l, type BackendTransactions as m, type Cardinality as n, type CheckUniqueBatchParams as o, type CheckUniqueParams as p, type ClaimEdgeCardinalityParams as q, type ClaimIndexMaterializationParams as r, type Collation as s, type CommitSchemaVersionExpected as t, type CommitSchemaVersionIfKindsEmptyResult as u, type CommitSchemaVersionParams as v, type CompiledRowsSql as w, type CompiledSelectSql as x, type CompiledStatementSql as y, type CompiledTemporaryStatementSql as z };