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

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,6 +1,6 @@
 import { Effect } from "effect";
 import type { RetrievalAuditRow } from "./models.ts";
-import { JobFailure, type Handler, type JobContext } from "./internal/workflow/index.js";
+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

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.

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

@@ -39,8 +39,8 @@
  * the active model stays 384-dim.
  */
 import { Effect } from "effect";
-import { JobFailure, type Handler, type JobContext } from "./internal/workflow/index.js";
-import type { EmbeddingModelConfig } from "./internal/config/index.js";
+import { JobFailure, type Handler, type JobContext } from "../../workflow/index.js";
+import type { EmbeddingModelConfig } from "../../config/index.js";
 import { Service as DbBackend } from "../db-backend.ts";
 import type { Interface as DbBackendInterface } from "../db-backend.ts";
 import { StoreError } from "../error.ts";

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

@@ -58,8 +58,8 @@
  * Effect Clock (observability only).
  */
 import { Effect } from "effect";
-import { JobFailure, type Handler, type JobContext } from "./internal/workflow/index.js";
-import type { EmbeddingModelConfig } from "./internal/config/index.js";
+import { JobFailure, type Handler, type JobContext } from "../../workflow/index.js";
+import type { EmbeddingModelConfig } from "../../config/index.js";
 import { Service as DbBackend } from "../db-backend.ts";
 import type { Interface as DbBackendInterface } from "../db-backend.ts";
 /** One memory pair judged by the classifier (older first — the direction

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

@@ -4,7 +4,7 @@ declare const EdgeNotFound_base: Schema.Class<EdgeNotFound, Schema.TaggedStruct<
 }>, import("effect/Cause").YieldableError>;
 /**
  * Graph error types (mirror of `topics/errors.ts`). Each distinct failure
- * mode gets its own `Schema.TaggedErrorClass` so callers can `catchTag`
+ * mode gets its own `Schema.TaggedError` so callers can `catchTag`
  * precisely; they ride the public `Store` error channel alongside
  * `StoreError`.
  */

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

@@ -38,8 +38,8 @@
  * simply finds nothing to fix).
  */
 import { Effect } from "effect";
-import { JobFailure, type Handler, type JobContext } from "./internal/workflow/index.js";
-import type { EmbeddingModelConfig } from "./internal/config/index.js";
+import { JobFailure, type Handler, type JobContext } from "../../workflow/index.js";
+import type { EmbeddingModelConfig } from "../../config/index.js";
 import { Service as DbBackend } from "../db-backend.ts";
 import type { Interface as DbBackendInterface } from "../db-backend.ts";
 /** How many rows of each class one repair pass fixed. */

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

@@ -28,12 +28,12 @@ export { Service as DbBackend, type DrizzleDB } from "./db-backend.ts";
 export { Service as Store } from "./service.ts";
 export * from "./models.ts";
 export { layer as dbBackendLayer, layerConfig as dbBackendLayerConfig, layerFromConfig as dbBackendLayerFromConfig, } from "./libsql-backend.ts";
-export { layer as storeLayer, layerConfig as storeLayerConfig, layerFromConfig as storeLayerFromConfig, } from "./store.ts";
+export { layer as storeLayer, layerConfig as storeLayerConfig, layerFromConfig as storeLayerFromConfig, configured as storeConfigured, node as storeNode, } from "./store.ts";
 export declare const layer: (url: string, options?: {
     migrationFolder?: string;
-}) => import("effect/Layer").Layer<import("./internal/logger/index.js").Logging | import("./db-backend.ts").Service | import("./service.ts").Service, import("./error.ts").StoreError, import("effect/Scope").Scope>;
+}) => import("effect/Layer").Layer<import("../logger/index.js").Logging | import("./db-backend.ts").Service | import("./service.ts").Service, import("./error.ts").StoreError, never>;
 export declare const layerConfig: (config: Config.Wrap<{
     url: string;
 }>, options?: {
     migrationFolder?: string;
-}) => import("effect/Layer").Layer<import("./internal/logger/index.js").Logging | import("./db-backend.ts").Service | import("./service.ts").Service, Config.ConfigError | import("./error.ts").StoreError, import("effect/Scope").Scope>;
+}) => import("effect/Layer").Layer<import("../logger/index.js").Logging | import("./db-backend.ts").Service | import("./service.ts").Service, Config.ConfigError | import("./error.ts").StoreError, never>;

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

