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

package/dist/indexer.d.ts

@@ -25,11 +25,20 @@ export interface WalkResult {
      * SAME file always gets the SAME key regardless of which path list was
      * passed (idempotent re-indexing across invocation shapes). */
     readonly root: string;
+    /** The resolved input paths — the reconcile DOMAIN: units whose file
+     * path is outside every root are untouched by subtree runs. */
+    readonly roots: readonly string[];
 }
 /** Recursively collect indexable files from paths (dirs or files). */
 export declare const walkFiles: (paths: readonly string[], extensions: readonly string[]) => WalkResult;
 /** Read a file's text, capped at `maxBytes` (string slice = char-safe). */
 export declare const readCapped: (path: string, maxBytes: number) => string;
+/** The repository's HEAD commit for provenance stamping — soft-failed
+ * (non-git trees, missing git, permission errors → null). Walks UP from
+ * the first indexed file (git finds the enclosing repo), so it works for
+ * absolute-path trees whose key root is "/". Platform side; the facade
+ * never touches node APIs. */
+export declare const currentCommit: (firstFile: string | undefined) => string | null;
 /** Resolve a file's relative import specifiers to indexed-tree files
  * (bare/absolute specifiers are external modules — no node_modules
  * resolution). */

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 { Service, layer } from "./service.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

@@ -13,11 +13,40 @@ export declare const EmbeddingModelConfig: Schema.Struct<{
     readonly dimensions: Schema.Number;
     readonly vectorType: Schema.optional<Schema.String>;
     readonly apiKey: Schema.optional<Schema.String>;
+    /** Hosted providers: OpenAI-compatible endpoint override (default
+     * `https://api.openai.com/v1`). */
+    readonly baseURL: Schema.optional<Schema.String>;
     readonly indexConfig: Schema.optional<Schema.Struct<{
         readonly compressNeighbors: Schema.optional<Schema.String>;
         readonly maxNeighbors: Schema.optional<Schema.Number>;
         readonly searchL: Schema.optional<Schema.Number>;
     }>>;
+    /** Transformers.js runtime options — per-model, all optional (defaults:
+     * device "cpu", dtype "q8", pooling "mean", normalize true). `dtype`
+     * quantizes the MODEL WEIGHTS (inference memory/speed), never the
+     * output vectors; unsupported devices fail typed at first use. */
+    readonly device: Schema.optional<Schema.Literals<readonly ["auto", "gpu", "cpu", "wasm", "webgpu", "cuda", "dml", "coreml", "webnn"]>>;
+    readonly dtype: Schema.optional<Schema.Literals<readonly ["fp32", "fp16", "q8", "int8", "uint8", "q4", "bnb4", "q4f16", "q2", "q2f16", "q1", "q1f16"]>>;
+    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). */
+    readonly sessionOptions: Schema.optional<Schema.Struct<{
+        readonly gpuMemLimit: Schema.optional<Schema.Number>;
+        readonly arenaExtendStrategy: Schema.optional<Schema.Literals<readonly [0, 1]>>;
+    }>>;
+    /** 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,
+     * proven unnecessary for embedding). Set false to require a manual
+     * install. */
+    readonly autoInstall: Schema.optional<Schema.Boolean>;
 }>;
 export interface EmbeddingModelConfig extends Schema.Schema.Type<typeof EmbeddingModelConfig> {
 }
