@swirls/looms 0.0.2 → 0.2.0

package/dist/runtime/wake-engine.d.ts

@@ -0,0 +1,20 @@
+import { type Context, type ManagedRuntime } from 'effect';
+import { type ComposedRegistry, type RegisteredDefinition } from '@swirls/looms/core';
+import { type RuntimeObserver } from './observer';
+import type { RuntimeRepository } from './repository';
+import type { RunExecutionContexts } from './run-execution-context';
+import type { LoomsRuntime, EffectWorker } from './types';
+import type { WakeScheduler } from './wake-scheduler';
+export interface WakeEngineOptions {
+    readonly registry: ComposedRegistry;
+    readonly services: ManagedRuntime.ManagedRuntime<Context.Service.Any, never>;
+    readonly definitions: ReadonlyMap<string, RegisteredDefinition>;
+    readonly executionContexts: RunExecutionContexts;
+    readonly repository: RuntimeRepository;
+    readonly snapshotEvery: number;
+    readonly maxWakeIterations: number;
+    readonly worker?: EffectWorker;
+    readonly observer?: RuntimeObserver;
+    readonly scheduler: () => WakeScheduler;
+}
+export declare function createWakeEngine(options: WakeEngineOptions): LoomsRuntime['wake'];

package/dist/runtime/wake-engine.js

