@yolk-sdk/harness 0.1.0-canary.100

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Yolk SDK contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,206 @@
+# @yolk-sdk/harness
+
+Domain-free **run lifecycle** for Yolk agents: who owns a live run, how wakes coalesce, and how
+claims survive a crash. The model/tool loop stays in `@yolk-sdk/agent/loop`.
+
+Canary APIs are unstable. Keep all `@yolk-sdk/*` packages on the same version.
+
+## Install
+
+```bash
+pnpm add @yolk-sdk/harness@canary effect@4.0.0
+```
+
+## Subpaths
+
+| Subpath                                   | Purpose                                                                                                 |
+| ----------------------------------------- | ------------------------------------------------------------------------------------------------------- |
+| `@yolk-sdk/harness`                       | Tiny root                                                                                               |
+| `@yolk-sdk/harness/coordinator`           | Process-local doorbell coordinator                                                                      |
+| `@yolk-sdk/harness/store`                 | `RunStore` claim/release                                                                                |
+| `@yolk-sdk/harness/inbox`                 | Admission / steer / queue items; in-memory HITL park tokens (not durable)                               |
+| `@yolk-sdk/harness/driver`                | `Driver` + `makeHarness`                                                                                |
+| `@yolk-sdk/harness/driver/memory`         | In-memory driver for tests                                                                              |
+| `@yolk-sdk/harness/driver/durable-object` | Durable Object storage-backed claims + driver                                                           |
+| `@yolk-sdk/harness/outcome`               | Classify one model/tool attempt: Completed / Retry / Continue / RecoverFull / Compacted / AwaitingInput |
+
+## Tagged constructors
+
+Inbox, driver, and outcome ADTs are `Data.taggedEnum` **values** on the existing subpaths. They are
+plain objects with `_tag` last, not `Equal`/`Hash` Data classes.
+
+```ts
+import {
+  DrainBegin,
+  HitlDecision,
+  PauseDecision,
+  RecoveryAdmission,
+  RecoveryAttempt
+} from '@yolk-sdk/harness/inbox'
+import { StopDecision } from '@yolk-sdk/harness/driver'
+import { HitlMatch, OverflowCompactionResult, StepOutcome } from '@yolk-sdk/harness/outcome'
+```
+
+| Subpath   | Value constructors                                                                    |
+| --------- | ------------------------------------------------------------------------------------- |
+| `inbox`   | `HitlDecision`, `PauseDecision`, `RecoveryAttempt`, `RecoveryAdmission`, `DrainBegin` |
+| `driver`  | `StopDecision` (`Idle` / `Interrupted` / `ParkCleared`)                               |
+| `outcome` | `OverflowCompactionResult`, `StepOutcome`, `HitlMatch`                                |
+
+`StopDecision` is the same internal tagged enum, re-exported as `export type` + `export const` from
+`./driver`. Driver recovery uses Inbox `RecoveryAttempt` (`Skip` / `Exhausted` / `Resume`). Prefer
+`Match.tag` / `Predicate.isTagged` over `_tag ===`. `HitlMatch.Match({ requestId })` /
+`HitlMatch.Mismatch()` replace handwritten `{ _tag: 'Match' | 'Mismatch' }` objects.
+
+## Example
+
+Omitting `drain` uses a no-op (`Effect.void`): `driver.run` only claims and releases ownership. Attach host work with a custom drain. `Inbox.takePromotable` requires that drain's live `drainToken`.
+
+`@yolk-sdk/harness` is introduced after `0.1.0-canary.76`. It is unavailable in `0.1.0-canary.76` and earlier. Choose a newer matching canary once available.
+
+Setup:
+
+```bash
+pnpm add @yolk-sdk/harness@canary effect@4.0.0
+pnpm add -D tsx
+```
+
+Filename: `drain-example.mts`
+
+```ts
+import { Effect } from 'effect'
+import { admit, Driver, type Drain } from '@yolk-sdk/harness/driver'
+import { makeInMemoryHarnessLayer } from '@yolk-sdk/harness/driver/memory'
+import { Inbox } from '@yolk-sdk/harness/inbox'
+
+const drain: Drain = (runId, _force, scope, context) =>
+  Effect.gen(function* () {
+    const inbox = yield* Inbox
+    const item = yield* inbox.takePromotable(runId, scope, context.drainToken)
+    if (item === undefined) {
+      yield* Effect.sync(() => {
+        console.log(`no work for ${runId}`)
+      })
+      return
+    }
+    yield* Effect.sync(() => {
+      console.log(`drained ${item.id} for ${runId}`)
+    })
+  })
+
+const program = Effect.gen(function* () {
+  yield* admit({
+    id: 'item_1',
+    runId: 'run_1',
+    delivery: 'input',
+    kind: 'input'
+  })
+  const driver = yield* Driver
+  yield* driver.awaitIdle('run_1')
+}).pipe(Effect.provide(makeInMemoryHarnessLayer({ drain })))
+
+await Effect.runPromise(program)
+```
+
+Run:
+
+```bash
+pnpm exec tsx drain-example.mts
+```
+
+Expected output:
+
+```txt
+drained item_1 for run_1
+```
+
+Durable Object claim persistence requires host `load` / `save` callbacks on `makeDurableObjectDriverLayer`. That snapshot stores claimed ids and resume counts. Its Inbox is still in-memory and does not persist queued input, parked HITL, host closures, or transcript storage.
+
+Hosts still own tools, prompts, auth, HITL payload persistence, and `'use workflow'` / `'use step'` files. Durable Object claims ship as `@yolk-sdk/harness/driver/durable-object`. There is no Vercel Workflow driver in this package and no hook registry or `World`.
+
+`Driver.pause` / `resumeHitl` / `stop` compose HITL onto the existing coordinator. Inbox items have no payload. Protocol match helpers live in `@yolk-sdk/harness/outcome`. Parked waits are not durable and are not shutdown claims.
+
+## Token types
+
+`DrainToken` and `ParkGeneration` are distinct branded string schemas/types exported from
+`@yolk-sdk/harness/inbox`. Forward `context.drainToken` into dequeue/pause and the returned park
+generation into HITL admission. Custom adapters and typed fixtures must now construct or decode
+these types rather than return raw strings. JSON stays unchanged.
+
+The brands are nominal only: even an empty or forged string can decode. Inbox still checks live
+ownership and freshness; decoding does not authorize a token or make an old park restorable.
+
+## Restart contract
+
+Ownership is per shared Driver instance. The host or platform supplies cross-process exclusivity and quiesces producers before closing that instance. Raw administrative `RunStore` mutations must be quiesced with Driver; runtime claim ownership belongs to Driver.
+
+Startup is explicit: build the shared Driver/Inbox/Store, restore host-owned waiting checkpoints through `run` / `pause`, then call `Driver.resumeSuspended` before exposing ingress.
+
+`resumeSuspended` is a finite current-snapshot sweep. Candidate IDs are hints, not durable incarnation IDs. Under the Inbox admission gate it rechecks live coordinator activity then the current claim, skips blocked parks, and charges a validated `maxResumeAttempts` budget before granting pending input. Stop with no newer intent skips; a later idle claimed run with the same id may recover the current host checkpoint only. The sweep does not wait for drain settlement while holding that gate.
+
+`maxResumeAttempts` is a finite nonnegative safe integer. The default is 10. Exhausted eligible claims are released and those IDs are returned in `exhausted`. Active candidates and candidates with blocked parks are skipped and are not released. `0` schedules, drains, and increments nothing: the sweep still releases eligible candidates as exhausted. Zero is not a nonmutating pause that preserves those claims. Omitted args, whole options `undefined`, or explicit `undefined` `maxResumeAttempts` keeps Layer `E = never`. A numeric or `number | undefined` config types `InvalidMaxResumeAttempts` and fails Layer init for invalid values.
+
+`wake` / `resumeSuspended` schedule work; `awaitIdle` is quiescence, not a success receipt. `run` observes start and settlement failures. A failed `started` claim must not automatically release a prior or never-acquired claim. Explicit user-terminal authority (`Driver.stop` or generic `interrupt` defaulting to `user`) still releases a leftover claim after that owner has actually settled. Shutdown interrupt keeps the claim.
+
+### HITL contract
+
+- Hosts persist typed HITL payloads by `itemId`. Inbox stores only opaque generation, request ids, and response item ids.
+- Resume requires the current park generation plus `outcome.matchHitlResponse` / `resumeHitlIfMatched` kind/request/tool-call identity. Mismatch never wakes.
+- All sibling request ids must be answered before continuation. Partial accepts do not start a tool drain.
+- Host drain receives `DrainContext.drainToken` and `readyResponses`. Pause with that token; do not park from a stale token. `Inbox.takePromotable(runId, scope, drainToken)` also requires that live token and dequeues only while it still owns the run. Missing, empty, inactive, stale, or wrong-run tokens return `undefined` and leave the queue unchanged. This canary signature is intentionally required; there is no optional/unchecked take.
+- `Inbox.beginDrain(runId, scope)` and `wakeIfUnblocked(runId, scope, wake)` are scope-aware. Pending input subsumes steer. A steer drain does not consume a later input intent, so an input admitted after Coordinator captures steer still drains.
+- A successful drain that leased a Ready generation acknowledges and clears those refs. Failure or interruption keeps them (at-least-once). Host side effects must be idempotent.
+- Human pause releases the busy claim. User `stop` is terminal at the captured owner's settlement (including shutdown then user-stop). Shutdown interrupt keeps the claim. The Durable Object snapshot claim store does not make Inbox durable.
+- After process restart, hosts enumerate their own persisted waiting checkpoints and rebuild a fresh park with the current drain token. Do not import old Inbox parks, drain tokens, or generation strings. Correlate later responses to the new park and host identity policy. Persisted partial responses may be re-admitted only after protocol/host validation against that fresh park.
+
+## Type imports (breaking)
+
+Runtime/wire is unchanged. These public type exports were renamed; there are no `Shape` aliases.
+
+```ts
+import type { RunStoreApi } from '@yolk-sdk/harness/store'
+import type { InboxApi } from '@yolk-sdk/harness/inbox'
+import type { DriverApi } from '@yolk-sdk/harness/driver'
+```
+
+| Old type import                                | New type import |
+| ---------------------------------------------- | --------------- |
+| `RunStoreShape` from `@yolk-sdk/harness/store` | `RunStoreApi`   |
+| `InboxShape` from `@yolk-sdk/harness/inbox`    | `InboxApi`      |
+| `DriverShape` from `@yolk-sdk/harness/driver`  | `DriverApi`     |
+
+## Owner layers
+
+Each service is acquired through its owning static layer factory, which holds the real
+construction logic. The historical `make*` factories keep their signatures and behavior
+and delegate to these canonical owners:
+
+| Canonical owner layer                                                                                                                 | Backward-compatible factory                                                                     |
+| ------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------- |
+| `RunStore.inMemoryLayer()` / `snapshotLayer()`                                                                                        | `makeInMemoryRunStoreLayer` / `makeSnapshotRunStoreLayer`                                       |
+| `Inbox.layer()`                                                                                                                       | `makeInMemoryInboxLayer`                                                                        |
+| `RunCoordinator.layer()` (claims via `RunStore`)                                                                                      | `makeCoordinator` stays as the scoped doorbell factory                                          |
+| `Driver.layer()` (requires `RunStore` + `Inbox` + `RunCoordinator`) + `Driver.coordinatedLayer()` (default coordinator, lazy options) | `makeDriverLayer` delegates to `coordinatedLayer`, keeping the `RunStore` + `Inbox` requirement |
+
+Every factory call builds fresh layers, so composed harnesses never share `Ref` state.
+Within one composed harness, the driver and the merged output share a single store
+instance. `InterruptReason` is owned by `@yolk-sdk/harness/coordinator` and re-exported
+from `@yolk-sdk/harness/driver`.
+
+## Step outcomes
+
+`attemptModelTurn` classifies **one `runModelTurn` invocation** after that stream's configured loop/provider retries. It does not add another retry loop or persist. Hosts that schedule physical attempts themselves should pass `LoopConfig.maxRetries: 0` and skip retry decorators.
+
+`attemptToolBatch` sets `needsContinuation` when the batch executed calls (the next step is a model turn). `runToolBatch` fences all execution when any HITL request is pending, so `AwaitingInput` does not carry executed sibling calls.
+
+| Owner                                         | What it retries                                                                                                    |
+| --------------------------------------------- | ------------------------------------------------------------------------------------------------------------------ |
+| `@yolk-sdk/agent/loop` `run` / `runModelTurn` | Generic retryable LLM errors (`LoopConfig.maxRetries`) inside the invocation                                       |
+| `makeContextOverflowRetryProvider`            | In-process overflow, silent compact-and-retry **once per provider stream**, and only before published output       |
+| Harness `Compacted`                           | Durable persist-then-retry. Host stores compacted messages plus `overflowCompactionAttempt` and re-enters the step |
+
+Pass `overflowCompactionAttempt` (default `0`). A successful compact returns `attempt + 1`. Compact is allowed only while `attempt < 1`. Invalid/negative/nonfinite counts fail as `validation_error`. If the host omits or resets the count, there is no cross-invocation budget.
+
+Do not persist `ContextTransformer` checkpoints. Do not wrap the provider in `makeContextOverflowRetryProvider` and also treat `Compacted` as durable compaction on the same path.
+
+Incomplete streams (`LLMError.responseIssue === 'missing_done'`, still `invalid_response` / `retryable: false`) become `RecoverFull` before output or `Continue` after partial text/reasoning/completed calls. Content-filter and other nonretryable provider terminals stay failed. `onEvent` sink errors and compact/Abort errors are not classified as provider failures. `Continue` does not invent message IDs or execute tools.

