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

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/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

@@ -1,4 +1,4 @@
-import { type EmbeddingModel } from "./internal/embedder/index.js";
+import { type EmbeddingModel } from "../embedder/index.js";
 export interface HostedEmbeddingOptions {
     readonly modelId: string;
     readonly model: string;

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

@@ -1,10 +1,28 @@
-import { type PackageManager } from "./internal/installer/index.js";
-export type { InstallTarget, PackageManager } from "./internal/installer/index.js";
-export { detectPackageManager } from "./internal/installer/index.js";
+/**
+ * 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 reject with the manual command. */
-export declare const installTransformers: (cwd: string) => Promise<void>;
+ * 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,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 registryLayer, type ModelSpec } from "./registry.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

@@ -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/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/installer/index.d.ts

@@ -16,11 +16,22 @@ export declare const resolveExecutable: (pm: PackageManager, platform?: NodeJS.P
 /** 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, makeEffect 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";

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

@@ -32,7 +32,7 @@ export interface Interface {
 declare const Service_base: Context.ServiceClass<Service, "@dimple/logger/Logging", Interface>;
 export declare class Service extends Service_base {
 }
-/** Effect variant of `make` — builds the file sink through lazy `node:fs`
+/** Effect variant of the sync logger factory — builds the file sink through lazy `node:fs`
  * (see `fileSink`; the console sink is sync). */
 export declare const makeEffect: (config: LogConfig) => Effect.Effect<Interface>;
 /** Effect log messages: strings pass through, arrays are joined, anything
@@ -60,10 +60,21 @@ export interface StructuredOutput {
 export declare const effectLogger: (logging: Interface) => Logger.Logger<unknown, void>;
 /** Installs the Logging service AND replaces Effect's default logger with
  * the adapter feeding it. `mergeWithExisting: false` — one logger
- * everywhere (the job runtime emits through this too). */
-export declare const layer: (config: LogConfig) => Layer.Layer<Service, never, Scope>;
+ * everywhere (the job runtime emits through this too). The acquisition is
+ * scope-owned (`Layer.effect` strips the build `Scope`), so the layer has no
+ * requirements of its own. */
+export declare const layer: (config: LogConfig) => Layer.Layer<Service, never>;
 /** Config-driven variant (the repo convention): `layerConfig(config)` or
  * `layerConfig(Config.succeed({...}))` — resolves the config inside the
  * layer and delegates to `layer` (no Effect.runSync in package sources). */
 export declare const layerConfig: (config: Config.Wrap<LogConfig>) => Layer.Layer<Service, Config.ConfigError, Scope>;
+/** Silent-by-default logging config: the Logging service is always
+ * available, and `layer` sets Effect's minimum-level filter to "None" so
+ * every log is short-circuited at the source. The single silent config
+ * consumed by @dimple/core and @dimple/store. */
+export declare const silentConfig: LogConfig;
+/** The Logging layer-graph node. `deps` stays empty — the composition root
+ * wires dependencies, per the layer-graph convention. */
+export declare const configured: (config?: LogConfig) => import("../core/index.js").LayerProvider<Service, never, undefined>;
+export declare const node: import("../core/index.js").LayerProvider<Service, never, undefined>;
 export {};

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

@@ -1,12 +1,22 @@
 import { Context, Effect, Layer } from "effect";
 import { TreeHandle } from "./models/treeHandle";
 import type { ParseRequest } from "./models/parseRequest";
-import { ParseError } from "@dimple/shared/errors";
+import { ParseError } from "../shared/errors/index.js";
 export interface Interface {
     readonly parse: (request: ParseRequest) => Effect.Effect<TreeHandle, ParseError>;
 }
 declare const Service_base: Context.ServiceClass<Service, "@dimple/parser/CodeParser", Interface>;
 export declare class Service extends Service_base {
 }
-export declare const layer: Layer.Layer<Service, import("@dimple/shared/errors").ParserInitError, never>;
+export declare const layer: Layer.Layer<Service, import("../shared/errors/index.js").ParserInitError, never>;
+/**
+ * Layer-graph declaration for `CodeParser`. `layer` is already
+ * self-contained — it provides `languageStoreLayer`, which in turn provides
+ * the wasm grammar store and the tree-sitter engine — so `deps` stays empty
+ * and the composition root wires the rest of the system.
+ */
+export declare const configured: () => import("../core/index.js").LayerProvider<Service, import("../shared/errors/index.js").ParserInitError, 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, import("../shared/errors/index.js").ParserInitError, undefined>;
 export {};

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

@@ -1,7 +1,7 @@
-export { Service as CodeParser, layer as codeParserLayer } from "./code-parser";
+export { Service as CodeParser, layer as codeParserLayer, configured as codeParserConfigured, node as codeParserNode, } from "./code-parser";
 export { Service as LanguageStore, layer as languageStoreLayer } from "./language-store";
 export { layer as treeSitterEngineLayer } from "./tree-sitter-engine";
 export { ParseRequest } from "./models/parseRequest";
 export { TreeHandle, TreeSchema } from "./models/treeHandle";
-export type { LanguageId } from "@dimple/shared/types/language";
-export { ParserInitError, LanguageLoadError, ParseError } from "@dimple/shared/errors";
+export type { LanguageId } from "../shared/types/language.js";
+export { ParserInitError, LanguageLoadError, ParseError } from "../shared/errors/index.js";

package/dist/internal/parser/language-store.d.ts

@@ -1,6 +1,6 @@
 import { Context, Effect, Layer } from "effect";
-import type { LanguageId } from "@dimple/shared/types/language";
-import { LanguageLoadError } from "@dimple/shared/errors";
+import type { LanguageId } from "../shared/types/language.js";
+import { LanguageLoadError } from "../shared/errors/index.js";
 import { Language } from "web-tree-sitter";
 export interface Interface {
     readonly get: (lang: LanguageId) => Effect.Effect<Language, LanguageLoadError>;
@@ -8,5 +8,5 @@ export interface Interface {
 declare const Service_base: Context.ServiceClass<Service, "@dimple/parser/LanguageStore", Interface>;
 export declare class Service extends Service_base {
 }
-export declare const layer: Layer.Layer<Service, import("@dimple/shared/errors").ParserInitError, never>;
+export declare const layer: Layer.Layer<Service, import("../shared/errors/index.js").ParserInitError, never>;
 export {};

package/dist/internal/parser/tree-sitter-engine.d.ts

@@ -1,5 +1,5 @@
 import { Layer } from "effect";
-import { ParserInitError } from "@dimple/shared/errors";
+import { ParserInitError } from "../shared/errors/index.js";
 /**
  * Tree-sitter engine initialization — the ORIGINAL design: `Parser.init()`
  * with no override, so web-tree-sitter's glue resolves `tree-sitter.wasm`

package/dist/internal/retriever/hybrid.d.ts

@@ -1,7 +1,8 @@
 import { Context, Effect, Layer, Schema } from "effect";
-import { EmbeddingModelRegistry } from "./internal/embedder/index.js";
-import { Store as StoreService } from "./internal/store/index.js";
-import type { AugmentedMemory } from "./internal/store/index.js";
+import { type Graph } from "../shared/effect/node.js";
+import { EmbeddingModelRegistry } from "../embedder/index.js";
+import { Store as StoreService } from "../store/index.js";
+import type { AugmentedMemory } from "../store/index.js";
 declare const HybridError_base: Schema.Class<HybridError, Schema.TaggedStruct<"HybridRetrieval.HybridError", {
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
@@ -33,16 +34,29 @@ export interface Interface {
 declare const Service_base: Context.ServiceClass<Service, "@dimple/retriever/HybridRetrieval", Interface>;
 export declare class Service extends Service_base {
 }
+/** Retrieval defaults for `layer` and the `configured` node; both fields are
+ * optional, and an omitted field falls back to the built-in default
+ * (k = 60, limit = 10). */
+export interface HybridRetrievalOptions {
+    readonly defaultK?: number;
+    readonly defaultLimit?: number;
+}
 /**
  * Layer factory: `hybridRetrievalLayer()` (no args) is the default
  * instance; pass `{ defaultK, defaultLimit }` to override the retrieval
  * defaults (the config path threads `defaultK`/`defaultLimit`).
  */
-export declare const layer: (options?: {
-    readonly defaultK?: number;
-    readonly defaultLimit?: number;
-}) => Layer.Layer<Service, HybridError, StoreService | EmbeddingModelRegistry>;
+export declare const layer: (options?: HybridRetrievalOptions) => Layer.Layer<Service, HybridError, StoreService | EmbeddingModelRegistry>;
 /** Default instance (no option overrides) — the classic const consumers
  * (tests, compositions) keep working; the factory form stays available. */
 export declare const hybridRetrievalLayer: Layer.Layer<Service, HybridError, StoreService | EmbeddingModelRegistry>;
+/**
+ * Node declaration over the factory, for the composition root. The `Store` and
+ * `EmbeddingModelRegistry` providers are dependencies the root owns (the
+ * retriever package has no default store or embedder), so the caller passes
+ * them as the `deps` tuple; `make` then checks that they cover the layer's
+ * requirements. The tuple elements may be any graph that provides at least the
+ * named service, and their build errors are preserved on the node.
+ */
+export declare const configured: <const StoreE, const RegistryE>(options: HybridRetrievalOptions | undefined, deps: readonly [Graph<StoreService, StoreE>, Graph<EmbeddingModelRegistry, RegistryE>]) => import("../core/index.js").LayerProvider<Service, RegistryE | StoreE | HybridError, undefined>;
 export {};

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

@@ -1,3 +1,3 @@
-export { Service as HybridRetrieval, layer as hybridRetrievalLayerFactory, hybridRetrievalLayer, HybridError, type QueryProfile, } from "./hybrid.ts";
+export { Service as HybridRetrieval, layer as hybridRetrievalLayerFactory, hybridRetrievalLayer, configured as hybridRetrievalConfigured, HybridError, type HybridRetrievalOptions, type QueryProfile, } from "./hybrid.ts";
 export { fuse } from "./rrf.ts";
 export type { RankResult } from "./rrf.ts";

package/dist/internal/shared/effect/node.d.ts

@@ -0,0 +1,155 @@
+import { Brand, Context, Layer } from "effect";
+/** The reference exposes its whole surface as one value namespace
+ * (`import { LayerNode } from "@opencode/util/effect/layer-node"`); dimple's
+ * module IS that surface, so the same name is exported here. */
+export * as LayerNode from "./node.ts";
+/**
+ * Typed layer graphs, ported from OpenCode v2's `LayerNode`
+ * (`packages/util/src/effect/layer-node.ts`).
+ *
+ * A graph is a node (`make`) or an ordered group (`group`). A node carries a
+ * service or name, an implementation layer, the nodes it depends on, and an
+ * optional tag. `compile` resolves the effective graph (applying
+ * replacements, rejecting cycles and unbound nodes), shares builds through
+ * Effect's memo maps, and infers the output layer from the declarations —
+ * there is no caller-stated cast.
+ *
+ * Type-level checks reject a node whose `deps` do not provide every service
+ * its layer requires, a replacement that drops outputs, widens errors, or
+ * crosses tags, and a group output that is not promised by every root. All
+ * declarations stay lazy: nothing is acquired until Effect builds the
+ * compiled layer.
+ */
+declare const GraphTypeId: unique symbol;
+declare const VarianceTypeId: unique symbol;
+declare const NodeTypeId: unique symbol;
+declare const ReplacementTypeId: unique symbol;
+export type Tag<Name extends string = string> = Name & Brand.Brand<"LayerNode.Tag">;
+export type Graph<A, E = never, T extends Tag | undefined = Tag | undefined> = GraphValue<A, E, T>;
+export type Node<A, E = never, T extends Tag | undefined = undefined> = NodeValue<A, E, T>;
+export type Provider<A, E = never, T extends Tag | undefined = undefined> = ProviderNode<A, E, T>;
+export type Replacement = ReplacementValue;
+export type Replacements = readonly Replacement[];
+type AnyGraph = Graph<never, unknown>;
+type AnyNode = AnyGraph & {
+    readonly [NodeTypeId]: unknown;
+    readonly tag: Tag | undefined;
+};
+type RuntimeLayer = Layer.Layer<never, unknown, unknown>;
+type GraphList = readonly [] | readonly [AnyGraph, ...AnyGraph[]];
+export type Output<Item> = CommonOutput<Item, Item extends Graph<infer A, unknown> ? A : never>;
+export type Error<Item> = Item extends Graph<never, infer E> ? E : never;
+type GraphTag<Item> = [Item] extends [never] ? undefined : Item extends Graph<never, unknown, infer T> ? T : never;
+type CommonOutput<Item, A> = A extends unknown ? [Item] extends [Graph<A, unknown>] ? A : never : never;
+type LayerOutput<Item extends Layer.Any, A = Layer.Success<Item>> = A extends unknown ? [Item] extends [Layer.Layer<A, unknown, unknown>] ? A : never : never;
+type ListOutput<Items extends readonly AnyGraph[], A = never> = [Items] extends [
+    readonly [infer Head extends AnyGraph, ...infer Tail extends readonly AnyGraph[]]
+] ? ListOutput<Tail, A | Output<Head>> : A;
+type Definition = {
+    readonly kind: "group";
+    readonly name: string;
+    readonly dependencies: readonly AnyGraph[];
+} | {
+    readonly kind: "unbound";
+    readonly name: string;
+} | {
+    readonly kind: "layer";
+    readonly name: string;
+    readonly implementation: RuntimeLayer;
+    readonly dependencies: readonly AnyGraph[];
+};
+declare class GraphValue<in A, out E, out T extends Tag | undefined> {
+    private readonly graph;
+    readonly [VarianceTypeId]: {
+        readonly output: (_: A) => void;
+        readonly error: () => E;
+        readonly tags: () => T;
+    };
+    readonly [GraphTypeId]: Definition;
+    constructor(definition: Definition);
+    get name(): string;
+}
+declare class NodeValue<in out A, in out E, in out T extends Tag | undefined> extends GraphValue<A, E, T> {
+    readonly tag: T;
+    readonly [NodeTypeId]: (_: [A, E, T]) => [A, E, T];
+    constructor(definition: Exclude<Definition, {
+        kind: "group";
+    }>, tag: T);
+    /** Replace this declaration, including every dependency on it, without acquiring its old wiring. */
+    replace<const Target extends AnyNode | Layer.Any>(this: Node<A, E, T>, replacement: Target & CheckReplacement<A, E, T, Target>): Replacement;
+}
+declare class ProviderNode<in out A, in out E, in out T extends Tag | undefined> extends NodeValue<A, E, T> {
+    /** Decorate the implementation while preserving its dependency wiring and service contract. */
+    mapLayer(this: Provider<A, E, T>, f: <R>(layer: Layer.Layer<A, E, R>) => Layer.Layer<A, E, R>): Provider<A, E, T>;
+}
+declare class ReplacementValue {
+    private readonly checked;
+    readonly [ReplacementTypeId]: {
+        readonly source: AnyNode;
+        readonly target: AnyNode;
+    };
+    constructor(source: AnyNode, target: AnyNode);
+}
+type CheckErrors<Expected, Actual> = [Exclude<Actual, Expected>] extends [never] ? never : {
+    readonly "New replacement errors": Exclude<Actual, Expected>;
+};
+type CheckReplacement<A, E, T, Target> = [ReplacementErrors<A, E, T, Target>] extends [never] ? unknown : ReplacementErrors<A, E, T, Target>;
+type ReplacementErrors<A, E, T, Target> = Target extends AnyNode ? [Exclude<A, Output<Target>>] extends [never] ? [GraphTag<Target>] extends [T] ? CheckErrors<E, Error<Target>> : {
+    readonly "Invalid replacement tag": GraphTag<Target>;
+} : {
+    readonly "Missing replacement outputs": Exclude<A, Output<Target>>;
+} : Target extends Layer.Layer<A, infer E2, never> ? CheckErrors<E, E2> : {
+    readonly "Replacement must be a closed layer": Target;
+};
+type CheckDependencies<Implementation extends Layer.Any, Items extends GraphList> = [
+    Exclude<Layer.Services<Implementation>, ListOutput<Items>>
+] extends [never] ? unknown : {
+    readonly "Missing dependencies": Exclude<Layer.Services<Implementation>, ListOutput<Items>>;
+};
+type Identity = {
+    readonly service: Context.Service.Any;
+    readonly name?: never;
+} | {
+    readonly name: string;
+    readonly service?: never;
+};
+type CheckLayer<Implementation> = [Implementation] extends [RuntimeLayer] ? unknown : {
+    readonly "Layer contract must be preserved": Implementation;
+};
+type TagInput<T> = {
+    readonly tag: T;
+} | ([T] extends [undefined] ? {
+    readonly tag?: undefined;
+} : never);
+type MakeInput<Implementation extends Layer.Any, Items extends GraphList, T extends Tag | undefined> = Identity & TagInput<T> & {
+    readonly layer: Implementation & CheckLayer<NoInfer<Implementation>>;
+    readonly deps: Items & CheckDependencies<Implementation, NoInfer<Items>>;
+};
+type DistributiveOmit<A, K extends PropertyKey> = A extends unknown ? Omit<A, K> : never;
+export type TagConfig = Readonly<Record<string, readonly string[]>>;
+type TagNames<Config extends TagConfig> = keyof Config & string;
+type CheckTags<Items extends GraphList, Names extends string> = [
+    Exclude<GraphTag<Items[number]>, Tag<Names> | undefined>
+] extends [never] ? unknown : {
+    readonly "Invalid tag dependencies": Exclude<GraphTag<Items[number]>, Tag<Names> | undefined>;
+};
+export interface Tags<Config extends TagConfig> {
+    readonly values: {
+        readonly [Name in TagNames<Config>]: Tag<Name>;
+    };
+    readonly make: <Name extends TagNames<Config>>(name: Name) => <const Implementation extends Layer.Any, const Items extends GraphList>(input: DistributiveOmit<MakeInput<Implementation, Items, Tag<Name>>, "tag"> & CheckTags<Items, Name | Extract<Config[Name][number], string>>) => Provider<LayerOutput<Implementation>, Layer.Error<Implementation> | Error<Items[number]>, Tag<Name>>;
+}
+export declare function tags<const Config extends {
+    readonly [Name in keyof Config]: readonly (keyof Config & string)[];
+}>(config: Config): Tags<Config>;
+export declare function make<const Implementation extends Layer.Any, const Items extends GraphList, const T extends Tag | undefined = undefined>(input: MakeInput<Implementation, Items, T>): Provider<LayerOutput<Implementation>, Layer.Error<Implementation> | Error<Items[number]>, T>;
+export declare function unbound<R, S, const T extends Tag>(service: Context.Key<R, S>, tag: T): Node<R, never, T>;
+/** Ordered, associative composition. Only these roots' outputs are exposed; their dependencies remain private. */
+export declare function group<const Items extends readonly AnyGraph[]>(dependencies: Items): Graph<ListOutput<Items>, Error<Items[number]>, GraphTag<Items[number]>>;
+export interface CompileOptions {
+    readonly replacements?: Replacements;
+    /** Share subgraphs rooted at this tag; give the remaining wiring a fresh map for each build. */
+    readonly shared?: Tag;
+}
+/** Resolve the final overrides before validating or acquiring anything. Effect owns acquisition and finalization. */
+export declare function compile<A, E>(root: Graph<A, E>, options?: CompileOptions): Layer.Layer<A, E>;

package/dist/internal/shared/file-database.d.ts

@@ -0,0 +1,17 @@
+/**
+ * File-local database preparation shared by the store and jobs backends:
+ * create the parent directory libSQL cannot, then restrict the database file
+ * and its sidecars to the owner (`0600`).
+ *
+ * SQLite creates new sidecars (`-journal`, `-wal`, `-shm`) with the
+ * database's own mode, so restricting the database file also covers sidecars
+ * created later. Any existing mode is overridden — an old permissive file is
+ * tightened on the next boot, and a file the process can write but cannot
+ * chmod fails the boot instead of running permissively.
+ *
+ * Reference: opencode v2's `Database` layer (`restrictToOwner`) — a
+ * local-first store must not be world-readable under a permissive umask.
+ * `node:fs` is imported lazily and remote URLs are untouched, so the module
+ * stays bundler-safe for workerd.
+ */
+export declare const prepareFileDatabase: (url: string) => Promise<void>;