@@ -0,0 +1,311 @@
+import { Clock, Effect, Exit, Option } from 'effect';
+import { createEvent, EventStoreTag, foldRun, isRunTerminal, } from '@swirls/looms/core';
+import { nextRuntimeDeadline, planDeadlineTransitions, planTerminalCancellationTransitions, } from './deadline-transition-planner.js';
+import { DuplicateEffectDispatchError, MaxWakeIterationsError, RuntimeExecutionError, } from './errors.js';
+import { stripSeq, synthesizedThreadFailed, waitSatisfiedEvents } from './helpers.js';
+import { executeLocalEffects } from './local-effect-executor.js';
+import { notifyObserver } from './observer.js';
+import { dispatchWorkerEffect, isWorkerEffect, planWorkerEffects } from './worker-effect-dispatch.js';
+function currentTimeMillis() {
+    return Math.floor(performance.timeOrigin + performance.now());
+}
+export function createWakeEngine(options) {
+    const { registry, services, definitions, executionContexts, repository, snapshotEvery, maxWakeIterations, } = options;
+    const { appendObserved, applyAppend, liveAppends, loadCursor, persistSnapshot } = repository;
+    const runCache = {
+        delete: repository.deleteCachedCursor,
+        set: repository.setCachedCursor,
+    };
+    const observe = (event) => notifyObserver(options.observer, event);
+    return (runId) => Effect.gen(function* () {
+        observe({ type: 'run.wake', runId, at: currentTimeMillis() });
+        const executionContext = executionContexts.get(runId);
+        // Claim synchronously before any yield so concurrent fibers cannot both pass.
+        if (executionContext.waking) {
+            executionContext.wakeAgain = true;
+            const activeCompletion = executionContext.wakeCompletion;
+            if (!activeCompletion) {
+                return yield* new RuntimeExecutionError(`Run "${runId}" has an active wake without completion state`);
+            }
+            const completion = yield* Effect.promise(() => activeCompletion);
+            if (Exit.isFailure(completion)) {
+                return yield* Effect.failCause(completion.cause);
+            }
+            return completion.value;
+        }
+        let resolveCompletion;
+        // oxlint-disable-next-line effecttsgo/new-promise
+        executionContext.wakeCompletion = new Promise((resolve) => {
+            resolveCompletion = resolve;
+        });
+        executionContext.resolveWakeCompletion = resolveCompletion;
+        executionContext.waking = true;
+        let released = false;
+        const releaseWake = () => {
+            released = true;
+            executionContext.waking = false;
+            executionContext.wakeAgain = false;
+            executionContext.wakeCompletion = null;
+            executionContext.resolveWakeCompletion = null;
+            executionContext.liveStore = undefined;
+            liveAppends.clear(runId);
+            executionContext.liveCount = 0;
+            executionContexts.releaseIfIdle(runId);
+        };
+        // Checking for a joined wake and releasing the claim must happen without yielding, or a wake
+        // requested in between would join a completion that never saw its events.
+        const releaseUnlessWokenAgain = () => {
+            if (executionContext.wakeAgain) {
+                executionContext.wakeAgain = false;
+                return false;
+            }
+            releaseWake();
+            return true;
+        };
+        return yield* Effect.gen(function* () {
+            const store = yield* EventStoreTag;
+            const runInContext = Effect.runPromiseWith(yield* Effect.context());
+            executionContext.liveStore = store;
+            let finalState;
+            do {
+                let cursor = yield* loadCursor(store, runId);
+                if (isRunTerminal(cursor.state)) {
+                    const now = yield* Clock.currentTimeMillis;
+                    const events = planTerminalCancellationTransitions({
+                        runId,
+                        state: cursor.state,
+                        now,
+                    });
+                    if (events.length > 0) {
+                        const appended = yield* appendObserved(store, runId, stripSeq(events));
+                        cursor = yield* applyAppend(store, runId, cursor, stripSeq(events), appended);
+                    }
+                    const nextDeadline = nextRuntimeDeadline(cursor.state, now);
+                    if (nextDeadline !== undefined) {
+                        yield* options.scheduler().schedule(runId, nextDeadline);
+                    }
+                    else {
+                        yield* options.scheduler().cancel(runId);
+                    }
+                    finalState = cursor.state;
+                    continue;
+                }
+                executionContext.liveCount = 0;
+                const dispatchedEffectIds = new Set();
+                const startedEffectIds = new Set();
+                let guard = 0;
+                // Deadlines at or before this instant were handled by the last loop iteration.
+                let plannedAt = Number.NEGATIVE_INFINITY;
+                while (!isRunTerminal(cursor.state)) {
+                    if (guard >= maxWakeIterations) {
+                        return yield* new MaxWakeIterationsError(runId, maxWakeIterations);
+                    }
+                    guard += 1;
+                    const state = cursor.state;
+                    const now = yield* Clock.currentTimeMillis;
+                    plannedAt = now;
+                    const deadlinePlan = planDeadlineTransitions({ runId, state, registry, now });
+                    if (deadlinePlan.events.length > 0) {
+                        for (const notice of deadlinePlan.timerNotices) {
+                            observe({
+                                type: 'timer.late',
+                                runId,
+                                at: now,
+                                timerId: notice.timerId,
+                                latenessMs: notice.latenessMs,
+                            });
+                        }
+                        for (const notice of deadlinePlan.timeoutNotices) {
+                            observe({
+                                type: 'effect.timeout',
+                                runId,
+                                at: now,
+                                effectId: notice.effectId,
+                                attempt: notice.attempt,
+                                detail: notice.timeout,
+                            });
+                        }
+                        const append = deadlinePlan.timerNotices.length > 0
+                            ? yield* appendObserved(store, runId, stripSeq(deadlinePlan.events), {
+                                expectedTail: cursor.seq,
+                            }).pipe(Effect.asSome, Effect.catchTag('EventStoreConflictError', () => Effect.succeedNone))
+                            : Option.some(yield* appendObserved(store, runId, stripSeq(deadlinePlan.events)));
+                        if (Option.isNone(append)) {
+                            runCache.delete(runId);
+                            cursor = yield* loadCursor(store, runId);
+                            continue;
+                        }
+                        cursor = yield* applyAppend(store, runId, cursor, stripSeq(deadlinePlan.events), append.value);
+                        continue;
+                    }
+                    const workerPlans = planWorkerEffects({
+                        runId,
+                        state,
+                        registry,
+                        worker: options.worker,
+                        now,
+                    });
+                    if (workerPlans.length > 0) {
+                        for (const workerPlan of workerPlans) {
+                            if (workerPlan.queuedEvent) {
+                                const queuedAppend = yield* appendObserved(store, runId, stripSeq([workerPlan.queuedEvent]));
+                                cursor = yield* applyAppend(store, runId, cursor, stripSeq([workerPlan.queuedEvent]), queuedAppend);
+                            }
+                            const dispatchEvent = yield* dispatchWorkerEffect(runId, workerPlan, options.worker);
+                            const dispatchAppend = yield* appendObserved(store, runId, stripSeq([dispatchEvent]));
+                            cursor = yield* applyAppend(store, runId, cursor, stripSeq([dispatchEvent]), dispatchAppend);
+                        }
+                        continue;
+                    }
+                    const cancellationTargets = new Set(state.outstandingEffects.flatMap((item) => item.effect.type === 'runtime.cancel' && 'threadId' in item.effect
+                        ? [item.effect.threadId]
+                        : []));
+                    const outstanding = state.outstandingEffects.filter((item) => {
+                        const execution = state.effectExecutions[item.effectId];
+                        return !((cancellationTargets.has(item.threadId) && item.effect.type !== 'runtime.cancel') ||
+                            isWorkerEffect({ runId, item, execution, registry, worker: options.worker }) ||
+                            (execution?.status === 'retry_wait' &&
+                                execution.nextAttemptAt !== null &&
+                                execution.nextAttemptAt > now));
+                    });
+                    if (outstanding.length === 0) {
+                        break;
+                    }
+                    const attempts = new Map(outstanding.map((item) => {
+                        const execution = state.effectExecutions[item.effectId];
+                        const attempt = execution?.status === 'running' && startedEffectIds.has(item.effectId)
+                            ? execution.attempt
+                            : (execution?.attempt ?? 0) + 1;
+                        return [item.effectId, attempt];
+                    }));
+                    for (const item of outstanding) {
+                        const dispatchKey = `${item.effectId}:${attempts.get(item.effectId) ?? 1}`;
+                        if (dispatchedEffectIds.has(dispatchKey)) {
+                            return yield* new DuplicateEffectDispatchError(runId, item.effectId, item.threadId);
+                        }
+                    }
+                    for (const item of outstanding) {
+                        dispatchedEffectIds.add(`${item.effectId}:${attempts.get(item.effectId) ?? 1}`);
+                    }
+                    const attemptEvents = outstanding.map((item) => createEvent(runId, {
+                        type: 'runtime.effect.attempt.started',
+                        payload: {
+                            effectId: item.effectId,
+                            attempt: attempts.get(item.effectId) ?? 1,
+                        },
+                        threadId: item.threadId,
+                        origin: { type: 'system' },
+                    }));
+                    for (const item of outstanding) {
+                        observe({
+                            type: 'effect.attempt',
+                            runId,
+                            at: now,
+                            effectId: item.effectId,
+                            attempt: attempts.get(item.effectId) ?? 1,
+                        });
+                    }
+                    const attemptAppend = yield* appendObserved(store, runId, stripSeq(attemptEvents));
+                    for (const item of outstanding) {
+                        startedEffectIds.add(item.effectId);
+                    }
+                    cursor = yield* applyAppend(store, runId, cursor, stripSeq(attemptEvents), attemptAppend);
+                    const produced = yield* executeLocalEffects({
+                        registry,
+                        services,
+                        definitions,
+                        executionContext,
+                        liveAppends,
+                        runInContext,
+                        observe,
+                    }, { runId, outstanding, attempts, now });
+                    if (produced.length === 0) {
+                        break;
+                    }
+                    yield* liveAppends.drain(runId);
+                    const beforeFold = cursor.state;
+                    const intermediateState = foldRun(produced, registry, { runId, initial: beforeFold });
+                    const synthesized = synthesizedThreadFailed(beforeFold, intermediateState, produced);
+                    const synthesizedEvents = synthesized.map((input) => createEvent(runId, input));
+                    const stateAfterSynth = synthesizedEvents.length > 0
+                        ? foldRun(synthesizedEvents, registry, { runId, initial: intermediateState })
+                        : intermediateState;
+                    const allNewEvents = [...produced, ...synthesizedEvents];
+                    const satisfied = waitSatisfiedEvents(stateAfterSynth, allNewEvents);
+                    const satisfiedEvents = satisfied.map((input) => createEvent(runId, input));
+                    const fullBatch = [...allNewEvents, ...satisfiedEvents];
+                    const appendResult = yield* appendObserved(store, runId, stripSeq(fullBatch));
+                    cursor = yield* applyAppend(store, runId, cursor, stripSeq(fullBatch), appendResult);
+                    // Bound replay after a crash inside a long wake.
+                    if (snapshotEvery > 0 && cursor.durableSinceSnapshot >= snapshotEvery) {
+                        cursor = yield* persistSnapshot(store, runId, cursor);
+                    }
+                }
+                const root = cursor.state.rootThreadId
+                    ? cursor.state.threads[cursor.state.rootThreadId]
+                    : undefined;
+                if (root &&
+                    (root.status === 'completed' ||
+                        root.status === 'failed' ||
+                        root.status === 'cancelled') &&
+                    !isRunTerminal(cursor.state)) {
+                    const completed = root.status === 'cancelled'
+                        ? createEvent(runId, {
+                            type: 'runtime.run.cancelled',
+                            payload: { reason: root.error ?? 'cancelled' },
+                            threadId: null,
+                            origin: { type: 'system' },
+                        })
+                        : createEvent(runId, {
+                            type: 'runtime.run.completed',
+                            payload: {
+                                output: root.output,
+                                error: root.error,
+                            },
+                            threadId: null,
+                            origin: { type: 'system' },
+                        });
+                    const appendResult = yield* appendObserved(store, runId, stripSeq([completed]));
+                    cursor = yield* applyAppend(store, runId, cursor, stripSeq([completed]), appendResult);
+                }
+                // Snapshot on park: the next wake (on any instance) starts from here.
+                cursor = yield* persistSnapshot(store, runId, cursor);
+                const nextDeadline = nextRuntimeDeadline(cursor.state, plannedAt);
+                if (nextDeadline !== undefined) {
+                    yield* options.scheduler().schedule(runId, nextDeadline);
+                }
+                else {
+                    yield* options.scheduler().cancel(runId);
+                }
+                if (isRunTerminal(cursor.state)) {
+                    observe({
+                        type: 'run.terminal',
+                        runId,
+                        at: currentTimeMillis(),
+                        status: cursor.state.status,
+                    });
+                    runCache.delete(runId);
+                }
+                else {
+                    observe({
+                        type: 'run.park',
+                        runId,
+                        at: currentTimeMillis(),
+                        status: cursor.state.status,
+                    });
+                    runCache.set(runId, cursor);
+                }
+                finalState = cursor.state;
+            } while (!releaseUnlessWokenAgain());
+            if (!finalState) {
+                return yield* new RuntimeExecutionError(`Wake for run "${runId}" completed without state`);
+            }
+            return finalState;
+        }).pipe(Effect.onExit((exit) => Effect.sync(() => {
+            if (!released) {
+                releaseWake();
+            }
+            resolveCompletion(exit);
+        })));
+    });
+}

