@nicia-ai/typegraph 0.43.0 → 0.45.0

package/dist/{types-Dh-EgT-w.d.ts → types-Ch9a0Dx6.d.ts}

@@ -595,6 +595,18 @@ type DialectCapabilities = Readonly<{
      */
     supportsFulltext: boolean;
 }>;
+/**
+ * Shape of a list-valued `IN` parameter, resolved at compile time.
+ */
+type InListParameterOptions = Readonly<{
+    /** Whether the predicate is `notIn` rather than `in`. */
+    negated: boolean;
+    /**
+     * The value type the left operand was compiled for. `undefined` when the
+     * schema declares nothing usable, in which case the comparison is textual.
+     */
+    elementType: ValueType | undefined;
+}>;
 /**
  * Adapter interface for SQL dialect differences.
  *
@@ -765,6 +777,13 @@ interface DialectAdapter {
      * PostgreSQL: jsonb_typeof(column #> path) = 'number'
      */
     readonly jsonPathIsNumber: (this: void, column: SqlFragment, pointer: JsonPointer) => SqlFragment;
+    /**
+     * Replaces top-level JSON object properties while preserving explicit JSON
+     * null values. This is the token-level dialect seam used by set-based node
+     * mutation; callers validate the patch against the node schema before SQL
+     * compilation.
+     */
+    readonly jsonSetProperties: (this: void, column: SqlFragment, patch: Readonly<Record<string, JsonValue>>, unsetProperties?: readonly string[]) => SqlFragment;
     /**
      * Null-safe equality: `TRUE` when both sides are equal OR both are NULL.
      * Unlike `=`, a NULL on either side does not yield NULL/unknown.
@@ -787,6 +806,40 @@ interface DialectAdapter {
      * PostgreSQL: left IN ($1, $2, ...)
      */
     readonly inList: (this: void, left: SqlFragment, values: readonly unknown[], negated: boolean) => SqlFragment;
+    /**
+     * Tests scalar membership in a list supplied as a SINGLE bound parameter —
+     * the `field.in(param("ids"))` form.
+     *
+     * The emitted SQL must not depend on how many elements the list holds, so a
+     * prepared statement compiles once and serves every arity from the same
+     * cached template. Both bundled dialects therefore unpack a JSON-encoded
+     * array (produced by {@link DialectAdapter.packListValue}) into a one-column
+     * relation instead of emitting one placeholder per element.
+     *
+     * `elementType` is the value type the left operand was compiled for, so a
+     * dialect that extracts JSON as text can cast the unpacked elements to the
+     * same type; `undefined` means text.
+     *
+     * @example
+     * SQLite: left IN (SELECT value FROM json_each(?))
+     * PostgreSQL: left IN (SELECT e.value::numeric FROM jsonb_array_elements_text($1::jsonb) AS e(value))
+     */
+    readonly inListParameter: (this: void, left: SqlFragment, packedValues: SqlFragment, options: InListParameterOptions) => SqlFragment;
+    /**
+     * Packs the scalar list bound to an `in()`/`notIn()` parameter into the
+     * single driver value {@link DialectAdapter.inListParameter} unpacks.
+     * Elements arrive as plain JavaScript scalars and must be bound with the
+     * same rules a literal of that type would be (SQLite booleans as 0/1, dates
+     * as ISO text), so the parameterized and literal forms match row for row.
+     *
+     * Every element is guaranteed to match the compiled element type, and to be
+     * a finite number when that type is numeric: `PreparedQuery` validates the
+     * binding before it reaches this method. Implementations therefore do not
+     * need to normalize or reject anything — and must not paper over a mismatch,
+     * since doing so is what would let one dialect quietly disagree with
+     * another.
+     */
+    readonly packListValue: (this: void, values: readonly unknown[]) => unknown;
     /**
      * Case-insensitive LIKE comparison.
      *
@@ -1265,6 +1318,10 @@ type VectorStrategy = Readonly<{
     buildUpsertBatch?: (this: void, slot: VectorSlot, params: UpsertEmbeddingBatchParams, timestamp: string) => readonly SqlFragment[];
     /** Emits the statement(s) that delete a single embedding from the slot. */
     buildDelete: (this: void, slot: VectorSlot, params: DeleteEmbeddingParams) => readonly SqlFragment[];
+    /** Emits one set-based delete for many node ids in a vector slot. */
+    buildDeleteBatch: (this: void, slot: VectorSlot, params: Omit<DeleteEmbeddingParams, "nodeId"> & Readonly<{
+        nodeIds: readonly string[];
+    }>) => readonly SqlFragment[];
     /**
      * Raw DDL statement(s) that drop the slot's entire physical storage
      * (table + ANN index, and any engine-managed shadow tables). Used by the
@@ -2088,7 +2145,9 @@ type BackendCapabilities = Readonly<{
      * Maximum number of bound parameters the engine accepts in one statement.
      * SQLite defaults to 999 (raisable at compile time via
      * `SQLITE_MAX_VARIABLE_NUMBER`), while hosted SQLite runtimes may impose a
-     * lower platform ceiling; PostgreSQL's wire protocol caps it at 65535.
+     * lower platform ceiling. PostgreSQL's wire protocol encodes a 65535-count,
+     * but postgres.js accepts at most 65533 bound values, so the bundled
+     * PostgreSQL capability advertises that lower shared-driver ceiling.
      * Recorded-time capture and recorded point reads size their multi-row
      * statements to this ceiling — the same budget the backend's own batched
      * inserts use — instead of a conservative dialect-blind constant. Custom
@@ -2233,6 +2292,38 @@ type UpdateNodeParams = Readonly<{
     /** If true, clears deleted_at (un-deletes the node). Used by upsert. */
     clearDeleted?: boolean;
 }>;
+/**
+ * Parameters for updating a set of live nodes selected by a compiled
+ * TypeGraph query.
+ *
+ * The candidate query must expose the named node-id column from the same graph
+ * and kind. The backend independently fences the rows it writes to
+ * `graphId` and `kind`; constructing the matching candidate query remains the
+ * caller's responsibility.
+ * Property values replace top-level keys, including preserving an explicit
+ * JSON `null` value.
+ *
+ * This is a storage primitive: callers that expose it as a graph mutation are
+ * responsible for schema validation and for synchronizing uniqueness,
+ * fulltext, and vector sidecars. The result contains after-images only; callers
+ * that need previous property values must freeze the candidate set and retain
+ * its before-images in the same transaction before invoking this method.
+ */
+type UpdateNodeSetParams = Readonly<{
+    graphId: string;
+    kind: string;
+    patch: Readonly<Record<string, JsonValue>>;
+    /** Top-level properties to remove (the storage form of an `undefined` patch value). */
+    unsetProperties?: readonly string[];
+    candidateIds: CompiledSelectSql;
+    /** Projected SQL column holding the candidate node id (for example `n_id`). */
+    candidateIdColumn: string;
+}>;
+/** The after-images changed by {@link GraphBackend.updateNodeSet}. */
+type UpdateNodeSetResult = Readonly<{
+    affectedCount: number;
+    rows: readonly NodeRow[];
+}>;
 /**
  * Parameters for deleting a node (soft delete).
  */
@@ -2780,6 +2871,124 @@ type RecordContributionMaterializationParams = Readonly<{
     /** Error message on failure; undefined on success (clears existing). */
     error: string | undefined;
 }>;