@@ -1,7 +1,7 @@
 import { Layer, Config, Scope } from "effect";
 import { StoreError } from "./error.ts";
 import { Service } from "./db-backend.ts";
-import { Service as ConfigService } from "./internal/config/index.js";
+import { Service as ConfigService } from "../config/index.js";
 export declare const layer: (url: string, options?: {
     migrationFolder?: string;
     releaseClient?: boolean;

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

@@ -1,16 +1,4 @@
 import { Schema } from "effect";
-/**
- * Mirrors `Schema.optionalWith(schema, { default })` from newer Effect versions.
- *
- * Effect 4.0.0-beta.99 (the pinned version) does not ship `optionalWith`;
- * `optional` + `withDecodingDefaultType` is semantically identical: 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>>;
 /**
  * The deterministic topic hierarchy. One ACTIVE tree per model;
  * retired trees keep their rows (status `inactive`) so the switch is

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

@@ -4,7 +4,7 @@ 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";
+import type { EmbeddingModelConfig } from "../config/index.js";
 import type { Topic, TopicChangeLog } from "./schema/topics.ts";
 import type { ArtifactEdge, EdgeKind, EdgeSource } from "./schema/graph.ts";
 import type { AugmentedMemory } from "./graph/retrieval-post-pass.ts";
@@ -130,10 +130,11 @@ export interface Interface {
         /** `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). */
+    /** One-pass graph augmentation over an already-ranked result set. The
+     * store exposes it for fused-row callers; the hybrid retriever does not
+     * call it yet, so fused results carry no graph fields. A wired caller
+     * gets one edge fetch + one concept fetch over the fused rows instead of
+     * two of each per leg. */
     readonly augmentSearchResults: (results: ReadonlyArray<ScoredMemory>) => Effect.Effect<ReadonlyArray<AugmentedMemory>, StoreError>;
     /** The DB's tables + columns (`dimple db-schema` surface). */
     readonly listSchema: () => Effect.Effect<ReadonlyArray<{

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

@@ -4,9 +4,9 @@ import type { RetrievalAuditRow } from "./models.ts";
 import { Service as DbBackend } from "./db-backend.ts";
 import { Service } from "./service.ts";
 import { StoreError } from "./error.ts";
-import { Service as ConfigService } from "./internal/config/index.js";
-import { type LogConfig, type Logging } from "./internal/logger/index.js";
-import type { EmbeddingModelConfig } from "./internal/config/index.js";
+import { Service as ConfigService } from "../config/index.js";
+import { type LogConfig, type Logging } from "../logger/index.js";
+import type { EmbeddingModelConfig } from "../config/index.js";
 import type { TopicConfig as TopicConfigType } from "./schema/topics.ts";
 import { GraphConfig } from "./schema/graph.ts";
 /**
@@ -57,14 +57,33 @@ export declare const layer: (url: string, options?: {
     /** Default TTL for writes that omit `ttlSecs` (the config's
      * `defaultTtlSecs`; default 604800). */
     defaultTtlSecs?: number;
-}) => Layer.Layer<Logging | DbBackend | Service, StoreError, Scope>;
+}) => Layer.Layer<Logging | DbBackend | Service, StoreError, never>;
+/**
+ * OpenCode-style node declaration for {@link layer} (the layer graph module
+ * at `@dimple/shared/effect`).
+ *
+ * `deps` stays empty on purpose: the store's production seams
+ * (`topics.enqueueSplit` / `enqueueMerge` / `enqueueAudit`) are effects
+ * built over `JobRuntime`, so the composition root owns the wiring — a node
+ * cannot own a dependency it is itself configured with. The options type is
+ * read off `layer` (`Parameters<typeof layer>[1]`) so the declaration can
+ * never drift from the layer it wraps.
+ */
+export declare const configured: (url: string, options?: Parameters<typeof layer>[1]) => import("../core/index.js").LayerProvider<Logging | DbBackend | Service, StoreError, undefined>;
+/** The default store node — the local libSQL database under `.dimple/`. */
+export declare const node: import("../core/index.js").LayerProvider<Logging | DbBackend | Service, StoreError, undefined>;
 export declare const layerConfig: (config: Config.Wrap<{
     url: string;
 }>, options?: {
     migrationFolder?: string;
     embeddingModelConfig?: EmbeddingModelConfig;
-}) => Layer.Layer<Logging | DbBackend | Service, Config.ConfigError | StoreError, Scope>;
+}) => Layer.Layer<Logging | DbBackend | Service, Config.ConfigError | StoreError, never>;
 export declare const layerFromConfig: (options?: {
     migrationFolder?: string;
 }) => Layer.Layer<Service | DbBackend | Logging, StoreError, ConfigService | Scope>;
