@nicia-ai/typegraph 0.25.1 → 0.27.0

package/dist/{types-WF5ItKQu.d.cts → types-Dzkr0Eqi.d.ts}

@@ -1,6 +1,8 @@
 import { z } from 'zod';
-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-D07e_NTw.cjs';
+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 { SQL } from 'drizzle-orm';
+import { PgDatabase, PgQueryResultHKT } from 'drizzle-orm/pg-core';
+import { BaseSQLiteDatabase } from 'drizzle-orm/sqlite-core';
 
 /** Brand key for MetaEdge */
 declare const META_EDGE_BRAND: "__metaEdge";
@@ -170,6 +172,64 @@ declare function createSqlSchema(names?: Partial<SqlTableNames>): SqlSchema;
  */
 declare const DEFAULT_SQL_SCHEMA: SqlSchema;
 
+/**
+ * A single table TypeGraph owns.
+ */
+type TableContribution = Readonly<{
+    /**
+     * Stable, graph- and deployment-independent identity for the logical
+     * slot this contribution fills (e.g. `"fulltext"`). NOT the physical
+     * table name. Stable across table-name overrides and across strategy
+     * swaps of the *same* logical slot, so #135's durable marker can
+     * survive both.
+     */
+    logicalName: string;
+    /**
+     * Identifies the producer of this contribution (e.g. a strategy id
+     * like `"tsvector"` / `"fts5"`, or `"base"` for core schema tables).
+     * Part of the #135 materialization identity and an input to the
+     * drift signature — a strategy swap on the same `logicalName` is a
+     * legitimate, detectable drift, not a silent reuse.
+     */
+    owner: string;
+    /**
+     * Resolved physical table name after any per-deployment name
+     * override. Part of the #135 materialization identity (custom names
+     * must be distinguishable) and used by diagnostics / the focused
+     * bootstrap ensure.
+     */
+    tableName: string;
+    /**
+     * Idempotent (`CREATE ... IF NOT EXISTS`) statements that
+     * materialize this contribution's table **and its supporting
+     * indexes**. Running the full list is how the runtime ensure
+     * self-heals partial states (table present, index missing) — it is
+     * not a probe-and-skip. Deterministic for a given resolved
+     * configuration: the canonical normalized input to #135's drift
+     * signature.
+     */
+    createDdl: readonly string[];
+    /**
+     * When `true`, the post-schema-load focused ensure
+     * (`loadActiveSchemaWithBootstrap`) materializes this contribution
+     * on every successful schema load.
+     *
+     * **Invariant: only strategy-declared contributions may set this.**
+     * Core/base tables are always `false` — they are created by
+     * drizzle-kit / `bootstrapTables`. This is what lets the boot path
+     * derive runtime contributions straight from the strategy
+     * (`fulltextStrategy.ownedTables`) without walking — and generating
+     * DDL for — every base table.
+     */
+    runtimeEnsure: boolean;
+}>;
+/**
+ * A table a {@link FulltextStrategy} declares it owns. An alias, not a
+ * distinct shape: a strategy's declaration is already authoritative
+ * (no resolution step). The name documents the producer role.
+ */
+type StrategyTableContribution = TableContribution;
+
 /**
  * Fulltext Strategy — pluggable DDL + SQL generation for a dialect's
  * fulltext stack. A strategy owns every SQL statement that touches its
@@ -245,11 +305,20 @@ interface FulltextStrategy {
      */
     snippetExpression(tableName: string, query: string, mode: FulltextQueryMode, language?: string): SQL;
     /**
-     * DDL statements to create the backing table and any supporting
-     * indexes. Idempotent (`CREATE ... IF NOT EXISTS`). Called once from
-     * `bootstrapTables()` on a fresh database.
+     * The tables this strategy owns, as Drizzle-free, already
+     * authoritative `TableContribution`s (`logicalName`, `owner`,
+     * resolved `tableName`, idempotent `createDdl` for the table **and
+     * its supporting indexes**, `runtimeEnsure`). A strategy never
+     * constructs a Drizzle table itself; drizzle-kit visibility, when
+     * applicable, is the schema barrel's responsibility (the default
+     * Postgres strategy's `schema/postgres.ts` exports a matching
+     * `tables.fulltext` — a non-default strategy must export its own).
+     *
+     * Replaces the former `generateDdl(tableName)`: DDL is now one field
+     * of a contribution rather than the strategy's whole storage
+     * surface. (Public API change — see #129.)
      */