+/**
+ * Why a contribution is not usable. Most members are a disagreement
+ * between the durable marker and the physical catalog; one
+ * (`failed-materialization`) is a state the two agree on and that is
+ * broken anyway. A contribution that is genuinely healthy — or that was
+ * simply never attempted — is not reported at all.
+ *
+ * - `orphaned-marker` — the marker records a successful materialization
+ *   but the physical table is gone (a partial restore, an out-of-band
+ *   `DROP`, a schema-scoped restore that missed the contribution
+ *   tables). The state {@link GraphBackend.verifyContributions} exists
+ *   to surface: nothing on the open path probes the catalog, so this
+ *   database opens clean and fails at the first read of the slot.
+ * - `missing-marker` — the physical table exists but no marker attests
+ *   it as initialized (no row, no recorded success, or a recorded
+ *   failure). Reads and writes are refused with
+ *   `StoreNotInitializedError` even though storage is present. These
+ *   three causes share one state because they share one repair; check
+ *   {@link ContributionDiagnostic.lastError} to tell them apart.
+ * - `failed-materialization` — the marker records a *failed* attempt
+ *   and no table was produced. Marker and catalog agree here, so this
+ *   is not a disagreement — but it is where a contribution lands when
+ *   provisioning genuinely broke (the `fts5` module is absent, the role
+ *   lacks `CREATE`, the extension was never loaded), and calling it
+ *   healthy on the grounds that both sides agree would be the one
+ *   answer this method must never give. Distinguished from a
+ *   contribution that was never attempted, which has no marker row and
+ *   is correctly silent. {@link ContributionDiagnostic.lastError}
+ *   carries the reason it failed.
+ * - `stale` — the table exists and the marker records a prior success
+ *   at a different signature (a strategy swap, or a declared embedding
+ *   dimension that has moved ahead of the provisioned table).
+ *
+ * **Do not re-frame this union as "how the marker disagrees with the
+ * catalog."** It was described that way once, and the description was
+ * load-bearing in the wrong direction: under it, a marker recording a
+ * failed attempt with no table looks like agreement, therefore not a
+ * disagreement, therefore correctly silent — and a contribution that
+ * had genuinely broken was reported as healthy. The gap read as
+ * principled rather than as an oversight precisely because the framing
+ * endorsed it. "Why the contribution is unusable" is the question that
+ * makes `failed-materialization` obviously belong, and any future
+ * tidy-up that narrows the framing back will re-open the same hole.
+ */
+type ContributionDiagnosticState = "orphaned-marker" | "missing-marker" | "failed-materialization" | "stale";
+/**
+ * One contribution that is not usable, reported by
+ * {@link GraphBackend.verifyContributions}.
+ *
+ * The identity fields come from the active contribution declaration and
+ * match the durable-marker identity contract, so a caller can route an entry
+ * to its repair without reconstructing any internal naming contract. A
+ * `missing-marker` entry may have no marker row at all.
+ *
+ * **Route on {@link ContributionDiagnosticState}, not on whether the
+ * entry is a vector slot.** The repair differs per state and the wrong
+ * choice destroys data: `store.reembedVectorField` drops and recreates
+ * storage, so applying it to a `missing-marker` — where the table is
+ * intact and only the bookkeeping is wrong — discards every embedding
+ * to fix a marker, and without an `embed` callback it leaves the field
+ * empty. Prefer `store.repairContributions()` for `missing-marker` and
+ * `failed-materialization`; it resolves the current strategy declarations
+ * internally and keeps the normal signature-drift guard enabled. It reports
+ * `stale` and `orphaned-marker` as `requires-rebuild`. See the per-state
+ * repair table in the troubleshooting guide.
+ */
+type ContributionDiagnostic = Readonly<{
+    /** Producing strategy, e.g. `"fts5"` / `"tsvector"` / `"pgvector"`. */
+    owner: string;
+    /** Stable logical slot, e.g. `"fulltext"`. Never the SQL name. */
+    logicalName: string;
+    /** Resolved physical table name that was probed. */
+    physicalName: string;
+    /** Node kind — vector slots only. */
+    kind?: string;
+    /** Embedding field path — vector slots only. */
+    fieldPath?: string;
+    state: ContributionDiagnosticState;
+    /**
+     * The error the marker recorded against its last attempt, when it
+     * recorded one. Absent otherwise.
+     *
+     * This is the part of the picture the catalog cannot supply. `state`
+     * says what to do — the states are chosen so that each maps to one
+     * repair — while this says *why it broke*, which is a different
+     * question and often a different investigation. A failed attempt with no
+     * table surfaces as `failed-materialization`; when the table exists but
+     * the marker does not attest a successful materialization, it surfaces as
+     * `missing-marker`. This field distinguishes only failures whose marker
+     * recorded a reason; a missing row has no `lastError`. Present on any state
+     * whose marker row carries an error, not just those two states.
+     */
+    lastError?: string;
+}>;
+/**
+ * Outcome of one contribution considered by
+ * {@link GraphBackend.repairContributions}.
+ *
+ * Repair targets are always resolved from the backend's current strategy
+ * declarations. The diagnostic is returned for operator context only; callers
+ * never pass diagnostics or physical DDL back into the repair API.
+ */
+type ContributionRepairEntry = Readonly<{
+    diagnostic: ContributionDiagnostic;
+    status: "repaired";
+}> | Readonly<{
+    diagnostic: ContributionDiagnostic;
+    status: "requires-rebuild";
+}> | Readonly<{
+    diagnostic: ContributionDiagnostic;
+    status: "failed";
+    error: string;
+}>;
+/** Result of a contribution repair pass followed by a fresh verification. */
+type ContributionRepairResult = Readonly<{
+    results: readonly ContributionRepairEntry[];
+    remaining: readonly ContributionDiagnostic[];
+}>;
 /**
  * One row of the per-deployment `typegraph_kind_removals` table:
  * a graph-extension kind that has been removed from the schema and whose
@@ -2867,6 +3076,7 @@ type GraphBackend = Readonly<{
     insertNodesBatch?: (this: void, params: readonly InsertNodeParams[]) => Promise<void>;
     insertNodesBatchReturning?: (this: void, params: readonly InsertNodeParams[]) => Promise<readonly NodeRow[]>;
     updateNode: (this: void, params: UpdateNodeParams) => Promise<NodeRow>;
+    updateNodeSet?: (this: void, params: UpdateNodeSetParams) => Promise<UpdateNodeSetResult>;
     deleteNode: (this: void, params: DeleteNodeParams) => Promise<void>;
     hardDeleteNode: (this: void, params: HardDeleteNodeParams) => Promise<void>;
     getNode: (this: void, graphId: string, kind: string, id: string) => Promise<NodeRow | undefined>;
@@ -2895,6 +3105,30 @@ type GraphBackend = Readonly<{
     findNodesByKind: (this: void, params: FindNodesByKindParams) => Promise<readonly NodeRow[]>;
     countNodesByKind: (this: void, params: CountNodesByKindParams) => Promise<number>;
     findEdgesByKind: (this: void, params: FindEdgesByKindParams) => Promise<readonly EdgeRow[]>;
+    /**
+     * Reads the edges of a SET of endpoints in one statement per bind-budget
+     * chunk — see {@link FindEdgesByEndpointSetParams}.
+     *
+     * **Optional, and its absence is the capability signal.** `store.edges.<kind>
+     * .bulkFindFrom` / `.bulkFindTo` check for this method before issuing any
+     * read and refuse with a typed `ConfigurationError` when it is missing,
+     * rather than degrading to a per-endpoint loop. A caller reaching for a bulk
+     * endpoint read is asking for set-oriented statements; quietly giving them N
+     * singleton statements is the surprise the method exists to prevent.
+     *
+     * Both bundled Drizzle backends implement it. A custom backend that does not
+     * simply omits it and the bulk reads refuse; the singleton `findEdgesByKind`
+     * path is unaffected.
+     */
+    findEdgesByEndpointSet?: (this: void, params: FindEdgesByEndpointSetParams) => Promise<readonly EdgeRow[]>;
+    /**
+     * Reads several edge kinds from a heterogeneous set of endpoints without
+     * issuing one statement per licensed `(edge kind, endpoint kind)` pair.
+     *
+     * Optional for custom backends. Store-level heterogeneous bulk reads refuse
+     * when it is absent rather than hiding a per-kind/per-endpoint fallback.
+     */
+    findEdgesByHeterogeneousEndpointSet?: (this: void, params: FindEdgesByHeterogeneousEndpointSetParams) => Promise<readonly EdgeRow[]>;
     countEdgesByKind: (this: void, params: CountEdgesByKindParams) => Promise<number>;
     insertUnique: (this: void, params: InsertUniqueParams) => Promise<void>;
     /**
@@ -2905,6 +3139,12 @@ type GraphBackend = Readonly<{
      */
     insertUniqueBatch?: (this: void, entries: readonly InsertUniqueParams[]) => Promise<void>;
     deleteUnique: (this: void, params: DeleteUniqueParams) => Promise<void>;