+/** The dimple.jsonc `logging` section, installed unconditionally — a
+ * DISABLED config when the section is absent (silent-by-default: library
+ * logging is opt-in, and every `Effect.log*` in the system routes through
+ * `@dimple/logger` either way). The silent config itself comes from the
+ * logger package, the one source of truth. */
 export declare const loggingFromConfig: Layer.Layer<Logging, never, ConfigService | Scope>;

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

@@ -4,7 +4,7 @@ declare const TopicNotFound_base: Schema.Class<TopicNotFound, Schema.TaggedStruc
 }>, import("effect/Cause").YieldableError>;
 /**
  * Topic-tree error types. Each distinct failure mode gets its
- * own `Schema.TaggedErrorClass` so callers can `catchTag` precisely.
+ * own `Schema.TaggedError` so callers can `catchTag` precisely.
  * `TopicError` is the tagged union; individual classes are exported for
  * pattern matching.
  */

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

@@ -12,8 +12,8 @@ export * from "./tree.ts";
 export * from "./routing.ts";
 export * from "./query.ts";
 export * from "./lifecycle.ts";
-export { memoryEmbedHandler } from "./lifecycle.ts";
-export type { MemoryEmbedHandler, MemoryEmbedHandlerDeps } from "./lifecycle.ts";
+export { memoryEmbedHandler, memoryEmbedBatchHandler } from "./lifecycle.ts";
+export type { MemoryEmbedHandler, MemoryEmbedHandlerDeps, MemoryEmbedBatchHandler, MemoryEmbedBatchPayload, } from "./lifecycle.ts";
 export * from "./errors.ts";
 export { splitTopic, topicSplitHandler, shouldSplit } from "./jobs.ts";
 export type { SplitOutcome, TopicSplitHandler, TopicSplitHandlerDeps } from "./jobs.ts";

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

@@ -46,8 +46,8 @@
  * (the canonical source — keep both in sync).
  */
 import { Effect } from "effect";
-import { JobFailure, type Handler, type JobContext } from "./internal/workflow/index.js";
-import type { EmbeddingModelConfig } from "./internal/config/index.js";
+import { JobFailure, type Handler, type JobContext } from "../../workflow/index.js";
+import type { EmbeddingModelConfig } from "../../config/index.js";
 import { Service as DbBackend } from "../db-backend.ts";
 import type { Interface as DbBackendInterface } from "../db-backend.ts";
 import { StoreError } from "../error.ts";

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

