@swirls/looms 0.0.1

package/dist/runtime/dispatch-effect.js

@@ -0,0 +1,113 @@
+import { Effect, Schedule } from 'effect';
+import { asJson, isPrimitiveEffect, isWaitOnTimer, } from '@swirls/looms/core';
+import { threadStartedEvents } from './runtime-helpers.js';
+export function dispatchEffect(registry, services, definitions, effect, ctx) {
+    const currentThreadId = ctx.threadId;
+    const baseDispatch = (eff, effCtx) => {
+        if (isPrimitiveEffect(eff)) {
+            switch (eff.type) {
+                case 'runtime.spawn': {
+                    const childThreadId = eff.childThreadId ?? '';
+                    return threadStartedEvents(definitions, {
+                        kind: eff.kind,
+                        definitionName: eff.definitionName,
+                        input: eff.input,
+                        threadId: childThreadId,
+                        parentThreadId: currentThreadId,
+                    });
+                }
+                case 'runtime.wait': {
+                    const events = [
+                        {
+                            type: 'runtime.wait.registered',
+                            payload: asJson({
+                                waitId: eff.waitId,
+                                threadId: currentThreadId,
+                                on: eff.on,
+                                tag: eff.tag ?? null,
+                            }),
+                            threadId: currentThreadId,
+                        },
+                    ];
+                    if (isWaitOnTimer(eff.on)) {
+                        events.push({
+                            type: 'runtime.timer.set',
+                            payload: { timerId: eff.waitId, waitId: eff.waitId, wakeAt: eff.on.timerAt },
+                            threadId: currentThreadId,
+                        });
+                    }
+                    return Effect.succeed(events);
+                }
+                case 'runtime.emit':
+                    return Effect.succeed([eff.event]);
+                case 'runtime.complete':
+                    return Effect.succeed([
+                        {
+                            type: 'runtime.thread.completed',
+                            payload: { threadId: currentThreadId, output: eff.output },
+                            threadId: currentThreadId,
+                        },
+                    ]);
+                case 'runtime.fail':
+                    return Effect.succeed([
+                        {
+                            type: 'runtime.thread.failed',
+                            payload: { threadId: currentThreadId, error: eff.error },
+                            threadId: currentThreadId,
+                        },
+                    ]);
+                case 'runtime.cancel': {
+                    const targetThreadId = eff.threadId ?? '';
+                    return Effect.succeed([
+                        {
+                            type: 'runtime.thread.cancelled',
+                            payload: { threadId: targetThreadId, reason: 'cancelled' },
+                            threadId: targetThreadId,
+                        },
+                    ]);
+                }
+                default: {
+                    const exhaustiveCheck = eff;
+                    return exhaustiveCheck;
+                }
+            }
+        }
+        const handler = registry.effects.get(eff.type);
+        if (!handler) {
+            return Effect.succeed([
+                {
+                    type: 'runtime.effect.failed',
+                    payload: { effectId: effCtx.effectId, error: `No handler for ${eff.type}` },
+                    threadId: currentThreadId,
+                },
+            ]);
+        }
+        const input = 'input' in eff ? eff.input : {};
+        let execution = handler
+            .execute(input, effCtx)
+            .pipe(Effect.provide(services));
+        if (handler.retry && handler.retry.maxAttempts > 1) {
+            const retryPolicy = handler.retry;
+            const backoff = retryPolicy.backoffMs ?? 100;
+            execution = execution.pipe(Effect.retry({
+                times: retryPolicy.maxAttempts - 1,
+                schedule: Schedule.spaced(backoff),
+            }));
+        }
+        return execution.pipe(Effect.catch((err) => Effect.succeed([
+            {
+                type: 'runtime.effect.failed',
+                payload: {
+                    effectId: effCtx.effectId,
+                    error: err instanceof Error ? err.message : String(err),
+                },
+                threadId: currentThreadId,
+            },
+        ])));
+    };
+    if (registry.middleware && registry.middleware.length > 0) {
+        const pipeline = registry.middleware.reduceRight((next, mw) => (e, c) => mw(e, c, next), baseDispatch);
+        return pipeline(effect, ctx);
+    }
+    return baseDispatch(effect, ctx);
+}

