@ponraaj/dimple-sdk 0.0.0-alpha.12 → 0.0.0-alpha.14

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

@@ -1,4 +1,4 @@
-export { DimpleConfig, EmbeddingModelConfig, EmbeddingConfig, IndexConfig, JobsConfig, TopicsConfig, } from "./schema.ts";
-export type { DimpleConfig as DimpleConfigType, EmbeddingModelConfig as EmbeddingModelConfigType, EmbeddingConfig as EmbeddingConfigType, IndexConfig as IndexConfigType, JobsConfig as JobsConfigType, TopicsConfig as TopicsConfigType, } from "./schema.ts";
+export { DimpleConfig, EmbeddingModelConfig, EmbeddingConfig, IndexConfig, JobsConfig, TopicsConfig, SessionOptions, mergeSessionOptions, } from "./schema.ts";
+export type { DimpleConfig as DimpleConfigType, EmbeddingModelConfig as EmbeddingModelConfigType, EmbeddingConfig as EmbeddingConfigType, IndexConfig as IndexConfigType, JobsConfig as JobsConfigType, TopicsConfig as TopicsConfigType, SessionOptions as SessionOptionsType, } from "./schema.ts";
 export { Service, layer, configured as configConfigured, node as configNode } from "./service.ts";
 export { loadConfig, loadConfigFromFile } from "./loader.ts";

package/dist/internal/config/schema.d.ts

@@ -6,6 +6,30 @@ export declare const IndexConfig: Schema.Struct<{
 }>;
 export interface IndexConfig extends Schema.Schema.Type<typeof IndexConfig> {
 }