@@ -56,12 +56,12 @@
  * (observability only — never read by routing).
  */
 import { Effect } from "effect";
-import type { EmbeddingModelConfig } from "./internal/config/index.js";
+import type { EmbeddingModelConfig } from "../../config/index.js";
 import { Service as DbBackend } from "../db-backend.ts";
 import type { TopicConfig } from "../schema/topics.ts";
 import type { TopicError } from "./errors.ts";
 import { NotFound, StoreError } from "../error.ts";
-import { JobFailure, type Handler, type JobContext } from "./internal/workflow/index.js";
+import { JobFailure, type Handler, type JobContext } from "../../workflow/index.js";
 import type { Interface as DbBackendInterface } from "../db-backend.ts";
 /** Result of {@link setActiveModel}. */
 export interface SetActiveModelResult {
@@ -120,6 +120,16 @@ export interface MemoryEmbedPayload {
 }
 /** The `memory.embed` handler shape (see jobs.ts). */
 export type MemoryEmbedHandler = (payload: MemoryEmbedPayload, ctx: JobContext) => Effect.Effect<unknown, JobFailure, DbBackend>;
+/** The decoded `memory.embed.batch` payload — mirrors the queue
+ * definition's schema; `nonce` only keeps distinct enqueues distinct. */
+export interface MemoryEmbedBatchPayload {
+    readonly memoryIds: readonly string[];
+    readonly modelKey: string;
+    readonly nonce: string;
+}
+/** The `memory.embed.batch` handler shape — the same deps as the per-memory
+ * handler; ids are embedded one at a time, in payload order. */
+export type MemoryEmbedBatchHandler = (payload: MemoryEmbedBatchPayload, 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
@@ -130,3 +140,18 @@ export declare function memoryEmbedHandler(deps: MemoryEmbedHandlerDeps & {
     readonly backend: DbBackendInterface;
 }): Handler;
 export declare function memoryEmbedHandler(deps: MemoryEmbedHandlerDeps): MemoryEmbedHandler;
+/**
+ * Factory for the `memory.embed.batch` job handler: the same outcome as the
+ * per-memory job for a whole list of ids, with the STORE phase batched —
+ * one tree seed, one vector-table seed, one membership SELECT, one vector
+ * insert, one routing pass, one embedding-column UPDATE for the whole batch
+ * (per-id repeats of those dominated a 235-unit drain). The EMBED step stays
+ * per id (one model forward pass per text). A stale id (memory gone) is a
+ * success no-op, exactly like the per-memory job's; a real failure fails the
+ * ONE job, naming how many ids failed and the first failure — ids that did
+ * succeed stay committed, and a redelivery re-runs them idempotently.
+ */
+export declare function memoryEmbedBatchHandler(deps: MemoryEmbedHandlerDeps & {
+    readonly backend: DbBackendInterface;
+}): Handler;
+export declare function memoryEmbedBatchHandler(deps: MemoryEmbedHandlerDeps): MemoryEmbedBatchHandler;

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

@@ -31,8 +31,8 @@
  * Effect Clock (captured outside the tx closure) — observability only.
  */
 import { Effect } from "effect";
-import { JobFailure, type Handler, type JobContext } from "./internal/workflow/index.js";
-import type { EmbeddingModelConfig } from "./internal/config/index.js";
+import { JobFailure, type Handler, type JobContext } from "../../workflow/index.js";
+import type { EmbeddingModelConfig } from "../../config/index.js";
 import { Service as DbBackend } from "../db-backend.ts";
 import type { Interface as DbBackendInterface } from "../db-backend.ts";
 import { StoreError } from "../error.ts";

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

@@ -24,7 +24,7 @@
  * ranking still runs in libSQL (`vectorSearch` with `topic_key IN (...)`).
  */
 import { Effect } from "effect";
-import type { EmbeddingModelConfig } from "./internal/config/index.js";
+import type { EmbeddingModelConfig } from "../../config/index.js";
 import { Service as DbBackend } from "../db-backend.ts";
 import type { TopicConfig } from "../schema/topics.ts";
 import type { TopicError } from "./errors.ts";

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

@@ -38,7 +38,7 @@
  * transaction-aware vector methods, move the upserts onto the tx.
  */
 import { Effect } from "effect";
-import type { EmbeddingModelConfig } from "./internal/config/index.js";
+import type { EmbeddingModelConfig } from "../../config/index.js";
 import { Service as DbBackend } from "../db-backend.ts";
 import type { TopicConfig } from "../schema/topics.ts";
 import type { TopicError } from "./errors.ts";

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

@@ -4,7 +4,7 @@
  * dynamic (not Drizzle tables), so every writer goes through this raw-SQL
  * helper — one canonical place for the table name + conversion function.
  */
-import type { EmbeddingModelConfig } from "./internal/config/index.js";
+import type { EmbeddingModelConfig } from "../../config/index.js";
 import { type SQLWrapper } from "drizzle-orm";
 /** Per-model topic vector table name (mirrors libsql-backend.ts — canonical). */
 export declare const topicVectorTableName: (model: EmbeddingModelConfig) => string;

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

@@ -28,9 +28,9 @@
  * `Schema.Unknown` Persistable keys — see persistence.ts for why.
  */
 import { Layer } from "effect";
-import { WorkflowEngine } from "effect/unstable/workflow";
-import { Persistence as PersistenceNamespace, PersistedQueue } from "effect/unstable/persistence";
-import { SqlError as SqlErrorNamespace } from "effect/unstable/sql";
+import { WorkflowEngine } from "effect/workflow";
+import { Persistence as PersistenceNamespace, PersistedQueue } from "effect/persistence";
+import { SqlError as SqlErrorNamespace } from "effect/sql";
 type SqlError = SqlErrorNamespace.SqlError;
 /**
  * Durable WorkflowEngine layer.
@@ -40,6 +40,14 @@ type SqlError = SqlErrorNamespace.SqlError;
  * (same `Encoded` contract into `makeUnsafe`).
  */
 export declare const layerDurable: Layer.Layer<WorkflowEngine.WorkflowEngine, never, PersistedQueue.PersistedQueueFactory | PersistenceNamespace.Persistence>;
+/**
+ * Shared libSQL stack: SQL persistence + resume-queue store over one
+ * `LibsqlClient`. Provides `Persistence | PersistedQueueFactory`, dep-free.
+ *
+ * The single libSQL connection is shared by the engine's store and the
+ * resume queue — both `Persistence.layerSql` and `PersistedQueue.layerStoreSql`
+ * create their own tables in the same file.
+ */
 export declare const libsqlStack: (options: {
     readonly url: string;
 }) => Layer.Layer<PersistedQueue.PersistedQueueFactory | PersistenceNamespace.Persistence, SqlErrorNamespace.SqlError, never>;
@@ -51,4 +59,20 @@ export declare const libsqlStack: (options: {
 export declare const layerDurableLibsql: (options: {
     readonly url: string;
 }) => Layer.Layer<WorkflowEngine.WorkflowEngine, SqlError>;
+/**
+ * OpenCode-style node declarations for the two libSQL-backed layers above.
+ *
+ * The convention's single `configured` name is per-layer, and this module
+ * exposes two, so each is declared under its layer's name; the shape
+ * (`make({ name, layer })`, empty `deps` — the root wires the runtime, the
+ * registry and the store) is unchanged. Neither gets a default `node`: both
+ * require a `url`, and a node that guessed one would silently point a
+ * durable engine at the wrong database.
+ */
+export declare const libsqlStackConfigured: (options: {
+    readonly url: string;
+}) => import("../core/index.js").LayerProvider<PersistedQueue.PersistedQueueFactory | PersistenceNamespace.Persistence, SqlErrorNamespace.SqlError, undefined>;
+export declare const layerDurableLibsqlConfigured: (options: {
+    readonly url: string;
+}) => import("../core/index.js").LayerProvider<WorkflowEngine.WorkflowEngine, SqlErrorNamespace.SqlError, undefined>;
 export {};

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

@@ -14,10 +14,11 @@
  * resumes the awaiting workflow (facade `submit`) and persists the result.
  */
 import { Duration, Effect, Layer } from "effect";
-import { WorkflowEngine } from "effect/unstable/workflow";
-import { PersistedQueue } from "effect/unstable/persistence";
-import { type LogConfig } from "./internal/logger/index.js";
-import type { JobDefinition } from "./queue.ts";
+import { WorkflowEngine } from "effect/workflow";
+import { PersistedQueue } from "effect/persistence";
+import { type LogConfig } from "../logger/index.js";
+import { type Graph } from "../shared/effect/node.js";
+import { type JobDefinition } from "./queue.ts";
 import { Service as JobRegistry } from "./registry.ts";
 import { Service as JobRuntime } from "./runtime.ts";
 export declare const workerLayer: (defs: readonly JobDefinition.Any[], options?: {
@@ -27,7 +28,20 @@ export declare const workerLayer: (defs: readonly JobDefinition.Any[], options?:
      * [1, 100]. */
     readonly maxAttempts?: number;
     readonly logging?: LogConfig;
-}) => Layer.Layer<never, never, PersistedQueue.PersistedQueueFactory | JobRegistry | WorkflowEngine.WorkflowEngine> | Layer.Layer<import("./internal/logger/index.js").Logging, never, PersistedQueue.PersistedQueueFactory | import("effect/Scope").Scope | JobRegistry | WorkflowEngine.WorkflowEngine>;
+}) => Layer.Layer<never, never, PersistedQueue.PersistedQueueFactory | JobRegistry | WorkflowEngine.WorkflowEngine>;
+/**
+ * OpenCode-style node declaration for {@link workerLayer}.
+ *
+ * Workers need `WorkflowEngine` + `PersistedQueueFactory` (the job stack) and
+ * `JobRegistry`, and those providers are root-owned state: a package default
+ * would build a SECOND job stack and bind the worker to it, so there is no
+ * `node` export here — the caller passes them as the `deps` tuple and `make`
+ * checks that they cover the layer's requirements. The tuple elements may be
+ * any graph that provides at least the named services, and their build errors
+ * are preserved on the node. The options type is read off `workerLayer` so the
+ * declaration cannot drift from the layer it wraps.
+ */
+export declare const configured: <const RuntimeE, const RegistryE>(defs: readonly JobDefinition.Any[], options: Parameters<typeof workerLayer>[1], deps: readonly [Graph<PersistedQueue.PersistedQueueFactory | WorkflowEngine.WorkflowEngine, RuntimeE>, Graph<JobRegistry, RegistryE>]) => import("../core/index.js").LayerProvider<never, RegistryE | RuntimeE, undefined>;
 /**
  * Inline mode — run the worker in the same fiber scope as the submit.
  *

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

@@ -3,11 +3,11 @@
  *
  * Barrel: named exports with aliases (project convention).
  */
-export { JobDefinition, Envelope, TopicSplit, MemoryEmbed, TopicMerge, TopicRebalance, ConceptCluster, MemoryDream, GraphRepair, AuditWrite, type AuditRow, queues, type EnvelopeSchema, } from "./queue.ts";
-export { Service as JobRuntime, layer as jobRuntimeLayer, type Interface as JobRuntimeInterface, type JobStatus, } from "./runtime.ts";
-export { layerDurable, layerDurableLibsql } from "./engine.ts";
-export { Service as JobRegistry, layer as jobRegistryLayer, JobFailure, type Handler, type JobContext, } from "./registry.ts";
-export { workerLayer, inline, processQueues } from "./executor.ts";
+export { JobDefinition, Envelope, TopicSplit, MemoryEmbed, MemoryEmbedBatch, TopicMerge, TopicRebalance, ConceptCluster, MemoryDream, GraphRepair, AuditWrite, type AuditRow, queues, type EnvelopeSchema, } from "./queue.ts";
+export { Service as JobRuntime, layer as jobRuntimeLayer, configured as jobRuntimeConfigured, node as jobRuntimeNode, type Interface as JobRuntimeInterface, type JobStatus, } from "./runtime.ts";
+export { layerDurable, layerDurableLibsql, libsqlStackConfigured, layerDurableLibsqlConfigured, } from "./engine.ts";
+export { Service as JobRegistry, layer as jobRegistryLayer, configured as jobRegistryConfigured, node as jobRegistryNode, JobFailure, type Handler, type JobContext, } from "./registry.ts";
+export { workerLayer, configured as workersConfigured, inline, processQueues } from "./executor.ts";
 export { JobsConfig, JobsConfigDefaults, resolveJobsConfig } from "./config.ts";
 export { QueueError, UnknownJobType, RegistryError, ShutdownError, JobFailed, JobTimeout, JobCancelled, type JobRuntimeError, type JobsError, } from "./errors.ts";
 export { STORE_ID, RESUME_QUEUE, ResumeSignal, ExecutionRecord, encodedKey, resultCodecFor, payloadCodecFor, } from "./persistence.ts";

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

@@ -32,9 +32,9 @@
  *
  */
 import { Effect, Exit, Option, Schema } from "effect";
-import { Persistable, Persistence as PersistenceNamespace } from "effect/unstable/persistence";
+import { Persistable, Persistence as PersistenceNamespace } from "effect/persistence";
 type PersistenceStore = PersistenceNamespace.PersistenceStore;
-import { Workflow } from "effect/unstable/workflow";
+import { Workflow } from "effect/workflow";
 /** Single store id shared by engine + facade (one table partition in jobs.db). */
 export declare const STORE_ID = "dimple/jobs";
 /**

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

@@ -30,8 +30,8 @@
  *
  */
 import { Effect, Schema, Scope } from "effect";
-import { DurableQueue, Workflow, WorkflowEngine } from "effect/unstable/workflow";
-import { PersistedQueue } from "effect/unstable/persistence";
+import { DurableQueue, Workflow, WorkflowEngine } from "effect/workflow";
+import { PersistedQueue } from "effect/persistence";
 /**
  * Envelope schema factory — wraps a job's payload schema with the runtime
  * fields the workflow machinery needs.
@@ -173,6 +173,23 @@ export declare const MemoryEmbed: JobDefinition<Schema.Struct<{
     memoryId: Schema.String;
     modelKey: Schema.String;
 }>, Schema.Void, Schema.String>;
+/**
+ * Batch embedding backfill job — `memory.embed.batch`. Same work as
+ * `memory.embed`, one job for many memories: the bulk ingest path
+ * (`Dimple.index` with `deferEmbed`) would otherwise enqueue and drain one
+ * job per unit while the walk is still running.
+ *
+ * `nonce` keeps distinct enqueues distinct (the key function stays
+ * deterministic over the payload, so it can never collapse two different
+ * batches into one execution id); the handler is idempotent PER MEMORY, so a
+ * redelivered or overlapping batch re-embeds an already-embedded unit for
+ * nothing rather than corrupting it.
+ */
+export declare const MemoryEmbedBatch: JobDefinition<Schema.Struct<{
+    memoryIds: Schema.$Array<Schema.String>;
+    modelKey: Schema.String;
+    nonce: Schema.String;
+}>, Schema.Void, Schema.String>;
 /** Underflow maintenance job — `topic.merge` (borrow-then-merge). */
 export declare const TopicMerge: JobDefinition<Schema.Struct<{
     topicId: Schema.String;
@@ -270,6 +287,10 @@ export declare const queues: readonly [JobDefinition<Schema.Struct<{
 }>, Schema.Void, Schema.String>, JobDefinition<Schema.Struct<{
     memoryId: Schema.String;
     modelKey: Schema.String;
+}>, Schema.Void, Schema.String>, JobDefinition<Schema.Struct<{
+    memoryIds: Schema.$Array<Schema.String>;
+    modelKey: Schema.String;
+    nonce: Schema.String;
 }>, Schema.Void, Schema.String>, JobDefinition<Schema.Struct<{
     topicId: Schema.String;
     modelKey: Schema.String;

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

@@ -54,4 +54,14 @@ export declare class Service extends Service_base {
  * unknown resolve fails with `UnknownJobType`.
  */
 export declare const layer: Layer.Layer<Service, never, never>;
+/**
+ * OpenCode-style node declaration for the {@link layer} job registry.
+ *
+ * `deps` is empty: the registry is dependency-free by construction (handlers
+ * are registered by the composition root, which owns the runtime and the
+ * store they need).
+ */
+export declare const configured: () => import("../core/index.js").LayerProvider<Service, never, undefined>;
+/** The default registry node — the one the app graph always wires. */
+export declare const node: import("../core/index.js").LayerProvider<Service, never, undefined>;
 export {};

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

@@ -51,10 +51,10 @@
  *
  */
 import { Context, Duration, Effect, Layer, Schema } from "effect";
-import { Workflow, WorkflowEngine } from "effect/unstable/workflow";
-import { PersistedQueue, Persistence as PersistenceNamespace } from "effect/unstable/persistence";
-import { SqlError as SqlErrorNamespace } from "effect/unstable/sql";
-import type { JobDefinition } from "./queue.ts";
+import { Workflow, WorkflowEngine } from "effect/workflow";
+import { PersistedQueue, Persistence as PersistenceNamespace } from "effect/persistence";
+import { SqlError as SqlErrorNamespace } from "effect/sql";
+import { type JobDefinition } from "./queue.ts";
 import { type JobsError } from "./errors.ts";
 type SqlError = SqlErrorNamespace.SqlError;
 /**
@@ -158,4 +158,22 @@ export declare const layer: (defs: readonly JobDefinition.Any[]) => Layer.Layer<
 export declare const layerLibsql: (defs: readonly JobDefinition.Any[], options: {
     readonly url: string;
 }) => Layer.Layer<Service | WorkflowEngine.WorkflowEngine | PersistenceNamespace.Persistence | PersistedQueue.PersistedQueueFactory, SqlError>;
+/**
+ * OpenCode-style node declaration for {@link layerLibsql}.
+ *
+ * `deps` is empty: the libSQL client, the durable engine, persistence and
+ * the queue factory all arrive from the node's own layer; the root only adds
+ * what the *consumers* (workers, the store's job seams) need.
+ */
+export declare const configured: (defs: readonly JobDefinition.Any[], options: {
+    readonly url: string;
+}) => import("../core/index.js").LayerProvider<PersistedQueue.PersistedQueueFactory | PersistenceNamespace.Persistence | Service | WorkflowEngine.WorkflowEngine, SqlErrorNamespace.SqlError, undefined>;
+/**
+ * The default job-stack node — every built-in definition over the package's
+ * documented jobs database default (`JobsConfigDefaults.dbUrl`,
+ * `file:./.dimple/jobs.db`), the same value `resolveJobsConfig` fills when
+ * the `jobs` section omits `dbUrl`. Nothing is connected at import: the
+ * node only holds a lazily-built layer.
+ */
+export declare const node: import("../core/index.js").LayerProvider<PersistedQueue.PersistedQueueFactory | PersistenceNamespace.Persistence | Service | WorkflowEngine.WorkflowEngine, SqlErrorNamespace.SqlError, undefined>;
 export {};