@ponraaj/dimple-sdk 0.0.0-alpha.1

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

@@ -0,0 +1,54 @@
+import { Cause, Effect, Schema } from "effect";
+import { type LanguageModel } from "ai";
+import { z } from "zod";
+declare const LLMError_base: Schema.Class<LLMError, Schema.TaggedStruct<"llm.LLMError", {
+    readonly message: Schema.String;
+    readonly cause: Schema.optional<Schema.Defect>;
+}>, Cause.YieldableError>;
+export declare class LLMError extends LLMError_base {
+}
+/** Provider reasoning-effort levels (opt-in; only sent when configured —
+ * servers that don't support it ignore the extra field). */
+export type ReasoningEffort = "low" | "medium" | "high";
+export interface GenerateTextInput {
+    readonly prompt: string;
+    readonly system?: string;
+    readonly temperature?: number;
+    readonly maxOutputTokens?: number;
+    readonly reasoningEffort?: ReasoningEffort;
+}
+export interface GenerateObjectInput<A> {
+    readonly prompt: string;
+    readonly system?: string;
+    readonly schema: z.ZodType<A>;
+    readonly temperature?: number;
+    readonly maxOutputTokens?: number;
+    readonly reasoningEffort?: ReasoningEffort;
+}
+/** Construction-time defaults (the `llm` config section); per-call
+ * overrides win. */
+export interface LLMDefaults {
+    readonly temperature?: number | undefined;
+    readonly maxOutputTokens?: number | undefined;
+    readonly reasoningEffort?: ReasoningEffort | undefined;
+}
+export interface LLM {
+    readonly generateText: (input: GenerateTextInput) => Effect.Effect<string, LLMError>;
+    readonly generateObject: <A>(input: GenerateObjectInput<A>) => Effect.Effect<A, LLMError>;
+}
+/**
+ * Wraps a Vercel AI SDK language model behind a small Effect-based interface.
+ * The wrapper is provider-agnostic: any `LanguageModel` works, and callers
+ * never touch the AI SDK directly. All provider failures surface as a typed
+ * `LLMError` on the error channel.
+ *
+ * Structured generation forces a synthetic tool call — the one
+ * structured-output mechanism every chat protocol supports (tool-call
+ * arguments are strict JSON, so there is no dependency on `response_format`
+ * modes that many OpenAI-compatible gateways reject, and no fragile
+ * fence-stripping). Providers without tool support fall back to plain text
+ * generation with the JSON schema embedded in the prompt plus tolerant
+ * extraction; both paths end in zod validation.
+ */
+export declare const makeLLM: (model: LanguageModel, defaults?: LLMDefaults) => LLM;
+export {};

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

@@ -0,0 +1,14 @@
+import type { LanguageModel } from "ai";
+export interface OpenAICompatibleOptions {
+    readonly baseURL: string;
+    readonly apiKey: string;
+    readonly modelId?: string;
+    readonly name?: string;
+}
+/**
+ * Builds a language model for any OpenAI-compatible chat endpoint
+ * (for example OpenCode Go style base URLs). The model id defaults to
+ * "default", which those gateways route to their default model; pass
+ * `modelId` to target a specific model on the endpoint.
+ */
+export declare const openAICompatible: (options: OpenAICompatibleOptions) => LanguageModel;

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

@@ -0,0 +1,29 @@
+import { Config, Context, Layer } from "effect";
+import { Service as ConfigService } from "./internal/config/index.js";
+import { type LLM, type LLMDefaults } from "./llm.ts";
+/**
+ * Connection options for the OpenAI-compatible LLM layer: the chat
+ * endpoint base URL, the API key for that endpoint, and the model id the
+ * endpoint should route to (OpenCode Go style gateways accept "default").
+ * The layer builds a language model from these and wraps it with
+ * `makeLLM`.
+ */
+export interface LLMOptions extends LLMDefaults {
+    readonly baseURL: string;
+    readonly apiKey: string;
+    readonly modelId: string;
+}
+/** The LLM service surface — the `makeLLM` wrapper's methods. */
+export interface Interface extends LLM {
+}
+declare const Service_base: Context.ServiceClass<Service, "@dimple/LLM", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const layer: (options: LLMOptions) => Layer.Layer<Service, never, never>;
+export declare const layerConfig: (config: Config.Wrap<LLMOptions>) => Layer.Layer<Service, Config.ConfigError, never>;
+/**
+ * Builds the LLM layer from the loaded `dimple.json` config (the `llm`
+ * section). Fails with a clear error when the section is absent.
+ */
+export declare const layerFromConfig: () => Layer.Layer<Service, Error, ConfigService>;
+export {};

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

