@nicia-ai/typegraph 0.49.0 → 0.51.0

package/dist/{sqlite-D7Oz0SQh.d.ts → sqlite-MZA3oZNB.d.ts}

@@ -1,5 +1,5 @@
 import * as drizzle_orm_sqlite_core from 'drizzle-orm/sqlite-core';
-import { I as IndexDeclaration } from './types-BqFZTQmV.js';
+import { I as IndexDeclaration } from './types-6yf0Vv-_.js';
 
 /**
  * Table name configuration.
@@ -16,6 +16,7 @@ type SqliteTableNames = Readonly<{
     identityClosure: string;
     identitySeparation: string;
     uniques: string;
+    edgeClaims: string;
     schemaVersions: string;
     fulltext: string;
     indexMaterializations: string;
@@ -23,6 +24,7 @@ type SqliteTableNames = Readonly<{
     kindRemovals: string;
     reconciliationMarkers: string;
 }>;
+
 type CreateSqliteTablesOptions = Readonly<{
     /**
      * Additional TypeGraph indexes to include in the Drizzle schema.
@@ -2275,6 +2277,108 @@ declare function createSqliteTables(names?: Partial<SqliteTableNames>, options?:
         };
         dialect: "sqlite";
     }>;
+    readonly edgeClaims: drizzle_orm_sqlite_core.SQLiteTableWithColumns<{
+        name: string;
+        schema: undefined;
+        columns: {
+            graphId: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "graph_id";
+                tableName: string;
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: number | undefined;
+            }>;
+            axis: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "axis";
+                tableName: string;
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: number | undefined;
+            }>;
+            key: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "key";
+                tableName: string;
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: number | undefined;
+            }>;
+            edgeId: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "edge_id";
+                tableName: string;
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: number | undefined;
+            }>;
+            updatedAt: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "updated_at";
+                tableName: string;
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: number | undefined;
+            }>;
+        };
+        dialect: "sqlite";
+    }>;
     readonly schemaVersions: drizzle_orm_sqlite_core.SQLiteTableWithColumns<{
         name: string;
         schema: undefined;
@@ -5157,6 +5261,108 @@ declare const tables: {
         };
         dialect: "sqlite";
     }>;
+    readonly edgeClaims: drizzle_orm_sqlite_core.SQLiteTableWithColumns<{
+        name: string;
+        schema: undefined;
+        columns: {
+            graphId: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "graph_id";
+                tableName: string;
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: number | undefined;
+            }>;
+            axis: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "axis";
+                tableName: string;
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: number | undefined;
+            }>;
+            key: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "key";
+                tableName: string;
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: number | undefined;
+            }>;
+            edgeId: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "edge_id";
+                tableName: string;
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: number | undefined;
+            }>;
+            updatedAt: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "updated_at";
+                tableName: string;
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: number | undefined;
+            }>;
+        };
+        dialect: "sqlite";
+    }>;
     readonly schemaVersions: drizzle_orm_sqlite_core.SQLiteTableWithColumns<{
         name: string;
         schema: undefined;
@@ -7154,6 +7360,108 @@ declare const uniques: drizzle_orm_sqlite_core.SQLiteTableWithColumns<{
     };
     dialect: "sqlite";
 }>;
+declare const edgeClaims: drizzle_orm_sqlite_core.SQLiteTableWithColumns<{
+    name: string;
+    schema: undefined;
+    columns: {
+        graphId: drizzle_orm_sqlite_core.SQLiteColumn<{
+            name: "graph_id";
+            tableName: string;
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        axis: drizzle_orm_sqlite_core.SQLiteColumn<{
+            name: "axis";
+            tableName: string;
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        key: drizzle_orm_sqlite_core.SQLiteColumn<{
+            name: "key";
+            tableName: string;
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        edgeId: drizzle_orm_sqlite_core.SQLiteColumn<{
+            name: "edge_id";
+            tableName: string;
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        updatedAt: drizzle_orm_sqlite_core.SQLiteColumn<{
+            name: "updated_at";
+            tableName: string;
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+    };
+    dialect: "sqlite";
+}>;
 declare const schemaVersions: drizzle_orm_sqlite_core.SQLiteTableWithColumns<{
     name: string;
     schema: undefined;
@@ -7276,4 +7584,4 @@ declare const schemaVersions: drizzle_orm_sqlite_core.SQLiteTableWithColumns<{
  */
 type SqliteTables = ReturnType<typeof createSqliteTables>;
 
-export { type CreateSqliteTablesOptions as C, type SqliteTables as S, type SqliteTableNames as a, recordedEdges as b, createSqliteTables as c, recordedNodes as d, edges as e, nodes as n, recordedClock as r, schemaVersions as s, tables as t, uniques as u };
+export { type CreateSqliteTablesOptions as C, type SqliteTables as S, type SqliteTableNames as a, edges as b, createSqliteTables as c, recordedEdges as d, edgeClaims as e, recordedNodes as f, nodes as n, recordedClock as r, schemaVersions as s, tables as t, uniques as u };

package/dist/{store-bphCSo7z.d.cts → store-CuFX7fCx.d.cts}

@@ -1,9 +1,9 @@
 import { z } from 'zod';