package/dist/runtime/events-api.d.ts

@@ -0,0 +1,4 @@
+import { encodeLoomsEvent, type EncodedLoomsEvent, type EventStore } from '@swirls/looms/core';
+import type { LoomsRuntime } from './runtime';
+export { encodeLoomsEvent, type EncodedLoomsEvent };
+export declare function handleEventsApi(req: Request, runtime: LoomsRuntime, store: EventStore): Promise<Response>;

package/dist/runtime/events-api.js

@@ -0,0 +1,84 @@
+import { Effect, Predicate } from 'effect';
+import { decodeAppendableEvent, encodeLoomsEvent, EventStoreConflictError, EventStoreTag, } from '@swirls/looms/core';
+import { createEventStreamResponse } from './sse.js';
+export { encodeLoomsEvent };
+function readCursor(req, url) {
+    const lastEventId = req.headers.get('last-event-id');
+    const raw = lastEventId !== null && lastEventId !== ''
+        ? lastEventId
+        : (url.searchParams.get('cursor') ?? '0');
+    const parsed = Number(raw);
+    return Number.isFinite(parsed) && parsed >= 0 ? parsed : 0;
+}
+function readRunId(url) {
+    return url.searchParams.get('runId');
+}
+export async function handleEventsApi(req, runtime, store) {
+    const url = new URL(req.url);
+    if (req.method === 'HEAD') {
+        return new Response(null, { status: 200 });
+    }
+    if (req.method === 'GET') {
+        const runId = readRunId(url);
+        if (!runId) {
+            return Response.json({ error: 'runId required' }, { status: 400 });
+        }
+        const cursor = readCursor(req, url);
+        const acceptHeader = req.headers.get('accept') ?? '';
+        const isLive = url.searchParams.get('live') === 'true' ||
+            url.searchParams.get('live') === '1' ||
+            acceptHeader.includes('text/event-stream');
+        if (!isLive) {
+            const events = await Effect.runPromise(store.read(runId, { fromSeq: cursor + 1 }));
+            const bounds = store.bounds
+                ? await Effect.runPromise(store.bounds(runId))
+                : { head: events[0]?.seq ?? 1, tail: await Effect.runPromise(store.tail(runId)) };
+            return Response.json({
+                batch: events.map(encodeLoomsEvent),
+                head: bounds.head,
+                tail: bounds.tail,
+            });
+        }
+        return createEventStreamResponse({
+            signal: req.signal,
+            request: req,
+            store,
+            runId,
+            fromSeq: cursor + 1,
+        });
+    }
+    if (req.method === 'POST') {
+        const body = await req.json();
+        const runId = readRunId(url) ??
+            (Predicate.isReadonlyObject(body) && Predicate.isString(body.runId) ? body.runId : null);
+        if (!runId) {
+            return Response.json({ error: 'runId required' }, { status: 400 });
+        }
+        const batch = Predicate.isReadonlyObject(body) && Array.isArray(body.batch) ? body.batch : [];
+        const expectedTail = Predicate.isReadonlyObject(body) && Predicate.isNumber(body.expectedTail)
+            ? body.expectedTail
+            : 0;
+        const tail = await Effect.runPromise(store.tail(runId));
+        if (expectedTail !== tail) {
+            return Response.json({ _tag: 'ServerAheadError', expected: expectedTail, actual: tail }, { status: 409 });
+        }
+        const appendable = batch
+            .map((item) => {
+            // SAFETY: push batch items are host-encoded envelopes.
+            return decodeAppendableEvent(item, runId);
+        })
+            .filter((item) => item !== undefined);
+        try {
+            await Effect.runPromise(store.append(runId, appendable, { expectedTail }));
+        }
+        catch (err) {
+            if (err instanceof EventStoreConflictError) {
+                return Response.json({ _tag: 'ServerAheadError', expected: err.expectedTail, actual: err.actualTail }, { status: 409 });
+            }
+            throw err;
+        }
+        await Effect.runPromise(Effect.provideService(runtime.wake(runId), EventStoreTag, store));
+        return Response.json({ ok: true });
+    }
+    return new Response('Method Not Allowed', { status: 405 });
+}

