@swirls/looms 0.0.1

package/dist/core/module-scope.js

@@ -0,0 +1,72 @@
+import { defineEventCatalog, } from './catalog.js';
+import { emit, defineEffect, } from './effects.js';
+import {} from './module.js';
+import { defineProjection } from './projection.js';
+import { defineThread, } from './thread.js';
+import { asJson } from './types.js';
+function buildScopeInput(namespace, events, key, payload, meta) {
+    if (events) {
+        // SAFETY: catalog input produces typed EventInput for the catalog entry.
+        return events.input(key, payload, meta);
+    }
+    return {
+        ...meta,
+        type: `${namespace}.${key}`,
+        payload: asJson(payload),
+    };
+}
+export function createModuleScope(options) {
+    const { namespace, protocolVersion, events, observes, dependencies } = options;
+    const scope = {
+        namespace,
+        protocolVersion,
+        events,
+        observes,
+        dependencies,
+        thread(def) {
+            return defineThread(def);
+        },
+        projection(def) {
+            return defineProjection(def);
+        },
+        effect(def) {
+            return defineEffect(def);
+        },
+        input(key, payload, meta) {
+            return buildScopeInput(namespace, events, key, payload, meta);
+        },
+        emit(key, payload, meta) {
+            return emit(buildScopeInput(namespace, events, key, payload, meta));
+        },
+    };
+    return scope;
+}
+/** Construct a complete module. Only members returned by setup are installed. */
+/* oxlint-disable anti-slop/no-runtime-typeof, anti-slop/no-chained-type-assertions, anti-slop/no-conditional-empty-object-spread, anti-slop/require-safety-comment-for-type-assertion -- This compatibility boundary normalizes either a module builder or its finished catalog while preserving its generic member types. */
+export function defineModule(options, setup) {
+    const source = options.events;
+    // SAFETY: catalogs have an input builder; inline entries are normalized once here.
+    const events = (source &&
+        (typeof source.input === 'function'
+            ? source
+            : defineEventCatalog(options.namespace, source)));
+    const scope = typeof options.effect === 'function'
+        ? options
+        : createModuleScope({ ...options, events });
+    const members = setup(scope);
+    return {
+        namespace: options.namespace,
+        protocolVersion: options.protocolVersion,
+        events: events,
+        ...(options.observes ? { observes: options.observes } : {}),
+        ...(options.dependencies ? { dependencies: options.dependencies } : {}),
+        ...(members.definitions ? { definitions: members.definitions } : {}),
+        ...(members.middleware ? { middleware: members.middleware } : {}),
+        ...(members.services ? { services: members.services } : {}),
+        // SAFETY: absent member bags use the corresponding empty-object generic defaults.
+        effects: (members.effects ?? {}),
+        threads: (members.threads ?? {}),
+        projections: (members.projections ?? {}),
+    };
+}
+/* oxlint-enable anti-slop/no-runtime-typeof, anti-slop/no-chained-type-assertions, anti-slop/no-conditional-empty-object-spread, anti-slop/require-safety-comment-for-type-assertion */

package/dist/core/module.d.ts