@@ -30,11 +59,40 @@ export declare const EmbeddingConfig: Schema.Struct<{
         readonly dimensions: Schema.Number;
         readonly vectorType: Schema.optional<Schema.String>;
         readonly apiKey: Schema.optional<Schema.String>;
+        /** Hosted providers: OpenAI-compatible endpoint override (default
+         * `https://api.openai.com/v1`). */
+        readonly baseURL: Schema.optional<Schema.String>;
         readonly indexConfig: Schema.optional<Schema.Struct<{
             readonly compressNeighbors: Schema.optional<Schema.String>;
             readonly maxNeighbors: Schema.optional<Schema.Number>;
             readonly searchL: Schema.optional<Schema.Number>;
         }>>;
+        /** Transformers.js runtime options — per-model, all optional (defaults:
+         * device "cpu", dtype "q8", pooling "mean", normalize true). `dtype`
+         * quantizes the MODEL WEIGHTS (inference memory/speed), never the
+         * output vectors; unsupported devices fail typed at first use. */
+        readonly device: Schema.optional<Schema.Literals<readonly ["auto", "gpu", "cpu", "wasm", "webgpu", "cuda", "dml", "coreml", "webnn"]>>;
+        readonly dtype: Schema.optional<Schema.Literals<readonly ["fp32", "fp16", "q8", "int8", "uint8", "q4", "bnb4", "q4f16", "q2", "q2f16", "q1", "q1f16"]>>;
+        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). */
+        readonly sessionOptions: Schema.optional<Schema.Struct<{
+            readonly gpuMemLimit: Schema.optional<Schema.Number>;
+            readonly arenaExtendStrategy: Schema.optional<Schema.Literals<readonly [0, 1]>>;
+        }>>;
+        /** 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,
+         * proven unnecessary for embedding). Set false to require a manual
+         * install. */
+        readonly autoInstall: Schema.optional<Schema.Boolean>;
     }>>;
 }>;
 export interface EmbeddingConfig extends Schema.Schema.Type<typeof EmbeddingConfig> {
@@ -110,11 +168,40 @@ export declare const DimpleConfig: Schema.Struct<{
             readonly dimensions: Schema.Number;
             readonly vectorType: Schema.optional<Schema.String>;
             readonly apiKey: Schema.optional<Schema.String>;
+            /** Hosted providers: OpenAI-compatible endpoint override (default
+             * `https://api.openai.com/v1`). */
+            readonly baseURL: Schema.optional<Schema.String>;
             readonly indexConfig: Schema.optional<Schema.Struct<{
                 readonly compressNeighbors: Schema.optional<Schema.String>;
                 readonly maxNeighbors: Schema.optional<Schema.Number>;
                 readonly searchL: Schema.optional<Schema.Number>;
             }>>;
+            /** Transformers.js runtime options — per-model, all optional (defaults:
+             * device "cpu", dtype "q8", pooling "mean", normalize true). `dtype`
+             * quantizes the MODEL WEIGHTS (inference memory/speed), never the
+             * output vectors; unsupported devices fail typed at first use. */
+            readonly device: Schema.optional<Schema.Literals<readonly ["auto", "gpu", "cpu", "wasm", "webgpu", "cuda", "dml", "coreml", "webnn"]>>;
+            readonly dtype: Schema.optional<Schema.Literals<readonly ["fp32", "fp16", "q8", "int8", "uint8", "q4", "bnb4", "q4f16", "q2", "q2f16", "q1", "q1f16"]>>;
+            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). */
+            readonly sessionOptions: Schema.optional<Schema.Struct<{
+                readonly gpuMemLimit: Schema.optional<Schema.Number>;
+                readonly arenaExtendStrategy: Schema.optional<Schema.Literals<readonly [0, 1]>>;
+            }>>;
+            /** 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,
+             * proven unnecessary for embedding). Set false to require a manual
+             * install. */
+            readonly autoInstall: Schema.optional<Schema.Boolean>;
         }>>;
     }>>;
     readonly jobs: Schema.optional<Schema.Struct<{

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

@@ -7,4 +7,8 @@ declare const Service_base: Context.ServiceClass<Service, "@dimple/Config", Inte
 export declare class Service extends Service_base {
 }
 export declare const layer: (overrides?: Partial<DimpleConfigType>) => Layer.Layer<Service, Error>;
+/** The Config layer-graph node. `deps` stays empty — the composition root
+ * wires dependencies, per the layer-graph convention. */
+export declare const configured: (overrides?: Partial<DimpleConfigType>) => import("../core/index.js").LayerProvider<Service, Error, undefined>;
+export declare const node: import("../core/index.js").LayerProvider<Service, Error, undefined>;
 export {};

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

@@ -1,13 +1,13 @@
 import { Context, Effect, Schema } from "effect";
-import type { EmbeddingModelConfig } from "./internal/config/index.js";
-import type { LLM } from "./internal/llm/index.js";
-import { EmbeddingError, type EmbeddingModel } from "./internal/embedder/index.js";
-import type { LogConfig, Logging } from "./internal/logger/index.js";
-import { Store, graph, type TopicConfig } from "./internal/store/index.js";
-import { HybridRetrieval } from "./internal/retriever/index.js";
-import { JobRuntime, JobRegistry, type Handler, type JobDefinition } from "./internal/workflow/index.js";
+import type { EmbeddingModelConfig } from "../config/index.js";
+import type { LLM } from "../llm/index.js";
+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";
 /** Topic-tree config (the store's schema, defaults decoded by the layer). */
-export type { TopicConfig } from "./internal/store/index.js";
+export type { TopicConfig } from "../store/index.js";
 /** Graph config (the store's schema — `graph.GraphConfig`). */
 export type GraphConfig = graph.GraphConfig;
 /**

package/dist/internal/core/hosted-embedding.d.ts

@@ -0,0 +1,33 @@
+import { type EmbeddingModel } from "../embedder/index.js";
+export interface HostedEmbeddingOptions {
+    readonly modelId: string;
+    readonly model: string;
+    readonly dimensions: number;
+    readonly apiKey: string;
+    /** The AI SDK provider family — see
+     * https://ai-sdk.dev/providers for the full provider list. */
+    readonly provider?: "openai" | "google" | "cohere" | "bedrock";
+    /** OpenAI-compatible endpoint override — ONLY needed for custom
+     * endpoints (vLLM/ollama/…). The preconfigured providers have their
+     * base URL baked in. */
+    readonly baseURL?: string;
+}
+/**
+ * Hosted embeddings — the `ai` SDK IS the implementation (`embedMany`),
+ * this adapter only bridges it to the dimple `EmbeddingModel` interface.
+ *
+ * Provider mapping (config `provider` field):
+ * - `"openai"` — openai-compatible provider; `baseURL` defaults to
+ *   `https://api.openai.com/v1`, override for any compatible endpoint
+ * - `"google"` — native `@ai-sdk/google` (gemini-embedding-*), no baseURL
+ * - `"cohere"` — native `@ai-sdk/cohere` (embed-*-v3.0), no baseURL
+ * - `"bedrock"` — native `@ai-sdk/amazon-bedrock` (titan/nova/cohere
+ *   models), no baseURL — credentials come from AWS env (or the provider
+ *   settings)
+ *
+ * `dimensions` is sent as a provider option where the API supports it
+ * (openaiCompatible.dimensions / google.outputDimensionality /
+ * cohere.outputDimension) and ALWAYS enforced on the output (some
+ * endpoints ignore the option).
+ */
+export declare const makeHostedEmbeddingModel: (options: HostedEmbeddingOptions) => EmbeddingModel;

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