package/dist/coordinator.d.mts

@@ -0,0 +1,72 @@
+import { RunStore } from "./store.mjs";
+import { Context, Effect, Exit, Layer, Scope } from "effect";
+
+//#region src/coordinator.d.ts
+/** `"input"` subsumes `"steer"` when coalescing wakes. */
+type Promotable = 'input' | 'steer';
+/** Shutdown retains the claim; explicit user stop releases it after settlement. */
+type InterruptReason = 'user' | 'shutdown';
+type CapturedRun<E> = {
+  readonly _tag: 'Started';
+  readonly join: Effect.Effect<void, E>;
+} | {
+  readonly _tag: 'Joined';
+  readonly join: Effect.Effect<void, E>;
+} | {
+  readonly _tag: 'Stopping';
+  readonly awaitSettlement: Effect.Effect<void>;
+};
+type StopReceipt = {
+  readonly _tag: 'Idle';
+} | {
+  readonly _tag: 'Interrupted';
+} | {
+  readonly _tag: 'LiveStopping';
+} | {
+  readonly _tag: 'Settling';
+};
+type Coordinator<Key, E, Reason = never> = {
+  readonly active: Effect.Effect<ReadonlySet<Key>>;
+  readonly isActive: (key: Key) => Effect.Effect<boolean>; /** Starts an execution while idle, or joins the active execution. */
+  readonly run: (key: Key) => Effect.Effect<void, E>;
+  /**
+   * Captures a run waiter without awaiting settlement.
+   * Idle starts force=true (`Started`); an active owner is joined (`Joined`),
+   * including during natural settlement. A stopping owner yields `Stopping` with a
+   * settlement waiter and no start.
+   */
+  readonly captureRun: (key: Key) => Effect.Effect<CapturedRun<E>>; /** Rings the doorbell: idle starts; active drains again before settling. */
+  readonly wake: (key: Key, scope?: Promotable) => Effect.Effect<void>;
+  /**
+   * Stops the active execution and clears its doorbell. No-op when idle.
+   * Resolves once the interruption request is delivered, not when cleanup settles.
+   * First accepted `reason` is kept; use `terminalStop` to escalate.
+   */
+  readonly interrupt: (key: Key, reason?: Reason, options?: {
+    readonly awaitSettlement?: boolean;
+  }) => Effect.Effect<boolean>;
+  /**
+   * Terminal stop receipt. Always clears pendingWake. Settling means the owner
+   * is already gone and the settled callback is chosen; Driver may release the
+   * claim under the Inbox gate. LiveStopping/Interrupted leave release to that
+   * owner's future settled callback. LiveStopping joins the same outstanding
+   * interruption request rather than forking a second one.
+   */
+  readonly terminalStop: (key: Key, reason: Reason) => Effect.Effect<StopReceipt>; /** Resolves once no execution is active. Never starts work. */
+  readonly awaitIdle: (key: Key) => Effect.Effect<void>;
+};
+declare const makeCoordinator: <Key, E, Reason = never>(options: {
+  readonly drain: (key: Key, force: boolean, scope: Promotable) => Effect.Effect<void, E>;
+  readonly started?: (key: Key) => Effect.Effect<void>;
+  readonly settled?: (key: Key, exit: Exit.Exit<void, E>, reason?: Reason) => Effect.Effect<void>;
+}) => Effect.Effect<Coordinator<Key, E, Reason>, never, Scope.Scope>;
+declare const RunCoordinator_base: Context.ServiceClass<RunCoordinator, "@yolk-sdk/harness/RunCoordinator", Coordinator<string, never, InterruptReason>>;
+/** Owning coordinator layer, with per-acquisition claim receipts and settlement policy. */
+declare class RunCoordinator extends RunCoordinator_base {
+  static layer: (options?: {
+    readonly drain?: (runId: string, force: boolean, scope: Promotable) => Effect.Effect<void>;
+  }) => Layer.Layer<RunCoordinator, never, RunStore>;
+}
+//#endregion
+export { CapturedRun, Coordinator, InterruptReason, Promotable, RunCoordinator, StopReceipt, makeCoordinator };
+//# sourceMappingURL=coordinator.d.mts.map

