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

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

@@ -1,4 +1,4 @@
-import { Config, Context, Layer, Logger } from "effect";
+import { Config, Context, Effect, Layer, Logger, Schema } from "effect";
 import type { Scope } from "effect/Scope";
 import { RingBuffer } from "./ring.ts";
 import { type LogConfig, type LogEntry } from "./types.ts";
@@ -9,42 +9,72 @@ 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;
+    readonly dispose: () => void | Promise<void>;
 }
 export declare const consoleSink: (pretty: boolean) => Sink;
-/** Append-per-event file sink (the pino model): each rendered line goes
+/**
+ * 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;
+ * throughput), NOT end-of-run dumps (lose everything on crash).
+ *
+ * `node:fs` loads LAZILY (dynamic import) — the module stays free of
+ * static node imports, so the worker bundle builds anywhere; a file sink
+ * is never configured on edge.
+ */
+export declare const fileSink: (path: string) => Effect.Effect<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;
+    readonly dispose: () => void | Promise<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. */
+/** 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
+ * else renders as JSON (the `Logger.formatStructured` message contract).
+ * The schema is total for the values Effect actually emits; the caller
+ * supplies the JSON fallback when decoding fails. */
+declare const LogMessage: Schema.Union<readonly [Schema.String, Schema.$Array<Schema.Unknown>]>;
+type LogMessage = Schema.Schema.Type<typeof LogMessage>;
+/** The structured shape after boundary decoding of Effect's raw
+ * `Logger.formatStructured` output (annotations carry arbitrary JSON
+ * values; the decode happens in `effectLogger` before `toEntry`). */
 export interface StructuredOutput {
     readonly level: string;
     readonly fiberId: string;
     readonly timestamp: string;
-    readonly message: unknown;
+    readonly message: LogMessage;
     readonly cause: string | undefined;
-    readonly annotations: Record<string, unknown>;
-    readonly spans: Record<string, number>;
+    readonly annotations: Readonly<Record<string, Schema.Json>>;
+    readonly spans: Readonly<Record<string, number>>;
 }
-/** The Effect `Logger` that feeds the Logging service. */
+/** The Effect `Logger` that feeds the Logging service. The raw structured
+ * output is decoded at this boundary: annotations may carry arbitrary
+ * values, so each is decoded as JSON (non-JSON payloads degrade to their
+ * JSON rendering, keeping the JSONL sink lossless). */
 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/logger/types.d.ts