-    generateDdl(tableName: string): readonly string[];
+    ownedTables(primaryTableName: string): readonly StrategyTableContribution[];
     /**
      * Emits the statements that upsert a single fulltext row. Returns one
      * or more statements — some backends (SQLite FTS5) cannot emulate
@@ -445,6 +514,33 @@ type SerializedSchema = Readonly<{
  */
 type SchemaHash = string;
 
+type AnyPgDatabase = PgDatabase<PgQueryResultHKT, Record<string, unknown>>;
+
+/**
+ * Controls how the backend manages SQLite transactions.
+ *
+ * - `"sql"`:     TypeGraph issues BEGIN / COMMIT / ROLLBACK SQL directly.
+ *                Default for sync drivers (better-sqlite3, bun:sqlite).
+ * - `"drizzle"`: Delegates to Drizzle's `db.transaction()` method.
+ *                Default for async drivers (libsql, sql.js).
+ * - `"do-sqlite"`: Delegates to the Cloudflare Durable Objects async
+ *                storage transaction runner (`db.$client.transaction`,
+ *                i.e. `ctx.storage.transaction(async ...)`). Drizzle's
+ *                own `db.transaction()` on DO is
+ *                `ctx.storage.transactionSync` and cannot span `await`,
+ *                so it is deliberately not used. Auto-detected for
+ *                `drizzle(ctx.storage)` (#140).
+ * - `"none"`:    Transactions disabled. Default for Cloudflare D1
+ *                (`D1Database.batch` is transactional but not an
+ *                interactive runner — tracked separately).
+ */
+type SqliteTransactionMode = "sql" | "drizzle" | "none" | "do-sqlite";
+type SqliteExecutionProfileHints = Readonly<{
+    isSync?: boolean;
+    transactionMode?: SqliteTransactionMode;
+}>;
+type AnySqliteDatabase = BaseSQLiteDatabase<"sync" | "async", unknown>;
+
 /**
  * SQL Dialect Abstraction Layer
  *
@@ -914,6 +1010,63 @@ type RecordIndexMaterializationParams = Readonly<{
     /** Error message on failure; undefined on success (clears existing). */
     error: string | undefined;
 }>;
+/**
+ * Durable identity of a strategy-owned table contribution (#129),
+ * scoped to a graph. This is the primary key of
+ * `typegraph_contribution_materializations`.
+ *
+ * `logicalName` is the stable slot ("fulltext"); `owner` is the
+ * producing strategy ("tsvector" / "fts5"); `tableName` is the resolved
+ * physical name (custom per-deployment names must be distinguishable).
+ * `graphId` is part of identity here — unlike the index status table
+ * where the physical index name is database-global, two graphs can each
+ * own a logically-identical fulltext contribution.
+ */
+type ContributionMaterializationIdentity = Readonly<{
+    graphId: string;
+    logicalName: string;
+    owner: string;
+    tableName: string;
+}>;
+/**
+ * Per-deployment record that a strategy-owned contribution has been
+ * durably materialized against this database.
+ *
+ * `signature` is intentionally NOT part of the identity: a row with the
+ * same identity but a different signature means "materialized artifact
+ * is stale/drifted" — a loud error on the hot path, never a silent
+ * re-materialize. `materializedAt` is undefined until the first
+ * successful materialization; `lastAttemptedAt` is always set.
+ */
+type ContributionMaterializationRow = Readonly<{
+    graphId: string;
+    logicalName: string;
+    owner: string;
+    tableName: string;
+    signature: string;
+    materializedAt: string | undefined;
+    lastAttemptedAt: string;
+    lastError: string | undefined;
+}>;
+/**
+ * Parameters for upserting a contribution-materialization attempt.
+ * Same success/failure contract as
+ * {@link RecordIndexMaterializationParams}: on failure pass undefined
+ * `materializedAt` so a prior successful timestamp is preserved via
+ * COALESCE, and the error message.
+ */
+type RecordContributionMaterializationParams = Readonly<{
+    graphId: string;
+    logicalName: string;
+    owner: string;
+    tableName: string;
+    signature: string;
+    attemptedAt: string;
+    /** ISO timestamp on success; undefined on failure (preserves existing). */
+    materializedAt: string | undefined;
+    /** Error message on failure; undefined on success (clears existing). */
+    error: string | undefined;
+}>;
 /**
  * One row of the per-deployment `typegraph_kind_removals` table:
  * a graph-extension kind that has been removed from the schema and whose
@@ -955,6 +1108,21 @@ type TransactionOptions = Readonly<{
     /** Transaction isolation level (if supported) */
     isolationLevel?: "read_uncommitted" | "read_committed" | "repeatable_read" | "serializable";
 }>;
