@ponraaj/dimple-sdk 0.0.0-alpha.1

package/dist/indexer.d.ts

@@ -0,0 +1,43 @@
+import type { LanguageId } from "./internal/parser/index.js";
+/**
+ * The platform side of `Dimple.index` — directory walking + capped reads
+ * + extension→language mapping. Isolated here (and exempted from the
+ * no-node-apis lint rule as platform code) so the facade stays pure.
+ *
+ * `walkFiles` is SYNC on purpose: indexing is an offline batch operation,
+ * and a sync walk keeps per-file ordering deterministic. It never throws —
+ * stat/read failures become per-file entries the facade surfaces.
+ */
+/** Extensions mapped to tree-sitter languages the extractor understands. */
+export declare const INDEXABLE_EXTENSIONS: readonly string[];
+export declare const languageForPath: (path: string) => LanguageId | undefined;
+export interface WalkResult {
+    /** Files that will be parsed (supported extension, within included dirs). */
+    readonly files: readonly string[];
+    /** Files skipped because the extension is not indexable (count only). */
+    readonly unsupported: number;
+    /** Files that could not be stat'd/read (broken symlinks, permissions). */
+    readonly errors: readonly {
+        readonly filePath: string;
+        readonly message: string;
+    }[];
+    /** Key root — keys are made relative to it. Anchored at the CWD so the
+     * SAME file always gets the SAME key regardless of which path list was
+     * passed (idempotent re-indexing across invocation shapes). */
+    readonly root: 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;
+/** Resolve a file's relative import specifiers to indexed-tree files
+ * (bare/absolute specifiers are external modules — no node_modules
+ * resolution). */
+export declare const resolveImports: (filePath: string, sources: readonly string[], extensions: readonly string[]) => readonly string[];
+/** Longest common ancestor of the resolved input paths — keys are made
+ * relative to it so they stay stable across runs and cwds (indexing the
+ * same tree twice yields the same keys → idempotent re-index). */
+export declare const commonRoot: (paths: readonly string[]) => string;
+/** Relative path for keys: strip the common root so keys are stable across
+ * runs (indexing the same tree from a different cwd yields the same keys). */
+export declare const keyForPath: (root: string, filePath: string) => string;

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

@@ -0,0 +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 { loadConfig, loadConfigFromFile } from "./loader.ts";

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

@@ -0,0 +1,9 @@
+import { Effect } from "effect";
+import { type DimpleConfig as DimpleConfigType } from "./schema.ts";
+/** Resolve a config from an EXPLICIT file path — the SDK's `config:
+ * "path/to/dimple.jsonc"` input. Merges the standard defaults and
+ * `${ENV_VAR}` resolution over the file's content. Strict JSONC: parser
+ * errors (missing braces, trailing garbage) reject the file instead of
+ * silently booting from the valid prefix. */
+export declare const loadConfigFromFile: (path: string) => Effect.Effect<DimpleConfigType, Error>;
+export declare const loadConfig: (overrides?: Partial<DimpleConfigType>) => Effect.Effect<DimpleConfigType, Error>;

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

@@ -0,0 +1,176 @@
+import { Schema } from "effect";
+export declare const IndexConfig: Schema.Struct<{
+    readonly compressNeighbors: Schema.optional<Schema.String>;
+    readonly maxNeighbors: Schema.optional<Schema.Number>;
+    readonly searchL: Schema.optional<Schema.Number>;
+}>;
+export interface IndexConfig extends Schema.Schema.Type<typeof IndexConfig> {
+}
+export declare const EmbeddingModelConfig: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly provider: Schema.String;
+    readonly model: Schema.String;
+    readonly dimensions: Schema.Number;
+    readonly vectorType: Schema.optional<Schema.String>;
+    readonly apiKey: 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>;
+    }>>;
+}>;
+export interface EmbeddingModelConfig extends Schema.Schema.Type<typeof EmbeddingModelConfig> {
+}
+export declare const EmbeddingConfig: Schema.Struct<{
+    readonly defaultModel: Schema.String;
+    readonly models: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly provider: Schema.String;
+        readonly model: Schema.String;
+        readonly dimensions: Schema.Number;
+        readonly vectorType: Schema.optional<Schema.String>;
+        readonly apiKey: 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>;
+        }>>;
+    }>>;
+}>;
+export interface EmbeddingConfig extends Schema.Schema.Type<typeof EmbeddingConfig> {
+}
+export declare const JobsConfig: Schema.Struct<{
+    readonly dbUrl: Schema.optional<Schema.String>;
+    readonly execution: Schema.optional<Schema.Literals<readonly ["background", "inline", "external"]>>;
+    readonly concurrency: Schema.optional<Schema.Number>;
+    readonly leaseTimeoutMs: Schema.optional<Schema.Number>;
+    readonly maxAttempts: Schema.optional<Schema.refine<number, Schema.Number>>;
+    readonly pollIntervalMs: Schema.optional<Schema.Number>;
+}>;
+export interface JobsConfig extends Schema.Schema.Type<typeof JobsConfig> {
+}
+/**
+ * Topic-tree configuration. `@dimple/config` cannot import
+ * `@dimple/store` (dependency direction: store → config), so this is a
+ * structurally-identical mirror of `packages/store/src/schema/topics.ts`
+ * `TopicConfig` — keep the two in sync. Decoding fills the same defaults, so
+ * a decoded `TopicsConfig` is assignable to the store's `TopicConfig`.
+ */
+export declare const TopicsConfig: Schema.Struct<{
+    readonly maxLeafItems: Schema.withDecodingDefaultType<Schema.optional<Schema.Number>, never>;
+    readonly minLeafItems: Schema.withDecodingDefaultType<Schema.optional<Schema.Number>, never>;
+    readonly maxChildren: Schema.withDecodingDefaultType<Schema.optional<Schema.Number>, never>;
+    readonly minChildren: Schema.withDecodingDefaultType<Schema.optional<Schema.Number>, never>;
+    readonly maxDepth: Schema.withDecodingDefaultType<Schema.optional<Schema.Number>, never>;
+    readonly beamWidth: Schema.withDecodingDefaultType<Schema.optional<Schema.Number>, never>;
+    readonly splitDeferredHardLimit: Schema.withDecodingDefaultType<Schema.optional<Schema.Number>, never>;
+    readonly rebalanceCooldownMs: Schema.withDecodingDefaultType<Schema.optional<Schema.Number>, never>;
+    readonly lloydPasses: Schema.withDecodingDefaultType<Schema.optional<Schema.Number>, never>;
+}>;
+export interface TopicsConfig extends Schema.Schema.Type<typeof TopicsConfig> {
+}
+/**
+ * Topic-tree configuration mirror (structural — @dimple/config cannot
+ * import the store). Decoded by the store layer into its own GraphConfig
+ * schema, which fills every default.
+ */
+export declare const GraphConfig: Schema.Struct<{
+    readonly enabled: Schema.optional<Schema.Boolean>;
+    readonly maxDepth: Schema.optional<Schema.Number>;
+    readonly maxNeighbors: Schema.optional<Schema.Number>;
+    readonly maxTotal: Schema.optional<Schema.Number>;
+    readonly supersedeDemotion: Schema.optional<Schema.Number>;
+    readonly conflictBands: Schema.optional<Schema.Struct<{
+        readonly nearDuplicate: Schema.Number;
+        readonly conflictLow: Schema.Number;
+    }>>;
+    readonly clusterK: Schema.optional<Schema.Number>;
+    readonly clusterMinSize: Schema.optional<Schema.Number>;
+}>;
+export interface GraphConfig extends Schema.Schema.Type<typeof GraphConfig> {
+}
+export declare const LLMConfig: Schema.Struct<{
+    readonly baseURL: Schema.String;
+    readonly apiKey: Schema.String;
+    readonly modelId: Schema.String;
+    readonly temperature: Schema.optional<Schema.refine<number, Schema.Number>>;
+    readonly maxOutputTokens: Schema.optional<Schema.refine<number, Schema.Number>>;
+    readonly reasoningEffort: Schema.optional<Schema.Literals<readonly ["low", "medium", "high"]>>;
+}>;
+export interface LLMConfig extends Schema.Schema.Type<typeof LLMConfig> {
+}
+export declare const DimpleConfig: Schema.Struct<{
+    readonly storeUrl: Schema.String;
+    readonly embedding: Schema.optional<Schema.Struct<{
+        readonly defaultModel: Schema.String;
+        readonly models: Schema.$Array<Schema.Struct<{
+            readonly id: Schema.String;
+            readonly provider: Schema.String;
+            readonly model: Schema.String;
+            readonly dimensions: Schema.Number;
+            readonly vectorType: Schema.optional<Schema.String>;
+            readonly apiKey: 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>;
+            }>>;
+        }>>;
+    }>>;
+    readonly jobs: Schema.optional<Schema.Struct<{
+        readonly dbUrl: Schema.optional<Schema.String>;
+        readonly execution: Schema.optional<Schema.Literals<readonly ["background", "inline", "external"]>>;
+        readonly concurrency: Schema.optional<Schema.Number>;
+        readonly leaseTimeoutMs: Schema.optional<Schema.Number>;
+        readonly maxAttempts: Schema.optional<Schema.refine<number, Schema.Number>>;
+        readonly pollIntervalMs: Schema.optional<Schema.Number>;
+    }>>;
+    readonly topics: Schema.optional<Schema.Struct<{
+        readonly maxLeafItems: Schema.withDecodingDefaultType<Schema.optional<Schema.Number>, never>;
+        readonly minLeafItems: Schema.withDecodingDefaultType<Schema.optional<Schema.Number>, never>;
+        readonly maxChildren: Schema.withDecodingDefaultType<Schema.optional<Schema.Number>, never>;
+        readonly minChildren: Schema.withDecodingDefaultType<Schema.optional<Schema.Number>, never>;
+        readonly maxDepth: Schema.withDecodingDefaultType<Schema.optional<Schema.Number>, never>;
+        readonly beamWidth: Schema.withDecodingDefaultType<Schema.optional<Schema.Number>, never>;
+        readonly splitDeferredHardLimit: Schema.withDecodingDefaultType<Schema.optional<Schema.Number>, never>;
+        readonly rebalanceCooldownMs: Schema.withDecodingDefaultType<Schema.optional<Schema.Number>, never>;
+        readonly lloydPasses: Schema.withDecodingDefaultType<Schema.optional<Schema.Number>, never>;
+    }>>;
+    readonly graph: Schema.optional<Schema.Struct<{
+        readonly enabled: Schema.optional<Schema.Boolean>;
+        readonly maxDepth: Schema.optional<Schema.Number>;
+        readonly maxNeighbors: Schema.optional<Schema.Number>;
+        readonly maxTotal: Schema.optional<Schema.Number>;
+        readonly supersedeDemotion: Schema.optional<Schema.Number>;
+        readonly conflictBands: Schema.optional<Schema.Struct<{
+            readonly nearDuplicate: Schema.Number;
+            readonly conflictLow: Schema.Number;
+        }>>;
+        readonly clusterK: Schema.optional<Schema.Number>;
+        readonly clusterMinSize: Schema.optional<Schema.Number>;
+    }>>;
+    readonly llm: Schema.optional<Schema.Struct<{
+        readonly baseURL: Schema.String;
+        readonly apiKey: Schema.String;
+        readonly modelId: Schema.String;
+        readonly temperature: Schema.optional<Schema.refine<number, Schema.Number>>;
+        readonly maxOutputTokens: Schema.optional<Schema.refine<number, Schema.Number>>;
+        readonly reasoningEffort: Schema.optional<Schema.Literals<readonly ["low", "medium", "high"]>>;
+    }>>;
+    /** Structured-logging section — the logger's own `LogConfig` (leaf
+     * dependency, no mirror needed). */
+    readonly logging: Schema.optional<Schema.Struct<{
+        readonly enabled: Schema.withDecodingDefaultType<Schema.optional<Schema.Boolean>, never>;
+        readonly level: Schema.withDecodingDefaultType<Schema.optional<Schema.Literals<readonly ["trace", "debug", "info", "warn", "error"]>>, never>;
+        readonly format: Schema.withDecodingDefaultType<Schema.optional<Schema.Literals<readonly ["jsonl", "pretty"]>>, never>;
+        readonly file: Schema.optionalKey<Schema.String>;
+        readonly scopes: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Literals<readonly ["trace", "debug", "info", "warn", "error"]>>>;
+        readonly ringSize: Schema.withDecodingDefaultType<Schema.optional<Schema.Number>, never>;
+    }>>;
+    readonly defaultK: Schema.optional<Schema.Number>;
+    readonly defaultLimit: Schema.optional<Schema.Number>;
+    readonly defaultTtlSecs: Schema.optional<Schema.Number>;
+    readonly sweepIntervalMs: Schema.optional<Schema.Number>;
+}>;
+export interface DimpleConfig extends Schema.Schema.Type<typeof DimpleConfig> {
+}

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