package/dist/coordinator.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coordinator.d.mts","names":[],"sources":["../src/coordinator.ts"],"mappings":";;;;;KAqBY,UAAA;AAKZ;AAAA,KAFY,eAAA;AAAA,KAEA,WAAA;EAAA,SACG,IAAA;EAAA,SAA0B,IAAA,EAAM,MAAA,CAAO,MAAA,OAAa,CAAA;AAAA;EAAA,SACpD,IAAA;EAAA,SAAyB,IAAA,EAAM,MAAA,CAAO,MAAA,OAAa,CAAA;AAAA;EAAA,SACnD,IAAA;EAAA,SAA2B,eAAA,EAAiB,MAAA,CAAO,MAAA;AAAA;AAAA,KAEtD,WAAA;EAAA,SACG,IAAA;AAAA;EAAA,SACA,IAAA;AAAA;EAAA,SACA,IAAA;AAAA;EAAA,SACA,IAAA;AAAA;AAAA,KAEH,WAAA;EAAA,SACD,MAAA,EAAQ,MAAA,CAAO,MAAA,CAAO,WAAA,CAAY,GAAA;EAAA,SAClC,QAAA,GAAW,GAAA,EAAK,GAAA,KAAQ,MAAA,CAAO,MAAA,WAVwB;EAAA,SAYvD,GAAA,GAAM,GAAA,EAAK,GAAA,KAAQ,MAAA,CAAO,MAAA,OAAa,CAAA;EAZsB;AAExE;;;;;EAFwE,SAmB7D,UAAA,GAAa,GAAA,EAAK,GAAA,KAAQ,MAAA,CAAO,MAAA,CAAO,WAAA,CAAY,CAAA,IAdhD;EAAA,SAgBJ,IAAA,GAAO,GAAA,EAAK,GAAA,EAAK,KAAA,GAAQ,UAAA,KAAe,MAAA,CAAO,MAAA;EAfvC;AAAA;AAEnB;;;EAFmB,SAqBR,SAAA,GACP,GAAA,EAAK,GAAA,EACL,MAAA,GAAS,MAAA,EACT,OAAA;IAAA,SAAqB,eAAA;EAAA,MAClB,MAAA,CAAO,MAAA;EArBa;;;;;;;EAAA,SA6BhB,YAAA,GAAe,GAAA,EAAK,GAAA,EAAK,MAAA,EAAQ,MAAA,KAAW,MAAA,CAAO,MAAA,CAAO,WAAA,GApBhC;EAAA,SAsB1B,SAAA,GAAY,GAAA,EAAK,GAAA,KAAQ,MAAA,CAAO,MAAA;AAAA;AAAA,cAgB9B,eAAA,2BAA2C,OAAA;EAAA,SAC7C,KAAA,GAAQ,GAAA,EAAK,GAAA,EAAK,KAAA,WAAgB,KAAA,EAAO,UAAA,KAAe,MAAA,CAAO,MAAA,OAAa,CAAA;EAAA,SAC5E,OAAA,IAAW,GAAA,EAAK,GAAA,KAAQ,MAAA,CAAO,MAAA;EAAA,SAC/B,OAAA,IAAW,GAAA,EAAK,GAAA,EAAK,IAAA,EAAM,IAAA,CAAK,IAAA,OAAW,CAAA,GAAI,MAAA,GAAS,MAAA,KAAW,MAAA,CAAO,MAAA;AAAA,MACjF,MAAA,CAAO,MAAA,CAAO,WAAA,CAAY,GAAA,EAAK,CAAA,EAAG,MAAA,UAAgB,KAAA,CAAM,KAAA;AAAA,cAyMxD,mBAAA;;cAGS,cAAA,SAAuB,mBAAA;EAAA,OAI3B,KAAA,GAAS,OAAA;IAAA,SACL,KAAA,IAAS,KAAA,UAAe,KAAA,WAAgB,KAAA,EAAO,UAAA,KAAe,MAAA,CAAO,MAAA;EAAA,MAC5E,KAAA,CAAM,KAAA,CAAM,cAAA,SAAuB,QAAA;AAAA"}

