@nicia-ai/typegraph 0.43.0 → 0.44.0

package/dist/{store-view-D1F6KqsE.d.cts → store-view-w-md0nQ4.d.cts}

@@ -1,10 +1,10 @@
-import { G as GraphDef, E as EdgeKinds, N as NodeKinds, a as AllNodeTypes } from './define-graph-Byslw2OO.cjs';
-import { R as RecordedInstant, d as ReadCoordinate } from './temporal-CMpigMCW.cjs';
-import { bZ as ValueType, b_ as PredicateExpression, aw as FulltextQueryMode, b$ as VectorMetricType, Q as QueryAst, J as JsonPointer, a0 as FieldRef, aX as ParameterRef, a as NodeType, b as AnyEdgeType, _ as EdgeType, bq as TraversalExpansion, w as GraphBackend, S as SqlDialect, bh as SqlSchema, c0 as Traversal, c1 as NodePredicate, c2 as ProjectedField, aW as OrderSpec, c3 as AggregateOrderSpec, T as TemporalMode, c4 as GroupBySpec, aE as HybridFusionOptions, aI as JsonPointerInput, c5 as RecursiveCyclePolicy, a3 as TraversalDirection$1, E as EdgeRegistration, aU as NodeId, bn as TransactionBackend, K as KindEntity, aq as ExternalRecordedReadSource, c6 as NodeRow, am as EdgeId, c7 as EdgeRow, N as NodeRegistration, bp as TransactionReadBackend, $ as AggregateExpr, ba as SortDirection, af as CompiledSelectSql, F as FulltextStrategy, V as VectorStrategy, c8 as VectorSlotMap, c9 as RecordedReadBinding, ca as SelectiveField, cb as ComposableQuery, cc as SetOperationType, cd as SetOperation, ce as VectorMetric, aN as KindAnnotations, W as JsonSchema, bu as UniquenessScope, ab as Collation, aa as Cardinality, ap as EndpointExistence, G as GraphExtension, B as BackendCapabilities, bo as TransactionOptions, A as AdapterBackend } from './types-Dh-EgT-w.cjs';
-import { K as KindRegistry, S as SchemaManagerOptions, a as SchemaValidationResult } from './manager-U9_zopqr.cjs';
+import { G as GraphDef, E as EdgeKinds, N as NodeKinds, a as AllNodeTypes } from './define-graph-DVF-oN1i.cjs';
+import { R as RecordedInstant, d as ReadCoordinate } from './temporal-BCORwUau.cjs';
+import { c5 as ValueType, c6 as PredicateExpression, az as FulltextQueryMode, c7 as VectorMetricType, Q as QueryAst, J as JsonPointer, a2 as FieldRef, a$ as ParameterRef, b as NodeType, c as AnyEdgeType, a0 as EdgeType, bx as TraversalExpansion, x as GraphBackend, S as SqlDialect, bo as SqlSchema, c8 as Traversal, c9 as NodePredicate, ca as ProjectedField, a_ as OrderSpec, cb as AggregateOrderSpec, T as TemporalMode, cc as GroupBySpec, aH as HybridFusionOptions, aL as JsonPointerInput, cd as RecursiveCyclePolicy, a5 as TraversalDirection$1, E as EdgeRegistration, aY as NodeId, bu as TransactionBackend, K as KindEntity, at as ExternalRecordedReadSource, ce as NodeRow, ap as EdgeId, cf as EdgeRow, N as NodeRegistration, bw as TransactionReadBackend, a1 as AggregateExpr, bh as SortDirection, ai as CompiledSelectSql, F as FulltextStrategy, V as VectorStrategy, cg as VectorSlotMap, ch as RecordedReadBinding, ci as SelectiveField, cj as ComposableQuery, ck as SetOperationType, cl as SetOperation, cm as VectorMetric, aQ as KindAnnotations, Y as JsonSchema, bC as UniquenessScope, ad as Collation, ac as Cardinality, as as EndpointExistence, G as GraphExtension, B as BackendCapabilities, C as ContributionDiagnostic, bv as TransactionOptions, A as AdapterBackend } from './types-Cjvkj0jA.cjs';
+import { K as KindRegistry, S as SchemaManagerOptions, b as SchemaValidationResult } from './manager-Cn0NFIhN.cjs';
 import { z } from 'zod';
