@nicia-ai/typegraph 0.42.1 → 0.44.0

package/dist/{types-Dh-EgT-w.d.cts → types-Cjvkj0jA.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.
  *
@@ -787,6 +799,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.
      *
@@ -2088,7 +2134,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
@@ -2780,6 +2828,102 @@ 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. For `missing-marker` and `failed-materialization` prefer
+ * `ensureVectorSlotContribution(slot, { force: true })`, whose DDL is
+ * `CREATE ... IF NOT EXISTS` and never drops. Note also that
+ * `ensureRuntimeContributions` does NOT repair a fulltext
+ * `orphaned-marker`: it short-circuits on the marker, which still
+ * reads as initialized. See the per-state repair tables 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;
+}>;
 /**
  * One row of the per-deployment `typegraph_kind_removals` table:
  * a graph-extension kind that has been removed from the schema and whose
@@ -2895,6 +3039,22 @@ 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[]>;
     countEdgesByKind: (this: void, params: CountEdgesByKindParams) => Promise<number>;
     insertUnique: (this: void, params: InsertUniqueParams) => Promise<void>;
     /**
@@ -2930,6 +3090,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 +3134,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 —
@@ -3193,6 +3404,32 @@ 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[]>;
     /**
      * Bootstraps the fulltext storage table the active `FulltextStrategy`
      * owns. Same focused-bootstrap rationale as the other `ensure*Table`
@@ -3263,9 +3500,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
@@ -3320,13 +3565,14 @@ 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 EdgeEntityReadBackend = Pick<GraphBackend, "getEdge" | "getEdges" | "countEdgesFrom" | "edgeExistsBetween" | "findEdgesConnectedTo" | "findEdgesByKind" | "findEdgesByEndpointSet" | "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 SchemaReadBackend = Pick<GraphBackend, "getActiveSchema" | "getSchemaVersion">;
-type SchemaCommitBackend = Pick<GraphBackend, "commitSchemaVersion" | "setActiveVersion">;
+type SchemaCommitBackend = Pick<GraphBackend, "commitSchemaVersion" | "commitSchemaVersionIfKindsEmpty" | "setActiveVersion">;
+type SchemaWriteFenceBackend = Pick<GraphBackend, "lockSchemaVersionForWrite">;
 type VectorOperationBackend = Pick<GraphBackend, "upsertEmbedding" | "upsertEmbeddingBatch" | "deleteEmbedding" | "vectorSearch" | "createVectorIndex" | "dropVectorIndex">;
 type FulltextOperationBackend = Pick<GraphBackend, "upsertFulltext" | "deleteFulltext" | "upsertFulltextBatch" | "deleteFulltextBatch" | "fulltextSearch">;
 type IndexMaterializationBackend = Pick<GraphBackend, "ensureIndexMaterializationsTable" | "getIndexMaterialization" | "getIndexMaterializations" | "recordIndexMaterialization">;
@@ -3358,7 +3604,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.
  */
@@ -3449,6 +3695,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 +3842,70 @@ 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 counting edges by kind.
  */