package/dist/coordinator.mjs

@@ -0,0 +1,154 @@
+import { StopReceipt } from "./outcome-constructors-internal.mjs";
+import { RunStore } from "./store.mjs";
+import { Cause, Context, Deferred, Effect, Exit, Fiber, FiberSet, Layer } from "effect";
+//#region src/coordinator.ts
+/**
+* Process-local run coordinator.
+*
+* Port of OpenCode v2 `SessionRunCoordinator` (MIT): one busy period per key,
+* a doorbell that coalesces wakes, and interrupt that claims pending wakes so a
+* dead intent cannot restart. Steering lands at the next drain boundary.
+*
+* @see https://github.com/sst/opencode (packages/core/src/session/run-coordinator.ts)
+*/
+const awaitDone = (done) => Deferred.await(done).pipe(Effect.flatMap((exit) => exit));
+const widerScope = (current, next) => current === "input" || next === "input" ? "input" : "steer";
+const makeCoordinator = (options) => Effect.gen(function* () {
+	const executions = /* @__PURE__ */ new Map();
+	const fork = yield* FiberSet.makeRuntime();
+	const loop = (key, execution, force) => Effect.suspend(() => {
+		if (execution.stopping) return Effect.void;
+		return options.drain(key, force, execution.scope);
+	}).pipe(Effect.andThen(Effect.suspend(() => {
+		if (execution.stopping || execution.pendingWake === void 0) return Effect.void;
+		execution.scope = execution.pendingWake;
+		execution.pendingWake = void 0;
+		return Effect.yieldNow.pipe(Effect.andThen(loop(key, execution, false)));
+	})));
+	const settle = (key, execution, exit) => {
+		if (execution.pendingWake !== void 0) start(key, false, execution.pendingWake);
+		else executions.delete(key);
+		return Deferred.succeed(execution.done, exit).pipe(Effect.asVoid);
+	};
+	const start = (key, force, scope) => {
+		const execution = {
+			done: Deferred.makeUnsafe(),
+			scope,
+			stopping: false
+		};
+		executions.set(key, execution);
+		execution.owner = fork(Effect.yieldNow.pipe(Effect.andThen(Effect.uninterruptible(Effect.suspend(() => options.started?.(key) ?? Effect.void))), Effect.andThen(loop(key, execution, force)), Effect.onExit((exit) => Effect.suspend(() => {
+			execution.owner = void 0;
+			return options.settled?.(key, exit, execution.interruptionReason) ?? Effect.void;
+		})), Effect.onExit((exit) => settle(key, execution, exit)), Effect.exit, Effect.asVoid));
+		return execution;
+	};
+	const forkInterruptionRequest = (owner) => fork(Effect.yieldNow.pipe(Effect.andThen(Effect.sync(() => owner.interruptUnsafe()))));
+	const interruptNow = (key, reason) => Effect.suspend(() => {
+		const execution = executions.get(key);
+		if (execution === void 0 || execution.stopping) return Effect.succeed(false);
+		if (execution.owner === void 0) {
+			execution.pendingWake = void 0;
+			return Effect.succeed(false);
+		}
+		const owner = execution.owner;
+		execution.stopping = true;
+		execution.pendingWake = void 0;
+		execution.interruptionReason = reason;
+		const request = forkInterruptionRequest(owner);
+		execution.request = request;
+		return Fiber.join(request).pipe(Effect.as(true));
+	});
+	const awaitIdle = (key) => Effect.suspend(() => {
+		const execution = executions.get(key);
+		if (execution === void 0) return Effect.void;
+		return awaitDone(execution.done).pipe(Effect.ignoreCause, Effect.andThen(awaitIdle(key)));
+	});
+	return {
+		active: Effect.sync(() => new Set(executions.keys())),
+		isActive: (key) => Effect.sync(() => executions.has(key)),
+		run: (key) => Effect.suspend(() => {
+			const execution = executions.get(key);
+			if (execution === void 0) return awaitDone(start(key, true, "input").done);
+			if (!execution.stopping) return awaitDone(execution.done);
+			return awaitDone(execution.done).pipe(Effect.ignoreCause, Effect.andThen(Effect.suspend(() => {
+				const next = executions.get(key);
+				return next === void 0 ? awaitDone(start(key, true, "input").done) : awaitDone(next.done);
+			})));
+		}),
+		captureRun: (key) => Effect.sync(() => {
+			const execution = executions.get(key);
+			if (execution === void 0) return {
+				_tag: "Started",
+				join: awaitDone(start(key, true, "input").done)
+			};
+			if (!execution.stopping) return {
+				_tag: "Joined",
+				join: awaitDone(execution.done)
+			};
+			return {
+				_tag: "Stopping",
+				awaitSettlement: awaitDone(execution.done).pipe(Effect.ignoreCause)
+			};
+		}),
+		wake: (key, scope = "input") => Effect.sync(() => {
+			const execution = executions.get(key);
+			if (execution !== void 0) {
+				execution.pendingWake = widerScope(execution.pendingWake, scope);
+				return;
+			}
+			start(key, false, scope);
+		}),
+		interrupt: (key, reason, options) => Effect.suspend(() => {
+			const execution = executions.get(key);
+			return interruptNow(key, reason).pipe(Effect.tap(() => options?.awaitSettlement === true && execution !== void 0 ? awaitDone(execution.done).pipe(Effect.ignoreCause) : Effect.void));
+		}),
+		terminalStop: (key, reason) => Effect.suspend(() => {
+			const execution = executions.get(key);
+			if (execution === void 0) return Effect.succeed(StopReceipt.Idle());
+			execution.pendingWake = void 0;
+			if (execution.owner === void 0) {
+				execution.stopping = true;
+				return Effect.succeed(StopReceipt.Settling());
+			}
+			execution.interruptionReason = reason;
+			if (execution.stopping) {
+				const request = execution.request;
+				return request === void 0 ? Effect.succeed(StopReceipt.LiveStopping()) : Fiber.join(request).pipe(Effect.as(StopReceipt.LiveStopping()));
+			}
+			const owner = execution.owner;
+			execution.stopping = true;
+			const request = forkInterruptionRequest(owner);
+			execution.request = request;
+			return Fiber.join(request).pipe(Effect.as(StopReceipt.Interrupted()));
+		}),
+		awaitIdle
+	};
+});
+/** Owning coordinator layer, with per-acquisition claim receipts and settlement policy. */
+var RunCoordinator = class extends Context.Service()("@yolk-sdk/harness/RunCoordinator") {
+	static layer = (options) => Layer.effect(this, Effect.gen(function* () {
+		const store = yield* RunStore;
+		const drain = options?.drain ?? ((_runId, _force, _scope) => Effect.void);
+		const acquired = /* @__PURE__ */ new Set();
+		return yield* makeCoordinator({
+			drain,
+			started: (runId) => store.claim(runId).pipe(Effect.tap(() => Effect.sync(() => {
+				acquired.add(runId);
+			}))),
+			settled: (runId, exit, reason) => Effect.suspend(() => {
+				const owned = acquired.delete(runId);
+				if (owned && (reason === "user" || reason === void 0 && !Exit.hasInterrupts(exit))) return store.release(runId);
+				if (reason === "user" && !owned) return store.isClaimed(runId).pipe(Effect.flatMap((claimed) => claimed ? store.release(runId) : Effect.void));
+				return Effect.void;
+			}).pipe(Effect.exit, Effect.flatMap((settledExit) => {
+				if (Exit.isSuccess(settledExit)) return Effect.void;
+				return Effect.failCause(Exit.isFailure(exit) ? Cause.combine(exit.cause, settledExit.cause) : settledExit.cause);
+			}))
+		});
+	}));
+};
+//#endregion
+export { RunCoordinator, makeCoordinator };
+
+//# sourceMappingURL=coordinator.mjs.map