+/**
+ * A caller-owned, already-open Drizzle transaction handle that a
+ * TypeGraph store can adopt so both layers commit/rollback together.
+ *
+ * The literal client the caller's transaction runs on — a `PgDatabase`
+ * transaction (node-postgres / `neon-serverless` Pool) or a
+ * `BaseSQLiteDatabase` connection. Async drivers obtain it from
+ * `db.transaction(async (tx) => …)`; synchronous `better-sqlite3` (whose
+ * driver rejects an `async` transaction callback) passes the connection
+ * itself under an explicit `BEGIN`/`COMMIT`/`ROLLBACK`. Passing it to
+ * {@link GraphBackend.adoptTransaction} threads that *literal* client
+ * through TypeGraph's SQL, so graph writes and the caller's own
+ * relational writes share one Postgres/SQLite transaction (#134).
+ */
+type AdoptedTransaction = AnyPgDatabase | AnySqliteDatabase;
 /**
  * Transaction backend — a backend scoped to a transaction.
  *
@@ -968,7 +1136,7 @@ type TransactionOptions = Readonly<{
  * exists to eliminate. Schema commits go through the top-level backend
  * methods only.
  */
-type TransactionBackend = Omit<GraphBackend, "transaction" | "close" | "refreshStatistics" | "commitSchemaVersion" | "setActiveVersion">;
+type TransactionBackend = Omit<GraphBackend, "transaction" | "adoptTransaction" | "close" | "refreshStatistics" | "commitSchemaVersion" | "setActiveVersion">;
 /**
  * The GraphBackend interface abstracts database operations.
  *
@@ -1107,6 +1275,40 @@ type GraphBackend = Readonly<{
      * timestamp survives across error windows.
      */
     recordIndexMaterialization?: (params: RecordIndexMaterializationParams) => Promise<void>;
+    /**
+     * Idempotently ensure ONLY the
+     * `typegraph_contribution_materializations` table exists. Same
+     * focused-bootstrap rationale as `ensureIndexMaterializationsTable`:
+     * a single `CREATE TABLE IF NOT EXISTS` is concurrency-safe under
+     * replica startup, where the full `bootstrapTables` set risks a
+     * Postgres SHARE-lock deadlock.
+     */
+    ensureContributionMaterializationsTable?: () => Promise<void>;
+    /**
+     * Look up the durable materialization marker for one strategy-owned
+     * contribution identity. Returns `undefined` when no row exists
+     * ("never initialized").
+     */
+    getContributionMaterialization?: (identity: ContributionMaterializationIdentity) => Promise<ContributionMaterializationRow | undefined>;
+    /**
+     * Upsert a contribution-materialization attempt — success or failure.
+     * Failure rows preserve any prior `materializedAt` via COALESCE so a
+     * later failed re-attempt doesn't erase the historical success.
+     */
+    recordContributionMaterialization?: (params: RecordContributionMaterializationParams) => Promise<void>;
+    /**
+     * Resolve (once per backend instance, cached) and assert the durable
+     * materialization markers for every `runtimeEnsure` contribution this
+     * backend's strategy declares, for `graphId`. Throws
+     * `StoreNotInitializedError` when a marker is missing, stale
+     * (signature drift), or recorded a failed last attempt.
+     *
+     * This is the single read-side gate the fulltext hot-path wrappers
+     * and `store.transaction()` consult. It performs ZERO DDL and ZERO
+     * marker writes — initialization is the exclusive job of the async
+     * boot path (`createStoreWithSchema` → `ensureRuntimeContributions`).
+     */
+    assertRuntimeContributionsInitialized?: (graphId: string) => Promise<void>;
     /**
      * Bootstraps the per-deployment `typegraph_kind_removals` table so
      * `store.removeKinds()` and `store.materializeRemovals()` can persist
@@ -1149,15 +1351,32 @@ type GraphBackend = Readonly<{
      * deadlock under concurrent replica startup.
      */
     ensureReconciliationMarkersTable?: () => Promise<void>;