@@ -0,0 +1,10 @@
+import { Context, Layer } from "effect";
+import type { DimpleConfig as DimpleConfigType } from "./schema.ts";
+export interface Interface {
+    readonly config: DimpleConfigType;
+}
+declare const Service_base: Context.ServiceClass<Service, "@dimple/Config", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const layer: (overrides?: Partial<DimpleConfigType>) => Layer.Layer<Service, Error>;
+export {};

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

@@ -0,0 +1,95 @@
+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";
+/** Topic-tree config (the store's schema, defaults decoded by the layer). */
+export type { TopicConfig } from "./internal/store/index.js";
+/** Graph config (the store's schema — `graph.GraphConfig`). */
+export type GraphConfig = graph.GraphConfig;
+/**
+ * Everything `@dimple/core` needs to compose the full system — one option
+ * set, resolved once at construction (no env reads past this boundary).
+ * The SDK builds these options from `dimple.jsonc`; power users can pass
+ * them directly.
+ */
+export interface CoreOptions {
+    /** Store database (file: or remote libsql URL). */
+    readonly storeUrl: string;
+    /** Jobs database — always a SEPARATE file/URL (the worker's own db). */
+    readonly jobsUrl: string;
+    readonly migrationFolder?: string;
+    /** The model registry — every model the store can embed/route with. */
+    readonly models: readonly EmbeddingModelConfig[];
+    readonly defaultModelId: string;
+    /** Injectable model factory (tests use synthetic embedders; production
+     * uses `makeTransformersModel` / the embedder registry's providers). */
+    readonly embedderFor: (model: EmbeddingModelConfig) => Effect.Effect<EmbeddingModel, EmbeddingError>;
+    /** Topic-tree section: enabled by default with `TopicConfig` defaults. */
+    readonly topics?: {
+        readonly enabled?: boolean;
+        readonly config?: TopicConfig;
+    };
+    readonly graph?: GraphConfig;
+    /** Structured-logging config (`@dimple/logger`); absent = silent. */
+    readonly logging?: LogConfig;
+    /** Optional LLM — enables the dream job's classifier (without it,
+     * `memory.dream` fails with an explicit "LLM not configured" error). */
+    readonly llm?: LLM;
+    /** Target model id stamped into the dream classifier prompt. */
+    readonly llmModelId?: string;
+    readonly concurrency?: number;
+    /** Bounded handler retries per job (default 1 = no retry; the config
+     * path threads `jobs.maxAttempts`, default 10). */
+    readonly maxAttempts?: number;
+    /** Config scalars: retrieval defaults + write TTL default (the config
+     * path threads `defaultK`/`defaultLimit`/`defaultTtlSecs`). */
+    readonly defaultK?: number;
+    readonly defaultLimit?: number;
+    readonly defaultTtlSecs?: number;
+    /** Route `retrieval_log` writes through `audit.write` jobs (default
+     * true) — the query path never blocks on audit writes. */
+    readonly audit?: boolean;
+    /** Custom durable job definitions ADDED to the worker (extensibility):
+     * the SDK's users can run their own jobs on the same runtime. */
+    readonly extraDefs?: readonly JobDefinition.Any[];
+    /** Custom handlers registered alongside the built-ins; a name that
+     * collides with a built-in OVERRIDES it (the registry otherwise fails
+     * on duplicates). */
+    readonly extraHandlers?: ReadonlyArray<{
+        readonly name: string;
+        readonly handler: Handler;
+    }>;
+}
+/** The composed system — the SDK's (and app's) handle to everything.
+ * Fields are the service SHAPES (`Tag["Service"]`) — the classes used as
+ * types would demand the tag members the yielded instances don't carry. */
+export interface Interface {
+    readonly store: Store["Service"];
+    readonly hybrid: HybridRetrieval["Service"];
+    readonly runtime: JobRuntime["Service"];
+    readonly registry: JobRegistry["Service"];
+    readonly models: ReadonlyMap<string, EmbeddingModelConfig>;
+    readonly defaultModel: EmbeddingModelConfig;
+    /** The default model's embedder instance (resolved from
+     * `embedderFor` at construction) — the SDK's `write` path embeds with
+     * it. */
+    readonly defaultEmbedder: EmbeddingModel;
+    readonly logging: Logging["Service"];
+    readonly llm?: LLM;
+}
+declare const CoreConfigError_base: Schema.Class<CoreConfigError, Schema.TaggedStruct<"core.ConfigError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** The dimple.jsonc `embedding` section is mandatory for the
+ * config-driven variant (`coreLayerConfig`) — without models there is
+ * nothing to embed or route. */
+export declare class CoreConfigError extends CoreConfigError_base {
+}
+declare const Service_base: Context.ServiceClass<Service, "@dimple/core/Core", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const make: (impl: Interface) => Interface;

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