package/dist/runtime/index.d.ts

@@ -0,0 +1,5 @@
+export { createRuntime, createTimeoutScheduler, DuplicateEffectDispatchError, MaxWakeIterationsError, type CreateRuntimeOptions, type LoomsRuntime, type RegisteredDefinition, type StartRunArgs, type WakeError, type WakeScheduler, } from './runtime';
+export { createLooms, type Looms, type CreateLoomsOptions, type StartResult } from './looms';
+export { serveHttp, createFetchHandler, isLoomsApiPath, type FetchHandlerOptions, type RunningServer, type LoomsFetchResult, } from './server';
+export { handleEventsApi, encodeLoomsEvent, type EncodedLoomsEvent } from './events-api';
+export { createEventStreamResponse, type EventStreamOptions } from './sse';

package/dist/runtime/index.js

@@ -0,0 +1,5 @@
+export { createRuntime, createTimeoutScheduler, DuplicateEffectDispatchError, MaxWakeIterationsError, } from './runtime.js';
+export { createLooms } from './looms.js';
+export { serveHttp, createFetchHandler, isLoomsApiPath, } from './server.js';
+export { handleEventsApi, encodeLoomsEvent } from './events-api.js';
+export { createEventStreamResponse } from './sse.js';

package/dist/runtime/looms.d.ts

@@ -0,0 +1,74 @@
+import { type AnyRuntimeModule, type DefinitionInput, type DefinitionRef, type EventEnvelope, type EventInput, type EventStore, type JsonValue, type SnapshotStore, type ProjectionDefinition, type ReplayStep, type RunState } from '@swirls/looms/core';
+import { type LoomsRuntime, type WakeScheduler } from './runtime';
+import { type RunningServer } from './server';
+export interface CreateLoomsOptions {
+    /** Runtime modules to enable. Pass `agent()`, `workflow()`, `approval()`, and/or your own. */
+    readonly modules?: readonly AnyRuntimeModule[];
+    readonly store?: EventStore | Promise<EventStore> | (() => Promise<EventStore>);
+    readonly serve?: boolean | {
+        port?: number;
+        hostname?: string;
+    };
+    readonly maxWakeIterations?: number;
+    /** Durable events between mid-wake snapshots. Default 200; `0` disables. Parking always snapshots. */
+    readonly snapshotEvery?: number;
+    /** Defaults to the EventStore's attached store (S2) or an in-memory SnapshotStore. */
+    readonly snapshotStore?: SnapshotStore;
+    readonly trimAfterSnapshot?: {
+        keepSnapshots: number;
+    };
+    /** In-process cursor cache size. Default `0` (stateless between calls). */
+    readonly runCacheSize?: number;
+    /** Scan existing runs for pending timers on boot. Default true. */
+    readonly rescanTimers?: boolean;
+    /** Pluggable wake scheduler for timer waits. Defaults to an in-process setTimeout scheduler. */
+    readonly scheduler?: WakeScheduler;
+}
+export interface StartResult {
+    readonly runId: string;
+    readonly threadId: string;
+    readonly state: RunState;
+}
+export interface Looms {
+    readonly runtime: Promise<LoomsRuntime>;
+    readonly store: Promise<EventStore>;
+    ready(): Promise<{
+        store: EventStore;
+        runtime: LoomsRuntime;
+    }>;
+    /** Start a run from a definition object; the input type follows the definition's schema. */
+    start<TDef extends DefinitionRef>(definition: TDef, input?: DefinitionInput<TDef>, options?: {
+        runId?: string;
+        threadId?: string;
+        idempotencyKey?: string;
+    }): Promise<StartResult>;
+    /** Start a run by `{ kind, definitionName }` when you only have names (HTTP bodies, CLIs). */
+    startRun(args: {
+        kind: string;
+        definitionName: string;
+        input?: JsonValue;
+        runId?: string;
+        threadId?: string;
+        idempotencyKey?: string;
+    }): Promise<StartResult>;
+    getRun(runId: string): Promise<RunState>;
+    getEvents(runId: string, options?: {
+        fromSeq?: number;
+        limit?: number;
+    }): Promise<EventEnvelope[]>;
+    signal(runId: string, events: ReadonlyArray<EventInput>, options?: {
+        idempotencyKey?: string;
+    }): Promise<RunState>;
+    wake(runId: string): Promise<RunState>;
+    rescanTimers(): Promise<number>;
+    project<S>(runId: string, definition: ProjectionDefinition<S>): Promise<S>;
+    replayTo(runId: string, seq: number): Promise<ReplayStep | null>;
+    cancel(runId: string, threadId?: string): Promise<RunState>;
+    fetch(req: Request): Promise<Response | null>;
+    serve(options?: {
+        port?: number;
+        hostname?: string;
+    }): RunningServer;
+    stop(): Promise<void>;
+}
+export declare function createLooms(options?: CreateLoomsOptions): Looms;