package/dist/coordinator.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"coordinator.mjs","names":["stopReceipt"],"sources":["../src/coordinator.ts"],"sourcesContent":["/**\n * Process-local run coordinator.\n *\n * Port of OpenCode v2 `SessionRunCoordinator` (MIT): one busy period per key,\n * a doorbell that coalesces wakes, and interrupt that claims pending wakes so a\n * dead intent cannot restart. Steering lands at the next drain boundary.\n *\n * @see https://github.com/sst/opencode (packages/core/src/session/run-coordinator.ts)\n */\nimport { Cause, Context, Deferred, Effect, Exit, Fiber, FiberSet, Layer } from 'effect'\nimport type { Scope } from 'effect'\nimport { StopReceipt as stopReceipt } from './outcome-constructors-internal.ts'\nimport { RunStore } from './store.ts'\n\n// Private settlement receipt: succeed the Deferred with Exit as a value so\n// interrupt fan-out does not skip Effect 4.0.0-beta.80 Deferred listeners.\n// Public waiters flatten that Exit; this is not a global Deferred fix.\nconst awaitDone = <E>(done: Deferred.Deferred<Exit.Exit<void, E>>): Effect.Effect<void, E> =>\n  Deferred.await(done).pipe(Effect.flatMap(exit => exit))\n\n/** `\"input\"` subsumes `\"steer\"` when coalescing wakes. */\nexport type Promotable = 'input' | 'steer'\n\n/** Shutdown retains the claim; explicit user stop releases it after settlement. */\nexport type InterruptReason = 'user' | 'shutdown'\n\nexport type CapturedRun<E> =\n  | { readonly _tag: 'Started'; readonly join: Effect.Effect<void, E> }\n  | { readonly _tag: 'Joined'; readonly join: Effect.Effect<void, E> }\n  | { readonly _tag: 'Stopping'; readonly awaitSettlement: Effect.Effect<void> }\n\nexport type StopReceipt =\n  | { readonly _tag: 'Idle' }\n  | { readonly _tag: 'Interrupted' }\n  | { readonly _tag: 'LiveStopping' }\n  | { readonly _tag: 'Settling' }\n\nexport type Coordinator<Key, E, Reason = never> = {\n  readonly active: Effect.Effect<ReadonlySet<Key>>\n  readonly isActive: (key: Key) => Effect.Effect<boolean>\n  /** Starts an execution while idle, or joins the active execution. */\n  readonly run: (key: Key) => Effect.Effect<void, E>\n  /**\n   * Captures a run waiter without awaiting settlement.\n   * Idle starts force=true (`Started`); an active owner is joined (`Joined`),\n   * including during natural settlement. A stopping owner yields `Stopping` with a\n   * settlement waiter and no start.\n   */\n  readonly captureRun: (key: Key) => Effect.Effect<CapturedRun<E>>\n  /** Rings the doorbell: idle starts; active drains again before settling. */\n  readonly wake: (key: Key, scope?: Promotable) => Effect.Effect<void>\n  /**\n   * Stops the active execution and clears its doorbell. No-op when idle.\n   * Resolves once the interruption request is delivered, not when cleanup settles.\n   * First accepted `reason` is kept; use `terminalStop` to escalate.\n   */\n  readonly interrupt: (\n    key: Key,\n    reason?: Reason,\n    options?: { readonly awaitSettlement?: boolean }\n  ) => Effect.Effect<boolean>\n  /**\n   * Terminal stop receipt. Always clears pendingWake. Settling means the owner\n   * is already gone and the settled callback is chosen; Driver may release the\n   * claim under the Inbox gate. LiveStopping/Interrupted leave release to that\n   * owner's future settled callback. LiveStopping joins the same outstanding\n   * interruption request rather than forking a second one.\n   */\n  readonly terminalStop: (key: Key, reason: Reason) => Effect.Effect<StopReceipt>\n  /** Resolves once no execution is active. Never starts work. */\n  readonly awaitIdle: (key: Key) => Effect.Effect<void>\n}\n\ntype Execution<E, Reason> = {\n  readonly done: Deferred.Deferred<Exit.Exit<void, E>>\n  owner?: Fiber.Fiber<void>\n  request?: Fiber.Fiber<void>\n  scope: Promotable\n  pendingWake?: Promotable\n  stopping: boolean\n  interruptionReason?: Reason\n}\n\nconst widerScope = (current: Promotable | undefined, next: Promotable): Promotable =>\n  current === 'input' || next === 'input' ? 'input' : 'steer'\n\nexport const makeCoordinator = <Key, E, Reason = never>(options: {\n  readonly drain: (key: Key, force: boolean, scope: Promotable) => Effect.Effect<void, E>\n  readonly started?: (key: Key) => Effect.Effect<void>\n  readonly settled?: (key: Key, exit: Exit.Exit<void, E>, reason?: Reason) => Effect.Effect<void>\n}): Effect.Effect<Coordinator<Key, E, Reason>, never, Scope.Scope> =>\n  Effect.gen(function* () {\n    const executions = new Map<Key, Execution<E, Reason>>()\n    const fork = yield* FiberSet.makeRuntime<never, void, never>()\n\n    const loop = (\n      key: Key,\n      execution: Execution<E, Reason>,\n      force: boolean\n    ): Effect.Effect<void, E> =>\n      Effect.suspend(() => {\n        if (execution.stopping) return Effect.void\n\n        return options.drain(key, force, execution.scope)\n      }).pipe(\n        Effect.andThen(\n          Effect.suspend(() => {\n            if (execution.stopping || execution.pendingWake === undefined) return Effect.void\n            execution.scope = execution.pendingWake\n            execution.pendingWake = undefined\n\n            return Effect.yieldNow.pipe(Effect.andThen(loop(key, execution, false)))\n          })\n        )\n      )\n\n    const settle = (key: Key, execution: Execution<E, Reason>, exit: Exit.Exit<void, E>) => {\n      if (execution.pendingWake !== undefined) start(key, false, execution.pendingWake)\n      else executions.delete(key)\n\n      return Deferred.succeed(execution.done, exit).pipe(Effect.asVoid)\n    }\n\n    const start = (key: Key, force: boolean, scope: Promotable) => {\n      const execution: Execution<E, Reason> = {\n        done: Deferred.makeUnsafe<Exit.Exit<void, E>>(),\n        scope,\n        stopping: false\n      }\n\n      executions.set(key, execution)\n      execution.owner = fork(\n        Effect.yieldNow.pipe(\n          Effect.andThen(\n            Effect.uninterruptible(Effect.suspend(() => options.started?.(key) ?? Effect.void))\n          ),\n          Effect.andThen(loop(key, execution, force)),\n          Effect.onExit(exit =>\n            Effect.suspend(() => {\n              execution.owner = undefined\n\n              return options.settled?.(key, exit, execution.interruptionReason) ?? Effect.void\n            })\n          ),\n          Effect.onExit(exit => settle(key, execution, exit)),\n          Effect.exit,\n          Effect.asVoid\n        )\n      )\n\n      return execution\n    }\n\n    const forkInterruptionRequest = (owner: Fiber.Fiber<void>): Fiber.Fiber<void> =>\n      fork(Effect.yieldNow.pipe(Effect.andThen(Effect.sync(() => owner.interruptUnsafe()))))\n\n    const interruptNow = (key: Key, reason?: Reason): Effect.Effect<boolean> =>\n      Effect.suspend(() => {\n        const execution = executions.get(key)\n\n        if (execution === undefined || execution.stopping) return Effect.succeed(false)\n\n        if (execution.owner === undefined) {\n          execution.pendingWake = undefined\n\n          return Effect.succeed(false)\n        }\n\n        const owner = execution.owner\n        execution.stopping = true\n        execution.pendingWake = undefined\n        execution.interruptionReason = reason\n        // Capture the exact old owner and fork the request in this same lazy\n        // transition so cancellation cannot leave stopping=true with no request.\n        // Initial yield breaks owner -> resumed caller -> owner reentrancy.\n        // Join the request fiber only; interruptUnsafe may run interruptible\n        // finalizers inline until they suspend. Do not await owner settlement.\n        const request = forkInterruptionRequest(owner)\n        execution.request = request\n\n        return Fiber.join(request).pipe(Effect.as(true))\n      })\n\n    const awaitIdle = (key: Key): Effect.Effect<void> =>\n      Effect.suspend(() => {\n        const execution = executions.get(key)\n\n        if (execution === undefined) return Effect.void\n\n        return awaitDone(execution.done).pipe(Effect.ignoreCause, Effect.andThen(awaitIdle(key)))\n      })\n\n    return {\n      active: Effect.sync(() => new Set(executions.keys())),\n      isActive: key => Effect.sync(() => executions.has(key)),\n      run: key =>\n        Effect.suspend(() => {\n          const execution = executions.get(key)\n\n          if (execution === undefined) return awaitDone(start(key, true, 'input').done)\n\n          if (!execution.stopping) return awaitDone(execution.done)\n\n          return awaitDone(execution.done).pipe(\n            Effect.ignoreCause,\n            Effect.andThen(\n              Effect.suspend(() => {\n                const next = executions.get(key)\n\n                return next === undefined\n                  ? awaitDone(start(key, true, 'input').done)\n                  : awaitDone(next.done)\n              })\n            )\n          )\n        }),\n      captureRun: key =>\n        Effect.sync(() => {\n          const execution = executions.get(key)\n\n          if (execution === undefined) {\n            const started = start(key, true, 'input')\n\n            return { _tag: 'Started' as const, join: awaitDone(started.done) }\n          }\n\n          if (!execution.stopping) {\n            return { _tag: 'Joined' as const, join: awaitDone(execution.done) }\n          }\n\n          return {\n            _tag: 'Stopping' as const,\n            awaitSettlement: awaitDone(execution.done).pipe(Effect.ignoreCause)\n          }\n        }),\n      wake: (key, scope = 'input') =>\n        Effect.sync(() => {\n          const execution = executions.get(key)\n\n          if (execution !== undefined) {\n            execution.pendingWake = widerScope(execution.pendingWake, scope)\n\n            return\n          }\n\n          start(key, false, scope)\n        }),\n      interrupt: (key, reason, options) =>\n        Effect.suspend(() => {\n          const execution = executions.get(key)\n\n          return interruptNow(key, reason).pipe(\n            Effect.tap(() =>\n              options?.awaitSettlement === true && execution !== undefined\n                ? awaitDone(execution.done).pipe(Effect.ignoreCause)\n                : Effect.void\n            )\n          )\n        }),\n      terminalStop: (key, reason) =>\n        Effect.suspend((): Effect.Effect<StopReceipt> => {\n          const execution = executions.get(key)\n\n          if (execution === undefined) return Effect.succeed(stopReceipt.Idle())\n          execution.pendingWake = undefined\n\n          if (execution.owner === undefined) {\n            execution.stopping = true\n\n            return Effect.succeed(stopReceipt.Settling())\n          }\n\n          execution.interruptionReason = reason\n\n          if (execution.stopping) {\n            const request = execution.request\n\n            return request === undefined\n              ? Effect.succeed(stopReceipt.LiveStopping())\n              : Fiber.join(request).pipe(Effect.as(stopReceipt.LiveStopping()))\n          }\n\n          const owner = execution.owner\n          execution.stopping = true\n          const request = forkInterruptionRequest(owner)\n          execution.request = request\n\n          return Fiber.join(request).pipe(Effect.as(stopReceipt.Interrupted()))\n        }),\n      awaitIdle\n    }\n  })\n\n/** Owning coordinator layer, with per-acquisition claim receipts and settlement policy. */\nexport class RunCoordinator extends Context.Service<\n  RunCoordinator,\n  Coordinator<string, never, InterruptReason>\n>()('@yolk-sdk/harness/RunCoordinator') {\n  static layer = (options?: {\n    readonly drain?: (runId: string, force: boolean, scope: Promotable) => Effect.Effect<void>\n  }): Layer.Layer<RunCoordinator, never, RunStore> =>\n    Layer.effect(\n      this,\n      Effect.gen(function* () {\n        const store = yield* RunStore\n        const drain = options?.drain ?? ((_runId, _force, _scope) => Effect.void)\n        const acquired = new Set<string>()\n\n        return yield* makeCoordinator<string, never, InterruptReason>({\n          drain,\n          started: runId =>\n            store.claim(runId).pipe(\n              Effect.tap(() =>\n                Effect.sync(() => {\n                  acquired.add(runId)\n                })\n              )\n            ),\n          settled: (runId, exit, reason) =>\n            Effect.suspend(() => {\n              const owned = acquired.delete(runId)\n\n              if (\n                owned &&\n                (reason === 'user' || (reason === undefined && !Exit.hasInterrupts(exit)))\n              ) {\n                return store.release(runId)\n              }\n\n              // Acquisition receipt guards automatic failed-start settlement only.\n              // Explicit user-terminal authority still releases a leftover claim\n              // after this owner has actually settled, matching Idle/Settling stop.\n              if (reason === 'user' && !owned) {\n                return store\n                  .isClaimed(runId)\n                  .pipe(Effect.flatMap(claimed => (claimed ? store.release(runId) : Effect.void)))\n              }\n\n              return Effect.void\n            }).pipe(\n              Effect.exit,\n              Effect.flatMap(settledExit => {\n                if (Exit.isSuccess(settledExit)) return Effect.void\n\n                return Effect.failCause(\n                  Exit.isFailure(exit)\n                    ? Cause.combine(exit.cause, settledExit.cause)\n                    : settledExit.cause\n                )\n              })\n            )\n        })\n      })\n    )\n}\n"],"mappings":"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"}