@@ -1,3 +1,9 @@
 export { Service as Core, make as makeCore, type Interface as CoreInterface, type CoreOptions, } from "./core.ts";
 export { layer as coreLayer, layerConfig as coreLayerConfig } from "./layer.ts";
+export type { CoreGraphServices } from "./layer.ts";
+/** The layer-graph surface, as the reference exposes it: one value namespace
+ * whose members are the `make`/`group`/`compile` constructors and the
+ * `Graph`/`Node`/`Provider`/`Replacement` types. */
+export * as LayerNode from "../shared/effect/node.js";
+export { compile as compileLayers, group as groupLayers, make as makeLayer, tags as layerTags, unbound as unboundLayer, type Graph as LayerGraph, type Provider as LayerProvider, type Replacement as LayerReplacement, } from "../shared/effect/node.js";
 export { CoreConfigError } from "./core.ts";

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

@@ -1,14 +1,23 @@
 import { Layer } from "effect";
-import { Store, DbBackend } from "./internal/store/index.js";
-import { EmbeddingError, EmbeddingModelRegistry } from "./internal/embedder/index.js";
-import { HybridRetrieval } from "./internal/retriever/index.js";
-import { JobRuntime, JobRegistry } from "./internal/workflow/index.js";
-import { Logging } from "./internal/logger/index.js";
-import { Service as ConfigService } from "./internal/config/index.js";
+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 { Logging } from "../logger/index.js";
+import { Service as ConfigService } from "../config/index.js";
 import type { CoreOptions } from "./core.ts";
 import { CoreConfigError } from "./core.ts";
 import { Service } from "./core.ts";