+    /**
+     * Permanently removes every uniqueness sidecar owned by the specified
+     * concrete nodes. Optional capability used by set-based updates before they
+     * rebuild reservations from the returned node after-images.
+     */
+    hardDeleteUniquesByNodeIds?: (this: void, params: HardDeleteUniquesByNodeIdsParams) => Promise<void>;
     checkUnique: (this: void, params: CheckUniqueParams) => Promise<UniqueRow | undefined>;
     checkUniqueBatch?: (this: void, params: CheckUniqueBatchParams) => Promise<readonly UniqueRow[]>;
     getActiveSchema: (this: void, graphId: string) => Promise<SchemaVersionRow | undefined>;
@@ -2930,6 +3170,40 @@ type GraphBackend = Readonly<{
      * window the primitive exists to eliminate.
      */
     commitSchemaVersion: (this: void, params: CommitSchemaVersionParams) => Promise<SchemaVersionRow>;
+    /**
+     * Commit a schema version only if every requested kind is empty. The probes
+     * and schema CAS run under one backend-owned write fence, preventing a
+     * participating schema-managed Store write from landing between the final
+     * count and commit. Raw Stores and direct backend writes are not fenced.
+     */
+    commitSchemaVersionIfKindsEmpty?: (this: void, params: CommitSchemaVersionParams, probes: readonly Readonly<{
+        entity: "node" | "edge";
+        kind: string;
+    }>[]) => Promise<Readonly<{
+        status: "committed";
+        row: SchemaVersionRow;
+    }> | Readonly<{
+        status: "populated";
+        kinds: readonly Readonly<{
+            entity: "node" | "edge";
+            kind: string;
+            count: number;
+        }>[];
+    }>>;
+    /**
+     * Acquire the transaction-scoped shared fence for a schema-managed graph
+     * write, then verify that the active schema still matches the Store that is
+     * issuing it. Official transactional backends provide this method; custom
+     * backends may omit it, in which case schema-managed Store writes fail
+     * closed rather than racing a schema change. This method must be called on a
+     * transaction-scoped backend. PostgreSQL locks the active schema row, so a
+     * concurrent change either becomes visible at read committed or raises the
+     * database's native serialization failure at stronger isolation.
+     */
+    lockSchemaVersionForWrite?: (this: void, params: Readonly<{
+        graphId: string;
+        expectedVersion: number;
+    }>) => Promise<void>;
     /**
      * Atomically flips the active schema pointer to an existing version,
      * with optimistic compare-and-swap on the currently active version.
@@ -2940,6 +3214,23 @@ type GraphBackend = Readonly<{
      * Same transactional requirements as `commitSchemaVersion`.
      */
     setActiveVersion: (this: void, params: SetActiveVersionParams) => Promise<void>;
+    /**
+     * Run an administrative callback while holding the same per-graph lock as
+     * schema commits. The callback receives the transaction-scoped backend, so
+     * its reads, DML, and DDL are committed atomically before another schema
+     * writer can proceed.
+     *
+     * This is intentionally absent from {@link TransactionBackend}: nesting a
+     * schema-write lock from an already-open transaction can deadlock. It is an
+     * optional backend capability so custom backends can decline operations
+     * that require a schema fence rather than silently running them unsafely.
+     */
+    schemaWriteTransaction?: <T>(this: void, graphId: string, fn: (tx: TransactionBackend & Readonly<{
+        executeStatement: NonNullable<TransactionBackend["executeStatement"]>;
+        tableExists: (this: void, tableName: string) => Promise<boolean>;
+        executeSchemaDdl: (this: void, ddl: string) => Promise<void>;
+        deleteSchemaVectorSlotContribution: (this: void, slot: VectorSlot) => Promise<void>;
+    }>) => Promise<T>) => Promise<T>;
     upsertEmbedding?: (this: void, params: UpsertEmbeddingParams) => Promise<void>;
     /**
      * Batched variant of `upsertEmbedding` for one vector slot. Optional —
@@ -2947,6 +3238,9 @@ type GraphBackend = Readonly<{
      */
     upsertEmbeddingBatch?: (this: void, params: UpsertEmbeddingBatchParams) => Promise<void>;
     deleteEmbedding?: (this: void, params: DeleteEmbeddingParams) => Promise<void>;
+    deleteEmbeddingBatch?: (this: void, params: Omit<DeleteEmbeddingParams, "nodeId"> & Readonly<{
+        nodeIds: readonly string[];
+    }>) => Promise<void>;
     /**
      * KNN search over one `(nodeKind, fieldPath)` slot. Top-k is computed
      * over CURRENT nodes only — non-tombstoned AND inside their validity
@@ -3084,11 +3378,11 @@ type GraphBackend = Readonly<{
     assertRuntimeContributionsInitialized?: (this: void, graphId: string) => Promise<void>;
     /**
      * Bootstraps the per-deployment `typegraph_kind_removals` table so
-     * `store.removeKinds()` and `store.materializeRemovals()` can persist
-     * removal status. Mirrors the focused-bootstrap rationale documented
-     * on `ensureIndexMaterializationsTable` — the full `bootstrapTables`
-     * touches every base table and risks Postgres SHARE-lock deadlock
-     * under concurrent replica startup.
+     * `store.evolve()` can check pending removals and the removal verbs can
+     * persist and materialize removal status. Mirrors the focused-bootstrap
+     * rationale documented on `ensureIndexMaterializationsTable` — the full
+     * `bootstrapTables` touches every base table and risks Postgres SHARE-lock
+     * deadlock under concurrent replica startup.
      */
     ensureKindRemovalsTable?: (this: void) => Promise<void>;
     /**
@@ -3193,6 +3487,44 @@ type GraphBackend = Readonly<{
      * Present only on backends wired with a vector strategy.
      */
     deleteVectorSlotContribution?: (this: void, slot: VectorSlot) => Promise<void>;
+    /**
+     * Diagnostic: compare each contribution currently expected for `graphId`
+     * against its durable marker and the physical catalog.
+     *
+     * Covers the strategy-owned `runtimeEnsure` contributions (fulltext)
+     * plus the `ownedTables` contribution(s) of each supplied vector slot.
+     * Returns one {@link ContributionDiagnostic} per detected unusable
+     * contribution. A recorded failed materialization is unusable even when
+     * marker and catalog agree that no table was produced. A contribution with
+     * neither a marker nor a table is treated as never attempted and omitted;
+     * marker rows outside the current declaration set are not audited. An empty
+     * array therefore is not proof that storage was initialized.
+     *
+     * Deliberately NOT part of the open path. `ensureRuntimeContributions`
+     * and `assertRuntimeContributionsInitialized` short-circuit on a
+     * per-instance signature cache and then on the marker row alone, which
+     * is the right default for a hot path but leaves a database whose
+     * contribution tables were dropped out of band opening clean and
+     * failing at the first read. This method is the explicit, operator-
+     * invoked catalog probe that fills that gap: it issues one uncached
+     * existence query per distinct physical table and performs ZERO DDL
+     * and ZERO writes, so it is safe under a least-privilege runtime role.
+     *
+     * Present only on backends that can probe their own catalog.
+     */
+    verifyContributions?: (this: void, graphId: string, vectorSlots: readonly VectorSlot[]) => Promise<readonly ContributionDiagnostic[]>;
+    /**
+     * Re-audit current contribution declarations and non-destructively repair
+     * `missing-marker` and `failed-materialization` findings. The backend must
+     * resolve every target itself; it must not accept caller-provided physical
+     * identities or DDL. `stale` and `orphaned-marker` findings are returned as
+     * `requires-rebuild` because repairing either can require destructive data
+     * reconstruction.
+     *
+     * Present only on backends that can both probe their catalog and run the
+     * strategy-owned contribution DDL.
+     */
+    repairContributions?: (this: void, graphId: string, vectorSlots: readonly VectorSlot[]) => Promise<ContributionRepairResult>;
     /**
      * Bootstraps the fulltext storage table the active `FulltextStrategy`
      * owns. Same focused-bootstrap rationale as the other `ensure*Table`
@@ -3263,9 +3595,17 @@ type GraphBackend = Readonly<{
      * entire operation back.
      *
      * This is a top-level-only lifecycle operation and is deliberately absent
-     * from {@link TransactionBackend}.
-     */
-    trustedImport?: <T>(this: void, fn: (session: TrustedImportSession) => Promise<T>) => Promise<T>;
+     * from {@link TransactionBackend}. When `schemaWrite` is supplied, the
+     * import acquires and validates that Store version's managed-write fence
+     * before checking emptiness or writing. Omitting it retains the raw,
+     * unversioned import behavior.
+     */
+    trustedImport?: <T>(this: void, fn: (session: TrustedImportSession) => Promise<T>, options?: Readonly<{
+        schemaWrite?: Readonly<{
+            graphId: string;
+            expectedVersion: number;
+        }>;
+    }>) => Promise<T>;
     execute: <T>(this: void, query: CompiledRowsSql) => Promise<readonly T[]>;
     /**
      * Execute a non-row-returning SQL statement bound to this backend or
@@ -3319,15 +3659,16 @@ type AdapterBackend<TNativeTransaction> = GraphBackend & Readonly<{
 }>;
 type BackendIdentity = Pick<GraphBackend, "dialect" | "capabilities" | "tableNames" | "fulltextStrategy" | "vectorStrategy">;
 type NodeEntityReadBackend = Pick<GraphBackend, "getNode" | "getNodes" | "findNodesByKind" | "countNodesByKind">;
-type NodeEntityWriteBackend = Pick<GraphBackend, "insertNode" | "insertNodeNoReturn" | "insertNodesBatch" | "insertNodesBatchReturning" | "updateNode" | "deleteNode" | "hardDeleteNode">;
-type EdgeEntityReadBackend = Pick<GraphBackend, "getEdge" | "getEdges" | "countEdgesFrom" | "edgeExistsBetween" | "findEdgesConnectedTo" | "findEdgesByKind" | "countEdgesByKind">;
+type NodeEntityWriteBackend = Pick<GraphBackend, "insertNode" | "insertNodeNoReturn" | "insertNodesBatch" | "insertNodesBatchReturning" | "updateNode" | "updateNodeSet" | "deleteNode" | "hardDeleteNode">;
+type EdgeEntityReadBackend = Pick<GraphBackend, "getEdge" | "getEdges" | "countEdgesFrom" | "edgeExistsBetween" | "findEdgesConnectedTo" | "findEdgesByKind" | "findEdgesByEndpointSet" | "findEdgesByHeterogeneousEndpointSet" | "countEdgesByKind">;
 type EdgeEntityWriteBackend = Pick<GraphBackend, "insertEdge" | "insertEdgeNoReturn" | "insertEdgesBatch" | "insertEdgesBatchReturning" | "updateEdge" | "deleteEdge" | "deleteEdgesBatch" | "hardDeleteEdge" | "hardDeleteEdgesBatch">;
 type GraphEntityReadBackend = NodeEntityReadBackend & EdgeEntityReadBackend;
 type GraphEntityWriteBackend = NodeEntityWriteBackend & EdgeEntityWriteBackend;
-type UniqueConstraintBackend = Pick<GraphBackend, "insertUnique" | "insertUniqueBatch" | "deleteUnique" | "checkUnique" | "checkUniqueBatch">;
+type UniqueConstraintBackend = Pick<GraphBackend, "insertUnique" | "insertUniqueBatch" | "deleteUnique" | "hardDeleteUniquesByNodeIds" | "checkUnique" | "checkUniqueBatch">;
 type SchemaReadBackend = Pick<GraphBackend, "getActiveSchema" | "getSchemaVersion">;
-type SchemaCommitBackend = Pick<GraphBackend, "commitSchemaVersion" | "setActiveVersion">;
-type VectorOperationBackend = Pick<GraphBackend, "upsertEmbedding" | "upsertEmbeddingBatch" | "deleteEmbedding" | "vectorSearch" | "createVectorIndex" | "dropVectorIndex">;
+type SchemaCommitBackend = Pick<GraphBackend, "commitSchemaVersion" | "commitSchemaVersionIfKindsEmpty" | "setActiveVersion">;
+type SchemaWriteFenceBackend = Pick<GraphBackend, "lockSchemaVersionForWrite">;
+type VectorOperationBackend = Pick<GraphBackend, "upsertEmbedding" | "upsertEmbeddingBatch" | "deleteEmbedding" | "deleteEmbeddingBatch" | "vectorSearch" | "createVectorIndex" | "dropVectorIndex">;
 type FulltextOperationBackend = Pick<GraphBackend, "upsertFulltext" | "deleteFulltext" | "upsertFulltextBatch" | "deleteFulltextBatch" | "fulltextSearch">;
 type IndexMaterializationBackend = Pick<GraphBackend, "ensureIndexMaterializationsTable" | "getIndexMaterialization" | "getIndexMaterializations" | "recordIndexMaterialization">;
 type ContributionMaterializationBackend = Pick<GraphBackend, "ensureContributionMaterializationsTable" | "getContributionMaterialization" | "recordContributionMaterialization" | "assertRuntimeContributionsInitialized" | "ensureRuntimeContributions" | "ensureFulltextTable">;
@@ -3358,7 +3699,7 @@ type TransactionReadBackend = Readonly<BackendIdentity & GraphEntityReadBackend
  * deliberately absent: their guarantees depend on the top-level backend or
  * lifecycle owner rather than an already-open transaction.
  */
-type TransactionBackend = Readonly<BackendIdentity & GraphEntityReadBackend & GraphEntityWriteBackend & UniqueConstraintBackend & SchemaReadBackend & VectorOperationBackend & FulltextOperationBackend & IndexMaterializationBackend & ContributionMaterializationBackend & RemovalMaterializationBackend & GraphLifecycleBackend & QueryExecutionBackend & RawQueryExecutionBackend & RawStatementExecutionBackend>;
+type TransactionBackend = Readonly<BackendIdentity & GraphEntityReadBackend & GraphEntityWriteBackend & UniqueConstraintBackend & SchemaReadBackend & Pick<GraphBackend, "lockSchemaVersionForWrite"> & VectorOperationBackend & FulltextOperationBackend & IndexMaterializationBackend & ContributionMaterializationBackend & RemovalMaterializationBackend & GraphLifecycleBackend & QueryExecutionBackend & RawQueryExecutionBackend & RawStatementExecutionBackend>;
 /**
  * Parameters for inserting a unique constraint entry.
  */
@@ -3379,6 +3720,12 @@ type DeleteUniqueParams = Readonly<{
     constraintName: string;
     key: string;
 }>;
+/** Parameters for permanently clearing uniqueness sidecars by node identity. */
+type HardDeleteUniquesByNodeIdsParams = Readonly<{
+    graphId: string;
+    concreteKind: string;
+    nodeIds: readonly string[];
+}>;
 /**
  * Parameters for checking a unique constraint.
  */
@@ -3449,6 +3796,35 @@ type CommitSchemaVersionParams = Readonly<{
     schemaHash: string;
     schemaDoc: SerializedSchema;
 }>;
+type SchemaKindEmptinessProbe = Readonly<{
+    entity: "node" | "edge";
+    kind: string;
+}>;
+type PopulatedSchemaKind = SchemaKindEmptinessProbe & Readonly<{
+    count: number;
+}>;
+type CommitSchemaVersionIfKindsEmptyResult = Readonly<{
+    status: "committed";
+    row: SchemaVersionRow;
+}> | Readonly<{
+    status: "populated";
+    kinds: readonly PopulatedSchemaKind[];
+}>;
+type LockSchemaVersionForWriteParams = Readonly<{
+    graphId: string;
+    expectedVersion: number;
+}>;
+/**
+ * Optional schema-managed write identity for a trusted import. Supplying it
+ * acquires and validates the Store version's transaction-scoped schema fence;
+ * omitting it leaves the import outside the versioned guarantee.
+ */
+type TrustedImportOptions = Readonly<{
+    schemaWrite?: Readonly<{
+        graphId: string;
+        expectedVersion: number;
+    }>;
+}>;
 /**
  * Parameters for `setActiveVersion`.
  *
@@ -3567,6 +3943,93 @@ type FindEdgesByKindParams = Readonly<{
      */
     after?: string;
 }>;
