@ponraaj/dimple-sdk 0.0.0-alpha.1 → 0.0.0-alpha.11

package/dist/internal/store/topics/routing.d.ts

@@ -38,7 +38,7 @@
  * transaction-aware vector methods, move the upserts onto the tx.
  */
 import { Effect } from "effect";
-import type { EmbeddingModelConfig } from "./internal/config/index.js";
+import type { EmbeddingModelConfig } from "../../config/index.js";
 import { Service as DbBackend } from "../db-backend.ts";
 import type { TopicConfig } from "../schema/topics.ts";
 import type { TopicError } from "./errors.ts";
@@ -88,3 +88,36 @@ export declare const routeInsert: (memoryId: string, vector: ReadonlyArray<numbe
     topicKey: string;
     overflow: boolean;
 }, TopicError | StoreError, DbBackend>;
+/**
+ * Batch routing — the bulk-ingest path (`Store.updateEmbeddingMany`).
+ *
+ * Sequential `routeInsert` re-reads the WHOLE tree (all topics, all
+ * relations, all centroid sum-vectors) and commits its own transaction
+ * PER UNIT — measured ~42 ms/unit under bulk ingest, dominating the
+ * write path. This variant:
+ *
+ * 1. Reads the tree structure + sum-vectors ONCE.
+ * 2. Routes every entry against an IN-MEMORY mirror of the tree state,
+ *    applying each unit's CF updates locally before the next descent —
+ *    so the descents are bit-identical to sequential routeInsert calls
+ *    against the DB (same reads, same writes, same order).
+ * 3. Applies ALL membership inserts + topic CF updates in ONE
+ *    transaction (per-topic deltas accumulated in memory).
+ * 4. Writes the derived sum vectors in ONE batched upsert (backend
+ *    `upsertTopicVectors`), still after commit (backend not
+ *    transaction-aware — see module docs).
+ *
+ * Contract differences vs sequential: all-or-nothing (a validation
+ * failure or structural corruption rejects the whole batch), and the
+ * batch does NOT handle re-embedding (no membership decrement path) —
+ * it is for NEW memories; re-embedding existing ones goes through
+ * `routeInsert`/`Store.updateEmbedding`.
+ */
+export declare const routeInsertMany: (entries: readonly {
+    readonly memoryId: string;
+    readonly vector: ReadonlyArray<number>;
+}[], model: EmbeddingModelConfig, config: TopicConfig) => Effect.Effect<readonly {
+    readonly memoryId: string;
+    readonly topicKey: string;
+    readonly overflow: boolean;
+}[], TopicError | StoreError, DbBackend>;

package/dist/internal/store/topics/topic-vectors.d.ts

@@ -4,15 +4,22 @@
  * dynamic (not Drizzle tables), so every writer goes through this raw-SQL
  * helper — one canonical place for the table name + conversion function.
  */
-import type { EmbeddingModelConfig } from "./internal/config/index.js";
+import type { EmbeddingModelConfig } from "../../config/index.js";
 import { type SQLWrapper } from "drizzle-orm";
 /** Per-model topic vector table name (mirrors libsql-backend.ts — canonical). */
 export declare const topicVectorTableName: (model: EmbeddingModelConfig) => string;
 /** vectorType → libSQL conversion function for the sum-vector column. */
-export declare const VECTOR_CONVERT_FNS: Readonly<Record<string, string>>;
-/** Anything with a `.run(sql)` — a Drizzle tx or the db handle. */
+export declare const VECTOR_CONVERT_FNS: {
+    readonly float32: "vector32";
+    readonly float16: "vector16";
+    readonly float8: "vector8";
+    readonly float1bit: "vector1bit";
+};
+/** Anything with a `.run(sql)` — a Drizzle tx or the db handle. The raw
+ * result is discarded by every caller (DELETE statements only), so the
+ * contract is fire-and-forget. */
 export interface SqlRunner {
-    readonly run: (query: string | SQLWrapper<unknown>) => unknown;
+    readonly run: (query: string | SQLWrapper<unknown>) => void;
 }
 /** Delete one topic's sum-vector row (merge absorbs the sibling's row). */
 export declare const deleteTopicVectorRow: (runner: SqlRunner, model: EmbeddingModelConfig, topicKey: string) => Promise<void>;