-export declare const layer: (options: CoreOptions) => Layer.Layer<import("effect/unstable/persistence/PersistedQueue").PersistedQueueFactory | import("effect/unstable/persistence/Persistence").Persistence | Logging | DbBackend | JobRuntime | JobRegistry | Store | EmbeddingModelRegistry | HybridRetrieval | Service | import("effect/unstable/workflow/WorkflowEngine").WorkflowEngine, CoreConfigError | EmbeddingError | import("./internal/retriever/index.js").HybridError | import("./internal/workflow/index.js").RegistryError | import("effect/unstable/sql/SqlError").SqlError | import("./internal/store/index.js").StoreError, import("effect/Scope").Scope>;
+/**
+ * Everything the composed graph exposes. Every node is a root, so the
+ * compiled group merges each node's outputs: the Core service plus the
+ * store (with `DbBackend` and the single `Logging` install), the embedder
+ * registry, hybrid retrieval, and the job stack (runtime, registry, durable
+ * engine, persistence, queue factory). The workers node contributes no
+ * 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>;
 /**
  * Config-driven variant — the `dimple.jsonc` path (the SDK's
  * `makeDimple({ config })`): reads the resolved `DimpleConfig` from
@@ -18,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/unstable/persistence/PersistedQueue").PersistedQueueFactory | import("effect/unstable/persistence/Persistence").Persistence | Logging | DbBackend | JobRuntime | JobRegistry | Store | EmbeddingModelRegistry | HybridRetrieval | Service | import("effect/unstable/workflow/WorkflowEngine").WorkflowEngine, CoreConfigError | EmbeddingError | import("./internal/retriever/index.js").HybridError | import("./internal/workflow/index.js").RegistryError | import("effect/unstable/sql/SqlError").SqlError | import("./internal/store/index.js").StoreError, import("effect/Scope").Scope | ConfigService>;
+}) => 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>;

package/dist/internal/embedder/auto-install.d.ts

@@ -0,0 +1,28 @@
+/**
+ * First-use auto-install of the OPTIONAL `@huggingface/transformers` peer.
+ *
+ * `@huggingface/transformers` is an optional peer (its tree pulls the
+ * `sharp` + `onnxruntime-node` install scripts, which npm 12 blocks by
+ * default and npm 11 runs with an advisory warning — npm RFC #0054). When
+ * the config declares a `transformers` provider model,
+ * the intent is explicit — so the FIRST local-embed use installs the
+ * package automatically with the project's own package manager, instead
+ * of failing with a manual step.
+ *
+ * Thin wrapper over the shared `@dimple/installer` machinery (manager
+ * detection, script-skipping argv, timeout-kill, in-flight dedup, win32
+ * shims, pnpm `-w`); failures map onto the typed `EmbeddingError` with
+ * the manual command.
+ */
+import { Effect } from "effect";
+import { EmbeddingError } from "./provider.ts";
+import { type PackageManager } from "../installer/index.js";
+export type { InstallTarget, PackageManager } from "../installer/index.js";
+export { detectPackageManager } from "../installer/index.js";
+/** The install argv for a manager with the transformers package (kept for
+ * callers/tests that assert the shape). */
+export declare const installCommand: (pm: PackageManager) => readonly [string, ...string[]];
+/** Install transformers at the project root detected from `cwd`. The
+ * shared installer kills the child on timeout and dedups concurrent
+ * first-use installs; failures fail typed with the manual command. */
+export declare const installTransformers: (cwd: string) => Effect.Effect<void, EmbeddingError>;

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

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

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