+/**
+ * The endpoint side a {@link FindEdgesByEndpointSetParams} read fans out over.
+ */
+type EdgeEndpointSide = "from" | "to";
+/**
+ * Parameters for reading the edges of a SET of endpoints in one statement per
+ * bind-budget chunk — the widened form of {@link FindEdgesByKindParams}'s
+ * scalar `fromId` / `toId`.
+ *
+ * Deliberately a SEPARATE parameter type on a separate operation rather than
+ * optional fields on `FindEdgesByKindParams`. A backend that did not implement
+ * set membership would still type-check while ignoring the id list, and would
+ * then return every edge of the kind — which the caller would rebucket into a
+ * correct-looking answer at unbounded cost. Splitting the operation makes that
+ * failure unreachable: support is detected by the method's presence, before any
+ * read is issued.
+ *
+ * The shape also makes the previously-validated illegal states
+ * unrepresentable. One `side` instead of two independent id lists means both
+ * endpoints can never fan out at once; no scalar `fromId` / `toId` field means
+ * a scalar and a set can never disagree; no `limit` / `offset` / `after` means
+ * a global slice can never be requested across a read the backend splits into
+ * bind-budget chunks.
+ */
+type FindEdgesByEndpointSetParams = Readonly<{
+    graphId: string;
+    kind: string;
+    /** Which endpoint column the id set constrains. */
+    side: EdgeEndpointSide;
+    /**
+     * Kind of the fanned-out endpoint. Required: it is the index prefix that
+     * makes the set a seek rather than a scan, so a set is always scoped to one
+     * endpoint kind and a heterogeneous page costs one read per distinct kind.
+     */
+    endpointKind: string;
+    /**
+     * Endpoint NODE ids to match — deliberately not named `ids`, which in the
+     * backend params vocabulary means edge ids (see
+     * {@link DeleteEdgesBatchParams}); the write-surface assertion in
+     * `recorded-capture/write-surface.ts` classifies params structurally and a
+     * `{ graphId, ids }` read would be misread as a write.
+     *
+     * The backend deduplicates before splitting the list across bind-budget
+     * chunks — a repeated id spanning two chunks would return its edges twice.
+     * An empty list reads nothing and yields no rows.
+     */
+    endpointIds: readonly string[];
+    /**
+     * Maximum rows per distinct endpoint id, applied inside the statement (via
+     * `ROW_NUMBER()` over the read's own ordering) rather than by the caller.
+     * Only meaningful on a backend whose `capabilities.windowFunctions` is true;
+     * callers must still cap client-side, so a backend that ignores this returns
+     * a superset rather than a wrong answer. Unlike a global `limit`, a
+     * per-endpoint cap composes with chunking: each endpoint's rows fall
+     * entirely within one chunk.
+     */
+    limitPerEndpoint?: number;
+    /** If true, exclude deleted edges. Default true. */
+    excludeDeleted?: boolean;
+    /** Temporal mode for filtering by validity period. */
+    temporalMode?: TemporalMode;
+    /** Timestamp for "current" and "asOf" temporal modes. */
+    asOf?: string;
+}>;
+/**
+ * Parameters for reading several edge kinds from several endpoint kinds.
+ *
+ * The endpoint pairs are joined as a relation, so round trips are independent
+ * of the number of licensed edge-kind/endpoint-kind combinations. Large source
+ * sets may still be split to respect the backend's bind-parameter budget.
+ */
+type FindEdgesByHeterogeneousEndpointSetParams = Readonly<{
+    graphId: string;
+    side: EdgeEndpointSide;
+    endpoints: readonly Readonly<{
+        kind: string;
+        id: string;
+    }>[];
+    edgeKinds: readonly string[];
+    limitPerEndpoint?: number;
+    /** If true, exclude deleted edges. Default true. */
+    excludeDeleted?: boolean;
+    /** Temporal mode for filtering by validity period. */
+    temporalMode?: TemporalMode;
+    /** Timestamp for "current" and "asOf" temporal modes. */
+    asOf?: string;
+}>;
 /**
  * Parameters for counting edges by kind.
  */
