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

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

@@ -5,6 +5,7 @@ export { topics };
 export { auditWriteHandler, type AuditWriteHandler } from "./audit.ts";
 export { TopicConfig } from "./schema/topics.ts";
 export type { AddEdgeInput, ExplainResult } from "./service.ts";
+export type { ArtifactEdge, EdgeKind, EdgeSource } from "./schema/graph.ts";
 export type { TopicHealth } from "./topics/observability.ts";
 export type { TopicConfig as TopicConfigType } from "./schema/topics.ts";
 export type { RetrievalAuditRow } from "./models.ts";

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

@@ -1,6 +1,7 @@
 import { Context, Effect } from "effect";
-import type { MemoryUnit, MemoryEvent, WriteMemoryInput, SweepResult, Concept } from "./models.ts";
+import type { MemoryUnit, MemoryEvent, WriteMemoryInput, SweepResult, Concept, ScoredMemory } from "./models.ts";
 import type { StoreError, NotFound, DuplicateActiveKey } from "./error.ts";
+import type { MetadataFilter } from "./db-backend.ts";
 import type { TopicError } from "./topics/errors.ts";
 import type { MaintenanceOutcome, RebalanceOutcome } from "./topics/maintenance.ts";
 import type { EmbeddingModelConfig } from "./internal/config/index.js";
@@ -65,21 +66,83 @@ export interface ExplainResult {
 }
 export interface Interface {
     readonly write: (input: WriteMemoryInput) => Effect.Effect<MemoryUnit, StoreError | DuplicateActiveKey>;
+    /** Bulk write: batch insert in ONE transaction (all-or-nothing; a
+     * duplicate logical key fails the whole batch with DuplicateActiveKey).
+     * The per-write graph candidate scan is NOT part of this — pair with
+     * `updateEmbedding(..., { scanCandidates: false })` for bulk ingest. */
+    readonly writeMany: (inputs: readonly WriteMemoryInput[]) => Effect.Effect<readonly 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;
+        /** Include the 384-float embedding on results (default false). */
+        readonly includeEmbedding?: boolean;
+        /** `false` skips the per-leg graph augmentation (fused-row callers). */
+        readonly augment?: boolean;
     }) => Effect.Effect<ReadonlyArray<AugmentedMemory>, StoreError>;
     readonly searchVector: (query: ReadonlyArray<number>, namespace: string, limit: number, opts?: {
         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;
+        /** Include the 384-float embedding on results (default false). */
+        readonly includeEmbedding?: boolean;
+        /** `false` skips the per-leg graph augmentation (fused-row callers). */
+        readonly augment?: boolean;
     }) => Effect.Effect<ReadonlyArray<AugmentedMemory>, StoreError>;
