@nicia-ai/typegraph 0.50.0 → 0.51.0

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

@@ -1842,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";
 /**
@@ -2071,6 +2247,1307 @@ declare function getNodeKinds<G extends GraphDef>(graph: G): readonly (keyof G["
  */
 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;
+    /**
+     * `"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.
+     */
+    reason?: "no_row_returned" | "duplicate_key";
+    /**
+     * 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.
+     */
+    attempted?: readonly Readonly<{
+        kind: string;
+        id: 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;
+    });
+}
+/**
+ * Details for EmbeddingDimensionChangedError.
+ */
+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;
+    });
+}
+/**
+ * Thrown when a query predicate cannot be compiled for the target database.
+ */
+declare class UnsupportedPredicateError extends TypeGraphError {
+    constructor(message: string, details?: Readonly<Record<string, unknown>>, options?: {
+        cause?: unknown;
+        suggestion?: string;
+    });
+}
+/**
+ * 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.
+ */
+declare class CompilerInvariantError extends TypeGraphError {
+    constructor(message: string, details?: Readonly<Record<string, unknown>>, options?: {
+        cause?: unknown;
+    });
+}
+/**
+ * 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.
+ */
+declare class TransactionClosedError extends TypeGraphError {
+    constructor(options?: {
+        cause?: unknown;
+    });
+}
+/**
+ * Type guard for TypeGraphError.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await store.nodes.Person.create({});
+ * } catch (error) {
+ *   if (isTypeGraphError(error)) {
+ *     console.log(error.code, error.category);
+ *   }
+ * }
+ * ```
+ */
+declare function isTypeGraphError(error: unknown): error is TypeGraphError;
+/**
+ * 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
+ * if (isUserRecoverable(error)) {
+ *   showErrorToUser(error.toUserMessage());
+ * } else {
+ *   logAndAlertOps(error);
+ * }
+ * ```
+ */
+declare function isUserRecoverable(error: unknown): boolean;
+/**
+ * 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 isSystemError(error: unknown): boolean;
+/**
+ * Check if error is a constraint violation.
+ */
+declare function isConstraintError(error: unknown): boolean;
+/**
+ * Extract suggestion from error if available.
+ */
+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).
  *
@@ -2239,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.
  *
@@ -2531,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;
@@ -3677,6 +5283,56 @@ 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.
  *