@@ -3611,11 +4074,11 @@ declare const D1_MAX_BIND_PARAMETERS = 100;
  */
 declare const DURABLE_OBJECT_MAX_BIND_PARAMETERS = 100;
 /**
- * PostgreSQL's wire-protocol bound-parameter ceiling (a 16-bit count). Single
- * source of truth for {@link POSTGRES_CAPABILITIES} and the Postgres backend's
- * batch math.
+ * Safe bound-parameter ceiling shared by every bundled PostgreSQL driver.
+ * The protocol count can represent 65535, but postgres.js rejects a statement
+ * with 65534 bound values, so backend batch math uses the lower portable limit.
  */
-declare const POSTGRES_MAX_BIND_PARAMETERS = 65535;
+declare const POSTGRES_MAX_BIND_PARAMETERS = 65533;
 /**
  * Default capabilities for SQLite.
  */
@@ -4417,4 +4880,4 @@ type RelationalIndexDeclaration = NodeIndexDeclaration | EdgeIndexDeclaration;
 type IndexDeclaration = RelationalIndexDeclaration | VectorIndexDeclaration;
 type SystemColumnName = "graph_id" | "kind" | "id" | "from_kind" | "from_id" | "to_kind" | "to_id" | "deleted_at" | "valid_from" | "valid_to" | "created_at" | "updated_at" | "version";
 