+    /** One-pass graph augmentation over an already-ranked result set (the
+     * hybrid path: the per-leg augment passes are skipped and the FUSED set
+     * gets one edge fetch + one concept fetch instead of two of each over
+     * 2× the rows). */
+    readonly augmentSearchResults: (results: ReadonlyArray<ScoredMemory>) => 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;
@@ -95,16 +158,32 @@ export interface Interface {
     readonly forget: (id: string) => Effect.Effect<void, NotFound | StoreError>;
     readonly sweep: (namespace: string) => Effect.Effect<SweepResult, StoreError>;
     readonly events: (memoryId: string) => Effect.Effect<readonly MemoryEvent[], StoreError>;
-    readonly updateEmbedding: (id: string, embedding: ReadonlyArray<number>, model: string) => Effect.Effect<void, NotFound | StoreError>;
+    readonly updateEmbedding: (id: string, embedding: ReadonlyArray<number>, model: string, options?: {
+        readonly scanCandidates?: boolean;
+    }) => Effect.Effect<void, NotFound | StoreError>;
+    /** Bulk variant of `updateEmbedding` — the writeMany path. One
+     * transaction for all memory updates + events, batch vector insert,
+     * and `routeInsertMany` (tree read once, all insertions computed in
+     * memory, one transaction). For NEW memories: the idempotent re-embed
+     * decrement is deliberately NOT part of the batch (use
+     * `updateEmbedding` for re-embedding existing routed memories).
+     * `scanCandidates` defaults to false-ish via the config: it runs only
+     * when explicitly requested AND `graph.enabled` is not false. */
+    readonly updateEmbeddingMany: (entries: ReadonlyArray<{
+        readonly id: string;
+        readonly embedding: ReadonlyArray<number>;
+    }>, model: string, options?: {
+        readonly scanCandidates?: boolean;
+    }) => Effect.Effect<void, StoreError>;
     readonly findStale: (model: string) => Effect.Effect<readonly string[], StoreError>;
     readonly createConcept: (name: string, embedding: ReadonlyArray<number>) => Effect.Effect<Concept, StoreError>;
     readonly getConcept: (id: string) => Effect.Effect<Concept, NotFound | StoreError>;
     readonly listConcepts: () => Effect.Effect<readonly Concept[], StoreError>;
     readonly annotateMemory: (memoryId: string, conceptId: string, confidence?: number) => Effect.Effect<void, NotFound | StoreError>;
     readonly getMemoryAnnotations: (memoryId: string) => Effect.Effect<readonly string[], StoreError>;
-    readonly queryByMetadata: (filter: Record<string, unknown>) => Effect.Effect<readonly MemoryUnit[], StoreError>;
+    readonly queryByMetadata: (filter: MetadataFilter) => 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/internal/store/topics/jobs.d.ts

@@ -127,8 +127,14 @@ export interface TopicSplitHandlerDeps {
      */
     readonly backend?: DbBackendInterface;
 }
+/** The decoded `topic.split` payload — mirrors the queue definition's
+ * schema (`{ topicId, modelKey }`); the executor decodes before calling. */
+export interface TopicSplitPayload {
+    readonly topicId: string;
+    readonly modelKey: string;
+}
 /** The `topic.split` handler shape — `unknown` success like `JobRegistry.Handler`. */
-export type TopicSplitHandler = (payload: unknown, ctx: JobContext) => Effect.Effect<unknown, JobFailure, DbBackend>;
+export type TopicSplitHandler = (payload: TopicSplitPayload, ctx: JobContext) => Effect.Effect<unknown, JobFailure, DbBackend>;
 /**
  * Factory for the `topic.split` job handler.
  *

package/dist/internal/store/topics/lifecycle.d.ts

@@ -112,8 +112,14 @@ export interface MemoryEmbedHandlerDeps {
     /** Backend captured at registration (see {@link topicSplitHandler}). */
     readonly backend?: DbBackendInterface;
 }
+/** The decoded `memory.embed` payload — mirrors the queue definition's
+ * schema (`{ memoryId, modelKey }`); the executor decodes before calling. */
+export interface MemoryEmbedPayload {
+    readonly memoryId: string;
+    readonly modelKey: string;
+}
 /** The `memory.embed` handler shape (see jobs.ts). */
-export type MemoryEmbedHandler = (payload: unknown, ctx: JobContext) => Effect.Effect<unknown, JobFailure, DbBackend>;
+export type MemoryEmbedHandler = (payload: MemoryEmbedPayload, ctx: JobContext) => Effect.Effect<unknown, JobFailure, DbBackend>;
 /**
  * Factory for the `memory.embed` job handler: re-embeds one memory with the
  * target model and routes it into that model's tree. The success schema is

package/dist/internal/store/topics/maintenance.d.ts

@@ -89,8 +89,14 @@ export interface TopicMaintenanceHandlerDeps {
     /** Backend captured at registration (see {@link topicSplitHandler}). */
     readonly backend?: DbBackendInterface;
 }
