lorenz 0.1.0

package/packages/worker-pool/dist/types.d.ts

@@ -0,0 +1,249 @@
+import type { WorkerDriver } from "@lorenz/worker-sdk";
+import type { WorkerDriverKind, WorkerPoolSettings } from "@lorenz/domain";
+/**
+ * Pool-side types for the embedded warm worker pool. Every implementation file
+ * imports from this module so concrete files (pool, lease, reaper, ledger) never
+ * form import cycles. The DRIVER contract (WorkerDriver, WorkerDescriptor,
+ * ProvisionRequest, WorkerHealth, TeardownReason, POOL_OWNED_LABEL, the registry)
+ * lives in `@lorenz/worker-sdk`; this module owns only the engine vocabulary the
+ * pool itself adds on top: leases, inventory records, the ledger row shape, and
+ * the pool surface.
+ */
+/**
+ * Outcome of a completed lease. `healthy` keeps the worker for reuse; `poison`
+ * recycles the worker (a typed worker-transport fault, not a local/agent failure).
+ * `release(outcome)` defaults to `healthy`; `fail(reason)` is equivalent to
+ * `release('poison')` with a recorded reason.
+ */
+export type WorkerOutcome = "healthy" | "poison";
+/**
+ * Lifecycle state of a worker inside the pool inventory. Internal to the pool;
+ * surfaced (read-only) via `WorkerPoolSnapshot` for tests/observability.
+ *
+ * `WARMING` and `DRAINING` are never assigned by the current pool (provisioning
+ * probes inline and drain is a pool-level flag); they stay in the vocabulary for
+ * a future async warmup strategy / per-worker drain marker, and the leasable/reap
+ * guards already treat them correctly.
+ */
+export type WorkerState = "PROVISIONING" | "WARMING" | "WARM_IDLE" | "LEASED" | "DEGRADED" | "DESTROYING" | "DESTROYED" | "DRAINING";
+/**
+ * In-memory record the pool keeps per worker. Mutated only inside the per-worker
+ * mutex so the reaper and a lease release can never both touch `inFlight`.
+ */
+export interface WorkerRecord {
+    workerId: string;
+    workerHost: string;
+    driverRef: string;
+    state: WorkerState;
+    labels: ReadonlyArray<string>;
+    createdAtMs: number;
+    /** Identity of the current lease generation; a release with a stale id is a no-op. */
+    leaseId: string | null;
+    /** Concurrent leases currently held against this worker (>= 0 invariant). */
+    inFlight: number;
+    /** When the worker last went idle (used by idle reaping). */
+    lastIdleAtMs: number;
+    /** Last heartbeat from the active run (used by orphan detection). */
+    lastHeartbeatMs: number;
+    /** Cumulative wall-clock worker-seconds attributed to this worker (monotonic). */
+    workerSecondsUsed: number;
+    /** Set when the reaper wants the worker gone but a lease is still in flight. */
+    markedForDestroy: boolean;
+    /** The affinity key (prior workerHost) this worker is currently sticky to, if any. */
+    affinityKey: string | null;
+    /** Per-worker metadata mirrored from the descriptor. */
+    metadata: Record<string, unknown>;
+    /**
+     * Per-issue lease refcount against this worker: issue id -> number of leases that
+     * issue currently holds on this worker. Used to enforce the optional
+     * `maxWorkersPerIssue` fairness cap (so one ensemble cannot monopolize the pool).
+     * A plain set of issue ids is wrong under co-residence (`slotsPerMachine>1`):
+     * the SAME issue can hold two slots on one worker, so settling one must not forget
+     * the worker still belongs to that issue. The key is dropped only when its count
+     * reaches zero. Absent on records that predate the pool's per-issue accounting;
+     * treated as empty.
+     */
+    leaseIssues?: Map<string, number>;
+    /**
+     * Acquire timestamps (ms) of every lease currently in flight against this worker,
+     * one entry per outstanding lease (so `maxInFlight>1` overlapping leases each
+     * carry their own window). A normal settle removes its own entry as it accrues
+     * its window in `onLeaseSettle`; a drain that force-destroys a still-LEASED worker
+     * accrues every remaining entry's window so the in-flight worker-seconds are not
+     * dropped. Absent on records that predate this accounting; treated as empty.
+     */
+    liveLeaseAcquiredMs?: number[];
+    /**
+     * The driver that PROVISIONED this worker, captured by `swapDriver` on a driver
+     * hot-reload BEFORE the pool reassigns its live `this.driver`. A teardown
+     * (`recycle`/`destroyDescriptor`) routes `destroy` to
+     * `record.originDriver ?? this.driver`, so an in-flight lease that settles
+     * AFTER a driver swap destroys its worker on the ORIGINAL backend and a paid worker
+     * is never orphaned on the now-detached driver. Absent on workers provisioned
+     * under the live driver (no swap has happened); treated as `this.driver`.
+     */
+    originDriver?: WorkerDriver;
+}
+/**
+ * Forward-looking alias for {@link WorkerRecord}. `WorkerRecord` stays the canonical
+ * name and shape (every implementation file keeps importing it); `MachineLease`
+ * is a pure re-export so downstream dispatch-coordinator code can refer to a
+ * leased machine by its domain noun without a second, drift-prone type. The two
+ * are structurally identical (an alias, not a subtype), so swapping one for the
+ * other is byte-identical.
+ */
+export type MachineLease = WorkerRecord;
+/**
+ * A single write-ahead ledger row (cloud drivers only). Written provisionally
+ * BEFORE provision, then upserted with `driverRef`/`workerHost` after the
+ * driver returns, so a crash mid-provision is recoverable by labels or workerId.
+ */
+export interface LedgerRow {
+    workerId: string;
+    driverRef: string | null;
+    workerHost: string | null;
+    labels: ReadonlyArray<string>;
+    /** `provisional` until the driver returns; then `active`; `destroying` while reaping. */
+    status: "provisional" | "active" | "destroying";
+    createdAtMs: number;
+    updatedAtMs: number;
+}
+/**
+ * A leased worker handed to the runtime. `release(outcome)` / `fail(reason)` settle
+ * the lease exactly once (guarded by `leaseId` + a `settled` flag + worker state);
+ * a stale generation or a DESTROYED worker is a no-op that never touches `inFlight`.
+ */
+export interface WorkerLease {
+    readonly leaseId: string;
+    readonly workerId: string;
+    readonly workerHost: string;
+    readonly acquiredAtMs: number;
+    readonly expiresAtMs: number | null;
+    release(outcome?: WorkerOutcome): Promise<void>;
+    fail(reason: string): Promise<void>;
+    heartbeat(): void;
+}
+/**
+ * Request to lease a worker for one run. `affinityKey` is the prior `workerHost`
+ * (sticky re-acquire on retry), NOT the pending sentinel. `labels` describe the
+ * issue/ensemble slot so the pool can apply per-issue fairness caps.
+ */
+export type AcquireRequest = {
+    issueId: string;
+    slotIndex: number;
+    labels: ReadonlyArray<string>;
+    affinityKey?: string | null;
+    timeoutMs: number;
+    signal?: AbortSignal;
+};
+/**
+ * Result of an acquire. `leased` carries a settled-once `WorkerLease`; `no_capacity`
+ * surfaces a typed reason mapped onto the existing `worker_host_capacity` dispatch
+ * signal so dispatch can recover (abandon-and-re-evaluate) without backoff churn.
+ */
+export type AcquireResult = {
+    status: "leased";
+    lease: WorkerLease;
+} | {
+    status: "no_capacity";
+    reason: "acquire_timeout" | "spend_cap" | "pool_disabled" | "driver_error";
+};
+/**
+ * Read-only view of pool state for tests/observability. Worker-seconds are
+ * cumulative wall-clock seconds; `dayKey` is the UTC day the daily cap rolls on.
+ */
+export interface WorkerPoolSnapshot {
+    enabled: boolean;
+    driver: WorkerDriverKind;
+    total: number;
+    warmIdle: number;
+    leased: number;
+    provisioning: number;
+    degraded: number;
+    inFlight: number;
+    spend: {
+        concurrentWorkers: number;
+        workerSecondsUsed: number;
+        dailyWorkerSecondsUsed: number;
+        dayKey: string;
+    };
+    workers: ReadonlyArray<{
+        workerId: string;
+        workerHost: string;
+        state: WorkerState;
+        inFlight: number;
+        markedForDestroy: boolean;
+    }>;
+}
+/**
+ * The embedded pool: a long-lived, reload-surviving singleton that produces each
+ * run's `workerHost`. `reconcile` diffs prev-vs-next settings on config reload;
+ * `hydrate` re-adopts survivors on startup; `drain` is awaitable so paid cloud
+ * workers are destroyed before process exit.
+ */
+export interface WorkerPool {
+    acquire(req: AcquireRequest): Promise<AcquireResult>;
+    canAcquire(): boolean;
+    /**
+     * Whether the pool currently GOVERNS worker-host capacity (i.e. `settings.enabled`).
+     * The pool survives config reloads, so a reload can DISABLE it (it drains to zero) while the
+     * orchestrator's lifetime capacity probe stays installed. The probe reads this to decide whether
+     * to delegate capacity to {@link WorkerPool.canAcquire} (governing) or fall through to static/local
+     * execution (not governing); a disabled pool that no longer governs must not block dispatch.
+     */
+    isEnabled(): boolean;
+    reconcile(next: WorkerPoolSettings): void;
+    /**
+     * Rebuilds the resolved driver IN PLACE (re-resolves `settings.driver` through
+     * the registry, re-threads the reaper driver, and rebuilds the ledger
+     * `usesLedger` gate) without reconstructing the singleton, capturing each
+     * existing worker's origin driver so an in-flight lease that settles AFTER the
+     * swap destroys its worker on the ORIGINAL backend. Called by `reconcile` when
+     * the driver construction changed (and by the dispatch coordinator before
+     * `reconcile` once it owns the reload path).
+     */
+    swapDriver(next: WorkerPoolSettings): void;
+    /**
+     * Registers a callback the pool invokes INSIDE the per-worker mutex immediately
+     * before it destroys a machine (every teardown path - a poison settle, a reaper
+     * reap, a driver-swap drain, and the drain force-destroy loop - routes through
+     * the single `recycle` chokepoint, so the callback fires exactly once per worker
+     * just before `driver.destroy`). The dispatch coordinator registers a callback
+     * here so a poisoned/recycled machine fails any still-open RunSlot bound to that
+     * worker CLEANLY (close its endpoint, settle, deregister) before the host dies,
+     * never leaving a hung endpoint to a dead host. The callback must be cheap and
+     * non-throwing; the pool swallows a callback error so a misbehaving listener can
+     * never block the teardown it precedes. Multiple callbacks may be registered.
+     */
+    onMachineRecycling(cb: (workerId: string) => void): void;
+    /**
+     * OPTIONAL additive hook: registers a callback the pool fires whenever it wakes
+     * its FIFO waiters AND capacity is actually leasable (`canAcquire()` is checked
+     * AFTER the waiters were woken, so a waiter that consumed the freed worker
+     * suppresses the notification). Fires on every capacity-freeing event - a lease
+     * settle returning a worker to warm, a reconcile/grow landing a warm worker, a reaper
+     * top-up. The runtime registers a poll nudge here so an issue skipped on
+     * `worker_host_capacity` re-dispatches within one scheduler turn of a worker
+     * landing warm instead of waiting out the poll interval. Callbacks must be
+     * cheap; the pool swallows callback errors so a misbehaving listener can never
+     * break the settle path that fired it. Optional so structural fakes/legacy
+     * pools without the hook stay valid (registration is then skipped).
+     */
+    onCapacityAvailable?(cb: () => void): void;
+    hydrate(): Promise<void>;
+    drain(opts: {
+        deadlineMs: number;
+        signal?: AbortSignal;
+    }): Promise<void>;
+    snapshot(): WorkerPoolSnapshot;
+}
+/**
+ * Tiny async mutex used to serialize per-worker state mutations and the
+ * reaper-vs-release interleave. `runExclusive` queues the body behind any
+ * in-flight body and resolves with its value (or rejects with its error),
+ * releasing the lock even when the body throws.
+ */
+export interface Mutex {
+    runExclusive<T>(fn: () => Promise<T>): Promise<T>;
+}
+//# sourceMappingURL=types.d.ts.map