+    /**
+     * Materializes every contribution flagged `runtimeEnsure` — the
+     * strategy-owned runtime tables (fulltext today) that drizzle-kit-
+     * managed setups don't create. Called once after a successful schema
+     * load. Deliberately scoped: base/drizzle-visible tables are
+     * `runtimeEnsure: false`, so this does not regress startup into
+     * broad DDL/probing across every table.
+     *
+     * The canonical durable-marker writer (#135): for each runtime
+     * contribution it short-circuits when the marker already records a
+     * matching signature, otherwise runs the idempotent `createDdl` and
+     * records the marker (success or failure) keyed by `graphId`.
+     */
+    ensureRuntimeContributions?: (graphId: string) => Promise<void>;
     /**
      * Bootstraps the fulltext storage table the active `FulltextStrategy`
-     * owns — the strategy owns this DDL because shapes diverge across
-     * stacks (`tsvector` + GIN, FTS5 virtual table, pg_trgm, …) and
-     * the SQLite case can't be Drizzle-modeled at all. Same focused-
-     * bootstrap rationale as the other `ensure*Table` methods:
-     * idempotent and concurrency-safe under replica startup.
+     * owns. Same focused-bootstrap rationale as the other `ensure*Table`
+     * methods: idempotent and concurrency-safe under replica startup.
+     *
+     * Superseded by `ensureRuntimeContributions()` (#129); retained as
+     * a thin back-compat wrapper for backends/callers predating #129. Not
+     * machine-`@deprecated` because the manager still calls it as the
+     * pre-#129 fallback. #135 removed the remaining hot-path callers and
+     * routed this through the durable-marker writer.
      */
-    ensureFulltextTable?: () => Promise<void>;
+    ensureFulltextTable?: (graphId: string) => Promise<void>;
     /**
      * Read the high-water mark schema version for which
      * `materializeRemovals` reconciliation has already verified history
@@ -1225,7 +1444,46 @@ type GraphBackend = Readonly<{
      * statement outside `transaction(...)`.
      */
     executeDdl?: (ddl: string) => Promise<void>;
