@yolk-sdk/harness 0.1.0-canary.77

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,134 @@
+# @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-beta.80
+```
+
+## 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 |
+
+## 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-beta.80
+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.
+
+## 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.
+
+## 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,62 @@
+import { Effect, Exit, Scope } from "effect";
+
+//#region src/coordinator.d.ts
+/** `"input"` subsumes `"steer"` when coalescing wakes. */
+type Promotable = 'input' | 'steer';
+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>;
+//#endregion
+export { CapturedRun, Coordinator, Promotable, 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":";;;;KAmBY,UAAA;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,WAR9B;EAAA,SAUD,GAAA,GAAM,GAAA,EAAK,GAAA,KAAQ,MAAA,CAAO,MAAA,OAAa,CAAA;;;;;;;WAOvC,UAAA,GAAa,GAAA,EAAK,GAAA,KAAQ,MAAA,CAAO,MAAA,CAAO,WAAA,CAAY,CAAA,IAb5C;EAAA,SAeR,IAAA,GAAO,GAAA,EAAK,GAAA,EAAK,KAAA,GAAQ,UAAA,KAAe,MAAA,CAAO,MAAA;EAbnC;;;;;EAAA,SAmBZ,SAAA,GACP,GAAA,EAAK,GAAA,EACL,MAAA,GAAS,MAAA,EACT,OAAA;IAAA,SAAqB,eAAA;EAAA,MAClB,MAAA,CAAO,MAAA;EAnBoC;;;;;;;EAAA,SA2BvC,YAAA,GAAe,GAAA,EAAK,GAAA,EAAK,MAAA,EAAQ,MAAA,KAAW,MAAA,CAAO,MAAA,CAAO,WAAA,GAlBlB;EAAA,SAoBxC,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"}

package/dist/coordinator.mjs

@@ -0,0 +1,129 @@
+import { Deferred, Effect, Fiber, FiberSet } 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({ _tag: "Idle" });
+			execution.pendingWake = void 0;
+			if (execution.owner === void 0) {
+				execution.stopping = true;
+				return Effect.succeed({ _tag: "Settling" });
+			}
+			execution.interruptionReason = reason;
+			if (execution.stopping) {
+				const request = execution.request;
+				return request === void 0 ? Effect.succeed({ _tag: "LiveStopping" }) : Fiber.join(request).pipe(Effect.as({ _tag: "LiveStopping" }));
+			}
+			const owner = execution.owner;
+			execution.stopping = true;
+			const request = forkInterruptionRequest(owner);
+			execution.request = request;
+			return Fiber.join(request).pipe(Effect.as({ _tag: "Interrupted" }));
+		}),
+		awaitIdle
+	};
+});
+//#endregion
+export { makeCoordinator };
+
+//# sourceMappingURL=coordinator.mjs.map

package/dist/coordinator.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"coordinator.mjs","names":[],"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 { Deferred, Effect, Fiber, FiberSet } from 'effect'\nimport type { Exit, Scope } from 'effect'\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\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        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            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      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      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              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      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        if (execution === undefined || execution.stopping) return Effect.succeed(false)\n        if (execution.owner === undefined) {\n          execution.pendingWake = undefined\n          return Effect.succeed(false)\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        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        if (execution === undefined) return Effect.void\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          if (execution === undefined) return awaitDone(start(key, true, 'input').done)\n          if (!execution.stopping) return awaitDone(execution.done)\n          return awaitDone(execution.done).pipe(\n            Effect.ignoreCause,\n            Effect.andThen(\n              Effect.suspend(() => {\n                const next = executions.get(key)\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          if (execution === undefined) {\n            const started = start(key, true, 'input')\n            return { _tag: 'Started' as const, join: awaitDone(started.done) }\n          }\n          if (!execution.stopping) {\n            return { _tag: 'Joined' as const, join: awaitDone(execution.done) }\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          if (execution !== undefined) {\n            execution.pendingWake = widerScope(execution.pendingWake, scope)\n            return\n          }\n          start(key, false, scope)\n        }),\n      interrupt: (key, reason, options) =>\n        Effect.suspend(() => {\n          const execution = executions.get(key)\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          if (execution === undefined) return Effect.succeed({ _tag: 'Idle' } as const)\n          execution.pendingWake = undefined\n          if (execution.owner === undefined) {\n            execution.stopping = true\n            return Effect.succeed({ _tag: 'Settling' } as const)\n          }\n          execution.interruptionReason = reason\n          if (execution.stopping) {\n            const request = execution.request\n            return request === undefined\n              ? Effect.succeed({ _tag: 'LiveStopping' } as const)\n              : Fiber.join(request).pipe(Effect.as({ _tag: 'LiveStopping' } as const))\n          }\n          const owner = execution.owner\n          execution.stopping = true\n          const request = forkInterruptionRequest(owner)\n          execution.request = request\n          return Fiber.join(request).pipe(Effect.as({ _tag: 'Interrupted' } as const))\n        }),\n      awaitIdle\n    }\n  })\n"],"mappings":"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"}

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

@@ -0,0 +1,20 @@
+import { Inbox } from "../inbox.mjs";
+import { DurableRunStoreSnapshot, RunStore } from "../store.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":";;;;;;KAcK,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 { makeInMemoryInboxLayer } from "../inbox.mjs";
+import { makeSnapshotRunStoreLayer } from "../store.mjs";
+import { makeDriverLayer } from "../driver.mjs";
+import { Layer } from "effect";
+//#region src/driver/durable-object.ts
+function makeDurableObjectDriverLayer(options) {
+	return makeDriverLayer(options).pipe(Layer.provideMerge(makeSnapshotRunStoreLayer(options)), Layer.provideMerge(makeInMemoryInboxLayer()));
+}
+//#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 {\n  makeDriverLayer,\n  type Drain,\n  type Driver,\n  type InvalidMaxResumeAttempts\n} from '../driver.ts'\nimport { makeInMemoryInboxLayer } from '../inbox.ts'\nimport type { Inbox } from '../inbox.ts'\nimport { makeSnapshotRunStoreLayer, type DurableRunStoreSnapshot, type RunStore } 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 makeDriverLayer(options).pipe(\n    Layer.provideMerge(makeSnapshotRunStoreLayer(options)),\n    Layer.provideMerge(makeInMemoryInboxLayer())\n  )\n}\n"],"mappings":";;;;;AA0BA,SAAgB,6BACd,SACA;CACA,OAAO,gBAAgB,OAAO,EAAE,KAC9B,MAAM,aAAa,0BAA0B,OAAO,CAAC,GACrD,MAAM,aAAa,uBAAuB,CAAC,CAC7C;AACF"}

package/dist/driver/memory.d.mts

@@ -0,0 +1,21 @@
+import { Inbox } from "../inbox.mjs";
+import { RunStore } from "../store.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":";;;;;;iBAWgB,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 { makeInMemoryInboxLayer } from "../inbox.mjs";
+import { makeInMemoryRunStoreLayer } from "../store.mjs";
+import { makeDriverLayer } from "../driver.mjs";
+import { Layer } from "effect";
+//#region src/driver/memory.ts
+function makeInMemoryDriverLayer(options) {
+	return options === void 0 ? makeDriverLayer() : makeDriverLayer(options);
+}
+function makeInMemoryHarnessLayer(options) {
+	return (options === void 0 ? makeDriverLayer() : makeDriverLayer(options)).pipe(Layer.provideMerge(makeInMemoryRunStoreLayer()), Layer.provideMerge(makeInMemoryInboxLayer()));
+}
+//#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  makeDriverLayer,\n  type Drain,\n  type Driver,\n  type DriverLayerOptions,\n  type InvalidMaxResumeAttempts\n} from '../driver.ts'\nimport { makeInMemoryInboxLayer, type Inbox } from '../inbox.ts'\nimport { makeInMemoryRunStoreLayer, type 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 ? makeDriverLayer() : makeDriverLayer(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 = options === undefined ? makeDriverLayer() : makeDriverLayer(options)\n  return driver.pipe(\n    Layer.provideMerge(makeInMemoryRunStoreLayer()),\n    Layer.provideMerge(makeInMemoryInboxLayer())\n  )\n}\n"],"mappings":";;;;;AAmBA,SAAgB,wBAAwB,SAA8B;CACpE,OAAO,YAAY,KAAA,IAAY,gBAAgB,IAAI,gBAAgB,OAAO;AAC5E;AAUA,SAAgB,yBAAyB,SAA8B;CAErE,QADe,YAAY,KAAA,IAAY,gBAAgB,IAAI,gBAAgB,OAAO,GACpE,KACZ,MAAM,aAAa,0BAA0B,CAAC,GAC9C,MAAM,aAAa,uBAAuB,CAAC,CAC7C;AACF"}

package/dist/driver.d.mts

@@ -0,0 +1,67 @@
+import { Promotable } from "./coordinator.mjs";
+import { HitlAdmission, HitlDecision, Inbox, InboxItem, ParkedResponse, PauseDecision } from "./inbox.mjs";
+import { RunStore } from "./store.mjs";
+import { Cause, Context, Effect, Layer } from "effect";
+
+//#region src/driver.d.ts
+type InterruptReason = 'user' | 'shutdown';
+declare const defaultMaxResumeAttempts = 10;
+declare const InvalidMaxResumeAttempts_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => Cause.YieldableError & {
+  readonly _tag: "InvalidMaxResumeAttempts";
+} & Readonly<A>;
+declare class InvalidMaxResumeAttempts extends InvalidMaxResumeAttempts_base<{
+  readonly maxResumeAttempts: number;
+}> {}
+type ResumeSuspendedResult = {
+  readonly resumed: ReadonlyArray<string>;
+  readonly exhausted: ReadonlyArray<string>;
+};
+type DrainContext = {
+  readonly drainToken: string;
+  readonly readyResponses: ReadonlyArray<ParkedResponse>;
+};
+type Drain = (runId: string, force: boolean, scope: Promotable, context: DrainContext) => Effect.Effect<void, never, Inbox | RunStore>;
+type DriverLayerOptions = {
+  readonly drain?: Drain;
+  readonly maxResumeAttempts?: number;
+};
+type StopDecision = {
+  readonly _tag: 'Interrupted';
+} | {
+  readonly _tag: 'ParkCleared';
+} | {
+  readonly _tag: 'Idle';
+};
+type DriverShape = {
+  readonly active: Effect.Effect<ReadonlySet<string>>;
+  readonly isActive: (runId: string) => Effect.Effect<boolean>;
+  readonly run: (runId: string) => Effect.Effect<void>;
+  readonly wake: (runId: string, scope?: Promotable) => Effect.Effect<void>;
+  readonly interrupt: (runId: string, options?: {
+    readonly reason?: InterruptReason;
+    readonly awaitSettlement?: boolean;
+  }) => Effect.Effect<boolean>;
+  readonly awaitIdle: (runId: string) => Effect.Effect<void>;
+  readonly resumeSuspended: Effect.Effect<ResumeSuspendedResult>;
+  readonly admit: (item: InboxItem) => Effect.Effect<void>;
+  readonly pause: (runId: string, requestIds: ReadonlyArray<string>, drainToken: string) => Effect.Effect<PauseDecision>;
+  readonly resumeHitl: (runId: string, admission: HitlAdmission) => Effect.Effect<HitlDecision>;
+  readonly stop: (runId: string) => Effect.Effect<StopDecision>;
+};
+declare const Driver_base: Context.ServiceClass<Driver, "@yolk-sdk/harness/Driver", DriverShape>;
+declare class Driver extends Driver_base {}
+declare const makeHarness: <DE, DR, SE, SR, IE, IR>(input: {
+  readonly driver: Layer.Layer<Driver, DE, DR>;
+  readonly store: Layer.Layer<RunStore, SE, SR>;
+  readonly inbox: Layer.Layer<Inbox, IE, IR>;
+}) => Layer.Layer<Driver | RunStore | Inbox, DE | SE | IE, DR | SR | IR>;
+declare const admit: (item: InboxItem) => Effect.Effect<void, never, Driver>;
+declare function makeDriverLayer(): Layer.Layer<Driver, never, RunStore | Inbox>;
+declare function makeDriverLayer(options?: {
+  readonly drain?: Drain;
+  readonly maxResumeAttempts?: undefined;
+}): Layer.Layer<Driver, never, RunStore | Inbox>;
+declare function makeDriverLayer(options?: DriverLayerOptions): Layer.Layer<Driver, InvalidMaxResumeAttempts, RunStore | Inbox>;
+//#endregion
+export { Drain, DrainContext, Driver, DriverLayerOptions, DriverShape, InterruptReason, InvalidMaxResumeAttempts, ResumeSuspendedResult, StopDecision, admit, defaultMaxResumeAttempts, makeDriverLayer, makeHarness };
+//# sourceMappingURL=driver.d.mts.map

package/dist/driver.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"driver.d.mts","names":[],"sources":["../src/driver.ts"],"mappings":";;;;;;KAYY,eAAA;AAAA,cAEC,wBAAA;AAAA,cAA6B,6BAAA;;;cAE7B,wBAAA,SAAiC,6BAAA;EAAA,SACnC,iBAAiB;AAAA;AAAA,KAKhB,qBAAA;EAAA,SACD,OAAA,EAAS,aAAA;EAAA,SACT,SAAA,EAAW,aAAa;AAAA;AAAA,KAGvB,YAAA;EAAA,SACD,UAAA;EAAA,SACA,cAAA,EAAgB,aAAa,CAAC,cAAA;AAAA;AAAA,KAG7B,KAAA,IACV,KAAA,UACA,KAAA,WACA,KAAA,EAAO,UAAA,EACP,OAAA,EAAS,YAAA,KACN,MAAA,CAAO,MAAA,cAAoB,KAAA,GAAQ,QAAA;AAAA,KAE5B,kBAAA;EAAA,SACD,KAAA,GAAQ,KAAK;EAAA,SACb,iBAAA;AAAA;AAAA,KAGC,YAAA;EAAA,SACG,IAAA;AAAA;EAAA,SACA,IAAA;AAAA;EAAA,SACA,IAAA;AAAA;AAAA,KAEH,WAAA;EAAA,SACD,MAAA,EAAQ,MAAA,CAAO,MAAA,CAAO,WAAA;EAAA,SACtB,QAAA,GAAW,KAAA,aAAkB,MAAA,CAAO,MAAA;EAAA,SACpC,GAAA,GAAM,KAAA,aAAkB,MAAA,CAAO,MAAA;EAAA,SAC/B,IAAA,GAAO,KAAA,UAAe,KAAA,GAAQ,UAAA,KAAe,MAAA,CAAO,MAAA;EAAA,SACpD,SAAA,GACP,KAAA,UACA,OAAA;IAAA,SAAqB,MAAA,GAAS,eAAA;IAAA,SAA0B,eAAA;EAAA,MACrD,MAAA,CAAO,MAAA;EAAA,SACH,SAAA,GAAY,KAAA,aAAkB,MAAA,CAAO,MAAA;EAAA,SACrC,eAAA,EAAiB,MAAA,CAAO,MAAA,CAAO,qBAAA;EAAA,SAC/B,KAAA,GAAQ,IAAA,EAAM,SAAA,KAAc,MAAA,CAAO,MAAA;EAAA,SACnC,KAAA,GACP,KAAA,UACA,UAAA,EAAY,aAAA,UACZ,UAAA,aACG,MAAA,CAAO,MAAA,CAAO,aAAA;EAAA,SACV,UAAA,GAAa,KAAA,UAAe,SAAA,EAAW,aAAA,KAAkB,MAAA,CAAO,MAAA,CAAO,YAAA;EAAA,SACvE,IAAA,GAAO,KAAA,aAAkB,MAAA,CAAO,MAAA,CAAO,YAAA;AAAA;AAAA,cACjD,WAAA;cAEY,MAAA,SAAe,WAAkE;AAAA,cAEjF,WAAA,2BAAuC,KAAA;EAAA,SACzC,MAAA,EAAQ,KAAA,CAAM,KAAA,CAAM,MAAA,EAAQ,EAAA,EAAI,EAAA;EAAA,SAChC,KAAA,EAAO,KAAA,CAAM,KAAA,CAAM,QAAA,EAAU,EAAA,EAAI,EAAA;EAAA,SACjC,KAAA,EAAO,KAAA,CAAM,KAAA,CAAM,KAAA,EAAO,EAAA,EAAI,EAAA;AAAA,MACrC,KAAA,CAAM,KAAA,CAAM,MAAA,GAAS,QAAA,GAAW,KAAA,EAAO,EAAA,GAAK,EAAA,GAAK,EAAA,EAAI,EAAA,GAAK,EAAA,GAAK,EAAA;AAAA,cAGtD,KAAA,GAAS,IAAA,EAAM,SAAA,KAAS,MAAA,CAAA,MAAA,cAAA,MAAA;AAAA,iBA2JrB,eAAA,CAAA,GAAmB,KAAA,CAAM,KAAA,CAAM,MAAA,SAAe,QAAA,GAAW,KAAA;AAAA,iBACzD,eAAA,CAAgB,OAAA;EAAA,SACrB,KAAA,GAAQ,KAAA;EAAA,SACR,iBAAA;AAAA,IACP,KAAA,CAAM,KAAA,CAAM,MAAA,SAAe,QAAA,GAAW,KAAA;AAAA,iBAC1B,eAAA,CACd,OAAA,GAAU,kBAAA,GACT,KAAA,CAAM,KAAA,CAAM,MAAA,EAAQ,wBAAA,EAA0B,QAAA,GAAW,KAAA"}