-import { S as SearchableMetadata, c as EmbeddingValue } from './searchable-B4mUXZT6.cjs';
-import { S as SchemaDiff, h as MaterializeIndexesOptions, M as MaterializeIndexesResult, j as MaterializeSystemIndexesOptions } from './materialize-indexes-DzMCetZe.cjs';
+import { S as SearchableMetadata, c as EmbeddingValue } from './searchable-BT7j9_IK.cjs';
+import { S as SchemaDiff, h as MaterializeIndexesOptions, M as MaterializeIndexesResult, j as MaterializeSystemIndexesOptions } from './materialize-indexes-DVRhd5h4.cjs';
 
 type FieldTypeInfo = Readonly<{
     valueType: ValueType;
@@ -50,8 +50,10 @@ type Predicate = Readonly<{
  * Creates a named parameter reference for prepared queries.
  *
  * Use with `query.prepare()` to create reusable parameterized queries.
- * Only supported in scalar comparison positions (eq, neq, gt, etc.),
- * string operations, and between bounds. Not supported in `in()`/`notIn()`.
+ * Supported in scalar comparison positions (eq, neq, gt, etc.), string
+ * operations, between bounds, and as the WHOLE list of `in()`/`notIn()` —
+ * `field.in(param("ids"))` bound to an array at execute time. A `param()`
+ * among the individual elements of a literal list is rejected.
  *
  * @example
  * ```typescript
@@ -63,6 +65,18 @@ type Predicate = Readonly<{
  *
  * const results = await prepared.execute({ name: "Alice" });
  * ```
+ *
+ * @example List-valued parameter — one compiled statement, any list length.
+ * ```typescript
+ * const byIds = store.query()
+ *   .from("Person", "p")
+ *   .whereNode("p", (p) => p.id.in(param("ids")))
+ *   .select((ctx) => ctx.p)
+ *   .prepare();
+ *
+ * await byIds.execute({ ids: ["a", "b"] });
+ * await byIds.execute({ ids: ["c"] });
+ * ```
  */
 declare function param(name: string): ParameterRef;
 /**
@@ -305,10 +319,17 @@ type DynamicSelectableEdge = Readonly<{
 
 type QueryCoordinateState = "open" | "sealed";
 /**
- * A query that can be executed within a `store.batch()` call.
+ * A query deferred for execution inside a `store.batch()` call.
  *
  * Both `ExecutableQuery` and `UnionableQuery` satisfy this interface.
  * The result type `R` is preserved per-query in the batch return tuple.
+ *
+ * Deferring costs nothing and saves nothing on its own: `store.batch()` runs
+ * each query as its own statement (sometimes two — see `ExecutableQuery`'s
+ * `executeOn`), so it does not fold these into a single round trip. Whether
+ * they share one connection is up to the adapter, not to
+ * `backend.capabilities.transactions` — see `store.batch()` for the full cost
+ * model.
  */
 type BatchableQuery<R = unknown> = Readonly<{
     executeOn: (backend: GraphBackend | TransactionBackend) => Promise<readonly R[]>;
@@ -417,8 +438,8 @@ type BaseFieldAccessor = Readonly<{
     neq: (value: unknown) => Predicate;
     isNull: () => Predicate;
     isNotNull: () => Predicate;
-    in: (values: readonly unknown[]) => Predicate;
-    notIn: (values: readonly unknown[]) => Predicate;
+    in: (values: readonly unknown[] | ParameterRef) => Predicate;
+    notIn: (values: readonly unknown[] | ParameterRef) => Predicate;
 }>;
 type StringFieldAccessor = BaseFieldAccessor & Readonly<{
     gt: (value: string | ParameterRef) => Predicate;
@@ -766,7 +787,7 @@ declare const CURRENT_ONLY_READ_NAMES: readonly ["findByConstraint", "bulkFindBy
 /** Node write method names: never available on a read-only StoreView. */
 declare const NODE_WRITE_NAMES: readonly ["create", "createFromRecord", "update", "delete", "hardDelete", "upsertById", "upsertByIdFromRecord", "bulkCreate", "bulkUpsertById", "bulkInsert", "bulkDelete", "getOrCreateByConstraint", "bulkGetOrCreateByConstraint"];
 /** Temporal-aware edge read method names. */
-declare const EDGE_TEMPORAL_READ_NAMES: readonly ["getById", "getByIds", "find", "count", "findFrom", "findTo", "findByEndpoints"];
+declare const EDGE_TEMPORAL_READ_NAMES: readonly ["getById", "getByIds", "find", "count", "findFrom", "findTo", "bulkFindFrom", "bulkFindTo", "findByEndpoints"];
 /** Deferred edge batch-read method names. */
 declare const EDGE_BATCH_READ_NAMES: readonly ["batchFindFrom", "batchFindTo", "batchFindByEndpoints"];
 /** Edge write method names: never available on a read-only StoreView. */
@@ -916,10 +937,14 @@ type HookContext = Readonly<{
     startedAt: Date;
 }>;
 /**
- * Query hook context with SQL information.
+ * Context for one SQL statement a query builder submits to the backend.
+ *
+ * A single logical query can emit more than one context, for example when a
+ * selective projection falls back to a full-row fetch. Backend-internal setup
+ * statements are not exposed as separate query-hook events.
  */
 type QueryHookContext = HookContext & Readonly<{
-    /** The SQL query being executed */
+    /** The SQL statement being executed */
     sql: string;
     /** Query parameters */
     params: readonly unknown[];
@@ -962,9 +987,9 @@ type OperationHookContext = HookContext & Readonly<{
  * ```
  */
 type StoreHooks = Readonly<{
-    /** Called before a query is executed */
+    /** Called before each query-builder statement is submitted to the backend. */
     onQueryStart?: (ctx: QueryHookContext) => void;
-    /** Called after a query completes successfully */
+    /** Called after each submitted query-builder statement succeeds. */
     onQueryEnd?: (ctx: QueryHookContext, result: Readonly<{
         rowCount: number;
         durationMs: number;
@@ -1234,6 +1259,26 @@ type NodeBulkFindByIndexOptions = Readonly<{
      */
     limitPerInput?: number;
 }>;
+/**
+ * Per-endpoint fan-out cap shared by the live and view forms of the edge
+ * bulk endpoint reads.
+ */
+type EdgeBulkFindOptions = Readonly<{
+    /**
+     * Maximum number of edges returned for each input endpoint. When omitted,
+     * every input's edge set is unbounded. Must be a positive integer.
+     *
+     * The cap keeps each input's leading edges under the same ordering
+     * `findFrom` / `findTo` return, so it bounds fan-out without reordering
+     * anything.
+     */
+    limitPerInput?: number;
+}>;
+/**
+ * Options for the edge bulk endpoint reads: the temporal coordinate every
+ * edge read accepts, plus the per-endpoint fan-out cap.
+ */
+type EdgeBulkFindEndpointOptions = QueryOptions & EdgeBulkFindOptions;
 /**
  * Result of an edge getOrCreateByEndpoints operation.
  */
@@ -1569,25 +1614,66 @@ type EdgeCollection<E extends AnyEdgeType, From extends NodeType = NodeType, To
      * Temporal semantics mirror {@link EdgeCollection.findFrom}.
      */
     findTo: (to: NodeRef<To>, options?: QueryOptions) => Promise<Edge<E, From, To>[]>;
+    /**
+     * Find the edges from a SET of source nodes in one read.
+     *
+     * `findFrom` with a widened endpoint predicate and nothing else: the same
+     * temporal model, the same soft-delete filtering, and the same per-source
+     * ordering — but `from_id IN (...)` instead of `from_id = ?`, so a page of
+     * N sources costs one statement per distinct source kind and bind-budget
+     * chunk rather than N singleton statements.
+     *
+     * Results are grouped per input: the outer array is parallel to `froms`
+     * (index `i` holds the edges of `froms[i]`), and repeated inputs each get
+     * their own copy of the same edge set. Empty input returns `[]`; a source
+     * with no edges gets an empty array. Large inputs are split across
+     * statements to respect the backend's bound-parameter budget, which is
+     * invisible in the result.
+     *
+     * Requires a backend implementing `findEdgesByEndpointSet` — both bundled
+     * Drizzle backends do. On one that does not, this **refuses** with a
+     * `ConfigurationError` rather than looping `findFrom` per input: asking for
+     * a bulk read is asking for set-oriented statements, and silently issuing N
+     * singleton statements is the cost surprise the method exists to remove.
+     *
+     * @param froms - Source nodes to read the edges of
+     * @param options - Temporal coordinate plus optional `limitPerInput`
+     * @throws {ConfigurationError} when the backend cannot read an endpoint set
+     */
+    bulkFindFrom: (froms: readonly NodeRef<From>[], options?: EdgeBulkFindEndpointOptions) => Promise<readonly Edge<E, From, To>[][]>;
+    /**
+     * Find the edges into a SET of target nodes in one read.
+     *
+     * Mirrors {@link EdgeCollection.bulkFindFrom} on the `to` endpoint.
+     */
+    bulkFindTo: (tos: readonly NodeRef<To>[], options?: EdgeBulkFindEndpointOptions) => Promise<readonly Edge<E, From, To>[][]>;
     /**
      * Deferred variant of `findFrom` for use with `store.batch()`.
      *
      * Returns a `BatchableQuery` instead of executing immediately. Accepts
      * the same temporal `options` as {@link EdgeCollection.findFrom}.
+     *
+     * Batching these still issues one statement per call — it does not merge
+     * the reads, and whether they share a connection is up to the adapter. It
+     * is not a snapshot: PostgreSQL's default read-committed isolation lets a
+     * later read observe a commit the earlier ones did not. To read edges for
+     * many sources in one statement, traverse from them in a single query.
      */
     batchFindFrom: (from: NodeRef<From>, options?: QueryOptions) => BatchableQuery<Edge<E, From, To>>;
     /**
      * Deferred variant of `findTo` for use with `store.batch()`.
      *
      * Returns a `BatchableQuery` instead of executing immediately. Accepts
-     * the same temporal `options` as {@link EdgeCollection.findTo}.
+     * the same temporal `options` as {@link EdgeCollection.findTo}. Costs one
+     * statement per call, like {@link EdgeCollection.batchFindFrom}.
      */
     batchFindTo: (to: NodeRef<To>, options?: QueryOptions) => BatchableQuery<Edge<E, From, To>>;
     /**
      * Deferred variant of `findByEndpoints` for use with `store.batch()`.
      *
      * Returns a `BatchableQuery` that yields a 0-or-1 element array
-     * (matching `findByEndpoints`' at-most-one semantics).
+     * (matching `findByEndpoints`' at-most-one semantics). Costs one statement
+     * per call, like {@link EdgeCollection.batchFindFrom}.
      */
     batchFindByEndpoints: (from: NodeRef<From>, to: NodeRef<To>, options?: EdgeFindByEndpointsOptions<E>, temporal?: QueryOptions) => BatchableQuery<Edge<E, From, To>>;
     /** Delete an edge (soft delete - sets deletedAt timestamp) */
@@ -1819,6 +1905,10 @@ type StoreViewEdgeCollection<E extends AnyEdgeType, From extends NodeType = Node
     findFrom: (from: NodeRef<From>) => Promise<Edge<E, From, To>[]>;
     /** Find edges to a specific node at the view's pinned coordinate. */
     findTo: (to: NodeRef<To>) => Promise<Edge<E, From, To>[]>;
+    /** Find the edges from a set of source nodes at the view's pinned coordinate. */
+    bulkFindFrom: (froms: readonly NodeRef<From>[], options?: EdgeBulkFindOptions) => Promise<readonly Edge<E, From, To>[][]>;
+    /** Find the edges into a set of target nodes at the view's pinned coordinate. */
+    bulkFindTo: (tos: readonly NodeRef<To>[], options?: EdgeBulkFindOptions) => Promise<readonly Edge<E, From, To>[][]>;
     /** Find the edge between two endpoints at the view's pinned coordinate. */
     findByEndpoints: (from: NodeRef<From>, to: NodeRef<To>, options?: EdgeFindByEndpointsOptions<E>) => Promise<Edge<E, From, To> | undefined>;
 }>;
@@ -2225,7 +2315,8 @@ type CompileQueryOptions = Readonly<{
  * the first `execute()`).
  *
  * Fast path: when the backend can compile and run raw SQL (`compileSql` +
- * `executeRaw`), the statement is compiled ONCE into a cached template whose
+ * `executeRaw`) AND the statement is raw-executable, it is compiled ONCE
+ * into a cached template whose
  * "current" read instant and user `param()` refs are reserved placeholders
  * (see {@link buildReadInstantTemplate}). Every `execute()` fills those
  * placeholders — a fresh instant plus the call's bindings — and runs the
@@ -2233,9 +2324,14 @@ type CompileQueryOptions = Readonly<{
  * never freezes "now" the way a cached literal instant would (the #246
  * regression).
  *
- * Fallback: on a backend without raw execution (custom/async), substitutes
- * parameter refs into the AST, compiles fresh per call, and executes via the
- * standard `backend.execute` path.
+ * Fallback: substitutes parameter refs into the AST, compiles fresh per call,
+ * and executes via the standard `backend.execute` path. Taken in two cases —
+ * a backend without raw execution (custom/async), and a statement that is not
+ * raw-executable because its execution semantics ride on the compiled SQL
+ * OBJECT rather than its text (approximate vector search's iterative-scan
+ * wrapper, `subgraph()`'s force-custom-plan fetches). The second applies even
+ * on PostgreSQL with `executeRaw` available; `isRawExecutable` in
+ * `sql-intent.ts` is the predicate that decides it.
  */
 
 type PreparedQueryConfig<R> = Readonly<{
@@ -2354,7 +2450,11 @@ declare class UnionableQuery<G extends GraphDef, R> {
     /**
      * Executes the combined query against a provided backend.
      *
-     * Used by `store.batch()` to run multiple queries over a single connection.
+     * Used by `store.batch()` to run several queries in sequence against one
+     * target — a transaction on backends that have them, the backend itself
+     * otherwise. A set operation compiles to one statement; whether that target
+     * is a shared connection is the adapter's business, not a function of
+     * transaction support.
      */
     executeOn(backend: GraphBackend | TransactionBackend): Promise<readonly R[]>;
 }
@@ -2445,7 +2545,9 @@ declare class ExecutableQuery<G extends GraphDef, Aliases extends AliasMap, Edge
      * validates the AST once (a malformed query fails fast, here, instead of on
      * first use); the prepared query then compiles once into a reusable template
      * and fills a fresh read instant per execute() — see PreparedQuery's class
-     * doc comment.
+     * doc comment, which also covers the two cases that recompile per call
+     * instead (no `executeRaw`, or a statement whose semantics ride on the SQL
+     * object rather than its text).
      *
      * Use `param("name")` in predicates to create parameterized slots,
      * then pass values via `prepared.execute({ name: "value" })`.
@@ -2481,9 +2583,15 @@ declare class ExecutableQuery<G extends GraphDef, Aliases extends AliasMap, Edge
     /**
      * Executes the query against a provided backend.
      *
-     * Used by `store.batch()` to run multiple queries over a single connection
-     * (e.g., within a transaction). The full compile → execute → transform
-     * pipeline runs identically to `execute()`, but against the given backend.
+     * Used by `store.batch()` to run several queries in sequence against one
+     * target — a transaction on backends that have them, the backend itself
+     * otherwise. The full compile → execute → transform pipeline runs
+     * identically to `execute()`, but against the given backend.
+     *
+     * Costs one statement, or two when the selective-field path runs and its
+     * mapping then falls back: `#tryOptimizedExecutionOn` detects that only
+     * after its statement has executed, and the caller re-runs the full fetch.
+     * The fallback clears the fast path for this instance.
      */
     executeOn(backend: GraphBackend | TransactionBackend): Promise<readonly R[]>;
     /**
@@ -3574,9 +3682,9 @@ declare class StoreSearch<G extends GraphDef> {
  * 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", "compileSql", "countEdgesByKind", "countEdgesFrom", "countNodesByKind", "createVectorIndex", "deleteEdge", "deleteEdgesBatch", "deleteEmbedding", "deleteFulltext", "deleteFulltextBatch", "deleteNode", "deleteUnique", "deleteVectorSlotContribution", "dialect", "dropVectorIndex", "edgeExistsBetween", "ensureContributionMaterializationsTable", "ensureFulltextTable", "ensureIndexMaterializationsTable", "ensureKindRemovalsTable", "ensureReconciliationMarkersTable", "ensureRevisionOriginsTable", "ensureRuntimeContributions", "ensureVectorSlotContribution", "ensureVectorSlotContributions", "execute", "executeTemporaryStatement", "findEdgesByKind", "findEdgesConnectedTo", "findNodesByKind", "fulltextSearch", "fulltextStrategy", "getActiveSchema", "getAllKindRemovals", "getContributionMaterialization", "getEdge", "getEdges", "getIndexMaterialization", "getIndexMaterializations", "getNode", "getNodes", "getPendingKindRemovals", "getReconciliationMarker", "getSchemaVersion", "hardDeleteEdge", "hardDeleteEdgesBatch", "hardDeleteNode", "hybridSearch", "insertEdge", "insertEdgeNoReturn", "insertEdgesBatch", "insertEdgesBatchReturning", "insertNode", "insertNodeNoReturn", "insertNodesBatch", "insertNodesBatchReturning", "insertUnique", "insertUniqueBatch", "recordContributionMaterialization", "recordIndexMaterialization", "recordKindRemoval", "refreshStatistics", "releaseIndexMaterializationClaim", "setActiveVersion", "setReconciliationMarker", "tableNames", "updateEdge", "updateNode", "upsertEmbedding", "upsertEmbeddingBatch", "upsertFulltext", "upsertFulltextBatch", "vectorSearch", "vectorStrategy"];
+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", "deleteFulltext", "deleteFulltextBatch", "deleteNode", "deleteUnique", "deleteVectorSlotContribution", "dialect", "dropVectorIndex", "edgeExistsBetween", "ensureContributionMaterializationsTable", "ensureFulltextTable", "ensureIndexMaterializationsTable", "ensureKindRemovalsTable", "ensureReconciliationMarkersTable", "ensureRevisionOriginsTable", "ensureRuntimeContributions", "ensureVectorSlotContribution", "ensureVectorSlotContributions", "execute", "executeTemporaryStatement", "findEdgesByKind", "findEdgesByEndpointSet", "findEdgesConnectedTo", "findNodesByKind", "fulltextSearch", "fulltextStrategy", "getActiveSchema", "getAllKindRemovals", "getContributionMaterialization", "getEdge", "getEdges", "getIndexMaterialization", "getIndexMaterializations", "getNode", "getNodes", "getPendingKindRemovals", "getReconciliationMarker", "getSchemaVersion", "hardDeleteEdge", "hardDeleteEdgesBatch", "hardDeleteNode", "hybridSearch", "insertEdge", "insertEdgeNoReturn", "insertEdgesBatch", "insertEdgesBatchReturning", "insertNode", "insertNodeNoReturn", "insertNodesBatch", "insertNodesBatchReturning", "insertUnique", "insertUniqueBatch", "recordContributionMaterialization", "recordIndexMaterialization", "recordKindRemoval", "refreshStatistics", "releaseIndexMaterializationClaim", "setActiveVersion", "setReconciliationMarker", "tableNames", "updateEdge", "updateNode", "upsertEmbedding", "upsertEmbeddingBatch", "upsertFulltext", "upsertFulltextBatch", "vectorSearch", "vectorStrategy", "verifyContributions"];
 type HistoryStoreBackendMember = (typeof HISTORY_STORE_BACKEND_KEYS)[number];
-type UnsafeHistoryStoreBackendMember = "clearGraph" | "executeDdl" | "executeRaw" | "executeStatement" | "transaction" | "trustedImport";
+type UnsafeHistoryStoreBackendMember = "clearGraph" | "executeDdl" | "executeRaw" | "executeStatement" | "schemaWriteTransaction" | "transaction" | "trustedImport";
 type UnclassifiedHistoryStoreBackendMember = Exclude<keyof GraphBackend, HistoryStoreBackendMember | UnsafeHistoryStoreBackendMember>;
 type HistoryStoreBackend = UnclassifiedHistoryStoreBackendMember extends never ? Readonly<Pick<GraphBackend, HistoryStoreBackendMember>> : never;
 
@@ -3662,8 +3770,8 @@ type UniqueIntrospection = Readonly<{
  * budget); the data deletion happens here, scoped per-deployment via
  * the `typegraph_kind_removals` status table. Splitting the verbs
  * mirrors how `materializeIndexes` complements `evolve`: schema
- * commits are atomic and fast, data work is bounded by row count and
- * deferrable / parallelizable.
+ * commits are atomic and fast, while data work is bounded by row count and
+ * deferrable. Candidates run sequentially because they share one graph lock.
  */
 
 type MaterializeRemovalsOptions = Readonly<{
@@ -3672,11 +3780,40 @@ type MaterializeRemovalsOptions = Readonly<{
     /** Halt on first failure. Default: false (best-effort). */
     stopOnError?: boolean;
 }>;
+/**
+ * Outcome of one queued kind removal, discriminated on `status`.
+ *
+ * A union rather than one shape with optional fields, so each outcome carries
+ * exactly its own payload: `"failed"` always has an `error`, `"skipped"`
+ * always has a `reason`, and `"removed"` has neither. The flat form permitted
+ * impossible states — a `"skipped"` with no reason, or a `"removed"` carrying
+ * `reason: "kind-is-live"` — and narrowing on `status` still left both fields
+ * optional at the use site.
+ */
 type MaterializeRemovalsEntry = Readonly<{
     kind: string;
     entity: KindEntity;
-    status: "removed" | "failed";
-    error?: Error;
+    status: "removed";
+}> | Readonly<{
+    kind: string;
+    entity: KindEntity;
+    status: "failed";
+    error: Error;
+}> | Readonly<{
+    kind: string;
+    entity: KindEntity;
+    status: "skipped";
+    /**
+     * `"kind-is-live"`: the active schema declares this kind again — it was
+     * dropped, then re-added — so deleting its rows would destroy live
+     * data. The queue row stays pending, so a later removal of the same
+     * kind still reclaims it.
+     *
+     * Reported rather than silent: an empty `results` array would otherwise
+     * be indistinguishable from "nothing was pending", leaving the queue at
+     * a non-zero depth with nothing explaining why.
+     */
+    reason: "kind-is-live";
 }>;
 /**
  * Outcome of reclaiming one per-`(graphId, kind, field)` vector table that
@@ -4007,6 +4144,7 @@ type StoreCore<G extends GraphDef> = Readonly<{
     materializeIndexes: (options?: MaterializeIndexesOptions) => Promise<MaterializeIndexesResult>;
     materializeSystemIndexes: (options?: MaterializeSystemIndexesOptions) => Promise<MaterializeIndexesResult>;
     reembedVectorField: (kind: string, fieldPath: string, options?: ReembedVectorFieldOptions) => Promise<ReembedVectorFieldResult>;
+    verifyContributions: () => Promise<readonly ContributionDiagnostic[]>;
     materializeRemovals: (options?: MaterializeRemovalsOptions) => Promise<MaterializeRemovalsResult>;
     close: () => Promise<void>;
 }>;
@@ -4185,6 +4323,10 @@ declare function createAdapterStore<G extends GraphDef, TNativeTransaction>(grap
  * - Initializes the schema on first run (version 1)
  * - Auto-migrates safe changes (additive changes)
  * - Throws MigrationError for breaking changes
+ * - Fences managed writes against concurrent schema-version commits; a stale Store
+ *   fails before writing instead of landing rows against a replaced schema
+ *   (official transactional backends only; unsupported custom backends fail
+ *   closed on their first managed write)
  *
  * @param graph - The graph definition
  * @param backend - The database backend
@@ -4245,6 +4387,11 @@ declare function createAdapterStoreWithSchema<G extends GraphDef, TNativeTransac
  *   initialized, or `StoreNotInitializedError` when the schema is
  *   current but the runtime-contribution markers are missing/stale.
  *   The runtime can use a least-privilege, DML-only database role.
+ *   Managed writes are fenced against concurrent schema-version commits just like
+ *   `createStoreWithSchema`; a stale verified Store fails before writing.
+ *   Runtime backends must support transactions and the schema-write fence;
+ *   unsupported custom or HTTP backends attach for reads but fail closed on a
+ *   managed write.
  * - **`createStore(graph, backend)`** is the same zero-DDL attach
  *   *without* the verification gate — fastest, but schema drift goes
  *   undetected until a hot-path operation trips.
@@ -4472,4 +4619,4 @@ declare class RecordedStoreView<G extends GraphDef> extends CoordinatePinnedView
     get edges(): RecordedStoreViewEdgeCollections<G>;
 }
 
-export { ExecutableAggregateQuery as $, type AliasMap as A, type BaseStoreOptions as B, type ConstraintNames as C, type DegreeOptions as D, type EdgeAliasMap as E, type DynamicNodeType as F, type DynamicSelectableEdge as G, type HistoryStoreOptions as H, type DynamicSelectableNode as I, type Edge as J, type EdgeAccessor as K, type LiveStoreOptions as L, type EdgeBatchReads as M, type EdgeCollection as N, type EdgeFindByEndpointsOptions as O, type EdgeGetOrCreateByEndpointsOptions as P, type QueryCoordinateState as Q, type RecordedReadStoreOptions as R, type StoreOptions as S, TraversalBuilder as T, type UnboundLiveStoreOptions as U, type EdgeGetOrCreateByEndpointsResult as V, type EdgeIntrospection as W, type EdgeTemporalReads as X, type EdgeWrites as Y, type EmptyAliasMap as Z, type EmptyEdgeAliasMap as _, type Store as a, type RecordedStoreViewEdgeCollections as a$, ExecutableQuery as a0, type FieldAccessor as a1, type FulltextSearchHit as a2, type FulltextSearchOptions as a3, type GetOrCreateAction as a4, type GraphAlgorithms as a5, type GraphEdgeCollections as a6, type GraphNodeCollections as a7, type HistoryStoreBackend as a8, type HookContext as a9, type NodeRef as aA, type NodeTemporalReads as aB, type NodeWrites as aC, type OntologyIntrospection as aD, type OperationHookContext as aE, type PageRankOptions as aF, type PageRankScore as aG, type PaginateOptions as aH, type PaginatedResult as aI, type PathNode as aJ, type PersonalizedPageRankOptions as aK, type PersonalizedPageRankSeed as aL, type Predicate as aM, PreparedQuery as aN, type PropsAccessor as aO, type QueryHookContext as aP, type QueryOptions as aQ, type ReachableNode as aR, type ReachableOptions as aS, type RebuildFulltextOptions as aT, type RebuildFulltextResult as aU, type ReclaimedVectorFieldEntry as aV, type ReconciledSchema as aW, type RecordedScanOptions as aX, type RecordedScanPage as aY, RecordedStoreView as aZ, type RecordedStoreViewEdgeCollection as a_, type HybridFulltextOptions as aa, type HybridSearchHit as ab, type HybridSearchOptions as ac, type HybridVectorOptions as ad, type IfExistsMode as ae, type InitialQueryBuilder as af, type KindIntrospection as ag, type LabelPropagationMembership as ah, type LabelPropagationOptions as ai, type MaterializeRemovalsEntry as aj, type MaterializeRemovalsOptions as ak, type MaterializeRemovalsResult as al, type MeasurableAdapterHistoryTransactionContext as am, type MeasurableAdapterTransactionContext as an, type MeasurableTransactionContext as ao, type NeighborsOptions as ap, type NoRecordedCoordinate as aq, type Node as ar, type NodeAccessor as as, type NodeAlias as at, type NodeBulkFindByIndexOptions as au, type NodeCollection as av, type NodeCurrentReads as aw, type NodeGetOrCreateByConstraintOptions as ax, type NodeGetOrCreateByConstraintResult as ay, type NodeIdentifier as az, type HistoryStore as b, createAdapterStoreWithSchema as b$, type RecordedStoreViewNodeCollection as b0, type RecordedStoreViewNodeCollections as b1, type RecursiveTraversalOptions as b2, type ReembedFunction as b3, type ReembedVectorFieldOptions as b4, type ReembedVectorFieldResult as b5, type SchemaIntrospection as b6, type ScopedMeasure as b7, type SearchScopeOptions as b8, type SelectContext as b9, type StoreViewWeightedShortestPathOptions as bA, type StreamOptions as bB, type SubgraphEdgeResult as bC, type SubgraphNodeResult as bD, type SubgraphOptions as bE, type SubgraphResult as bF, type SubsetEdge as bG, type SubsetNode as bH, type TemporalAlgorithmOptions as bI, type TransactionContext as bJ, type TransactionOutcome as bK, type TransactionReceipt as bL, type TraversalDirection as bM, type TypedEdgeCollection as bN, type TypedRecordedStoreViewEdgeCollection as bO, type TypedStoreViewEdgeCollection as bP, UnionableQuery as bQ, type UniqueIntrospection as bR, type UpdateEdgeInput as bS, type UpdateNodeInput as bT, type VectorSearchHit as bU, type VectorSearchOptions as bV, type WeaklyConnectedComponentMembership as bW, type WeaklyConnectedComponentsOptions as bX, type WeightedShortestPathOptions as bY, type WeightedShortestPathResult as bZ, createAdapterStore as b_, 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 RecordedReadStore as c, createQueryBuilder as c0, createStore as c1, createStoreWithSchema as c2, createVerifiedAdapterStore as c3, createVerifiedStore as c4, defineSubgraphProject as c5, exists as c6, fieldRef as c7, inSubquery as c8, isParameterRef as c9, notExists as ca, notInSubquery as cb, param as cc, type RecursiveAliasMap as d, QueryBuilder as e, type EmptyRecursiveAliasMap as f, type AdapterHistoryStore as g, type AdapterHistoryTransactionContext as h, type AdapterRecordedReadStore as i, type AdapterStore as j, type AdapterTransactionContext as k, type AggregateResult as l, type AlgorithmCyclePolicy as m, type AnyEdge as n, type AnyNode as o, type BaseTraversalOptions as p, type BatchResults as q, type BatchableQuery as r, type CreateEdgeInput as s, type CreateNodeInput as t, type DynamicEdgeAccessor as u, type DynamicEdgeCollection as v, type DynamicEdgeType as w, type DynamicFieldBuilder as x, type DynamicNodeAccessor as y, type DynamicNodeCollection as z };
+export { type EmptyAliasMap as $, type AliasMap as A, type BaseStoreOptions as B, type ConstraintNames as C, type DegreeOptions as D, type EdgeAliasMap as E, type DynamicNodeType as F, type DynamicSelectableEdge as G, type HistoryStoreOptions as H, type DynamicSelectableNode as I, type Edge as J, type EdgeAccessor as K, type LiveStoreOptions as L, type EdgeBatchReads as M, type EdgeBulkFindEndpointOptions as N, type EdgeBulkFindOptions as O, type EdgeCollection as P, type QueryCoordinateState as Q, type RecordedReadStoreOptions as R, type StoreOptions as S, TraversalBuilder as T, type UnboundLiveStoreOptions as U, type EdgeFindByEndpointsOptions as V, type EdgeGetOrCreateByEndpointsOptions as W, type EdgeGetOrCreateByEndpointsResult as X, type EdgeIntrospection as Y, type EdgeTemporalReads as Z, type EdgeWrites as _, type Store as a, RecordedStoreView as a$, type EmptyEdgeAliasMap as a0, ExecutableAggregateQuery as a1, ExecutableQuery as a2, type FieldAccessor as a3, type FulltextSearchHit as a4, type FulltextSearchOptions as a5, type GetOrCreateAction as a6, type GraphAlgorithms as a7, type GraphEdgeCollections as a8, type GraphNodeCollections as a9, type NodeGetOrCreateByConstraintResult as aA, type NodeIdentifier as aB, type NodeRef as aC, type NodeTemporalReads as aD, type NodeWrites as aE, type OntologyIntrospection as aF, type OperationHookContext as aG, type PageRankOptions as aH, type PageRankScore as aI, type PaginateOptions as aJ, type PaginatedResult as aK, type PathNode as aL, type PersonalizedPageRankOptions as aM, type PersonalizedPageRankSeed as aN, type Predicate as aO, PreparedQuery as aP, type PropsAccessor as aQ, type QueryHookContext as aR, type QueryOptions as aS, type ReachableNode as aT, type ReachableOptions as aU, type RebuildFulltextOptions as aV, type RebuildFulltextResult as aW, type ReclaimedVectorFieldEntry as aX, type ReconciledSchema as aY, type RecordedScanOptions as aZ, type RecordedScanPage as a_, type HistoryStoreBackend as aa, type HookContext as ab, type HybridFulltextOptions as ac, type HybridSearchHit as ad, type HybridSearchOptions as ae, type HybridVectorOptions 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 HistoryStore as b, type WeightedShortestPathResult as b$, type RecordedStoreViewEdgeCollection as b0, type RecordedStoreViewEdgeCollections as b1, type RecordedStoreViewNodeCollection as b2, type RecordedStoreViewNodeCollections as b3, type RecursiveTraversalOptions as b4, type ReembedFunction as b5, type ReembedVectorFieldOptions as b6, type ReembedVectorFieldResult as b7, type SchemaIntrospection as b8, type ScopedMeasure as b9, type StoreViewSubgraphOptions as bA, type StoreViewWeaklyConnectedComponentsOptions as bB, type StoreViewWeightedShortestPathOptions as bC, type StreamOptions as bD, type SubgraphEdgeResult as bE, type SubgraphNodeResult as bF, type SubgraphOptions as bG, type SubgraphResult as bH, type SubsetEdge as bI, type SubsetNode as bJ, type TemporalAlgorithmOptions as bK, type TransactionContext as bL, type TransactionOutcome as bM, type TransactionReceipt as bN, type TraversalDirection as bO, type TypedEdgeCollection as bP, type TypedRecordedStoreViewEdgeCollection as bQ, type TypedStoreViewEdgeCollection as bR, UnionableQuery as bS, type UniqueIntrospection as bT, type UpdateEdgeInput as bU, type UpdateNodeInput as bV, type VectorSearchHit as bW, type VectorSearchOptions as bX, type WeaklyConnectedComponentMembership as bY, type WeaklyConnectedComponentsOptions as bZ, type WeightedShortestPathOptions as b_, type SearchScopeOptions as ba, type SelectContext as bb, type SelectableEdge as bc, type SelectableNode as bd, type ShortestPathOptions as be, type ShortestPathResult as bf, type SqlAvailability as bg, type StoreHooks as bh, type StoreProjection as bi, type StoreRef as bj, StoreSearch as bk, StoreView as bl, type StoreViewCanReachOptions as bm, type StoreViewCoordinate as bn, type StoreViewDegreeOptions as bo, type StoreViewEdgeCollection as bp, type StoreViewEdgeCollections as bq, type StoreViewGraphAlgorithms as br, type StoreViewLabelPropagationOptions as bs, type StoreViewNeighborsOptions as bt, type StoreViewNodeCollection as bu, type StoreViewNodeCollections as bv, type StoreViewPageRankOptions as bw, type StoreViewPersonalizedPageRankOptions as bx, type StoreViewReachableOptions as by, type StoreViewShortestPathOptions as bz, type RecordedReadStore as c, createAdapterStore as c0, createAdapterStoreWithSchema as c1, createQueryBuilder as c2, createStore as c3, createStoreWithSchema as c4, createVerifiedAdapterStore as c5, createVerifiedStore as c6, defineSubgraphProject as c7, exists as c8, fieldRef as c9, inSubquery as ca, isParameterRef as cb, notExists as cc, notInSubquery as cd, param as ce, type RecursiveAliasMap as d, QueryBuilder as e, type EmptyRecursiveAliasMap as f, type AdapterHistoryStore as g, type AdapterHistoryTransactionContext as h, type AdapterRecordedReadStore as i, type AdapterStore as j, type AdapterTransactionContext as k, type AggregateResult as l, type AlgorithmCyclePolicy as m, type AnyEdge as n, type AnyNode as o, type BaseTraversalOptions as p, type BatchResults as q, type BatchableQuery as r, type CreateEdgeInput as s, type CreateNodeInput as t, type DynamicEdgeAccessor as u, type DynamicEdgeCollection as v, type DynamicEdgeType as w, type DynamicFieldBuilder as x, type DynamicNodeAccessor as y, type DynamicNodeCollection as z };

package/dist/{temporal-BtrTYTiB.d.ts → temporal--x9T8K4S.d.ts}

@@ -1,4 +1,4 @@
-import { T as TemporalMode } from './types-Dh-EgT-w.js';
+import { T as TemporalMode } from './types-Cjvkj0jA.js';
 
 declare const RECORDED_INSTANT_BRAND: unique symbol;
 /**

package/dist/{temporal-CMpigMCW.d.cts → temporal-BCORwUau.d.cts}

@@ -1,4 +1,4 @@
-import { T as TemporalMode } from './types-Dh-EgT-w.cjs';
+import { T as TemporalMode } from './types-Cjvkj0jA.cjs';
 
 declare const RECORDED_INSTANT_BRAND: unique symbol;
 /**

package/dist/{types-G4sVM-76.d.cts → types-6-WJmSD4.d.cts}

@@ -1,4 +1,4 @@
-import { K as KindEntity, J as JsonPointer } from './types-Dh-EgT-w.cjs';
+import { K as KindEntity, J as JsonPointer } from './types-Cjvkj0jA.cjs';
 
 /**
  * QueryProfiler types.

package/dist/{types-D2rU5Taq.d.ts → types-COODtTJU.d.ts}

@@ -1,4 +1,4 @@
-import { K as KindEntity, J as JsonPointer } from './types-Dh-EgT-w.js';
+import { K as KindEntity, J as JsonPointer } from './types-Cjvkj0jA.js';
 
 /**
  * QueryProfiler types.