package/dist/internal/store/topics/tree.d.ts

@@ -91,10 +91,13 @@ export declare const canonicalOrder: (vectors: readonly Float32Array[]) => reado
  * For fewer than 2 vectors returns `{ a: 0, b: 0 }` (degenerate — callers
  * guard on counts before splitting). Never mutates input.
  */
-export declare const farthestPair: (vectors: readonly Float32Array[]) => {
-    a: number;
-    b: number;
-};
+/** The farthest-seed pair — `a` is fixed by the canonical order; `b` is
+ * the vector with the lowest dot product against `a`. */
+export interface FarthestPair {
+    readonly a: number;
+    readonly b: number;
+}
+export declare const farthestPair: (vectors: readonly Float32Array[]) => FarthestPair;
 /**
  * Assign every vector to group 0 or 1 by higher dot product against the
  * seed vectors at `seedA` / `seedB`; ties go to group 0 (smaller index).
@@ -119,11 +122,14 @@ export declare const assignNearest: (vectors: readonly Float32Array[], seedA: nu
  *
  * Never mutates inputs.
  */
-export declare const lloydRefine: (vectors: readonly Float32Array[], groups: Uint8Array, passes: number) => {
-    groups: Uint8Array;
-    leftCf: CfTriplet;
-    rightCf: CfTriplet;
-};
+/** Outcome of the Lloyd refinement — the assignment plus each group's
+ * CF triplet (the split-plan acceptance gates read these). */
+export interface LloydRefineResult {
+    readonly groups: Uint8Array;
+    readonly leftCf: CfTriplet;
+    readonly rightCf: CfTriplet;
+}
+export declare const lloydRefine: (vectors: readonly Float32Array[], groups: Uint8Array, passes: number) => LloydRefineResult;
 /** Outcome of {@link splitPlan} — accepted splits plus the acceptance gate diagnostics. */
 export interface SplitPlanResult {
     readonly accepted: boolean;

package/dist/internal/workflow/engine.d.ts

@@ -28,9 +28,9 @@
  * `Schema.Unknown` Persistable keys — see persistence.ts for why.
  */
 import { Layer } from "effect";
-import { WorkflowEngine } from "effect/unstable/workflow";
-import { Persistence as PersistenceNamespace, PersistedQueue } from "effect/unstable/persistence";
-import { SqlError as SqlErrorNamespace } from "effect/unstable/sql";
+import { WorkflowEngine } from "effect/workflow";
+import { Persistence as PersistenceNamespace, PersistedQueue } from "effect/persistence";
+import { SqlError as SqlErrorNamespace } from "effect/sql";
 type SqlError = SqlErrorNamespace.SqlError;
 /**
  * Durable WorkflowEngine layer.
@@ -40,6 +40,14 @@ type SqlError = SqlErrorNamespace.SqlError;
  * (same `Encoded` contract into `makeUnsafe`).
  */
 export declare const layerDurable: Layer.Layer<WorkflowEngine.WorkflowEngine, never, PersistedQueue.PersistedQueueFactory | PersistenceNamespace.Persistence>;
+/**
+ * Shared libSQL stack: SQL persistence + resume-queue store over one
+ * `LibsqlClient`. Provides `Persistence | PersistedQueueFactory`, dep-free.
+ *
+ * The single libSQL connection is shared by the engine's store and the
+ * resume queue — both `Persistence.layerSql` and `PersistedQueue.layerStoreSql`
+ * create their own tables in the same file.
+ */
 export declare const libsqlStack: (options: {
     readonly url: string;
 }) => Layer.Layer<PersistedQueue.PersistedQueueFactory | PersistenceNamespace.Persistence, SqlErrorNamespace.SqlError, never>;
@@ -51,4 +59,20 @@ export declare const libsqlStack: (options: {
 export declare const layerDurableLibsql: (options: {
     readonly url: string;
 }) => Layer.Layer<WorkflowEngine.WorkflowEngine, SqlError>;
+/**
+ * OpenCode-style node declarations for the two libSQL-backed layers above.
+ *
+ * The convention's single `configured` name is per-layer, and this module
+ * exposes two, so each is declared under its layer's name; the shape
+ * (`make({ name, layer })`, empty `deps` — the root wires the runtime, the
+ * registry and the store) is unchanged. Neither gets a default `node`: both
+ * require a `url`, and a node that guessed one would silently point a
+ * durable engine at the wrong database.
+ */
+export declare const libsqlStackConfigured: (options: {
+    readonly url: string;
+}) => import("../core/index.js").LayerProvider<PersistedQueue.PersistedQueueFactory | PersistenceNamespace.Persistence, SqlErrorNamespace.SqlError, undefined>;
+export declare const layerDurableLibsqlConfigured: (options: {
+    readonly url: string;
+}) => import("../core/index.js").LayerProvider<WorkflowEngine.WorkflowEngine, SqlErrorNamespace.SqlError, undefined>;
 export {};

package/dist/internal/workflow/executor.d.ts

@@ -14,10 +14,11 @@
  * resumes the awaiting workflow (facade `submit`) and persists the result.
  */
 import { Duration, Effect, Layer } from "effect";
-import { WorkflowEngine } from "effect/unstable/workflow";
-import { PersistedQueue } from "effect/unstable/persistence";
-import { type LogConfig } from "./internal/logger/index.js";
-import type { JobDefinition } from "./queue.ts";
+import { WorkflowEngine } from "effect/workflow";
+import { PersistedQueue } from "effect/persistence";
+import { type LogConfig } from "../logger/index.js";
+import { type Graph } from "../shared/effect/node.js";
+import { type JobDefinition } from "./queue.ts";
 import { Service as JobRegistry } from "./registry.ts";
 import { Service as JobRuntime } from "./runtime.ts";
 export declare const workerLayer: (defs: readonly JobDefinition.Any[], options?: {
@@ -27,7 +28,20 @@ export declare const workerLayer: (defs: readonly JobDefinition.Any[], options?:
      * [1, 100]. */
     readonly maxAttempts?: number;
     readonly logging?: LogConfig;
-}) => Layer.Layer<never, never, PersistedQueue.PersistedQueueFactory | JobRegistry | WorkflowEngine.WorkflowEngine> | Layer.Layer<import("./internal/logger/index.js").Logging, never, PersistedQueue.PersistedQueueFactory | import("effect/Scope").Scope | JobRegistry | WorkflowEngine.WorkflowEngine>;
+}) => Layer.Layer<never, never, PersistedQueue.PersistedQueueFactory | JobRegistry | WorkflowEngine.WorkflowEngine>;
+/**
+ * OpenCode-style node declaration for {@link workerLayer}.
+ *
+ * Workers need `WorkflowEngine` + `PersistedQueueFactory` (the job stack) and
+ * `JobRegistry`, and those providers are root-owned state: a package default
+ * would build a SECOND job stack and bind the worker to it, so there is no
+ * `node` export here — the caller passes them as the `deps` tuple and `make`
+ * checks that they cover the layer's requirements. The tuple elements may be
+ * any graph that provides at least the named services, and their build errors
+ * are preserved on the node. The options type is read off `workerLayer` so the
+ * declaration cannot drift from the layer it wraps.
+ */
+export declare const configured: <const RuntimeE, const RegistryE>(defs: readonly JobDefinition.Any[], options: Parameters<typeof workerLayer>[1], deps: readonly [Graph<PersistedQueue.PersistedQueueFactory | WorkflowEngine.WorkflowEngine, RuntimeE>, Graph<JobRegistry, RegistryE>]) => import("../core/index.js").LayerProvider<never, RegistryE | RuntimeE, undefined>;
 /**
  * Inline mode — run the worker in the same fiber scope as the submit.
  *
@@ -38,7 +52,7 @@ export declare const workerLayer: (defs: readonly JobDefinition.Any[], options?:
  * Requires the full stack (JobRuntime + engine + queue + registry); use
  * `workerLayer` for persistent processes instead.
  */
-export declare const inline: (def: JobDefinition.Any, payload: unknown, options?: {
+export declare const inline: <P>(def: JobDefinition.Any, payload: P, options?: {
     readonly concurrency?: number;
     readonly maxAttempts?: number;
 }) => Effect.Effect<unknown, unknown, WorkflowEngine.WorkflowEngine | PersistedQueue.PersistedQueueFactory | JobRegistry | JobRuntime>;

package/dist/internal/workflow/index.d.ts

@@ -4,10 +4,10 @@
  * Barrel: named exports with aliases (project convention).
  */
 export { JobDefinition, Envelope, TopicSplit, MemoryEmbed, TopicMerge, TopicRebalance, ConceptCluster, MemoryDream, GraphRepair, AuditWrite, type AuditRow, queues, type EnvelopeSchema, } from "./queue.ts";
-export { Service as JobRuntime, layer as jobRuntimeLayer, type Interface as JobRuntimeInterface, type JobStatus, } from "./runtime.ts";
-export { layerDurable, layerDurableLibsql } from "./engine.ts";
-export { Service as JobRegistry, layer as jobRegistryLayer, JobFailure, type Handler, type JobContext, } from "./registry.ts";
-export { workerLayer, inline, processQueues } from "./executor.ts";
+export { Service as JobRuntime, layer as jobRuntimeLayer, configured as jobRuntimeConfigured, node as jobRuntimeNode, type Interface as JobRuntimeInterface, type JobStatus, } from "./runtime.ts";
+export { layerDurable, layerDurableLibsql, libsqlStackConfigured, layerDurableLibsqlConfigured, } from "./engine.ts";
+export { Service as JobRegistry, layer as jobRegistryLayer, configured as jobRegistryConfigured, node as jobRegistryNode, JobFailure, type Handler, type JobContext, } from "./registry.ts";
+export { workerLayer, configured as workersConfigured, inline, processQueues } from "./executor.ts";
 export { JobsConfig, JobsConfigDefaults, resolveJobsConfig } from "./config.ts";
 export { QueueError, UnknownJobType, RegistryError, ShutdownError, JobFailed, JobTimeout, JobCancelled, type JobRuntimeError, type JobsError, } from "./errors.ts";
 export { STORE_ID, RESUME_QUEUE, ResumeSignal, ExecutionRecord, encodedKey, resultCodecFor, payloadCodecFor, } from "./persistence.ts";

package/dist/internal/workflow/persistence.d.ts

@@ -32,9 +32,9 @@
  *
  */
 import { Effect, Exit, Option, Schema } from "effect";
-import { Persistable, Persistence as PersistenceNamespace } from "effect/unstable/persistence";
+import { Persistable, Persistence as PersistenceNamespace } from "effect/persistence";
 type PersistenceStore = PersistenceNamespace.PersistenceStore;
-import { Workflow } from "effect/unstable/workflow";
+import { Workflow } from "effect/workflow";
 /** Single store id shared by engine + facade (one table partition in jobs.db). */
 export declare const STORE_ID = "dimple/jobs";
 /**
@@ -56,7 +56,7 @@ export interface ResumeSignal extends Schema.Schema.Type<typeof ResumeSignal> {
  */
 export declare const ExecutionRecord: Schema.Struct<{
     readonly workflowTag: Schema.String;
-    readonly payload: Schema.$Record<Schema.String, Schema.Unknown>;
+    readonly payload: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
 }>;
 export interface ExecutionRecord extends Schema.Schema.Type<typeof ExecutionRecord> {
 }

package/dist/internal/workflow/queue.d.ts

@@ -30,8 +30,8 @@
  *
  */
 import { Effect, Schema, Scope } from "effect";
-import { DurableQueue, Workflow, WorkflowEngine } from "effect/unstable/workflow";
-import { PersistedQueue } from "effect/unstable/persistence";
+import { DurableQueue, Workflow, WorkflowEngine } from "effect/workflow";
+import { PersistedQueue } from "effect/persistence";
 /**
  * Envelope schema factory — wraps a job's payload schema with the runtime
  * fields the workflow machinery needs.
@@ -75,8 +75,11 @@ export declare class JobDefinition<Payload extends Workflow.AnyStructSchema = Wo
     /**
      * Decodes an envelope back to `{ payload }`. Built in `make` where the
      * schema types are concrete; the erased `Any` form widens the result.
+     * The engine delivers the workflow payload per its `register` contract
+     * (the decoded envelope type); the runtime decode below re-validates it
+     * against the envelope schema before the payload reaches the queue.
      */
-    readonly decodeEnvelope: (envelope: unknown) => Effect.Effect<{
+    readonly decodeEnvelope: (envelope: EnvelopeSchema<Payload>["Type"]) => Effect.Effect<{
         readonly payload: Payload["Type"];
     }, never, Payload["DecodingServices"] | Payload["EncodingServices"]>;
     constructor(args: {
@@ -87,7 +90,7 @@ export declare class JobDefinition<Payload extends Workflow.AnyStructSchema = Wo
         readonly successSchema: Success;
         readonly errorSchema: Error;
         readonly idempotencyKey: (payload: Payload["Type"]) => string;
-        readonly decodeEnvelope: (envelope: unknown) => Effect.Effect<{
+        readonly decodeEnvelope: (envelope: EnvelopeSchema<Payload>["Type"]) => Effect.Effect<{
             readonly payload: Payload["Type"];
         }, never, Payload["DecodingServices"] | Payload["EncodingServices"]>;
     });
@@ -145,7 +148,7 @@ export declare namespace JobDefinition {
         readonly successSchema: Schema.Top;
         readonly errorSchema: Schema.Top;
         readonly idempotencyKey: (payload: any) => string;
-        readonly decodeEnvelope: (envelope: unknown) => Effect.Effect<{
+        readonly decodeEnvelope: (envelope: any) => Effect.Effect<{
             readonly payload: unknown;
         }, never, unknown>;
         readonly register: (engine: WorkflowEngine.WorkflowEngine["Service"]) => Effect.Effect<void, never, Scope.Scope | PersistedQueue.PersistedQueueFactory>;

package/dist/internal/workflow/registry.d.ts

@@ -29,7 +29,7 @@ export interface JobContext {
  * decoded payload and returns the job's success value (or fails with
  * `JobFailure`); the runtime owns retries/leases.
  */
-export type Handler = (payload: unknown, ctx: JobContext) => Effect.Effect<unknown, JobFailure>;
+export type Handler = (payload: any, ctx: JobContext) => Effect.Effect<unknown, JobFailure>;
 /**
  * JobRegistry service contract.
  *
@@ -54,4 +54,14 @@ export declare class Service extends Service_base {
  * unknown resolve fails with `UnknownJobType`.
  */
 export declare const layer: Layer.Layer<Service, never, never>;
+/**
+ * OpenCode-style node declaration for the {@link layer} job registry.
+ *
+ * `deps` is empty: the registry is dependency-free by construction (handlers
+ * are registered by the composition root, which owns the runtime and the
+ * store they need).
+ */
+export declare const configured: () => import("../core/index.js").LayerProvider<Service, never, undefined>;
+/** The default registry node — the one the app graph always wires. */
+export declare const node: import("../core/index.js").LayerProvider<Service, never, undefined>;
 export {};

package/dist/internal/workflow/runtime.d.ts

@@ -51,10 +51,10 @@
  *
  */
 import { Context, Duration, Effect, Layer, Schema } from "effect";
-import { Workflow, WorkflowEngine } from "effect/unstable/workflow";
-import { PersistedQueue, Persistence as PersistenceNamespace } from "effect/unstable/persistence";
-import { SqlError as SqlErrorNamespace } from "effect/unstable/sql";
-import type { JobDefinition } from "./queue.ts";
+import { Workflow, WorkflowEngine } from "effect/workflow";
+import { PersistedQueue, Persistence as PersistenceNamespace } from "effect/persistence";
+import { SqlError as SqlErrorNamespace } from "effect/sql";
+import { type JobDefinition } from "./queue.ts";
 import { type JobsError } from "./errors.ts";
 type SqlError = SqlErrorNamespace.SqlError;
 /**
@@ -158,4 +158,22 @@ export declare const layer: (defs: readonly JobDefinition.Any[]) => Layer.Layer<
 export declare const layerLibsql: (defs: readonly JobDefinition.Any[], options: {
     readonly url: string;
 }) => Layer.Layer<Service | WorkflowEngine.WorkflowEngine | PersistenceNamespace.Persistence | PersistedQueue.PersistedQueueFactory, SqlError>;
+/**
+ * OpenCode-style node declaration for {@link layerLibsql}.
+ *
+ * `deps` is empty: the libSQL client, the durable engine, persistence and
+ * the queue factory all arrive from the node's own layer; the root only adds
+ * what the *consumers* (workers, the store's job seams) need.
+ */
+export declare const configured: (defs: readonly JobDefinition.Any[], options: {
+    readonly url: string;
+}) => import("../core/index.js").LayerProvider<PersistedQueue.PersistedQueueFactory | PersistenceNamespace.Persistence | Service | WorkflowEngine.WorkflowEngine, SqlErrorNamespace.SqlError, undefined>;
+/**
+ * The default job-stack node — every built-in definition over the package's
+ * documented jobs database default (`JobsConfigDefaults.dbUrl`,
+ * `file:./.dimple/jobs.db`), the same value `resolveJobsConfig` fills when
+ * the `jobs` section omits `dbUrl`. Nothing is connected at import: the
+ * node only holds a lazily-built layer.
+ */
+export declare const node: import("../core/index.js").LayerProvider<PersistedQueue.PersistedQueueFactory | PersistenceNamespace.Persistence | Service | WorkflowEngine.WorkflowEngine, SqlErrorNamespace.SqlError, undefined>;
 export {};

package/dist/internal/workflow/signals.d.ts

@@ -0,0 +1,21 @@
+/**
+ * In-process execution-completion signals — the event side of `Runtime.wait`.
+ *
+ * `wait` used to poll the persisted `${jobId}/result` key every 250ms. The
+ * engine knows the exact completion moment, so it now notifies a per-
+ * executionId set of Deferreds; `wait` races the signal against its poll
+ * interval (the poll stays as the fallback for cross-process waits, where
+ * the completing engine lives in another process).
+ *
+ * Plain module-level Map — no Effect service: the signal is a fire-and-
+ * forget wakeup, and the subscribers are runtime-layer Deferreds. Cleanup
+ * on unsubscribe keeps the map from leaking job ids.
+ */
+import { Deferred, Effect } from "effect";
+/** Subscribe to one execution's completion. */
+export declare const onExecutionDone: (executionId: string, deferred: Deferred.Deferred<void>) => void;
+/** Unsubscribe (wait's finally — the poll fallback may still be running). */
+export declare const offExecutionDone: (executionId: string, deferred: Deferred.Deferred<void>) => void;
+/** Fire every subscriber's deferred (the engine's completion tap) — an
+ * Effect the caller forks, so no Effect.run* leaks into package code. */
+export declare const notifyExecutionDone: (executionId: string) => Effect.Effect<void>;

package/dist/make.d.ts

@@ -16,6 +16,12 @@ export type MakeDimpleOptions = {
 } | {
     readonly core: CoreOptions;
 };
+/** What changed between the live config and the resolved one. */
+export interface ConfigDiff {
+    readonly storeUrl: boolean;
+    readonly jobsUrl: boolean;
+    readonly rest: boolean;
+}
 /**
  * Create the Dimple facade — resolves once the composed system is fully
  * booted. One runtime is built from the application layer; `runPromise`
@@ -23,5 +29,26 @@ export type MakeDimpleOptions = {
  * Boot failures reject with the same closed `DimpleError` surface as the
  * facade methods (never raw Effect internals) and close the owned
  * resources (scope + runtime) before rethrowing.
+ *
+ * ### Reload (see `Dimple.reload`)
+ *
+ * The facade owns a mutable `LiveStack` cell. A reload:
+ *
+ * 1. re-resolves the config source TYPED (schema errors reject before
+ *    anything pauses — a bad config has zero impact);
+ * 2. pauses: new calls wait on the gate, calls already in flight settle on
+ *    the OLD stack;
+ * 3. boots a fresh stack from the re-resolved config;
+ * 4. drains (waits the in-flight count to zero, bounded by
+ *    `RELOAD_DRAIN_MS`), then swaps the cell and disposes the old stack
+ *    (worker fleet stops, clients close);
+ * 5. releases the gate. Boot or drain failure leaves the old stack
+ *    untouched — the reload rejects and the system keeps serving the
+ *    previous config (blue-green).
+ *
+ * Durable jobs make the pause safe: a handler interrupted by the old
+ * stack's disposal has its lease expire and is re-claimed after boot;
+ * handlers are idempotent by design (transactions roll back, watermarks
+ * advance only on success).
  */
 export declare const makeDimple: (options: MakeDimpleOptions) => Promise<Dimple>;

package/package.json

@@ -1,7 +1,25 @@
 {
   "name": "@ponraaj/dimple-sdk",
-  "version": "0.0.0-alpha.1",
+  "version": "0.0.0-alpha.11",
   "private": false,
+  "description": "Local-first memory for AI agents: durable text and code memories with hybrid semantic and lexical retrieval.",
+  "keywords": [
+    "ai-agents",
+    "embeddings",
+    "libsql",
+    "local-first",
+    "memory",
+    "semantic-search"
+  ],
+  "homepage": "https://dimple.ponraaj.me",
+  "bugs": {
+    "url": "https://github.com/Ponraaj/dimple/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Ponraaj/dimple.git",
+    "directory": "packages/sdk"
+  },
   "files": [
     "dist"
   ],
@@ -23,23 +41,29 @@
   "publishConfig": {
     "access": "public"
   },
-  "scripts": {
-    "build": "rm -rf dist && bun build ./src/index.ts --outdir ./dist --target node --format esm --external effect --external zod --external ai --external \"@ai-sdk/*\" --external @libsql/client --external drizzle-orm --external jsonc-parser --external \"@huggingface/transformers\" --external web-tree-sitter && tsgo -p tsconfig.build.json --outDir dist/.raw && bun scripts/internalize-dts.ts",
-    "prepack": "bun run build",
-    "typecheck": "tsgo --noEmit"
-  },
   "dependencies": {
-    "@ai-sdk/openai-compatible": "^1.0.0",
-    "@huggingface/transformers": "^4.2.0",
+    "@ai-sdk/amazon-bedrock": "^5.0.46",
+    "@ai-sdk/cohere": "^3",
+    "@ai-sdk/google": "^2",
+    "@ai-sdk/openai-compatible": "^3.0.21",
     "@libsql/client": "^0.17.4",
-    "ai": "^5.0.0",
+    "ai": "^7.0.50",
     "drizzle-orm": "^1.0.0-rc.4",
-    "effect": "4.0.0-beta.103",
+    "effect": "4.0.0",
     "jsonc-parser": "^3.3.1",
     "web-tree-sitter": "^0.26.9",
     "zod": "^4.4.3"
   },
   "peerDependencies": {
+    "@huggingface/transformers": "^4.0.0",
     "typescript": "^5"
+  },
+  "peerDependenciesMeta": {
+    "@huggingface/transformers": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": ">=22"
   }
 }

package/dist/internal/embedder/openai.d.ts

@@ -1,8 +0,0 @@
-import { type EmbeddingModel } from "./provider.ts";
-export interface OpenAIOptions {
-    readonly modelId: string;
-    readonly model: string;
-    readonly dimensions: number;
-    readonly apiKey: string;
-}
-export declare const makeOpenAIModel: (options: OpenAIOptions) => EmbeddingModel;

package/dist/internal/wasm/grammar-store.d.ts

@@ -1,14 +0,0 @@
-import { Context, Effect, Layer } from "effect";
-import { GrammarProvisionError } from "@dimple/shared/errors";
-import { Service as TreeSitterRegistry } from "./wasm-registry";
-import { Service as WasmDownloader } from "./wasm-downloader";
-import { Service as WasmCache } from "./wasm-cache";
-export interface Interface {
-    readonly ensure: (lang: string) => Effect.Effect<string, GrammarProvisionError>;
-}
-declare const Service_base: Context.ServiceClass<Service, "@dimple/wasm/GrammarStore", Interface>;
-export declare class Service extends Service_base {
-}
-export declare const layer: Layer.Layer<Service, never, TreeSitterRegistry | WasmDownloader | WasmCache>;
-export declare const allLive: Layer.Layer<TreeSitterRegistry | WasmDownloader | WasmCache | Service, never, never>;
-export {};

package/dist/internal/wasm/index.d.ts

@@ -1,5 +0,0 @@
-export { Service as TreeSitterRegistry } from "./wasm-registry";
-export type { GrammarMetaData } from "./wasm-registry";
-export { Service as WasmDownloader } from "./wasm-downloader";
-export { Service as WasmCache, layer as wasmCacheLayer } from "./wasm-cache";
-export { Service as GrammarStore, layer as grammarStoreLayer, allLive as GrammarStoreAllLive, } from "./grammar-store";

package/dist/internal/wasm/wasm-cache.d.ts

@@ -1,17 +0,0 @@
-import { Context, Effect, Layer } from "effect";
-import { WasmCacheError } from "@dimple/shared/errors";
-/**
- * Grammar WASM cache — downloads are staged to a temp file and renamed
- * into place (an interrupted download never leaves a corrupt parser).
- * Plain `node:fs` (NOT @effect/platform-bun): the bundled SDK runs on
- * Node too (the CLI's shebang spawns node), so Bun-specific filesystem
- * layers are off the table.
- */
-export interface Interface {
-    readonly ensure: (lang: string, version: string, download: Effect.Effect<Uint8Array>) => Effect.Effect<string, WasmCacheError>;
-}
-declare const Service_base: Context.ServiceClass<Service, "@dimple/wasm/WasmCache", Interface>;
-export declare class Service extends Service_base {
-}
-export declare const layer: Layer.Layer<Service, never, never>;
-export {};

package/dist/internal/wasm/wasm-downloader.d.ts

@@ -1,10 +0,0 @@
-import { Context, Effect, Layer } from "effect";
-import { WasmDownloadError } from "@dimple/shared/errors";
-export interface Interface {
-    readonly download: (url: string) => Effect.Effect<Uint8Array, WasmDownloadError>;
-}
-declare const Service_base: Context.ServiceClass<Service, "@dimple/wasm/WasmDownloader", Interface>;
-export declare class Service extends Service_base {
-    static readonly layer: Layer.Layer<Service, never, never>;
-}
-export {};

package/dist/internal/wasm/wasm-registry.d.ts

@@ -1,16 +0,0 @@
-import { Context, Effect, Layer, Schema } from "effect";
-import { RegistryError } from "@dimple/shared/errors";
-declare const GrammarMetaDataSchema: Schema.Struct<{
-    readonly lang: Schema.String;
-    readonly version: Schema.String;
-    readonly url: Schema.String;
-}>;
-export type GrammarMetaData = typeof GrammarMetaDataSchema.Type;
-export interface Interface {
-    readonly resolve: (lang: string) => Effect.Effect<GrammarMetaData, RegistryError>;
-}
-declare const Service_base: Context.ServiceClass<Service, "@dimple/wasm/TreeSitterRegistry", Interface>;
-export declare class Service extends Service_base {
-    static readonly layer: Layer.Layer<Service, never, never>;
-}
-export {};

package/dist/internal/workflow/queue-store.d.ts

@@ -1,5 +0,0 @@
-import { Layer } from "effect";
-import { PersistedQueue } from "effect/unstable/persistence";
-import { SqlClient, SqlError } from "effect/unstable/sql";
-/** Provide the FIXED store to effect's `PersistedQueue.layer`. */
-export declare const storeSqliteLayer: Layer.Layer<PersistedQueue.PersistedQueueStore, SqlError.SqlError, SqlClient.SqlClient>;