@nicia-ai/typegraph 0.28.0 → 0.29.0

package/dist/{types-CQ7xXJMP.d.ts → types-DXCSyxac.d.cts}

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { N as NodeType, e as EdgeType, o as UniquenessScope, g as Collation, D as DeleteBehavior, d as KindAnnotations, f as Cardinality, k as EndpointExistence, T as TemporalMode, G as GraphExtension, I as IndexEntity, K as KindEntity, a as NullCheckOp, A as AnyEdgeType } from './extension-types-B78CZfA5.js';
+import { N as NodeType, d as EdgeType, U as UniquenessScope, C as Collation, D as DeleteBehavior, e as KindAnnotations, f as Cardinality, g as EndpointExistence, T as TemporalMode, G as GraphExtension, I as IndexEntity, K as KindEntity, a as NullCheckOp, A as AnyEdgeType } from './extension-types-CwHV-Uk4.cjs';
 import { SQL } from 'drizzle-orm';
 import { PgDatabase, PgQueryResultHKT } from 'drizzle-orm/pg-core';
 import { BaseSQLiteDatabase } from 'drizzle-orm/sqlite-core';
@@ -120,8 +120,6 @@ type SqlTableNames = Readonly<{
     nodes: string;
     /** Edges table name (default: "typegraph_edges") */
     edges: string;
-    /** Node embeddings table name (default: "typegraph_node_embeddings") */
-    embeddings: string;
     /** Node fulltext table name (default: "typegraph_node_fulltext") */
     fulltext: string;
     /** Node uniques table name (default: "typegraph_node_uniques") */
@@ -138,8 +136,6 @@ type SqlSchema = Readonly<{
     nodesTable: SQL;
     /** Get a SQL reference to the edges table */
     edgesTable: SQL;
-    /** Get a SQL reference to the embeddings table */
-    embeddingsTable: SQL;
     /** Get a SQL reference to the fulltext table */
     fulltextTable: SQL;
 }>;
@@ -162,7 +158,7 @@ type SqlSchema = Readonly<{
  * const schema = createSqlSchema({
  *   nodes: "myapp_nodes",
  *   edges: "myapp_edges",
- *   embeddings: "myapp_embeddings",
+ *   fulltext: "myapp_fulltext",
  * });
  * ```
  */
@@ -171,6 +167,27 @@ declare function createSqlSchema(names?: Partial<SqlTableNames>): SqlSchema;
  * Default SqlSchema using standard TypeGraph table names.
  */
 declare const DEFAULT_SQL_SCHEMA: SqlSchema;
+/**
+ * The compiler's resolved view of one declared embedding field — the
+ * `(dimensions, metric, indexType)` a {@link VectorStrategy} needs to
+ * name and scan the field's typed per-`(kind, field)` storage. Sourced
+ * from the registered node schema's `embedding()` declaration when the
+ * store builds its compile options.
+ */
+type VectorSlotDescriptor = Readonly<{
+    dimensions: number;
+    metric: VectorMetric;
+    indexType: VectorIndexType;
+}>;
+/**
+ * Map of declared embedding slots keyed by {@link vectorSlotKey} -
+ * `"<nodeKind>\0<fieldPath>"` (NUL-separated). Carries every `(concrete kind,
+ * fieldPath)` that declares an embedding field, so the compiler's
+ * `field.similarTo(...)` CTE can UNION ALL the per-field tables for the
+ * kinds in an alias that actually declare the field (only
+ * `includeSubClasses` yields more than one).
+ */
+type VectorSlotMap = ReadonlyMap<string, VectorSlotDescriptor>;
 
 /**
  * A single table TypeGraph owns.
@@ -348,6 +365,181 @@ interface FulltextStrategy {
 declare const tsvectorStrategy: FulltextStrategy;
 declare const fts5Strategy: FulltextStrategy;
 
+/**
+ * Vector Strategy — pluggable storage + SQL generation for a backend's
+ * vector stack. The sibling of {@link FulltextStrategy}: a strategy owns
+ * every statement that touches its embedding storage — the per-field DDL,
+ * upsert, delete, similarity search, and (optional) ANN index lifecycle —
+ * plus the capability advertisement and the distance/score expressions the
+ * query compiler splices into its relevance CTE.
+ *
+ * ## Why a strategy, and why per-(kind, field) storage
+ *
+ * The spike behind #157 established that "real" ANN on every engine we
+ * support converges on a
+ * **typed, fixed-dimension structure per `(nodeKind, fieldPath)`**:
+ *
+ * - pgvector: a `vector(N)` column + HNSW/IVFFlat;
+ * - libSQL native: an `F32_BLOB(N)` column + `libsql_vector_idx` +
+ *   `vector_top_k` (a plain `BLOB` or dimensionless `F32_BLOB` is rejected
+ *   by the index — the dimension must live in the column type);
+ * - sqlite-vec: a `vec0(embedding float[N])` virtual table.
+ *
+ * The legacy single shared `typegraph_node_embeddings` table (one generic
+ * column holding mixed-dimension vectors) can only ever be brute-forced;
+ * pgvector was the sole engine that hid this, because its index supplies the
+ * dimension via a `::vector(N)` cast expression. So storage is the
+ * strategy's to own, slot by slot, rather than a fixed global table.
+ *
+ * Brute force remains a legitimate, capability-advertised mode (libSQL's
+ * `vector_distance_cos` over a column with no index, sqlite-vec's
+ * `vec_distance_cosine`): a strategy whose `capabilities.indexTypes` is
+ * `["none"]` simply never emits an ANN index and `buildSearch` always scans.
+ */
+
+/**
+ * The resolved identity of one embedding field's storage in a graph —
+ * everything a strategy needs to DDL, address, and index it.
+ *
+ * Graph-scoped: each `(graphId, nodeKind, fieldPath)` gets its own physical
+ * table. TypeGraph supports many graphs per physical database, and the same
+ * `(kind, field)` can carry different embedding dimensions across graphs — a
+ * shared per-`(kind, field)` table would collide on the fixed column type
+ * (`vector(N)` / `F32_BLOB(N)`). Graph-scoping also makes libSQL's
+ * table-global `vector_top_k` per-graph-exact (no cross-graph recall bleed).
+ */
+type VectorSlot = Readonly<{
+    /** Graph the embedding belongs to — scopes the physical table. */
+    graphId: string;
+    /** Node kind owning the embedding field (e.g. `"Document"`). */
+    nodeKind: string;
+    /** Dot-path of the embedding field within the node props (e.g. `"embedding"`). */
+    fieldPath: string;
+    /** Fixed vector dimension `N` for this field — carried into the column type. */
+    dimensions: number;
+    /** Distance metric the field's index is built for. */
+    metric: VectorMetric;
+    /**
+     * Index type to materialize. `"none"` means brute-force only (no ANN
+     * index emitted); the strategy still stores and searches the field.
+     */
+    indexType: VectorIndexType;
+    /**
+     * Optional ANN index tuning carried into the index DDL (pgvector
+     * `m`/`ef_construction`/`lists`). Present on the create-index / re-embed
+     * paths (resolved from the field's `embedding()` declaration); omitted on
+     * the write/search ensure paths, where the strategy falls back to defaults.
+     */
+    indexParams?: Readonly<{
+        m?: number;
+        efConstruction?: number;
+        lists?: number;
+    }>;
+}>;
+/**
+ * Derives the `VectorCapabilities` a backend advertises from its active
+ * strategy, so the two never drift (mirrors `buildFulltextCapabilities`).
+ * The strategy is the single source of truth; there are no per-call-site
+ * `SQLITE_VECTOR_*` constants.
+ */
+declare function buildVectorCapabilities(strategy: VectorStrategy): VectorCapabilities;
+/**
+ * A pluggable vector implementation. Each strategy is self-contained:
+ * given a {@link VectorSlot}, it emits every statement the backend and
+ * compiler need — per-field storage DDL, writes, similarity search, ANN
+ * index lifecycle — and advertises exactly the metrics and index types it
+ * can honor. Adding the Nth backend is one of these objects; no core edits.
+ */
+interface VectorStrategy {
+    /** Human-readable identifier used in error messages and telemetry. */
+    readonly name: string;
+    /**
+     * The metrics, index types, and dimension ceiling this strategy honors —
+     * advertised verbatim as `backend.capabilities.vector`. Asymmetry across
+     * engines is legitimate and explicit here (pgvector has `inner_product`;
+     * libSQL/sqlite-vec do not), never a silent runtime failure.
+     */
+    readonly capabilities: VectorCapabilities;
+    /**
+     * Deterministic physical table (or virtual-table) name backing a field in
+     * a graph. The compiler references this to scan the right per-field storage,
+     * and the backend uses it to route upserts/deletes. Must be a stable,
+     * collision-safe SQL identifier derived from `(graphId, nodeKind, fieldPath)`.
+     */
+    tableName(graphId: string, nodeKind: string, fieldPath: string): string;
+    /**
+     * The per-field storage this strategy owns for `slot`, as Drizzle-free
+     * `StrategyTableContribution`s (resolved `tableName`, deterministic
+     * idempotent `createDdl` for the table **and** its ANN index when the
+     * slot's `indexType` warrants one, `runtimeEnsure`). Rides the #129/#135
+     * table-contribution + durable-materialization machinery exactly as the
+     * FTS5 / tsvector virtual tables do — these are materialized per graph by
+     * `materializeIndexes()`, not by global `bootstrapTables`.
+     */
+    ownedTables(slot: VectorSlot): readonly StrategyTableContribution[];
+    /**
+     * Emits the statement(s) that upsert a single embedding into the slot's
+     * storage. Multiple statements are allowed for engines that cannot upsert
+     * a vector in one statement (e.g. a `vec0` virtual table → DELETE+INSERT).
+     */
+    buildUpsert(slot: VectorSlot, params: UpsertEmbeddingParams, timestamp: string): readonly SQL[];
+    /** Emits the statement(s) that delete a single embedding from the slot. */
+    buildDelete(slot: VectorSlot, params: DeleteEmbeddingParams): readonly SQL[];
+    /**
+     * Raw DDL statement(s) that drop the slot's entire physical storage
+     * (table + ANN index, and any engine-managed shadow tables). Used by the
+     * destructive `store.reembedVectorField()` path to recreate a field's
+     * storage at a new dimension. Returned as raw strings (like
+     * `ownedTables(...).createDdl`) for `backend.executeDdl`; must be idempotent
+     * (`IF EXISTS`).
+     */
+    buildDropStorage(slot: VectorSlot): readonly string[];
+    /**
+     * Emits the similarity-search query for the `backend.vectorSearch` path,
+     * returning rows shaped `{ node_id, score }` ordered best-first. The
+     * strategy picks brute-force vs ANN based on whether `slot.indexType`
+     * materialized an index — the caller never branches. `score` follows the
+     * shared convention (cosine → similarity `1 - distance`; l2 /
+     * inner_product → raw distance), so `coerceVectorScore` / fusion stay
+     * dialect-neutral.
+     */
+    buildSearch(slot: VectorSlot, params: VectorSearchParams): SQL;
+    /**
+     * The distance expression over the slot's embedding column, used by the
+     * **query compiler** to splice vector relevance into its CTE. This is the
+     * one genuinely engine-specific fragment (`vec_distance_cosine` vs
+     * `<=>` vs `vector_distance_cos`); the surrounding score / minScore /
+     * ORDER BY math is shared (see {@link vectorScoreExpression} etc.).
+     *
+     * `embeddingColumn` is the already-qualified column SQL; `queryEmbedding`
+     * is formatted by the strategy into its engine's literal form.
+     */
+    distanceExpression(embeddingColumn: SQL, queryEmbedding: readonly number[], metric: VectorMetric): SQL;
+    /**
+     * Emits the ANN index creation statement for a slot, or `undefined` when
+     * indexing is inline (vec0) or unsupported (brute-force-only strategies).
+     * Invoked through `backend.createVectorIndex` during `materializeIndexes`.
+     */
+    buildCreateIndex?(slot: VectorSlot, options?: Readonly<{
+        concurrent?: boolean;
+    }>): SQL | undefined;
+    /** Emits the ANN index drop statement, or `undefined` when not applicable. */
+    buildDropIndex?(slot: VectorSlot): SQL | undefined;
+}
+
+/**
+ * SQL Dialect Abstraction Layer
+ *
+ * Provides a unified interface for dialect-specific SQL generation.
+ * Implementing a new dialect (MySQL, SQL Server, etc.) requires
+ * implementing this interface.
+ */
+
+/**
+ * Supported SQL dialects.
+ */
+type SqlDialect = "sqlite" | "postgres";
+
 /**
  * JSON Schema type (subset used by Zod toJSONSchema).
  *
@@ -541,19 +733,6 @@ type SqliteExecutionProfileHints = Readonly<{
 }>;
 type AnySqliteDatabase = BaseSQLiteDatabase<"sync" | "async", unknown>;
 
-/**
- * SQL Dialect Abstraction Layer
- *
- * Provides a unified interface for dialect-specific SQL generation.
- * Implementing a new dialect (MySQL, SQL Server, etc.) requires
- * implementing this interface.
- */
-
-/**
- * Supported SQL dialects.
- */
-type SqlDialect = "sqlite" | "postgres";
-
 /**
  * Backend interface types for TypeGraph storage.
  *
@@ -618,16 +797,6 @@ type FulltextCapabilities = Readonly<{
  * Backend capabilities that vary by dialect.
  */
 type BackendCapabilities = Readonly<{
-    /** Whether the backend supports JSONB type (vs TEXT for JSON) */
-    jsonb: boolean;
-    /** Whether the backend supports partial indexes */
-    partialIndexes: boolean;
-    /** Whether the backend supports GIN indexes for JSON */
-    ginIndexes: boolean;
-    /** Whether the backend supports CTE (WITH) queries */
-    cte: boolean;
-    /** Whether the backend supports RETURNING clause */
-    returning: boolean;
     /** Whether the backend supports atomic transactions (D1 does not) */
     transactions: boolean;
     /** Vector search capabilities (undefined if not configured) */
@@ -691,19 +860,6 @@ type SchemaVersionRow = Readonly<{
     created_at: string;
     is_active: boolean;
 }>;
-/**
- * A row from the typegraph_node_embeddings table.
- */
-type EmbeddingRow = Readonly<{
-    graph_id: string;
-    node_kind: string;
-    node_id: string;
-    field_path: string;
-    embedding: readonly number[];
-    dimensions: number;
-    created_at: string;
-    updated_at: string;
-}>;
 /**
  * Parameters for inserting a node.
  */
@@ -785,6 +941,14 @@ type HardDeleteEdgeParams = Readonly<{
 }>;
 /**
  * Parameters for inserting or updating an embedding.
+ *
+ * `dimensions`, `metric`, and `indexType` together resolve the slot's
+ * typed per-`(nodeKind, fieldPath)` storage (the strategy needs the fixed
+ * dimension for the column type, and the metric/index type to address the
+ * right ANN structure). The store populates them from the schema's
+ * `embedding()` declaration via `getEmbeddingDimensions()` /
+ * `getEmbeddingIndex()`; the backend constructs a `VectorSlot` from them
+ * and stays graph-agnostic.
  */
 type UpsertEmbeddingParams = Readonly<{
     graphId: string;
@@ -793,15 +957,29 @@ type UpsertEmbeddingParams = Readonly<{
     fieldPath: string;
     embedding: readonly number[];
     dimensions: number;
+    metric: VectorMetric;
+    indexType: VectorIndexType;
 }>;
 /**
  * Parameters for deleting an embedding.
+ *
+ * `dimensions` / `metric` / `indexType` mirror {@link UpsertEmbeddingParams}
+ * so the backend can resolve the slot's typed per-`(nodeKind, fieldPath)`
+ * storage and idempotently ensure it exists before the DELETE. That
+ * matters because a delete can run before any embedding was ever written
+ * (e.g. a node hard-deleted having never carried one), and on Postgres a
+ * DELETE against a missing relation inside a transaction aborts the whole
+ * transaction. The store populates them from the schema's `embedding()`
+ * declaration, exactly as for upserts.
  */
 type DeleteEmbeddingParams = Readonly<{
     graphId: string;
     nodeKind: string;
     nodeId: string;
     fieldPath: string;
+    dimensions: number;
+    metric: VectorMetric;
+    indexType: VectorIndexType;
 }>;
 /**
  * Parameters for vector similarity search.
@@ -812,6 +990,19 @@ type VectorSearchParams = Readonly<{
     fieldPath: string;
     queryEmbedding: readonly number[];
     metric: VectorMetric;
+    /**
+     * Fixed vector dimension `N` for the searched `(nodeKind, fieldPath)`
+     * slot. The store populates it from the schema's `embedding()`
+     * declaration via `getEmbeddingDimensions()`; the backend uses it to
+     * construct the `VectorSlot` whose typed storage the strategy scans.
+     */
+    dimensions: number;
+    /**
+     * Index type materialized for this slot. `"none"` means brute-force
+     * only; otherwise the strategy may route through its ANN structure.
+     * The store populates it from `getEmbeddingIndex()`.
+     */
+    indexType: VectorIndexType;
     limit: number;
     minScore?: number;
     /**
@@ -1170,6 +1361,16 @@ type GraphBackend = Readonly<{
      * When absent, the dialect's default strategy is used.
      */
     fulltextStrategy?: FulltextStrategy | undefined;
+    /**
+     * Optional vector strategy this backend is wired with. The query
+     * compiler reads it (via `compileQuery` options) to emit per-`(kind,
+     * field)` relevance scans for `field.similarTo(...)` predicates, and
+     * the index-materialization / removal paths read its deterministic
+     * `tableName(...)` to address the right physical per-field storage.
+     * `undefined` when the backend has no vector support (e.g. a generic
+     * SQLite backend without sqlite-vec).
+     */
+    vectorStrategy?: VectorStrategy | undefined;
     insertNode: (params: InsertNodeParams) => Promise<NodeRow>;
     insertNodeNoReturn?: (params: InsertNodeParams) => Promise<void>;
     insertNodesBatch?: (params: readonly InsertNodeParams[]) => Promise<void>;
@@ -1234,7 +1435,6 @@ type GraphBackend = Readonly<{
     setActiveVersion: (params: SetActiveVersionParams) => Promise<void>;
     upsertEmbedding?: (params: UpsertEmbeddingParams) => Promise<void>;
     deleteEmbedding?: (params: DeleteEmbeddingParams) => Promise<void>;
-    getEmbedding?: (graphId: string, nodeKind: string, nodeId: string, fieldPath: string) => Promise<EmbeddingRow | undefined>;
     vectorSearch?: (params: VectorSearchParams) => Promise<readonly VectorSearchResult[]>;
     createVectorIndex?: (params: CreateVectorIndexParams) => Promise<void>;
     dropVectorIndex?: (params: DropVectorIndexParams) => Promise<void>;
@@ -1879,8 +2079,12 @@ type VectorSimilarityPredicate = Readonly<{
     field: FieldRef;
     /** The query embedding to compare against */
     queryEmbedding: readonly number[];
-    /** Similarity metric to use */
-    metric: VectorMetricType;
+    /**
+     * Similarity metric. Omitted when the caller didn't pass one — the compiler
+     * then uses the field's DECLARED `embedding()` metric (resolved per kind),
+     * falling back to "cosine" only when no declaration is available.
+     */
+    metric?: VectorMetricType;
     /** Maximum number of results to return */
     limit: number;
     /** Optional minimum similarity score (0-1 for cosine) */
@@ -2398,4 +2602,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 FulltextCapabilities as $, type AnySqliteDatabase as A, type BackendCapabilities as B, type VectorIndexParams as C, type SchemaVersionRow as D, type EdgeIndexConfig as E, type FulltextStrategy as F, type GraphBackend as G, type InferenceType as H, type IndexDeclaration as I, type JsonPointer as J, type AggregateExpr as K, type FieldRef as L, type MetaEdge as M, type NodeIndexConfig as N, type OntologyRelation as O, type ComparisonOp as P, type QueryAst as Q, type RelationalIndexDeclaration as R, type SqliteExecutionProfileHints as S, type AggregateComparisonPredicate as T, type AdoptedTransaction as U, type VectorIndexDeclaration as V, type CommitSchemaVersionExpected as W, type CommitSchemaVersionParams as X, DEFAULT_SQL_SCHEMA as Y, type DeleteFulltextBatchParams as Z, type FulltextBatchRow as _, type SqliteTransactionMode as a, type FulltextQueryMode as a0, type FulltextSearchParams as a1, type FulltextSearchResult as a2, type HybridFusionOptions as a3, type JsonPointerFor as a4, type JsonPointerInput as a5, type JsonPointerSegment as a6, type JsonPointerSegments as a7, type JsonPointerSegmentsFor as a8, MAX_JSON_POINTER_DEPTH as a9, type Traversal as aA, type NodePredicate as aB, type ProjectedField as aC, type GroupBySpec as aD, type RecursiveCyclePolicy as aE, type TraversalDirection as aF, type EdgeRow as aG, type NodeRow as aH, type SelectiveField as aI, type ComposableQuery as aJ, type SetOperationType as aK, type SetOperation as aL, type VectorMetric as aM, type MetaEdgeProperties as aa, type OrderSpec as ab, type ParameterRef as ac, type ResolveJsonPointer as ad, type ResolveJsonPointerSegments as ae, type SetActiveVersionParams as af, type SortDirection as ag, type SqlSchema as ah, type SqlTableNames as ai, type StrategyTableContribution as aj, type TableContribution as ak, type TransactionBackend as al, type TraversalExpansion as am, type UpsertFulltextBatchParams as an, type VectorCapabilities as ao, createSqlSchema as ap, fts5Strategy as aq, isMetaEdge as ar, joinJsonPointers as as, jsonPointer as at, normalizeJsonPointer as au, parseJsonPointer as av, tsvectorStrategy as aw, type ValueType as ax, type PredicateExpression as ay, type VectorMetricType as az, type AnyPgDatabase as b, type EdgeIndexDeclaration as c, type NodeIndexDeclaration as d, type IndexWhereExpression as e, type SerializedNodeDef as f, type SerializedEdgeDef as g, type SerializedMetaEdge as h, type SerializedOntologyRelation as i, type SerializedClosures as j, type SerializedSchema as k, type SchemaHash as l, type JsonSchema as m, type SerializedOntology as n, type SerializedUniqueConstraint as o, type SqlDialect as p, type EdgeIndexDirection as q, type EdgeIndexWhereBuilder as r, type IndexOrigin as s, type IndexScope as t, type IndexWhereFieldBuilder as u, type IndexWhereInput as v, type NodeIndexWhereBuilder as w, type SystemColumnName as x, type VectorIndexImplementation as y, type VectorIndexMetric as z };
+export { type FulltextBatchRow as $, type AnySqliteDatabase as A, type BackendCapabilities as B, type VectorIndexMetric as C, type VectorIndexParams as D, type EdgeIndexConfig as E, type FulltextStrategy as F, type GraphBackend as G, type SchemaVersionRow as H, type IndexDeclaration as I, type JsonPointer as J, type InferenceType as K, type AggregateExpr as L, type MetaEdge as M, type NodeIndexConfig as N, type OntologyRelation as O, type FieldRef as P, type QueryAst as Q, type RelationalIndexDeclaration as R, type SqliteExecutionProfileHints as S, type ComparisonOp as T, type AggregateComparisonPredicate as U, type VectorStrategy as V, type AdoptedTransaction as W, type CommitSchemaVersionExpected as X, type CommitSchemaVersionParams as Y, DEFAULT_SQL_SCHEMA as Z, type DeleteFulltextBatchParams as _, type SqliteTransactionMode as a, type FulltextCapabilities as a0, type FulltextQueryMode as a1, type FulltextSearchParams as a2, type FulltextSearchResult as a3, type HybridFusionOptions as a4, type JsonPointerFor as a5, type JsonPointerInput as a6, type JsonPointerSegment as a7, type JsonPointerSegments as a8, type JsonPointerSegmentsFor as a9, type VectorSlotMap as aA, type ValueType as aB, type PredicateExpression as aC, type VectorMetricType as aD, type Traversal as aE, type NodePredicate as aF, type ProjectedField as aG, type GroupBySpec as aH, type RecursiveCyclePolicy as aI, type TraversalDirection as aJ, type EdgeRow as aK, type NodeRow as aL, type SelectiveField as aM, type ComposableQuery as aN, type SetOperationType as aO, type SetOperation as aP, type VectorMetric as aQ, MAX_JSON_POINTER_DEPTH as aa, type MetaEdgeProperties as ab, type OrderSpec as ac, type ParameterRef as ad, type ResolveJsonPointer as ae, type ResolveJsonPointerSegments as af, type SetActiveVersionParams as ag, type SortDirection as ah, type SqlSchema as ai, type SqlTableNames as aj, type StrategyTableContribution as ak, type TableContribution as al, type TransactionBackend as am, type TraversalExpansion as an, type UpsertFulltextBatchParams as ao, type VectorCapabilities as ap, type VectorSlot as aq, buildVectorCapabilities as ar, createSqlSchema as as, fts5Strategy as at, isMetaEdge as au, joinJsonPointers as av, jsonPointer as aw, normalizeJsonPointer as ax, parseJsonPointer as ay, tsvectorStrategy as az, type AnyPgDatabase as b, type EdgeIndexDeclaration as c, type NodeIndexDeclaration as d, type IndexWhereExpression as e, type SerializedNodeDef as f, type SerializedEdgeDef as g, type SerializedMetaEdge as h, type SerializedOntologyRelation as i, type SerializedClosures as j, type SerializedSchema as k, type SchemaHash as l, type JsonSchema as m, type SerializedOntology as n, type SerializedUniqueConstraint as o, type SqlDialect as p, type EdgeIndexDirection as q, type EdgeIndexWhereBuilder as r, type IndexOrigin as s, type IndexScope as t, type IndexWhereFieldBuilder as u, type IndexWhereInput as v, type NodeIndexWhereBuilder as w, type SystemColumnName as x, type VectorIndexDeclaration as y, type VectorIndexImplementation as z };

package/dist/{where-5zf15aFZ.d.cts → where-2dsyYt3d.d.cts}

@@ -1,5 +1,5 @@
-import { A as AnyEdgeType, N as NodeType } from './extension-types-B78CZfA5.cjs';
-import { E as EdgeIndexConfig, c as EdgeIndexDeclaration, N as NodeIndexConfig, d as NodeIndexDeclaration, e as IndexWhereExpression } from './types-CMQymcwk.cjs';
+import { A as AnyEdgeType, N as NodeType } from './extension-types-CwHV-Uk4.cjs';
+import { E as EdgeIndexConfig, c as EdgeIndexDeclaration, N as NodeIndexConfig, d as NodeIndexDeclaration, e as IndexWhereExpression } from './types-DXCSyxac.cjs';
 
 declare function defineNodeIndex<N extends NodeType>(node: N, config: NodeIndexConfig<N>): NodeIndexDeclaration;
 declare function defineEdgeIndex<E extends AnyEdgeType>(edge: E, config: EdgeIndexConfig<E>): EdgeIndexDeclaration;

package/dist/{where-CtrLu1Zf.d.ts → where-CP4qGIHd.d.ts}

@@ -1,5 +1,5 @@
-import { A as AnyEdgeType, N as NodeType } from './extension-types-B78CZfA5.js';
-import { E as EdgeIndexConfig, c as EdgeIndexDeclaration, N as NodeIndexConfig, d as NodeIndexDeclaration, e as IndexWhereExpression } from './types-CQ7xXJMP.js';
+import { A as AnyEdgeType, N as NodeType } from './extension-types-CwHV-Uk4.js';
+import { E as EdgeIndexConfig, c as EdgeIndexDeclaration, N as NodeIndexConfig, d as NodeIndexDeclaration, e as IndexWhereExpression } from './types-CmAT-Z47.js';
 
 declare function defineNodeIndex<N extends NodeType>(node: N, config: NodeIndexConfig<N>): NodeIndexDeclaration;
 declare function defineEdgeIndex<E extends AnyEdgeType>(edge: E, config: EdgeIndexConfig<E>): EdgeIndexDeclaration;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nicia-ai/typegraph",
-  "version": "0.28.0",
+  "version": "0.29.0",
   "description": "TypeScript-first embedded knowledge graph library with ontological reasoning",
   "type": "module",
   "main": "./dist/index.cjs",
@@ -47,6 +47,11 @@
       "import": "./dist/backend/postgres/index.js",
       "require": "./dist/backend/postgres/index.cjs"
     },
+    "./postgres/pglite": {
+      "types": "./dist/backend/postgres/pglite.d.ts",
+      "import": "./dist/backend/postgres/pglite.js",
+      "require": "./dist/backend/postgres/pglite.cjs"
+    },
     "./sqlite/local": {
       "types": "./dist/backend/sqlite/local.d.ts",
       "import": "./dist/backend/sqlite/local.js",
@@ -92,6 +97,8 @@
     "node": ">=22"
   },
   "peerDependencies": {
+    "@electric-sql/pglite": ">=0.5.0 <0.6.0",
+    "@electric-sql/pglite-pgvector": ">=0.0.2 <1.0.0",
     "@libsql/client": ">=0.6.0",
     "@neondatabase/serverless": ">=0.9.0 <2.0.0",
     "better-sqlite3": ">=9.0.0 <13.0.0",
@@ -101,6 +108,12 @@
     "zod": "^4.0.0"
   },
   "peerDependenciesMeta": {
+    "@electric-sql/pglite": {
+      "optional": true
+    },
+    "@electric-sql/pglite-pgvector": {
+      "optional": true
+    },
     "@libsql/client": {
       "optional": true
     },
@@ -121,7 +134,9 @@
     "nanoid": "^5.1.11"
   },
   "devDependencies": {
-    "@cloudflare/vitest-pool-workers": "^0.16.7",
+    "@cloudflare/vitest-pool-workers": "^0.16.12",
+    "@electric-sql/pglite": "^0.5.1",
+    "@electric-sql/pglite-pgvector": "^0.0.2",
     "@libsql/client": "^0.17.3",
     "@neondatabase/serverless": "^1.1.0",
     "@stryker-mutator/core": "^9.6.1",
@@ -129,10 +144,10 @@
     "@types/better-sqlite3": "^7.6.13",
     "@types/node": "^24.12.0",
     "@types/pg": "^8.20.0",
-    "@vitest/coverage-v8": "^4.1.7",
+    "@vitest/coverage-v8": "^4.1.8",
     "better-sqlite3": "^12.10.0",
     "drizzle-orm": "^0.45.2",
-    "eslint": "^10.4.0",
+    "eslint": "^10.4.1",
     "fast-check": "^4.8.0",
     "pg": "^8.21.0",
     "postgres": "^3.4.9",
@@ -140,7 +155,7 @@
     "tsd": "^0.33.0",
     "tsup": "^8.5.1",
     "typescript": "^5.9.3",
-    "vitest": "^4.1.7",
+    "vitest": "^4.1.8",
     "zod": "^4.4.3",
     "@typegraph/eslint-config": "0.1.0"
   },