@@ -0,0 +1,74 @@
+import type { Effect, Layer } from 'effect';
+import type { EventCatalog } from './catalog';
+import type { EffectContext, EffectDefinition, RuntimeEffect } from './effects';
+import type { EventInput } from './envelope';
+import type { ProjectionDefinition } from './projection';
+import type { InferDefinedSchema, SchemaInput } from './schema';
+import type { ThreadDefinition } from './thread';
+import type { JsonValue } from './types';
+export type NextEffectHandler = (effect: RuntimeEffect, ctx: EffectContext) => Effect.Effect<ReadonlyArray<EventInput>, Error>;
+export type EffectMiddleware = (effect: RuntimeEffect, ctx: EffectContext, next: NextEffectHandler) => Effect.Effect<ReadonlyArray<EventInput>, Error>;
+export interface RuntimeModuleDependency {
+    readonly namespace: string;
+    readonly protocolVersion?: string;
+}
+/** Anything a host can start by `{ kind, name }`: an agent, a workflow, or your own kind. */
+export interface DefinitionRef {
+    readonly kind: string;
+    readonly name: string;
+    readonly input?: SchemaInput | undefined;
+}
+/** A definition registered on a host, keyed by `${kind}:${name}`. */
+export interface RegisteredDefinition {
+    readonly kind: string;
+    readonly name: string;
+    readonly input?: SchemaInput | undefined;
+    readonly value: DefinitionRef;
+}
+/**
+ * Input type accepted when starting a definition: inferred from the definition's
+ * `input` Standard Schema / Effect Schema, or JsonValue when it has none.
+ */
+export type DefinitionInput<TDef> = TDef extends {
+    readonly input?: infer S;
+} ? InferDefinedSchema<S> : JsonValue;
+export interface RuntimeModule<TNamespace extends string = string, TEvents extends EventCatalog = EventCatalog, TEffects extends {
+    readonly [key: string]: EffectDefinition;
+} = {
+    readonly [key: string]: EffectDefinition;
+}, TThreads extends {
+    readonly [key: string]: ThreadDefinition;
+} = {
+    readonly [key: string]: ThreadDefinition;
+}, TProjections extends {
+    readonly [key: string]: ProjectionDefinition;
+} = {
+    readonly [key: string]: ProjectionDefinition;
+}, TServices = any> {
+    readonly namespace: TNamespace;
+    readonly protocolVersion: string;
+    readonly events?: TEvents;
+    readonly observes?: readonly EventCatalog[];
+    readonly threads?: TThreads;
+    readonly effects?: TEffects;
+    readonly projections?: TProjections;
+    readonly definitions?: readonly DefinitionRef[];
+    readonly dependencies?: readonly RuntimeModuleDependency[];
+    readonly middleware?: readonly EffectMiddleware[];
+    /** Host-side services this module's effect handlers need (an LLM, a definition lookup, a DB pool). */
+    readonly services?: () => Layer.Layer<TServices>;
+}
+export declare function defineRuntimeModule<TNamespace extends string, TEvents extends EventCatalog, TEffects extends {
+    readonly [key: string]: EffectDefinition;
+}, TThreads extends {
+    readonly [key: string]: ThreadDefinition;
+}, TProjections extends {
+    readonly [key: string]: ProjectionDefinition;
+}, TServices = any>(module: RuntimeModule<TNamespace, TEvents, TEffects, TThreads, TProjections, TServices>): RuntimeModule<TNamespace, TEvents, TEffects, TThreads, TProjections, TServices>;
+export type AnyRuntimeModule = RuntimeModule<string, EventCatalog, {
+    readonly [name: string]: EffectDefinition;
+}, {
+    readonly [kind: string]: ThreadDefinition;
+}, {
+    readonly [name: string]: ProjectionDefinition;
+}>;

package/dist/core/module.js

@@ -0,0 +1,3 @@
+export function defineRuntimeModule(module) {
+    return module;
+}

package/dist/core/projection.d.ts