-/** The `topic.merge` / `topic.rebalance` handler shape (see jobs.ts). */
-export type TopicMaintenanceHandler = (payload: unknown, ctx: JobContext) => Effect.Effect<unknown, JobFailure, DbBackend>;
+/** The decoded `topic.merge` / `topic.rebalance` payload — mirrors the
+ * queue definitions' schema (`{ topicId, modelKey }`); the executor
+ * decodes before calling. */
+export interface TopicMaintenancePayload {
+    readonly topicId: string;
+    readonly modelKey: string;
+}
+export type TopicMaintenanceHandler = (payload: TopicMaintenancePayload, ctx: JobContext) => Effect.Effect<unknown, JobFailure, DbBackend>;
 /**
  * Factory for the `topic.merge` job handler: resolves the model, runs
  * {@link mergeOrBorrow}, returns `undefined` (the definition's success

package/dist/internal/store/topics/routing.d.ts

@@ -88,3 +88,36 @@ export declare const routeInsert: (memoryId: string, vector: ReadonlyArray<numbe
     topicKey: string;
     overflow: boolean;
 }, TopicError | StoreError, DbBackend>;
+/**
+ * Batch routing — the bulk-ingest path (`Store.updateEmbeddingMany`).
+ *
+ * Sequential `routeInsert` re-reads the WHOLE tree (all topics, all
+ * relations, all centroid sum-vectors) and commits its own transaction
+ * PER UNIT — measured ~42 ms/unit under bulk ingest, dominating the
+ * write path. This variant:
+ *
+ * 1. Reads the tree structure + sum-vectors ONCE.
+ * 2. Routes every entry against an IN-MEMORY mirror of the tree state,
+ *    applying each unit's CF updates locally before the next descent —
+ *    so the descents are bit-identical to sequential routeInsert calls
+ *    against the DB (same reads, same writes, same order).
+ * 3. Applies ALL membership inserts + topic CF updates in ONE
+ *    transaction (per-topic deltas accumulated in memory).
+ * 4. Writes the derived sum vectors in ONE batched upsert (backend
+ *    `upsertTopicVectors`), still after commit (backend not
+ *    transaction-aware — see module docs).
+ *
+ * Contract differences vs sequential: all-or-nothing (a validation
+ * failure or structural corruption rejects the whole batch), and the
+ * batch does NOT handle re-embedding (no membership decrement path) —
+ * it is for NEW memories; re-embedding existing ones goes through
+ * `routeInsert`/`Store.updateEmbedding`.
+ */
+export declare const routeInsertMany: (entries: readonly {
+    readonly memoryId: string;
+    readonly vector: ReadonlyArray<number>;
+}[], model: EmbeddingModelConfig, config: TopicConfig) => Effect.Effect<readonly {
+    readonly memoryId: string;
+    readonly topicKey: string;
+    readonly overflow: boolean;
+}[], TopicError | StoreError, DbBackend>;

package/dist/internal/store/topics/topic-vectors.d.ts

@@ -9,10 +9,17 @@ import { type SQLWrapper } from "drizzle-orm";
 /** Per-model topic vector table name (mirrors libsql-backend.ts — canonical). */
 export declare const topicVectorTableName: (model: EmbeddingModelConfig) => string;
 /** vectorType → libSQL conversion function for the sum-vector column. */
-export declare const VECTOR_CONVERT_FNS: Readonly<Record<string, string>>;
-/** Anything with a `.run(sql)` — a Drizzle tx or the db handle. */
+export declare const VECTOR_CONVERT_FNS: {
+    readonly float32: "vector32";
+    readonly float16: "vector16";
+    readonly float8: "vector8";
+    readonly float1bit: "vector1bit";
+};
+/** Anything with a `.run(sql)` — a Drizzle tx or the db handle. The raw
+ * result is discarded by every caller (DELETE statements only), so the
+ * contract is fire-and-forget. */
 export interface SqlRunner {
-    readonly run: (query: string | SQLWrapper<unknown>) => unknown;
+    readonly run: (query: string | SQLWrapper<unknown>) => void;
 }
 /** Delete one topic's sum-vector row (merge absorbs the sibling's row). */
 export declare const deleteTopicVectorRow: (runner: SqlRunner, model: EmbeddingModelConfig, topicKey: string) => Promise<void>;

package/dist/internal/store/topics/tree.d.ts

@@ -91,10 +91,13 @@ export declare const canonicalOrder: (vectors: readonly Float32Array[]) => reado
  * For fewer than 2 vectors returns `{ a: 0, b: 0 }` (degenerate — callers
  * guard on counts before splitting). Never mutates input.
  */
