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

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/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,13 +1,43 @@
 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 {
-    readonly executionProviders: readonly [
+    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;
             readonly device_id: number;
@@ -16,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;
@@ -30,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 sessionOptions; 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/index.d.ts

@@ -12,8 +12,8 @@ export * from "./tree.ts";
 export * from "./routing.ts";
 export * from "./query.ts";
 export * from "./lifecycle.ts";
-export { memoryEmbedHandler } from "./lifecycle.ts";
-export type { MemoryEmbedHandler, MemoryEmbedHandlerDeps } from "./lifecycle.ts";
+export { memoryEmbedHandler, memoryEmbedBatchHandler } from "./lifecycle.ts";
+export type { MemoryEmbedHandler, MemoryEmbedHandlerDeps, MemoryEmbedBatchHandler, MemoryEmbedBatchPayload, } from "./lifecycle.ts";
 export * from "./errors.ts";
 export { splitTopic, topicSplitHandler, shouldSplit } from "./jobs.ts";
 export type { SplitOutcome, TopicSplitHandler, TopicSplitHandlerDeps } from "./jobs.ts";

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

@@ -120,6 +120,16 @@ export interface MemoryEmbedPayload {
 }
 /** The `memory.embed` handler shape (see jobs.ts). */
 export type MemoryEmbedHandler = (payload: MemoryEmbedPayload, ctx: JobContext) => Effect.Effect<unknown, JobFailure, DbBackend>;
+/** The decoded `memory.embed.batch` payload — mirrors the queue
+ * definition's schema; `nonce` only keeps distinct enqueues distinct. */
+export interface MemoryEmbedBatchPayload {
+    readonly memoryIds: readonly string[];
+    readonly modelKey: string;
+    readonly nonce: string;
+}
+/** The `memory.embed.batch` handler shape — the same deps as the per-memory
+ * handler; ids are embedded one at a time, in payload order. */
+export type MemoryEmbedBatchHandler = (payload: MemoryEmbedBatchPayload, ctx: JobContext) => Effect.Effect<unknown, JobFailure, DbBackend>;
 /**
  * Factory for the `memory.embed` job handler: re-embeds one memory with the
  * target model and routes it into that model's tree. The success schema is
@@ -130,3 +140,18 @@ export declare function memoryEmbedHandler(deps: MemoryEmbedHandlerDeps & {
     readonly backend: DbBackendInterface;
 }): Handler;
 export declare function memoryEmbedHandler(deps: MemoryEmbedHandlerDeps): MemoryEmbedHandler;
+/**
+ * Factory for the `memory.embed.batch` job handler: the same outcome as the
+ * per-memory job for a whole list of ids, with the STORE phase batched —
+ * one tree seed, one vector-table seed, one membership SELECT, one vector
+ * insert, one routing pass, one embedding-column UPDATE for the whole batch
+ * (per-id repeats of those dominated a 235-unit drain). The EMBED step stays
+ * per id (one model forward pass per text). A stale id (memory gone) is a
+ * success no-op, exactly like the per-memory job's; a real failure fails the
+ * ONE job, naming how many ids failed and the first failure — ids that did
+ * succeed stay committed, and a redelivery re-runs them idempotently.
+ */
+export declare function memoryEmbedBatchHandler(deps: MemoryEmbedHandlerDeps & {
+    readonly backend: DbBackendInterface;
+}): Handler;
+export declare function memoryEmbedBatchHandler(deps: MemoryEmbedHandlerDeps): MemoryEmbedBatchHandler;

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

@@ -3,7 +3,7 @@
  *
  * 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 { 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 JobRegistry, layer as jobRegistryLayer, configured as jobRegistryConfigured, node as jobRegistryNode, JobFailure, type Handler, type JobContext, } from "./registry.ts";

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

@@ -173,6 +173,23 @@ export declare const MemoryEmbed: JobDefinition<Schema.Struct<{
     memoryId: Schema.String;
     modelKey: Schema.String;
 }>, Schema.Void, Schema.String>;
+/**
+ * Batch embedding backfill job — `memory.embed.batch`. Same work as
+ * `memory.embed`, one job for many memories: the bulk ingest path
+ * (`Dimple.index` with `deferEmbed`) would otherwise enqueue and drain one
+ * job per unit while the walk is still running.
+ *
+ * `nonce` keeps distinct enqueues distinct (the key function stays
+ * deterministic over the payload, so it can never collapse two different
+ * batches into one execution id); the handler is idempotent PER MEMORY, so a
+ * redelivered or overlapping batch re-embeds an already-embedded unit for
+ * nothing rather than corrupting it.
+ */
+export declare const MemoryEmbedBatch: JobDefinition<Schema.Struct<{
+    memoryIds: Schema.$Array<Schema.String>;
+    modelKey: Schema.String;
+    nonce: Schema.String;
+}>, Schema.Void, Schema.String>;
 /** Underflow maintenance job — `topic.merge` (borrow-then-merge). */
 export declare const TopicMerge: JobDefinition<Schema.Struct<{
     topicId: Schema.String;
@@ -270,6 +287,10 @@ export declare const queues: readonly [JobDefinition<Schema.Struct<{
 }>, Schema.Void, Schema.String>, JobDefinition<Schema.Struct<{
     memoryId: Schema.String;
     modelKey: Schema.String;
+}>, Schema.Void, Schema.String>, JobDefinition<Schema.Struct<{
+    memoryIds: Schema.$Array<Schema.String>;
+    modelKey: Schema.String;
+    nonce: Schema.String;
 }>, Schema.Void, Schema.String>, JobDefinition<Schema.Struct<{
     topicId: Schema.String;
     modelKey: Schema.String;

package/package.json

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