@@ -0,0 +1,83 @@
+import { Schema, Stream, type Effect } from 'effect';
+import type { EventEnvelope } from './envelope';
+import type { InferSchemaOutput } from './schema';
+import type { RunState, ThreadRecord } from './state';
+export interface ProjectionDefinition<S = unknown> {
+    readonly name: string;
+    readonly shape?: unknown;
+    initialState: S;
+    reduce(state: S, event: EventEnvelope): S;
+}
+export declare function defineProjection<TShape>(def: {
+    readonly name: string;
+    readonly shape: TShape;
+    readonly initialState: InferSchemaOutput<TShape>;
+    reduce(state: InferSchemaOutput<TShape>, event: EventEnvelope): InferSchemaOutput<TShape>;
+}): ProjectionDefinition<InferSchemaOutput<TShape>>;
+export declare function defineProjection<S = unknown>(def: {
+    readonly name: string;
+    readonly shape?: unknown;
+    readonly initialState: S;
+    reduce(state: S, event: EventEnvelope): S;
+}): ProjectionDefinition<S>;
+export declare function foldProjection<S>(projection: ProjectionDefinition<S>, events: readonly EventEnvelope[], initial?: S): S;
+/** Fold a projection over events, skipping ephemeral ones. */
+export declare function project<S>(definition: ProjectionDefinition<S>, events: readonly EventEnvelope[], from?: S): S;
+/** Fold a projection over an Effect Stream of events, skipping ephemeral ones. */
+export declare function projectStream<S, E = never, R = never>(definition: ProjectionDefinition<S>, stream: Stream.Stream<EventEnvelope, E, R>, from?: S): Effect.Effect<S, E, R>;
+export interface ThreadNode {
+    threadId: string;
+    kind: string;
+    definitionName: string;
+    status: ThreadRecord['status'];
+    parentThreadId: string | null;
+    children: ThreadNode[];
+}
+export type TreeNode = ThreadNode;
+export interface ThreadTree {
+    runId: string;
+    root: ThreadNode | null;
+}
+export interface TreeBuildState {
+    runId: string;
+    records: {
+        [threadId: string]: ThreadRecord;
+    };
+    rootThreadId: string | null;
+    /** Wait ids still open for a thread (mirrors fold `state.waits`). */
+    activeWaits?: {
+        [threadId: string]: string[];
+    };
+}
+export declare const TreeBuildStateSchema: Schema.Schema<TreeBuildState>;
+export declare const threadTree: ProjectionDefinition<TreeBuildState>;
+export declare function toThreadTree(state: TreeBuildState): ThreadTree;
+export declare function treeFromRun(state: RunState): ThreadTree;
+export declare const TimelineEntrySchema: Schema.Struct<{
+    readonly seq: Schema.Number;
+    readonly id: Schema.String;
+    readonly type: Schema.String;
+    readonly threadId: Schema.NullOr<Schema.String>;
+    readonly causationId: Schema.NullOr<Schema.String>;
+    readonly effectId: Schema.NullOr<Schema.String>;
+    readonly ts: Schema.Number;
+}>;
+export type TimelineEntry = Schema.Schema.Type<typeof TimelineEntrySchema>;
+export declare const TimelineSchema: Schema.mutable<Schema.$Array<Schema.Struct<{
+    readonly seq: Schema.Number;
+    readonly id: Schema.String;
+    readonly type: Schema.String;
+    readonly threadId: Schema.NullOr<Schema.String>;
+    readonly causationId: Schema.NullOr<Schema.String>;
+    readonly effectId: Schema.NullOr<Schema.String>;
+    readonly ts: Schema.Number;
+}>>>;
+export declare const timeline: ProjectionDefinition<{
+    readonly seq: number;
+    readonly id: string;
+    readonly type: string;
+    readonly threadId: string | null;
+    readonly causationId: string | null;
+    readonly effectId: string | null;
+    readonly ts: number;
+}[]>;

package/dist/core/projection.js