-export declare const farthestPair: (vectors: readonly Float32Array[]) => {
-    a: number;
-    b: number;
-};
+/** The farthest-seed pair — `a` is fixed by the canonical order; `b` is
+ * the vector with the lowest dot product against `a`. */
+export interface FarthestPair {
+    readonly a: number;
+    readonly b: number;
+}
+export declare const farthestPair: (vectors: readonly Float32Array[]) => FarthestPair;
 /**
  * Assign every vector to group 0 or 1 by higher dot product against the
  * seed vectors at `seedA` / `seedB`; ties go to group 0 (smaller index).
@@ -119,11 +122,14 @@ export declare const assignNearest: (vectors: readonly Float32Array[], seedA: nu
  *
  * Never mutates inputs.
  */
-export declare const lloydRefine: (vectors: readonly Float32Array[], groups: Uint8Array, passes: number) => {
-    groups: Uint8Array;
-    leftCf: CfTriplet;
-    rightCf: CfTriplet;
-};
+/** Outcome of the Lloyd refinement — the assignment plus each group's
+ * CF triplet (the split-plan acceptance gates read these). */
+export interface LloydRefineResult {
+    readonly groups: Uint8Array;
+    readonly leftCf: CfTriplet;
+    readonly rightCf: CfTriplet;
+}
+export declare const lloydRefine: (vectors: readonly Float32Array[], groups: Uint8Array, passes: number) => LloydRefineResult;
 /** Outcome of {@link splitPlan} — accepted splits plus the acceptance gate diagnostics. */
 export interface SplitPlanResult {
     readonly accepted: boolean;

package/dist/internal/workflow/executor.d.ts

@@ -38,7 +38,7 @@ export declare const workerLayer: (defs: readonly JobDefinition.Any[], options?:
  * Requires the full stack (JobRuntime + engine + queue + registry); use
  * `workerLayer` for persistent processes instead.
  */
-export declare const inline: (def: JobDefinition.Any, payload: unknown, options?: {
+export declare const inline: <P>(def: JobDefinition.Any, payload: P, options?: {
     readonly concurrency?: number;
     readonly maxAttempts?: number;
 }) => Effect.Effect<unknown, unknown, WorkflowEngine.WorkflowEngine | PersistedQueue.PersistedQueueFactory | JobRegistry | JobRuntime>;

package/dist/internal/workflow/persistence.d.ts

@@ -56,7 +56,7 @@ export interface ResumeSignal extends Schema.Schema.Type<typeof ResumeSignal> {
  */
 export declare const ExecutionRecord: Schema.Struct<{
     readonly workflowTag: Schema.String;
-    readonly payload: Schema.$Record<Schema.String, Schema.Unknown>;
+    readonly payload: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
 }>;
 export interface ExecutionRecord extends Schema.Schema.Type<typeof ExecutionRecord> {
 }

package/dist/internal/workflow/queue.d.ts

@@ -75,8 +75,11 @@ export declare class JobDefinition<Payload extends Workflow.AnyStructSchema = Wo
     /**
      * Decodes an envelope back to `{ payload }`. Built in `make` where the
      * schema types are concrete; the erased `Any` form widens the result.
+     * The engine delivers the workflow payload per its `register` contract
+     * (the decoded envelope type); the runtime decode below re-validates it
+     * against the envelope schema before the payload reaches the queue.
      */
-    readonly decodeEnvelope: (envelope: unknown) => Effect.Effect<{
+    readonly decodeEnvelope: (envelope: EnvelopeSchema<Payload>["Type"]) => Effect.Effect<{
         readonly payload: Payload["Type"];
     }, never, Payload["DecodingServices"] | Payload["EncodingServices"]>;
     constructor(args: {
@@ -87,7 +90,7 @@ export declare class JobDefinition<Payload extends Workflow.AnyStructSchema = Wo
         readonly successSchema: Success;
         readonly errorSchema: Error;
         readonly idempotencyKey: (payload: Payload["Type"]) => string;
-        readonly decodeEnvelope: (envelope: unknown) => Effect.Effect<{
+        readonly decodeEnvelope: (envelope: EnvelopeSchema<Payload>["Type"]) => Effect.Effect<{
             readonly payload: Payload["Type"];
         }, never, Payload["DecodingServices"] | Payload["EncodingServices"]>;
     });
@@ -145,7 +148,7 @@ export declare namespace JobDefinition {
         readonly successSchema: Schema.Top;
         readonly errorSchema: Schema.Top;
         readonly idempotencyKey: (payload: any) => string;
-        readonly decodeEnvelope: (envelope: unknown) => Effect.Effect<{
+        readonly decodeEnvelope: (envelope: any) => Effect.Effect<{
             readonly payload: unknown;
         }, never, unknown>;
         readonly register: (engine: WorkflowEngine.WorkflowEngine["Service"]) => Effect.Effect<void, never, Scope.Scope | PersistedQueue.PersistedQueueFactory>;

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

@@ -29,7 +29,7 @@ export interface JobContext {
  * decoded payload and returns the job's success value (or fails with
  * `JobFailure`); the runtime owns retries/leases.
  */
-export type Handler = (payload: unknown, ctx: JobContext) => Effect.Effect<unknown, JobFailure>;
+export type Handler = (payload: any, ctx: JobContext) => Effect.Effect<unknown, JobFailure>;
 /**
  * JobRegistry service contract.
  *

package/dist/internal/workflow/signals.d.ts

@@ -0,0 +1,21 @@
+/**
+ * In-process execution-completion signals — the event side of `Runtime.wait`.
+ *
+ * `wait` used to poll the persisted `${jobId}/result` key every 250ms. The
+ * engine knows the exact completion moment, so it now notifies a per-
+ * executionId set of Deferreds; `wait` races the signal against its poll
+ * interval (the poll stays as the fallback for cross-process waits, where
+ * the completing engine lives in another process).
+ *
+ * Plain module-level Map — no Effect service: the signal is a fire-and-
+ * forget wakeup, and the subscribers are runtime-layer Deferreds. Cleanup
+ * on unsubscribe keeps the map from leaking job ids.
+ */
+import { Deferred, Effect } from "effect";
+/** Subscribe to one execution's completion. */
+export declare const onExecutionDone: (executionId: string, deferred: Deferred.Deferred<void>) => void;
+/** Unsubscribe (wait's finally — the poll fallback may still be running). */
+export declare const offExecutionDone: (executionId: string, deferred: Deferred.Deferred<void>) => void;
+/** Fire every subscriber's deferred (the engine's completion tap) — an
+ * Effect the caller forks, so no Effect.run* leaks into package code. */
+export declare const notifyExecutionDone: (executionId: string) => Effect.Effect<void>;

package/dist/make.d.ts

@@ -16,6 +16,12 @@ export type MakeDimpleOptions = {
 } | {
     readonly core: CoreOptions;
 };
+/** What changed between the live config and the resolved one. */
+export interface ConfigDiff {
+    readonly storeUrl: boolean;
+    readonly jobsUrl: boolean;
+    readonly rest: boolean;
+}
 /**
  * Create the Dimple facade — resolves once the composed system is fully
  * booted. One runtime is built from the application layer; `runPromise`
@@ -23,5 +29,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.1",
+  "version": "0.0.0-alpha.10",
   "private": false,
   "files": [
     "dist"
@@ -29,10 +29,12 @@
     "typecheck": "tsgo --noEmit"
   },
   "dependencies": {
-    "@ai-sdk/openai-compatible": "^1.0.0",
-    "@huggingface/transformers": "^4.2.0",
+    "@ai-sdk/amazon-bedrock": "^5.0.46",
+    "@ai-sdk/cohere": "^3",
+    "@ai-sdk/google": "^2",
+    "@ai-sdk/openai-compatible": "^3.0.21",
     "@libsql/client": "^0.17.4",
-    "ai": "^5.0.0",
+    "ai": "^7.0.50",
     "drizzle-orm": "^1.0.0-rc.4",
     "effect": "4.0.0-beta.103",
     "jsonc-parser": "^3.3.1",
@@ -40,6 +42,12 @@
     "zod": "^4.4.3"
   },
   "peerDependencies": {
+    "@huggingface/transformers": "^4.0.0",
     "typescript": "^5"
+  },
+  "peerDependenciesMeta": {
+    "@huggingface/transformers": {
+      "optional": true
+    }
   }
 }

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

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