package/dist/runtime/wake-scheduler.d.ts

@@ -1,8 +1,7 @@
 import { Effect } from 'effect';
 export interface WakeScheduler {
-    schedule(runId: string, at: number): void | Promise<void>;
-    cancel(runId: string): void | Promise<void>;
+    schedule(runId: string, at: number): Effect.Effect<void>;
+    cancel(runId: string): Effect.Effect<void>;
     dispose?(): void;
 }
-export declare function createTimeoutScheduler(wake: (runId: string) => Promise<void> | void): WakeScheduler;
-export declare function toEffectVoid(result: void | Promise<void>): Effect.Effect<void>;
+export declare function createTimeoutScheduler(wake: (runId: string) => Effect.Effect<void>): WakeScheduler;

package/dist/runtime/wake-scheduler.js

@@ -1,38 +1,32 @@
-import { Effect } from 'effect';
+import { Clock, Effect, Fiber } from 'effect';
 export function createTimeoutScheduler(wake) {
-    const scheduledTimers = new Map();
+    const scheduled = new Map();
+    const cancel = (runId) => Effect.gen(function* () {
+        const existing = scheduled.get(runId);
+        if (existing) {
+            scheduled.delete(runId);
+            yield* Fiber.interrupt(existing.fiber);
+        }
+    });
     return {
-        schedule(runId, timerAt) {
-            const existing = scheduledTimers.get(runId);
-            if (existing) {
-                clearTimeout(existing);
-                scheduledTimers.delete(runId);
-            }
-            const delay = Math.max(0, timerAt - Date.now() + 5);
-            const handle = setTimeout(() => {
-                scheduledTimers.delete(runId);
-                void wake(runId);
-            }, delay);
-            scheduledTimers.set(runId, handle);
-        },
-        cancel(runId) {
-            const existing = scheduledTimers.get(runId);
-            if (existing) {
-                clearTimeout(existing);
-                scheduledTimers.delete(runId);
-            }
-        },
+        schedule: (runId, timerAt) => Effect.gen(function* () {
+            yield* cancel(runId);
+            const now = yield* Clock.currentTimeMillis;
+            const token = Symbol(runId);
+            const release = Effect.sync(() => {
+                if (scheduled.get(runId)?.token === token) {
+                    scheduled.delete(runId);
+                }
+            });
+            const fiber = yield* Effect.sleep(Math.max(0, timerAt - now + 5)).pipe(Effect.andThen(release), Effect.andThen(wake(runId)), Effect.ensuring(release), Effect.forkDetach);
+            scheduled.set(runId, { fiber, token });
+        }),
+        cancel,
         dispose() {
-            for (const handle of scheduledTimers.values()) {
-                clearTimeout(handle);
+            for (const { fiber } of scheduled.values()) {
+                Effect.runFork(Fiber.interrupt(fiber));
             }
-            scheduledTimers.clear();
+            scheduled.clear();
         },
     };
 }
-export function toEffectVoid(result) {
-    if (result instanceof Promise) {
-        return Effect.promise(() => result);
-    }
-    return Effect.void;
-}

package/dist/runtime/worker-callbacks.d.ts

@@ -0,0 +1,16 @@
+import { Effect } from 'effect';
+import { EventStoreTag, type ComposedRegistry, type RunState, type WorkerCallbackInput } from '@swirls/looms/core';
+import type { RunIngress } from './ingress';
+import { type RuntimeObserver } from './observer';
+import type { RuntimeRepository } from './repository';
+import type { LoomsRuntime } from './types';
+export interface WorkerCallbacksOptions {
+    readonly registry: ComposedRegistry;
+    readonly repository: RuntimeRepository;
+    readonly withRunIngress: RunIngress;
+    readonly observer?: RuntimeObserver;
+    readonly wake: LoomsRuntime['wake'];
+}
+export declare function createWorkerCallbacks(options: WorkerCallbacksOptions): {
+    workerCallback: (runId: string, callback: WorkerCallbackInput) => Effect.Effect<RunState, import("./errors").DuplicateEffectDispatchError | Error | import("@swirls/looms/core").EventPayloadTooLargeError | import("@swirls/looms/core").EventStoreConflictError | import("@swirls/looms/core").EventStoreError | import("@swirls/looms/core").EventStoreFencedError | import("@swirls/looms/core").EventStoreTrimmedError | import("@swirls/looms/core").EventStoreTruncationError | import("./errors").MaxWakeIterationsError | import("./ingress").RunOverloadedError | import("./errors").RuntimeExecutionError, EventStoreTag>;
+};

package/dist/runtime/worker-callbacks.js

@@ -0,0 +1,167 @@
+import { Clock, Effect, Predicate } from 'effect';
+import { createEvent, EventStoreTag, isRunTerminal, } from '@swirls/looms/core';
+import { materializeEffectOutcome } from './helpers.js';
+import { notifyObserver } from './observer.js';
+import { planAttemptFailure } from './retry-policy.js';
+const WORKER_ORIGIN = { type: 'external', actorId: 'worker' };
+/** The earliest of the start-to-close cap and the next heartbeat deadline. */
+function workerDeadline(retry, startedAt, now) {
+    const deadlines = [
+        retry?.startToCloseTimeoutMs ? startedAt + retry.startToCloseTimeoutMs : null,
+        retry?.heartbeatTimeoutMs ? now + retry.heartbeatTimeoutMs : null,
+    ].filter(Predicate.isNotNull);
+    return deadlines.length > 0 ? Math.min(...deadlines) : null;
+}
+function workerStartedEvent(runId, item, attempt, retry, now) {
+    return createEvent(runId, {
+        type: 'runtime.effect.worker.started',
+        payload: { effectId: item.effectId, attempt, deadlineAt: workerDeadline(retry, now, now) },
+        threadId: item.threadId,
+        origin: WORKER_ORIGIN,
+    });
+}
+const IGNORED = { events: [], notices: [] };
+/**
+ * Turn a worker callback into events against the current durable state. Callbacks for another
+ * attempt, a settled attempt, or an effect running in process are ignored.
+ */
+function planWorkerCallback(input) {
+    const { runId, state, callback, registry, now } = input;
+    const execution = state.effectExecutions[callback.effectId];
+    const item = state.outstandingEffects.find((candidate) => candidate.effectId === callback.effectId);
+    const isCancellationAcknowledgement = callback.kind === 'cancelled' &&
+        execution?.attempt === callback.attempt &&
+        execution.status === 'cancel_requested';
+    if (!execution ||
+        execution.attempt !== callback.attempt ||
+        (isRunTerminal(state) && !isCancellationAcknowledgement) ||
+        (!item && !isCancellationAcknowledgement) ||
+        execution.status === 'running' ||
+        execution.status === 'retry_wait' ||
+        execution.status === 'timed_out' ||
+        execution.status === 'ambiguous' ||
+        (callback.kind === 'cancelled' && !isCancellationAcknowledgement) ||
+        (execution.status === 'cancel_requested' && callback.kind !== 'cancelled')) {
+        return Effect.succeed(IGNORED);
+    }
+    const retry = item ? registry.effects.get(item.effect.type)?.retry : undefined;
+    const notice = (type) => ({
+        type,
+        runId,
+        at: now,
+        effectId: callback.effectId,
+        attempt: callback.attempt,
+    });
+    switch (callback.kind) {
+        case 'started': {
+            return Effect.succeed(item && execution.status === 'dispatched'
+                ? { events: [workerStartedEvent(runId, item, callback.attempt, retry, now)], notices: [] }
+                : IGNORED);
+        }
+        case 'heartbeat': {
+            const implicitStart = execution.status === 'dispatched';
+            if (!item ||
+                (!implicitStart && execution.status !== 'started' && execution.status !== 'heartbeat')) {
+                return Effect.succeed(IGNORED);
+            }
+            return Effect.succeed({
+                events: [
+                    ...(implicitStart ? [workerStartedEvent(runId, item, callback.attempt, retry, now)] : []),
+                    createEvent(runId, {
+                        type: 'runtime.effect.heartbeat',
+                        payload: {
+                            effectId: item.effectId,
+                            attempt: callback.attempt,
+                            heartbeatAt: now,
+                            deadlineAt: workerDeadline(retry, execution.startedAt ?? now, now),
+                        },
+                        threadId: item.threadId,
+                        origin: WORKER_ORIGIN,
+                    }),
+                ],
+                notices: [notice('effect.heartbeat')],
+            });
+        }
+        case 'complete': {
+            if (!item) {
+                return Effect.succeed(IGNORED);
+            }
+            return Effect.forEach(callback.events, (event) => materializeEffectOutcome(registry.catalogs, runId, item, event)).pipe(Effect.map((outcomes) => ({
+                events: [
+                    ...outcomes,
+                    createEvent(runId, {
+                        type: 'runtime.effect.completed',
+                        payload: { effectId: item.effectId, attempt: callback.attempt },
+                        threadId: item.threadId,
+                        effectId: item.effectId,
+                        causationId: item.causingEventId,
+                        origin: WORKER_ORIGIN,
+                    }),
+                ],
+                notices: [],
+            })));
+        }
+        case 'fail': {
+            if (!item) {
+                return Effect.succeed(IGNORED);
+            }
+            const failure = planAttemptFailure({
+                runId,
+                item,
+                attempt: callback.attempt,
+                error: callback.error,
+                now,
+                retry,
+                origin: WORKER_ORIGIN,
+            });
+            return Effect.succeed({
+                events: [failure.event],
+                notices: failure.retrying
+                    ? [
+                        {
+                            type: 'effect.retry',
+                            runId,
+                            at: now,
+                            effectId: item.effectId,
+                            attempt: callback.attempt,
+                            detail: callback.error,
+                        },
+                    ]
+                    : [],
+            });
+        }
+        case 'cancelled': {
+            return Effect.succeed({
+                events: [
+                    createEvent(runId, {
+                        type: 'runtime.effect.cancelled',
+                        payload: { effectId: callback.effectId, attempt: callback.attempt },
+                        threadId: item?.threadId ?? null,
+                        effectId: callback.effectId,
+                        origin: WORKER_ORIGIN,
+                    }),
+                ],
+                notices: [notice('effect.cancellation')],
+            });
+        }
+        default: {
+            const exhaustiveCheck = callback;
+            return exhaustiveCheck;
+        }
+    }
+}
+export function createWorkerCallbacks(options) {
+    const { registry, repository, withRunIngress } = options;
+    const applyWorkerCallback = (runId, callback) => withRunIngress(runId, Effect.gen(function* () {
+        const store = yield* EventStoreTag;
+        const now = yield* Clock.currentTimeMillis;
+        const committed = yield* repository.commit(store, runId, (cursor) => planWorkerCallback({ runId, state: cursor.state, callback, registry, now }).pipe(Effect.map((plan) => ({ events: plan.events, value: plan.notices }))));
+        if (committed.append) {
+            for (const notice of committed.value) {
+                notifyObserver(options.observer, notice);
+            }
+        }
+        return committed.cursor.state;
+    })).pipe(Effect.andThen(options.wake(runId)));
+    return { workerCallback: applyWorkerCallback };
+}

package/dist/runtime/worker-effect-dispatch.d.ts

@@ -0,0 +1,36 @@
+import { Effect } from 'effect';
+import { type ComposedRegistry, type EffectExecutionRecord, type EventEnvelope, type OutstandingEffect, type RunState } from '@swirls/looms/core';
+import type { EffectWorker, EffectWorkerTask } from './types';
+export interface WorkerEffectDispatchPlan {
+    readonly item: OutstandingEffect;
+    readonly attempt: number;
+    readonly queuedEvent?: EventEnvelope;
+    readonly task: EffectWorkerTask;
+    readonly scheduleToStartDeadlineAt: number | null;
+}
+/**
+ * Decides where an outstanding effect runs. An attempt already in flight keeps
+ * its durable placement. Otherwise an explicit `execution` wins, then a worker
+ * claim; effects with a local handler run in process and handler-less effects
+ * go to the worker.
+ */
+export declare function isWorkerEffect(input: {
+    readonly runId: string;
+    readonly item: OutstandingEffect;
+    readonly execution: EffectExecutionRecord | undefined;
+    readonly registry: ComposedRegistry;
+    readonly worker?: EffectWorker;
+}): boolean;
+export declare function planWorkerEffects(input: {
+    readonly runId: string;
+    readonly state: RunState;
+    readonly registry: ComposedRegistry;
+    readonly worker?: EffectWorker;
+    readonly now: number;
+}): ReadonlyArray<WorkerEffectDispatchPlan>;
+/**
+ * Hand a planned attempt to the worker. A rejected dispatch may still have reached the worker, so
+ * with a schedule-to-start deadline it is recorded as dispatched and recovered by that timeout;
+ * without one it is parked as ambiguous for an operator.
+ */
+export declare function dispatchWorkerEffect(runId: string, plan: WorkerEffectDispatchPlan, worker: EffectWorker | undefined): Effect.Effect<EventEnvelope>;