package/dist/runtime/looms.js

@@ -0,0 +1,109 @@
+import { Effect, Predicate } from 'effect';
+import { EventStoreTag, makeMemoryEventStore, snapshotStoreOf, SnapshotStoreTag, } from '@swirls/looms/core';
+import { createRuntime } from './runtime.js';
+import { createFetchHandler, isLoomsApiPath, serveHttp } from './server.js';
+export function createLooms(options = {}) {
+    const modules = options.modules ?? [];
+    let initPromise;
+    let runningServer;
+    const getInit = () => {
+        if (!initPromise) {
+            initPromise = (async () => {
+                let store;
+                if (!options.store) {
+                    store = await Effect.runPromise(makeMemoryEventStore);
+                }
+                else if (Predicate.isFunction(options.store)) {
+                    store = await options.store();
+                }
+                else {
+                    store = await options.store;
+                }
+                const runtime = createRuntime({
+                    modules,
+                    store,
+                    maxWakeIterations: options.maxWakeIterations,
+                    snapshotEvery: options.snapshotEvery,
+                    snapshotStore: options.snapshotStore ?? snapshotStoreOf(store),
+                    trimAfterSnapshot: options.trimAfterSnapshot,
+                    runCacheSize: options.runCacheSize,
+                    scheduler: options.scheduler,
+                });
+                if (options.rescanTimers !== false) {
+                    await Effect.runPromise(Effect.provideService(runtime.rescanTimers(), EventStoreTag, store)).catch((err) => {
+                        console.error('[rescan timers error]', err);
+                    });
+                }
+                const fetchHandler = createFetchHandler({ runtime, store });
+                return { runtime, store, snapshotStore: snapshotStoreOf(store), fetchHandler };
+            })();
+        }
+        return initPromise;
+    };
+    const runEffect = async (fn) => {
+        const init = await getInit();
+        let provided = Effect.provideService(fn(init), EventStoreTag, init.store);
+        if (init.snapshotStore) {
+            provided = Effect.provideService(provided, SnapshotStoreTag, init.snapshotStore);
+        }
+        return Effect.runPromise(provided);
+    };
+    const looms = {
+        get runtime() {
+            return getInit().then((i) => i.runtime);
+        },
+        get store() {
+            return getInit().then((i) => i.store);
+        },
+        ready: async () => {
+            const init = await getInit();
+            return { store: init.store, runtime: init.runtime };
+        },
+        startRun: (args) => runEffect((i) => i.runtime.startRun(args)),
+        start: (definition, input, startOpts) => runEffect((i) => i.runtime.startRun({
+            kind: definition.kind,
+            definitionName: definition.name,
+            // SAFETY: input is validated against the definition's schema inside startRun.
+            input: input,
+            runId: startOpts?.runId,
+            threadId: startOpts?.threadId,
+            idempotencyKey: startOpts?.idempotencyKey,
+        })),
+        getRun: (runId) => runEffect((i) => i.runtime.getRun(runId)),
+        getEvents: (runId, opts) => runEffect((i) => i.runtime.getEvents(runId, opts)),
+        signal: (runId, events, signalOpts) => runEffect((i) => i.runtime.signal(runId, events, signalOpts)),
+        wake: (runId) => runEffect((i) => i.runtime.wake(runId)),
+        rescanTimers: () => runEffect((i) => i.runtime.rescanTimers()),
+        project: (runId, definition) => runEffect((i) => i.runtime.project(runId, definition)),
+        replayTo: (runId, seq) => runEffect((i) => i.runtime.replayTo(runId, seq)),
+        cancel: (runId, threadId) => runEffect((i) => i.runtime.cancel(runId, threadId)),
+        fetch: async (req) => {
+            if (!isLoomsApiPath(new URL(req.url).pathname)) {
+                return null;
+            }
+            const { fetchHandler } = await getInit();
+            return fetchHandler(req);
+        },
+        serve: (serveOpts) => {
+            if (runningServer) {
+                return runningServer;
+            }
+            runningServer = serveHttp((req) => looms.fetch(req), serveOpts);
+            return runningServer;
+        },
+        stop: async () => {
+            if (runningServer) {
+                runningServer.stop();
+                runningServer = undefined;
+            }
+            if (initPromise) {
+                const init = await initPromise;
+                init.runtime.dispose();
+            }
+        },
+    };
+    if (options.serve) {
+        looms.serve(options.serve === true ? {} : options.serve);
+    }
+    return looms;
+}