package/dist/driver/durable-object.d.mts

@@ -0,0 +1,20 @@
+import { DurableRunStoreSnapshot, RunStore } from "../store.mjs";
+import { Inbox } from "../inbox.mjs";
+import { Drain, Driver, InvalidMaxResumeAttempts } from "../driver.mjs";
+import { Effect, Layer } from "effect";
+
+//#region src/driver/durable-object.d.ts
+type DurableObjectDriverBase = {
+  readonly load: Effect.Effect<DurableRunStoreSnapshot | undefined>;
+  readonly save: (snapshot: DurableRunStoreSnapshot) => Effect.Effect<void>;
+  readonly drain?: Drain;
+};
+declare function makeDurableObjectDriverLayer(options: DurableObjectDriverBase & {
+  readonly maxResumeAttempts?: undefined;
+}): Layer.Layer<Driver | RunStore | Inbox>;
+declare function makeDurableObjectDriverLayer(options: DurableObjectDriverBase & {
+  readonly maxResumeAttempts?: number;
+}): Layer.Layer<Driver | RunStore | Inbox, InvalidMaxResumeAttempts>;
+//#endregion
+export { type DurableRunStoreSnapshot, makeDurableObjectDriverLayer };
+//# sourceMappingURL=durable-object.d.mts.map