@@ -8,3 +8,10 @@ export interface ModelSpec {
     readonly apiKey?: string;
 }
 export declare const layer: (...models: ModelSpec[]) => Layer.Layer<Service, EmbeddingError>;
+/**
+ * Node declaration over `layer`, for the composition root: the graph wires
+ * the dependencies, so `deps` stays empty here. The variadic model list is
+ * the declaration's whole configuration — no `node` default, because an
+ * empty registry has no models and `defaultModelId` fails typed.
+ */
+export declare const configured: (...models: ModelSpec[]) => import("../core/index.js").LayerProvider<Service, EmbeddingError, undefined>;

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

@@ -1,16 +1,54 @@
 import { Config, Layer } from "effect";
-import type { DeviceType } from "@huggingface/transformers";
 import { Service, type EmbeddingModel } from "./provider.ts";
+/** 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). */
+interface OrtSessionOptions {
+    readonly executionProviders: readonly [
+        {
+            readonly name: string;
+            readonly device_id: number;
+            readonly gpu_mem_limit?: number;
+            readonly arena_extend_strategy?: 0 | 1;
+        }
+    ];
+}
+/** 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: {
+    readonly gpuMemLimit?: number | undefined;
+    readonly arenaExtendStrategy?: 0 | 1 | undefined;
+}) => OrtSessionOptions;
 interface TransformersOptions {
     readonly modelId?: string;
     readonly device?: DeviceType;
-    readonly dtype?: "fp32" | "fp16" | "q8" | "q4";
+    readonly dtype?: "fp32" | "fp16" | "q8" | "int8" | "uint8" | "q4" | "bnb4" | "q4f16" | "q2" | "q2f16" | "q1" | "q1f16";
     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;
+    };
     /** Declared output dimension — validated against the model's actual
      * output on first embed (a mismatch fails typed, precisely). */
     readonly dimensions?: number;
+    /** First-use auto-install of the optional `@huggingface/transformers`
+     * peer (default true): the config declaring a transformers provider is
+     * explicit intent — the missing package is installed with the project's
+     * own package manager (scripts skipped; proven unnecessary for
+     * embedding). Set false to require a manual install. */
+    readonly autoInstall?: boolean;
 }
 export declare const makeTransformersModel: (options?: TransformersOptions) => EmbeddingModel;
 export declare const layer: (options?: TransformersOptions) => Layer.Layer<Service>;

package/dist/internal/extractor/code-extractor.d.ts

@@ -1,5 +1,5 @@
 import { Context, Effect, Layer } from "effect";