package/dist/runtime/runtime-helpers.d.ts

@@ -0,0 +1,51 @@
+import { Effect, Layer } from 'effect';
+import { type AnyRuntimeModule, type AppendableEvent, type EventCatalog, type EventEnvelope, type EventInput, type EventOrigin, type EventStore, type InvalidEventError, type JsonValue, type RegisteredDefinition, type RunCursor, type RunState, type SnapshotStore } from '@swirls/looms/core';
+export declare function resolveSnapshotStore(explicit: SnapshotStore | undefined, store: EventStore | undefined): SnapshotStore;
+export declare class RunCursorCache {
+    private readonly max;
+    private readonly map;
+    constructor(max: number);
+    get(runId: string): RunCursor | undefined;
+    set(runId: string, cursor: RunCursor): void;
+    delete(runId: string): void;
+}
+export declare function stripSeq(events: ReadonlyArray<EventEnvelope>): AppendableEvent[];
+export declare function moduleServices(modules: readonly AnyRuntimeModule[]): Layer.Layer<any>;
+export declare function groupOutstanding(items: readonly {
+    threadId: string;
+    causingSeq: number;
+}[]): string[];
+/**
+ * Every `runtime.thread.started` in the log goes through this helper so
+ * definition input is validated and Standard Schema defaults are applied.
+ * A future third producer of thread.started must call this; do not emit the
+ * event with raw input.
+ */
+export declare function threadStartedEvents(definitions: ReadonlyMap<string, RegisteredDefinition>, args: {
+    kind: string;
+    definitionName: string;
+    input: JsonValue;
+    threadId: string;
+    parentThreadId: string | null;
+}): Effect.Effect<ReadonlyArray<EventInput>, Error>;
+export declare function synthesizedThreadFailed(before: RunState, after: RunState, written: readonly EventEnvelope[]): EventInput[];
+export declare function waitSatisfiedEvents(state: RunState, events: readonly EventEnvelope[]): EventInput[];
+export declare function createEffectFailedEvent(runId: string, item: {
+    effectId: string;
+    causingEventId: string;
+    threadId: string;
+}, error: string): EventEnvelope;
+export declare function materializeEffectOutcome(catalogs: readonly EventCatalog[], runId: string, item: {
+    effectId: string;
+    causingEventId: string;
+    threadId: string;
+}, input: EventInput): Effect.Effect<EventEnvelope>;
+export declare function createLiveEvent(runId: string, item: {
+    effectId: string;
+    causingEventId: string;
+    threadId: string;
+}, validated: EventInput): AppendableEvent | undefined;
+export declare function validateAndCreateEvents(catalogs: readonly EventCatalog[], runId: string, events: readonly EventInput[], defaults: {
+    origin: EventOrigin;
+    threadId?: string | null;
+}): Effect.Effect<EventEnvelope[], InvalidEventError>;