@@ -0,0 +1,6 @@
+import type { LogEntry } from "./types.ts";
+/** Render one entry as a single JSON line (JSONL/NDJSON: append-only, one
+ * bad line is isolated, a crash corrupts at most the last partial line). */
+export declare function renderJson(entry: LogEntry): string;
+/** Human-readable one-line rendering for console debugging. */
+export declare function renderPretty(entry: LogEntry): string;

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

@@ -0,0 +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 { 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/ring.d.ts

@@ -0,0 +1,33 @@
+/** One pre-rendered line + monotonic sequence id (for Last-Event-ID
+ * resume on the SSE tail). */
+export interface RingFrame {
+    readonly seq: number;
+    readonly line: string;
+}
+export interface Subscriber {
+    readonly id: number;
+    /** null once the subscriber has been evicted for being too slow. */
+    readonly poll: () => string[] | null;
+    readonly close: () => void;
+}
+/** Drop-oldest ring of pre-rendered log lines with per-subscriber bounded
+ * queues (the live-tail mirror). NOT durable — the file sink is the source
+ * of truth (Vector buffering model); a crash loses the ring only. */
+export declare class RingBuffer {
+    private readonly frames;
+    private nextSeq;
+    private nextId;
+    private readonly queues;
+    private readonly evicted;
+    private readonly capacity;
+    /** Invalid capacities (0, negative, NaN, Infinity) clamp to 0 — a
+     * zero-capacity ring retains nothing. */
+    constructor(capacity: number);
+    get seq(): number;
+    /** All frames currently held (initial snapshot for a new subscriber). */
+    snapshot(): RingFrame[];
+    push(line: string): void;
+    /** Subscribe for live frames. `poll()` drains the subscriber's queue;
+     * returns null once the subscriber was evicted (caller closes). */
+    subscribe(): Subscriber;
+}

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

@@ -0,0 +1,50 @@
+import { Config, Context, Layer, Logger } from "effect";
+import type { Scope } from "effect/Scope";
+import { RingBuffer } from "./ring.ts";
+import { type LogConfig, type LogEntry } from "./types.ts";
+/** A sink consumes rendered log lines. File sinks always render JSONL
+ * (the durable, machine-readable source of truth); the console sink may
+ * render pretty for humans. */
+export interface Sink {
+    /** Receives the ENTRY — each sink renders it its own way (pretty on the
+     * console, JSONL in the file and ring). */
+    readonly write: (entry: LogEntry) => void;
+    readonly dispose: () => void;
+}
+export declare const consoleSink: (pretty: boolean) => Sink;
+/** Append-per-event file sink (the pino model): each rendered line goes
+ * straight to the fd and the OS page cache does the buffering; `fsync`
+ * runs on process exit and on dispose. NOT sync-flush-per-event (kills
+ * throughput), NOT end-of-run dumps (lose everything on crash). */
+export declare const fileSink: (path: string) => Sink;
+export interface Interface {
+    readonly emit: (entry: LogEntry) => void;
+    /** Live tail mirror: pre-rendered JSONL lines, drop-oldest, NOT durable. */
+    readonly ring: RingBuffer;
+    readonly dispose: () => void;
+}
+declare const Service_base: Context.ServiceClass<Service, "@dimple/logger/Logging", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const make: (config: LogConfig) => Interface;
+/** The structured shape Effect's `Logger.formatStructured` emits. */
+export interface StructuredOutput {
+    readonly level: string;
+    readonly fiberId: string;
+    readonly timestamp: string;
+    readonly message: unknown;
+    readonly cause: string | undefined;
+    readonly annotations: Record<string, unknown>;
+    readonly spans: Record<string, number>;
+}
+/** The Effect `Logger` that feeds the Logging service. */
+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>;
+/** 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>;
+export {};

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

@@ -0,0 +1,39 @@
+import { Schema } from "effect";
+/** Named levels, ordered low → high. `All`/`None` are absent on purpose:
+ * a user-configured logger always has a concrete floor. */
+export type LogLevel = "trace" | "debug" | "info" | "warn" | "error";
+/** v4-beta note: `Schema.Literals` takes a readonly array (not variadic). */
+export declare const LogLevel: Schema.Literals<readonly ["trace", "debug", "info", "warn", "error"]>;
+/** OTel severity numbers (logs data model): TRACE=1, DEBUG=5, INFO=9,
+ * WARN=13, ERROR=17. */
+export declare const SEV_NUM: Record<LogLevel, number>;
+export declare const LEVEL_ORDER: Record<LogLevel, number>;
+export declare const LogConfig: 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>;
+    /** Optional file path for the durable sink (JSONL appended per event). */
+    readonly file: Schema.optionalKey<Schema.String>;
+    /** Per-emitting-package level overrides, keyed by package name. */
+    readonly scopes: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Literals<readonly ["trace", "debug", "info", "warn", "error"]>>>;
+    /** Ring buffer capacity for the live tail (pre-rendered lines). Invalid
+     * values (0, negative, NaN, Infinity) are clamped by the RingBuffer. */
+    readonly ringSize: Schema.withDecodingDefaultType<Schema.optional<Schema.Number>, never>;
+}>;
+export type LogConfig = Schema.Schema.Type<typeof LogConfig>;
+/** OTel-aligned structured log entry. `scope` is the EMITTING PACKAGE
+ * (InstrumentationScope), never a feature name; `event` is a stable,
+ * low-cardinality operation name; variable payload goes in `attrs`. */
+export interface LogEntry {
+    readonly ts: string;
+    readonly level: LogLevel;
+    readonly sevNum: number;
+    readonly scope: string;
+    readonly event: string;
+    readonly message: string;
+    readonly fiber: string;
+    readonly traceId?: string;
+    readonly spanId?: string;
+    readonly attrs: Record<string, unknown>;
+    readonly cause?: string;
+}

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