-import type { TreeHandle } from "./internal/parser/index.js";
+import type { TreeHandle } from "../parser/index.js";
 import { ExtractedFile, ExtractionError } from "./models/extraction";
 export interface ExtractRequest {
     readonly filePath: string;
@@ -12,4 +12,14 @@ declare const Service_base: Context.ServiceClass<Service, "@dimple/extractor/Cod
 export declare class Service extends Service_base {
 }
 export declare const layer: Layer.Layer<Service, never, never>;
+/**
+ * Layer-graph declaration for `CodeExtractor`. The layer has no
+ * requirements of its own (a `TreeHandle` is passed per call, not
+ * injected), so `deps` stays empty and the composition root wires the
+ * parser that produces those handles.
+ */
+export declare const configured: () => import("../core/index.js").LayerProvider<Service, never, undefined>;
+/** The default declaration — the live implementation the composition root
+ * picks unless it replaces this node. */
+export declare const node: import("../core/index.js").LayerProvider<Service, never, undefined>;
 export {};

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

@@ -1,4 +1,4 @@
-export { Service as CodeExtractor, layer as codeExtractorLayer } from "./code-extractor";
+export { Service as CodeExtractor, layer as codeExtractorLayer, configured as codeExtractorConfigured, node as codeExtractorNode, } from "./code-extractor";
 export type { ExtractRequest } from "./code-extractor";
 export { ExtractedFile, ExtractedChunk, ImportInfo, ExtractionError } from "./models/extraction";
 export { Service as ContentHandler, layer as contentHandlerLayer, ContentError, } from "./content-handler";

package/dist/internal/extractor/languages/index.d.ts

@@ -1,4 +1,4 @@
-import type { TreeHandle } from "./internal/parser/index.js";
+import type { TreeHandle } from "../../parser/index.js";
 import type { ExtractedChunk, ImportInfo } from "../models/extraction";
 import { ExtractionError } from "../models/extraction";
 /**

package/dist/internal/extractor/languages/javascript.d.ts

@@ -1,4 +1,4 @@
-import type { TreeHandle } from "./internal/parser/index.js";
+import type { TreeHandle } from "../../parser/index.js";
 import type { ExtractedChunk, ImportInfo } from "../models/extraction";
 /**
  * Extract chunks and imports from a JavaScript/JSX file.

package/dist/internal/extractor/languages/typescript.d.ts

@@ -1,4 +1,4 @@
-import type { TreeHandle } from "./internal/parser/index.js";
+import type { TreeHandle } from "../../parser/index.js";
 import type { ExtractedChunk, ImportInfo } from "../models/extraction";
 /**
  * Extract chunks and imports from a TypeScript/TSX file.

package/dist/internal/extractor/models/extraction.d.ts

@@ -15,6 +15,13 @@ export declare const ExtractedChunk: Schema.Struct<{
     readonly endLine: Schema.Number;
     readonly language: Schema.String;
     readonly docstring: Schema.optional<Schema.String>;
+    /** Call sites inside this definition — the code_calls edge source:
+     * `[{ name, line }]`, callee names only (member/property calls unwrap
+     * to the property name). */
+    readonly calls: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly name: Schema.String;
+        readonly line: Schema.Number;
+    }>>>;
 }>;
 export interface ExtractedChunk extends Schema.Schema.Type<typeof ExtractedChunk> {
 }
