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

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

@@ -7,7 +7,11 @@ type DeviceType = "auto" | "gpu" | "cpu" | "wasm" | "webgpu" | "cuda" | "dml" |
 /** The ORT session-options shape transformers.js forwards to
  * onnxruntime-node (executionProviders with a bounded CUDA arena). */
 interface OrtSessionOptions {
-    readonly executionProviders: readonly [
+    /** 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 executionProviders?: readonly [
         {
             readonly name: string;
             readonly device_id: number;
@@ -34,7 +38,7 @@ interface TransformersOptions {
      * 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
+     * to the pipeline's `session_options`; absent = ORT defaults (CPU and
      * ample-VRAM GPUs unaffected). */
     readonly sessionOptions?: {
         readonly gpuMemLimit?: number | undefined;

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.12",
   "private": false,
   "description": "Local-first memory for AI agents: durable text and code memories with hybrid semantic and lexical retrieval.",
   "keywords": [