@swirls/looms 0.0.2 → 0.2.0

package/dist/react/store.js

@@ -1,10 +1,16 @@
-import { Predicate } from 'effect';
-import { decodeLoomsEvent, } from '@swirls/looms/core';
+import { Data, Effect, Fiber, Option, Predicate, Schema } from 'effect';
+import { decodeLoomsEvent, stringifyJson, } from '@swirls/looms/core';
 import { EventIndex, ProjectionCache } from './derived.js';
 import { materializeEvents } from './materialize.js';
 import { createNotifyScheduler } from './notify.js';
-import { consumeSseStream, delay, eventsFromSseData } from './sse.js';
+import { consumeSseStreamEffect, eventsFromSseData } from './sse.js';
 import { emptyTables } from './tables.js';
+class LoomsStoreError extends Data.TaggedError('LoomsStoreError') {
+    constructor(message, cause) {
+        super({ cause, message });
+        this.name = 'LoomsStoreError';
+    }
+}
 function eventSourceCtor() {
     if (typeof EventSource === 'undefined') {
         return undefined;
@@ -36,13 +42,12 @@ export function createLoomsStore(options) {
     let liveStarted = false;
     let liveAbort;
     let eventSource;
-    let reconnectTimer;
+    let reconnectFiber;
     let syncing = null;
     const publishedEvents = () => {
         if (!eventsSnapshotDirty) {
             return eventsSnapshot;
         }
-        // SAFETY: events array only contains TEvent values pushed from applyBatch.
         eventsSnapshot = Object.freeze(events.slice());
         eventsSnapshotDirty = false;
         return eventsSnapshot;
@@ -68,7 +73,6 @@ export function createLoomsStore(options) {
                 continue;
             }
             seenIds.add(event.id);
-            // SAFETY: wire events match the app-registered TEvent catalog at the type boundary.
             fresh.push(event);
             fromSeq = Math.max(fromSeq, event.seq + 1);
         }
@@ -88,85 +92,67 @@ export function createLoomsStore(options) {
         applyBatch(eventsFromSseData(data, options.storeId));
     };
     const liveUrl = () => {
-        const cursor = Math.max(0, fromSeq - 1);
-        return `${endpoint}/api/events?runId=${encodeURIComponent(options.storeId)}&live=true&cursor=${cursor}`;
+        return `${endpoint}/runs/${encodeURIComponent(options.storeId)}/events?live=true&fromSeq=${fromSeq}`;
     };
-    const pull = async () => {
-        try {
-            const cursor = Math.max(0, fromSeq - 1);
-            const url = `${endpoint}/api/events?runId=${encodeURIComponent(options.storeId)}&cursor=${cursor}`;
-            const res = await fetchFn(url);
-            if (!res.ok) {
-                if (res.status === 404 || res.status === 416) {
-                    return;
-                }
-                const text = await res.text();
-                if (text.includes('out of range') || text.includes('Range not satisfiable')) {
-                    return;
-                }
-                throw new Error(`event pull failed: ${res.status}`);
-            }
-            const body = await res.json();
-            if (!Predicate.isReadonlyObject(body)) {
-                return;
+    const pull = Effect.gen(function* () {
+        const url = `${endpoint}/runs/${encodeURIComponent(options.storeId)}/events?fromSeq=${fromSeq}`;
+        const res = yield* Effect.tryPromise({
+            try: (signal) => fetchFn(url, { signal }),
+            catch: (cause) => new LoomsStoreError('Event pull failed', cause),
+        });
+        if (!res.ok) {
+            if (res.status === 404 || res.status === 416) {
+                return undefined;
             }
-            const batch = 'batch' in body && Array.isArray(body.batch) ? body.batch : [];
-            applyBatch(batch.map((raw) => decodeLoomsEvent(
-            // SAFETY: host pull batch items are encoded Looms event envelopes.
-            raw, options.storeId)));
-            const head = 'head' in body && Predicate.isNumber(body.head) ? body.head : undefined;
-            if (head !== undefined) {
-                fromSeq = Math.max(fromSeq, head + 1);
+            const text = yield* Effect.promise(() => res.text());
+            if (text.includes('out of range') || text.includes('Range not satisfiable')) {
+                return undefined;
             }
+            return yield* new LoomsStoreError(`Event pull failed: ${res.status}`);
         }
-        catch (err) {
-            if (disposed) {
-                return;
-            }
-            // When offline or host is restarting, suppress connection refused/fetch errors during sync
-            if (err instanceof Error &&
-                (err.message.includes('fetch failed') ||
-                    err.message.includes('ConnectionRefused') ||
-                    err.message.includes('Unable to connect'))) {
-                return;
-            }
-            throw err;
+        const rawBody = yield* Effect.promise(() => res.json());
+        const decodedBody = Schema.decodeUnknownOption(Schema.Json)(rawBody);
+        if (Option.isNone(decodedBody) || !Predicate.isReadonlyObject(decodedBody.value)) {
+            return undefined;
         }
-    };
-    const sync = async () => {
+        const body = decodedBody.value;
+        const pulledEvents = 'events' in body && Array.isArray(body.events) ? body.events : [];
+        applyBatch(pulledEvents.map((raw) => decodeLoomsEvent(raw, options.storeId)));
+        return undefined;
+    }).pipe(Effect.catchIf((error) => disposed ||
+        error.message.includes('fetch failed') ||
+        error.message.includes('ConnectionRefused') ||
+        error.message.includes('Unable to connect'), () => Effect.void));
+    const sync = () => {
         if (disposed) {
-            return;
+            return Promise.resolve();
         }
         if (syncing) {
             return syncing;
         }
-        syncing = (async () => {
-            try {
-                await pull();
-            }
-            finally {
-                syncing = null;
-            }
-        })();
+        syncing = Effect.runPromise(pull).finally(() => {
+            syncing = null;
+        });
         return syncing;
     };
     const scheduleReconnect = (Ctor) => {
-        if (disposed || !liveStarted || reconnectTimer !== undefined) {
+        if (disposed || !liveStarted || reconnectFiber !== undefined) {
             return;
         }
-        reconnectTimer = setTimeout(() => {
-            reconnectTimer = undefined;
+        reconnectFiber = Effect.runFork(Effect.gen(function* () {
+            yield* Effect.sleep(reconnectDelayMs);
+            reconnectFiber = undefined;
             if (disposed || !liveStarted) {
                 return;
             }
-            void sync()
-                .catch(() => { })
-                .finally(() => {
-                if (!disposed && liveStarted) {
-                    startEventSource(Ctor);
-                }
-            });
-        }, reconnectDelayMs);
+            yield* Effect.tryPromise({
+                try: sync,
+                catch: (cause) => new LoomsStoreError('Event resync failed', cause),
+            }).pipe(Effect.ignore);
+            if (!disposed && liveStarted) {
+                startEventSource(Ctor);
+            }
+        }));
     };
     const startEventSource = (Ctor) => {
         if (disposed || !liveStarted) {
@@ -199,45 +185,46 @@ export function createLoomsStore(options) {
             }
         });
     };
-    const startFetchStream = async () => {
-        while (true) {
-            if (disposed) {
-                break;
-            }
-            const controller = new AbortController();
-            liveAbort = controller;
-            try {
-                const headers = new Headers({ accept: 'text/event-stream' });
-                const cursor = Math.max(0, fromSeq - 1);
-                if (cursor > 0) {
-                    headers.set('last-event-id', String(cursor));
-                }
-                const res = await fetchFn(liveUrl(), { headers, signal: controller.signal });
-                if (!res.ok) {
-                    throw new Error(`event stream failed: ${res.status}`);
-                }
-                if (!res.body) {
-                    throw new Error('event stream missing body');
-                }
-                live = true;
-                setStatus('live');
-                await consumeSseStream(res.body, (frame) => {
-                    applyEncoded(frame.data);
-                }, controller.signal);
-            }
-            catch {
-                live = false;
+    const startFetchStream = () => {
+        const controller = new AbortController();
+        liveAbort = controller;
+        const run = Effect.gen(function* () {
+            while (true) {
                 if (disposed) {
                     return;
                 }
-                setStatus('reconnecting');
-            }
-            live = false;
-            if (disposed) {
-                return;
+                yield* Effect.gen(function* () {
+                    const headers = new Headers({ accept: 'text/event-stream' });
+                    const cursor = Math.max(0, fromSeq - 1);
+                    if (cursor > 0) {
+                        headers.set('last-event-id', String(cursor));
+                    }
+                    const res = yield* Effect.tryPromise({
+                        try: (signal) => fetchFn(liveUrl(), { headers, signal }),
+                        catch: (cause) => new LoomsStoreError('Event stream failed', cause),
+                    });
+                    const body = res.body;
+                    if (!res.ok || !body) {
+                        return yield* new LoomsStoreError(res.ok ? 'Event stream missing body' : `Event stream failed: ${res.status}`);
+                    }
+                    live = true;
+                    setStatus('live');
+                    return yield* consumeSseStreamEffect(body, (frame) => {
+                        applyEncoded(frame.data);
+                    });
+                }).pipe(Effect.catch(() => Effect.sync(() => {
+                    live = false;
+                    if (!disposed) {
+                        setStatus('reconnecting');
+                    }
+                })));
+                live = false;
+                if (!disposed) {
+                    yield* Effect.sleep(reconnectDelayMs);
+                }
             }
-            await delay(reconnectDelayMs, controller.signal);
-        }
+        });
+        void Effect.runPromise(run, { signal: controller.signal }).catch(() => undefined);
     };
     const startLive = () => {
         if (!options.storeId || (liveStarted && !disposed)) {
@@ -250,15 +237,15 @@ export function createLoomsStore(options) {
             startEventSource(ctor);
         }
         else {
-            void startFetchStream();
+            startFetchStream();
         }
     };
     const stopLive = () => {
         liveStarted = false;
         live = false;
-        if (reconnectTimer !== undefined) {
-            clearTimeout(reconnectTimer);
-            reconnectTimer = undefined;
+        if (reconnectFiber !== undefined) {
+            Effect.runFork(Fiber.interrupt(reconnectFiber));
+            reconnectFiber = undefined;
         }
         eventSource?.close();
         eventSource = undefined;
@@ -307,26 +294,29 @@ export function createLoomsStore(options) {
         project: (definition) => projectionCache.project(definition, publishedEvents()),
         fold: (definition) => projectionCache.fold(definition, publishedEvents()),
         flush: notify.flush,
-        sync: async () => {
-            const res = await sync();
+        sync: () => sync().then(() => {
             notify.flush();
-            return res;
-        },
-        commit: async (event) => {
-            const res = await fetchFn(`${endpoint}/runs/${encodeURIComponent(options.storeId)}/events`, {
-                method: 'POST',
-                headers: { 'content-type': 'application/json' },
-                body: JSON.stringify(event),
+        }),
+        commit: (event) => Effect.runPromise(Effect.gen(function* () {
+            const res = yield* Effect.tryPromise({
+                try: (signal) => fetchFn(`${endpoint}/runs/${encodeURIComponent(options.storeId)}/events`, {
+                    method: 'POST',
+                    headers: { 'content-type': 'application/json' },
+                    body: stringifyJson(Array.isArray(event) ? { events: event } : event),
+                    signal,
+                }),
+                catch: (cause) => new LoomsStoreError('Run signal failed', cause),
             });
             if (!res.ok) {
-                const text = await res.text();
-                throw new Error(`run signal failed: ${res.status} ${text}`);
+                const text = yield* Effect.promise(() => res.text());
+                return yield* new LoomsStoreError(`Run signal failed: ${res.status} ${text}`);
             }
             if (!live) {
-                await sync();
+                yield* Effect.promise(sync);
             }
             notify.flush();
-        },
+            return undefined;
+        })),
         dispose: () => {
             disposed = true;
             notify.cancel();

package/dist/runtime/cancellation.d.ts

@@ -0,0 +1,16 @@
+import { type ComposedRegistry } from '@swirls/looms/core';
+import type { RunIngress } from './ingress';
+import { type RuntimeObserver } from './observer';
+import type { RuntimeRepository } from './repository';
+import type { RunExecutionContexts } from './run-execution-context';
+import type { EffectWorker, LoomsRuntime } from './types';
+export interface CancellationOptions {
+    readonly registry: ComposedRegistry;
+    readonly repository: RuntimeRepository;
+    readonly executionContexts: RunExecutionContexts;
+    readonly worker?: EffectWorker;
+    readonly observer?: RuntimeObserver;
+    readonly wake: LoomsRuntime['wake'];
+    readonly withRunIngress: RunIngress;
+}
+export declare function createCancellation(options: CancellationOptions): LoomsRuntime['cancel'];

package/dist/runtime/cancellation.js

@@ -0,0 +1,129 @@
+import { Clock, Effect } from 'effect';
+import { createEvent, EventStoreTag, foldRun, } from '@swirls/looms/core';
+import { RuntimeExecutionError } from './errors.js';
+import { waitSatisfiedEvents, workerTask } from './helpers.js';
+import { notifyObserver } from './observer.js';
+import { isWorkerEffect } from './worker-effect-dispatch.js';
+function descendantThreadIds(state, targetThreadId) {
+    return Object.values(state.threads)
+        .filter((record) => {
+        let parentThreadId = record.parentThreadId;
+        while (parentThreadId) {
+            if (parentThreadId === targetThreadId) {
+                return true;
+            }
+            parentThreadId = state.threads[parentThreadId]?.parentThreadId ?? null;
+        }
+        return false;
+    })
+        .map((record) => record.threadId);
+}
+/**
+ * Cancel a thread and its descendants. Worker attempts in flight are asked to stop and must
+ * acknowledge; attempts waiting to retry were never handed out and are cancelled outright.
+ */
+function planCancellation(input) {
+    const { runId, state, registry, now } = input;
+    const targetThreadId = input.threadId ?? state.rootThreadId ?? '';
+    const idempotencyKey = `cancel:${targetThreadId}`;
+    if (state.processedIdempotencyKeys.includes(idempotencyKey)) {
+        return { events: [], threadIds: new Set(), workerCancellations: [] };
+    }
+    const descendants = descendantThreadIds(state, targetThreadId);
+    const threadIds = new Set([...descendants, targetThreadId]);
+    const workerCancellations = [];
+    const effectEvents = [];
+    for (const item of state.outstandingEffects) {
+        const execution = state.effectExecutions[item.effectId];
+        if (!execution ||
+            !threadIds.has(item.threadId) ||
+            !isWorkerEffect({ runId, item, execution, registry, worker: input.worker })) {
+            continue;
+        }
+        if (execution.status === 'retry_wait') {
+            effectEvents.push(createEvent(runId, {
+                type: 'runtime.effect.cancelled',
+                payload: { effectId: item.effectId, attempt: execution.attempt },
+                threadId: item.threadId,
+                effectId: item.effectId,
+                origin: { type: 'system' },
+                idempotencyKey,
+            }));
+            continue;
+        }
+        const timeoutMs = registry.effects.get(item.effect.type)?.retry?.cancellationTimeoutMs;
+        workerCancellations.push({ item, execution });
+        effectEvents.push(createEvent(runId, {
+            type: 'runtime.effect.cancel.requested',
+            payload: {
+                effectId: item.effectId,
+                attempt: execution.attempt,
+                deadlineAt: timeoutMs ? now + timeoutMs : null,
+            },
+            threadId: item.threadId,
+            origin: { type: 'system' },
+            idempotencyKey,
+        }));
+    }
+    const threadEvents = [
+        ...descendants.map((_, index) => descendants[descendants.length - 1 - index]),
+        targetThreadId,
+    ]
+        .filter((threadId) => threadId.length > 0)
+        .map((threadId) => createEvent(runId, {
+        type: 'runtime.thread.cancelled',
+        payload: { threadId, reason: 'cancelled' },
+        threadId,
+        origin: { type: 'external' },
+        idempotencyKey,
+    }));
+    const batch = [...effectEvents, ...threadEvents];
+    const folded = foldRun(batch, registry, { runId, initial: state });
+    const satisfied = waitSatisfiedEvents(folded, batch).map((event) => createEvent(runId, event));
+    return { events: [...batch, ...satisfied], threadIds, workerCancellations };
+}
+export function createCancellation(options) {
+    const { registry, repository, executionContexts, worker } = options;
+    return (runId, threadId) => Effect.gen(function* () {
+        const committed = yield* options.withRunIngress(runId, Effect.gen(function* () {
+            const store = yield* EventStoreTag;
+            const now = yield* Clock.currentTimeMillis;
+            return yield* repository.commit(store, runId, (current) => {
+                const plan = planCancellation({
+                    runId,
+                    state: current.state,
+                    threadId,
+                    registry,
+                    worker,
+                    now,
+                });
+                return Effect.succeed({
+                    events: plan.events,
+                    value: { plan, now },
+                    idempotencyKey: `signal:cancel:${threadId ?? current.state.rootThreadId ?? ''}`,
+                });
+            });
+        }));
+        const { plan, now } = committed.value;
+        if (committed.append) {
+            executionContexts.abort(runId, plan.threadIds, 'Effect cancelled');
+            for (const { item, execution } of plan.workerCancellations) {
+                notifyObserver(options.observer, {
+                    type: 'effect.cancellation',
+                    runId,
+                    at: now,
+                    effectId: item.effectId,
+                    attempt: execution.attempt,
+                });
+            }
+        }
+        const cancelledState = yield* options.wake(runId);
+        if (worker?.cancel && committed.append) {
+            yield* Effect.forEach(plan.workerCancellations, ({ item, execution }) => Effect.tryPromise({
+                try: () => Promise.resolve(worker.cancel?.(workerTask(runId, item, execution.attempt))),
+                catch: (cause) => new RuntimeExecutionError(cause instanceof Error ? cause.message : String(cause)),
+            }).pipe(Effect.ignore), { concurrency: 'unbounded', discard: true });
+        }
+        return cancelledState;
+    });
+}

package/dist/runtime/deadline-transition-planner.d.ts

@@ -0,0 +1,31 @@
+import { type ComposedRegistry, type EventEnvelope, type RunState } from '@swirls/looms/core';
+export interface TimerLateNotice {
+    readonly timerId: string;
+    readonly latenessMs: number;
+}
+export interface EffectTimeoutNotice {
+    readonly effectId: string;
+    readonly attempt: number;
+    readonly timeout: 'schedule-to-start' | 'heartbeat' | 'start-to-close';
+}
+export interface DeadlineTransitionPlan {
+    readonly events: ReadonlyArray<EventEnvelope>;
+    readonly timerNotices: ReadonlyArray<TimerLateNotice>;
+    readonly timeoutNotices: ReadonlyArray<EffectTimeoutNotice>;
+}
+export declare function planDeadlineTransitions(input: {
+    readonly runId: string;
+    readonly state: RunState;
+    readonly registry: ComposedRegistry;
+    readonly now: number;
+}): DeadlineTransitionPlan;
+export declare function planTerminalCancellationTransitions(input: {
+    readonly runId: string;
+    readonly state: RunState;
+    readonly now: number;
+}): ReadonlyArray<EventEnvelope>;
+/**
+ * The earliest deadline after `after` that needs a wake. A terminal run only waits on
+ * unacknowledged worker cancellations; its leftover timers can never fire anything.
+ */
+export declare function nextRuntimeDeadline(state: RunState, after?: number): number | undefined;

package/dist/runtime/deadline-transition-planner.js

@@ -0,0 +1,139 @@
+import { createEvent, foldRun, isRunTerminal, isWaitOnTimer, } from '@swirls/looms/core';
+import { waitSatisfiedEvents } from './helpers.js';
+import { planAttemptFailure } from './retry-policy.js';
+const EMPTY_PLAN = {
+    events: [],
+    timerNotices: [],
+    timeoutNotices: [],
+};
+export function planDeadlineTransitions(input) {
+    const timerPlan = planDueTimers(input);
+    if (timerPlan.events.length > 0) {
+        return timerPlan;
+    }
+    return planExpiredExecutions(input);
+}
+function planDueTimers(input) {
+    const due = Object.values(input.state.waits).filter((record) => isWaitOnTimer(record.on) && record.on.timerAt <= input.now + 5);
+    if (due.length === 0) {
+        return EMPTY_PLAN;
+    }
+    const fired = due.flatMap((record) => isWaitOnTimer(record.on)
+        ? [
+            createEvent(input.runId, {
+                type: 'runtime.timer.fired',
+                payload: { timerId: record.waitId, waitId: record.waitId },
+                threadId: record.threadId,
+                origin: { type: 'system' },
+            }),
+        ]
+        : []);
+    const stateAfterFired = foldRun(fired, input.registry, {
+        runId: input.runId,
+        initial: input.state,
+    });
+    const satisfied = waitSatisfiedEvents(stateAfterFired, fired).map((event) => createEvent(input.runId, event));
+    return {
+        events: [...fired, ...satisfied],
+        timerNotices: due.flatMap((record) => isWaitOnTimer(record.on)
+            ? [{ timerId: record.waitId, latenessMs: Math.max(0, input.now - record.on.timerAt) }]
+            : []),
+        timeoutNotices: [],
+    };
+}
+function planExpiredExecutions(input) {
+    const expired = Object.values(input.state.effectExecutions).filter((execution) => (execution.status === 'dispatched' ||
+        execution.status === 'started' ||
+        execution.status === 'heartbeat' ||
+        execution.status === 'cancel_requested') &&
+        execution.deadlineAt !== null &&
+        execution.deadlineAt <= input.now);
+    if (expired.length === 0) {
+        return EMPTY_PLAN;
+    }
+    const events = [];
+    const timeoutNotices = [];
+    for (const execution of expired) {
+        const item = input.state.outstandingEffects.find((candidate) => candidate.effectId === execution.effectId);
+        if (!item) {
+            if (execution.status === 'cancel_requested') {
+                events.push(cancellationAmbiguous(input.runId, execution.effectId, execution.attempt));
+            }
+            continue;
+        }
+        const retry = input.registry.effects.get(item.effect.type)?.retry;
+        const timeout = timeoutKind(execution, retry, input.now);
+        timeoutNotices.push({
+            effectId: item.effectId,
+            attempt: execution.attempt,
+            timeout,
+        });
+        events.push(createEvent(input.runId, {
+            type: 'runtime.effect.timed_out',
+            payload: { effectId: item.effectId, attempt: execution.attempt, timeout },
+            threadId: item.threadId,
+            causationId: item.causingEventId,
+            origin: { type: 'system' },
+        }));
+        events.push(planAttemptFailure({
+            runId: input.runId,
+            item,
+            attempt: execution.attempt,
+            error: `${timeout} timeout`,
+            now: input.now,
+            retry,
+            origin: { type: 'system' },
+        }).event);
+    }
+    return { events, timerNotices: [], timeoutNotices };
+}
+function timeoutKind(execution, retry, now) {
+    if (execution.status === 'dispatched') {
+        return 'schedule-to-start';
+    }
+    const startToCloseAt = execution.startedAt !== null && retry?.startToCloseTimeoutMs
+        ? execution.startedAt + retry.startToCloseTimeoutMs
+        : null;
+    return execution.lastHeartbeatAt !== null && (startToCloseAt === null || startToCloseAt > now)
+        ? 'heartbeat'
+        : 'start-to-close';
+}
+export function planTerminalCancellationTransitions(input) {
+    if (!isRunTerminal(input.state)) {
+        return [];
+    }
+    return Object.values(input.state.effectExecutions)
+        .filter((execution) => execution.status === 'cancel_requested' &&
+        execution.deadlineAt !== null &&
+        execution.deadlineAt <= input.now)
+        .map((execution) => cancellationAmbiguous(input.runId, execution.effectId, execution.attempt));
+}
+/**
+ * The earliest deadline after `after` that needs a wake. A terminal run only waits on
+ * unacknowledged worker cancellations; its leftover timers can never fire anything.
+ */
+export function nextRuntimeDeadline(state, after = Number.NEGATIVE_INFINITY) {
+    const terminal = isRunTerminal(state);
+    const timers = terminal
+        ? []
+        : Object.values(state.waits).flatMap((record) => isWaitOnTimer(record.on) && record.on.timerAt > after ? [record.on.timerAt] : []);
+    const executions = Object.values(state.effectExecutions).flatMap((execution) => (!terminal || execution.status === 'cancel_requested') &&
+        execution.deadlineAt !== null &&
+        execution.deadlineAt > after
+        ? [execution.deadlineAt]
+        : []);
+    const deadlines = [...timers, ...executions];
+    return deadlines.length > 0 ? Math.min(...deadlines) : undefined;
+}
+function cancellationAmbiguous(runId, effectId, attempt) {
+    return createEvent(runId, {
+        type: 'runtime.effect.ambiguous',
+        payload: {
+            effectId,
+            attempt,
+            error: 'worker did not acknowledge cancellation',
+        },
+        threadId: null,
+        origin: { type: 'system' },
+    });
+}

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

@@ -1,3 +1,4 @@
-import { Effect, type Layer } from 'effect';
+import type { Context, ManagedRuntime } from 'effect';
+import { Effect } from 'effect';
 import { type ComposedRegistry, type EffectContext, type EventInput, type RegisteredDefinition, type RuntimeEffect } from '@swirls/looms/core';
-export declare function dispatchEffect(registry: ComposedRegistry, services: Layer.Layer<any>, definitions: ReadonlyMap<string, RegisteredDefinition>, effect: RuntimeEffect, ctx: EffectContext): Effect.Effect<ReadonlyArray<EventInput>, Error>;
+export declare function dispatchEffect(registry: ComposedRegistry, services: ManagedRuntime.ManagedRuntime<Context.Service.Any, never>, definitions: ReadonlyMap<string, RegisteredDefinition>, effect: RuntimeEffect, ctx: EffectContext): Effect.Effect<ReadonlyArray<EventInput>, Error>;