@@ -3611,11 +3950,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 +4756,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 InferenceType 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 SerializedEdgeDef as H, type IndexDeclaration as I, type JsonPointer as J, type KindEntity as K, type IndexEntity as L, type SerializedMetaEdge as M, type NodeRegistration as N, type OntologyRelation as O, type SerializedOntologyRelation as P, type QueryAst as Q, type RelationalIndexDeclaration as R, type SqlDialect as S, type TemporalMode as T, type SerializedClosures as U, type VectorStrategy as V, type SchemaHash as W, type NullCheckOp as X, type JsonSchema as Y, type SerializedOntology as Z, type SerializedUniqueConstraint as _, type ContributionDiagnosticState as a, type ParameterRef as a$, type EdgeType as a0, type AggregateExpr as a1, type FieldRef as a2, type ComparisonOp as a3, type AggregateComparisonPredicate as a4, type TraversalDirection as a5, type AdapterBackendTransactions as a6, type BackendIdentity as a7, type BackendLifecycle as a8, type BackendMaintenance as a9, type FulltextSearchParams as aA, type FulltextSearchResult as aB, type GraphAnalyticsCapabilities as aC, type GraphEntityReadBackend as aD, type GraphEntityWriteBackend as aE, type GraphExtensionVersion as aF, type GraphLifecycleBackend as aG, type HybridFusionOptions as aH, type IndexMaterializationBackend as aI, type IntentSql as aJ, type JsonPointerFor as aK, type JsonPointerInput as aL, type JsonPointerSegment as aM, type JsonPointerSegments as aN, type JsonPointerSegmentsFor as aO, type JsonValue as aP, type KindAnnotations as aQ, LEGACY_GRAPH_EXTENSION_VERSION as aR, type LockSchemaVersionForWriteParams as aS, MAX_JSON_POINTER_DEPTH as aT, type MetaEdge as aU, type MetaEdgeProperties as aV, type NodeEntityReadBackend as aW, type NodeEntityWriteBackend as aX, type NodeId as aY, type NodeProps as aZ, type OrderSpec as a_, type BackendTransactions as aa, CURRENT_GRAPH_EXTENSION_VERSION as ab, type Cardinality as ac, type Collation as ad, type CommitSchemaVersionExpected as ae, type CommitSchemaVersionIfKindsEmptyResult as af, type CommitSchemaVersionParams as ag, type CompiledRowsSql as ah, type CompiledSelectSql as ai, type CompiledStatementSql as aj, type ContributionMaterializationBackend as ak, DEFAULT_SQL_SCHEMA as al, type DeleteFulltextBatchParams as am, type EdgeEntityReadBackend as an, type EdgeEntityWriteBackend as ao, type EdgeId as ap, type EdgeProps as aq, type EdgeTypeWithEndpoints as ar, type EndpointExistence as as, type ExternalRecordedReadSource as at, type FilteredApproximateSearch as au, type FilteredApproximateSearchMode as av, type FulltextBatchRow as aw, type FulltextCapabilities as ax, type FulltextOperationBackend as ay, type FulltextQueryMode as az, type NodeType as b, sql as b$, Placeholder as b0, type PopulatedSchemaKind as b1, type QueryExecutionBackend as b2, type RawQueryExecutionBackend as b3, type RawStatementExecutionBackend as b4, type RecordedRelationOptions as b5, type RemovalMaterializationBackend as b6, type RenderedSql as b7, type ResolveJsonPointer as b8, type ResolveJsonPointerSegments as b9, type UniqueConstraint as bA, type UniqueConstraintBackend as bB, type UniquenessScope as bC, type UpsertFulltextBatchParams as bD, type VectorCapabilities as bE, type VectorOperationBackend as bF, asEdgeId as bG, asNodeId as bH, buildVectorCapabilities as bI, createSqlSchema as bJ, fts5Strategy as bK, isEdgeType as bL, isEdgeTypeWithEndpoints as bM, isMetaEdge as bN, isNodeType as bO, isSqlFragment as bP, joinJsonPointers as bQ, jsonPointer as bR, normalizeJsonPointer as bS, parseJsonPointer as bT, recordedRelation as bU, renderPostgres as bV, renderSql as bW, renderSqlInline as bX, renderSqlite as bY, rowPropsToJsonText as bZ, rowPropsToObject as b_, type ResolvedSqlTableNames as ba, type RowProps as bb, type SchemaCommitBackend as bc, type SchemaKindEmptinessProbe as bd, type SchemaReadBackend as be, type SchemaWriteFenceBackend as bf, type SetActiveVersionParams as bg, type SortDirection as bh, type SqlChunk as bi, type SqlFragment as bj, type SqlIdentifierChunk as bk, type SqlIntent as bl, type SqlParameterChunk as bm, type SqlPlaceholderChunk as bn, SqlSchema as bo, type SqlTableNames as bp, type SqlTag as bq, type SqlTextChunk as br, type StrategyTableContribution as bs, type TableContribution as bt, type TransactionBackend as bu, type TransactionOptions as bv, type TransactionReadBackend as bw, type TraversalExpansion as bx, type TrustedImportOptions as by, type TrustedImportSession as bz, type AnyEdgeType as c, type ExtensionPropertyType as c$, tsvectorStrategy as c0, type ExtensionNodeDef as c1, type ExtensionEdgeDef as c2, type ExtensionOntologyRelation as c3, type ExtensionIndex as c4, type ValueType as c5, type PredicateExpression as c6, type VectorMetricType as c7, type Traversal as c8, type NodePredicate as c9, D1_MAX_BIND_PARAMETERS as cA, DURABLE_OBJECT_MAX_BIND_PARAMETERS as cB, type DeleteEdgeParams as cC, type DeleteEdgesBatchParams as cD, type DeleteEmbeddingParams as cE, type DeleteFulltextParams as cF, type DeleteNodeParams as cG, type DeleteUniqueParams as cH, type DialectAdapter as cI, type DialectCapabilities as cJ, type DialectRecursiveQueryStrategy as cK, type DialectStandardQueryStrategy as cL, type DialectVectorPredicateStrategy as cM, type DropVectorIndexParams as cN, type EdgeExistsBetweenParams as cO, type ExtensionArrayItemType as cP, type ExtensionArrayProperty as cQ, type ExtensionBooleanProperty as cR, type ExtensionEdgeIndex as cS, type ExtensionEmbeddingModifier as cT, type ExtensionEnumProperty as cU, type ExtensionIndexWhere as cV, type ExtensionNodeIndex as cW, type ExtensionNumberProperty as cX, type ExtensionObjectFieldProperty as cY, type ExtensionObjectProperty as cZ, type ExtensionPropertyModifiers as c_, type ProjectedField as ca, type AggregateOrderSpec as cb, type GroupBySpec as cc, type RecursiveCyclePolicy as cd, type NodeRow as ce, type EdgeRow as cf, type VectorSlotMap as cg, type RecordedReadBinding as ch, type SelectiveField as ci, type ComposableQuery as cj, type SetOperationType as ck, type SetOperation as cl, type VectorMetric as cm, ALL_FULLTEXT_MODES as cn, ALL_META_EDGE_NAMES as co, BASE_CONTRIBUTION_OWNER as cp, type CheckUniqueBatchParams as cq, type CheckUniqueParams as cr, type ClaimIndexMaterializationParams as cs, type CompiledTemporaryStatementSql as ct, type ContributionMaterializationIdentity as cu, type ContributionMaterializationRow as cv, type CountEdgesByKindParams as cw, type CountEdgesFromParams as cx, type CountNodesByKindParams as cy, type CreateVectorIndexParams as cz, type GraphDefaults as d, GRAPH_EXTENSION_TOP_LEVEL_KEYS as d$, type ExtensionSearchableModifier as d0, type ExtensionStringProperty as d1, type ExtensionUniqueConstraint as d2, type ExtensionUniqueWhere as d3, FULLTEXT_CONTRIBUTION_NAME as d4, type FindEdgesByKindParams as d5, type FindEdgesConnectedToParams as d6, type FindNodesByKindParams as d7, type GraphReadBackend as d8, type HardDeleteEdgeParams as d9, SQLITE_MAX_BIND_PARAMETERS as dA, type SqlCompilationBackend as dB, type TombstonedNodeRow as dC, type UniqueRow as dD, type UpdateEdgeParams as dE, type UpdateNodeParams as dF, type UpsertEmbeddingBatchParams as dG, type UpsertEmbeddingBatchRow as dH, type UpsertEmbeddingParams as dI, type UpsertFulltextParams as dJ, VECTOR_CONTRIBUTION_PREFIX as dK, type VectorIndexType as dL, type VectorSearchParams as dM, type VectorSearchResult as dN, assertFiniteEmbedding as dO, assertVectorMinScore as dP, assertVectorSearchLimit as dQ, buildFulltextCapabilities as dR, isLiveNodeRow as dS, isSqlPlaceholder as dT, isTombstonedNodeRow as dU, normalizeGraphAnalyticsCapabilities as dV, quoteIdentifier as dW, shortHash as dX, vectorMinScoreCondition as dY, vectorPhysicalName as dZ, vectorScoreExpression as d_, type HardDeleteNodeParams as da, type HybridSearchParams as db, type HybridSearchRow as dc, type InListParameterOptions as dd, type IndexDeclarationBase as de, type IndexMaterializationRow as df, type IndexWhereLiteral as dg, type IndexWhereOp as dh, type IndexWhereOperand as di, type InsertEdgeParams as dj, type InsertNodeParams as dk, type InsertSchemaParams as dl, type InsertUniqueParams as dm, type KindRemovalRow as dn, type LiveNodeRow as dp, MODERN_SQLITE_MAX_BIND_PARAMETERS as dq, type MetaEdgeName as dr, POSTGRES_CAPABILITIES as ds, POSTGRES_MAX_BIND_PARAMETERS as dt, type RecordContributionMaterializationParams as du, type RecordIndexMaterializationParams as dv, type RecordKindRemovalParams as dw, type RelationalIndexMethod as dx, type ReleaseIndexMaterializationClaimParams as dy, SQLITE_CAPABILITIES as dz, type EdgeIndexDeclaration as e, type GraphExtensionTopLevelKey as e0, type NodeIndexDeclaration as f, type EdgeIndexConfig as g, type EdgeIndexDirection as h, type EdgeIndexWhereBuilder as i, type IndexOrigin as j, type IndexScope as k, type IndexWhereExpression as l, type IndexWhereFieldBuilder as m, type IndexWhereInput as n, type NodeIndexConfig as o, type NodeIndexWhereBuilder as p, type SystemColumnName as q, type VectorIndexDeclaration as r, type VectorIndexImplementation as s, type VectorIndexMetric as t, type VectorIndexParams as u, type VectorSlot as v, type SchemaVersionRow as w, type GraphBackend as x, type SerializedSchema as y, type SerializedNodeDef as z };