@@ -0,0 +1,12 @@
+import { Context, Effect, Layer } from "effect";
+import { TreeHandle } from "./models/treeHandle";
+import type { ParseRequest } from "./models/parseRequest";
+import { ParseError } from "@dimple/shared/errors";
+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 {};

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

@@ -0,0 +1,7 @@
+export { Service as CodeParser, layer as codeParserLayer } 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";

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

@@ -0,0 +1,12 @@
+import { Context, Effect, Layer } from "effect";
+import type { LanguageId } from "@dimple/shared/types/language";
+import { LanguageLoadError } from "@dimple/shared/errors";
+import { Language } from "web-tree-sitter";
+export interface Interface {
+    readonly get: (lang: LanguageId) => Effect.Effect<Language, LanguageLoadError>;
+}
+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 {};

package/dist/internal/parser/models/parseRequest.d.ts

@@ -0,0 +1,17 @@
+import { Schema } from "effect";
+/**
+ * Schema for ParseRequest - the input to CodeParser.parse().
+ *
+ * Validates at runtime that:
+ * - lang is a valid LanguageId
+ * - source is a non-empty-or-any string
+ *
+ * Example:
+ *
+ * ParseRequest({ lang: "typescript", source: "const x = 1" })
+ */
+export declare const ParseRequest: Schema.Struct<{
+    readonly lang: Schema.Literals<readonly ["javascript", "typescript", "tsx", "jsx", "python", "rust", "go"]>;
+    readonly source: Schema.String;
+}>;
+export type ParseRequest = Schema.Schema.Type<typeof ParseRequest>;

package/dist/internal/parser/models/treeHandle.d.ts

@@ -0,0 +1,23 @@
+import { Schema } from "effect";
+import { Tree } from "web-tree-sitter";
+/**
+ * Schema for validating that a value is a tree-sitter `Tree` instance.
+ */
+export declare const TreeSchema: Schema.instanceOf<Tree, Tree>;
+/**
+ * TreeHandle wraps a parsed tree-sitter tree with its metadata.
+ *
+ * Fields:
+ * - `tree`:   The parsed tree-sitter Tree (rootNode, walk, edit, etc.)
+ * - `lang`:   The language identifier used for parsing
+ * - `source`: The original source code that was parsed
+ *
+ * This is the output type of `CodeParser.parse()`.
+ */
+export declare const TreeHandle: Schema.Struct<{
+    readonly tree: Schema.instanceOf<Tree, Tree>;
+    readonly lang: Schema.Literals<readonly ["javascript", "typescript", "tsx", "jsx", "python", "rust", "go"]>;
+    readonly source: Schema.String;
+}>;
+export interface TreeHandle extends Schema.Schema.Type<typeof TreeHandle> {
+}

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