@@ -4108,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.
@@ -5904,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 DeleteEmbeddingParams as $, ALL_FULLTEXT_MODES as A, BASE_CONTRIBUTION_OWNER as B, type Cardinality as C, type ContributionMaterializationBackend as D, type ContributionMaterializationIdentity as E, type ContributionMaterializationRow as F, type ContributionProbeContribution as G, type ContributionProbeEntry as H, type IndexDeclaration as I, type ContributionProbeResult as J, type ContributionProbeState as K, type ContributionRebuildResult as L, type ContributionRebuildScope as M, type ContributionRepairEntry as N, type ContributionRepairResult as O, type ContributionRepopulationStats as P, type CountEdgesByKindParams as Q, type CountEdgesFromParams as R, type CountNodesByKindParams as S, type CreateVectorIndexParams as T, D1_MAX_BIND_PARAMETERS as U, DATABASE_EXTENSION_NAMES as V, DURABLE_OBJECT_MAX_BIND_PARAMETERS as W, type DatabaseExtensionName as X, type DeleteBehavior as Y, type DeleteEdgeParams as Z, type DeleteEdgesBatchParams as _, ALL_META_EDGE_NAMES as a, type GraphLifecycleBackend as a$, type DeleteFulltextBatchParams as a0, type DeleteFulltextParams as a1, type DeleteNodeParams as a2, type DeleteUniqueParams as a3, type DialectAdapter as a4, type DialectCapabilities as a5, type DialectRecursiveQueryStrategy as a6, type DialectStandardQueryStrategy as a7, type DialectVectorPredicateStrategy as a8, type DisjointOverlapRow as a9, type ExtensionPropertyType as aA, type ExtensionSearchableModifier as aB, type ExtensionStringProperty as aC, type ExtensionUniqueConstraint as aD, type ExtensionUniqueWhere as aE, FULLTEXT_CONTRIBUTION_NAME as aF, type FilteredApproximateSearch as aG, type FilteredApproximateSearchMode as aH, type FindEdgesByEndpointSetParams as aI, type FindEdgesByHeterogeneousEndpointSetParams as aJ, type FindEdgesByKindParams as aK, type FindEdgesConnectedToParams as aL, type FindNodesByKindParams as aM, type FulltextBatchRow as aN, type FulltextCapabilities as aO, type FulltextOperationBackend as aP, type FulltextQueryMode as aQ, type FulltextSearchParams as aR, type FulltextSearchResult as aS, type FulltextStrategy as aT, type GraphAnalyticsCapabilities as aU, type GraphBackend as aV, type GraphEntityReadBackend as aW, type GraphEntityWriteBackend as aX, type GraphExtension as aY, type GraphExtensionVersion as aZ, type GraphIdentityConfig as a_, type DropVectorIndexParams as aa, type EdgeCardinalityDeclaration as ab, type EdgeClaimOutcome as ac, type EdgeEntityReadBackend as ad, type EdgeEntityWriteBackend as ae, type EdgeExistsBetweenParams as af, type EdgeIndexDeclaration as ag, type EdgeIndexDirection as ah, type EdgeRow as ai, type EndpointExistence as aj, type ExtensionArrayItemType as ak, type ExtensionArrayProperty as al, type ExtensionBooleanProperty as am, type ExtensionEdgeDef as an, type ExtensionEdgeIndex as ao, type ExtensionEmbeddingModifier as ap, type ExtensionEnumProperty as aq, type ExtensionIndex as ar, type ExtensionIndexWhere as as, type ExtensionNodeDef as at, type ExtensionNodeIndex as au, type ExtensionNumberProperty as av, type ExtensionObjectFieldProperty as aw, type ExtensionObjectProperty as ax, type ExtensionOntologyRelation as ay, type ExtensionPropertyModifiers as az, type AdapterBackend as b, type SchemaKindEmptinessProbe as b$, type GraphReadBackend as b0, type HardDeleteEdgeParams as b1, type HardDeleteNodeParams as b2, type HardDeleteUniquesByConcreteKindParams as b3, type HardDeleteUniquesByNodeIdsParams as b4, type HybridSearchParams as b5, type HybridSearchRow as b6, type IdentityTableNames as b7, type InListParameterOptions as b8, type IndexDeclarationBase as b9, type NodeEntityWriteBackend as bA, type NodeIndexDeclaration as bB, type NodeRow as bC, type NullCheckOp as bD, POSTGRES_CAPABILITIES as bE, POSTGRES_MAX_BIND_PARAMETERS as bF, Placeholder as bG, type PopulatedSchemaKind as bH, type PurgeEdgeClaimsParams as bI, type QueryExecutionBackend as bJ, type RawQueryExecutionBackend as bK, type RawStatementExecutionBackend as bL, type ReadConstraintFenceViolationsParams as bM, type RecordContributionMaterializationParams as bN, type RecordIndexMaterializationParams as bO, type RecordKindRemovalParams as bP, type RelationalIndexDeclaration as bQ, type RelationalIndexMethod as bR, type ReleaseIndexMaterializationClaimParams as bS, type RemovalMaterializationBackend as bT, type RenderedSql as bU, type ResolvedSqlTableNames as bV, type RowProps as bW, SQLITE_CAPABILITIES as bX, SQLITE_MAX_BIND_PARAMETERS as bY, type SchemaCommitBackend as bZ, type SchemaCommitPreflightBackend as b_, type IndexEntity as ba, type IndexMaterializationBackend as bb, type IndexMaterializationRow as bc, type IndexOrigin as bd, type IndexScope as be, type IndexWhereExpression as bf, type IndexWhereLiteral as bg, type IndexWhereOp as bh, type IndexWhereOperand as bi, type InferenceType as bj, type InsertEdgeParams as bk, type InsertNodeParams as bl, type InsertSchemaParams as bm, type InsertUniqueParams as bn, type IntentSql as bo, type JsonPointer as bp, type JsonSchema as bq, type JsonValue as br, type KindAnnotations as bs, type KindEntity as bt, type KindRemovalRow as bu, type LiveNodeRow as bv, type LockSchemaVersionForWriteParams as bw, MODERN_SQLITE_MAX_BIND_PARAMETERS as bx, type MetaEdgeName as by, type NodeEntityReadBackend as bz, type AdapterBackendTransactions as c, buildFulltextCapabilities as c$, type SchemaReadBackend as c0, type SchemaVersionRow as c1, type SchemaWriteFenceBackend as c2, type SerializedClosures as c3, type SerializedEdgeDef as c4, type SerializedMetaEdge as c5, type SerializedNodeDef as c6, type SerializedOntology as c7, type SerializedOntologyRelation as c8, type SerializedSchema as c9, type UpdateEdgeParams as cA, type UpdateNodeParams as cB, type UpdateNodeSetParams as cC, type UpdateNodeSetResult as cD, type UpsertEmbeddingBatchParams as cE, type UpsertEmbeddingBatchRow as cF, type UpsertEmbeddingParams as cG, type UpsertFulltextBatchParams as cH, type UpsertFulltextParams as cI, VECTOR_CONTRIBUTION_PREFIX as cJ, type ValueType as cK, type VectorCapabilities as cL, type VectorIndexDeclaration as cM, type VectorIndexImplementation as cN, type VectorIndexMetric as cO, type VectorIndexParams as cP, type VectorIndexType as cQ, type VectorMetric as cR, type VectorOperationBackend as cS, type VectorSearchFrontierTuning as cT, type VectorSearchParams as cU, type VectorSearchResult as cV, type VectorSlot as cW, type VectorStrategy as cX, assertFiniteEmbedding as cY, assertVectorMinScore as cZ, assertVectorSearchLimit as c_, type SerializedUniqueConstraint as ca, type SetActiveVersionParams as cb, type SqlChunk as cc, type SqlCompilationBackend as cd, type SqlDialect as ce, type SqlFragment as cf, type SqlIdentifierChunk as cg, type SqlIntent as ch, type SqlParameterChunk as ci, type SqlPlaceholderChunk as cj, type SqlTableNames as ck, type SqlTag as cl, type SqlTextChunk as cm, type StrategyTableContribution as cn, type SystemColumnName as co, type TableContribution as cp, type TemporalMode as cq, type TombstonedNodeRow as cr, type TransactionBackend as cs, type TransactionOptions as ct, type TransactionReadBackend as cu, type TrustedImportOptions as cv, type TrustedImportSession as cw, type UniqueConstraintBackend as cx, type UniqueRow as cy, type UniquenessScope as cz, type BackendCapabilities as d, type NodeId as d$, buildVectorCapabilities as d0, fts5Strategy as d1, isLiveNodeRow as d2, isSqlFragment as d3, isSqlPlaceholder as d4, isTombstonedNodeRow as d5, normalizeGraphAnalyticsCapabilities as d6, quoteIdentifier as d7, renderPostgres as d8, renderSql as d9, type AggregateComparisonPredicate as dA, type TraversalDirection as dB, type OntologyRelation as dC, type EdgeType as dD, type AllEdgeTypes as dE, type AllNodeTypes as dF, CURRENT_GRAPH_EXTENSION_VERSION as dG, DEFAULT_SQL_SCHEMA as dH, type EdgeId as dI, type EdgeKinds as dJ, type EdgeProps as dK, type EdgeRegistration as dL, type EdgeTypeWithEndpoints as dM, type ExternalRecordedReadSource as dN, type GetEdgeType as dO, type GetNodeType as dP, type GraphDefaults as dQ, type HybridFusionOptions as dR, type JsonPointerFor as dS, type JsonPointerInput as dT, type JsonPointerSegment as dU, type JsonPointerSegments as dV, type JsonPointerSegmentsFor as dW, LEGACY_GRAPH_EXTENSION_VERSION as dX, MAX_JSON_POINTER_DEPTH as dY, type MetaEdge as dZ, type MetaEdgeProperties as d_, renderSqlInline as da, renderSqlite as db, rowPropsToJsonText as dc, rowPropsToObject as dd, shortHash as de, sql as df, tsvectorStrategy as dg, vectorMinScoreCondition as dh, vectorPhysicalName as di, vectorScoreExpression as dj, type GraphDef as dk, type QueryAst as dl, type EdgeIndexConfig as dm, type EdgeIndexWhereBuilder as dn, type IndexWhereFieldBuilder as dp, type IndexWhereInput as dq, type NodeIndexConfig as dr, type NodeIndexWhereBuilder as ds, type NodeType as dt, type AnyEdgeType as du, SqlSchema as dv, type SchemaHash as dw, type AggregateExpr as dx, type FieldRef as dy, type ComparisonOp as dz, type BackendIdentity as e, type NodeKinds as e0, type NodeProps as e1, type NodeRegistration as e2, type OrderSpec as e3, type ParameterRef as e4, type RecordedRelationOptions as e5, type ResolveJsonPointer as e6, type ResolveJsonPointerSegments as e7, type SortDirection as e8, type TraversalExpansion as e9, type RecordedReadBinding as eA, type SelectiveField as eB, type ComposableQuery as eC, type SetOperationType as eD, type SetOperation as eE, type BackendValidityEndMutation as eF, GRAPH_EXTENSION_TOP_LEVEL_KEYS as eG, type GraphExtensionTopLevelKey as eH, type UniqueConstraint as ea, asEdgeId as eb, asNodeId as ec, createSqlSchema as ed, defineGraph as ee, getEdgeKinds as ef, getNodeKinds as eg, isEdgeType as eh, isEdgeTypeWithEndpoints as ei, isGraphDef as ej, isMetaEdge as ek, isNodeType as el, joinJsonPointers as em, jsonPointer as en, normalizeJsonPointer as eo, parseJsonPointer as ep, recordedRelation as eq, type PredicateExpression as er, type VectorMetricType as es, type Traversal as et, type NodePredicate as eu, type ProjectedField as ev, type AggregateOrderSpec as ew, type GroupBySpec as ex, type RecursiveCyclePolicy as ey, type VectorSlotMap as ez, type BackendLifecycle as f, type BackendMaintenance as g, type BackendTransactions as h, type CheckUniqueBatchParams as i, type CheckUniqueParams as j, type ClaimEdgeCardinalityParams as k, type ClaimIndexMaterializationParams as l, type Collation as m, type CommitSchemaVersionExpected as n, type CommitSchemaVersionIfKindsEmptyResult as o, type CommitSchemaVersionParams as p, type CompiledRowsSql as q, type CompiledSelectSql as r, type CompiledStatementSql as s, type CompiledTemporaryStatementSql as t, type ConstraintFenceViolationRows as u, type ContendedEdgeRow as v, type ContendedUniqueRow as w, type ContributionCapabilities as x, type ContributionDiagnostic as y, type ContributionDiagnosticState 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 };