@@ -0,0 +1,241 @@
+import { Predicate, Schema, Stream } from 'effect';
+import { isTerminalStatus } from './thread.js';
+export function defineProjection(def) {
+    return def;
+}
+export function foldProjection(projection, events, initial) {
+    let state = initial !== undefined ? initial : projection.initialState;
+    for (const event of events) {
+        state = projection.reduce(state, event);
+    }
+    return state;
+}
+/** Fold a projection over events, skipping ephemeral ones. */
+export function project(definition, events, from) {
+    let state = from ?? definition.initialState;
+    for (const event of events) {
+        if (event.ephemeral) {
+            continue;
+        }
+        state = definition.reduce(state, event);
+    }
+    return state;
+}
+/** Fold a projection over an Effect Stream of events, skipping ephemeral ones. */
+export function projectStream(definition, stream, from) {
+    const getInitial = () => (from !== undefined ? from : definition.initialState);
+    return Stream.runFold(stream, getInitial, (state, event) => event.ephemeral ? state : definition.reduce(state, event));
+}
+// SAFETY: TreeBuildState is folded by reducers; Schema.Unknown is a typed placeholder, not a decoder.
+export const TreeBuildStateSchema = Schema.Unknown;
+function readPayload(event) {
+    if (!Predicate.isObject(event.payload)) {
+        return {};
+    }
+    return event.payload;
+}
+function readString(obj, key) {
+    const value = obj[key];
+    return Predicate.isString(value) ? value : undefined;
+}
+export const threadTree = defineProjection({
+    name: 'threadTree',
+    shape: TreeBuildStateSchema,
+    initialState: { runId: '', records: {}, rootThreadId: null },
+    reduce(state, event) {
+        const payload = readPayload(event);
+        switch (event.type) {
+            case 'runtime.run.started': {
+                const rootThreadId = readString(payload, 'rootThreadId') ?? state.rootThreadId;
+                return {
+                    ...state,
+                    runId: event.runId,
+                    rootThreadId,
+                };
+            }
+            case 'runtime.thread.started': {
+                const threadId = readString(payload, 'threadId') ?? event.threadId;
+                const kind = readString(payload, 'kind');
+                const definitionName = readString(payload, 'definitionName');
+                if (!threadId || !kind || !definitionName) {
+                    return { ...state, runId: event.runId };
+                }
+                const parent = payload.parentThreadId;
+                const parentThreadId = parent === null || Predicate.isString(parent) ? parent : null;
+                const record = {
+                    threadId,
+                    kind,
+                    definitionName,
+                    parentThreadId,
+                    status: 'running',
+                    input: payload.input ?? null,
+                    output: null,
+                    error: null,
+                    state: {},
+                };
+                const rootThreadId = state.rootThreadId ?? threadId;
+                return {
+                    ...state,
+                    runId: event.runId,
+                    rootThreadId,
+                    records: { ...state.records, [threadId]: record },
+                };
+            }
+            case 'runtime.thread.completed':
+            case 'runtime.thread.failed':
+            case 'runtime.thread.cancelled': {
+                const threadId = readString(payload, 'threadId') ?? event.threadId;
+                if (!threadId) {
+                    return { ...state, runId: event.runId };
+                }
+                const existing = state.records[threadId];
+                if (!existing) {
+                    return { ...state, runId: event.runId };
+                }
+                const status = event.type === 'runtime.thread.completed'
+                    ? 'completed'
+                    : event.type === 'runtime.thread.failed'
+                        ? 'failed'
+                        : 'cancelled';
+                return {
+                    ...state,
+                    runId: event.runId,
+                    records: {
+                        ...state.records,
+                        [threadId]: {
+                            ...existing,
+                            status,
+                            output: payload.output ?? existing.output,
+                            error: readString(payload, 'error') ?? existing.error,
+                        },
+                    },
+                };
+            }
+            case 'runtime.wait.registered': {
+                const threadId = event.threadId ?? readString(payload, 'threadId');
+                const waitId = readString(payload, 'waitId');
+                if (!threadId || !waitId) {
+                    return { ...state, runId: event.runId };
+                }
+                const existing = state.records[threadId];
+                if (!existing || isTerminalStatus(existing.status)) {
+                    return { ...state, runId: event.runId };
+                }
+                const currentWaits = state.activeWaits?.[threadId] ?? [];
+                const nextWaits = currentWaits.includes(waitId) ? currentWaits : [...currentWaits, waitId];
+                return {
+                    ...state,
+                    runId: event.runId,
+                    activeWaits: { ...state.activeWaits, [threadId]: nextWaits },
+                    records: {
+                        ...state.records,
+                        [threadId]: {
+                            ...existing,
+                            status: 'waiting',
+                        },
+                    },
+                };
+            }
+            case 'runtime.wait.satisfied': {
+                const threadId = event.threadId ?? readString(payload, 'threadId');
+                const waitId = readString(payload, 'waitId');
+                if (!threadId) {
+                    return { ...state, runId: event.runId };
+                }
+                const existing = state.records[threadId];
+                if (!existing || isTerminalStatus(existing.status)) {
+                    return { ...state, runId: event.runId };
+                }
+                const currentWaits = waitId
+                    ? (state.activeWaits?.[threadId] ?? []).filter((id) => id !== waitId)
+                    : [];
+                const nextStatus = currentWaits.length > 0 ? 'waiting' : 'running';
+                return {
+                    ...state,
+                    runId: event.runId,
+                    activeWaits: { ...state.activeWaits, [threadId]: currentWaits },
+                    records: {
+                        ...state.records,
+                        [threadId]: {
+                            ...existing,
+                            status: nextStatus,
+                        },
+                    },
+                };
+            }
+            default:
+                return state.runId === event.runId ? state : { ...state, runId: event.runId };
+        }
+    },
+});
+export function toThreadTree(state) {
+    return treeFromRun({
+        runId: state.runId,
+        status: 'running',
+        rootThreadId: state.rootThreadId,
+        threads: state.records,
+        waits: {},
+        outstandingEffects: [],
+        completedEffectIds: [],
+    });
+}
+export function treeFromRun(state) {
+    const records = Object.values(state.threads);
+    const waitingThreadIds = new Set(Object.values(state.waits).map((w) => w.threadId));
+    const byParent = new Map();
+    for (const record of records) {
+        const key = record.parentThreadId;
+        const list = byParent.get(key) ?? [];
+        list.push(record);
+        byParent.set(key, list);
+    }
+    const toNode = (record) => {
+        const isWaiting = !isTerminalStatus(record.status) &&
+            (record.status === 'waiting' || waitingThreadIds.has(record.threadId));
+        return {
+            threadId: record.threadId,
+            kind: record.kind,
+            definitionName: record.definitionName,
+            status: isWaiting ? 'waiting' : record.status,
+            parentThreadId: record.parentThreadId,
+            children: (byParent.get(record.threadId) ?? []).map(toNode),
+        };
+    };
+    const rootRecord = state.rootThreadId
+        ? state.threads[state.rootThreadId]
+        : records.find((r) => r.parentThreadId === null);
+    return {
+        runId: state.runId,
+        root: rootRecord ? toNode(rootRecord) : null,
+    };
+}
+export const TimelineEntrySchema = Schema.Struct({
+    seq: Schema.Number,
+    id: Schema.String,
+    type: Schema.String,
+    threadId: Schema.NullOr(Schema.String),
+    causationId: Schema.NullOr(Schema.String),
+    effectId: Schema.NullOr(Schema.String),
+    ts: Schema.Number,
+});
+export const TimelineSchema = Schema.mutable(Schema.Array(TimelineEntrySchema));
+export const timeline = defineProjection({
+    name: 'timeline',
+    shape: TimelineSchema,
+    initialState: [],
+    reduce(state, event) {
+        const threadId = event.threadId ?? null;
+        return [
+            ...state,
+            {
+                seq: event.seq,
+                id: event.id,
+                type: event.type,
+                threadId,
+                causationId: event.causationId ?? null,
+                effectId: event.effectId ?? null,
+                ts: event.ts,
+            },
+        ];
+    },
+});

