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

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/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 {

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

@@ -4,10 +4,10 @@
  * 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 { 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.

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

package/package.json

@@ -1,7 +1,25 @@
 {
   "name": "@ponraaj/dimple-sdk",
-  "version": "0.0.0-alpha.10",
+  "version": "0.0.0-alpha.11",
   "private": false,
+  "description": "Local-first memory for AI agents: durable text and code memories with hybrid semantic and lexical retrieval.",
+  "keywords": [
+    "ai-agents",
+    "embeddings",
+    "libsql",
+    "local-first",
+    "memory",
+    "semantic-search"
+  ],
+  "homepage": "https://dimple.ponraaj.me",
+  "bugs": {
+    "url": "https://github.com/Ponraaj/dimple/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Ponraaj/dimple.git",
+    "directory": "packages/sdk"
+  },
   "files": [
     "dist"
   ],
@@ -23,11 +41,6 @@
   "publishConfig": {
     "access": "public"
   },
-  "scripts": {
-    "build": "rm -rf dist && bun build ./src/index.ts --outdir ./dist --target node --format esm --external effect --external zod --external ai --external \"@ai-sdk/*\" --external @libsql/client --external drizzle-orm --external jsonc-parser --external \"@huggingface/transformers\" --external web-tree-sitter && tsgo -p tsconfig.build.json --outDir dist/.raw && bun scripts/internalize-dts.ts",
-    "prepack": "bun run build",
-    "typecheck": "tsgo --noEmit"
-  },
   "dependencies": {
     "@ai-sdk/amazon-bedrock": "^5.0.46",
     "@ai-sdk/cohere": "^3",
@@ -36,7 +49,7 @@
     "@libsql/client": "^0.17.4",
     "ai": "^7.0.50",
     "drizzle-orm": "^1.0.0-rc.4",
-    "effect": "4.0.0-beta.103",
+    "effect": "4.0.0",
     "jsonc-parser": "^3.3.1",
     "web-tree-sitter": "^0.26.9",
     "zod": "^4.4.3"
@@ -49,5 +62,8 @@
     "@huggingface/transformers": {
       "optional": true
     }
+  },
+  "engines": {
+    "node": ">=22"
   }
 }

package/dist/internal/wasm/grammar-store.d.ts

@@ -1,14 +0,0 @@
-import { Context, Effect, Layer } from "effect";
-import { GrammarProvisionError } from "@dimple/shared/errors";
-import { Service as TreeSitterRegistry } from "./wasm-registry";
-import { Service as WasmDownloader } from "./wasm-downloader";
-import { Service as WasmCache } from "./wasm-cache";
-export interface Interface {
-    readonly ensure: (lang: string) => Effect.Effect<string, GrammarProvisionError>;
-}
-declare const Service_base: Context.ServiceClass<Service, "@dimple/wasm/GrammarStore", Interface>;
-export declare class Service extends Service_base {
-}
-export declare const layer: Layer.Layer<Service, never, TreeSitterRegistry | WasmDownloader | WasmCache>;
-export declare const allLive: Layer.Layer<TreeSitterRegistry | WasmDownloader | WasmCache | Service, never, never>;
-export {};

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

@@ -1,5 +0,0 @@
-export { Service as TreeSitterRegistry } from "./wasm-registry";
-export type { GrammarMetaData } from "./wasm-registry";
-export { Service as WasmDownloader } from "./wasm-downloader";
-export { Service as WasmCache, layer as wasmCacheLayer } from "./wasm-cache";
-export { Service as GrammarStore, layer as grammarStoreLayer, allLive as GrammarStoreAllLive, } from "./grammar-store";

package/dist/internal/wasm/wasm-cache.d.ts

@@ -1,17 +0,0 @@
-import { Context, Effect, Layer } from "effect";
-import { WasmCacheError } from "@dimple/shared/errors";
-/**
- * Grammar WASM cache — downloads are staged to a temp file and renamed
- * into place (an interrupted download never leaves a corrupt parser).
- * Plain `node:fs` (NOT @effect/platform-bun): the bundled SDK runs on
- * Node too (the CLI's shebang spawns node), so Bun-specific filesystem
- * layers are off the table.
- */
-export interface Interface {
-    readonly ensure: (lang: string, version: string, download: Effect.Effect<Uint8Array>) => Effect.Effect<string, WasmCacheError>;
-}
-declare const Service_base: Context.ServiceClass<Service, "@dimple/wasm/WasmCache", Interface>;
-export declare class Service extends Service_base {
-}
-export declare const layer: Layer.Layer<Service, never, never>;
-export {};

package/dist/internal/wasm/wasm-downloader.d.ts

@@ -1,10 +0,0 @@
-import { Context, Effect, Layer } from "effect";
-import { WasmDownloadError } from "@dimple/shared/errors";
-export interface Interface {
-    readonly download: (url: string) => Effect.Effect<Uint8Array, WasmDownloadError>;
-}
-declare const Service_base: Context.ServiceClass<Service, "@dimple/wasm/WasmDownloader", Interface>;
-export declare class Service extends Service_base {
-    static readonly layer: Layer.Layer<Service, never, never>;
-}
-export {};

package/dist/internal/wasm/wasm-registry.d.ts

@@ -1,16 +0,0 @@
-import { Context, Effect, Layer, Schema } from "effect";
-import { RegistryError } from "@dimple/shared/errors";
-declare const GrammarMetaDataSchema: Schema.Struct<{
-    readonly lang: Schema.String;
-    readonly version: Schema.String;
-    readonly url: Schema.String;
-}>;
-export type GrammarMetaData = typeof GrammarMetaDataSchema.Type;
-export interface Interface {
-    readonly resolve: (lang: string) => Effect.Effect<GrammarMetaData, RegistryError>;
-}
-declare const Service_base: Context.ServiceClass<Service, "@dimple/wasm/TreeSitterRegistry", Interface>;
-export declare class Service extends Service_base {
-    static readonly layer: Layer.Layer<Service, never, never>;
-}
-export {};

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

@@ -1,5 +0,0 @@
-import { Layer } from "effect";
-import { PersistedQueue } from "effect/unstable/persistence";
-import { SqlClient, SqlError } from "effect/unstable/sql";
-/** Provide the FIXED store to effect's `PersistedQueue.layer`. */
-export declare const storeSqliteLayer: Layer.Layer<PersistedQueue.PersistedQueueStore, SqlError.SqlError, SqlClient.SqlClient>;