@@ -6,8 +6,20 @@ export type LogLevel = "trace" | "debug" | "info" | "warn" | "error";
 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 SEV_NUM: {
+    trace: number;
+    debug: number;
+    info: number;
+    warn: number;
+    error: number;
+};
+export declare const LEVEL_ORDER: {
+    trace: number;
+    debug: number;
+    info: number;
+    warn: number;
+    error: 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>;
@@ -34,6 +46,6 @@ export interface LogEntry {
     readonly fiber: string;
     readonly traceId?: string;
     readonly spanId?: string;
-    readonly attrs: Record<string, unknown>;
+    readonly attrs: Record<string, Schema.Json>;
     readonly cause?: string;
 }

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

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

@@ -0,0 +1,20 @@
+/**
+ * Cross-process migration lock shared by the store backend and the workflow
+ * queue stack. Both run `CREATE TABLE`-style migrations on a `file:` database
+ * at boot; two runtimes starting together race them and the loser fails with
+ * a raw "Failed to execute statement". An exclusive lock file next to the
+ * database serializes them. Remote URLs skip locking — the server owns its
+ * migrations.
+ *
+ * `node:fs` is imported lazily: callers bundle for workerd, and the lock is
+ * only ever reached for `file:` URLs.
+ */
+export interface FileLockOptions {
+    /** Steal a lock whose mtime is older than this (a crashed owner). */
+    readonly staleMs?: number;
+    /** Give up after this long and throw (default 30s). */
+    readonly timeoutMs?: number;
+}
+/** Acquire `<db>.migrate-lock` for a `file:` URL. Remote URLs resolve to
+ *  `undefined` (nothing to release). */
+export declare const acquireMigrationLock: (url: string) => Promise<(() => void) | undefined>;

package/dist/internal/shared/schema/defaults.d.ts

@@ -0,0 +1,13 @@
+import { Schema } from "effect";
+/**
+ * Defaulted optional struct fields for Effect 4.0.0.
+ *
+ * `Schema.optionalWith` does not exist in this version; `optional` plus
+ * `withDecodingDefaultType` is the equivalent: the key may be absent or
+ * `undefined` on input, the default fills it during decoding, and the
+ * decoded type keeps the field required. Curried so the default thunk is
+ * contextually typed against the already-fixed schema type.
+ */
+export declare const optionalWithDefault: <S extends Schema.Constraint>(schema: S) => (options: {
+    default: () => Schema.Schema.Type<S>;
+}) => Schema.withDecodingDefaultType<Schema.optional<S>>;

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

@@ -1,9 +1,15 @@
 import { Effect } from "effect";
-import { JobFailure, type Handler, type JobContext } from "./internal/workflow/index.js";
+import type { RetrievalAuditRow } from "./models.ts";
+import { JobFailure, type Handler, type JobContext } from "../workflow/index.js";
 import { Service as DbBackend } from "./db-backend.ts";
 import type { Interface as DbBackendInterface } from "./db-backend.ts";
+/** The decoded `audit.write` payload — mirrors the queue definition's
+ * schema (`{ rows }`); the executor decodes before calling. */
+export interface AuditWritePayload {
+    readonly rows: ReadonlyArray<RetrievalAuditRow>;
+}
 /** The `audit.write` handler shape (see queue.ts). */
-export type AuditWriteHandler = (payload: unknown, ctx: JobContext) => Effect.Effect<unknown, JobFailure, DbBackend>;
+export type AuditWriteHandler = (payload: AuditWritePayload, 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

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

@@ -1,7 +1,7 @@
 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";
+import type { EmbeddingModelConfig } from "../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
@@ -29,7 +29,7 @@ export interface TopicVectorRow {
 /** A memory embedding row from a per-model memory vector table (raw SQL boundary shape). */
 export interface MemoryVectorRow {
     readonly memoryId: string;
-    readonly vector: number[];
+    readonly vector: readonly number[];
 }
 /**
  * Canonical row of a `graphNeighbors` traversal.
@@ -54,12 +54,23 @@ export interface GraphNeighborsOptions {
     readonly maxNeighbors?: number;
     readonly maxTotal?: number;
     readonly includePending?: boolean;
+    /** Restrict traversal to these edge kinds (default: all). The common
+     * ask is memory-only navigation: pass the three `memory_*` kinds to
+     * keep the topic/concept legs out of the answer. */
+    readonly edgeKinds?: readonly string[];
     /** 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;
 }
+/** Metadata filter keys for `queryByMetadata` — `topic` (LIKE on
+ * `$.topics`) and `sourceType` (equality on `$.sourceType`); unknown keys
+ * are ignored (see the SQL in libsql-backend). */
+export interface MetadataFilter {
+    readonly topic?: string;
+    readonly sourceType?: string;
+}
 export interface Interface {
     readonly runMigrations: () => Effect.Effect<void, StoreError>;
     /**
@@ -77,31 +88,58 @@ export interface Interface {
      * `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 listIsolatedMemories: (limit: number, modelKey?: string) => Effect.Effect<readonly 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 ftsSearch: (query: string, namespace: string, limit: number, topicKeys?: ReadonlyArray<string>, modelKey?: string, contentType?: string | ReadonlyArray<string>, 
+    /** Include the 384-float `embedding` blob per row (default false —
+     * search results never need vectors; write paths read them via
+     * fetchMemoryVectors). */
+    includeEmbedding?: boolean) => Effect.Effect<readonly unknown[], StoreError>;
+    readonly vectorSearch: (query: ReadonlyArray<number>, namespace: string, limit: number, model: EmbeddingModelConfig, topicKeys?: ReadonlyArray<string>, contentType?: string | ReadonlyArray<string>, includeEmbedding?: boolean) => Effect.Effect<readonly unknown[], StoreError>;
     readonly sweep: (namespace: string) => Effect.Effect<SweepResult, StoreError>;
+    /** The DB's tables + columns (`dimple db-schema` surface). */
+    readonly listSchema: () => Effect.Effect<ReadonlyArray<{
+        readonly table: string;
+        readonly columns: ReadonlyArray<{
+            readonly name: string;
+            readonly type: string;
+        }>;
+    }>, 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`
+     * like `ftsSearch`). Raw SQL, returns raw rows — 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 queryByMetadata: (filter: MetadataFilter, limit?: number) => Effect.Effect<readonly unknown[], StoreError>;
+    readonly graphNeighbors: (kind: "memory" | "topic" | "concept", id: string, opts?: GraphNeighborsOptions) => Effect.Effect<readonly unknown[], StoreError>;
     readonly ensureVectorTable: (model: EmbeddingModelConfig) => Effect.Effect<void, StoreError>;
     readonly insertVector: (memoryId: string, vector: ReadonlyArray<number>, model: EmbeddingModelConfig) => Effect.Effect<void, StoreError>;
+    /** Batch variant of `insertVector` — one multi-row statement (bulk
+     * ingest: per-memory statements dominate the write path). */
+    readonly insertVectors: (entries: ReadonlyArray<{
+        readonly memoryId: string;
+        readonly 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>;
+    /** Batch variant of `upsertTopicVector` — one multi-row statement (the
+     * bulk-routing path: sequential per-key upserts dominate batch ingest). */
+    readonly upsertTopicVectors: (entries: ReadonlyArray<{
+        readonly topicKey: string;
+        readonly 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>;
+    /** Single-row variant — the forget path's per-ancestor maintenance
+     * re-read the WHOLE table per level before (O(depth × N) decodes). */
+    readonly fetchTopicVector: (topicKey: string, model: EmbeddingModelConfig) => Effect.Effect<TopicVectorRow | undefined, StoreError>;
     readonly fetchMemoryVectors: (memoryIds: ReadonlyArray<string>, model: EmbeddingModelConfig) => Effect.Effect<ReadonlyArray<MemoryVectorRow>, StoreError>;
     readonly listMemoryIds: (model: EmbeddingModelConfig) => Effect.Effect<ReadonlyArray<string>, StoreError>;
 }

package/dist/internal/store/graph/candidates.d.ts

@@ -42,7 +42,7 @@ export interface CandidateMember {
     readonly metadata?: string | null;
 }
 /** Which rule produced a candidate (the provenance on `EdgeCandidate`). */
-export type CandidateKind = "near-duplicate" | "conflict-band" | "identity";
+export type CandidateKind = "near-duplicate" | "conflict-band" | "identity" | "rename";
 /** One rule-derived edge proposal from `leafLocalCandidates`. */
 export interface EdgeCandidate {
     readonly fromMemoryId: string;
@@ -81,6 +81,8 @@ export interface GraphCandidatesOptions {
     /** Max pending candidates returned (clamped to [1, 200]; default 50). */
     readonly limit?: number;
 }
+/** Cosine similarity of two vectors (equal-length; zero norm ⇒ 0). */
+export declare const cosineSimilarity: (a: Float32Array, b: Float32Array) => number;
 /**
  * The leaf-local candidate scan: compare the new memory against its
  * leaf-mates (per the module rules) and return at most one candidate per