package/packages/worker-pool/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}

package/packages/worker-pool/dist/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/packages/worker-pool/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":""}

package/packages/worker-pool/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "@lorenz/worker-pool",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "dependencies": {
+    "@lorenz/domain": "file:../domain",
+    "@lorenz/ssh": "file:../ssh",
+    "@lorenz/worker-sdk": "file:../worker-sdk"
+  }
+}

package/packages/worker-sdk/dist/conformance.d.ts

@@ -0,0 +1,64 @@
+import type { WorkerDriver, ProvisionRequest } from "./types.js";
+/**
+ * Shared, parameterized test body that asserts the {@link WorkerDriver} contract.
+ *
+ * This module deliberately lives under `src/` (not `test/`) so it compiles to
+ * `dist/` and can be imported by every driver's own test file (fake,
+ * static-ssh, and each cloud driver behind its own gate). It registers its own
+ * `describe`/`test` blocks, so a caller simply invokes it at the top level of a
+ * test file:
+ *
+ * ```ts
+ * runDriverConformanceSuite(() => new FakeWorkerDriver(deps), {
+ *   suiteName: "FakeWorkerDriver",
+ *   workerIds: ["worker-a", "worker-b"],
+ *   makeUnreachable: () => ({ driver, workerId: "worker-down" }),
+ * });
+ * ```
+ *
+ * The contract asserted here is intentionally minimal and driver-agnostic:
+ *   1. `provision` is idempotent on `workerId` (same id -> same worker).
+ *   2. `destroy` is idempotent and tolerant of an already-gone worker.
+ *   3. `list()` reflects provisioned-minus-destroyed.
+ *   4. `probe` gates a created-but-unreachable worker to `{ ok: false }`.
+ */
+/** Options that tailor the shared suite to a specific driver backend. */
+export interface ConformanceSuiteOptions {
+    /** Label for the `describe` block (e.g. the driver class name). */
+    suiteName?: string;
+    /**
+     * Two distinct, driver-acceptable worker ids. For fixed-inventory drivers
+     * (static-ssh, `min==max==len`) these must map onto real configured hosts.
+     */
+    workerIds: readonly [string, string];
+    /** Timeout passed to `provision` (defaults to 30s). */
+    provisionTimeoutMs?: number;
+    /** Timeout passed to `probe` (defaults to 30s). */
+    probeTimeoutMs?: number;
+    /** Timeout passed to `destroy` (defaults to 30s). */
+    destroyTimeoutMs?: number;
+    /**
+     * Builds a {@link ProvisionRequest} for a given worker id. Lets a driver supply
+     * its own `labels`/`driverOptions`. Defaults to a minimal request with a
+     * single `symphony.worker-pool` label and the configured `provisionTimeoutMs`.
+     */
+    makeProvisionRequest?: (workerId: string) => ProvisionRequest;
+    /**
+     * Yields a driver plus a worker id that is created-but-unreachable, so the
+     * suite can assert `probe` returns `{ ok: false }`. Optional: a driver that
+     * cannot represent an unreachable-but-created worker omits this and the probe
+     * gating case is skipped. Both built-in drivers supply it (fake via failure
+     * injection, static-ssh via an unroutable host).
+     */
+    makeUnreachable?: () => {
+        driver: WorkerDriver;
+        workerId: string;
+    };
+}
+/**
+ * Registers the shared {@link WorkerDriver} conformance tests. `makeDriver`
+ * must return a FRESH driver per call so each case starts from a clean
+ * inventory.
+ */
+export declare function runDriverConformanceSuite(makeDriver: () => WorkerDriver, opts: ConformanceSuiteOptions): void;
+//# sourceMappingURL=conformance.d.ts.map