package/dist/core/protocol.d.ts

@@ -0,0 +1,99 @@
+import { Schema } from 'effect';
+import { type EventInputOf, type EventsOfCatalog } from './catalog';
+import type { WaitCondition } from './effects';
+export declare const WaitConditionSchema: Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Union<readonly [Schema.String, Schema.$Array<Schema.String>]>;
+    readonly match: Schema.optional<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+}>, Schema.Struct<{
+    readonly timerAt: Schema.Number;
+}>]>;
+export declare const protocolCatalog: import("./catalog").EventCatalog<"runtime", {
+    'run.started': Schema.Struct<{
+        readonly rootThreadId: Schema.optional<Schema.String>;
+        readonly kind: Schema.String;
+        readonly definitionName: Schema.String;
+        readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    }>;
+    'run.completed': Schema.Struct<{
+        readonly output: Schema.NullOr<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+        readonly error: Schema.NullOr<Schema.String>;
+    }>;
+    'thread.started': Schema.Struct<{
+        readonly threadId: Schema.String;
+        readonly kind: Schema.String;
+        readonly definitionName: Schema.String;
+        readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly parentThreadId: Schema.NullOr<Schema.String>;
+    }>;
+    'thread.completed': Schema.Struct<{
+        readonly threadId: Schema.String;
+        readonly output: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    }>;
+    'thread.failed': Schema.Struct<{
+        readonly threadId: Schema.String;
+        readonly error: Schema.String;
+    }>;
+    'thread.cancelled': Schema.Struct<{
+        readonly threadId: Schema.String;
+        readonly reason: Schema.optional<Schema.String>;
+    }>;
+    'wait.registered': Schema.Struct<{
+        readonly waitId: Schema.String;
+        readonly threadId: Schema.optional<Schema.String>;
+        readonly on: Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Union<readonly [Schema.String, Schema.$Array<Schema.String>]>;
+            readonly match: Schema.optional<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+        }>, Schema.Struct<{
+            readonly timerAt: Schema.Number;
+        }>]>;
+        readonly tag: Schema.optional<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    }>;
+    'wait.satisfied': Schema.Struct<{
+        readonly waitId: Schema.String;
+        readonly tag: Schema.optional<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+        readonly event: Schema.Struct<{
+            readonly id: Schema.String;
+            readonly type: Schema.String;
+            readonly payload: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        }>;
+    }>;
+    'timer.set': Schema.Struct<{
+        readonly timerId: Schema.String;
+        readonly waitId: Schema.String;
+        readonly wakeAt: Schema.Number;
+    }>;
+    'timer.fired': Schema.Struct<{
+        readonly timerId: Schema.String;
+        readonly waitId: Schema.String;
+    }>;
+    'effect.failed': Schema.Struct<{
+        readonly effectId: Schema.String;
+        readonly error: Schema.String;
+    }>;
+    'snapshot.taken': Schema.Struct<{
+        readonly seq: Schema.Number;
+        readonly stateHash: Schema.String;
+        readonly state: Schema.optional<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    }>;
+    'signal.received': Schema.Struct<{
+        readonly signalType: Schema.String;
+    }>;
+}>;
+export type ProtocolEvent = EventsOfCatalog<typeof protocolCatalog>;
+export type ProtocolEventInput = EventInputOf<typeof protocolCatalog>;
+export declare const PROTOCOL_TYPES: readonly ['runtime.run.started', 'runtime.run.completed', 'runtime.thread.started', 'runtime.thread.completed', 'runtime.thread.failed', 'runtime.thread.cancelled', 'runtime.wait.registered', 'runtime.wait.satisfied', 'runtime.timer.set', 'runtime.timer.fired', 'runtime.effect.failed', 'runtime.snapshot.taken', 'runtime.signal.received'];
+export type ProtocolEventType = (typeof PROTOCOL_TYPES)[number];
+export declare function isProtocolType(type: string): type is ProtocolEventType;
+export type RunStartedPayload = Schema.Schema.Type<(typeof protocolCatalog.entries)['run.started']>;
+export type RunCompletedPayload = Schema.Schema.Type<(typeof protocolCatalog.entries)['run.completed']>;
+export type ThreadStartedPayload = Schema.Schema.Type<(typeof protocolCatalog.entries)['thread.started']>;
+export type ThreadCompletedPayload = Schema.Schema.Type<(typeof protocolCatalog.entries)['thread.completed']>;
+export type ThreadFailedPayload = Schema.Schema.Type<(typeof protocolCatalog.entries)['thread.failed']>;
+export type ThreadCancelledPayload = Schema.Schema.Type<(typeof protocolCatalog.entries)['thread.cancelled']>;
+export type WaitRegisteredPayload = Schema.Schema.Type<(typeof protocolCatalog.entries)['wait.registered']>;
+export type WaitSatisfiedPayload = Schema.Schema.Type<(typeof protocolCatalog.entries)['wait.satisfied']>;
+export type TimerSetPayload = Schema.Schema.Type<(typeof protocolCatalog.entries)['timer.set']>;
+export type TimerFiredPayload = Schema.Schema.Type<(typeof protocolCatalog.entries)['timer.fired']>;
+export type EffectFailedPayload = Schema.Schema.Type<(typeof protocolCatalog.entries)['effect.failed']>;
+export type SnapshotTakenPayload = Schema.Schema.Type<(typeof protocolCatalog.entries)['snapshot.taken']>;
+export declare function asWaitCondition(value: Schema.Schema.Type<typeof WaitConditionSchema>): WaitCondition;

