@nicia-ai/typegraph 0.46.2 → 0.48.0

package/dist/{store-FTqBpuJD.d.cts → store-JUVvtmR4.d.cts}

@@ -1,9 +1,9 @@
 import { z } from 'zod';
-import { cw as ValueType, cx as PredicateExpression, aY as FulltextQueryMode, cy as VectorMetricType, Q as QueryAst, J as JsonPointer, ad as FieldRef, bo as ParameterRef, u as NodeType, v as AnyEdgeType, a5 as EdgeType, bV as TraversalExpansion, y as GraphBackend, S as SqlDialect, w as SqlSchema, cz as Traversal, cA as NodePredicate, cB as ProjectedField, bn as OrderSpec, cC as AggregateOrderSpec, T as TemporalMode, cD as GroupBySpec, b7 as HybridFusionOptions, bb as JsonPointerInput, cE as RecursiveCyclePolicy, d as GraphDef, ag as TraversalDirection$1, aO as EdgeRegistration, _ as NodeId, bS as TransactionBackend, ac as AggregateExpr, bG as SortDirection, ax as CompiledSelectSql, F as FulltextStrategy, V as VectorStrategy, cF as VectorSlotMap, cG as RecordedReadBinding, cH as SelectiveField, cI as ComposableQuery, cJ as SetOperationType, cK as SetOperation, G as GraphIdentityConfig, a1 as NodeKinds, cL as NodeRow, K as KindEntity, aR as ExternalRecordedReadSource, $ as EdgeId, cM as EdgeRow, bm as NodeRegistration, aM as EdgeKinds, bU as TransactionReadBackend, al as AllNodeTypes, a3 as KindAnnotations, X as JsonSchema, b_ as UniquenessScope, as as Collation, ar as Cardinality, aQ as EndpointExistence, b4 as GraphExtension, cN as VectorMetric, B as BackendCapabilities, C as ContributionDiagnostic, c as ContributionRepairResult, aD as ContributionProbeResult, aG as ContributionRebuildScope, aF as ContributionRebuildResult, bT as TransactionOptions, A as AdapterBackend } from './types-Du78EvpN.cjs';
-import { R as RecordedInstant, d as ReadCoordinate } from './temporal-CXewwLTB.cjs';
-import { S as SearchableMetadata, c as EmbeddingValue } from './searchable-BrUh0pdc.cjs';
-import { K as KindRegistry, S as SchemaManagerOptions, b as SchemaValidationResult } from './manager-ptr3JLRP.cjs';
-import { S as SchemaDiff, j as MaterializeIndexesOptions, M as MaterializeIndexesResult, k as MaterializeSystemIndexesOptions } from './materialize-indexes-BXz77YqO.cjs';
+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';
 
 type FieldTypeInfo = Readonly<{
     valueType: ValueType;
@@ -272,7 +272,11 @@ declare function notInSubquery(field: FieldRef, subquery: QueryAst): Predicate;
 
 declare const DYNAMIC_NODE_BRAND: unique symbol;
 declare const DYNAMIC_EDGE_BRAND: unique symbol;
-type DynamicNodeType = NodeType & Readonly<{
+/** A runtime-registered node kind whose collection lookup preserved `K`. */
+type DynamicNodeKind<K extends string = string> = K & Readonly<{
+    [DYNAMIC_NODE_BRAND]: true;
+}>;
+type DynamicNodeType<K extends string = string> = NodeType<DynamicNodeKind<K>> & Readonly<{
     [DYNAMIC_NODE_BRAND]: true;
 }>;
 type DynamicEdgeType = AnyEdgeType & Readonly<{
@@ -1643,6 +1647,13 @@ declare const RECORDED_POINT_READ_NAMES: readonly ["getById", "getByIds"];
  * Store types for TypeGraph operations.
  */
 
+/**
+ * An explicit validity-end mutation. Omission preserves the stored end,
+ * `validTo` sets it, and `clearValidTo` reopens the window. The union keeps the
+ * two write actions mutually exclusive without exposing public `null`.
+ */
+type ValidityEndMutation = BackendValidityEndMutation;
+
 /**
  * Canonical mapping from snake_case row fields to camelCase meta fields.
  *
@@ -1707,8 +1718,7 @@ type UpdateNodeInput<N extends NodeType = NodeType> = Readonly<{
     kind: N["kind"];
     id: NodeId<N>;
     props: Partial<z.infer<N["schema"]>>;
-    validTo?: string;
-}>;
+}> & ValidityEndMutation;
 /**
  * Metadata for an edge instance.
  * Derived from EdgeRow via TemporalMetaFieldMap (edges have no version).
@@ -1750,8 +1760,7 @@ type CreateEdgeInput<E extends AnyEdgeType = EdgeType> = Readonly<{
 type UpdateEdgeInput<E extends AnyEdgeType = EdgeType> = Readonly<{
     id: EdgeId<E>;
     props: Partial<z.infer<E["schema"]>>;
-    validTo?: string;
-}>;
+}> & ValidityEndMutation;
 /**
  * Options for node and edge queries.
  */
@@ -1921,9 +1930,9 @@ type BaseStoreOptions = Readonly<{
      */
     autoRefreshStatistics?: false | number;
     /**
-     * Skip the write for an `upsertById` (or `bulkUpsertById` item) whose
-     * validated props are value-identical to the existing live row. Default
-     * off.
+     * Skip the write for an `upsertById`, `bulkUpsertById` item, or endpoint
+     * get-or-create update whose validated props are value-identical to the
+     * existing live row. Default off.
      *
      * Enable this for at-least-once / replay materializers. An event log that
      * re-delivers a byte-identical change would otherwise rewrite the row anyway:
@@ -1944,7 +1953,12 @@ type BaseStoreOptions = Readonly<{
      * **no write at all**: no `updateNode`, no recorded-time capture, no history
      * row, no revision-anchor advance, and no `update` operation hooks (nothing
      * happened, so nothing is reported). It resolves with the **existing** node,
-     * preserving its original `validFrom` / `updatedAt` / `version`.
+     * preserving its original `validFrom` / `updatedAt` / `version`. An endpoint
+     * get-or-create reports action `"found"` when its requested update is
+     * coalesced; `"updated"` always means an UPDATE actually ran.
+     * Node `getOrCreateByConstraint` updates are outside this option's scope and
+     * still write on every `ifExists: "update"` match; replay projectors that
+     * need coalescing should use `upsertById` for nodes.
      *
      * Receipt shape is unchanged and needs no new signal: a coalesced upsert
      * still counts as one write intent (`writes.total` includes it), but
@@ -1960,9 +1974,8 @@ type BaseStoreOptions = Readonly<{
      *      batch already queued (a create or an update).
      *   2. That row is not soft-deleted (a deleted row resurrects — a real
      *      change — and is never coalesced).
-     *   3. The caller passed no explicit `validFrom` / `validTo` (an explicit
-     *      temporal override is a deliberate request and is never coalesced;
-     *      applied per item in the bulk path).
+     *   3. Any requested `validFrom` / `validTo` names the window already stored;
+     *      a changed or inapplicable temporal request reaches the write path.
      *   4. The new props, merged over the stored props and run through the
      *      kind's Zod schema (defaults applied, values normalized), are deeply
      *      value-identical to the stored props (key order aside).
@@ -2240,13 +2253,7 @@ type EdgeGetOrCreateByEndpointsOptions<E extends AnyEdgeType> = Readonly<{
      * properties and `validTo`.
      */
     onImmutableLowerBound?: "preserve" | "refuse";
-    /**
-     * Valid-time end for a created, updated, or resurrected edge. Ignored when
-     * the operation returns an existing edge without writing. May not precede
-     * the row's effective start; see `INVERTED_VALIDITY_WINDOW_CODE`.
-     */
-    validTo?: string;
-}>;
+}> & ValidityEndMutation;
 /**
  * A collection of nodes of a specific type.
  *
@@ -2256,7 +2263,11 @@ type NodeCollection<N extends NodeType, CN extends string = string> = Readonly<{
     /**
      * Create a new node.
      *
-     * `validFrom` defaults to the operation's creation timestamp when omitted.
+     * `validFrom` defaults to the operation's creation timestamp when omitted —
+     * unless a stated `validTo` at or before that instant would leave the row
+     * readable at no coordinate, in which case the row is stored with NO lower
+     * bound ("ended at T, start unknown") and `meta.validFrom` reads back as
+     * `undefined`. A future `validTo` is unaffected.
      */
     create: (props: z.input<N["schema"]>, options?: Readonly<{
         id?: string;
@@ -2267,10 +2278,11 @@ type NodeCollection<N extends NodeType, CN extends string = string> = Readonly<{
     getById: (id: NodeId<N>, options?: QueryOptions) => Promise<Node<N> | undefined>;
     /** Get multiple nodes by ID, preserving input order (undefined for missing) */
     getByIds: (ids: readonly NodeId<N>[], options?: QueryOptions) => Promise<readonly (Node<N> | undefined)[]>;
-    /** Update a node */
-    update: (id: NodeId<N>, props: Partial<z.input<N["schema"]>>, options?: Readonly<{
-        validTo?: string;
-    }>) => Promise<Node<N>>;
+    /**
+     * Update a node's properties and optionally set or clear its validity end.
+     * Omitting both end options preserves the stored window.
+     */
+    update: (id: NodeId<N>, props: Partial<z.input<N["schema"]>>, options?: ValidityEndMutation) => Promise<Node<N>>;
     /**
      * Updates every current node selected by the supplied predicates in one
      * set-based write. Relationship clauses are independent EXISTS predicates
@@ -2324,7 +2336,11 @@ type NodeCollection<N extends NodeType, CN extends string = string> = Readonly<{
      * the data shape is determined at runtime, not compile time.
      * The return type is fully typed — only the input gate is relaxed.
      *
-     * `validFrom` defaults to the operation's creation timestamp when omitted.
+     * `validFrom` defaults to the operation's creation timestamp when omitted —
+     * unless a stated `validTo` at or before that instant would leave the row
+     * readable at no coordinate, in which case the row is stored with NO lower
+     * bound ("ended at T, start unknown") and `meta.validFrom` reads back as
+     * `undefined`. A future `validTo` is unaffected.
      */
     createFromRecord: (data: Record<string, unknown>, options?: Readonly<{
         id?: string;
@@ -2339,9 +2355,15 @@ type NodeCollection<N extends NodeType, CN extends string = string> = Readonly<{
      *
      * `validFrom` applies when the upsert CREATES the row and when it RESURRECTS
      * a tombstoned one — both write a fresh validity window — defaulting to the
-     * operation's timestamp when omitted. An update to a LIVE row stores no lower
-     * bound, because that row's is already history, so one naming a different
-     * instant is REFUSED (`ValidationError` carrying
+     * operation's timestamp when omitted. That default is dropped when a stated
+     * `validTo` at or before the write instant would leave the row readable at no
+     * coordinate: NO lower bound is stored ("ended at T, start unknown") and
+     * `meta.validFrom` reads back as `undefined`. A RESURRECTION takes the same
+     * exception, decided against the instant it samples, so one stated window
+     * reaches ONE stored shape whether the id is fresh or names a tombstone. An
+     * update to a LIVE row stores no lower bound, because that row's is already
+     * history, so one naming a different instant is REFUSED (`ValidationError`
+     * carrying
      * `IMMUTABLE_VALIDITY_LOWER_BOUND_CODE`) rather than ignored. Restating the
      * bound the row already holds is accepted and changes nothing. Set
      * `onImmutableLowerBound: "preserve"` for event materializers whose
@@ -2350,9 +2372,8 @@ type NodeCollection<N extends NodeType, CN extends string = string> = Readonly<{
      */
     upsertById: (id: string, props: z.input<N["schema"]>, options?: Readonly<{
         validFrom?: string;
-        validTo?: string;
         onImmutableLowerBound?: "preserve" | "refuse";
-    }>) => Promise<Node<N>>;
+    }> & ValidityEndMutation) => Promise<Node<N>>;
     /**
      * Upsert a node from untyped data, relying on runtime Zod validation.
      *
@@ -2362,25 +2383,34 @@ type NodeCollection<N extends NodeType, CN extends string = string> = Readonly<{
      *
      * `validFrom` applies when the upsert CREATES the row and when it RESURRECTS
      * a tombstoned one — both write a fresh validity window — defaulting to the
-     * operation's timestamp when omitted. An update to a LIVE row stores no lower
-     * bound, because that row's is already history, so one naming a different
-     * instant is REFUSED (`ValidationError` carrying
+     * operation's timestamp when omitted. That default is dropped when a stated
+     * `validTo` at or before the write instant would leave the row readable at no
+     * coordinate: NO lower bound is stored ("ended at T, start unknown") and
+     * `meta.validFrom` reads back as `undefined`. A RESURRECTION takes the same
+     * exception, decided against the instant it samples, so one stated window
+     * reaches ONE stored shape whether the id is fresh or names a tombstone. An
+     * update to a LIVE row stores no lower bound, because that row's is already
+     * history, so one naming a different instant is REFUSED (`ValidationError`
+     * carrying
      * `IMMUTABLE_VALIDITY_LOWER_BOUND_CODE`) rather than ignored. Restating the
      * bound the row already holds is accepted and changes nothing. Set
      * `onImmutableLowerBound: "preserve"` for create/resurrection-only input.
      */
     upsertByIdFromRecord: (id: string, data: Record<string, unknown>, options?: Readonly<{
         validFrom?: string;
-        validTo?: string;
         onImmutableLowerBound?: "preserve" | "refuse";
-    }>) => Promise<Node<N>>;
+    }> & ValidityEndMutation) => Promise<Node<N>>;
     /**
      * Create multiple nodes in a batch.
      *
      * More efficient than calling create() multiple times.
      * Use `bulkInsert` for the dedicated fast path that skips returning results.
      *
-     * `validFrom` defaults to the operation's creation timestamp when omitted.
+     * `validFrom` defaults to the operation's creation timestamp when omitted —
+     * unless a stated `validTo` at or before that instant would leave the row
+     * readable at no coordinate, in which case the row is stored with NO lower
+     * bound ("ended at T, start unknown") and `meta.validFrom` reads back as
+     * `undefined`. A future `validTo` is unaffected.
      */
     bulkCreate: (items: readonly Readonly<{
         props: z.input<N["schema"]>;
@@ -2402,7 +2432,12 @@ type NodeCollection<N extends NodeType, CN extends string = string> = Readonly<{
      *
      * `validFrom` applies when the upsert CREATES the row and when it RESURRECTS
      * a tombstoned one — both write a fresh validity window — defaulting to the
-     * operation's timestamp when omitted. An update to a LIVE row stores no lower
+     * operation's timestamp when omitted. That default is dropped when a stated
+     * `validTo` at or before the write instant would leave the row readable at no
+     * coordinate: NO lower bound is stored ("ended at T, start unknown") and
+     * `meta.validFrom` reads back as `undefined`. A RESURRECTION takes the same
+     * exception, decided against the instant it samples, so one stated window
+     * reaches ONE stored shape whether the id is fresh or names a tombstone. An update to a LIVE row stores no lower
      * bound, because that row's is already history, so one naming a different
      * instant is REFUSED (`ValidationError` carrying
      * `IMMUTABLE_VALIDITY_LOWER_BOUND_CODE`) rather than ignored. Restating the
@@ -2423,13 +2458,12 @@ type NodeCollection<N extends NodeType, CN extends string = string> = Readonly<{
      * the workaround is to split the handoff across two batches (release, then
      * claim) or to apply those items as sequential `upsertById` calls.
      */
-    bulkUpsertById: (items: readonly Readonly<{
+    bulkUpsertById: (items: readonly (Readonly<{
         id: string;
         props: z.input<N["schema"]>;
         validFrom?: string;
-        validTo?: string;
         onImmutableLowerBound?: "preserve" | "refuse";
-    }>[]) => Promise<Node<N>[]>;
+    }> & ValidityEndMutation)[]) => Promise<Node<N>[]>;
     /**
      * Insert multiple nodes without returning results.
      *
@@ -2437,7 +2471,11 @@ type NodeCollection<N extends NodeType, CN extends string = string> = Readonly<{
      * with `returnResults: false`, the intent is unambiguous: no results
      * are returned and the operation is wrapped in a transaction.
      *
-     * `validFrom` defaults to the operation's creation timestamp when omitted.
+     * `validFrom` defaults to the operation's creation timestamp when omitted —
+     * unless a stated `validTo` at or before that instant would leave the row
+     * readable at no coordinate, in which case the row is stored with NO lower
+     * bound ("ended at T, start unknown") and `meta.validFrom` reads back as
+     * `undefined`. A future `validTo` is unaffected.
      */
     bulkInsert: (items: readonly Readonly<{
         props: z.input<N["schema"]>;
@@ -2572,7 +2610,11 @@ type EdgeCollection<E extends AnyEdgeType, From extends NodeType = NodeType, To
     /**
      * Create a new edge.
      *
-     * `validFrom` defaults to the operation's creation timestamp when omitted.
+     * `validFrom` defaults to the operation's creation timestamp when omitted —
+     * unless a stated `validTo` at or before that instant would leave the row
+     * readable at no coordinate, in which case the row is stored with NO lower
+     * bound ("ended at T, start unknown") and `meta.validFrom` reads back as
+     * `undefined`. A future `validTo` is unaffected.
      *
      * @param from - Source node (must be one of the allowed 'from' types)
      * @param to - Target node (must be one of the allowed 'to' types)
@@ -2583,10 +2625,11 @@ type EdgeCollection<E extends AnyEdgeType, From extends NodeType = NodeType, To
     getById: (id: EdgeId<E>, options?: QueryOptions) => Promise<Edge<E, From, To> | undefined>;
     /** Get multiple edges by ID, preserving input order (undefined for missing) */
     getByIds: (ids: readonly EdgeId<E>[], options?: QueryOptions) => Promise<readonly (Edge<E, From, To> | undefined)[]>;
-    /** Update an edge's properties */
-    update: (id: EdgeId<E>, props: Partial<z.input<E["schema"]>>, options?: Readonly<{
-        validTo?: string;
-    }>) => Promise<Edge<E, From, To>>;
+    /**
+     * Update an edge's properties and optionally set or clear its validity end.
+     * Reopening a `oneActive` edge rechecks cardinality before the write.
+     */
+    update: (id: EdgeId<E>, props: Partial<z.input<E["schema"]>>, options?: ValidityEndMutation) => Promise<Edge<E, From, To>>;
     /**
      * Find edges from a specific node.
      *
@@ -2695,7 +2738,11 @@ type EdgeCollection<E extends AnyEdgeType, From extends NodeType = NodeType, To
      * More efficient than calling create() multiple times.
      * Use `bulkInsert` for the dedicated fast path that skips returning results.
      *
-     * `validFrom` defaults to the operation's creation timestamp when omitted.
+     * `validFrom` defaults to the operation's creation timestamp when omitted —
+     * unless a stated `validTo` at or before that instant would leave the row
+     * readable at no coordinate, in which case the row is stored with NO lower
+     * bound ("ended at T, start unknown") and `meta.validFrom` reads back as
+     * `undefined`. A future `validTo` is unaffected.
      */
     bulkCreate: (items: readonly Readonly<{
         from: NodeRef<From>;
@@ -2720,11 +2767,16 @@ type EdgeCollection<E extends AnyEdgeType, From extends NodeType = NodeType, To
      * is refused with `ValidationError` carrying
      * `EDGE_IDENTITY_MISMATCH_CODE`; it is never silently ignored.
      *
-     * `validFrom` applies when the upsert CREATES the row and when it RESURRECTS
-     * a tombstoned one — both write a fresh validity window — defaulting to the
-     * operation's timestamp when omitted. An update to a LIVE row stores no lower
-     * bound, because that row's is already history, so one naming a different
-     * instant is REFUSED (`ValidationError` carrying
+     * `validFrom` applies when the upsert CREATES the edge and when it RESURRECTS
+     * a tombstoned one. A create writes a fresh validity window, defaulting to the
+     * operation's timestamp when omitted — unless a stated `validTo` at or before
+     * that instant would leave the row readable at no coordinate, in which case NO
+     * lower bound is stored ("ended at T, start unknown") and `meta.validFrom`
+     * reads back as `undefined`. A resurrection stamps nothing: an edge RETAINS
+     * its stored lower bound unless the item names a new one, so a `validTo`
+     * before the retained bound is REFUSED rather than stamped over. An update to
+     * a LIVE row stores no lower bound, because that row's is already history, so
+     * one naming a different instant is REFUSED (`ValidationError` carrying
      * `IMMUTABLE_VALIDITY_LOWER_BOUND_CODE`) rather than ignored. Restating the
      * bound the row already holds is accepted and changes nothing.
      *
@@ -2740,14 +2792,13 @@ type EdgeCollection<E extends AnyEdgeType, From extends NodeType = NodeType, To
      * than silent, and the workaround is to split the handoff across two batches
      * (free the slot, then claim it) or to apply those items individually.
      */
-    bulkUpsertById: (items: readonly Readonly<{
+    bulkUpsertById: (items: readonly (Readonly<{
         id: EdgeId<E>;
         from: NodeRef<From>;
         to: NodeRef<To>;
         props?: z.input<E["schema"]>;
         validFrom?: string;
-        validTo?: string;
-    }>[]) => Promise<Edge<E, From, To>[]>;
+    }> & ValidityEndMutation)[]) => Promise<Edge<E, From, To>[]>;
     /**
      * Insert multiple edges without returning results.
      *
@@ -2755,7 +2806,11 @@ type EdgeCollection<E extends AnyEdgeType, From extends NodeType = NodeType, To
      * with `returnResults: false`, the intent is unambiguous: no results
      * are returned and the operation is wrapped in a transaction.
      *
-     * `validFrom` defaults to the operation's creation timestamp when omitted.
+     * `validFrom` defaults to the operation's creation timestamp when omitted —
+     * unless a stated `validTo` at or before that instant would leave the row
+     * readable at no coordinate, in which case the row is stored with NO lower
+     * bound ("ended at T, start unknown") and `meta.validFrom` reads back as
+     * `undefined`. A future `validTo` is unaffected.
      */
     bulkInsert: (items: readonly Readonly<{
         from: NodeRef<From>;
@@ -2802,8 +2857,13 @@ type EdgeCollection<E extends AnyEdgeType, From extends NodeType = NodeType, To
      * property fields, only edges whose properties match on those fields are considered.
      * Soft-deleted matches are resurrected when cardinality allows.
      *
-     * `validFrom` applies on the create and RESURRECT branches, defaulting to the
-     * operation's creation timestamp when omitted. On the `ifExists: "update"`
+     * `validFrom` applies on the create and RESURRECT branches. A create defaults
+     * it to the operation's creation timestamp when omitted — unless a stated
+     * `validTo` at or before that instant would leave the row readable at no
+     * coordinate, in which case no lower bound is stored ("ended at T, start
+     * unknown"). A resurrection stamps nothing: an edge RETAINS its stored lower
+     * bound unless the call names a new one, so a `validTo` before the retained
+     * bound is REFUSED rather than stamped over. On the `ifExists: "update"`
      * branch a live edge's lower bound is history and cannot be stored, so a
      * `validFrom` naming a different instant is REFUSED (`ValidationError`
      * carrying `IMMUTABLE_VALIDITY_LOWER_BOUND_CODE`); restating the bound the
@@ -2824,14 +2884,13 @@ type EdgeCollection<E extends AnyEdgeType, From extends NodeType = NodeType, To
      * Results are returned in the same order as the input items.
      * Atomic when the backend supports transactions.
      */
-    bulkGetOrCreateByEndpoints: (items: readonly Readonly<{
+    bulkGetOrCreateByEndpoints: (items: readonly (Readonly<{
         from: NodeRef<From>;
         to: NodeRef<To>;
         props: z.input<E["schema"]>;
         validFrom?: string;
-        validTo?: string;
         onImmutableLowerBound?: "preserve" | "refuse";
-    }>[], options?: Pick<EdgeGetOrCreateByEndpointsOptions<E>, "matchOn" | "ifExists">) => Promise<EdgeGetOrCreateByEndpointsResult<E, From, To>[]>;
+    }> & ValidityEndMutation)[], options?: Pick<EdgeGetOrCreateByEndpointsOptions<E>, "matchOn" | "ifExists">) => Promise<EdgeGetOrCreateByEndpointsResult<E, From, To>[]>;
 }>;
 /**
  * Extract uniqueness constraint names from a NodeRegistration.
@@ -3042,7 +3101,7 @@ type TransactionCollections<G extends GraphDef> = Readonly<{
      * `Store.getNodeCollection`. Returns `undefined` when `kind` is not
      * registered in this graph.
      */
-    getNodeCollection: (kind: string) => DynamicNodeCollection | undefined;
+    getNodeCollection: <const K extends string>(kind: K) => DynamicNodeCollection<K> | undefined;
 }> & (G["identity"] extends GraphIdentityConfig ? Readonly<{
     identity: IdentityFacade<G>;
 }> : Readonly<Record<never, never>>);
@@ -3098,6 +3157,20 @@ type MeasurableTransactionContext<G extends GraphDef> = TransactionContext<G> &
 type MeasurableAdapterTransactionContext<G extends GraphDef, TNativeTransaction> = AdapterTransactionContext<G, TNativeTransaction> & Readonly<{
     measure: ScopedMeasure<MeasurableAdapterTransactionContext<G, TNativeTransaction>>;
 }>;
+/**
+ * A node returned by a runtime string-keyed collection.
+ *
+ * Its nominal node-type brand proves the value passed through the dynamic
+ * collection API while its properties remain runtime-schema-shaped.
+ */
+type DynamicNode<K extends string = string> = Node<DynamicNodeType<K>>;
+declare const DYNAMIC_NODE_REFERENCE_BRAND: unique symbol;
+/** A nominal lightweight reference returned by runtime-aware identity reads. */
+type DynamicNodeReference<K extends string = string> = Readonly<{
+    kind: DynamicNodeKind<K>;
+    id: NodeId<DynamicNodeType<K>>;
+    [DYNAMIC_NODE_REFERENCE_BRAND]: true;
+}>;
 /**
  * Replace branded `NodeId` / `EdgeId` with plain `string` in each
  * method's parameter list. Return types are preserved unchanged.
@@ -3122,15 +3195,15 @@ type UnbrandRecord<T extends Record<string, unknown>> = {
  * A node collection with widened generics for runtime string-keyed access.
  *
  * This is the return type of `store.getNodeCollection(kind)`. It exposes
- * the full `NodeCollection` API but with `NodeType` and `string` constraint
- * names instead of the specific generic parameters, since the concrete type
- * is not known at compile time.
+ * the full `NodeCollection` API but with a nominal `DynamicNodeType` and
+ * `string` constraint names instead of the specific generic parameters, since
+ * the concrete type is not known at compile time.
  *
  * ID parameters accept plain `string` instead of branded `NodeId<N>`, since
  * the dynamic path typically receives IDs from edge metadata, snapshots,
  * or external input where the brand is not available.
  */
-type DynamicNodeCollection = WidenBrandedIds<NodeCollection<NodeType, string>>;
+type DynamicNodeCollection<K extends string = string> = WidenBrandedIds<NodeCollection<DynamicNodeType<K>, string>>;
 /**
  * An edge collection with widened generics for runtime string-keyed access.
  *
@@ -3182,19 +3255,28 @@ type StoreProjection<G extends GraphDef, N extends keyof G["nodes"] & string = n
 }>;
 
 /**
- * The loose *input* form every identity facade method accepts: a whole node, a
- * bare id, or a `{ kind, id }` pair, for any node kind in the graph. Its kind
- * and id are independent, so a caller can pass what it already has without
- * re-correlating them.
+ * The accepted *input* form for every identity facade method: a whole node or
+ * a `{ kind, id }` pair for any compile-time graph kind, plus a proof-bearing
+ * node or reference produced through the runtime collection lane. Runtime
+ * values stay nominal so accepting them does not make an arbitrary
+ * `{ kind: string, id: string }` object type-safe.
+ *
+ * Identity results use {@link IdentityNodeReference}, which honestly includes
+ * runtime kinds because an evolved kind can belong to a class reached from a
+ * compile-time node.
+ */
+type IdentityNodeRefInput<G extends GraphDef> = NodeRef<AllNodeTypes<G>> | DynamicNode | DynamicNodeReference;
+/**
+ * A node reference returned by Operational Identity.
  *
- * Identity *results* use the strict {@link GraphNodeReference} instead, whose
- * `kind` and branded `id` stay correlated.
+ * Identity classes can contain runtime-evolved kinds even when a read starts
+ * from a compile-time node, so results honestly include both lanes.
  */
-type IdentityNodeRefInput<G extends GraphDef> = NodeRef<AllNodeTypes<G>>;
-/** A hydrated identity member, discriminated by its registered node kind. */
+type IdentityNodeReference<G extends GraphDef> = GraphNodeReference<G> | DynamicNodeReference;
+/** A hydrated compile-time or runtime identity member. */
 type IdentityNode<G extends GraphDef> = {
     [K in NodeKinds<G>]: Node<G["nodes"][K]["type"]>;
-}[NodeKinds<G>];
+}[NodeKinds<G>] | DynamicNode;
 declare const __identityAssertionId: unique symbol;
 type IdentityAssertionId = string & Readonly<{
     [__identityAssertionId]: true;
@@ -3224,8 +3306,8 @@ type IdentityRelation = "same" | "different";
 type IdentityAssertion<G extends GraphDef> = Readonly<{
     id: IdentityAssertionId;
     relation: IdentityRelation;
-    a: GraphNodeReference<G>;
-    b: GraphNodeReference<G>;
+    a: IdentityNodeReference<G>;
+    b: IdentityNodeReference<G>;
     validFrom: string;
     validTo?: string;
 }>;
@@ -3234,11 +3316,16 @@ type IdentityAssertionResult<G extends GraphDef> = Readonly<{
     assertion: IdentityAssertion<G>;
     action: "created" | "existing";
 }>;
+/** The half-open effective-time window of an identity assertion. */
+type IdentityValidityWindow = Readonly<{
+    validFrom?: string;
+    validTo?: string;
+}>;
 /** One ordered node pair handed to `bulkAssertSame` / `bulkAssertDifferent`. */
 type IdentityPair<G extends GraphDef> = Readonly<{
     a: IdentityNodeRefInput<G>;
     b: IdentityNodeRefInput<G>;
-}>;
+}> & IdentityValidityWindow;
 /**
  * The read half of the identity surface: equivalence-set membership,
  * representative selection, and the assertions behind them.
@@ -3248,8 +3335,8 @@ type IdentityPair<G extends GraphDef> = Readonly<{
  * The full read+write surface is {@link IdentityFacade}.
  */
 type IdentityReadFacade<G extends GraphDef> = Readonly<{
-    representativeOf: (ref: IdentityNodeRefInput<G>) => Promise<GraphNodeReference<G> | undefined>;
-    membersOf: (ref: IdentityNodeRefInput<G>) => Promise<readonly GraphNodeReference<G>[]>;
+    representativeOf: (ref: IdentityNodeRefInput<G>) => Promise<IdentityNodeReference<G> | undefined>;
+    membersOf: (ref: IdentityNodeRefInput<G>) => Promise<readonly IdentityNodeReference<G>[]>;
     nodesOf: (ref: IdentityNodeRefInput<G>) => Promise<readonly IdentityNode<G>[]>;
     areSame: (a: IdentityNodeRefInput<G>, b: IdentityNodeRefInput<G>) => Promise<boolean>;
     areDifferent: (a: IdentityNodeRefInput<G>, b: IdentityNodeRefInput<G>) => Promise<boolean>;
@@ -3265,8 +3352,8 @@ type IdentityReadFacade<G extends GraphDef> = Readonly<{
  * `action: "existing"` rather than duplicating it.
  */
 type IdentityFacade<G extends GraphDef> = IdentityReadFacade<G> & Readonly<{
-    assertSame: (a: IdentityNodeRefInput<G>, b: IdentityNodeRefInput<G>) => Promise<IdentityAssertionResult<G>>;
-    assertDifferent: (a: IdentityNodeRefInput<G>, b: IdentityNodeRefInput<G>) => Promise<IdentityAssertionResult<G>>;
+    assertSame: (a: IdentityNodeRefInput<G>, b: IdentityNodeRefInput<G>, window?: IdentityValidityWindow) => Promise<IdentityAssertionResult<G>>;
+    assertDifferent: (a: IdentityNodeRefInput<G>, b: IdentityNodeRefInput<G>, window?: IdentityValidityWindow) => Promise<IdentityAssertionResult<G>>;
     bulkAssertSame: (pairs: readonly IdentityPair<G>[]) => Promise<readonly IdentityAssertionResult<G>[]>;
     bulkAssertDifferent: (pairs: readonly IdentityPair<G>[]) => Promise<readonly IdentityAssertionResult<G>[]>;
     retractAssertion: (id: IdentityAssertionId) => Promise<IdentityAssertion<G> | undefined>;
@@ -3733,7 +3820,7 @@ type InternalGraphAlgorithms<G extends GraphDef> = Readonly<{
  */
 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"];
 type HistoryStoreBackendMember = (typeof HISTORY_STORE_BACKEND_KEYS)[number];
-type UnsafeHistoryStoreBackendMember = "clearGraph" | "commitSchemaVersionWithPreflight" | "executeDdl" | "executeRaw" | "executeStatement" | "ensureIdentityTables" | "identityTableDdl" | "rebuildContribution" | "repairContributions" | "schemaWriteTransaction" | "transaction" | "trustedImport";
+type UnsafeHistoryStoreBackendMember = "clearGraph" | "commitSchemaVersionWithPreflight" | "executeDdl" | "executeRaw" | "executeStatement" | "ensureIdentityTables" | "ensureTrigramExtension" | "identityTableDdl" | "rebuildContribution" | "repairContributions" | "schemaWriteTransaction" | "transaction" | "trustedImport";
 type UnclassifiedHistoryStoreBackendMember = Exclude<keyof GraphBackend, HistoryStoreBackendMember | UnsafeHistoryStoreBackendMember>;
 type HistoryStoreBackend = UnclassifiedHistoryStoreBackendMember extends never ? Readonly<Pick<GraphBackend, HistoryStoreBackendMember>> : never;
 
@@ -4068,6 +4155,22 @@ declare const STORE_RUNTIME: unique symbol;
  */
 type StoreRuntime<G extends GraphDef> = Readonly<{
     backend: GraphBackend;
+    /**
+     * @internal The backend this Store's queries actually execute through for
+     * `target` — the Store's own backend when `target` is omitted.
+     *
+     * It is the SAME private construction the query path uses rather than a
+     * reconstruction of it, because the object it returns is the one a lost
+     * derivation corrupts: the hooked query backend is a transient local inside
+     * query construction that is stored nowhere, so no other handle on it exists
+     * and a regression there is invisible to every assertion about
+     * {@link StoreRuntime.backend}.
+     *
+     * NOTE for anything asserting on it: with no query hook configured this
+     * returns its argument unchanged, so a hookless Store answers with the very
+     * object it was handed and a comparison against that object is a tautology.
+     */
+    queryBackend: (target?: GraphBackend | TransactionBackend) => GraphBackend;
     sealedQuery: (coordinate: ReadCoordinate) => InitialQueryBuilder<G, "sealed">;
     recordedNodeGetById: <N extends NodeType>(kind: string, id: NodeId<N>, coordinate: ReadCoordinate) => Promise<Node<N> | undefined>;
     recordedNodeGetByIds: <N extends NodeType>(kind: string, ids: readonly NodeId<N>[], coordinate: ReadCoordinate) => Promise<readonly (Node<N> | undefined)[]>;
@@ -4080,6 +4183,22 @@ type StoreRuntime<G extends GraphDef> = Readonly<{
     identityAtCoordinate: (coordinate: ReadCoordinate) => IdentityReadFacade<G>;
     rebuildIdentityClosure: () => Promise<void>;
     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.
+     */
+    applyResolvedNodeUniqueness: <Output>(target: TransactionBackend, writes: Readonly<{
+        upserts: readonly Readonly<{
+            kind: string;
+            id: string;
+            props: Readonly<Record<string, unknown>>;
+        }>[];
+        releases: readonly Readonly<{
+            kind: string;
+            id: string;
+        }>[];
+    }>, apply: () => Promise<Output>) => Promise<Output>;
     /**
      * @internal Reads the graph's identity assertions in transfer shape, honoring
      * this store's SQL binding. Used by interchange export, base-version
@@ -4225,7 +4344,24 @@ type StoreRuntime<G extends GraphDef> = Readonly<{
         created: number;
         skipped: number;
     }>>;
-    applyIdentityMergeAtTarget: (target: GraphBackend | TransactionBackend, retractionIds: readonly string[], assertions: readonly Readonly<{
+    applyIdentityMergeAtTarget: (target: GraphBackend | TransactionBackend, retractions: readonly Readonly<{
+        id: string;
+        relation: "same" | "different";
+        a: Readonly<{
+            kind: string;
+            id: string;
+        }>;
+        b: Readonly<{
+            kind: string;
+            id: string;
+        }>;
+        validFrom: string;
+        validTo?: string | undefined;
+        endedBy?: Readonly<{
+            kind: string;
+            id: string;
+        }> | undefined;
+    }>[], assertions: readonly Readonly<{
         id: string;
         relation: "same" | "different";
         a: Readonly<{
@@ -4894,8 +5030,8 @@ type StoreCore<G extends GraphDef> = Readonly<{
     edges: GraphEdgeCollections<G>;
     algorithms: GraphAlgorithms<G>;
     search: StoreSearch<G>;
-    getNodeCollection: (kind: string) => DynamicNodeCollection | undefined;
-    getNodeCollectionOrThrow: (kind: string) => DynamicNodeCollection;
+    getNodeCollection: <const K extends string>(kind: K) => DynamicNodeCollection<K> | undefined;
+    getNodeCollectionOrThrow: <const K extends string>(kind: K) => DynamicNodeCollection<K>;
     getEdgeCollection: (kind: string) => DynamicEdgeCollection | undefined;
     getEdgeCollectionOrThrow: (kind: string) => DynamicEdgeCollection;
     getNodePropsSchema: (kind: string) => z.ZodObject<z.ZodRawShape> | undefined;
@@ -5227,4 +5363,4 @@ declare function createVerifiedAdapterStore<G extends GraphDef, TNativeTransacti
     SchemaValidationResult
 ]>;
 
-export { type DynamicNodeCollection as $, type AliasMap as A, type BaseStoreOptions as B, type BatchResults as C, type BatchableQuery as D, type EdgeAliasMap as E, type BulkEdgeSourceGroup as F, type BulkFindEdgesFromParams as G, type HistoryStoreOptions as H, type IdentityAssertion as I, type BulkFindEdgesFromResult as J, type BulkOperationHookContext as K, type LiveStoreOptions as L, type ConstraintNames as M, type Node as N, type CreateEdgeInput as O, type CreateNodeInput as P, type QueryCoordinateState as Q, type RecordedReadStoreOptions as R, type StoreOptions as S, TraversalBuilder as T, type UnboundLiveStoreOptions as U, type DegreeOptions as V, type DynamicEdgeAccessor as W, type DynamicEdgeCollection as X, type DynamicEdgeType as Y, type DynamicFieldBuilder as Z, type DynamicNodeAccessor as _, type Store as a, type PaginateOptions as a$, type DynamicNodeType as a0, type DynamicSelectableEdge as a1, type DynamicSelectableNode as a2, type Edge as a3, type EdgeAccessor as a4, type EdgeBatchReads as a5, type EdgeBulkFindEndpointOptions as a6, type EdgeBulkFindOptions as a7, type EdgeCollection as a8, type EdgeFindByEndpointsOptions as a9, type InitialQueryBuilder as aA, type KindIntrospection as aB, type LabelPropagationMembership as aC, type LabelPropagationOptions as aD, type MaterializeRemovalsEntry as aE, type MaterializeRemovalsOptions as aF, type MaterializeRemovalsResult as aG, type MeasurableAdapterHistoryTransactionContext as aH, type MeasurableAdapterTransactionContext as aI, type MeasurableTransactionContext as aJ, type NeighborsOptions as aK, type NoRecordedCoordinate as aL, type NodeAccessor as aM, type NodeAlias as aN, type NodeBulkFindByIndexOptions as aO, type NodeCollection as aP, type NodeCurrentReads as aQ, type NodeGetOrCreateByConstraintOptions as aR, type NodeGetOrCreateByConstraintResult as aS, type NodeIdentifier as aT, type NodeRef as aU, type NodeTemporalReads as aV, type NodeWrites as aW, type OntologyIntrospection as aX, type OperationHookContext as aY, type PageRankOptions as aZ, type PageRankScore as a_, type EdgeGetOrCreateByEndpointsOptions as aa, type EdgeGetOrCreateByEndpointsResult as ab, type EdgeIntrospection as ac, type EdgeTemporalReads as ad, type EdgeWrites as ae, type EmptyAliasMap as af, type EmptyEdgeAliasMap as ag, ExecutableAggregateQuery as ah, ExecutableQuery as ai, type FieldAccessor as aj, type FulltextSearchHit as ak, type FulltextSearchOptions as al, type GetOrCreateAction as am, type GraphAlgorithms as an, type GraphEdgeCollections as ao, type GraphEdgeForKinds as ap, type GraphNodeCollections as aq, type GraphNodeReference as ar, type HistoryStoreBackend as as, type HookContext as at, type HybridFulltextOptions as au, type HybridSearchHit as av, type HybridSearchOptions as aw, type HybridVectorOptions as ax, type IdentityTraversalOption as ay, type IfExistsMode as az, type HistoryStore as b, type SubsetEdge as b$, type PaginatedResult as b0, type PathNode as b1, type PersonalizedPageRankOptions as b2, type PersonalizedPageRankSeed as b3, type Predicate as b4, PreparedQuery as b5, type PropsAccessor as b6, type QueryHookContext as b7, type QueryOptions as b8, type ReachableNode as b9, type StoreHooks as bA, type StoreProjection as bB, type StoreRef as bC, StoreSearch as bD, StoreView as bE, type StoreViewCanReachOptions as bF, type StoreViewCoordinate as bG, type StoreViewDegreeOptions as bH, type StoreViewEdgeCollection as bI, type StoreViewEdgeCollections as bJ, type StoreViewGraphAlgorithms as bK, type StoreViewLabelPropagationOptions as bL, type StoreViewNeighborsOptions as bM, type StoreViewNodeCollection as bN, type StoreViewNodeCollections as bO, type StoreViewPageRankOptions as bP, type StoreViewPersonalizedPageRankOptions as bQ, type StoreViewReachableOptions as bR, type StoreViewShortestPathOptions as bS, type StoreViewSubgraphOptions as bT, type StoreViewWeaklyConnectedComponentsOptions as bU, type StoreViewWeightedShortestPathOptions as bV, type StreamOptions as bW, type SubgraphEdgeResult as bX, type SubgraphNodeResult as bY, type SubgraphOptions as bZ, type SubgraphResult as b_, type ReachableOptions as ba, type RebuildContributionOptions as bb, type RebuildFulltextOptions as bc, type RebuildFulltextResult as bd, type ReclaimedVectorFieldEntry as be, type ReconciledSchema as bf, type RecordedScanOptions as bg, type RecordedScanPage as bh, RecordedStoreView as bi, type RecordedStoreViewEdgeCollection as bj, type RecordedStoreViewEdgeCollections as bk, type RecordedStoreViewNodeCollection as bl, type RecordedStoreViewNodeCollections as bm, type RecursiveTraversalOptions as bn, type ReembedFunction as bo, type ReembedVectorFieldOptions as bp, type ReembedVectorFieldResult as bq, type SchemaIntrospection as br, type ScopedMeasure as bs, type SearchScopeOptions as bt, type SelectContext as bu, type SelectableEdge as bv, type SelectableNode as bw, type ShortestPathOptions as bx, type ShortestPathResult as by, type SqlAvailability as bz, type RecordedReadStore as c, type SubsetNode as c0, type TemporalAlgorithmOptions as c1, type TransactionContext as c2, type TransactionOutcome as c3, type TransactionReceipt as c4, type TraversalDirection as c5, type TypedEdgeCollection as c6, type TypedRecordedStoreViewEdgeCollection as c7, type TypedStoreViewEdgeCollection as c8, UnionableQuery as c9, type UpdateEdgeInput as ca, type UpdateNodeInput as cb, type VectorSearchHit as cc, type VectorSearchOptions as cd, type WeaklyConnectedComponentMembership as ce, type WeaklyConnectedComponentsOptions as cf, type WeightedShortestPathOptions as cg, type WeightedShortestPathResult as ch, asIdentityAssertionId as ci, createAdapterStore as cj, createAdapterStoreWithSchema as ck, createQueryBuilder as cl, createStore as cm, createStoreWithSchema as cn, createVerifiedAdapterStore as co, createVerifiedStore as cp, defineSubgraphProject as cq, exists as cr, fieldRef as cs, inSubquery as ct, isParameterRef as cu, notExists as cv, notInSubquery as cw, param as cx, 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 UniqueIntrospection as m, type RecursiveAliasMap as n, QueryBuilder as o, type EmptyRecursiveAliasMap as p, type AdapterHistoryStore as q, type AdapterHistoryTransactionContext as r, type AdapterRecordedReadStore as s, type AdapterStore as t, type AdapterTransactionContext as u, type AggregateResult as v, type AlgorithmCyclePolicy as w, type AnyEdge as x, type AnyNode as y, type BaseTraversalOptions as z };
+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 OntologyIntrospection 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 IdentityTraversalOption as aA, type IdentityValidityWindow as aB, type IfExistsMode as aC, type InitialQueryBuilder as aD, type KindIntrospection as aE, type LabelPropagationMembership as aF, type LabelPropagationOptions as aG, type MaterializeRemovalsEntry as aH, type MaterializeRemovalsOptions as aI, type MaterializeRemovalsResult as aJ, type MeasurableAdapterHistoryTransactionContext as aK, type MeasurableAdapterTransactionContext as aL, type MeasurableTransactionContext as aM, type NeighborsOptions as aN, type NoRecordedCoordinate as aO, type Node as aP, type NodeAccessor as aQ, type NodeAlias as aR, type NodeBulkFindByIndexOptions as aS, type NodeCollection as aT, type NodeCurrentReads as aU, type NodeGetOrCreateByConstraintOptions as aV, type NodeGetOrCreateByConstraintResult as aW, type NodeIdentifier as aX, type NodeRef as aY, type NodeTemporalReads as aZ, type NodeWrites 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 IdentityNodeReference as az, type HistoryStore as b, type SubgraphEdgeResult as b$, type OperationHookContext as b0, type PageRankOptions as b1, type PageRankScore as b2, type PaginateOptions as b3, type PaginatedResult as b4, type PathNode as b5, type PersonalizedPageRankOptions as b6, type PersonalizedPageRankSeed as b7, type Predicate as b8, PreparedQuery as b9, type SelectableNode as bA, type ShortestPathOptions as bB, type ShortestPathResult as bC, type SqlAvailability as bD, type StoreHooks as bE, type StoreProjection as bF, type StoreRef as bG, StoreSearch as bH, StoreView as bI, type StoreViewCanReachOptions as bJ, type StoreViewCoordinate as bK, type StoreViewDegreeOptions as bL, type StoreViewEdgeCollection as bM, type StoreViewEdgeCollections as bN, type StoreViewGraphAlgorithms as bO, type StoreViewLabelPropagationOptions as bP, type StoreViewNeighborsOptions as bQ, type StoreViewNodeCollection as bR, type StoreViewNodeCollections as bS, type StoreViewPageRankOptions as bT, type StoreViewPersonalizedPageRankOptions as bU, type StoreViewReachableOptions as bV, type StoreViewShortestPathOptions as bW, type StoreViewSubgraphOptions as bX, type StoreViewWeaklyConnectedComponentsOptions as bY, type StoreViewWeightedShortestPathOptions as bZ, type StreamOptions as b_, type PropsAccessor as ba, type QueryHookContext as bb, type QueryOptions as bc, type ReachableNode as bd, type ReachableOptions as be, type RebuildContributionOptions as bf, type RebuildFulltextOptions as bg, type RebuildFulltextResult as bh, type ReclaimedVectorFieldEntry as bi, type ReconciledSchema as bj, type RecordedScanOptions as bk, type RecordedScanPage as bl, RecordedStoreView as bm, type RecordedStoreViewEdgeCollection as bn, type RecordedStoreViewEdgeCollections as bo, type RecordedStoreViewNodeCollection as bp, type RecordedStoreViewNodeCollections as bq, type RecursiveTraversalOptions as br, type ReembedFunction as bs, type ReembedVectorFieldOptions as bt, type ReembedVectorFieldResult as bu, type SchemaIntrospection as bv, type ScopedMeasure as bw, type SearchScopeOptions as bx, type SelectContext as by, type SelectableEdge as bz, type RecordedReadStore as c, type SubgraphNodeResult as c0, type SubgraphOptions as c1, type SubgraphResult as c2, type SubsetEdge as c3, type SubsetNode as c4, type TemporalAlgorithmOptions as c5, type TransactionContext as c6, type TransactionOutcome as c7, type TransactionReceipt as c8, type TraversalDirection as c9, isParameterRef as cA, notExists as cB, notInSubquery as cC, param as cD, type TypedEdgeCollection as ca, type TypedRecordedStoreViewEdgeCollection as cb, type TypedStoreViewEdgeCollection as cc, UnionableQuery as cd, type UniqueIntrospection as ce, type UpdateEdgeInput as cf, type UpdateNodeInput as cg, type ValidityEndMutation as ch, type VectorSearchHit as ci, type VectorSearchOptions as cj, type WeaklyConnectedComponentMembership as ck, type WeaklyConnectedComponentsOptions as cl, type WeightedShortestPathOptions as cm, type WeightedShortestPathResult as cn, asIdentityAssertionId as co, createAdapterStore as cp, createAdapterStoreWithSchema as cq, createQueryBuilder as cr, createStore as cs, createStoreWithSchema as ct, createVerifiedAdapterStore as cu, createVerifiedStore as cv, defineSubgraphProject as cw, exists as cx, fieldRef as cy, inSubquery 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 };