package/packages/worker-sdk/dist/conformance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conformance.d.ts","sourceRoot":"","sources":["../src/conformance.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAoB,YAAY,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAEnF;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,yEAAyE;AACzE,MAAM,WAAW,uBAAuB;IACtC,mEAAmE;IACnE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;OAGG;IACH,SAAS,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACrC,uDAAuD;IACvD,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,mDAAmD;IACnD,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,qDAAqD;IACrD,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B;;;;OAIG;IACH,oBAAoB,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,gBAAgB,CAAC;IAC9D;;;;;;OAMG;IACH,eAAe,CAAC,EAAE,MAAM;QAAE,MAAM,EAAE,YAAY,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC;CACpE;AAYD;;;;GAIG;AACH,wBAAgB,yBAAyB,CACvC,UAAU,EAAE,MAAM,YAAY,EAC9B,IAAI,EAAE,uBAAuB,GAC5B,IAAI,CAkHN"}

package/packages/worker-sdk/dist/conformance.js

@@ -0,0 +1,109 @@
+import { describe, expect, test } from "vitest";
+import { POOL_OWNED_LABEL } from "./types.js";
+const DEFAULT_TIMEOUT_MS = 30_000;
+function descriptorOf(worker) {
+    return { workerId: worker.workerId, workerHost: worker.workerHost, driverRef: worker.driverRef };
+}
+/**
+ * Registers the shared {@link WorkerDriver} conformance tests. `makeDriver`
+ * must return a FRESH driver per call so each case starts from a clean
+ * inventory.
+ */
+export function runDriverConformanceSuite(makeDriver, opts) {
+    const suiteName = opts.suiteName ?? "WorkerDriver conformance";
+    const provisionTimeoutMs = opts.provisionTimeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const probeTimeoutMs = opts.probeTimeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const destroyTimeoutMs = opts.destroyTimeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const [workerIdA, workerIdB] = opts.workerIds;
+    const provisionRequest = (workerId) => opts.makeProvisionRequest?.(workerId) ?? {
+        workerId,
+        labels: ["symphony.worker-pool"],
+        timeoutMs: provisionTimeoutMs,
+    };
+    describe(suiteName, () => {
+        test("provision is idempotent on workerId", async () => {
+            const driver = makeDriver();
+            const first = await driver.provision(provisionRequest(workerIdA));
+            const second = await driver.provision(provisionRequest(workerIdA));
+            // Same idempotency key must yield the same worker identity (no duplicate).
+            expect(first.workerId).toBe(workerIdA);
+            expect(descriptorOf(second)).toEqual(descriptorOf(first));
+            // A second provision must NOT create a duplicate in the inventory.
+            const listed = await driver.list();
+            const matching = listed.filter((worker) => worker.workerId === workerIdA);
+            expect(matching).toHaveLength(1);
+        });
+        test("list() descriptors carry the pool-owned label", async () => {
+            // The pool's hydrate re-adoption and reaper reconcile gate ONLY re-adopt /
+            // destroy survivors whose list() descriptor carries POOL_OWNED_LABEL. A
+            // descriptor missing it is NEVER touched, so for a driver that creates
+            // disposable, pool-owned workers (ephemeral), a leaked survivor (e.g. a paid
+            // E2B/Modal/Fly/Docker worker left by a crashed daemon) would leak forever.
+            // Pinning the label on every ephemeral driver's list() descriptors
+            // catches that class of bug going forward.
+            //
+            // Non-ephemeral drivers (fixed-inventory static-ssh, in-memory fake) own
+            // no disposable resource the pool re-adopts/reaps via this gate, so the
+            // label is not load-bearing for them and the assertion does not apply.
+            const driver = makeDriver();
+            if (!driver.capabilities.ephemeral)
+                return;
+            await driver.provision(provisionRequest(workerIdA));
+            const listed = await driver.list();
+            expect(listed.length).toBeGreaterThan(0);
+            for (const worker of listed) {
+                expect(worker.labels).toContain(POOL_OWNED_LABEL);
+            }
+        });
+        test("list() reflects provisioned-minus-destroyed", async () => {
+            const driver = makeDriver();
+            const a = await driver.provision(provisionRequest(workerIdA));
+            const b = await driver.provision(provisionRequest(workerIdB));
+            const afterProvision = (await driver.list()).map((worker) => worker.workerId).sort();
+            expect(afterProvision).toContain(workerIdA);
+            expect(afterProvision).toContain(workerIdB);
+            await driver.destroy(b, { timeoutMs: destroyTimeoutMs, reason: "shrink" });
+            const afterDestroy = (await driver.list()).map((worker) => worker.workerId);
+            // The surviving worker is still listed; the destroyed one is gone.
+            expect(afterDestroy).toContain(a.workerId);
+            expect(afterDestroy).not.toContain(b.workerId);
+        });
+        test("destroy is idempotent (already-gone is ok)", async () => {
+            const driver = makeDriver();
+            const worker = await driver.provision(provisionRequest(workerIdA));
+            // Destroying twice must not throw; the worker is gone after the first call.
+            await driver.destroy(worker, { timeoutMs: destroyTimeoutMs, reason: "idle" });
+            await driver.destroy(worker, { timeoutMs: destroyTimeoutMs, reason: "idle" });
+            const listed = (await driver.list()).map((entry) => entry.workerId);
+            expect(listed).not.toContain(worker.workerId);
+        });
+        test("destroy of a never-provisioned worker is a no-op (does not throw)", async () => {
+            const driver = makeDriver();
+            const phantom = {
+                workerId: workerIdA,
+                workerHost: "unknown",
+                driverRef: "unknown",
+                createdAtMs: 0,
+                labels: ["symphony.worker-pool"],
+                metadata: {},
+            };
+            // Destroying a worker the driver has never seen must be tolerated.
+            await driver.destroy(phantom, { timeoutMs: destroyTimeoutMs, reason: "orphan" });
+        });
+        if (opts.makeUnreachable) {
+            const makeUnreachable = opts.makeUnreachable;
+            test("probe gates a created-but-unreachable worker to ok:false", async () => {
+                const { driver, workerId } = makeUnreachable();
+                const worker = await driver.provision(provisionRequest(workerId));
+                const health = await driver.probe(worker, { timeoutMs: probeTimeoutMs });
+                expect(health.ok).toBe(false);
+                if (!health.ok) {
+                    // The failure must carry a non-empty reason for diagnostics.
+                    expect(typeof health.reason).toBe("string");
+                    expect(health.reason.length).toBeGreaterThan(0);
+                }
+            });
+        }
+    });
+}
+//# sourceMappingURL=conformance.js.map

