@ponraaj/dimple-sdk 0.0.0-alpha.4 → 0.0.0-alpha.5

package/dist/indexer.d.ts

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

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

@@ -30,6 +30,12 @@ export declare const EmbeddingModelConfig: Schema.Struct<{
     readonly pooling: Schema.optional<Schema.Literals<readonly ["mean", "cls", "none"]>>;
     readonly normalize: Schema.optional<Schema.Boolean>;
     readonly cacheDir: Schema.optional<Schema.String>;
+    /** First-use auto-install of the optional `@huggingface/transformers`
+     * peer (default true) — the package is installed with the project's
+     * own package manager on the first local-embed use (scripts skipped,
+     * proven unnecessary for embedding). Set false to require a manual
+     * install. */
+    readonly autoInstall: Schema.optional<Schema.Boolean>;
 }>;
 export interface EmbeddingModelConfig extends Schema.Schema.Type<typeof EmbeddingModelConfig> {
 }
@@ -59,6 +65,12 @@ export declare const EmbeddingConfig: Schema.Struct<{
         readonly pooling: Schema.optional<Schema.Literals<readonly ["mean", "cls", "none"]>>;
         readonly normalize: Schema.optional<Schema.Boolean>;
         readonly cacheDir: Schema.optional<Schema.String>;
+        /** First-use auto-install of the optional `@huggingface/transformers`
+         * peer (default true) — the package is installed with the project's
+         * own package manager on the first local-embed use (scripts skipped,
+         * proven unnecessary for embedding). Set false to require a manual
+         * install. */
+        readonly autoInstall: Schema.optional<Schema.Boolean>;
     }>>;
 }>;
 export interface EmbeddingConfig extends Schema.Schema.Type<typeof EmbeddingConfig> {
@@ -151,6 +163,12 @@ export declare const DimpleConfig: Schema.Struct<{
             readonly pooling: Schema.optional<Schema.Literals<readonly ["mean", "cls", "none"]>>;
             readonly normalize: Schema.optional<Schema.Boolean>;
             readonly cacheDir: Schema.optional<Schema.String>;
+            /** First-use auto-install of the optional `@huggingface/transformers`
+             * peer (default true) — the package is installed with the project's
+             * own package manager on the first local-embed use (scripts skipped,
+             * proven unnecessary for embedding). Set false to require a manual
+             * install. */
+            readonly autoInstall: Schema.optional<Schema.Boolean>;
         }>>;
     }>>;
     readonly jobs: Schema.optional<Schema.Struct<{

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

@@ -0,0 +1,35 @@
+/**
+ * First-use auto-install of the OPTIONAL `@huggingface/transformers` peer.
+ *
+ * `@huggingface/transformers` is an optional peer (its tree pulls the
+ * `sharp` + `onnxruntime-node` postinstall scripts that abort npm 11
+ * installs). When the config declares a `transformers` provider model,
+ * the intent is explicit — so the FIRST local-embed use installs the
+ * package automatically with the project's own package manager, instead
+ * of failing with a manual step.
+ *
+ * Safety notes:
+ * - The install is scoped to the detected project root (the manifest's
+ *   directory) and uses the manager the project already uses.
+ * - EVERY install runs `--ignore-scripts` (npm/pnpm/yarn) or bun's
+ *   default script-blocking — verified harmless: the onnxruntime-node
+ *   binaries ship in the package; its postinstall is not required for
+ *   embedding, and sharp is never loaded for text embeddings.
+ * - Failure (offline, restricted env) is a typed EmbeddingError with the
+ *   manual command — never a crash.
+ */
+export type PackageManager = "bun" | "npm" | "pnpm" | "yarn";
+export interface InstallTarget {
+    readonly pm: PackageManager;
+    readonly root: string;
+}
+/** Detect the project's package manager by walking UP from `cwd` for a
+ * lockfile (bun.lock/bun.lockb → bun, package-lock.json → npm,
+ * pnpm-lock.yaml → pnpm, yarn.lock → yarn). Falls back to bun + cwd. */
+export declare const detectPackageManager: (cwd: string) => InstallTarget;
+/** The install argv for a manager. `--ignore-scripts` on npm/pnpm/yarn:
+ * the blocked postinstalls are proven unnecessary for embedding (bun
+ * blocks them by default already). */
+export declare const installCommand: (pm: PackageManager) => readonly [string, ...string[]];
+/** Run the install for the project at `cwd`; rejects on non-zero exit. */
+export declare const installTransformers: (cwd: string) => Promise<void>;

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

@@ -1,6 +1,9 @@
 import { Config, Layer } from "effect";
-import type { DeviceType } from "@huggingface/transformers";
 import { Service, type EmbeddingModel } from "./provider.ts";
+/** Mirror of transformers.js's `DeviceType` (the config schema carries the
+ * same literals) — kept local so the optional peer's types never appear
+ * in this module's surface. */
+type DeviceType = "auto" | "gpu" | "cpu" | "wasm" | "webgpu" | "cuda" | "dml" | "coreml" | "webnn";
 interface TransformersOptions {
     readonly modelId?: string;
     readonly device?: DeviceType;
@@ -11,6 +14,12 @@ interface TransformersOptions {
     /** Declared output dimension — validated against the model's actual
      * output on first embed (a mismatch fails typed, precisely). */
     readonly dimensions?: number;
+    /** First-use auto-install of the optional `@huggingface/transformers`
+     * peer (default true): the config declaring a transformers provider is
+     * explicit intent — the missing package is installed with the project's
+     * own package manager (scripts skipped; proven unnecessary for
+     * embedding). Set false to require a manual install. */
+    readonly autoInstall?: boolean;
 }
 export declare const makeTransformersModel: (options?: TransformersOptions) => EmbeddingModel;
 export declare const layer: (options?: TransformersOptions) => Layer.Layer<Service>;

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

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

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

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

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

@@ -1,4 +1,4 @@
-import { Config, Context, Layer, Logger } from "effect";
+import { Config, Context, Effect, Layer, Logger } from "effect";
 import type { Scope } from "effect/Scope";
 import { RingBuffer } from "./ring.ts";
 import { type LogConfig, type LogEntry } from "./types.ts";
@@ -9,24 +9,32 @@ 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;
+/** Effect variant of `make` — builds the file sink through lazy `node:fs`
+ * (see `fileSink`; the console sink is sync). */
+export declare const makeEffect: (config: LogConfig) => Effect.Effect<Interface>;
 /** The structured shape Effect's `Logger.formatStructured` emits. */
 export interface StructuredOutput {
     readonly level: string;

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

@@ -54,6 +54,10 @@ 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
@@ -80,9 +84,17 @@ export interface Interface {
     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 ftsSearch: (query: string, namespace: string, limit: number, topicKeys?: ReadonlyArray<string>, modelKey?: string, contentType?: string | ReadonlyArray<string>) => Effect.Effect<readonly Record<string, unknown>[], StoreError>;
+    readonly vectorSearch: (query: ReadonlyArray<number>, namespace: string, limit: number, model: EmbeddingModelConfig, topicKeys?: ReadonlyArray<string>, contentType?: string | ReadonlyArray<string>) => Effect.Effect<readonly Record<string, 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>;

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

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

@@ -11,7 +11,7 @@ export declare const MemoryUnit: Schema.Struct<{
     readonly contentType: Schema.String;
     readonly state: Schema.Literals<readonly ["active", "superseded", "archived", "forgotten"]>;
     readonly createdAt: Schema.Number;
-    readonly ttlSecs: Schema.Number;
+    readonly ttlSecs: Schema.NullOr<Schema.Number>;
     readonly namespace: Schema.String;
     readonly metadata: Schema.optional<Schema.String>;
     readonly embedding: Schema.optional<Schema.$Array<Schema.Number>>;
@@ -24,7 +24,7 @@ export declare const WriteMemoryInput: Schema.Struct<{
     readonly content: Schema.String;
     readonly contentType: Schema.optional<Schema.String>;
     readonly namespace: Schema.optional<Schema.String>;
-    readonly ttlSecs: Schema.optional<Schema.Number>;
+    readonly ttlSecs: Schema.optional<Schema.NullOr<Schema.Number>>;
     readonly metadata: Schema.optional<Schema.String>;
     /** Typed overlay merged INTO the raw metadata blob on write (unknown blob
      * keys preserved. Takes precedence over `metadata`. */
@@ -38,6 +38,7 @@ export declare const WriteMemoryInput: Schema.Struct<{
         readonly confidence: Schema.Number;
         readonly affordances: Schema.$Array<Schema.String>;
         readonly language: Schema.optional<Schema.String>;
+        readonly codeVersion: Schema.optional<Schema.String>;
         readonly pinned: Schema.optional<Schema.Boolean>;
     }>>;
 }>;
@@ -51,7 +52,7 @@ export declare const ScoredMemory: Schema.Struct<{
         readonly contentType: Schema.String;
         readonly state: Schema.Literals<readonly ["active", "superseded", "archived", "forgotten"]>;
         readonly createdAt: Schema.Number;
-        readonly ttlSecs: Schema.Number;
+        readonly ttlSecs: Schema.NullOr<Schema.Number>;
         readonly namespace: Schema.String;
         readonly metadata: Schema.optional<Schema.String>;
         readonly embedding: Schema.optional<Schema.$Array<Schema.Number>>;

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

@@ -74,14 +74,14 @@ export declare const artifactEdges: import("drizzle-orm/sqlite-core").SQLiteTabl
             name: string;
             tableName: "artifact_edges";
             dataType: "string enum";
-            data: "memory_contradicts" | "memory_supersedes" | "memory_supports";
+            data: "code_calls" | "memory_contradicts" | "memory_supersedes" | "memory_supports";
             driverParam: string;
             notNull: true;
             hasDefault: false;
             isPrimaryKey: false;
             isAutoincrement: false;
             hasRuntimeDefault: false;
-            enumValues: ["memory_supports", "memory_supersedes", "memory_contradicts"];
+            enumValues: ["memory_supports", "memory_supersedes", "memory_contradicts", "code_calls"];
             baseColumn: never;
             identity: undefined;
             generated: undefined;
@@ -218,7 +218,7 @@ export declare const artifactEdges: import("drizzle-orm/sqlite-core").SQLiteTabl
     dialect: 'sqlite';
 }>;
 /** The memory↔memory edge kinds `artifact_edges` can hold (the only kinds in the lean table). */
-export type EdgeKind = "memory_supports" | "memory_supersedes" | "memory_contradicts";
+export type EdgeKind = "memory_supports" | "memory_supersedes" | "memory_contradicts" | "code_calls";
 /** Writers of edges (provenance on every row). */
 export type EdgeSource = "rule" | "llm" | "agent";
 export declare const ArtifactEdgeInsert: import("drizzle-orm/effect-schema").BuildSchema<"insert", {
@@ -274,14 +274,14 @@ export declare const ArtifactEdgeInsert: import("drizzle-orm/effect-schema").Bui
         name: string;
         tableName: "artifact_edges";
         dataType: "string enum";
-        data: "memory_contradicts" | "memory_supersedes" | "memory_supports";
+        data: "code_calls" | "memory_contradicts" | "memory_supersedes" | "memory_supports";
         driverParam: string;
         notNull: true;
         hasDefault: false;
         isPrimaryKey: false;
         isAutoincrement: false;
         hasRuntimeDefault: false;
-        enumValues: ["memory_supports", "memory_supersedes", "memory_contradicts"];
+        enumValues: ["memory_supports", "memory_supersedes", "memory_contradicts", "code_calls"];
         baseColumn: never;
         identity: undefined;
         generated: undefined;
@@ -468,14 +468,14 @@ export declare const ArtifactEdgeSelect: import("drizzle-orm/effect-schema").Bui
         name: string;
         tableName: "artifact_edges";
         dataType: "string enum";
-        data: "memory_contradicts" | "memory_supersedes" | "memory_supports";
+        data: "code_calls" | "memory_contradicts" | "memory_supersedes" | "memory_supports";
         driverParam: string;
         notNull: true;
         hasDefault: false;
         isPrimaryKey: false;
         isAutoincrement: false;
         hasRuntimeDefault: false;
-        enumValues: ["memory_supports", "memory_supersedes", "memory_contradicts"];
+        enumValues: ["memory_supports", "memory_supersedes", "memory_contradicts", "code_calls"];
         baseColumn: never;
         identity: undefined;
         generated: undefined;

package/dist/internal/store/schema/libsql.d.ts

@@ -104,7 +104,7 @@ export declare const memories: import("drizzle-orm/sqlite-core").SQLiteTableWith
             dataType: "number int53";
             data: number;
             driverParam: number;
-            notNull: true;
+            notNull: false;
             hasDefault: true;
             isPrimaryKey: false;
             isAutoincrement: false;
@@ -847,7 +847,7 @@ export declare const MemoryInsert: import("drizzle-orm/effect-schema").BuildSche
         dataType: "number int53";
         data: number;
         driverParam: number;
-        notNull: true;
+        notNull: false;
         hasDefault: true;
         isPrimaryKey: false;
         isAutoincrement: false;
@@ -1025,7 +1025,7 @@ export declare const MemorySelect: import("drizzle-orm/effect-schema").BuildSche
         dataType: "number int53";
         data: number;
         driverParam: number;
-        notNull: true;
+        notNull: false;
         hasDefault: true;
         isPrimaryKey: false;
         isAutoincrement: false;
@@ -1203,7 +1203,7 @@ export declare const MemoryUpdate: import("drizzle-orm/effect-schema").BuildSche
         dataType: "number int53";
         data: number;
         driverParam: number;
-        notNull: true;
+        notNull: false;
         hasDefault: true;
         isPrimaryKey: false;
         isAutoincrement: false;

package/dist/internal/store/schema/metadata.d.ts

@@ -27,6 +27,9 @@ export declare const MemoryMetadata: Schema.Struct<{
     readonly affordances: Schema.$Array<Schema.String>;
     /** Code-specific: "typescript" | "rust" | ... */
     readonly language: Schema.optional<Schema.String>;
+    /** Code-specific: the repo HEAD at index time (the indexer's
+     * provenance stamp — which commit this unit came from). */
+    readonly codeVersion: Schema.optional<Schema.String>;
     /** Writer-set pin: the memory is deliberately stable — automatic graph
      * lifecycle moves should leave it alone. */
     readonly pinned: Schema.optional<Schema.Boolean>;
@@ -48,4 +51,4 @@ export declare const encodeMetadata: (metadata: MemoryMetadata) => string;
  * does not declare (producer-specific extensions) survives. A malformed
  * existing blob is treated as empty — the merge never throws.
  */
-export declare const mergeMetadataBlob: (existing: string | null | undefined, typed: MemoryMetadata) => string;
+export declare const mergeMetadataBlob: (existing: string | null | undefined, typed: Partial<MemoryMetadata>) => string;

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

@@ -65,11 +65,44 @@ export interface ExplainResult {
 }
 export interface Interface {
     readonly write: (input: WriteMemoryInput) => Effect.Effect<MemoryUnit, StoreError | DuplicateActiveKey>;
+    /** Upsert for the index path — the identity rule (same logical key ⇒
+     * confirmed `memory_supersedes`) made reachable for ACTIVE keys: demote
+     * the active holder of the key (if any), write the new unit, and link
+     * old → new with a confirmed rule edge, all in ONE transaction. Returns
+     * the new memory plus the superseded id (when a predecessor existed). */
+    readonly writeSuperseding: (input: WriteMemoryInput) => Effect.Effect<{
+        readonly memory: MemoryUnit;
+        readonly supersededId?: string;
+    }, StoreError | DuplicateActiveKey>;
+    /** Index reconciliation — demote every ACTIVE unit under `keyPrefix`
+     * that is (a) INSIDE the walked domain (its file path is under one of
+     * `walkedRoots`, joined against `keyRoot`) and (b) not among `keptKeys`
+     * (this run's unit keys — files AND chunks: a chunk the extractor no
+     * longer emits, e.g. a deleted function inside a surviving file, is
+     * vanished). Demotion is `source_removed` (one transaction). Returns the demoted
+     * rows for the rename-candidate scan. Units outside the walked domain
+     * (subtree runs) and normal (non-index) memories are never touched. */
+    readonly reconcile: (namespace: string, keyPrefix: string, keyRoot: string, walkedRoots: readonly string[], keptKeys: readonly string[]) => Effect.Effect<readonly {
+        readonly id: string;
+        readonly logicalKey: string;
+        readonly embedding: number[] | null;
+    }[], StoreError>;
+    /** Rename/move detection (human-gated): cosine each vanished unit's
+     * stored embedding against this run's new units; ≥ the near-duplicate
+     * band → a PENDING `memory_supersedes` candidate (source rule, never
+     * auto-confirms — a rename is a guess). Returns the new-candidate count. */
+    readonly reconcileRenameCandidates: (vanished: readonly {
+        readonly id: string;
+        readonly embedding: number[] | null;
+    }[], newUnitIds: readonly string[]) => Effect.Effect<number, StoreError>;
     readonly get: (id: string) => Effect.Effect<MemoryUnit, NotFound | StoreError>;
     readonly getByKey: (key: string, namespace: string) => Effect.Effect<MemoryUnit, NotFound | StoreError>;
     readonly recency: (namespace: string, limit: number) => Effect.Effect<ReadonlyArray<AugmentedMemory>, StoreError>;
     readonly searchFts5: (query: string, namespace: string, limit: number, opts?: {
         readonly topicKeys?: ReadonlyArray<string>;
+        /** Content-type filter: one kind or a list (code-vs-message
+         * separation lever at query time). */
+        readonly contentType?: string | ReadonlyArray<string>;
         /** `false` suppresses the per-leg audit row (fused-row callers). */
         readonly audit?: boolean;
     }) => Effect.Effect<ReadonlyArray<AugmentedMemory>, StoreError>;
@@ -77,9 +110,20 @@ export interface Interface {
         readonly topicKeys?: ReadonlyArray<string>;
         /** Restrict to memories annotated with ANY of these concept ids. */
         readonly conceptIds?: ReadonlyArray<string>;
+        /** Content-type filter: one kind or a list (code-vs-message
+         * separation lever at query time). */
+        readonly contentType?: string | ReadonlyArray<string>;
         /** `false` suppresses the per-leg audit row (fused-row callers). */
         readonly audit?: boolean;
     }) => Effect.Effect<ReadonlyArray<AugmentedMemory>, 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>;
     /** One fused retrieval-audit row (the hybrid path's audit contract). */
     readonly logAudit: (input: {
         readonly query: string;
@@ -104,7 +148,7 @@ export interface Interface {
     readonly getMemoryAnnotations: (memoryId: string) => Effect.Effect<readonly string[], StoreError>;
     readonly queryByMetadata: (filter: Record<string, unknown>) => Effect.Effect<readonly MemoryUnit[], StoreError>;
     readonly getMemoryMetadata: (id: string) => Effect.Effect<MemoryMetadata | undefined, NotFound | StoreError>;
-    readonly setMemoryMetadata: (id: string, metadata: MemoryMetadata) => Effect.Effect<void, NotFound | StoreError>;
+    readonly setMemoryMetadata: (id: string, metadata: Partial<MemoryMetadata>) => Effect.Effect<void, NotFound | StoreError>;
     readonly ensureTopicTree: (modelKey: string) => Effect.Effect<{
         rootKey: string;
         unassignedKey: string;

package/dist/make.d.ts

@@ -23,5 +23,26 @@ export type MakeDimpleOptions = {
  * Boot failures reject with the same closed `DimpleError` surface as the
  * facade methods (never raw Effect internals) and close the owned
  * resources (scope + runtime) before rethrowing.
+ *
+ * ### Reload (see `Dimple.reload`)
+ *
+ * The facade owns a mutable `LiveStack` cell. A reload:
+ *
+ * 1. re-resolves the config source TYPED (schema errors reject before
+ *    anything pauses — a bad config has zero impact);
+ * 2. pauses: new calls wait on the gate, calls already in flight settle on
+ *    the OLD stack;
+ * 3. boots a fresh stack from the re-resolved config;
+ * 4. drains (waits the in-flight count to zero, bounded by
+ *    `RELOAD_DRAIN_MS`), then swaps the cell and disposes the old stack
+ *    (worker fleet stops, clients close);
+ * 5. releases the gate. Boot or drain failure leaves the old stack
+ *    untouched — the reload rejects and the system keeps serving the
+ *    previous config (blue-green).
+ *
+ * Durable jobs make the pause safe: a handler interrupted by the old
+ * stack's disposal has its lease expire and is re-claimed after boot;
+ * handlers are idempotent by design (transactions roll back, watermarks
+ * advance only on success).
  */
 export declare const makeDimple: (options: MakeDimpleOptions) => Promise<Dimple>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ponraaj/dimple-sdk",
-  "version": "0.0.0-alpha.4",
+  "version": "0.0.0-alpha.5",
   "private": false,
   "files": [
     "dist"
@@ -33,7 +33,6 @@
     "@ai-sdk/cohere": "^3",
     "@ai-sdk/google": "^2",
     "@ai-sdk/openai-compatible": "^3.0.21",
-    "@huggingface/transformers": "^4.2.0",
     "@libsql/client": "^0.17.4",
     "ai": "^7.0.50",
     "drizzle-orm": "^1.0.0-rc.4",
@@ -43,6 +42,12 @@
     "zod": "^4.4.3"
   },
   "peerDependencies": {
+    "@huggingface/transformers": "^4.0.0",
     "typescript": "^5"
+  },
+  "peerDependenciesMeta": {
+    "@huggingface/transformers": {
+      "optional": true
+    }
   }
 }