package/dist/{where-B8Y21kig.d.ts → where-5xVawAwL.d.ts}

@@ -1,4 +1,4 @@
-import { b as AnyEdgeType, f as EdgeIndexConfig, d as EdgeIndexDeclaration, a as NodeType, n as NodeIndexConfig, e as NodeIndexDeclaration, k as IndexWhereExpression } from './types-Dh-EgT-w.js';
+import { c as AnyEdgeType, g as EdgeIndexConfig, e as EdgeIndexDeclaration, b as NodeType, o as NodeIndexConfig, f as NodeIndexDeclaration, l as IndexWhereExpression } from './types-Cjvkj0jA.js';
 
 /** The TypeGraph relations that carry system indexes. */
 type SystemIndexTable = "nodes" | "edges" | "recordedNodes" | "recordedEdges";

package/dist/{where-DbZ9XDOI.d.cts → where-CUQmCR6d.d.cts}

@@ -1,4 +1,4 @@
-import { b as AnyEdgeType, f as EdgeIndexConfig, d as EdgeIndexDeclaration, a as NodeType, n as NodeIndexConfig, e as NodeIndexDeclaration, k as IndexWhereExpression } from './types-Dh-EgT-w.cjs';
+import { c as AnyEdgeType, g as EdgeIndexConfig, e as EdgeIndexDeclaration, b as NodeType, o as NodeIndexConfig, f as NodeIndexDeclaration, l as IndexWhereExpression } from './types-Cjvkj0jA.cjs';
 
 /** The TypeGraph relations that carry system indexes. */
 type SystemIndexTable = "nodes" | "edges" | "recordedNodes" | "recordedEdges";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nicia-ai/typegraph",
-  "version": "0.42.1",
+  "version": "0.44.0",
   "description": "TypeScript-first embedded knowledge graph library with ontological reasoning",
   "type": "module",
   "main": "./dist/index.cjs",