-export { type AggregateExpr as $, type AdapterBackend as A, type BackendCapabilities as B, type IndexEntity as C, type DeleteBehavior as D, type EdgeRegistration as E, type FulltextStrategy as F, type GraphExtension as G, type SerializedMetaEdge as H, type IndexDeclaration as I, type JsonPointer as J, type KindEntity as K, type SerializedOntologyRelation as L, type SerializedClosures as M, type NodeRegistration as N, type OntologyRelation as O, type SchemaHash as P, type QueryAst as Q, type RelationalIndexDeclaration as R, type SqlDialect as S, type TemporalMode as T, type NullCheckOp as U, type VectorStrategy as V, type JsonSchema as W, type SerializedOntology as X, type SerializedUniqueConstraint as Y, type InferenceType as Z, type EdgeType as _, type NodeType as a, type RawStatementExecutionBackend as a$, type FieldRef as a0, type ComparisonOp as a1, type AggregateComparisonPredicate as a2, type TraversalDirection as a3, type AdapterBackendTransactions as a4, type BackendIdentity as a5, type BackendLifecycle as a6, type BackendMaintenance as a7, type BackendTransactions as a8, CURRENT_GRAPH_EXTENSION_VERSION as a9, type GraphEntityReadBackend as aA, type GraphEntityWriteBackend as aB, type GraphExtensionVersion as aC, type GraphLifecycleBackend as aD, type HybridFusionOptions as aE, type IndexMaterializationBackend as aF, type IntentSql as aG, type JsonPointerFor as aH, type JsonPointerInput as aI, type JsonPointerSegment as aJ, type JsonPointerSegments as aK, type JsonPointerSegmentsFor as aL, type JsonValue as aM, type KindAnnotations as aN, LEGACY_GRAPH_EXTENSION_VERSION as aO, MAX_JSON_POINTER_DEPTH as aP, type MetaEdge as aQ, type MetaEdgeProperties as aR, type NodeEntityReadBackend as aS, type NodeEntityWriteBackend as aT, type NodeId as aU, type NodeProps as aV, type OrderSpec as aW, type ParameterRef as aX, Placeholder as aY, type QueryExecutionBackend as aZ, type RawQueryExecutionBackend as a_, type Cardinality as aa, type Collation as ab, type CommitSchemaVersionExpected as ac, type CommitSchemaVersionParams as ad, type CompiledRowsSql as ae, type CompiledSelectSql as af, type CompiledStatementSql as ag, type ContributionMaterializationBackend as ah, DEFAULT_SQL_SCHEMA as ai, type DeleteFulltextBatchParams as aj, type EdgeEntityReadBackend as ak, type EdgeEntityWriteBackend as al, type EdgeId as am, type EdgeProps as an, type EdgeTypeWithEndpoints as ao, type EndpointExistence as ap, type ExternalRecordedReadSource as aq, type FilteredApproximateSearch as ar, type FilteredApproximateSearchMode as as, type FulltextBatchRow as at, type FulltextCapabilities as au, type FulltextOperationBackend as av, type FulltextQueryMode as aw, type FulltextSearchParams as ax, type FulltextSearchResult as ay, type GraphAnalyticsCapabilities as az, type AnyEdgeType as b, type VectorMetricType as b$, type RecordedRelationOptions as b0, type RemovalMaterializationBackend as b1, type RenderedSql as b2, type ResolveJsonPointer as b3, type ResolveJsonPointerSegments as b4, type ResolvedSqlTableNames as b5, type RowProps as b6, type SchemaCommitBackend as b7, type SchemaReadBackend as b8, type SetActiveVersionParams as b9, buildVectorCapabilities as bA, createSqlSchema as bB, fts5Strategy as bC, isEdgeType as bD, isEdgeTypeWithEndpoints as bE, isMetaEdge as bF, isNodeType as bG, isSqlFragment as bH, joinJsonPointers as bI, jsonPointer as bJ, normalizeJsonPointer as bK, parseJsonPointer as bL, recordedRelation as bM, renderPostgres as bN, renderSql as bO, renderSqlInline as bP, renderSqlite as bQ, rowPropsToJsonText as bR, rowPropsToObject as bS, sql as bT, tsvectorStrategy as bU, type ExtensionNodeDef as bV, type ExtensionEdgeDef as bW, type ExtensionOntologyRelation as bX, type ExtensionIndex as bY, type ValueType as bZ, type PredicateExpression as b_, type SortDirection as ba, type SqlChunk as bb, type SqlFragment as bc, type SqlIdentifierChunk as bd, type SqlIntent as be, type SqlParameterChunk as bf, type SqlPlaceholderChunk as bg, SqlSchema as bh, type SqlTableNames as bi, type SqlTag as bj, type SqlTextChunk as bk, type StrategyTableContribution as bl, type TableContribution as bm, type TransactionBackend as bn, type TransactionOptions as bo, type TransactionReadBackend as bp, type TraversalExpansion as bq, type TrustedImportSession as br, type UniqueConstraint as bs, type UniqueConstraintBackend as bt, type UniquenessScope as bu, type UpsertFulltextBatchParams as bv, type VectorCapabilities as bw, type VectorOperationBackend as bx, asEdgeId as by, asNodeId as bz, type GraphDefaults as c, type FindNodesByKindParams as c$, type Traversal as c0, type NodePredicate as c1, type ProjectedField as c2, type AggregateOrderSpec as c3, type GroupBySpec as c4, type RecursiveCyclePolicy as c5, type NodeRow as c6, type EdgeRow as c7, type VectorSlotMap as c8, type RecordedReadBinding as c9, type DialectAdapter as cA, type DialectCapabilities as cB, type DialectRecursiveQueryStrategy as cC, type DialectStandardQueryStrategy as cD, type DialectVectorPredicateStrategy as cE, type DropVectorIndexParams as cF, type EdgeExistsBetweenParams as cG, type ExtensionArrayItemType as cH, type ExtensionArrayProperty as cI, type ExtensionBooleanProperty as cJ, type ExtensionEdgeIndex as cK, type ExtensionEmbeddingModifier as cL, type ExtensionEnumProperty as cM, type ExtensionIndexWhere as cN, type ExtensionNodeIndex as cO, type ExtensionNumberProperty as cP, type ExtensionObjectFieldProperty as cQ, type ExtensionObjectProperty as cR, type ExtensionPropertyModifiers as cS, type ExtensionPropertyType as cT, type ExtensionSearchableModifier as cU, type ExtensionStringProperty as cV, type ExtensionUniqueConstraint as cW, type ExtensionUniqueWhere as cX, FULLTEXT_CONTRIBUTION_NAME as cY, type FindEdgesByKindParams as cZ, type FindEdgesConnectedToParams as c_, type SelectiveField as ca, type ComposableQuery as cb, type SetOperationType as cc, type SetOperation as cd, type VectorMetric as ce, ALL_FULLTEXT_MODES as cf, ALL_META_EDGE_NAMES as cg, BASE_CONTRIBUTION_OWNER as ch, type CheckUniqueBatchParams as ci, type CheckUniqueParams as cj, type ClaimIndexMaterializationParams as ck, type CompiledTemporaryStatementSql as cl, type ContributionMaterializationIdentity as cm, type ContributionMaterializationRow as cn, type CountEdgesByKindParams as co, type CountEdgesFromParams as cp, type CountNodesByKindParams as cq, type CreateVectorIndexParams as cr, D1_MAX_BIND_PARAMETERS as cs, DURABLE_OBJECT_MAX_BIND_PARAMETERS as ct, type DeleteEdgeParams as cu, type DeleteEdgesBatchParams as cv, type DeleteEmbeddingParams as cw, type DeleteFulltextParams as cx, type DeleteNodeParams as cy, type DeleteUniqueParams as cz, type EdgeIndexDeclaration as d, type GraphReadBackend as d0, type HardDeleteEdgeParams as d1, type HardDeleteNodeParams as d2, type HybridSearchParams as d3, type HybridSearchRow as d4, type IndexDeclarationBase as d5, type IndexMaterializationRow as d6, type IndexWhereLiteral as d7, type IndexWhereOp as d8, type IndexWhereOperand as d9, type UpsertFulltextParams as dA, VECTOR_CONTRIBUTION_PREFIX as dB, type VectorIndexType as dC, type VectorSearchParams as dD, type VectorSearchResult as dE, assertFiniteEmbedding as dF, assertVectorMinScore as dG, assertVectorSearchLimit as dH, buildFulltextCapabilities as dI, isLiveNodeRow as dJ, isSqlPlaceholder as dK, isTombstonedNodeRow as dL, normalizeGraphAnalyticsCapabilities as dM, quoteIdentifier as dN, shortHash as dO, vectorMinScoreCondition as dP, vectorPhysicalName as dQ, vectorScoreExpression as dR, GRAPH_EXTENSION_TOP_LEVEL_KEYS as dS, type GraphExtensionTopLevelKey as dT, type InsertEdgeParams as da, type InsertNodeParams as db, type InsertSchemaParams as dc, type InsertUniqueParams as dd, type KindRemovalRow as de, type LiveNodeRow as df, MODERN_SQLITE_MAX_BIND_PARAMETERS as dg, type MetaEdgeName as dh, POSTGRES_CAPABILITIES as di, POSTGRES_MAX_BIND_PARAMETERS as dj, type RecordContributionMaterializationParams as dk, type RecordIndexMaterializationParams as dl, type RecordKindRemovalParams as dm, type RelationalIndexMethod as dn, type ReleaseIndexMaterializationClaimParams as dp, SQLITE_CAPABILITIES as dq, SQLITE_MAX_BIND_PARAMETERS as dr, type SqlCompilationBackend as ds, type TombstonedNodeRow as dt, type UniqueRow as du, type UpdateEdgeParams as dv, type UpdateNodeParams as dw, type UpsertEmbeddingBatchParams as dx, type UpsertEmbeddingBatchRow as dy, type UpsertEmbeddingParams as dz, type NodeIndexDeclaration as e, type EdgeIndexConfig as f, type EdgeIndexDirection as g, type EdgeIndexWhereBuilder as h, type IndexOrigin as i, type IndexScope as j, type IndexWhereExpression as k, type IndexWhereFieldBuilder as l, type IndexWhereInput as m, type NodeIndexConfig as n, type NodeIndexWhereBuilder as o, type SystemColumnName as p, type VectorIndexDeclaration as q, type VectorIndexImplementation as r, type VectorIndexMetric as s, type VectorIndexParams as t, type VectorSlot as u, type SchemaVersionRow as v, type GraphBackend as w, type SerializedSchema as x, type SerializedNodeDef as y, type SerializedEdgeDef as z };
+export { type SerializedOntology as $, type AdapterBackend as A, type BackendCapabilities as B, type ContributionDiagnostic as C, type DeleteBehavior as D, type EdgeRegistration as E, type FulltextStrategy as F, type GraphExtension as G, type SerializedSchema as H, type IndexDeclaration as I, type JsonPointer as J, type KindEntity as K, type SerializedNodeDef as L, type SerializedEdgeDef as M, type NodeRegistration as N, type OntologyRelation as O, type IndexEntity as P, type QueryAst as Q, type RelationalIndexDeclaration as R, type SqlDialect as S, type TemporalMode as T, type SerializedMetaEdge as U, type VectorStrategy as V, type SerializedOntologyRelation as W, type SerializedClosures as X, type SchemaHash as Y, type NullCheckOp as Z, type JsonSchema as _, type ContributionDiagnosticState as a, type NodeEntityWriteBackend as a$, type SerializedUniqueConstraint as a0, type InferenceType as a1, type EdgeType as a2, type AggregateExpr as a3, type FieldRef as a4, type ComparisonOp as a5, type AggregateComparisonPredicate as a6, type TraversalDirection as a7, type AdapterBackendTransactions as a8, type BackendIdentity as a9, type FulltextCapabilities as aA, type FulltextOperationBackend as aB, type FulltextQueryMode as aC, type FulltextSearchParams as aD, type FulltextSearchResult as aE, type GraphAnalyticsCapabilities as aF, type GraphEntityReadBackend as aG, type GraphEntityWriteBackend as aH, type GraphExtensionVersion as aI, type GraphLifecycleBackend as aJ, type HardDeleteUniquesByNodeIdsParams as aK, type HybridFusionOptions as aL, type IndexMaterializationBackend as aM, type IntentSql as aN, type JsonPointerFor as aO, type JsonPointerInput as aP, type JsonPointerSegment as aQ, type JsonPointerSegments as aR, type JsonPointerSegmentsFor as aS, type JsonValue as aT, type KindAnnotations as aU, LEGACY_GRAPH_EXTENSION_VERSION as aV, type LockSchemaVersionForWriteParams as aW, MAX_JSON_POINTER_DEPTH as aX, type MetaEdge as aY, type MetaEdgeProperties as aZ, type NodeEntityReadBackend as a_, type BackendLifecycle as aa, type BackendMaintenance as ab, type BackendTransactions as ac, CURRENT_GRAPH_EXTENSION_VERSION as ad, type Cardinality as ae, type Collation as af, type CommitSchemaVersionExpected as ag, type CommitSchemaVersionIfKindsEmptyResult as ah, type CommitSchemaVersionParams as ai, type CompiledRowsSql as aj, type CompiledSelectSql as ak, type CompiledStatementSql as al, type ContributionMaterializationBackend as am, DEFAULT_SQL_SCHEMA as an, type DeleteFulltextBatchParams as ao, type EdgeEntityReadBackend as ap, type EdgeEntityWriteBackend as aq, type EdgeId as ar, type EdgeProps as as, type EdgeTypeWithEndpoints as at, type EndpointExistence as au, type ExternalRecordedReadSource as av, type FilteredApproximateSearch as aw, type FilteredApproximateSearchMode as ax, type FindEdgesByHeterogeneousEndpointSetParams as ay, type FulltextBatchRow as az, type ContributionRepairEntry as b, renderPostgres as b$, type NodeId as b0, type NodeProps as b1, type OrderSpec as b2, type ParameterRef as b3, Placeholder as b4, type PopulatedSchemaKind as b5, type QueryExecutionBackend as b6, type RawQueryExecutionBackend as b7, type RawStatementExecutionBackend as b8, type RecordedRelationOptions as b9, type TransactionReadBackend as bA, type TraversalExpansion as bB, type TrustedImportOptions as bC, type TrustedImportSession as bD, type UniqueConstraint as bE, type UniqueConstraintBackend as bF, type UniquenessScope as bG, type UpdateNodeSetParams as bH, type UpdateNodeSetResult as bI, type UpsertFulltextBatchParams as bJ, type VectorCapabilities as bK, type VectorOperationBackend as bL, asEdgeId as bM, asNodeId as bN, buildVectorCapabilities as bO, createSqlSchema as bP, fts5Strategy as bQ, isEdgeType as bR, isEdgeTypeWithEndpoints as bS, isMetaEdge as bT, isNodeType as bU, isSqlFragment as bV, joinJsonPointers as bW, jsonPointer as bX, normalizeJsonPointer as bY, parseJsonPointer as bZ, recordedRelation as b_, type RemovalMaterializationBackend as ba, type RenderedSql as bb, type ResolveJsonPointer as bc, type ResolveJsonPointerSegments as bd, type ResolvedSqlTableNames as be, type RowProps as bf, type SchemaCommitBackend as bg, type SchemaKindEmptinessProbe as bh, type SchemaReadBackend as bi, type SchemaWriteFenceBackend as bj, type SetActiveVersionParams as bk, type SortDirection as bl, type SqlChunk as bm, type SqlFragment as bn, type SqlIdentifierChunk as bo, type SqlIntent as bp, type SqlParameterChunk as bq, type SqlPlaceholderChunk as br, SqlSchema as bs, type SqlTableNames as bt, type SqlTag as bu, type SqlTextChunk as bv, type StrategyTableContribution as bw, type TableContribution as bx, type TransactionBackend as by, type TransactionOptions as bz, type ContributionRepairResult as c, type ExtensionIndexWhere as c$, renderSql as c0, renderSqlInline as c1, renderSqlite as c2, rowPropsToJsonText as c3, rowPropsToObject as c4, sql as c5, tsvectorStrategy as c6, type ExtensionNodeDef as c7, type ExtensionEdgeDef as c8, type ExtensionOntologyRelation as c9, type ContributionMaterializationIdentity as cA, type ContributionMaterializationRow as cB, type CountEdgesByKindParams as cC, type CountEdgesFromParams as cD, type CountNodesByKindParams as cE, type CreateVectorIndexParams as cF, D1_MAX_BIND_PARAMETERS as cG, DURABLE_OBJECT_MAX_BIND_PARAMETERS as cH, type DeleteEdgeParams as cI, type DeleteEdgesBatchParams as cJ, type DeleteEmbeddingParams as cK, type DeleteFulltextParams as cL, type DeleteNodeParams as cM, type DeleteUniqueParams as cN, type DialectAdapter as cO, type DialectCapabilities as cP, type DialectRecursiveQueryStrategy as cQ, type DialectStandardQueryStrategy as cR, type DialectVectorPredicateStrategy as cS, type DropVectorIndexParams as cT, type EdgeExistsBetweenParams as cU, type ExtensionArrayItemType as cV, type ExtensionArrayProperty as cW, type ExtensionBooleanProperty as cX, type ExtensionEdgeIndex as cY, type ExtensionEmbeddingModifier as cZ, type ExtensionEnumProperty as c_, type ExtensionIndex as ca, type ValueType as cb, type PredicateExpression as cc, type VectorMetricType as cd, type Traversal as ce, type NodePredicate as cf, type ProjectedField as cg, type AggregateOrderSpec as ch, type GroupBySpec as ci, type RecursiveCyclePolicy as cj, type VectorSlotMap as ck, type RecordedReadBinding as cl, type SelectiveField as cm, type ComposableQuery as cn, type SetOperationType as co, type SetOperation as cp, type NodeRow as cq, type EdgeRow as cr, type VectorMetric as cs, ALL_FULLTEXT_MODES as ct, ALL_META_EDGE_NAMES as cu, BASE_CONTRIBUTION_OWNER as cv, type CheckUniqueBatchParams as cw, type CheckUniqueParams as cx, type ClaimIndexMaterializationParams as cy, type CompiledTemporaryStatementSql as cz, type NodeType as d, isTombstonedNodeRow as d$, type ExtensionNodeIndex as d0, type ExtensionNumberProperty as d1, type ExtensionObjectFieldProperty as d2, type ExtensionObjectProperty as d3, type ExtensionPropertyModifiers as d4, type ExtensionPropertyType as d5, type ExtensionSearchableModifier as d6, type ExtensionStringProperty as d7, type ExtensionUniqueConstraint as d8, type ExtensionUniqueWhere as d9, POSTGRES_MAX_BIND_PARAMETERS as dA, type RecordContributionMaterializationParams as dB, type RecordIndexMaterializationParams as dC, type RecordKindRemovalParams as dD, type RelationalIndexMethod as dE, type ReleaseIndexMaterializationClaimParams as dF, SQLITE_CAPABILITIES as dG, SQLITE_MAX_BIND_PARAMETERS as dH, type SqlCompilationBackend as dI, type TombstonedNodeRow as dJ, type UniqueRow as dK, type UpdateEdgeParams as dL, type UpdateNodeParams as dM, type UpsertEmbeddingBatchParams as dN, type UpsertEmbeddingBatchRow as dO, type UpsertEmbeddingParams as dP, type UpsertFulltextParams as dQ, VECTOR_CONTRIBUTION_PREFIX as dR, type VectorIndexType as dS, type VectorSearchParams as dT, type VectorSearchResult as dU, assertFiniteEmbedding as dV, assertVectorMinScore as dW, assertVectorSearchLimit as dX, buildFulltextCapabilities as dY, isLiveNodeRow as dZ, isSqlPlaceholder as d_, FULLTEXT_CONTRIBUTION_NAME as da, type FindEdgesByEndpointSetParams as db, type FindEdgesByKindParams as dc, type FindEdgesConnectedToParams as dd, type FindNodesByKindParams as de, type GraphReadBackend as df, type HardDeleteEdgeParams as dg, type HardDeleteNodeParams as dh, type HybridSearchParams as di, type HybridSearchRow as dj, type InListParameterOptions as dk, type IndexDeclarationBase as dl, type IndexMaterializationRow as dm, type IndexWhereLiteral as dn, type IndexWhereOp as dp, type IndexWhereOperand as dq, type InsertEdgeParams as dr, type InsertNodeParams as ds, type InsertSchemaParams as dt, type InsertUniqueParams as du, type KindRemovalRow as dv, type LiveNodeRow as dw, MODERN_SQLITE_MAX_BIND_PARAMETERS as dx, type MetaEdgeName as dy, POSTGRES_CAPABILITIES as dz, type AnyEdgeType as e, normalizeGraphAnalyticsCapabilities as e0, quoteIdentifier as e1, shortHash as e2, vectorMinScoreCondition as e3, vectorPhysicalName as e4, vectorScoreExpression as e5, GRAPH_EXTENSION_TOP_LEVEL_KEYS as e6, type GraphExtensionTopLevelKey as e7, type GraphDefaults as f, type EdgeIndexDeclaration as g, type NodeIndexDeclaration as h, type EdgeIndexConfig as i, type EdgeIndexDirection as j, type EdgeIndexWhereBuilder as k, type IndexOrigin as l, type IndexScope as m, type IndexWhereExpression as n, type IndexWhereFieldBuilder as o, type IndexWhereInput as p, type NodeIndexConfig as q, type NodeIndexWhereBuilder as r, type SystemColumnName as s, type VectorIndexDeclaration as t, type VectorIndexImplementation as u, type VectorIndexMetric as v, type VectorIndexParams as w, type VectorSlot as x, type SchemaVersionRow as y, type GraphBackend as z };