@@ -0,0 +1,3 @@
+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 { CoreConfigError } from "./core.ts";

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

@@ -0,0 +1,21 @@
+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 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>;
+/**
+ * Config-driven variant — the `dimple.jsonc` path (the SDK's
+ * `makeDimple({ config })`): reads the resolved `DimpleConfig` from
+ * `@dimple/config` and builds the same composition as `layer`:
+ * store/jobs URLs, the `embedding` section (models + default model +
+ * provider-built embedders), topics/graph/logging/llm sections.
+ */
+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>;

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

@@ -0,0 +1,4 @@
+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";

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

@@ -0,0 +1,8 @@
+import { type EmbeddingModel } from "./provider.ts";
+export interface OpenAIOptions {
+    readonly modelId: string;
+    readonly model: string;
+    readonly dimensions: number;
+    readonly apiKey: string;
+}
+export declare const makeOpenAIModel: (options: OpenAIOptions) => EmbeddingModel;

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

@@ -0,0 +1,29 @@
+import { Context, Effect, Schema } from "effect";
+declare const EmbeddingError_base: Schema.Class<EmbeddingError, Schema.TaggedStruct<"EmbeddingProvider.EmbeddingError", {
+    readonly message: Schema.String;
+    readonly cause: Schema.optional<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+export declare class EmbeddingError extends EmbeddingError_base {
+}
+export interface EmbeddingModel {
+    readonly modelId: string;
+    readonly provider: string;
+    readonly dimensions: number;
+    readonly embed: (texts: readonly string[]) => Effect.Effect<readonly Float32Array[], EmbeddingError>;
+    readonly embedSingle: (text: string) => Effect.Effect<Float32Array, EmbeddingError>;
+}
+export interface Interface {
+    readonly getModel: (modelId: string) => Effect.Effect<EmbeddingModel, EmbeddingError>;
+    readonly defaultModelId: Effect.Effect<string, EmbeddingError>;
+    readonly registerModel: (spec: {
+        id: string;
+        provider: string;
+        model: string;
+        dimensions: number;
+        apiKey?: string;
+    }) => Effect.Effect<void, EmbeddingError>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@dimple/embedder/EmbeddingModelRegistry", Interface>;
+export declare class Service extends Service_base {
+}
+export {};

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

@@ -0,0 +1,10 @@
+import { Layer } from "effect";
+import { EmbeddingError, Service } from "./provider.ts";
+export interface ModelSpec {
+    readonly id: string;
+    readonly provider: string;
+    readonly model: string;
+    readonly dimensions: number;
+    readonly apiKey?: string;
+}
+export declare const layer: (...models: ModelSpec[]) => Layer.Layer<Service, EmbeddingError>;

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

@@ -0,0 +1,18 @@
+import { Config, Layer } from "effect";
+import type { DeviceType } from "@huggingface/transformers";
+import { Service, type EmbeddingModel } from "./provider.ts";
+interface TransformersOptions {
+    readonly modelId?: string;
+    readonly device?: DeviceType;
+    readonly dtype?: "fp32" | "fp16" | "q8" | "q4";
+    readonly pooling?: "mean" | "cls" | "none";
+    readonly normalize?: boolean;
+    readonly cacheDir?: string;
+    /** Declared output dimension — validated against the model's actual
+     * output on first embed (a mismatch fails typed, precisely). */
+    readonly dimensions?: number;
+}
+export declare const makeTransformersModel: (options?: TransformersOptions) => EmbeddingModel;
+export declare const layer: (options?: TransformersOptions) => Layer.Layer<Service>;
+export declare const layerConfig: (config: Config.Wrap<TransformersOptions>) => Layer.Layer<Service, Config.ConfigError>;
+export {};

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

@@ -0,0 +1,15 @@
+import { Context, Effect, Layer } from "effect";
+import type { TreeHandle } from "./internal/parser/index.js";
+import { ExtractedFile, ExtractionError } from "./models/extraction";
+export interface ExtractRequest {
+    readonly filePath: string;
+    readonly tree: TreeHandle;
+}
+export interface Interface {
+    readonly extract: (request: ExtractRequest) => Effect.Effect<ExtractedFile, ExtractionError>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@dimple/extractor/CodeExtractor", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const layer: Layer.Layer<Service, never, never>;
+export {};

package/dist/internal/extractor/content-handler.d.ts

@@ -0,0 +1,17 @@
+import { Context, Layer, Schema } from "effect";
+declare const ContentError_base: Schema.Class<ContentError, Schema.TaggedStruct<"Content.ContentError", {
+    readonly contentType: Schema.String;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class ContentError extends ContentError_base {
+}
+export interface Interface {
+    readonly contentType: string;
+    readonly renderText: (content: string) => string;
+    readonly extractText: (content: string) => string;
+}
+declare const Service_base: Context.ServiceClass<Service, "@dimple/extractor/ContentHandler", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const layer: Layer.Layer<Service, never, never>;
+export {};

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

@@ -0,0 +1,4 @@
+export { Service as CodeExtractor, layer as codeExtractorLayer } 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

@@ -0,0 +1,24 @@
+import type { TreeHandle } from "./internal/parser/index.js";
+import type { ExtractedChunk, ImportInfo } from "../models/extraction";
+import { ExtractionError } from "../models/extraction";
+/**
+ * Extract chunks and imports from a parsed tree-sitter tree.
+ *
+ * Dispatches to the language-specific extractor based on the tree's
+ * language identifier. Both tsx and jsx use their base language extractors
+ * since the AST node types for definitions and imports are identical.
+ * The parser (via @dimple/parser + @dimple/wasm) loads the correct grammar WASM.
+ *
+ * Returns a discriminated result: an unknown language yields an
+ * `ExtractionError` VALUE (never a throw — the caller fails its effect
+ * typed).
+ */
+export type ExtractionResult = {
+    readonly ok: true;
+    readonly chunks: ExtractedChunk[];
+    readonly imports: ImportInfo[];
+} | {
+    readonly ok: false;
+    readonly error: ExtractionError;
+};
+export declare function extract(filePath: string, tree: TreeHandle): ExtractionResult;

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

@@ -0,0 +1,22 @@
+import type { TreeHandle } from "./internal/parser/index.js";
+import type { ExtractedChunk, ImportInfo } from "../models/extraction";
+/**
+ * Extract chunks and imports from a JavaScript/JSX file.
+ *
+ * Walks top-level children of the tree-sitter AST. For each node:
+ * - import_statement: collect import info (source, specifiers)
+ * - export_statement: unwrap to inner declaration, emit with export prefix
+ * - definition type: emit a chunk
+ * - class: emit methods as separate chunks + the class itself
+ *
+ * Unlike TypeScript, JS does not have interfaces, type aliases, enums,
+ * abstract classes, or declare/ambient patterns.
+ *
+ * Returns an object with:
+ * - chunks: extracted definition nodes ready for embedding
+ * - imports: extracted import statement metadata for dependency tracking
+ */
+export declare function extract(filePath: string, tree: TreeHandle): {
+    chunks: ExtractedChunk[];
+    imports: ImportInfo[];
+};

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

@@ -0,0 +1,20 @@
+import type { TreeHandle } from "./internal/parser/index.js";
+import type { ExtractedChunk, ImportInfo } from "../models/extraction";
+/**
+ * Extract chunks and imports from a TypeScript/TSX file.
+ *
+ * Walks top-level children of the tree-sitter AST. For each node:
+ * - import_statement: collect import info (source, specifiers)
+ * - export_statement: unwrap to inner declaration, emit with export prefix
+ * - ambient_declaration: unwrap to inner declaration (declare class/module/etc.)
+ * - definition type: emit a chunk
+ * - class: emit methods as separate chunks + the class itself
+ *
+ * Returns an object with:
+ * - chunks: extracted definition nodes ready for embedding
+ * - imports: extracted import statement metadata for dependency tracking
+ */
+export declare function extract(filePath: string, tree: TreeHandle): {
+    chunks: ExtractedChunk[];
+    imports: ImportInfo[];
+};

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

@@ -0,0 +1,53 @@
+import { Schema } from "effect";
+declare const ExtractionError_base: Schema.Class<ExtractionError, Schema.TaggedStruct<"ExtractionError", {
+    readonly message: Schema.String;
+    readonly cause: Schema.optional<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+export declare class ExtractionError extends ExtractionError_base {
+}
+export declare const ExtractedChunk: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly filePath: Schema.String;
+    readonly sourceText: Schema.String;
+    readonly kind: Schema.String;
+    readonly name: Schema.String;
+    readonly startLine: Schema.Number;
+    readonly endLine: Schema.Number;
+    readonly language: Schema.String;
+    readonly docstring: Schema.optional<Schema.String>;
+}>;
+export interface ExtractedChunk extends Schema.Schema.Type<typeof ExtractedChunk> {
+}
+export declare const ImportInfo: Schema.Struct<{
+    readonly source: Schema.String;
+    readonly specifiers: Schema.$Array<Schema.String>;
+    readonly startLine: Schema.Number;
+    readonly endLine: Schema.Number;
+}>;
+export interface ImportInfo extends Schema.Schema.Type<typeof ImportInfo> {
+}
+export declare const ExtractedFile: Schema.Struct<{
+    readonly filePath: Schema.String;
+    readonly language: Schema.String;
+    readonly source: Schema.String;
+    readonly chunks: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly filePath: Schema.String;
+        readonly sourceText: Schema.String;
+        readonly kind: Schema.String;
+        readonly name: Schema.String;
+        readonly startLine: Schema.Number;
+        readonly endLine: Schema.Number;
+        readonly language: Schema.String;
+        readonly docstring: Schema.optional<Schema.String>;
+    }>>;
+    readonly imports: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly source: Schema.String;
+        readonly specifiers: Schema.$Array<Schema.String>;
+        readonly startLine: Schema.Number;
+        readonly endLine: Schema.Number;
+    }>>>;
+}>;
+export interface ExtractedFile extends Schema.Schema.Type<typeof ExtractedFile> {
+}
+export {};

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

@@ -0,0 +1,14 @@
+import type { LLM } from "./llm.ts";
+import type { DreamClassifier } from "./internal/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
+ * model's space it is judging — the ids in each pair are opaque to the
+ * judge either way. Classifier failures surface as `LLMError` on the
+ * error channel; the dream handler logs and swallows them (the watermark
+ * stays put, so the batch is judged again on the next run).
+ */
+export declare const makeDreamClassifier: (deps: {
+    readonly llm: LLM;
+    readonly modelId?: string;
+}) => DreamClassifier;

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

@@ -0,0 +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";