package/packages/worker-sdk/dist/conformance.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"conformance.js","sourceRoot":"","sources":["../src/conformance.ts"],"names":[],"mappings":"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"}

package/packages/worker-sdk/dist/fake.d.ts

@@ -0,0 +1,76 @@
+import type { WorkerDriverRegistry } from "./registry.js";
+import type { WorkerDescriptor, WorkerDriver, WorkerDriverFactory, DriverCapabilities, DriverDeps, WorkerHealth, ProvisionRequest, TeardownReason } from "./types.js";
+/**
+ * An in-memory {@link WorkerDriver} used by the always-on test layer and the
+ * memory-tracker e2e demo, and the SDK's reference implementation of the
+ * driver contract. It owns no real machines and touches no disk: every
+ * operation mutates a `Map<workerId, WorkerDescriptor>` and the yielded `workerHost`
+ * is a synthetic `fake://worker-<workerId>` address. Determinism comes from the
+ * injected clock (so `createdAtMs` is reproducible), and failure can be
+ * injected per-worker so tests can exercise probe/provision/destroy faults and
+ * the conformance suite's unreachable-worker case.
+ */
+export declare class FakeWorkerDriver implements WorkerDriver {
+    private readonly deps;
+    readonly kind = "fake";
+    readonly capabilities: DriverCapabilities;
+    private readonly workers;
+    private readonly probeFailures;
+    private readonly provisionFailures;
+    private readonly destroyFailures;
+    private writes;
+    constructor(deps: Pick<DriverDeps, "clock">);
+    /** Number of fs writes performed (always 0; the driver is purely in-memory). */
+    get fsWriteCount(): number;
+    /**
+     * Provisions (or re-adopts) a worker for `req.workerId`. Idempotent on `workerId`: a
+     * second call returns the SAME descriptor without creating a duplicate. The
+     * descriptor is stamped from the injected clock so its `createdAtMs` is
+     * deterministic.
+     */
+    provision(req: ProvisionRequest): Promise<WorkerDescriptor>;
+    /**
+     * Reports the worker healthy unless a probe failure was injected for its
+     * `workerId`. An unknown/already-destroyed worker is reported `ok: false` rather
+     * than throwing (mirroring a real probe against a gone machine).
+     */
+    probe(worker: WorkerDescriptor, _opts: {
+        timeoutMs: number;
+        signal?: AbortSignal;
+    }): Promise<WorkerHealth>;
+    /**
+     * Destroys a worker. Idempotent and tolerant of an already-gone (or
+     * never-provisioned) worker. Rejects only when a destroy failure was injected
+     * for the worker, leaving the worker in place so the caller can retry.
+     */
+    destroy(worker: WorkerDescriptor, _opts: {
+        timeoutMs: number;
+        reason: TeardownReason;
+    }): Promise<void>;
+    /** Returns the live inventory (provisioned-minus-destroyed). */
+    list(): Promise<WorkerDescriptor[]>;
+    /** Injects a probe failure so `probe` returns `{ ok: false, reason }`. */
+    injectProbeFailure(workerId: string, reason: string): void;
+    /** Clears a previously injected probe failure so the worker probes healthy again. */
+    clearProbeFailure(workerId: string): void;
+    /** Injects a provision failure so `provision` rejects with `reason`. */
+    injectProvisionFailure(workerId: string, reason: string): void;
+    /** Clears a previously injected provision failure. */
+    clearProvisionFailure(workerId: string): void;
+    /** Injects a destroy failure so `destroy` rejects with `reason`. */
+    injectDestroyFailure(workerId: string, reason: string): void;
+    /** Clears a previously injected destroy failure. */
+    clearDestroyFailure(workerId: string): void;
+}
+/** The registered `fake` factory: constructs a fresh in-memory driver per pool. */
+export declare const fakeWorkerDriverFactory: WorkerDriverFactory;
+/**
+ * Registers the `fake` driver. The SDK ships this reference driver (rather
+ * than an extension) so engine and extension test suites alike can exercise
+ * the pool without real machines; the composition root registers it next to
+ * the real driver extensions.
+ */
+export declare function registerFakeWorkerDriver(registries?: {
+    workerDrivers?: WorkerDriverRegistry | undefined;
+}): void;
+//# sourceMappingURL=fake.d.ts.map