package/dist/runtime/runtime-helpers.js

@@ -0,0 +1,230 @@
+import { Effect, Layer, Predicate } from 'effect';
+import { asJson, createEvent, makeMemorySnapshotStore, matchingWaits, snapshotStoreOf, validateEventInput, validateEventsEffect, validateInput, withSnapshotStore, } from '@swirls/looms/core';
+export function resolveSnapshotStore(explicit, store) {
+    if (explicit) {
+        if (store) {
+            withSnapshotStore(store, explicit);
+        }
+        return explicit;
+    }
+    const attached = store ? snapshotStoreOf(store) : undefined;
+    if (attached) {
+        return attached;
+    }
+    const memory = Effect.runSync(makeMemorySnapshotStore);
+    if (store) {
+        withSnapshotStore(store, memory);
+    }
+    return memory;
+}
+export class RunCursorCache {
+    max;
+    map = new Map();
+    constructor(max) {
+        this.max = max;
+    }
+    get(runId) {
+        const value = this.map.get(runId);
+        if (value) {
+            this.map.delete(runId);
+            this.map.set(runId, value);
+        }
+        return value;
+    }
+    set(runId, cursor) {
+        if (this.max <= 0) {
+            return;
+        }
+        this.map.delete(runId);
+        this.map.set(runId, cursor);
+        while (this.map.size > this.max) {
+            const oldest = this.map.keys().next().value;
+            if (oldest === undefined) {
+                break;
+            }
+            this.map.delete(oldest);
+        }
+    }
+    delete(runId) {
+        this.map.delete(runId);
+    }
+}
+export function stripSeq(events) {
+    return events.map(({ seq: _seq, ...rest }) => rest);
+}
+export function moduleServices(modules) {
+    // SAFETY: Empty layer serves as seed; module service layers are merged in.
+    let merged = Layer.empty;
+    for (const module of modules) {
+        if (module.services) {
+            merged = Layer.merge(merged, module.services());
+        }
+    }
+    return merged;
+}
+export function groupOutstanding(items) {
+    const keys = [];
+    const seen = new Set();
+    for (const item of items) {
+        const key = `${item.threadId}:${item.causingSeq}`;
+        if (seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        keys.push(key);
+    }
+    return keys;
+}
+/**
+ * Every `runtime.thread.started` in the log goes through this helper so
+ * definition input is validated and Standard Schema defaults are applied.
+ * A future third producer of thread.started must call this; do not emit the
+ * event with raw input.
+ */
+export function threadStartedEvents(definitions, args) {
+    return Effect.gen(function* () {
+        const def = definitions.get(`${args.kind}:${args.definitionName}`);
+        if (!def) {
+            return yield* Effect.fail(new Error(`Unknown definition ${args.kind}:${args.definitionName}`));
+        }
+        const raw = args.input ?? null;
+        let startedInput = raw;
+        let validationError;
+        if (def?.input) {
+            const validated = yield* Effect.tryPromise({
+                try: () => {
+                    // SAFETY: RegisteredDefinition.input is a Standard Schema when present.
+                    return validateInput(def.input, raw);
+                },
+                catch: (err) => (err instanceof Error ? err : new Error(String(err))),
+            }).pipe(Effect.map((value) => ({ ok: true, value })), Effect.catch((err) => Effect.succeed({ ok: false, error: err.message })));
+            if (validated.ok) {
+                startedInput = validated.value;
+            }
+            else {
+                validationError = validated.error;
+            }
+        }
+        const started = {
+            type: 'runtime.thread.started',
+            payload: {
+                threadId: args.threadId,
+                kind: args.kind,
+                definitionName: args.definitionName,
+                input: startedInput,
+                parentThreadId: args.parentThreadId,
+            },
+            threadId: args.threadId,
+            parentThreadId: args.parentThreadId,
+        };
+        if (!validationError) {
+            return [started];
+        }
+        return [
+            started,
+            {
+                type: 'runtime.thread.failed',
+                payload: { threadId: args.threadId, error: validationError },
+                threadId: args.threadId,
+            },
+        ];
+    });
+}
+export function synthesizedThreadFailed(before, after, written) {
+    const out = [];
+    for (const [threadId, thread] of Object.entries(after.threads)) {
+        if (thread.status !== 'failed') {
+            continue;
+        }
+        const prev = before.threads[threadId];
+        if (prev?.status === 'failed') {
+            continue;
+        }
+        const already = written.some((event) => {
+            if (event.type !== 'runtime.thread.failed') {
+                return false;
+            }
+            if (event.threadId === threadId) {
+                return true;
+            }
+            return Predicate.isObject(event.payload) && event.payload.threadId === threadId;
+        });
+        if (already) {
+            continue;
+        }
+        out.push({
+            type: 'runtime.thread.failed',
+            payload: { threadId, error: thread.error ?? 'failed' },
+            threadId,
+        });
+    }
+    return out;
+}
+export function waitSatisfiedEvents(state, events) {
+    const produced = [];
+    const remaining = { ...state.waits };
+    for (const event of events) {
+        if (event.ephemeral || event.type === 'runtime.wait.satisfied') {
+            continue;
+        }
+        const matches = matchingWaits(event, Object.values(remaining));
+        for (const record of matches) {
+            produced.push({
+                type: 'runtime.wait.satisfied',
+                payload: asJson({
+                    waitId: record.waitId,
+                    tag: record.tag ?? null,
+                    event: { id: event.id, type: event.type, payload: event.payload },
+                }),
+                threadId: record.threadId,
+                causationId: event.id,
+            });
+            delete remaining[record.waitId];
+        }
+    }
+    return produced;
+}
+export function createEffectFailedEvent(runId, item, error) {
+    return createEvent(runId, {
+        type: 'runtime.effect.failed',
+        payload: {
+            effectId: item.effectId,
+            error,
+        },
+        threadId: item.threadId,
+        effectId: item.effectId,
+        causationId: item.causingEventId,
+        origin: { type: 'system' },
+    });
+}
+export function materializeEffectOutcome(catalogs, runId, item, input) {
+    return validateEventInput(catalogs, input).pipe(Effect.map((validated) => createEvent(runId, {
+        ...validated,
+        effectId: validated.effectId ?? item.effectId,
+        causationId: validated.causationId ?? item.causingEventId,
+        threadId: validated.threadId ?? item.threadId,
+        origin: validated.origin ?? { type: 'thread', threadId: item.threadId },
+        id: validated.id,
+        ts: validated.ts,
+    })), Effect.catchTag('InvalidEventError', (err) => Effect.succeed(createEffectFailedEvent(runId, item, err.message))));
+}
+export function createLiveEvent(runId, item, validated) {
+    const targetThreadId = validated.threadId ?? item.threadId;
+    const ephemeral = createEvent(runId, {
+        ...validated,
+        effectId: item.effectId,
+        causationId: item.causingEventId,
+        threadId: targetThreadId,
+        ephemeral: validated.ephemeral ?? true,
+        origin: validated.origin ?? { type: 'thread', threadId: item.threadId },
+    });
+    const [liveEvent] = stripSeq([ephemeral]);
+    return liveEvent;
+}
+export function validateAndCreateEvents(catalogs, runId, events, defaults) {
+    return validateEventsEffect(catalogs, events).pipe(Effect.map((validated) => validated.map((input) => createEvent(runId, {
+        ...input,
+        threadId: input.threadId !== undefined ? input.threadId : (defaults.threadId ?? null),
+        origin: input.origin ?? defaults.origin,
+    }))));
+}