-import { cy as ValueType, ef as PredicateExpression, aH as FulltextQueryMode, eg as VectorMetricType, d9 as QueryAst, bf as JsonPointer, dl as FieldRef, dU as ParameterRef, dg as NodeType, dh as AnyEdgeType, dr as EdgeType, dZ as TraversalExpansion, aM as GraphBackend, c2 as SqlDialect, di as SqlSchema, eh as Traversal, ei as NodePredicate, ej as ProjectedField, dT as OrderSpec, ek as AggregateOrderSpec, ce as TemporalMode, el as GroupBySpec, dF as HybridFusionOptions, dH as JsonPointerInput, em as RecursiveCyclePolicy, d8 as GraphDef, dp as TraversalDirection$1, dz as EdgeRegistration, dP as NodeId, cg as TransactionBackend, dk as AggregateExpr, dY as SortDirection, q as CompiledSelectSql, aK as FulltextStrategy, cL as VectorStrategy, en as VectorSlotMap, eo as RecordedReadBinding, ep as SelectiveField, eq as ComposableQuery, er as SetOperationType, es as SetOperation, aR as GraphIdentityConfig, dQ as NodeKinds, bs as NodeRow, bj as KindEntity, dB as ExternalRecordedReadSource, dw as EdgeId, a9 as EdgeRow, et as BackendValidityEndMutation, dS as NodeRegistration, dx as EdgeKinds, ci as TransactionReadBackend, dt as AllNodeTypes, bi as KindAnnotations, bg as JsonSchema, cn as UniquenessScope, l as Collation, C as Cardinality, aa as EndpointExistence, aP as GraphExtension, cF as VectorMetric, d as BackendCapabilities, u as ContributionDiagnostic, K as ContributionRepairResult, E as ContributionProbeResult, H as ContributionRebuildScope, G as ContributionRebuildResult, ch as TransactionOptions, b as AdapterBackend } from './types-BqFZTQmV.cjs';
-import { R as RecordedInstant, d as ReadCoordinate } from './temporal-5GqpYCk2.cjs';
-import { S as SearchableMetadata, c as EmbeddingValue } from './searchable-DHJMh_nj.cjs';
-import { K as KindRegistry, S as SchemaManagerOptions, b as SchemaValidationResult } from './manager-CYaff3n3.cjs';
-import { S as SchemaDiff, j as MaterializeIndexesOptions, M as MaterializeIndexesResult, k as MaterializeSystemIndexesOptions } from './materialize-indexes-DTtAnvfY.cjs';
+import { cS as ValueType, gi as PredicateExpression, aZ as FulltextQueryMode, gj as VectorMetricType, Q as QueryAst, J as JsonPointer, d$ as FieldRef, fr as ParameterRef, dF as NodeType, dG as AnyEdgeType, e4 as EdgeType, fL as TraversalExpansion, e as GraphBackend, cn as SqlDialect, dI as SqlSchema, gk as Traversal, gl as NodePredicate, gm as ProjectedField, fq as OrderSpec, gn as AggregateOrderSpec, T as TemporalMode, go as GroupBySpec, eL as HybridFusionOptions, e_ as JsonPointerInput, gp as RecursiveCyclePolicy, d as GraphDef, e2 as TraversalDirection$1, ev as EdgeRegistration, fi as NodeId, cA as TransactionBackend, d_ as AggregateExpr, fE as SortDirection, x as CompiledSelectSql, F as FulltextStrategy, V as VectorStrategy, gq as VectorSlotMap, gr as RecordedReadBinding, bY as RecursiveTraversalVerdict, gs as SelectiveField, gt as ComposableQuery, gu as SetOperationType, gv as SetOperation, G as GraphIdentityConfig, fl as NodeKinds, bG as NodeRow, K as KindEntity, eG as ExternalRecordedReadSource, eq as EdgeId, ar as EdgeRow, gw as BackendValidityEndMutation, fp as NodeRegistration, er as EdgeKinds, cC as TransactionReadBackend, e6 as AllNodeTypes, bx as KindAnnotations, bv as JsonSchema, cH as UniquenessScope, s as Collation, n as Cardinality, as as EndpointExistence, b3 as GraphExtension, j as BackendIdentity, b1 as GraphEntityReadBackend, c9 as SchemaReadBackend, bO as QueryExecutionBackend, cm as SqlCompilationBackend, bP as RawQueryExecutionBackend, cZ as VectorMetric, B as BackendCapabilities, dH as SchemaDiff, f8 as MaterializeIndexesOptions, f9 as MaterializeIndexesResult, fa as MaterializeSystemIndexesOptions, C as ContributionDiagnostic, c as ContributionRepairResult, S as ContributionProbeResult, X as ContributionRebuildScope, W as ContributionRebuildResult, cB as TransactionOptions, A as AdapterBackend } from './types-6yf0Vv-_.cjs';
+import { R as RecordedInstant, d as ReadCoordinate } from './temporal-CpyEiRY8.cjs';
+import { S as SearchableMetadata, c as EmbeddingValue } from './searchable-ClgET_i7.cjs';
+import { K as KindRegistry, S as SchemaManagerOptions, b as SchemaValidationResult } from './manager-D_t7oK69.cjs';
+import { b as BundleVerdictOf, U as UNIQUE_SIDECAR_BATCH, B as BATCH_POINT_READ } from './resolve-WEW8gWws.cjs';
 
 type FieldTypeInfo = Readonly<{
     valueType: ValueType;
@@ -969,6 +969,12 @@ type CompileQueryOptions = Readonly<{
     readInstant?: ReadInstantMode | undefined;
     /** Equal-id behavior for historical identity traversal reconstruction. */
     identitySameIdAcrossKinds?: "fold" | "ignore" | undefined;
+    /**
+     * Whether the active backend can compute a bounded transitive closure in
+     * one round trip. Defaults to {@link COMPILER_DEFAULT_RECURSIVE_TRAVERSAL}
+     * for direct compiler callers, mirroring `windowFunctions`.
+     */
+    recursiveTraversal?: RecursiveTraversalVerdict | undefined;
 }>;
 
 /**
@@ -3818,6 +3824,71 @@ type InternalGraphAlgorithms<G extends GraphDef> = Readonly<{
     personalizedPageRank: (options: InternalPersonalizedPageRankOptions<G>) => Promise<readonly PageRankScore[]>;
 }>;
 
+/** The relation a claim row lives in. */
+type ClaimRelation = "uniques" | "edgeClaims";
+/** A claim row named in full — the row a statement is about to lock. */
+type ClaimTarget = Readonly<{
+    relation: ClaimRelation;
+    graphId: string;
+    axis: string;
+    /**
+     * `uniques.constraint_name`. The edge claim relation keys on
+     * `(graph_id, axis, key)` and has no such column, so its targets omit it and
+     * sort as the empty string. Absent means "this relation does not key on a
+     * constraint name", never "not known yet".
+     */
+    constraintName?: string;
+    key: string;
+}>;
+/**
+ * WHO holds a claim. A node, not an id: ids are unique only per kind, so
+ * `(concrete_kind, node_id)` is the smallest thing that identifies a claimant.
+ */
+type ClaimOwner = Readonly<{
+    concreteKind: string;
+    nodeId: string;
+}>;
+
+/**
+ * The read-only fence diagnostic: which claim axes are ALREADY contended.
+ *
+ * A claim relation refuses a second claimant from the first post-upgrade write
+ * onward, but it repairs nothing that is already there. A database that carried
+ * two live siblings sharing a scoped key, or two live `cardinality: "one"` edges
+ * from one source, keeps carrying them — the next write that touches such an
+ * axis is refused with the ordinary typed error naming the incumbent, and until
+ * then nothing says so out loud. This module is what says so.
+ *
+ * It reports; it never repairs. Choosing which of two live claimants keeps the
+ * axis is a data-loss decision that belongs to the operator, not to a
+ * diagnostic.
+ *
+ * Every axis and key it names is built by the SAME function the fence writes
+ * with — {@link uniquenessClaimTarget}, {@link disjointnessClaimAxis},
+ * {@link edgeCardinalityClaimTarget} — so a report row names the row a writer
+ * would actually contend for. A second spelling here would produce a report
+ * about axes the fence does not use.
+ */
+
+/**
+ * One claim axis more than one live claimant holds.
+ *
+ * Discriminated on the family because the two claim relations record their
+ * holders differently: a `uniques` axis is held by an OWNER PAIR (ids are
+ * unique only per kind), an edge-claim axis by an edge id. `target` is the
+ * claim row itself, so a reader can go straight to the row a writer contends
+ * for rather than reconstructing it from the family's own vocabulary.
+ */
+type ConstraintFenceViolation = Readonly<{
+    family: "nodeUniqueness" | "nodeDisjointness";
+    target: ClaimTarget;
+    owners: readonly ClaimOwner[];
+}> | Readonly<{
+    family: "edgeCardinality";
+    target: ClaimTarget;
+    edgeIds: readonly string[];
+}>;
+
 /**
  * Members that are safe to expose through a history-enabled adapter Store.
  *
@@ -3826,9 +3897,9 @@ type InternalGraphAlgorithms<G extends GraphDef> = Readonly<{
  * transactions stay internal because each can mutate live rows without a
  * corresponding capture flush.
  */
-declare const HISTORY_STORE_BACKEND_KEYS: readonly ["assertRuntimeContributionsInitialized", "assertVectorSlotInitialized", "assertVectorSlotsInitialized", "bootstrapTables", "capabilities", "checkUnique", "checkUniqueBatch", "claimIndexMaterialization", "close", "commitSchemaVersion", "commitSchemaVersionIfKindsEmpty", "lockSchemaVersionForWrite", "compileSql", "countEdgesByKind", "countEdgesFrom", "countNodesByKind", "createVectorIndex", "deleteEdge", "deleteEdgesBatch", "deleteEmbedding", "deleteEmbeddingBatch", "deleteFulltext", "deleteFulltextBatch", "deleteNode", "deleteUnique", "hardDeleteUniquesByNodeIds", "deleteVectorSlotContribution", "dialect", "dropVectorIndex", "edgeExistsBetween", "ensureContributionMaterializationsTable", "ensureFulltextTable", "ensureIndexMaterializationsTable", "ensureKindRemovalsTable", "ensureReconciliationMarkersTable", "ensureRevisionOriginsTable", "ensureRuntimeContributions", "ensureVectorSlotContribution", "ensureVectorSlotContributions", "execute", "executeTemporaryStatement", "findEdgesByKind", "findEdgesByEndpointSet", "findEdgesByHeterogeneousEndpointSet", "findEdgesConnectedTo", "findNodesByKind", "fulltextSearch", "fulltextStrategy", "getActiveSchema", "getAllKindRemovals", "getContributionMaterialization", "getEdge", "getEdges", "getIndexMaterialization", "getIndexMaterializations", "getNode", "getNodes", "getPendingKindRemovals", "getReconciliationMarker", "getSchemaVersion", "hardDeleteEdge", "hardDeleteEdgesBatch", "hardDeleteNode", "hardDeleteUniquesByNodeIds", "hybridSearch", "insertEdge", "insertEdgeNoReturn", "insertEdgesBatch", "insertEdgesBatchReturning", "insertNode", "insertNodeNoReturn", "insertNodesBatch", "insertNodesBatchReturning", "insertUnique", "insertUniqueBatch", "probeContributions", "recordContributionMaterialization", "recordIndexMaterialization", "recordKindRemoval", "refreshStatistics", "releaseIndexMaterializationClaim", "setActiveVersion", "setReconciliationMarker", "tableNames", "updateEdge", "updateNode", "updateNodeSet", "upsertEmbedding", "upsertEmbeddingBatch", "upsertFulltext", "upsertFulltextBatch", "vectorSearch", "vectorStrategy", "verifyContributions"];
+declare const HISTORY_STORE_BACKEND_KEYS: readonly ["assertRuntimeContributionsInitialized", "assertVectorSlotInitialized", "assertVectorSlotsInitialized", "bootstrapTables", "capabilities", "checkUnique", "checkUniqueBatch", "claimEdgeCardinality", "claimEdgeCardinalityBatch", "claimIndexMaterialization", "close", "commitSchemaVersion", "commitSchemaVersionIfKindsEmpty", "lockSchemaVersionForWrite", "compileSql", "countEdgesByKind", "countEdgesFrom", "countNodesByKind", "createVectorIndex", "deleteEdge", "deleteEdgesBatch", "deleteEmbedding", "deleteEmbeddingBatch", "deleteFulltext", "deleteFulltextBatch", "deleteNode", "deleteUnique", "hardDeleteUniquesByNodeIds", "deleteVectorSlotContribution", "dialect", "dropVectorIndex", "edgeExistsBetween", "ensureContributionMaterializationsTable", "ensureExtension", "ensureFulltextTable", "ensureIndexMaterializationsTable", "ensureKindRemovalsTable", "ensureReconciliationMarkersTable", "ensureRevisionOriginsTable", "ensureRuntimeContributions", "ensureTrigramExtension", "ensureVectorSlotContribution", "ensureVectorSlotContributions", "execute", "executeTemporaryStatement", "findEdgesByKind", "findEdgesByEndpointSet", "findEdgesByHeterogeneousEndpointSet", "findEdgesConnectedTo", "findNodesByKind", "fulltextSearch", "fulltextStrategy", "getActiveSchema", "getAllKindRemovals", "getContributionMaterialization", "getEdge", "getEdges", "getIndexMaterialization", "getIndexMaterializations", "getNode", "getNodes", "getPendingKindRemovals", "getReconciliationMarker", "getSchemaVersion", "hardDeleteEdge", "hardDeleteEdgesBatch", "hardDeleteNode", "hardDeleteUniquesByConcreteKind", "hardDeleteUniquesByNodeIds", "hybridSearch", "insertEdge", "insertEdgeNoReturn", "insertEdgesBatch", "insertEdgesBatchReturning", "insertNode", "insertNodeNoReturn", "insertNodesBatch", "insertNodesBatchReturning", "insertUnique", "insertUniqueBatch", "probeContributions", "purgeEdgeClaims", "readConstraintFenceViolations", "recordContributionMaterialization", "recordIndexMaterialization", "recordKindRemoval", "refreshStatistics", "releaseIndexMaterializationClaim", "setActiveVersion", "setReconciliationMarker", "tableNames", "updateEdge", "updateNode", "updateNodeSet", "upsertEmbedding", "upsertEmbeddingBatch", "upsertFulltext", "upsertFulltextBatch", "vectorSearch", "vectorStrategy", "verifyContributions"];
 type HistoryStoreBackendMember = (typeof HISTORY_STORE_BACKEND_KEYS)[number];
-type UnsafeHistoryStoreBackendMember = "clearGraph" | "commitSchemaVersionWithPreflight" | "executeDdl" | "executeRaw" | "executeStatement" | "ensureIdentityTables" | "ensureTrigramExtension" | "identityTableDdl" | "rebuildContribution" | "repairContributions" | "schemaWriteTransaction" | "transaction" | "trustedImport";
+type UnsafeHistoryStoreBackendMember = "clearGraph" | "commitSchemaVersionWithPreflight" | "executeDdl" | "executeRaw" | "executeStatement" | "ensureIdentityTables" | "identityTableDdl" | "rebuildContribution" | "recordedTableDdl" | "repairContributions" | "schemaWriteTransaction" | "transaction" | "trustedImport";
 type UnclassifiedHistoryStoreBackendMember = Exclude<keyof GraphBackend, HistoryStoreBackendMember | UnsafeHistoryStoreBackendMember>;
 type HistoryStoreBackend = UnclassifiedHistoryStoreBackendMember extends never ? Readonly<Pick<GraphBackend, HistoryStoreBackendMember>> : never;
 
@@ -3984,14 +4055,6 @@ type MaterializeRemovalsResult = Readonly<{
     reclaimedVectorFields: readonly ReclaimedVectorFieldEntry[];
 }>;
 
-/**
- * Subgraph Extraction
- *
- * Extracts a typed subgraph from a root node by traversing a set of edge kinds.
- * Uses a recursive CTE for BFS traversal with cycle detection, then hydrates
- * the reachable nodes and connecting edges in two parallel queries.
- */
-
 /**
  * Discriminated union of all Node runtime types in a graph.
  *
@@ -4163,6 +4226,23 @@ declare const STORE_RUNTIME: unique symbol;
  */
 type StoreRuntime<G extends GraphDef> = Readonly<{
     backend: GraphBackend;
+    /**
+     * @internal The `uniqueSidecarBatch` bundle's verdict, resolved once at
+     * store construction against `backend` (ruling B8 spec item 2) and exposed
+     * here so a Store-owned view (provenance's fact close/reopen) can build a
+     * {@link file://./claims/node-claims.ts NodeClaimContext} without re-minting
+     * a second verdict for the same backend — the same reason `backend` itself
+     * is exposed here rather than reconstructed.
+     *
+     * Optional at this boundary — a `StoreRuntime`-shaped value is a
+     * contravariant (externally-authorable) position, so a new REQUIRED member
+     * here would be a breaking change (`scripts/api-surface-compat.ts`).
+     * Required after resolution instead, the same pattern
+     * `CompileQueryOptions.recursiveTraversal` uses: the one real producer
+     * (`store.ts`'s constructor) always populates it, and the one real
+     * consumer (`provenance/index.ts`) asserts it with `requireDefined`.
+     */
+    uniqueSidecarBatch?: BundleVerdictOf<typeof UNIQUE_SIDECAR_BATCH> | undefined;
     /**
      * @internal The backend this Store's queries actually execute through for
      * `target` — the Store's own backend when `target` is omitted.
@@ -4193,8 +4273,14 @@ type StoreRuntime<G extends GraphDef> = Readonly<{
     validateIdentity: () => Promise<void>;
     /**
      * Validates one final resolved node write set, then clears the affected
-     * uniqueness sidecars so its upserts may claim their approved keys in any
-     * order. The caller must supply a transaction-bound backend.
+     * nodes' claim rows so its upserts may take their approved keys in any order,
+     * and re-takes the complete claim set once the writes have landed. The caller
+     * must supply a transaction-bound backend.
+     *
+     * The clear is by OWNER, so it takes every claim the affected nodes hold —
+     * uniqueness and `disjointWith` alike — and the rebuild therefore goes through
+     * the same claim writer an ordinary create uses rather than a uniqueness-only
+     * insert. See `store/claims/resolved-node-claims.ts`.
      */
     applyResolvedNodeUniqueness: <Output>(target: TransactionBackend, writes: Readonly<{
         upserts: readonly Readonly<{
@@ -4326,12 +4412,12 @@ type StoreRuntime<G extends GraphDef> = Readonly<{
         nextAfter?: string;
         done: boolean;
     }>>;
-    lockIdentityImportTarget: (target: GraphBackend | TransactionBackend) => Promise<void>;
-    foldImportedIdentityNodes: (target: GraphBackend | TransactionBackend, references: readonly Readonly<{
+    lockIdentityImportTarget: (target: Readonly<BackendIdentity & GraphEntityReadBackend & SchemaReadBackend & QueryExecutionBackend & SqlCompilationBackend & RawQueryExecutionBackend & Pick<GraphBackend, "executeStatement">>) => Promise<void>;
+    foldImportedIdentityNodes: (target: Readonly<BackendIdentity & GraphEntityReadBackend & SchemaReadBackend & QueryExecutionBackend & SqlCompilationBackend & RawQueryExecutionBackend & Pick<GraphBackend, "executeStatement">>, references: readonly Readonly<{
         kind: string;
         id: string;
     }>[]) => Promise<void>;
-    importIdentityAssertionsAtTarget: (target: GraphBackend | TransactionBackend, assertions: readonly Readonly<{
+    importIdentityAssertionsAtTarget: (target: Readonly<BackendIdentity & GraphEntityReadBackend & SchemaReadBackend & QueryExecutionBackend & SqlCompilationBackend & RawQueryExecutionBackend & Pick<GraphBackend, "executeStatement">>, assertions: readonly Readonly<{
         id: string;
         relation: "same" | "different";
         a: Readonly<{
@@ -4438,16 +4524,6 @@ type RebuildFulltextResult = Readonly<{
     skippedTruncated: boolean;
 }>;
 
-/**
- * Store-level search helpers.
- *
- * `fulltextSearch` is a thin typed wrapper over `backend.fulltextSearch`.
- * `hybridSearch` runs a vector and a fulltext query in parallel and
- * fuses the two ranked lists with Reciprocal Rank Fusion. RRF is
- * rank-based, so it papers over score-scale differences between
- * pgvector/sqlite-vec (distance-derived) and tsvector/FTS5 (BM25-style).
- */
-
 /**
  * A fulltext search hit. `N` defaults to the generic `Node`; the
  * `store.search.fulltext<K>(kind)` facade narrows it to the concrete
@@ -4641,6 +4717,15 @@ type StoreSearchContext = Readonly<{
     backend: GraphBackend;
     registry: KindRegistry;
     createQuery?: () => QueryBuilder<GraphDef>;
+    /**
+     * The threaded `batchPointRead` verdict, resolved once per facade. Optional
+     * at this boundary for the same reason `search.ts`'s own
+     * `StoreSearchContext` is: a contravariant position, so a new required
+     * member would be a breaking change. The constructor resolves it when
+     * legacy callers omit it; `store.ts`'s `search` getter threads its
+     * already-resolved verdict through.
+     */
+    batchPointRead?: BundleVerdictOf<typeof BATCH_POINT_READ> | undefined;
 }>;
 /**
  * Search-related operations exposed via `store.search`.
@@ -5070,6 +5155,7 @@ type StoreCore<G extends GraphDef> = Readonly<{
     materializeSystemIndexes: (options?: MaterializeSystemIndexesOptions) => Promise<MaterializeIndexesResult>;
     reembedVectorField: (kind: string, fieldPath: string, options?: ReembedVectorFieldOptions) => Promise<ReembedVectorFieldResult>;
     verifyContributions: () => Promise<readonly ContributionDiagnostic[]>;
+    verifyConstraintFences: () => Promise<readonly ConstraintFenceViolation[]>;
     repairContributions: () => Promise<ContributionRepairResult>;
     probeContributions: () => Promise<ContributionProbeResult>;
     rebuildContribution: (scope: ContributionRebuildScope, options?: RebuildContributionOptions) => Promise<ContributionRebuildResult>;
@@ -5371,4 +5457,4 @@ declare function createVerifiedAdapterStore<G extends GraphDef, TNativeTransacti
     SchemaValidationResult
 ]>;
 
-export { type DynamicNodeKind as $, type AliasMap as A, type BaseStoreOptions as B, type BatchableQuery as C, type BulkEdgeSourceGroup as D, type EdgeAliasMap as E, type BulkFindEdgesFromParams as F, type BulkFindEdgesFromResult as G, type HistoryStoreOptions as H, type IdentityAssertion as I, type BulkOperationHookContext as J, type ConstraintNames as K, type LiveStoreOptions as L, type CreateEdgeInput as M, type CreateNodeInput as N, type DegreeOptions as O, type DynamicEdgeAccessor as P, type QueryCoordinateState as Q, type RecordedReadStoreOptions as R, type StoreOptions as S, TraversalBuilder as T, type UnboundLiveStoreOptions as U, type DynamicEdgeCollection as V, type DynamicEdgeType as W, type DynamicFieldBuilder as X, type DynamicNode as Y, type DynamicNodeAccessor as Z, type DynamicNodeCollection as _, type Store as a, type NodeWrites as a$, type DynamicNodeReference as a0, type DynamicNodeType as a1, type DynamicSelectableEdge as a2, type DynamicSelectableNode as a3, type Edge as a4, type EdgeAccessor as a5, type EdgeBatchReads as a6, type EdgeBulkFindEndpointOptions as a7, type EdgeBulkFindOptions as a8, type EdgeCollection as a9, type IdentityNodeReference as aA, type IdentityTraversalOption as aB, type IdentityValidityWindow as aC, type IfExistsMode as aD, type InitialQueryBuilder as aE, type KindIntrospection as aF, type LabelPropagationMembership as aG, type LabelPropagationOptions as aH, type MaterializeRemovalsEntry as aI, type MaterializeRemovalsOptions as aJ, type MaterializeRemovalsResult as aK, type MeasurableAdapterHistoryTransactionContext as aL, type MeasurableAdapterTransactionContext as aM, type MeasurableTransactionContext as aN, type NeighborsOptions as aO, type NoRecordedCoordinate as aP, type Node as aQ, type NodeAccessor as aR, type NodeAlias as aS, type NodeBulkFindByIndexOptions as aT, type NodeCollection as aU, type NodeCurrentReads as aV, type NodeGetOrCreateByConstraintOptions as aW, type NodeGetOrCreateByConstraintResult as aX, type NodeIdentifier as aY, type NodeRef as aZ, type NodeTemporalReads as a_, type EdgeFindByEndpointsOptions as aa, type EdgeGetOrCreateByEndpointsOptions as ab, type EdgeGetOrCreateByEndpointsResult as ac, type EdgeIntrospection as ad, type EdgeTemporalReads as ae, type EdgeWrites as af, type EmptyAliasMap as ag, type EmptyEdgeAliasMap as ah, ExecutableAggregateQuery as ai, ExecutableQuery as aj, type FieldAccessor as ak, type FulltextSearchHit as al, type FulltextSearchOptions as am, type GetOrCreateAction as an, type GraphAlgorithms as ao, type GraphEdgeCollections as ap, type GraphEdgeForKinds as aq, type GraphNodeCollections as ar, type GraphNodeReference as as, type HistoryStoreBackend as at, type HookContext as au, type HybridFulltextOptions as av, type HybridSearchHit as aw, type HybridSearchOptions as ax, type HybridVectorOptions as ay, type IdentityAssertionWriteFacade as az, type HistoryStore as b, type StreamOptions as b$, type OntologyIntrospection as b0, type OperationHookContext as b1, type PageRankOptions as b2, type PageRankScore as b3, type PaginateOptions as b4, type PaginatedResult as b5, type PathNode as b6, type PersonalizedPageRankOptions as b7, type PersonalizedPageRankSeed as b8, type Predicate as b9, type SelectableEdge as bA, type SelectableNode as bB, type ShortestPathOptions as bC, type ShortestPathResult as bD, type SqlAvailability as bE, type StoreHooks as bF, type StoreProjection as bG, type StoreRef as bH, StoreSearch as bI, StoreView as bJ, type StoreViewCanReachOptions as bK, type StoreViewCoordinate as bL, type StoreViewDegreeOptions as bM, type StoreViewEdgeCollection as bN, type StoreViewEdgeCollections as bO, type StoreViewGraphAlgorithms as bP, type StoreViewLabelPropagationOptions as bQ, type StoreViewNeighborsOptions as bR, type StoreViewNodeCollection as bS, type StoreViewNodeCollections as bT, type StoreViewPageRankOptions as bU, type StoreViewPersonalizedPageRankOptions as bV, type StoreViewReachableOptions as bW, type StoreViewShortestPathOptions as bX, type StoreViewSubgraphOptions as bY, type StoreViewWeaklyConnectedComponentsOptions as bZ, type StoreViewWeightedShortestPathOptions as b_, PreparedQuery as ba, type PropsAccessor as bb, type QueryHookContext as bc, type QueryOptions as bd, type ReachableNode as be, type ReachableOptions as bf, type RebuildContributionOptions as bg, type RebuildFulltextOptions as bh, type RebuildFulltextResult as bi, type ReclaimedVectorFieldEntry as bj, type ReconciledSchema as bk, type RecordedScanOptions as bl, type RecordedScanPage as bm, RecordedStoreView as bn, type RecordedStoreViewEdgeCollection as bo, type RecordedStoreViewEdgeCollections as bp, type RecordedStoreViewNodeCollection as bq, type RecordedStoreViewNodeCollections as br, type RecursiveTraversalOptions as bs, type ReembedFunction as bt, type ReembedVectorFieldOptions as bu, type ReembedVectorFieldResult as bv, type SchemaIntrospection as bw, type ScopedMeasure as bx, type SearchScopeOptions as by, type SelectContext as bz, type RecordedReadStore as c, type SubgraphEdgeResult as c0, type SubgraphNodeResult as c1, type SubgraphOptions as c2, type SubgraphResult as c3, type SubsetEdge as c4, type SubsetNode as c5, type TemporalAlgorithmOptions as c6, type TransactionContext as c7, type TransactionOutcome as c8, type TransactionReceipt as c9, inSubquery as cA, isParameterRef as cB, notExists as cC, notInSubquery as cD, param as cE, type TraversalDirection as ca, type TypedEdgeCollection as cb, type TypedRecordedStoreViewEdgeCollection as cc, type TypedStoreViewEdgeCollection as cd, UnionableQuery as ce, type UniqueIntrospection as cf, type UpdateEdgeInput as cg, type UpdateNodeInput as ch, type ValidityEndMutation as ci, type VectorSearchHit as cj, type VectorSearchOptions as ck, type WeaklyConnectedComponentMembership as cl, type WeaklyConnectedComponentsOptions as cm, type WeightedShortestPathOptions as cn, type WeightedShortestPathResult as co, asIdentityAssertionId as cp, createAdapterStore as cq, createAdapterStoreWithSchema as cr, createQueryBuilder as cs, createStore as ct, createStoreWithSchema as cu, createVerifiedAdapterStore as cv, createVerifiedStore as cw, defineSubgraphProject as cx, exists as cy, fieldRef as cz, type IdentityAssertionId as d, type IdentityAssertionResult as e, type IdentityFacade as f, type IdentityNode as g, type IdentityNodeRefInput as h, type IdentityPair as i, type IdentityReadFacade as j, type IdentityRelation as k, type IdentityWriteSummary as l, type RecursiveAliasMap as m, QueryBuilder as n, type EmptyRecursiveAliasMap as o, type AdapterHistoryStore as p, type AdapterHistoryTransactionContext as q, type AdapterRecordedReadStore as r, type AdapterStore as s, type AdapterTransactionContext as t, type AggregateResult as u, type AlgorithmCyclePolicy as v, type AnyEdge as w, type AnyNode as x, type BaseTraversalOptions as y, type BatchResults as z };
+export { type DynamicNode as $, type AliasMap as A, type BaseStoreOptions as B, type BatchableQuery as C, type BulkEdgeSourceGroup as D, type EdgeAliasMap as E, type BulkFindEdgesFromParams as F, type BulkFindEdgesFromResult as G, type HistoryStoreOptions as H, type IdentityAssertion as I, type BulkOperationHookContext as J, type ClaimOwner as K, type LiveStoreOptions as L, type ClaimTarget as M, type ConstraintFenceViolation as N, type ConstraintNames as O, type CreateEdgeInput as P, type QueryCoordinateState as Q, type RecordedReadStoreOptions as R, type StoreOptions as S, TraversalBuilder as T, type UnboundLiveStoreOptions as U, type CreateNodeInput as V, type DegreeOptions as W, type DynamicEdgeAccessor as X, type DynamicEdgeCollection as Y, type DynamicEdgeType as Z, type DynamicFieldBuilder as _, type Store as a, type NodeIdentifier as a$, type DynamicNodeAccessor as a0, type DynamicNodeCollection as a1, type DynamicNodeKind as a2, type DynamicNodeReference as a3, type DynamicNodeType as a4, type DynamicSelectableEdge as a5, type DynamicSelectableNode as a6, type Edge as a7, type EdgeAccessor as a8, type EdgeBatchReads as a9, type HybridSearchOptions as aA, type HybridVectorOptions as aB, type IdentityAssertionWriteFacade as aC, type IdentityNodeReference as aD, type IdentityTraversalOption as aE, type IdentityValidityWindow as aF, type IfExistsMode as aG, type InitialQueryBuilder as aH, type KindIntrospection as aI, type LabelPropagationMembership as aJ, type LabelPropagationOptions as aK, type MaterializeRemovalsEntry as aL, type MaterializeRemovalsOptions as aM, type MaterializeRemovalsResult as aN, type MeasurableAdapterHistoryTransactionContext as aO, type MeasurableAdapterTransactionContext as aP, type MeasurableTransactionContext as aQ, type NeighborsOptions as aR, type NoRecordedCoordinate as aS, type Node as aT, type NodeAccessor as aU, type NodeAlias as aV, type NodeBulkFindByIndexOptions as aW, type NodeCollection as aX, type NodeCurrentReads as aY, type NodeGetOrCreateByConstraintOptions as aZ, type NodeGetOrCreateByConstraintResult as a_, type EdgeBulkFindEndpointOptions as aa, type EdgeBulkFindOptions as ab, type EdgeCollection as ac, type EdgeFindByEndpointsOptions as ad, type EdgeGetOrCreateByEndpointsOptions as ae, type EdgeGetOrCreateByEndpointsResult as af, type EdgeIntrospection as ag, type EdgeTemporalReads as ah, type EdgeWrites as ai, type EmptyAliasMap as aj, type EmptyEdgeAliasMap as ak, ExecutableAggregateQuery as al, ExecutableQuery as am, type FieldAccessor as an, type FulltextSearchHit as ao, type FulltextSearchOptions as ap, type GetOrCreateAction as aq, type GraphAlgorithms as ar, type GraphEdgeCollections as as, type GraphEdgeForKinds as at, type GraphNodeCollections as au, type GraphNodeReference as av, type HistoryStoreBackend as aw, type HookContext as ax, type HybridFulltextOptions as ay, type HybridSearchHit as az, type HistoryStore as b, type StoreViewSubgraphOptions as b$, type NodeRef as b0, type NodeTemporalReads as b1, type NodeWrites as b2, type OntologyIntrospection as b3, type OperationHookContext as b4, type PageRankOptions as b5, type PageRankScore as b6, type PaginateOptions as b7, type PaginatedResult as b8, type PathNode as b9, type ScopedMeasure as bA, type SearchScopeOptions as bB, type SelectContext as bC, type SelectableEdge as bD, type SelectableNode as bE, type ShortestPathOptions as bF, type ShortestPathResult as bG, type SqlAvailability as bH, type StoreHooks as bI, type StoreProjection as bJ, type StoreRef as bK, StoreSearch as bL, StoreView as bM, type StoreViewCanReachOptions as bN, type StoreViewCoordinate as bO, type StoreViewDegreeOptions as bP, type StoreViewEdgeCollection as bQ, type StoreViewEdgeCollections as bR, type StoreViewGraphAlgorithms as bS, type StoreViewLabelPropagationOptions as bT, type StoreViewNeighborsOptions as bU, type StoreViewNodeCollection as bV, type StoreViewNodeCollections as bW, type StoreViewPageRankOptions as bX, type StoreViewPersonalizedPageRankOptions as bY, type StoreViewReachableOptions as bZ, type StoreViewShortestPathOptions as b_, type PersonalizedPageRankOptions as ba, type PersonalizedPageRankSeed as bb, type Predicate as bc, PreparedQuery as bd, type PropsAccessor as be, type QueryHookContext as bf, type QueryOptions as bg, type ReachableNode as bh, type ReachableOptions as bi, type RebuildContributionOptions as bj, type RebuildFulltextOptions as bk, type RebuildFulltextResult as bl, type ReclaimedVectorFieldEntry as bm, type ReconciledSchema as bn, type RecordedScanOptions as bo, type RecordedScanPage as bp, RecordedStoreView as bq, type RecordedStoreViewEdgeCollection as br, type RecordedStoreViewEdgeCollections as bs, type RecordedStoreViewNodeCollection as bt, type RecordedStoreViewNodeCollections as bu, type RecursiveTraversalOptions as bv, type ReembedFunction as bw, type ReembedVectorFieldOptions as bx, type ReembedVectorFieldResult as by, type SchemaIntrospection as bz, type RecordedReadStore as c, type StoreViewWeaklyConnectedComponentsOptions as c0, type StoreViewWeightedShortestPathOptions as c1, type StreamOptions as c2, type SubgraphEdgeResult as c3, type SubgraphNodeResult as c4, type SubgraphOptions as c5, type SubgraphResult as c6, type SubsetEdge as c7, type SubsetNode as c8, type TemporalAlgorithmOptions as c9, defineSubgraphProject as cA, exists as cB, fieldRef as cC, inSubquery as cD, isParameterRef as cE, notExists as cF, notInSubquery as cG, param as cH, type TransactionContext as ca, type TransactionOutcome as cb, type TransactionReceipt as cc, type TraversalDirection as cd, type TypedEdgeCollection as ce, type TypedRecordedStoreViewEdgeCollection as cf, type TypedStoreViewEdgeCollection as cg, UnionableQuery as ch, type UniqueIntrospection as ci, type UpdateEdgeInput as cj, type UpdateNodeInput as ck, type ValidityEndMutation as cl, type VectorSearchHit as cm, type VectorSearchOptions as cn, type WeaklyConnectedComponentMembership as co, type WeaklyConnectedComponentsOptions as cp, type WeightedShortestPathOptions as cq, type WeightedShortestPathResult as cr, asIdentityAssertionId as cs, createAdapterStore as ct, createAdapterStoreWithSchema as cu, createQueryBuilder as cv, createStore as cw, createStoreWithSchema as cx, createVerifiedAdapterStore as cy, createVerifiedStore as cz, type IdentityAssertionId as d, type IdentityAssertionResult as e, type IdentityFacade as f, type IdentityNode as g, type IdentityNodeRefInput as h, type IdentityPair as i, type IdentityReadFacade as j, type IdentityRelation as k, type IdentityWriteSummary as l, type RecursiveAliasMap as m, QueryBuilder as n, type EmptyRecursiveAliasMap as o, type AdapterHistoryStore as p, type AdapterHistoryTransactionContext as q, type AdapterRecordedReadStore as r, type AdapterStore as s, type AdapterTransactionContext as t, type AggregateResult as u, type AlgorithmCyclePolicy as v, type AnyEdge as w, type AnyNode as x, type BaseTraversalOptions as y, type BatchResults as z };