+/** ONNX Runtime session options — one shared shape for the global default
+ * (`embedding.sessionOptions`) and the per-model override, so parallel
+ * ingest workers can split cores between processes. The CUDA keys stay flat
+ * (not nested under an EP name) for backward compatibility with the
+ * existing single-purpose configs. */
+export declare const SessionOptions: Schema.Struct<{
+    readonly intraOpNumThreads: Schema.optional<Schema.refine<number, Schema.Number>>;
+    readonly interOpNumThreads: Schema.optional<Schema.refine<number, Schema.Number>>;
+    readonly executionMode: Schema.optional<Schema.Literals<readonly ["sequential", "parallel"]>>;
+    readonly graphOptimizationLevel: Schema.optional<Schema.Literals<readonly ["disabled", "basic", "extended", "all", "layout"]>>;
+    readonly enableCpuMemArena: Schema.optional<Schema.Boolean>;
+    readonly enableMemPattern: Schema.optional<Schema.Boolean>;
+    readonly gpuMemLimit: Schema.optional<Schema.Number>;
+    readonly arenaExtendStrategy: Schema.optional<Schema.Literals<readonly [0, 1]>>;
+}>;
+export interface SessionOptions extends Schema.Schema.Type<typeof SessionOptions> {
+}
+/** Precedence: built-in defaults → `embedding.sessionOptions` → the model
+ * block, merged FIELD BY FIELD, so a model can override one key while
+ * inheriting the rest. `??` only falls through on an ABSENT field, which
+ * keeps `false`/`0` model values overriding a global `true`/non-zero.
+ * `undefined` when both sides are absent — the embedder then forwards no
+ * session options at all. */
+export declare const mergeSessionOptions: (global: SessionOptions | undefined, model: SessionOptions | undefined) => SessionOptions | undefined;
 export declare const EmbeddingModelConfig: Schema.Struct<{
     readonly id: Schema.String;
     readonly provider: Schema.String;
@@ -30,17 +54,32 @@ export declare const EmbeddingModelConfig: Schema.Struct<{
     readonly pooling: Schema.optional<Schema.Literals<readonly ["mean", "cls", "none"]>>;
     readonly normalize: Schema.optional<Schema.Boolean>;
     readonly cacheDir: Schema.optional<Schema.String>;
-    /** ONNX Runtime CUDA session options — the verified fix for GPUs with
-     * limited VRAM (≤8GB): ORT's default arena is unbounded and grows by
-     * powers of two, so batch inference OOMs mid-run and poisons the
-     * process for later queries. `gpuMemLimit` caps the arena (bytes);
-     * `arenaExtendStrategy` picks the growth policy (0 = kNextPowerOfTwo,
-     * 1 = kSameAsRequested). CPU / ample-VRAM GPUs are unaffected (ORT
-     * defaults preserved when absent). */
+    /** ONNX Runtime session options — `intraOpNumThreads` /
+     * `interOpNumThreads` (0 = runtime default, else the per-session thread
+     * count), `executionMode`, `graphOptimizationLevel`,
+     * `enableCpuMemArena`, `enableMemPattern`, plus the CUDA pair: the
+     * verified fix for GPUs with limited VRAM (≤8GB), where ORT's default
+     * arena is unbounded and grows by powers of two, so batch inference OOMs
+     * mid-run and poisons the process for later queries. `gpuMemLimit` caps
+     * the arena (bytes); `arenaExtendStrategy` picks the growth policy
+     * (0 = kNextPowerOfTwo, 1 = kSameAsRequested). CPU / ample-VRAM GPUs are
+     * unaffected (ORT defaults preserved when absent). Merged over
+     * `embedding.sessionOptions` field by field. */
     readonly sessionOptions: Schema.optional<Schema.Struct<{
+        readonly intraOpNumThreads: Schema.optional<Schema.refine<number, Schema.Number>>;
+        readonly interOpNumThreads: Schema.optional<Schema.refine<number, Schema.Number>>;
+        readonly executionMode: Schema.optional<Schema.Literals<readonly ["sequential", "parallel"]>>;
+        readonly graphOptimizationLevel: Schema.optional<Schema.Literals<readonly ["disabled", "basic", "extended", "all", "layout"]>>;
+        readonly enableCpuMemArena: Schema.optional<Schema.Boolean>;
+        readonly enableMemPattern: Schema.optional<Schema.Boolean>;
         readonly gpuMemLimit: Schema.optional<Schema.Number>;
         readonly arenaExtendStrategy: Schema.optional<Schema.Literals<readonly [0, 1]>>;
     }>>;
+    /** ONNX Runtime WASM backend — its own thread knob, which intra-op
+     * threads do NOT reach. */
+    readonly wasm: Schema.optional<Schema.Struct<{
+        readonly numThreads: Schema.optional<Schema.refine<number, Schema.Number>>;
+    }>>;
     /** First-use auto-install of the optional `@huggingface/transformers`
      * peer (default true) — the package is installed with the project's
      * own package manager on the first local-embed use (scripts skipped,
@@ -52,6 +91,19 @@ export interface EmbeddingModelConfig extends Schema.Schema.Type<typeof Embeddin
 }
 export declare const EmbeddingConfig: Schema.Struct<{
     readonly defaultModel: Schema.String;
+    /** Session options every model inherits unless its own block overrides a
+     * field — the single knob for splitting cores across parallel ingest
+     * workers. */
+    readonly sessionOptions: Schema.optional<Schema.Struct<{
+        readonly intraOpNumThreads: Schema.optional<Schema.refine<number, Schema.Number>>;
+        readonly interOpNumThreads: Schema.optional<Schema.refine<number, Schema.Number>>;
+        readonly executionMode: Schema.optional<Schema.Literals<readonly ["sequential", "parallel"]>>;
+        readonly graphOptimizationLevel: Schema.optional<Schema.Literals<readonly ["disabled", "basic", "extended", "all", "layout"]>>;
+        readonly enableCpuMemArena: Schema.optional<Schema.Boolean>;
+        readonly enableMemPattern: Schema.optional<Schema.Boolean>;
+        readonly gpuMemLimit: Schema.optional<Schema.Number>;
+        readonly arenaExtendStrategy: Schema.optional<Schema.Literals<readonly [0, 1]>>;
+    }>>;
     readonly models: Schema.$Array<Schema.Struct<{
         readonly id: Schema.String;
         readonly provider: Schema.String;
@@ -76,17 +128,32 @@ export declare const EmbeddingConfig: Schema.Struct<{
         readonly pooling: Schema.optional<Schema.Literals<readonly ["mean", "cls", "none"]>>;
         readonly normalize: Schema.optional<Schema.Boolean>;
         readonly cacheDir: Schema.optional<Schema.String>;
-        /** ONNX Runtime CUDA session options — the verified fix for GPUs with
-         * limited VRAM (≤8GB): ORT's default arena is unbounded and grows by
-         * powers of two, so batch inference OOMs mid-run and poisons the
-         * process for later queries. `gpuMemLimit` caps the arena (bytes);
-         * `arenaExtendStrategy` picks the growth policy (0 = kNextPowerOfTwo,
-         * 1 = kSameAsRequested). CPU / ample-VRAM GPUs are unaffected (ORT
-         * defaults preserved when absent). */
+        /** ONNX Runtime session options — `intraOpNumThreads` /
+         * `interOpNumThreads` (0 = runtime default, else the per-session thread
+         * count), `executionMode`, `graphOptimizationLevel`,
+         * `enableCpuMemArena`, `enableMemPattern`, plus the CUDA pair: the
+         * verified fix for GPUs with limited VRAM (≤8GB), where ORT's default
+         * arena is unbounded and grows by powers of two, so batch inference OOMs
+         * mid-run and poisons the process for later queries. `gpuMemLimit` caps
+         * the arena (bytes); `arenaExtendStrategy` picks the growth policy
+         * (0 = kNextPowerOfTwo, 1 = kSameAsRequested). CPU / ample-VRAM GPUs are
+         * unaffected (ORT defaults preserved when absent). Merged over
+         * `embedding.sessionOptions` field by field. */
         readonly sessionOptions: Schema.optional<Schema.Struct<{
+            readonly intraOpNumThreads: Schema.optional<Schema.refine<number, Schema.Number>>;
+            readonly interOpNumThreads: Schema.optional<Schema.refine<number, Schema.Number>>;
+            readonly executionMode: Schema.optional<Schema.Literals<readonly ["sequential", "parallel"]>>;
+            readonly graphOptimizationLevel: Schema.optional<Schema.Literals<readonly ["disabled", "basic", "extended", "all", "layout"]>>;
+            readonly enableCpuMemArena: Schema.optional<Schema.Boolean>;
+            readonly enableMemPattern: Schema.optional<Schema.Boolean>;
             readonly gpuMemLimit: Schema.optional<Schema.Number>;
             readonly arenaExtendStrategy: Schema.optional<Schema.Literals<readonly [0, 1]>>;
         }>>;
+        /** ONNX Runtime WASM backend — its own thread knob, which intra-op
+         * threads do NOT reach. */
+        readonly wasm: Schema.optional<Schema.Struct<{
+            readonly numThreads: Schema.optional<Schema.refine<number, Schema.Number>>;
+        }>>;
         /** First-use auto-install of the optional `@huggingface/transformers`
          * peer (default true) — the package is installed with the project's
          * own package manager on the first local-embed use (scripts skipped,
@@ -161,6 +228,19 @@ export declare const DimpleConfig: Schema.Struct<{
     readonly storeUrl: Schema.String;
     readonly embedding: Schema.optional<Schema.Struct<{
         readonly defaultModel: Schema.String;
+        /** Session options every model inherits unless its own block overrides a
+         * field — the single knob for splitting cores across parallel ingest
+         * workers. */
+        readonly sessionOptions: Schema.optional<Schema.Struct<{
+            readonly intraOpNumThreads: Schema.optional<Schema.refine<number, Schema.Number>>;
+            readonly interOpNumThreads: Schema.optional<Schema.refine<number, Schema.Number>>;
+            readonly executionMode: Schema.optional<Schema.Literals<readonly ["sequential", "parallel"]>>;
+            readonly graphOptimizationLevel: Schema.optional<Schema.Literals<readonly ["disabled", "basic", "extended", "all", "layout"]>>;
+            readonly enableCpuMemArena: Schema.optional<Schema.Boolean>;
+            readonly enableMemPattern: Schema.optional<Schema.Boolean>;
+            readonly gpuMemLimit: Schema.optional<Schema.Number>;
+            readonly arenaExtendStrategy: Schema.optional<Schema.Literals<readonly [0, 1]>>;
+        }>>;
         readonly models: Schema.$Array<Schema.Struct<{
             readonly id: Schema.String;
             readonly provider: Schema.String;
@@ -185,17 +265,32 @@ export declare const DimpleConfig: Schema.Struct<{
             readonly pooling: Schema.optional<Schema.Literals<readonly ["mean", "cls", "none"]>>;
             readonly normalize: Schema.optional<Schema.Boolean>;
             readonly cacheDir: Schema.optional<Schema.String>;
-            /** ONNX Runtime CUDA session options — the verified fix for GPUs with
-             * limited VRAM (≤8GB): ORT's default arena is unbounded and grows by
-             * powers of two, so batch inference OOMs mid-run and poisons the
-             * process for later queries. `gpuMemLimit` caps the arena (bytes);
-             * `arenaExtendStrategy` picks the growth policy (0 = kNextPowerOfTwo,
-             * 1 = kSameAsRequested). CPU / ample-VRAM GPUs are unaffected (ORT
-             * defaults preserved when absent). */
+            /** ONNX Runtime session options — `intraOpNumThreads` /
+             * `interOpNumThreads` (0 = runtime default, else the per-session thread
+             * count), `executionMode`, `graphOptimizationLevel`,
+             * `enableCpuMemArena`, `enableMemPattern`, plus the CUDA pair: the
+             * verified fix for GPUs with limited VRAM (≤8GB), where ORT's default
+             * arena is unbounded and grows by powers of two, so batch inference OOMs
+             * mid-run and poisons the process for later queries. `gpuMemLimit` caps
+             * the arena (bytes); `arenaExtendStrategy` picks the growth policy
+             * (0 = kNextPowerOfTwo, 1 = kSameAsRequested). CPU / ample-VRAM GPUs are
+             * unaffected (ORT defaults preserved when absent). Merged over
+             * `embedding.sessionOptions` field by field. */
             readonly sessionOptions: Schema.optional<Schema.Struct<{
+                readonly intraOpNumThreads: Schema.optional<Schema.refine<number, Schema.Number>>;
+                readonly interOpNumThreads: Schema.optional<Schema.refine<number, Schema.Number>>;
+                readonly executionMode: Schema.optional<Schema.Literals<readonly ["sequential", "parallel"]>>;
+                readonly graphOptimizationLevel: Schema.optional<Schema.Literals<readonly ["disabled", "basic", "extended", "all", "layout"]>>;
+                readonly enableCpuMemArena: Schema.optional<Schema.Boolean>;
+                readonly enableMemPattern: Schema.optional<Schema.Boolean>;
                 readonly gpuMemLimit: Schema.optional<Schema.Number>;
                 readonly arenaExtendStrategy: Schema.optional<Schema.Literals<readonly [0, 1]>>;
             }>>;
+            /** ONNX Runtime WASM backend — its own thread knob, which intra-op
+             * threads do NOT reach. */
+            readonly wasm: Schema.optional<Schema.Struct<{
+                readonly numThreads: Schema.optional<Schema.refine<number, Schema.Number>>;
+            }>>;
             /** First-use auto-install of the optional `@huggingface/transformers`
              * peer (default true) — the package is installed with the project's
              * own package manager on the first local-embed use (scripts skipped,

package/dist/internal/core/core.d.ts

@@ -5,7 +5,7 @@ import { EmbeddingError, type EmbeddingModel } from "../embedder/index.js";
 import type { LogConfig, Logging } from "../logger/index.js";
 import { Store, graph, type TopicConfig } from "../store/index.js";
 import { HybridRetrieval } from "../retriever/index.js";
-import { JobRuntime, JobRegistry, type Handler, type JobDefinition } from "../workflow/index.js";
+import { JobRuntime, JobRegistry, QueueStats, type Handler, type JobDefinition } from "../workflow/index.js";
 /** Topic-tree config (the store's schema, defaults decoded by the layer). */
 export type { TopicConfig } from "../store/index.js";
 /** Graph config (the store's schema — `graph.GraphConfig`). */
@@ -71,6 +71,9 @@ export interface Interface {
     readonly store: Store["Service"];
     readonly hybrid: HybridRetrieval["Service"];
     readonly runtime: JobRuntime["Service"];
+    /** Pending durable-queue elements per queue — drain visibility for the
+     * status surfaces (`dimple health`, `dimple://health`). */
+    readonly queueStats: QueueStats["Service"];
     readonly registry: JobRegistry["Service"];
     readonly models: ReadonlyMap<string, EmbeddingModelConfig>;
     readonly defaultModel: EmbeddingModelConfig;

package/dist/internal/core/layer.d.ts

@@ -2,7 +2,7 @@ import { Layer } from "effect";
 import { Store, DbBackend } from "../store/index.js";
 import { EmbeddingError, EmbeddingModelRegistry } from "../embedder/index.js";
 import { HybridRetrieval } from "../retriever/index.js";
-import { JobRuntime, JobRegistry } from "../workflow/index.js";
+import { JobRuntime, JobRegistry, QueueStats } from "../workflow/index.js";
 import { Logging } from "../logger/index.js";
 import { Service as ConfigService } from "../config/index.js";
 import type { CoreOptions } from "./core.ts";
@@ -17,7 +17,7 @@ import { Service } from "./core.ts";
  * service (it runs fibers).
  */
 export type CoreGraphServices = Layer.Success<ReturnType<typeof layer>>;
-export declare const layer: (options: CoreOptions) => Layer.Layer<import("effect/persistence/PersistedQueue").PersistedQueueFactory | import("effect/persistence/Persistence").Persistence | Logging | DbBackend | JobRuntime | JobRegistry | Store | EmbeddingModelRegistry | HybridRetrieval | Service | import("effect/workflow/WorkflowEngine").WorkflowEngine, CoreConfigError | EmbeddingError | import("../retriever/index.js").HybridError | import("../workflow/index.js").RegistryError | import("effect/sql/SqlError").SqlError | import("../store/index.js").StoreError, never>;
+export declare const layer: (options: CoreOptions) => Layer.Layer<import("effect/persistence/PersistedQueue").PersistedQueueFactory | import("effect/persistence/Persistence").Persistence | Logging | DbBackend | QueueStats | JobRuntime | JobRegistry | Store | EmbeddingModelRegistry | HybridRetrieval | Service | import("effect/workflow/WorkflowEngine").WorkflowEngine, CoreConfigError | EmbeddingError | import("../retriever/index.js").HybridError | import("../workflow/index.js").RegistryError | import("effect/sql/SqlError").SqlError | import("../store/index.js").StoreError, never>;
 /**
  * Config-driven variant — the `dimple.jsonc` path (the SDK's
  * `makeDimple({ config })`): reads the resolved `DimpleConfig` from
@@ -27,4 +27,4 @@ export declare const layer: (options: CoreOptions) => Layer.Layer<import("effect
  */
 export declare const layerConfig: (options?: {
     readonly migrationFolder?: string;
-}) => Layer.Layer<import("effect/persistence/PersistedQueue").PersistedQueueFactory | import("effect/persistence/Persistence").Persistence | Logging | DbBackend | JobRuntime | JobRegistry | Store | EmbeddingModelRegistry | HybridRetrieval | Service | import("effect/workflow/WorkflowEngine").WorkflowEngine, CoreConfigError | EmbeddingError | import("../retriever/index.js").HybridError | import("../workflow/index.js").RegistryError | import("effect/sql/SqlError").SqlError | import("../store/index.js").StoreError, ConfigService>;
+}) => Layer.Layer<import("effect/persistence/PersistedQueue").PersistedQueueFactory | import("effect/persistence/Persistence").Persistence | Logging | DbBackend | QueueStats | JobRuntime | JobRegistry | Store | EmbeddingModelRegistry | HybridRetrieval | Service | import("effect/workflow/WorkflowEngine").WorkflowEngine, CoreConfigError | EmbeddingError | import("../retriever/index.js").HybridError | import("../workflow/index.js").RegistryError | import("effect/sql/SqlError").SqlError | import("../store/index.js").StoreError, ConfigService>;

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

@@ -1,3 +1,3 @@
 export { Service as EmbeddingModelRegistry, type Interface as EmbeddingModelRegistryInterface, type EmbeddingModel, EmbeddingError, } from "./provider.ts";
-export { layer as transformersEmbeddingLayer, layerConfig as transformersEmbeddingLayerConfig, makeTransformersModel, buildSessionOptions, } from "./transformers.ts";
+export { layer as transformersEmbeddingLayer, layerConfig as transformersEmbeddingLayerConfig, makeTransformersModel, buildSessionOptions, applyWasmOptions, type SessionOptions, type TransformersEnv, type WasmOptions, } from "./transformers.ts";
 export { layer as registryLayer, configured as registryConfigured, type ModelSpec, } from "./registry.ts";

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

@@ -1,16 +1,42 @@
 import { Config, Layer } from "effect";
 import { Service, type EmbeddingModel } from "./provider.ts";
+/** Mirror of transformers.js's `env` — `backends.onnx` is a shallow copy of
+ * ORT's env object, so `.wasm` is the LIVE nested object the runtime reads
+ * at session creation (hence assignable before the pipeline is built). */
+export interface TransformersEnv {
+    cacheDir?: string;
+    backends: {
+        onnx: {
+            wasm: OrtWasmEnvFlags;
+        };
+    };
+}
+/** The ORT wasm env knobs dimple sets — `numThreads` is the wasm backend's
+ * own thread count (0 = system-determined, 1 = no worker threads), read
+ * when the session is created. */
+export interface OrtWasmEnvFlags {
+    numThreads?: number;
+}
+/** Per-model wasm backend options. */
+export interface WasmOptions {
+    readonly numThreads?: number | undefined;
+}
 /** Mirror of transformers.js's `DeviceType` (the config schema carries the
  * same literals) — kept local so the optional peer's types never appear
  * in this module's surface. */
 type DeviceType = "auto" | "gpu" | "cpu" | "wasm" | "webgpu" | "cuda" | "dml" | "coreml" | "webnn";
 /** The ORT session-options shape transformers.js forwards to
- * onnxruntime-node (executionProviders with a bounded CUDA arena). */
+ * onnxruntime-node/web unchanged (ORT reads camelCase JS keys out of the
+ * snake_case `session_options` bag). Thread counts and the arena/pattern
+ * switches are what let parallel dimple processes split cores instead of
+ * each taking one thread per physical core. */
 interface OrtSessionOptions {
-    /** ORT JS session options are camelCase; transformers.js reads them from
-     * a snake_case `session_options` bag. The CPU arena pre-allocates and
-     * holds memory across runs (onnxruntime#11627). */
     readonly enableCpuMemArena?: boolean;
+    readonly intraOpNumThreads?: number;
+    readonly interOpNumThreads?: number;
+    readonly executionMode?: "sequential" | "parallel";
+    readonly graphOptimizationLevel?: "disabled" | "basic" | "extended" | "all" | "layout";
+    readonly enableMemPattern?: boolean;
     readonly executionProviders?: readonly [
         {
             readonly name: string;
@@ -20,13 +46,30 @@ interface OrtSessionOptions {
         }
     ];
 }
-/** Map the focused dimple-level pair to ORT's snake_case session keys.
- * Both fields absent → `undefined`, so the caller can skip the whole
- * sessionOptions (ORT defaults preserved). */
-export declare const buildSessionOptions: (opts: {
+/** ONNX Runtime session options — a structural mirror of `@dimple/config`'s
+ * `SessionOptions` (the embedder does not depend on config; the config
+ * schema carries the same field names). */
+export interface SessionOptions {
+    readonly intraOpNumThreads?: number | undefined;
+    readonly interOpNumThreads?: number | undefined;
+    readonly executionMode?: "sequential" | "parallel" | undefined;
+    readonly graphOptimizationLevel?: "disabled" | "basic" | "extended" | "all" | "layout" | undefined;
+    readonly enableCpuMemArena?: boolean | undefined;
+    readonly enableMemPattern?: boolean | undefined;
     readonly gpuMemLimit?: number | undefined;
     readonly arenaExtendStrategy?: 0 | 1 | undefined;
-}) => OrtSessionOptions;
+}
+/** Map the dimple-level session options to ORT's session keys. Absent
+ * fields are omitted, so ORT keeps its own default; `enableCpuMemArena`
+ * always lands because it has a dimple default (bulk ingest does not need
+ * the arena). The CUDA execution provider is emitted ONLY when a CUDA key
+ * is present — injecting it unconditionally would pin every CPU-only model
+ * to a CUDA EP the runtime may not have. */
+export declare const buildSessionOptions: (opts: SessionOptions) => OrtSessionOptions;
+/** Map the wasm block onto transformers' ORT env, BEFORE the session is
+ * created — the wasm backend reads `numThreads` from its env, not from the
+ * session options, so `intraOpNumThreads` does not reach it. */
+export declare const applyWasmOptions: (env: TransformersEnv, wasm: WasmOptions | undefined) => void;
 interface TransformersOptions {
     readonly modelId?: string;
     readonly device?: DeviceType;
@@ -34,16 +77,17 @@ interface TransformersOptions {
     readonly pooling?: "mean" | "cls" | "none";
     readonly normalize?: boolean;
     readonly cacheDir?: string;
-    /** ONNX Runtime CUDA session options — the verified fix for GPUs with
-     * limited VRAM (≤8GB): ORT's default arena is unbounded (grows by
-     * powers of two), so batch inference OOMs mid-run and leaves the
-     * process unable to allocate even a cublas handle afterwards. Forwarded
-     * to the pipeline's `session_options`; absent = ORT defaults (CPU and
-     * ample-VRAM GPUs unaffected). */
-    readonly sessionOptions?: {
-        readonly gpuMemLimit?: number | undefined;
-        readonly arenaExtendStrategy?: 0 | 1 | undefined;
-    };
+    /** ONNX Runtime session options — thread counts, arena/pattern switches,
+     * execution mode, graph optimization, and the CUDA pair (the verified fix
+     * for GPUs with limited VRAM (≤8GB): ORT's default arena is unbounded
+     * (grows by powers of two), so batch inference OOMs mid-run and leaves
+     * the process unable to allocate even a cublas handle afterwards).
+     * Forwarded to the pipeline's `session_options`; absent fields keep ORT's
+     * own defaults. */
+    readonly sessionOptions?: SessionOptions;
+    /** ONNX Runtime WASM backend options — applied to the ORT env before the
+     * session is created. */
+    readonly wasm?: WasmOptions;
     /** Declared output dimension — validated against the model's actual
      * output on first embed (a mismatch fails typed, precisely). */
     readonly dimensions?: number;

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

@@ -102,7 +102,7 @@ export declare const routeInsert: (memoryId: string, vector: ReadonlyArray<numbe
  *    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).
+ *    transaction (per-topic FINAL states 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).

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

@@ -31,6 +31,7 @@ import { Layer } from "effect";
 import { WorkflowEngine } from "effect/workflow";
 import { Persistence as PersistenceNamespace, PersistedQueue } from "effect/persistence";
 import { SqlError as SqlErrorNamespace } from "effect/sql";
+import { Service as QueueStatsService } from "./stats.ts";
 type SqlError = SqlErrorNamespace.SqlError;
 /**
  * Durable WorkflowEngine layer.
@@ -50,7 +51,7 @@ export declare const layerDurable: Layer.Layer<WorkflowEngine.WorkflowEngine, ne
  */
 export declare const libsqlStack: (options: {
     readonly url: string;
-}) => Layer.Layer<PersistedQueue.PersistedQueueFactory | PersistenceNamespace.Persistence, SqlErrorNamespace.SqlError, never>;
+}) => Layer.Layer<PersistedQueue.PersistedQueueFactory | PersistenceNamespace.Persistence | QueueStatsService, SqlErrorNamespace.SqlError, never>;
 /**
  * Convenience layer: durable engine + SQL persistence + resume queue + libSQL
  * client, all sharing one libSQL instance. Surfaces `SqlError` from the
@@ -71,7 +72,7 @@ export declare const layerDurableLibsql: (options: {
  */
 export declare const libsqlStackConfigured: (options: {
     readonly url: string;
-}) => import("../core/index.js").LayerProvider<PersistedQueue.PersistedQueueFactory | PersistenceNamespace.Persistence, SqlErrorNamespace.SqlError, undefined>;
+}) => import("../core/index.js").LayerProvider<PersistedQueue.PersistedQueueFactory | PersistenceNamespace.Persistence | QueueStatsService, SqlErrorNamespace.SqlError, undefined>;
 export declare const layerDurableLibsqlConfigured: (options: {
     readonly url: string;
 }) => import("../core/index.js").LayerProvider<WorkflowEngine.WorkflowEngine, SqlErrorNamespace.SqlError, undefined>;

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

@@ -6,6 +6,7 @@
 export { JobDefinition, Envelope, TopicSplit, MemoryEmbed, MemoryEmbedBatch, TopicMerge, TopicRebalance, ConceptCluster, MemoryDream, GraphRepair, AuditWrite, type AuditRow, queues, type EnvelopeSchema, } from "./queue.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 QueueStats, layer as queueStatsLayer, type Interface as QueueStatsInterface, type QueueStat, } from "./stats.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";

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

@@ -56,6 +56,7 @@ import { PersistedQueue, Persistence as PersistenceNamespace } from "effect/pers
 import { SqlError as SqlErrorNamespace } from "effect/sql";
 import { type JobDefinition } from "./queue.ts";
 import { type JobsError } from "./errors.ts";
+import { Service as QueueStatsService } from "./stats.ts";
 type SqlError = SqlErrorNamespace.SqlError;
 /**
  * Lifecycle of a job from the caller's perspective.
@@ -157,7 +158,7 @@ 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>;
+}) => Layer.Layer<Service | WorkflowEngine.WorkflowEngine | PersistenceNamespace.Persistence | PersistedQueue.PersistedQueueFactory | QueueStatsService, SqlError>;
 /**
  * OpenCode-style node declaration for {@link layerLibsql}.
  *
@@ -167,7 +168,7 @@ export declare const layerLibsql: (defs: readonly JobDefinition.Any[], options:
  */
 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>;
+}) => import("../core/index.js").LayerProvider<PersistedQueue.PersistedQueueFactory | PersistenceNamespace.Persistence | QueueStatsService | 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`,
@@ -175,5 +176,5 @@ export declare const configured: (defs: readonly JobDefinition.Any[], options: {
  * 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 declare const node: import("../core/index.js").LayerProvider<PersistedQueue.PersistedQueueFactory | PersistenceNamespace.Persistence | QueueStatsService | Service | WorkflowEngine.WorkflowEngine, SqlErrorNamespace.SqlError, undefined>;
 export {};

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

@@ -0,0 +1,44 @@
+/**
+ * Queue statistics — drain visibility for the status surfaces.
+ *
+ * The durable queue's own API (`PersistedQueueStore`: offer/take/cleanup)
+ * exposes no count, so pending work is invisible to callers once enqueued:
+ * after `memory_index` returns `pendingEmbeddings: N` an agent has no way to
+ * ask "how much is still draining?" — it guesses, sleeps, and retries.
+ *
+ * This service answers that with ONE grouped COUNT over the queue table
+ * (`effect_queue`, the table `PersistedQueue.layerStoreSql` creates). Only
+ * `state = 'pending'` rows are counted — offered but NOT YET FINISHED.
+ * Taking an element does not change its state (it stamps `acquired_at` /
+ * `acquired_by`); completion or failure moves it to `completed` / `failed`.
+ * So the count is "outstanding work", in-flight included. `completed` rows
+ * are dedup records and `failed` rows are dead letters — neither is counted.
+ *
+ * The internal {@link RESUME_QUEUE} is excluded by design: it carries
+ * cross-process wake-up signals for suspended executions, and a signal row
+ * outlives the work it points at (the engine resumes in-process too, leaving
+ * the durable row pending forever). Counting it would make "is anything
+ * still running?" unanswerable — the question this service exists for.
+ *
+ * It lives beside the stack that owns the queue (the same `SqlClient` the
+ * engine and queue store share), so the status surfaces can report drain
+ * state without opening a second connection or reaching into `jobs.db`.
+ */
+import { Context, Effect, Layer } from "effect";
+import { SqlClient, SqlError as SqlErrorNamespace } from "effect/sql";
+type SqlError = SqlErrorNamespace.SqlError;
+/** Pending elements for one queue (`DurableQueue/<job name>`, `dimple/resume`). */
+export interface QueueStat {
+    readonly queue: string;
+    readonly pending: number;
+}
+export interface Interface {
+    /** Outstanding (offered, not yet finished) elements per queue, queue name
+     * ascending. */
+    readonly pending: () => Effect.Effect<readonly QueueStat[], SqlError>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@dimple/workflow/QueueStats", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const layer: Layer.Layer<Service, never, SqlClient.SqlClient>;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ponraaj/dimple-sdk",
-  "version": "0.0.0-alpha.12",
+  "version": "0.0.0-alpha.14",
   "private": false,
   "description": "Local-first memory for AI agents: durable text and code memories with hybrid semantic and lexical retrieval.",
   "keywords": [