package/dist/driver/durable-object.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"durable-object.d.mts","names":[],"sources":["../../src/driver/durable-object.ts"],"mappings":";;;;;;KAQK,uBAAA;EAAA,SACM,IAAA,EAAM,MAAA,CAAO,MAAA,CAAO,uBAAA;EAAA,SACpB,IAAA,GAAO,QAAA,EAAU,uBAAA,KAA4B,MAAA,CAAO,MAAA;EAAA,SACpD,KAAA,GAAQ,KAAA;AAAA;AAAA,iBAGH,4BAAA,CACd,OAAA,EAAS,uBAAA;EAAA,SAAqC,iBAAA;AAAA,IAC7C,KAAA,CAAM,KAAA,CAAM,MAAA,GAAS,QAAA,GAAW,KAAA;AAAA,iBACnB,4BAAA,CACd,OAAA,EAAS,uBAAA;EAAA,SAAqC,iBAAA;AAAA,IAC7C,KAAA,CAAM,KAAA,CAAM,MAAA,GAAS,QAAA,GAAW,KAAA,EAAO,wBAAA"}

package/dist/driver/durable-object.mjs

@@ -0,0 +1,12 @@
+import { RunStore } from "../store.mjs";
+import { Inbox } from "../inbox.mjs";
+import { Driver } from "../driver.mjs";
+import { Layer } from "effect";
+//#region src/driver/durable-object.ts
+function makeDurableObjectDriverLayer(options) {
+	return Driver.coordinatedLayer(options).pipe(Layer.provideMerge(RunStore.snapshotLayer(options)), Layer.provideMerge(Inbox.layer()));
+}
+//#endregion
+export { makeDurableObjectDriverLayer };
+
+//# sourceMappingURL=durable-object.mjs.map

package/dist/driver/durable-object.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"durable-object.mjs","names":[],"sources":["../../src/driver/durable-object.ts"],"sourcesContent":["import { Layer } from 'effect'\nimport type { Effect } from 'effect'\nimport { Driver, type Drain, type InvalidMaxResumeAttempts } from '../driver.ts'\nimport { Inbox } from '../inbox.ts'\nimport { RunStore, type DurableRunStoreSnapshot } from '../store.ts'\n\nexport type { DurableRunStoreSnapshot }\n\ntype DurableObjectDriverBase = {\n  readonly load: Effect.Effect<DurableRunStoreSnapshot | undefined>\n  readonly save: (snapshot: DurableRunStoreSnapshot) => Effect.Effect<void>\n  readonly drain?: Drain\n}\n\nexport function makeDurableObjectDriverLayer(\n  options: DurableObjectDriverBase & { readonly maxResumeAttempts?: undefined }\n): Layer.Layer<Driver | RunStore | Inbox>\nexport function makeDurableObjectDriverLayer(\n  options: DurableObjectDriverBase & { readonly maxResumeAttempts?: number }\n): Layer.Layer<Driver | RunStore | Inbox, InvalidMaxResumeAttempts>\nexport function makeDurableObjectDriverLayer(\n  options: DurableObjectDriverBase & { readonly maxResumeAttempts?: number }\n) {\n  return Driver.coordinatedLayer(options).pipe(\n    Layer.provideMerge(RunStore.snapshotLayer(options)),\n    Layer.provideMerge(Inbox.layer())\n  )\n}\n"],"mappings":";;;;;AAoBA,SAAgB,6BACd,SACA;CACA,OAAO,OAAO,iBAAiB,OAAO,EAAE,KACtC,MAAM,aAAa,SAAS,cAAc,OAAO,CAAC,GAClD,MAAM,aAAa,MAAM,MAAM,CAAC,CAClC;AACF"}