-    transaction: <T>(fn: (tx: TransactionBackend) => Promise<T>, options?: TransactionOptions) => Promise<T>;
+    /**
+     * `fn` receives the tx-scoped backend and the raw Drizzle handle
+     * **bound to that same transaction** (`AdoptedTransaction`). The
+     * store surfaces the second argument as `TransactionContext.sql` so
+     * callers can write their own relational tables inside the
+     * graph-owned transaction. Implementations MUST pass the *exact*
+     * handle the tx-scoped backend writes through (the Postgres/libsql
+     * tx handle; for better-sqlite3 / do-sqlite the bound connection),
+     * never a fresh one.
+     */
+    transaction: <T>(fn: (tx: TransactionBackend, sql: AdoptedTransaction) => Promise<T>, options?: TransactionOptions) => Promise<T>;
+    /**
+     * Adopt a caller-owned, already-open transaction (#134).
+     *
+     * Returns a transaction-scoped backend bound to the *exact*
+     * `externalTx` client, reusing this backend's already-resolved
+     * schema/strategy config — no `createStoreWithSchema` / `evolve` /
+     * `migrateSchema`, and **no DDL inside the caller's business
+     * transaction**. The caller owns `BEGIN`/`COMMIT`/`ROLLBACK`; this
+     * method neither opens nor closes a transaction. Async drivers
+     * (node-postgres, `neon-serverless` Pool, libsql) wrap with
+     * `db.transaction(async …)`; synchronous `better-sqlite3` must instead
+     * issue explicit `BEGIN`/`COMMIT`/`ROLLBACK` (its driver rejects an
+     * `async` transaction callback).
+     *
+     * Optional and presence-detected like the other capability-scoped
+     * members: only the Drizzle Postgres/SQLite backends provide it.
+     * Implementations MUST throw (not silently degrade) when
+     * `capabilities.transactions` is `false` — a non-atomic fallback is
+     * safe for graph-only writes but dangerous for cross-store flows,
+     * where the caller's relational write *would* still commit.
+     *
+     * Fulltext stays safe by construction: the returned backend's
+     * fulltext methods assert the durable materialization marker (a
+     * cached SELECT, never DDL) at point of use and throw
+     * `StoreNotInitializedError` on a missing/stale/failed marker rather
+     * than migrating mid-transaction. Prefer booting the parent store via
+     * `createStoreWithSchema` so that assertion is a warm-cache no-op.
+     */
+    adoptTransaction?: (externalTx: AdoptedTransaction) => TransactionBackend;
     close: () => Promise<void>;
 }>;
 /**
@@ -2129,4 +2387,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 JsonPointerFor as $, type AggregateExpr as A, type BackendCapabilities as B, type FieldRef as C, type ComparisonOp as D, type EdgeIndexConfig as E, type FulltextStrategy as F, type GraphBackend as G, type AggregateComparisonPredicate as H, type IndexDeclaration as I, type JsonPointer as J, type CommitSchemaVersionExpected as K, type CommitSchemaVersionParams as L, type MetaEdge as M, type NodeIndexConfig as N, type OntologyRelation as O, DEFAULT_SQL_SCHEMA as P, type QueryAst as Q, type RelationalIndexDeclaration as R, type SerializedNodeDef as S, type DeleteFulltextBatchParams as T, type FulltextBatchRow as U, type VectorIndexDeclaration as V, type FulltextCapabilities as W, type FulltextQueryMode as X, type FulltextSearchParams as Y, type FulltextSearchResult as Z, type HybridFusionOptions as _, type EdgeIndexDeclaration as a, type JsonPointerInput as a0, type JsonPointerSegment as a1, type JsonPointerSegments as a2, type JsonPointerSegmentsFor as a3, MAX_JSON_POINTER_DEPTH as a4, type MetaEdgeProperties as a5, type OrderSpec as a6, type ParameterRef as a7, type ResolveJsonPointer as a8, type ResolveJsonPointerSegments as a9, type NodeRow as aA, type SelectiveField as aB, type ComposableQuery as aC, type SetOperationType as aD, type SetOperation as aE, type VectorMetric as aF, type SetActiveVersionParams as aa, type SortDirection as ab, type SqlSchema as ac, type SqlTableNames as ad, type TransactionBackend as ae, type TraversalExpansion as af, type UpsertFulltextBatchParams as ag, type VectorCapabilities as ah, createSqlSchema as ai, fts5Strategy as aj, isMetaEdge as ak, joinJsonPointers as al, jsonPointer as am, normalizeJsonPointer as an, parseJsonPointer as ao, tsvectorStrategy as ap, type ValueType as aq, type PredicateExpression as ar, type VectorMetricType as as, type Traversal as at, type NodePredicate as au, type ProjectedField as av, type GroupBySpec as aw, type RecursiveCyclePolicy as ax, type TraversalDirection as ay, type EdgeRow as az, type NodeIndexDeclaration as b, type IndexWhereExpression as c, type SerializedEdgeDef as d, type SerializedMetaEdge as e, type SerializedOntologyRelation as f, type SerializedClosures as g, type SerializedSchema as h, type SchemaHash as i, type JsonSchema as j, type SerializedOntology as k, type SerializedUniqueConstraint as l, type SqlDialect as m, type EdgeIndexDirection as n, type EdgeIndexWhereBuilder as o, type IndexOrigin as p, type IndexScope as q, type IndexWhereFieldBuilder as r, type IndexWhereInput as s, type NodeIndexWhereBuilder as t, type SystemColumnName as u, type VectorIndexImplementation as v, type VectorIndexMetric as w, type VectorIndexParams as x, type SchemaVersionRow as y, type InferenceType as z };
+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 };

package/dist/{where-DZYMiXVq.d.cts → where-BmtjfWuS.d.cts}

@@ -1,5 +1,5 @@
-import { A as AnyEdgeType, N as NodeType } from './extension-types-D07e_NTw.cjs';
-import { E as EdgeIndexConfig, a as EdgeIndexDeclaration, N as NodeIndexConfig, b as NodeIndexDeclaration, c as IndexWhereExpression } from './types-WF5ItKQu.cjs';
+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-DZPBXZOK.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-C40InMIp.d.ts → where-kk1Zz2En.d.ts}

@@ -1,5 +1,5 @@
-import { A as AnyEdgeType, N as NodeType } from './extension-types-D07e_NTw.js';
-import { E as EdgeIndexConfig, a as EdgeIndexDeclaration, N as NodeIndexConfig, b as NodeIndexDeclaration, c as IndexWhereExpression } from './types-DptZHe-l.js';
+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-Dzkr0Eqi.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.25.1",
+  "version": "0.27.0",
   "description": "TypeScript-first embedded knowledge graph library with ontological reasoning",
   "type": "module",
   "main": "./dist/index.cjs",
@@ -121,6 +121,7 @@
     "nanoid": "^5.1.11"
   },
   "devDependencies": {
+    "@cloudflare/vitest-pool-workers": "^0.16.6",
     "@libsql/client": "^0.17.3",
     "@neondatabase/serverless": "^1.1.0",
     "@stryker-mutator/core": "^9.6.1",
@@ -164,6 +165,7 @@
     "test:perf:postgres": "pnpm --filter @nicia-ai/typegraph-benchmarks perf:check:postgres",
     "bench:perf:postgres": "pnpm --filter @nicia-ai/typegraph-benchmarks perf:postgres",
     "test:postgres": "./scripts/test-postgres.sh",
+    "test:do": "vitest run --config vitest.workers.config.ts",
     "test:coverage": "vitest run --coverage",
     "test:mutation": "stryker run"
   }