package/packages/worker-sdk/dist/fake.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fake.d.ts","sourceRoot":"","sources":["../src/fake.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AAE1D,OAAO,KAAK,EACV,gBAAgB,EAChB,YAAY,EACZ,mBAAmB,EACnB,kBAAkB,EAClB,UAAU,EACV,YAAY,EACZ,gBAAgB,EAChB,cAAc,EACf,MAAM,YAAY,CAAC;AAUpB;;;;;;;;;GASG;AACH,qBAAa,gBAAiB,YAAW,YAAY;IAmBvC,OAAO,CAAC,QAAQ,CAAC,IAAI;IAlBjC,QAAQ,CAAC,IAAI,UAAQ;IACrB,QAAQ,CAAC,YAAY,qBAAgB;IAIrC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAuC;IAI/D,OAAO,CAAC,QAAQ,CAAC,aAAa,CAA6B;IAC3D,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAA6B;IAC/D,OAAO,CAAC,QAAQ,CAAC,eAAe,CAA6B;IAK7D,OAAO,CAAC,MAAM,CAAK;gBAEU,IAAI,EAAE,IAAI,CAAC,UAAU,EAAE,OAAO,CAAC;IAE5D,gFAAgF;IAChF,IAAI,YAAY,IAAI,MAAM,CAEzB;IAED;;;;;OAKG;IACG,SAAS,CAAC,GAAG,EAAE,gBAAgB,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAwBjE;;;;OAIG;IACG,KAAK,CACT,MAAM,EAAE,gBAAgB,EACxB,KAAK,EAAE;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,WAAW,CAAA;KAAE,GACjD,OAAO,CAAC,YAAY,CAAC;IAWxB;;;;OAIG;IACG,OAAO,CACX,MAAM,EAAE,gBAAgB,EACxB,KAAK,EAAE;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,cAAc,CAAA;KAAE,GACnD,OAAO,CAAC,IAAI,CAAC;IAShB,gEAAgE;IAC1D,IAAI,IAAI,OAAO,CAAC,gBAAgB,EAAE,CAAC;IAIzC,0EAA0E;IAC1E,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;IAI1D,qFAAqF;IACrF,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAIzC,wEAAwE;IACxE,sBAAsB,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;IAI9D,sDAAsD;IACtD,qBAAqB,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAI7C,oEAAoE;IACpE,oBAAoB,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;IAI5D,oDAAoD;IACpD,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;CAG5C;AAED,mFAAmF;AACnF,eAAO,MAAM,uBAAuB,EAAE,mBAGrC,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,wBAAwB,CACtC,UAAU,GAAE;IAAE,aAAa,CAAC,EAAE,oBAAoB,GAAG,SAAS,CAAA;CAAO,GACpE,IAAI,CAKN"}