package/dist/driver/memory.d.mts

@@ -0,0 +1,21 @@
+import { RunStore } from "../store.mjs";
+import { Inbox } from "../inbox.mjs";
+import { Drain, Driver, DriverLayerOptions, InvalidMaxResumeAttempts } from "../driver.mjs";
+import { Layer } from "effect";
+
+//#region src/driver/memory.d.ts
+declare function makeInMemoryDriverLayer(): Layer.Layer<Driver, never, RunStore | Inbox>;
+declare function makeInMemoryDriverLayer(options?: {
+  readonly drain?: Drain;
+  readonly maxResumeAttempts?: undefined;
+}): Layer.Layer<Driver, never, RunStore | Inbox>;
+declare function makeInMemoryDriverLayer(options?: DriverLayerOptions): Layer.Layer<Driver, InvalidMaxResumeAttempts, RunStore | Inbox>;
+declare function makeInMemoryHarnessLayer(): Layer.Layer<Driver | RunStore | Inbox>;
+declare function makeInMemoryHarnessLayer(options?: {
+  readonly drain?: Drain;
+  readonly maxResumeAttempts?: undefined;
+}): Layer.Layer<Driver | RunStore | Inbox>;
+declare function makeInMemoryHarnessLayer(options?: DriverLayerOptions): Layer.Layer<Driver | RunStore | Inbox, InvalidMaxResumeAttempts>;
+//#endregion
+export { makeInMemoryDriverLayer, makeInMemoryHarnessLayer };
+//# sourceMappingURL=memory.d.mts.map

package/dist/driver/memory.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory.d.mts","names":[],"sources":["../../src/driver/memory.ts"],"mappings":";;;;;;iBAUgB,uBAAA,CAAA,GAA2B,KAAA,CAAM,KAAA,CAAM,MAAA,SAAe,QAAA,GAAW,KAAA;AAAA,iBACjE,uBAAA,CAAwB,OAAA;EAAA,SAC7B,KAAA,GAAQ,KAAA;EAAA,SACR,iBAAA;AAAA,IACP,KAAA,CAAM,KAAA,CAAM,MAAA,SAAe,QAAA,GAAW,KAAA;AAAA,iBAC1B,uBAAA,CACd,OAAA,GAAU,kBAAA,GACT,KAAA,CAAM,KAAA,CAAM,MAAA,EAAQ,wBAAA,EAA0B,QAAA,GAAW,KAAA;AAAA,iBAK5C,wBAAA,CAAA,GAA4B,KAAA,CAAM,KAAA,CAAM,MAAA,GAAS,QAAA,GAAW,KAAA;AAAA,iBAC5D,wBAAA,CAAyB,OAAA;EAAA,SAC9B,KAAA,GAAQ,KAAA;EAAA,SACR,iBAAA;AAAA,IACP,KAAA,CAAM,KAAA,CAAM,MAAA,GAAS,QAAA,GAAW,KAAA;AAAA,iBACpB,wBAAA,CACd,OAAA,GAAU,kBAAA,GACT,KAAA,CAAM,KAAA,CAAM,MAAA,GAAS,QAAA,GAAW,KAAA,EAAO,wBAAA"}

package/dist/driver/memory.mjs

@@ -0,0 +1,15 @@
+import { RunStore } from "../store.mjs";
+import { Inbox } from "../inbox.mjs";
+import { Driver } from "../driver.mjs";
+import { Layer } from "effect";
+//#region src/driver/memory.ts
+function makeInMemoryDriverLayer(options) {
+	return options === void 0 ? Driver.coordinatedLayer() : Driver.coordinatedLayer(options);
+}
+function makeInMemoryHarnessLayer(options) {
+	return (options === void 0 ? Driver.coordinatedLayer() : Driver.coordinatedLayer(options)).pipe(Layer.provideMerge(RunStore.inMemoryLayer()), Layer.provideMerge(Inbox.layer()));
+}
+//#endregion
+export { makeInMemoryDriverLayer, makeInMemoryHarnessLayer };
+
+//# sourceMappingURL=memory.mjs.map

package/dist/driver/memory.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory.mjs","names":[],"sources":["../../src/driver/memory.ts"],"sourcesContent":["import { Layer } from 'effect'\nimport {\n  Driver,\n  type Drain,\n  type DriverLayerOptions,\n  type InvalidMaxResumeAttempts\n} from '../driver.ts'\nimport { Inbox } from '../inbox.ts'\nimport { RunStore } from '../store.ts'\n\nexport function makeInMemoryDriverLayer(): Layer.Layer<Driver, never, RunStore | Inbox>\nexport function makeInMemoryDriverLayer(options?: {\n  readonly drain?: Drain\n  readonly maxResumeAttempts?: undefined\n}): Layer.Layer<Driver, never, RunStore | Inbox>\nexport function makeInMemoryDriverLayer(\n  options?: DriverLayerOptions\n): Layer.Layer<Driver, InvalidMaxResumeAttempts, RunStore | Inbox>\nexport function makeInMemoryDriverLayer(options?: DriverLayerOptions) {\n  return options === undefined ? Driver.coordinatedLayer() : Driver.coordinatedLayer(options)\n}\n\nexport function makeInMemoryHarnessLayer(): Layer.Layer<Driver | RunStore | Inbox>\nexport function makeInMemoryHarnessLayer(options?: {\n  readonly drain?: Drain\n  readonly maxResumeAttempts?: undefined\n}): Layer.Layer<Driver | RunStore | Inbox>\nexport function makeInMemoryHarnessLayer(\n  options?: DriverLayerOptions\n): Layer.Layer<Driver | RunStore | Inbox, InvalidMaxResumeAttempts>\nexport function makeInMemoryHarnessLayer(options?: DriverLayerOptions) {\n  const driver =\n    options === undefined ? Driver.coordinatedLayer() : Driver.coordinatedLayer(options)\n\n  return driver.pipe(\n    Layer.provideMerge(RunStore.inMemoryLayer()),\n    Layer.provideMerge(Inbox.layer())\n  )\n}\n"],"mappings":";;;;;AAkBA,SAAgB,wBAAwB,SAA8B;CACpE,OAAO,YAAY,KAAA,IAAY,OAAO,iBAAiB,IAAI,OAAO,iBAAiB,OAAO;AAC5F;AAUA,SAAgB,yBAAyB,SAA8B;CAIrE,QAFE,YAAY,KAAA,IAAY,OAAO,iBAAiB,IAAI,OAAO,iBAAiB,OAAO,GAEvE,KACZ,MAAM,aAAa,SAAS,cAAc,CAAC,GAC3C,MAAM,aAAa,MAAM,MAAM,CAAC,CAClC;AACF"}