package/dist/core/protocol.js

@@ -0,0 +1,101 @@
+import { Schema } from 'effect';
+import { defineEventCatalog } from './catalog.js';
+import { JsonValueSchema } from './envelope.js';
+const WaitOnEventSchema = Schema.Struct({
+    type: Schema.Union([Schema.String, Schema.Array(Schema.String)]),
+    match: Schema.optional(JsonValueSchema),
+});
+const WaitOnTimerSchema = Schema.Struct({
+    timerAt: Schema.Number,
+});
+export const WaitConditionSchema = Schema.Union([WaitOnEventSchema, WaitOnTimerSchema]);
+export const protocolCatalog = defineEventCatalog('runtime', {
+    'run.started': Schema.Struct({
+        rootThreadId: Schema.optional(Schema.String),
+        kind: Schema.String,
+        definitionName: Schema.String,
+        input: JsonValueSchema,
+    }),
+    'run.completed': Schema.Struct({
+        output: Schema.NullOr(JsonValueSchema),
+        error: Schema.NullOr(Schema.String),
+    }),
+    'thread.started': Schema.Struct({
+        threadId: Schema.String,
+        kind: Schema.String,
+        definitionName: Schema.String,
+        input: JsonValueSchema,
+        parentThreadId: Schema.NullOr(Schema.String),
+    }),
+    'thread.completed': Schema.Struct({
+        threadId: Schema.String,
+        output: JsonValueSchema,
+    }),
+    'thread.failed': Schema.Struct({
+        threadId: Schema.String,
+        error: Schema.String,
+    }),
+    'thread.cancelled': Schema.Struct({
+        threadId: Schema.String,
+        reason: Schema.optional(Schema.String),
+    }),
+    'wait.registered': Schema.Struct({
+        waitId: Schema.String,
+        threadId: Schema.optional(Schema.String),
+        on: WaitConditionSchema,
+        tag: Schema.optional(JsonValueSchema),
+    }),
+    'wait.satisfied': Schema.Struct({
+        waitId: Schema.String,
+        tag: Schema.optional(JsonValueSchema),
+        event: Schema.Struct({
+            id: Schema.String,
+            type: Schema.String,
+            payload: JsonValueSchema,
+        }),
+    }),
+    'timer.set': Schema.Struct({
+        timerId: Schema.String,
+        waitId: Schema.String,
+        wakeAt: Schema.Number,
+    }),
+    'timer.fired': Schema.Struct({
+        timerId: Schema.String,
+        waitId: Schema.String,
+    }),
+    'effect.failed': Schema.Struct({
+        effectId: Schema.String,
+        error: Schema.String,
+    }),
+    'snapshot.taken': Schema.Struct({
+        seq: Schema.Number,
+        stateHash: Schema.String,
+        state: Schema.optional(JsonValueSchema),
+    }),
+    'signal.received': Schema.Struct({
+        signalType: Schema.String,
+    }),
+});
+export const PROTOCOL_TYPES = [
+    'runtime.run.started',
+    'runtime.run.completed',
+    'runtime.thread.started',
+    'runtime.thread.completed',
+    'runtime.thread.failed',
+    'runtime.thread.cancelled',
+    'runtime.wait.registered',
+    'runtime.wait.satisfied',
+    'runtime.timer.set',
+    'runtime.timer.fired',
+    'runtime.effect.failed',
+    'runtime.snapshot.taken',
+    'runtime.signal.received',
+];
+export function isProtocolType(type) {
+    // SAFETY: PROTOCOL_TYPES is the closed list of runtime.* event names.
+    const names = PROTOCOL_TYPES;
+    return names.includes(type);
+}
+export function asWaitCondition(value) {
+    return value;
+}