@@ -0,0 +1,15 @@
+import { Layer } from "effect";
+import { ParserInitError } from "@dimple/shared/errors";
+/**
+ * Tree-sitter engine initialization — the ORIGINAL design: `Parser.init()`
+ * with no override, so web-tree-sitter's glue resolves `tree-sitter.wasm`
+ * relative to ITS OWN module (import.meta.url). That keeps the engine wasm
+ * riding inside the web-tree-sitter npm package — nothing wasm is shipped
+ * or downloaded by dimple itself (only the LANGUAGE grammars go through
+ * the runtime download + cache in @dimple/wasm).
+ *
+ * Bundling note: the SDK build EXTERNALIZES web-tree-sitter (it is a
+ * runtime dependency of the published package), so the module — and its
+ * wasm — stay intact at the consumer's node_modules.
+ */
+export declare const layer: Layer.Layer<never, ParserInitError, never>;

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

@@ -0,0 +1,48 @@
+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";
+declare const HybridError_base: Schema.Class<HybridError, Schema.TaggedStruct<"HybridRetrieval.HybridError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class HybridError extends HybridError_base {
+}
+export interface QueryProfile {
+    /** Rescale fused scores toward fresh memories (see the formula in
+     * `hybrid`): 0 disables the boost entirely. */
+    readonly recencyBoost?: number;
+    /** Restrict the dense leg to memories annotated with any of these
+     * concept ids (passed through to `Store.searchVector`). */
+    readonly conceptFilter?: readonly string[];
+    readonly modeWeights?: {
+        readonly vector?: number;
+        readonly fts?: number;
+    };
+}
+export interface Interface {
+    readonly hybrid: (query: string, options?: {
+        readonly namespace?: string;
+        readonly limit?: number;
+        readonly k?: number;
+        readonly profile?: QueryProfile | "hybrid" | "semantic" | "keyword";
+        readonly topics?: {
+            readonly topicKeys?: ReadonlyArray<string>;
+        };
+    }) => Effect.Effect<readonly AugmentedMemory[], HybridError>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@dimple/retriever/HybridRetrieval", Interface>;
+export declare class Service extends Service_base {
+}
+/**
+ * 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>;
+/** 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>;
+export {};

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

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

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

@@ -0,0 +1,11 @@
+export interface RankResult {
+    readonly memoryId: string;
+    readonly denseScore: number | null;
+    readonly fts5Score: number | null;
+    readonly rrfScore: number;
+}
+/**
+ * Reciprocal Rank Fusion
+ * RRF(d) = sum(1 / (k + rank_i(d))) for each retriever i
+ */
+export declare function fuse(denseRanks: ReadonlyArray<readonly [string, number]> | null, fts5Ranks: ReadonlyArray<readonly [string, number]> | null, k: number, limit: number): RankResult[];

package/dist/internal/shared/errors/index.d.ts

@@ -0,0 +1,2 @@
+export { WasmCacheError, RegistryError, WasmDownloadError, GrammarProvisionError } from "./wasm";
+export { ParseError, LanguageLoadError, ParserInitError } from "./parser";

package/dist/internal/shared/errors/parser.d.ts

@@ -0,0 +1,21 @@
+import { Schema } from "effect";
+declare const ParserInitError_base: Schema.Class<ParserInitError, Schema.TaggedStruct<"ParserInitError", {
+    readonly message: Schema.String;
+    readonly cause: Schema.optional<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+export declare class ParserInitError extends ParserInitError_base {
+}
+declare const LanguageLoadError_base: Schema.Class<LanguageLoadError, Schema.TaggedStruct<"LanguageLoadError", {
+    readonly lang: Schema.Literals<readonly ["javascript", "typescript", "tsx", "jsx", "python", "rust", "go"]>;
+    readonly message: Schema.String;
+    readonly cause: Schema.optional<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+export declare class LanguageLoadError extends LanguageLoadError_base {
+}
+declare const ParseError_base: Schema.Class<ParseError, Schema.TaggedStruct<"ParseError", {
+    readonly message: Schema.String;
+    readonly cause: Schema.optional<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+export declare class ParseError extends ParseError_base {
+}
+export {};

package/dist/internal/shared/errors/wasm.d.ts

@@ -0,0 +1,28 @@
+import { Schema } from "effect";
+declare const WasmCacheError_base: Schema.Class<WasmCacheError, Schema.TaggedStruct<"WasmCacheError", {
+    readonly message: Schema.String;
+    readonly cause: Schema.optional<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+export declare class WasmCacheError extends WasmCacheError_base {
+}
+declare const RegistryError_base: Schema.Class<RegistryError, Schema.TaggedStruct<"RegistryError", {
+    readonly message: Schema.String;
+    readonly cause: Schema.optional<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+export declare class RegistryError extends RegistryError_base {
+}
+declare const WasmDownloadError_base: Schema.Class<WasmDownloadError, Schema.TaggedStruct<"WasmDownloadError", {
+    readonly message: Schema.String;
+    readonly url: Schema.String;
+    readonly cause: Schema.optional<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+export declare class WasmDownloadError extends WasmDownloadError_base {
+}
+declare const GrammarProvisionError_base: Schema.Class<GrammarProvisionError, Schema.TaggedStruct<"GrammarProvisionError", {
+    readonly language: Schema.String;
+    readonly message: Schema.String;
+    readonly cause: Schema.optional<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+export declare class GrammarProvisionError extends GrammarProvisionError_base {
+}
+export {};

package/dist/internal/shared/types/index.d.ts

@@ -0,0 +1 @@
+export type { LanguageId } from "./language";

package/dist/internal/shared/types/language.d.ts

@@ -0,0 +1,3 @@
+import { Schema } from "effect";
+export declare const LanguageId: Schema.Literals<readonly ["javascript", "typescript", "tsx", "jsx", "python", "rust", "go"]>;
+export type LanguageId = Schema.Schema.Type<typeof LanguageId>;

package/dist/internal/store/audit.d.ts

@@ -0,0 +1,21 @@
+import { Effect } from "effect";
+import { JobFailure, type Handler, type JobContext } from "./internal/workflow/index.js";
+import { Service as DbBackend } from "./db-backend.ts";
+import type { Interface as DbBackendInterface } from "./db-backend.ts";
+/** The `audit.write` handler shape (see queue.ts). */
+export type AuditWriteHandler = (payload: unknown, ctx: JobContext) => Effect.Effect<unknown, JobFailure, DbBackend>;
+/**
+ * Factory for the `audit.write` job handler. Payload: `{ rows }` — one or
+ * more `retrieval_log` rows enqueued by the store's `enqueueAudit` seam
+ * (the query path's audit writes). The handler performs the actual insert
+ * through `DbBackend.writeAuditRows`, so it stays dialect-neutral. This is
+ * the durable, visible counterpart of the old fire-and-forget insert: the
+ * job either succeeds (row persisted) or fails loudly (queue retry /
+ * observability), never silently.
+ */
+export declare function auditWriteHandler(deps: {
+    readonly backend: DbBackendInterface;
+}): Handler;
+export declare function auditWriteHandler(deps: {
+    readonly backend?: DbBackendInterface;
+}): AuditWriteHandler;

package/dist/internal/store/db-backend.d.ts

@@ -0,0 +1,111 @@
+import { Context, Effect } from "effect";
+import type { StoreError } from "./error.ts";
+import type { RetrievalAuditRow, SweepResult } from "./models.ts";
+import type { EmbeddingModelConfig } from "./internal/config/index.js";
+/** Opaque handle to a Drizzle database instance.
+ * Concrete type varies by backend dialect (LibSQLDatabase, PgDatabase, etc.).
+ * Standard CRUD uses Drizzle's polymorphic query builder — no dialect-specific cast needed
+ * for select/insert/update/delete. Vector and FTS operations are backend-specific. */
+export type DrizzleDB = any;
+/** Tables exposed by a backend for the Store to use in Drizzle query builder calls.
+ * Each backend provides its own dialect-specific table objects (sqliteTable / pgTable).
+ * The `any` type is intentional — Drizzle's query builder accepts tables polymorphically
+ * for standard CRUD (select/insert/update/delete). */
+export interface StoreTables {
+    readonly memories: any;
+    readonly memoryEvents: any;
+    readonly concepts: any;
+    readonly memoryConcepts: any;
+    readonly conceptRelations: any;
+    readonly retrievalLog: any;
+    readonly topics: any;
+    readonly artifactEdges: any;
+}
+/** A topic centroid row from a per-model topic vector table (raw SQL boundary shape). */
+export interface TopicVectorRow {
+    readonly topicKey: string;
+    readonly sumVector: number[];
+}
+/** A memory embedding row from a per-model memory vector table (raw SQL boundary shape). */
+export interface MemoryVectorRow {
+    readonly memoryId: string;
+    readonly vector: number[];
+}
+/**
+ * Canonical row of a `graphNeighbors` traversal.
+ * The backend returns raw view rows (`Record<string, unknown>[]` — snake_case
+ * `graph_edges` columns plus `depth`); the store casts once at the boundary
+ * into this shape (the `graph/traversal.ts` helper, mirror of `ftsSearch`).
+ */
+export interface GraphNeighborRow {
+    /** The edge that reached this row's `to` endpoint. */
+    readonly fromId: string;
+    readonly fromKind: string;
+    readonly toId: string;
+    readonly toKind: string;
+    readonly edgeKind: string;
+    readonly edgeStatus: string;
+    readonly weight: number;
+    readonly edgeSource: string;
+    readonly depth: number;
+}
+export interface GraphNeighborsOptions {
+    readonly maxDepth?: number;
+    readonly maxNeighbors?: number;
+    readonly maxTotal?: number;
+    readonly includePending?: boolean;
+    /** Optional scope for the topic legs of the view (topic edges are
+     * model-scoped by PK). `undefined` unions every model's topic edges —
+     * the intended default (topic edges are retrieval context regardless
+     * of the model that wrote them). */
+    readonly modelKey?: string;
+}
+export interface Interface {
+    readonly runMigrations: () => Effect.Effect<void, StoreError>;
+    /**
+     * True when the cause chain contains a UNIQUE-constraint violation. The
+     * store uses it to map duplicate inserts to typed domain errors; the
+     * dialect-specific detection (SQLite message vs PG error code 23505)
+     * stays backend-owned.
+     */
+    readonly isUniqueViolation: (cause: unknown) => boolean;
+    /**
+     * Memories with NO live incident edge (either endpoint; expired and
+     * rejected edges do not count as live) — the isolated-memory survey for
+     * the candidate review surface and coverage metrics. Rows are
+     * `{ id, createdAt }`, ordered by `created_at` then `id` (deterministic).
+     * `limit` bounds the rows (0 = unbounded); `modelKey` optionally scopes
+     * to the model's active population.
+     */
+    readonly listIsolatedMemories: (limit: number, modelKey?: string) => Effect.Effect<readonly Record<string, unknown>[], StoreError>;
+    readonly db: DrizzleDB;
+    readonly tables: StoreTables;
+    readonly ftsSearch: (query: string, namespace: string, limit: number, topicKeys?: ReadonlyArray<string>, modelKey?: string) => Effect.Effect<readonly Record<string, unknown>[], StoreError>;
+    readonly vectorSearch: (query: ReadonlyArray<number>, namespace: string, limit: number, model: EmbeddingModelConfig, topicKeys?: ReadonlyArray<string>) => Effect.Effect<readonly Record<string, unknown>[], StoreError>;
+    readonly sweep: (namespace: string) => Effect.Effect<SweepResult, StoreError>;
+    /** Persist retrieval-audit rows (`retrieval_log`). Owned by the backend
+     * so the `audit.write` job handler stays dialect-neutral. */
+    readonly writeAuditRows: (rows: readonly RetrievalAuditRow[]) => Effect.Effect<void, StoreError>;
+    /** Metadata-filtered memory lookup (the one
+     * `json_extract` (SQLite) / `->` (PG) portability wart, now backend-owned
+     * like `ftsSearch`). Raw SQL, returns `Record<string, unknown>[]` — the
+     * store casts once at the boundary. Supported filter keys mirror the old
+     * store-level SQL exactly: `topic` (LIKE on `$.topics`) and `sourceType`
+     * (equality on `$.sourceType`); unknown keys are ignored. `limit` is
+     * optional — omitted means no LIMIT. */
+    readonly queryByMetadata: (filter: Record<string, unknown>, limit?: number) => Effect.Effect<readonly Record<string, unknown>[], StoreError>;
+    readonly graphNeighbors: (kind: "memory" | "topic" | "concept", id: string, opts?: GraphNeighborsOptions) => Effect.Effect<readonly Record<string, unknown>[], StoreError>;
+    readonly ensureVectorTable: (model: EmbeddingModelConfig) => Effect.Effect<void, StoreError>;
+    readonly insertVector: (memoryId: string, vector: ReadonlyArray<number>, model: EmbeddingModelConfig) => Effect.Effect<void, StoreError>;
+    readonly deleteVector: (memoryId: string, dimensions: number) => Effect.Effect<void, StoreError>;
+    readonly ensureTopicVectorTable: (model: EmbeddingModelConfig) => Effect.Effect<void, StoreError>;
+    readonly upsertTopicVector: (topicKey: string, sumVector: ReadonlyArray<number>, model: EmbeddingModelConfig) => Effect.Effect<void, StoreError>;
+    readonly deleteTopicVectors: (model: EmbeddingModelConfig) => Effect.Effect<void, StoreError>;
+    readonly fetchTopicVectors: (model: EmbeddingModelConfig) => Effect.Effect<ReadonlyArray<TopicVectorRow>, StoreError>;
+    readonly fetchMemoryVectors: (memoryIds: ReadonlyArray<string>, model: EmbeddingModelConfig) => Effect.Effect<ReadonlyArray<MemoryVectorRow>, StoreError>;
+    readonly listMemoryIds: (model: EmbeddingModelConfig) => Effect.Effect<ReadonlyArray<string>, StoreError>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@dimple/store/DbBackend", Interface>;
+export declare class Service extends Service_base {
+}
+export {};

package/dist/internal/store/drizzle-schema.d.ts

@@ -0,0 +1 @@
+export { memories, memoryEvents, concepts, memoryConcepts, conceptRelations, retrievalLog, MemoryInsert, MemorySelect, MemoryUpdate, MemoryEventInsert, MemoryEventSelect, ConceptInsert, ConceptSelect, MemoryConceptInsert, MemoryConceptSelect, ConceptRelationInsert, ConceptRelationSelect, RetrievalLogInsert, RetrievalLogSelect, } from "./schema/libsql.ts";

package/dist/internal/store/error.d.ts

@@ -0,0 +1,19 @@
+import { Schema } from "effect";
+declare const StoreError_base: Schema.Class<StoreError, Schema.TaggedStruct<"Store.StoreError", {
+    readonly message: Schema.String;
+    readonly cause: Schema.optional<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+export declare class StoreError extends StoreError_base {
+}
+declare const NotFound_base: Schema.Class<NotFound, Schema.TaggedStruct<"Store.NotFound", {
+    readonly id: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class NotFound extends NotFound_base {
+}
+declare const DuplicateActiveKey_base: Schema.Class<DuplicateActiveKey, Schema.TaggedStruct<"Store.DuplicateActiveKey", {
+    readonly logicalKey: Schema.String;
+    readonly namespace: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class DuplicateActiveKey extends DuplicateActiveKey_base {
+}
+export {};

package/dist/internal/store/fnv1a32.d.ts

@@ -0,0 +1,14 @@
+/**
+ * FNV-1a 32-bit hash of a string — deterministic, no crypto needed.
+ *
+ * The repo's single canonical implementation, used by:
+ * - `topics/jobs.ts` — content-addressable split child keys (`t_<hash>`).
+ * - `store.ts` — the retrieval audit hash (`retrieval_log.query_hash`,
+ *   deterministic + joinable, replacing the former
+ *   random UUID prefix.
+ *
+ * Returns the raw unsigned 32-bit hash as a number; callers format it
+ * (`.toString(16)` for hex). A string's hash is stable across runs, DBs and
+ * processes — same query text ⇒ same hash.
+ */
+export declare const fnv1a32: (text: string) => number;