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

package/dist/errors.js

@@ -840,6 +840,43 @@ var IndexConfig = Schema8.Struct({
   maxNeighbors: Schema8.optional(Schema8.Number),
   searchL: Schema8.optional(Schema8.Number)
 });
+var ThreadCount = Schema8.Number.pipe(Schema8.refine((n) => Number.isInteger(n) && n >= 0 && n <= 1024, {
+  identifier: "ThreadCount"
+}));
+var SessionOptions = Schema8.Struct({
+  intraOpNumThreads: Schema8.optional(ThreadCount),
+  interOpNumThreads: Schema8.optional(ThreadCount),
+  executionMode: Schema8.optional(Schema8.Literals(["sequential", "parallel"])),
+  graphOptimizationLevel: Schema8.optional(Schema8.Literals(["disabled", "basic", "extended", "all", "layout"])),
+  enableCpuMemArena: Schema8.optional(Schema8.Boolean),
+  enableMemPattern: Schema8.optional(Schema8.Boolean),
+  gpuMemLimit: Schema8.optional(Schema8.Number),
+  arenaExtendStrategy: Schema8.optional(Schema8.Literals([0, 1]))
+});
+var mergeSessionOptions = (global, model) => {
+  const pick = (key) => model?.[key] ?? global?.[key];
+  const intraOpNumThreads = pick("intraOpNumThreads");
+  const interOpNumThreads = pick("interOpNumThreads");
+  const executionMode = pick("executionMode");
+  const graphOptimizationLevel = pick("graphOptimizationLevel");
+  const enableCpuMemArena = pick("enableCpuMemArena");
+  const enableMemPattern = pick("enableMemPattern");
+  const gpuMemLimit = pick("gpuMemLimit");
+  const arenaExtendStrategy = pick("arenaExtendStrategy");
+  const empty = intraOpNumThreads === undefined && interOpNumThreads === undefined && executionMode === undefined && graphOptimizationLevel === undefined && enableCpuMemArena === undefined && enableMemPattern === undefined && gpuMemLimit === undefined && arenaExtendStrategy === undefined;
+  if (empty)
+    return;
+  return {
+    ...intraOpNumThreads !== undefined ? { intraOpNumThreads } : undefined,
+    ...interOpNumThreads !== undefined ? { interOpNumThreads } : undefined,
+    ...executionMode !== undefined ? { executionMode } : undefined,
+    ...graphOptimizationLevel !== undefined ? { graphOptimizationLevel } : undefined,
+    ...enableCpuMemArena !== undefined ? { enableCpuMemArena } : undefined,
+    ...enableMemPattern !== undefined ? { enableMemPattern } : undefined,
+    ...gpuMemLimit !== undefined ? { gpuMemLimit } : undefined,
+    ...arenaExtendStrategy !== undefined ? { arenaExtendStrategy } : undefined
+  };
+};
 var EmbeddingModelConfig = Schema8.Struct({
   id: Schema8.String,
   provider: Schema8.String,
@@ -877,14 +914,13 @@ var EmbeddingModelConfig = Schema8.Struct({
   pooling: Schema8.optional(Schema8.Literals(["mean", "cls", "none"])),
   normalize: Schema8.optional(Schema8.Boolean),
   cacheDir: Schema8.optional(Schema8.String),
-  sessionOptions: Schema8.optional(Schema8.Struct({
-    gpuMemLimit: Schema8.optional(Schema8.Number),
-    arenaExtendStrategy: Schema8.optional(Schema8.Literals([0, 1]))
-  })),
+  sessionOptions: Schema8.optional(SessionOptions),
+  wasm: Schema8.optional(Schema8.Struct({ numThreads: Schema8.optional(ThreadCount) })),
   autoInstall: Schema8.optional(Schema8.Boolean)
 });
 var EmbeddingConfig = Schema8.Struct({
   defaultModel: Schema8.String,
+  sessionOptions: Schema8.optional(SessionOptions),
   models: Schema8.Array(EmbeddingModelConfig)
 });
 var MaxAttempts = Schema8.Number.pipe(Schema8.refine((n) => Number.isInteger(n) && n > 0 && n <= 100, {
@@ -7423,16 +7459,32 @@ var importFromDisk = () => new Promise((resolve, reject) => {
     reject(cause);
   }
 });
-var buildSessionOptions = (opts) => ({
-  executionProviders: [
-    {
-      name: "cuda",
-      device_id: 0,
-      ...opts.gpuMemLimit !== undefined ? { gpu_mem_limit: opts.gpuMemLimit } : undefined,
-      ...opts.arenaExtendStrategy !== undefined ? { arena_extend_strategy: opts.arenaExtendStrategy } : undefined
-    }
-  ]
-});
+var buildSessionOptions = (opts) => {
+  const cuda = opts.gpuMemLimit !== undefined || opts.arenaExtendStrategy !== undefined;
+  return {
+    enableCpuMemArena: opts.enableCpuMemArena ?? false,
+    ...opts.intraOpNumThreads !== undefined ? { intraOpNumThreads: opts.intraOpNumThreads } : undefined,
+    ...opts.interOpNumThreads !== undefined ? { interOpNumThreads: opts.interOpNumThreads } : undefined,
+    ...opts.executionMode !== undefined ? { executionMode: opts.executionMode } : undefined,
+    ...opts.graphOptimizationLevel !== undefined ? { graphOptimizationLevel: opts.graphOptimizationLevel } : undefined,
+    ...opts.enableMemPattern !== undefined ? { enableMemPattern: opts.enableMemPattern } : undefined,
+    ...cuda ? {
+      executionProviders: [
+        {
+          name: "cuda",
+          device_id: 0,
+          ...opts.gpuMemLimit !== undefined ? { gpu_mem_limit: opts.gpuMemLimit } : undefined,
+          ...opts.arenaExtendStrategy !== undefined ? { arena_extend_strategy: opts.arenaExtendStrategy } : undefined
+        }
+      ]
+    } : undefined
+  };
+};
+var applyWasmOptions = (env, wasm) => {
+  if (wasm?.numThreads === undefined)
+    return;
+  env.backends.onnx.wasm.numThreads = wasm.numThreads;
+};
 var defaults2 = {
   modelId: "Xenova/all-MiniLM-L6-v2",
   device: "cpu",
@@ -7474,13 +7526,11 @@ var make6 = (options) => {
     }));
     if (options.cacheDir)
       transformers.env.cacheDir = options.cacheDir;
+    applyWasmOptions(transformers.env, options.wasm);
     pipe = yield* Effect32.tryPromise(() => transformers.pipeline("feature-extraction", options.modelId ?? defaults2.modelId, {
       device: options.device ?? defaults2.device,
       dtype: options.dtype ?? defaults2.dtype,
-      session_options: {
-        enableCpuMemArena: false,
-        ...options.sessionOptions !== undefined ? buildSessionOptions(options.sessionOptions) : undefined
-      }
+      session_options: buildSessionOptions(options.sessionOptions ?? {})
     })).pipe(Effect32.mapError((cause) => new EmbeddingError({ message: `load model: ${cause}` })));
     return pipe;
   });
@@ -8002,7 +8052,8 @@ var embedderFromConfig = (model) => model.provider === "transformers" ? Effect39
   ...model.normalize !== undefined ? { normalize: model.normalize } : undefined,
   ...model.cacheDir !== undefined ? { cacheDir: model.cacheDir } : undefined,
   ...model.autoInstall !== undefined ? { autoInstall: model.autoInstall } : undefined,
-  ...model.sessionOptions !== undefined ? { sessionOptions: model.sessionOptions } : undefined
+  ...model.sessionOptions !== undefined ? { sessionOptions: model.sessionOptions } : undefined,
+  ...model.wasm !== undefined ? { wasm: model.wasm } : undefined
 })) : model.provider === "openai" ? model.apiKey === undefined ? Effect39.fail(new EmbeddingError({ message: `OpenAI model ${model.id} requires an apiKey` })) : Effect39.succeed(makeHostedEmbeddingModel({
   modelId: model.id,
   model: model.model,
@@ -8174,6 +8225,13 @@ var layerConfig7 = (options) => Layer15.unwrap(Effect39.gen(function* () {
     });
   }
   const llm = cfg.config.llm;
+  const models2 = embedding.models.map((model) => {
+    const sessionOptions = mergeSessionOptions(embedding.sessionOptions, model.sessionOptions);
+    return {
+      ...model,
+      ...sessionOptions !== undefined ? { sessionOptions } : undefined
+    };
+  });
   return layer13({
     storeUrl: cfg.config.storeUrl,
     ...cfg.config.defaultK !== undefined ? { defaultK: cfg.config.defaultK } : undefined,
@@ -8181,7 +8239,7 @@ var layerConfig7 = (options) => Layer15.unwrap(Effect39.gen(function* () {
     ...cfg.config.defaultTtlSecs !== undefined ? { defaultTtlSecs: cfg.config.defaultTtlSecs } : undefined,
     jobsUrl,
     ...options?.migrationFolder !== undefined ? { migrationFolder: options.migrationFolder } : undefined,
-    models: embedding.models,
+    models: models2,
     defaultModelId: embedding.defaultModel,
     embedderFor: embedderFromConfig,
     ...cfg.config.topics !== undefined ? { topics: { config: cfg.config.topics } } : undefined,

package/dist/index.js

@@ -840,6 +840,43 @@ var IndexConfig = Schema8.Struct({
   maxNeighbors: Schema8.optional(Schema8.Number),
   searchL: Schema8.optional(Schema8.Number)
 });
+var ThreadCount = Schema8.Number.pipe(Schema8.refine((n) => Number.isInteger(n) && n >= 0 && n <= 1024, {
+  identifier: "ThreadCount"
+}));
+var SessionOptions = Schema8.Struct({
+  intraOpNumThreads: Schema8.optional(ThreadCount),
+  interOpNumThreads: Schema8.optional(ThreadCount),
+  executionMode: Schema8.optional(Schema8.Literals(["sequential", "parallel"])),
+  graphOptimizationLevel: Schema8.optional(Schema8.Literals(["disabled", "basic", "extended", "all", "layout"])),
+  enableCpuMemArena: Schema8.optional(Schema8.Boolean),
+  enableMemPattern: Schema8.optional(Schema8.Boolean),
+  gpuMemLimit: Schema8.optional(Schema8.Number),
+  arenaExtendStrategy: Schema8.optional(Schema8.Literals([0, 1]))
+});
+var mergeSessionOptions = (global, model) => {
+  const pick = (key) => model?.[key] ?? global?.[key];
+  const intraOpNumThreads = pick("intraOpNumThreads");
+  const interOpNumThreads = pick("interOpNumThreads");
+  const executionMode = pick("executionMode");
+  const graphOptimizationLevel = pick("graphOptimizationLevel");
+  const enableCpuMemArena = pick("enableCpuMemArena");
+  const enableMemPattern = pick("enableMemPattern");
+  const gpuMemLimit = pick("gpuMemLimit");
+  const arenaExtendStrategy = pick("arenaExtendStrategy");
+  const empty = intraOpNumThreads === undefined && interOpNumThreads === undefined && executionMode === undefined && graphOptimizationLevel === undefined && enableCpuMemArena === undefined && enableMemPattern === undefined && gpuMemLimit === undefined && arenaExtendStrategy === undefined;
+  if (empty)
+    return;
+  return {
+    ...intraOpNumThreads !== undefined ? { intraOpNumThreads } : undefined,
+    ...interOpNumThreads !== undefined ? { interOpNumThreads } : undefined,
+    ...executionMode !== undefined ? { executionMode } : undefined,
+    ...graphOptimizationLevel !== undefined ? { graphOptimizationLevel } : undefined,
+    ...enableCpuMemArena !== undefined ? { enableCpuMemArena } : undefined,
+    ...enableMemPattern !== undefined ? { enableMemPattern } : undefined,
+    ...gpuMemLimit !== undefined ? { gpuMemLimit } : undefined,
+    ...arenaExtendStrategy !== undefined ? { arenaExtendStrategy } : undefined
+  };
+};
 var EmbeddingModelConfig = Schema8.Struct({
   id: Schema8.String,
   provider: Schema8.String,
@@ -877,14 +914,13 @@ var EmbeddingModelConfig = Schema8.Struct({
   pooling: Schema8.optional(Schema8.Literals(["mean", "cls", "none"])),
   normalize: Schema8.optional(Schema8.Boolean),
   cacheDir: Schema8.optional(Schema8.String),
-  sessionOptions: Schema8.optional(Schema8.Struct({
-    gpuMemLimit: Schema8.optional(Schema8.Number),
-    arenaExtendStrategy: Schema8.optional(Schema8.Literals([0, 1]))
-  })),
+  sessionOptions: Schema8.optional(SessionOptions),
+  wasm: Schema8.optional(Schema8.Struct({ numThreads: Schema8.optional(ThreadCount) })),
   autoInstall: Schema8.optional(Schema8.Boolean)
 });
 var EmbeddingConfig = Schema8.Struct({
   defaultModel: Schema8.String,
+  sessionOptions: Schema8.optional(SessionOptions),
   models: Schema8.Array(EmbeddingModelConfig)
 });
 var MaxAttempts = Schema8.Number.pipe(Schema8.refine((n) => Number.isInteger(n) && n > 0 && n <= 100, {
@@ -7423,16 +7459,32 @@ var importFromDisk = () => new Promise((resolve, reject) => {
     reject(cause);
   }
 });
-var buildSessionOptions = (opts) => ({
-  executionProviders: [
-    {
-      name: "cuda",
-      device_id: 0,
-      ...opts.gpuMemLimit !== undefined ? { gpu_mem_limit: opts.gpuMemLimit } : undefined,
-      ...opts.arenaExtendStrategy !== undefined ? { arena_extend_strategy: opts.arenaExtendStrategy } : undefined
-    }
-  ]
-});
+var buildSessionOptions = (opts) => {
+  const cuda = opts.gpuMemLimit !== undefined || opts.arenaExtendStrategy !== undefined;
+  return {
+    enableCpuMemArena: opts.enableCpuMemArena ?? false,
+    ...opts.intraOpNumThreads !== undefined ? { intraOpNumThreads: opts.intraOpNumThreads } : undefined,
+    ...opts.interOpNumThreads !== undefined ? { interOpNumThreads: opts.interOpNumThreads } : undefined,
+    ...opts.executionMode !== undefined ? { executionMode: opts.executionMode } : undefined,
+    ...opts.graphOptimizationLevel !== undefined ? { graphOptimizationLevel: opts.graphOptimizationLevel } : undefined,
+    ...opts.enableMemPattern !== undefined ? { enableMemPattern: opts.enableMemPattern } : undefined,
+    ...cuda ? {
+      executionProviders: [
+        {
+          name: "cuda",
+          device_id: 0,
+          ...opts.gpuMemLimit !== undefined ? { gpu_mem_limit: opts.gpuMemLimit } : undefined,
+          ...opts.arenaExtendStrategy !== undefined ? { arena_extend_strategy: opts.arenaExtendStrategy } : undefined
+        }
+      ]
+    } : undefined
+  };
+};
+var applyWasmOptions = (env, wasm) => {
+  if (wasm?.numThreads === undefined)
+    return;
+  env.backends.onnx.wasm.numThreads = wasm.numThreads;
+};
 var defaults2 = {
   modelId: "Xenova/all-MiniLM-L6-v2",
   device: "cpu",
@@ -7474,13 +7526,11 @@ var make6 = (options) => {
     }));
     if (options.cacheDir)
       transformers.env.cacheDir = options.cacheDir;
+    applyWasmOptions(transformers.env, options.wasm);
     pipe = yield* Effect32.tryPromise(() => transformers.pipeline("feature-extraction", options.modelId ?? defaults2.modelId, {
       device: options.device ?? defaults2.device,
       dtype: options.dtype ?? defaults2.dtype,
-      session_options: {
-        enableCpuMemArena: false,
-        ...options.sessionOptions !== undefined ? buildSessionOptions(options.sessionOptions) : undefined
-      }
+      session_options: buildSessionOptions(options.sessionOptions ?? {})
     })).pipe(Effect32.mapError((cause) => new EmbeddingError({ message: `load model: ${cause}` })));
     return pipe;
   });
@@ -8002,7 +8052,8 @@ var embedderFromConfig = (model) => model.provider === "transformers" ? Effect39
   ...model.normalize !== undefined ? { normalize: model.normalize } : undefined,
   ...model.cacheDir !== undefined ? { cacheDir: model.cacheDir } : undefined,
   ...model.autoInstall !== undefined ? { autoInstall: model.autoInstall } : undefined,
-  ...model.sessionOptions !== undefined ? { sessionOptions: model.sessionOptions } : undefined
+  ...model.sessionOptions !== undefined ? { sessionOptions: model.sessionOptions } : undefined,
+  ...model.wasm !== undefined ? { wasm: model.wasm } : undefined
 })) : model.provider === "openai" ? model.apiKey === undefined ? Effect39.fail(new EmbeddingError({ message: `OpenAI model ${model.id} requires an apiKey` })) : Effect39.succeed(makeHostedEmbeddingModel({
   modelId: model.id,
   model: model.model,
@@ -8174,6 +8225,13 @@ var layerConfig7 = (options) => Layer15.unwrap(Effect39.gen(function* () {
     });
   }
   const llm = cfg.config.llm;
+  const models2 = embedding.models.map((model) => {
+    const sessionOptions = mergeSessionOptions(embedding.sessionOptions, model.sessionOptions);
+    return {
+      ...model,
+      ...sessionOptions !== undefined ? { sessionOptions } : undefined
+    };
+  });
   return layer13({
     storeUrl: cfg.config.storeUrl,
     ...cfg.config.defaultK !== undefined ? { defaultK: cfg.config.defaultK } : undefined,
@@ -8181,7 +8239,7 @@ var layerConfig7 = (options) => Layer15.unwrap(Effect39.gen(function* () {
     ...cfg.config.defaultTtlSecs !== undefined ? { defaultTtlSecs: cfg.config.defaultTtlSecs } : undefined,
     jobsUrl,
     ...options?.migrationFolder !== undefined ? { migrationFolder: options.migrationFolder } : undefined,
-    models: embedding.models,
+    models: models2,
     defaultModelId: embedding.defaultModel,
     embedderFor: embedderFromConfig,
     ...cfg.config.topics !== undefined ? { topics: { config: cfg.config.topics } } : undefined,

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,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ponraaj/dimple-sdk",
-  "version": "0.0.0-alpha.12",
+  "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": [