@@ -40,6 +47,13 @@ export declare const ExtractedFile: Schema.Struct<{
         readonly endLine: Schema.Number;
         readonly language: Schema.String;
         readonly docstring: Schema.optional<Schema.String>;
+        /** Call sites inside this definition — the code_calls edge source:
+         * `[{ name, line }]`, callee names only (member/property calls unwrap
+         * to the property name). */
+        readonly calls: Schema.optional<Schema.$Array<Schema.Struct<{
+            readonly name: Schema.String;
+            readonly line: Schema.Number;
+        }>>>;
     }>>;
     readonly imports: Schema.optional<Schema.$Array<Schema.Struct<{
         readonly source: Schema.String;

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

@@ -0,0 +1,37 @@
+export type PackageManager = "bun" | "npm" | "pnpm" | "yarn";
+export interface InstallTarget {
+    readonly pm: PackageManager;
+    readonly root: string;
+}
+export declare class InstallerError extends Error {
+    constructor(message: string);
+}
+/** Detect the project's package manager by walking UP from `cwd` for a
+ * lockfile. NO lockfile → npm (the most universal — a bun fallback broke
+ * Node-only machines with ENOENT). */
+export declare const detectPackageManager: (cwd: string) => InstallTarget;
+/** The executable name for a manager. win32 ships `.cmd` shims for
+ * npm/pnpm/yarn — the bare names fail with ENOENT. */
+export declare const resolveExecutable: (pm: PackageManager, platform?: NodeJS.Platform) => string;
+/** The base install argv for a manager. Scripts are skipped everywhere;
+ * pnpm at a workspace root additionally gets `-w`. */
+export declare const installArgs: (pm: PackageManager, packages: readonly string[], root: string) => string[];
+/** The slice of a spawned child the installer uses; tests inject a fake. */
+export interface InstallChild {
+    on(event: "error", listener: (cause: Error) => void): void;
+    on(event: "exit", listener: (code: number | null, signal: string | null) => void): void;
+    kill(signal?: NodeJS.Signals): boolean;
+}
+export interface InstallOptions {
+    readonly cwd?: string;
+    /** Hard deadline; the child is SIGKILLed when it trips (default 5 min). */
+    readonly timeoutMs?: number;
+    /** Injectable for tests (defaults to process.platform). */
+    readonly platform?: NodeJS.Platform;
+    /** Injectable for tests; defaults to `node:child_process.spawn`. */
+    readonly spawnImpl?: (command: string, args: readonly string[], options: {
+        readonly cwd: string;
+        readonly stdio: "ignore";
+    }) => InstallChild;
+}
+export declare const installOptionalPeers: (packages: readonly string[], opts?: InstallOptions) => Promise<void>;

package/dist/internal/llm/dream-classifier.d.ts

@@ -1,5 +1,5 @@
 import type { LLM } from "./llm.ts";
-import type { DreamClassifier } from "./internal/store/index.js";
+import type { DreamClassifier } from "../store/index.js";
 /**
  * Builds a `DreamClassifier` from a generic `LLM`. `modelId` (when given)
  * is mentioned in the system prompt so the model knows which embedding

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

@@ -1,4 +1,4 @@
 export { LLMError, makeLLM, type GenerateTextInput, type GenerateObjectInput, type LLM, } from "./llm.ts";
 export { openAICompatible, type OpenAICompatibleOptions } from "./provider.ts";
 export { makeDreamClassifier } from "./dream-classifier.ts";
-export { Service as LLMService, type Interface as LLMServiceInterface, type LLMOptions, layer as llmLayer, layerConfig as llmLayerConfig, layerFromConfig as llmLayerFromConfig, } from "./service.ts";
+export { Service as LLMService, type Interface as LLMServiceInterface, type LLMOptions, layer as llmLayer, layerConfig as llmLayerConfig, layerFromConfig as llmLayerFromConfig, configured as llmConfigured, } from "./service.ts";

package/dist/internal/llm/service.d.ts

@@ -1,5 +1,5 @@
 import { Config, Context, Layer } from "effect";
-import { Service as ConfigService } from "./internal/config/index.js";
+import { Service as ConfigService } from "../config/index.js";
 import { type LLM, type LLMDefaults } from "./llm.ts";
 /**
  * Connection options for the OpenAI-compatible LLM layer: the chat
@@ -26,4 +26,10 @@ export declare const layerConfig: (config: Config.Wrap<LLMOptions>) => Layer.Lay
  * section). Fails with a clear error when the section is absent.
  */
 export declare const layerFromConfig: () => Layer.Layer<Service, Error, ConfigService>;
+/**
+ * Node declaration over `layer`, for the composition root: the graph wires
+ * the dependencies, so `deps` stays empty here. `LLMOptions` is all-required
+ * (endpoint, key, model), so there is no `node` default to declare.
+ */
+export declare const configured: (options: LLMOptions) => import("../core/index.js").LayerProvider<Service, never, undefined>;
 export {};

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

@@ -1,4 +1,4 @@
-export { Service as Logging, layer as loggingLayer, layerConfig as loggingLayerConfig, make as makeLogging, consoleSink, fileSink, effectLogger, type Sink, type Interface as LoggingInterface, type StructuredOutput, } from "./service.ts";
+export { Service as Logging, layer as loggingLayer, layerConfig as loggingLayerConfig, configured as loggingConfigured, node as loggingNode, silentConfig as loggingSilentConfig, makeEffect as makeLogging, consoleSink, fileSink, effectLogger, type Sink, type Interface as LoggingInterface, type StructuredOutput, } from "./service.ts";
 export { LogConfig, LogLevel, SEV_NUM, LEVEL_ORDER, type LogEntry } from "./types.ts";
 export { RingBuffer, type RingFrame, type Subscriber } from "./ring.ts";
 export { renderJson, renderPretty } from "./format.ts";