@swirls/looms 0.0.1 → 0.1.0

package/dist/core/limits.d.ts

@@ -0,0 +1,34 @@
+import type { AppendableEvent } from './envelope';
+import type { RunSnapshot } from './snapshot-store';
+import type { JsonValue } from './types';
+export declare const DEFAULT_MAX_EVENT_BYTES: number;
+export declare const DEFAULT_MAX_SNAPSHOT_BYTES: number;
+declare const EventPayloadTooLargeError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "EventPayloadTooLargeError";
+} & Readonly<A>;
+export declare class EventPayloadTooLargeError extends EventPayloadTooLargeError_base<{
+    readonly runId: string;
+    readonly eventType: string;
+    readonly bytes: number;
+    readonly maxBytes: number;
+    readonly message: string;
+}> {
+    constructor(runId: string, eventType: string, bytes: number, maxBytes: number);
+}
+declare const SnapshotPayloadTooLargeError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "SnapshotPayloadTooLargeError";
+} & Readonly<A>;
+export declare class SnapshotPayloadTooLargeError extends SnapshotPayloadTooLargeError_base<{
+    readonly runId: string;
+    readonly bytes: number;
+    readonly maxBytes: number;
+    readonly message: string;
+}> {
+    constructor(runId: string, bytes: number, maxBytes: number);
+}
+/** Size of `value` as serialized JSON, in UTF-8 bytes. */
+export declare function utf8JsonBytes(value: JsonValue | Readonly<object>): number;
+/** Validate every event before any storage mutation begins. */
+export declare function assertEventByteLimits(runId: string, events: ReadonlyArray<AppendableEvent>, maxBytes?: number): void;
+export declare function assertSnapshotByteLimit(snapshot: RunSnapshot, maxBytes?: number): void;
+export {};

package/dist/core/limits.js

@@ -0,0 +1,46 @@
+import { Data } from 'effect';
+export const DEFAULT_MAX_EVENT_BYTES = 1024 * 1024;
+export const DEFAULT_MAX_SNAPSHOT_BYTES = 8 * 1024 * 1024;
+const utf8 = new TextEncoder();
+export class EventPayloadTooLargeError extends Data.TaggedError('EventPayloadTooLargeError') {
+    constructor(runId, eventType, bytes, maxBytes) {
+        super({
+            runId,
+            eventType,
+            bytes,
+            maxBytes,
+            message: `EventPayloadTooLarge: event "${eventType}" for run "${runId}" is ${bytes} UTF-8 bytes; limit is ${maxBytes}`,
+        });
+        this.name = 'EventPayloadTooLargeError';
+    }
+}
+export class SnapshotPayloadTooLargeError extends Data.TaggedError('SnapshotPayloadTooLargeError') {
+    constructor(runId, bytes, maxBytes) {
+        super({
+            runId,
+            bytes,
+            maxBytes,
+            message: `SnapshotPayloadTooLarge: snapshot for run "${runId}" is ${bytes} UTF-8 bytes; limit is ${maxBytes}`,
+        });
+        this.name = 'SnapshotPayloadTooLargeError';
+    }
+}
+/** Size of `value` as serialized JSON, in UTF-8 bytes. */
+export function utf8JsonBytes(value) {
+    return utf8.encode(JSON.stringify(value)).byteLength;
+}
+/** Validate every event before any storage mutation begins. */
+export function assertEventByteLimits(runId, events, maxBytes = DEFAULT_MAX_EVENT_BYTES) {
+    for (const event of events) {
+        const bytes = utf8JsonBytes({ ...event, runId, seq: event.seq ?? 0 });
+        if (bytes > maxBytes) {
+            throw new EventPayloadTooLargeError(runId, event.type, bytes, maxBytes);
+        }
+    }
+}
+export function assertSnapshotByteLimit(snapshot, maxBytes = DEFAULT_MAX_SNAPSHOT_BYTES) {
+    const bytes = utf8JsonBytes(snapshot);
+    if (bytes > maxBytes) {
+        throw new SnapshotPayloadTooLargeError(snapshot.runId, bytes, maxBytes);
+    }
+}

package/dist/core/match.d.ts

@@ -4,5 +4,6 @@ import type { JsonValue } from './types';
 export declare function isSubset(match: JsonValue, payload: JsonValue): boolean;
 export declare function matchesWait(event: EventEnvelope, on: WaitCondition): boolean;
 export declare function matchingWaits<T extends {
+    waitId: string;
     on: WaitCondition;
 }>(event: EventEnvelope, waits: readonly T[]): T[];

package/dist/core/match.js

@@ -54,5 +54,14 @@ export function matchesWait(event, on) {
     return isSubset(on.match, event.payload);
 }
 export function matchingWaits(event, waits) {
-    return waits.filter((record) => matchesWait(event, record.on));
+    return waits.filter((record) => {
+        if (isWaitOnTimer(record.on)) {
+            if (event.type !== 'runtime.timer.fired' || !Predicate.isObject(event.payload)) {
+                return false;
+            }
+            const firedWaitId = event.payload.waitId;
+            return Predicate.isString(firedWaitId) && firedWaitId === record.waitId;
+        }
+        return matchesWait(event, record.on);
+    });
 }

package/dist/core/module-scope.d.ts

@@ -1,9 +1,9 @@
 import type { Layer } from 'effect';
 import { type CatalogEntries, type EventCatalog, type EventInputOf, type EventsOfCatalog, type InferPayload } from './catalog';
 import type { EventsOf, ProtocolEvents } from './compose';
-import { type EffectDefinition, type EffectHandlerResult, type EmitEffect, type RetryPolicy, type RuntimeEffect, type ScopedEffectContext } from './effects';
+import { type EffectDefinition, type EffectExecution, type EffectHandlerResult, type EmitEffect, type RetryPolicy, type RuntimeEffect, type ScopedEffectContext } from './effects';
 import type { EventEnvelope, EventInput } from './envelope';
-import { type AnyRuntimeModule, type EffectMiddleware, type RuntimeModule, type DefinitionRef, type RuntimeModuleDependency } from './module';
+import { type AnyRuntimeModule, type EffectMiddleware, type RuntimeModule, type DefinitionRef, type RuntimeModuleDependency, type SignalInterruptRule } from './module';
 import { type ProjectionDefinition } from './projection';
 import type { InferDefinedSchema, InferSchemaOutput, SchemaInput } from './schema';
 import { type StartContext, type ThreadContext, type ThreadDefinition } from './thread';
@@ -32,40 +32,41 @@ export interface ModuleScope<TNamespace extends string, U extends EventEnvelope<
     readonly events?: TEvents;
     readonly observes?: TObserves;
     readonly dependencies?: readonly RuntimeModuleDependency[];
-    thread<TShape, TInputSchema extends SchemaInput | undefined = undefined>(def: {
-        readonly kind: string;
-        readonly shape: TShape;
-        readonly input?: TInputSchema;
-        initialState(ctx: StartContext<InferDefinedSchema<TInputSchema>>): InferSchemaOutput<TShape>;
-        step(state: InferSchemaOutput<TShape>, event: U, ctx: ThreadContext): InferSchemaOutput<TShape>;
-        effects?(state: InferSchemaOutput<TShape>, ctx: ThreadContext): RuntimeEffect[];
-    }): ThreadDefinition<InferSchemaOutput<TShape>>;
     thread<S = JsonValue, TInputSchema extends SchemaInput | undefined = undefined>(def: {
         readonly kind: string;
-        readonly shape?: unknown;
+        readonly shape?: undefined;
         readonly input?: TInputSchema;
         initialState(ctx: StartContext<InferDefinedSchema<TInputSchema>>): S;
         step(state: S, event: U, ctx: ThreadContext): S;
         effects?(state: S, ctx: ThreadContext): RuntimeEffect[];
     }): ThreadDefinition<S>;
-    projection<TShape>(def: {
-        readonly name: string;
+    thread<TShape extends SchemaInput, TInputSchema extends SchemaInput | undefined = undefined>(def: {
+        readonly kind: string;
         readonly shape: TShape;
-        readonly initialState: InferSchemaOutput<TShape>;
-        reduce(state: InferSchemaOutput<TShape>, event: U): InferSchemaOutput<TShape>;
-    }): ProjectionDefinition<InferSchemaOutput<TShape>>;
+        readonly input?: TInputSchema;
+        initialState(ctx: StartContext<InferDefinedSchema<TInputSchema>>): InferSchemaOutput<TShape>;
+        step(state: NoInfer<InferSchemaOutput<TShape>>, event: U, ctx: ThreadContext): InferSchemaOutput<TShape>;
+        effects?(state: NoInfer<InferSchemaOutput<TShape>>, ctx: ThreadContext): RuntimeEffect[];
+    }): ThreadDefinition<InferSchemaOutput<TShape>>;
     projection<S>(def: {
         readonly name: string;
-        readonly shape?: unknown;
+        readonly shape?: undefined;
         readonly initialState: S;
         reduce(state: S, event: U): S;
     }): ProjectionDefinition<S>;
-    effect<TSchema = undefined, TInput = InferDefinedSchema<TSchema>, R = never, E extends EventInputOf<U> = EventInputOf<U>>(def: {
+    projection<TShape extends SchemaInput>(def: {
+        readonly name: string;
+        readonly shape: TShape;
+        readonly initialState: InferSchemaOutput<TShape>;
+        reduce(state: NoInfer<InferSchemaOutput<TShape>>, event: U): InferSchemaOutput<TShape>;
+    }): ProjectionDefinition<InferSchemaOutput<TShape>>;
+    effect<TSchema extends SchemaInput | undefined = undefined, TInput = InferDefinedSchema<TSchema>, R = never, HandlerError = never>(def: {
         type: `${TNamespace}.${string}`;
         input?: TSchema;
         retry?: RetryPolicy;
-        execute: (input: TInput, ctx: ScopedEffectContext<EventInputOf<U>>) => EffectHandlerResult<R, EventInputOf<U>>;
-    }): NoInfer<EffectDefinition<TInput, R, E>>;
+        execution?: EffectExecution;
+        execute?: (input: TInput, ctx: ScopedEffectContext<EventInputOf<U>>) => EffectHandlerResult<R, EventInputOf<U>, HandlerError>;
+    }): NoInfer<EffectDefinition<TInput, R, EventInputOf<U>>>;
     input<K extends keyof (TEvents extends EventCatalog<any, infer E> ? E : never) & string>(key: K, payload: InferPayload<(TEvents extends EventCatalog<any, infer E> ? E : never)[K]>, meta?: Omit<EventInput, 'type' | 'payload'>): Omit<EventInput, 'type' | 'payload'> & {
         readonly type: `${TNamespace}.${K}`;
         readonly payload: InferPayload<(TEvents extends EventCatalog<any, infer E> ? E : never)[K]>;
@@ -92,6 +93,7 @@ export declare function defineModule<const N extends string, E extends EventCata
     readonly projections?: PR;
     readonly definitions?: readonly DefinitionRef[];
     readonly middleware?: readonly EffectMiddleware[];
+    readonly interruptsOnSignal?: SignalInterruptRule;
 } & ModuleServicesConfig<EffectRequirementsOf<FX>>): RuntimeModule<N, Extract<ModuleCatalog<N, E>, EventCatalog>, FX, TH, PR> & {
     readonly effects: FX;
     readonly threads: TH;

package/dist/core/module-scope.js

@@ -4,11 +4,7 @@ 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);
-    }
+function buildScopeInput(namespace, key, payload, meta) {
     return {
         ...meta,
         type: `${namespace}.${key}`,
@@ -33,40 +29,54 @@ export function createModuleScope(options) {
             return defineEffect(def);
         },
         input(key, payload, meta) {
-            return buildScopeInput(namespace, events, key, payload, meta);
+            return buildScopeInput(namespace, key, payload, meta);
         },
         emit(key, payload, meta) {
-            return emit(buildScopeInput(namespace, events, key, payload, meta));
+            return emit(buildScopeInput(namespace, 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. */
+function isEventCatalog(source) {
+    return 'namespace' in source && 'entries' in source;
+}
+function isModuleScope(source) {
+    return 'thread' in source && 'effect' in source;
+}
 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'
+    const events = source
+        ? isEventCatalog(source)
             ? source
-            : defineEventCatalog(options.namespace, source)));
-    const scope = typeof options.effect === 'function'
-        ? options
-        : createModuleScope({ ...options, events });
+            : defineEventCatalog(options.namespace, source)
+        : undefined;
+    const scope = isModuleScope(options) ? options : createModuleScope({ ...options, events });
     const members = setup(scope);
-    return {
+    const module = {
         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 ?? {}),
+        events,
+        effects: members.effects ?? {},
+        threads: members.threads ?? {},
+        projections: members.projections ?? {},
     };
+    if (options.observes) {
+        module.observes = options.observes;
+    }
+    if (options.dependencies) {
+        module.dependencies = options.dependencies;
+    }
+    if (members.definitions) {
+        module.definitions = members.definitions;
+    }
+    if (members.middleware) {
+        module.middleware = members.middleware;
+    }
+    if (members.services) {
+        module.services = members.services;
+    }
+    if (members.interruptsOnSignal) {
+        module.interruptsOnSignal = members.interruptsOnSignal;
+    }
+    return module;
 }
-/* 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

@@ -1,4 +1,4 @@
-import type { Effect, Layer } from 'effect';
+import type { Context, Effect, Layer } from 'effect';
 import type { EventCatalog } from './catalog';
 import type { EffectContext, EffectDefinition, RuntimeEffect } from './effects';
 import type { EventInput } from './envelope';
@@ -8,6 +8,12 @@ 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>;
+/**
+ * Names the threads whose in-process effects an admitted signal event interrupts, so a running
+ * effect (such as a model call) can stop early. Return an empty array when the event interrupts
+ * nothing.
+ */
+export type SignalInterruptRule = (event: EventInput) => readonly string[];
 export interface RuntimeModuleDependency {
     readonly namespace: string;
     readonly protocolVersion?: string;
@@ -16,12 +22,16 @@ export interface RuntimeModuleDependency {
 export interface DefinitionRef {
     readonly kind: string;
     readonly name: string;
+    readonly version?: string;
     readonly input?: SchemaInput | undefined;
 }
-/** A definition registered on a host, keyed by `${kind}:${name}`. */
+export declare const DEFAULT_DEFINITION_VERSION = "v1";
+export declare function definitionKey(kind: string, name: string, version: string): string;
+/** A definition registered on a host, keyed by `${kind}:${name}@${version}`. */
 export interface RegisteredDefinition {
     readonly kind: string;
     readonly name: string;
+    readonly version: string;
     readonly input?: SchemaInput | undefined;
     readonly value: DefinitionRef;
 }
@@ -44,7 +54,7 @@ export interface RuntimeModule<TNamespace extends string = string, TEvents exten
     readonly [key: string]: ProjectionDefinition;
 } = {
     readonly [key: string]: ProjectionDefinition;
-}, TServices = any> {
+}, TServices = Context.Service.Any> {
     readonly namespace: TNamespace;
     readonly protocolVersion: string;
     readonly events?: TEvents;
@@ -55,6 +65,7 @@ export interface RuntimeModule<TNamespace extends string = string, TEvents exten
     readonly definitions?: readonly DefinitionRef[];
     readonly dependencies?: readonly RuntimeModuleDependency[];
     readonly middleware?: readonly EffectMiddleware[];
+    readonly interruptsOnSignal?: SignalInterruptRule;
     /** Host-side services this module's effect handlers need (an LLM, a definition lookup, a DB pool). */
     readonly services?: () => Layer.Layer<TServices>;
 }
@@ -64,9 +75,9 @@ export declare function defineRuntimeModule<TNamespace extends string, TEvents e
     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>;
+}, TServices = Context.Service.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 [name: string]: EffectDefinition<any, any, any>;
 }, {
     readonly [kind: string]: ThreadDefinition;
 }, {

package/dist/core/module.js

@@ -1,3 +1,7 @@
+export const DEFAULT_DEFINITION_VERSION = 'v1';
+export function definitionKey(kind, name, version) {
+    return `${kind}:${name}@${version}`;
+}
 export function defineRuntimeModule(module) {
     return module;
 }

package/dist/core/projection.d.ts

@@ -1,6 +1,6 @@
 import { Schema, Stream, type Effect } from 'effect';
 import type { EventEnvelope } from './envelope';
-import type { InferSchemaOutput } from './schema';
+import type { InferSchemaOutput, SchemaInput } from './schema';
 import type { RunState, ThreadRecord } from './state';
 export interface ProjectionDefinition<S = unknown> {
     readonly name: string;
@@ -8,18 +8,18 @@ export interface ProjectionDefinition<S = 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 shape?: undefined;
     readonly initialState: S;
     reduce(state: S, event: EventEnvelope): S;
 }): ProjectionDefinition<S>;
+export declare function defineProjection<TShape extends SchemaInput>(def: {
+    readonly name: string;
+    readonly shape: TShape;
+    readonly initialState: InferSchemaOutput<TShape>;
+    reduce(state: NoInfer<InferSchemaOutput<TShape>>, event: EventEnvelope): InferSchemaOutput<TShape>;
+}): ProjectionDefinition<InferSchemaOutput<TShape>>;
 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;
@@ -29,6 +29,7 @@ export interface ThreadNode {
     threadId: string;
     kind: string;
     definitionName: string;
+    definitionVersion: string;
     status: ThreadRecord['status'];
     parentThreadId: string | null;
     children: ThreadNode[];
@@ -49,28 +50,27 @@ export interface TreeBuildState {
         [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 seq: Schema.Finite;
     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;
+    readonly ts: Schema.Finite;
 }>;
 export type TimelineEntry = Schema.Schema.Type<typeof TimelineEntrySchema>;
 export declare const TimelineSchema: Schema.mutable<Schema.$Array<Schema.Struct<{
-    readonly seq: Schema.Number;
+    readonly seq: Schema.Finite;
     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;
+    readonly ts: Schema.Finite;
 }>>>;
 export declare const timeline: ProjectionDefinition<{
     readonly seq: number;

package/dist/core/projection.js

@@ -1,4 +1,5 @@
 import { Predicate, Schema, Stream } from 'effect';
+import { DEFAULT_DEFINITION_VERSION } from './module.js';
 import { isTerminalStatus } from './thread.js';
 export function defineProjection(def) {
     return def;
@@ -26,8 +27,6 @@ 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 {};
@@ -40,7 +39,6 @@ function readString(obj, key) {
 }
 export const threadTree = defineProjection({
     name: 'threadTree',
-    shape: TreeBuildStateSchema,
     initialState: { runId: '', records: {}, rootThreadId: null },
     reduce(state, event) {
         const payload = readPayload(event);
@@ -57,6 +55,7 @@ export const threadTree = defineProjection({
                 const threadId = readString(payload, 'threadId') ?? event.threadId;
                 const kind = readString(payload, 'kind');
                 const definitionName = readString(payload, 'definitionName');
+                const definitionVersion = readString(payload, 'definitionVersion') ?? DEFAULT_DEFINITION_VERSION;
                 if (!threadId || !kind || !definitionName) {
                     return { ...state, runId: event.runId };
                 }
@@ -66,6 +65,7 @@ export const threadTree = defineProjection({
                     threadId,
                     kind,
                     definitionName,
+                    definitionVersion,
                     parentThreadId,
                     status: 'running',
                     input: payload.input ?? null,
@@ -173,10 +173,13 @@ export function toThreadTree(state) {
         runId: state.runId,
         status: 'running',
         rootThreadId: state.rootThreadId,
+        startIdentity: null,
         threads: state.records,
         waits: {},
         outstandingEffects: [],
+        effectExecutions: {},
         completedEffectIds: [],
+        processedIdempotencyKeys: [],
     });
 }
 export function treeFromRun(state) {
@@ -196,6 +199,7 @@ export function treeFromRun(state) {
             threadId: record.threadId,
             kind: record.kind,
             definitionName: record.definitionName,
+            definitionVersion: record.definitionVersion,
             status: isWaiting ? 'waiting' : record.status,
             parentThreadId: record.parentThreadId,
             children: (byParent.get(record.threadId) ?? []).map(toNode),
@@ -210,13 +214,13 @@ export function treeFromRun(state) {
     };
 }
 export const TimelineEntrySchema = Schema.Struct({
-    seq: Schema.Number,
+    seq: Schema.Finite,
     id: Schema.String,
     type: Schema.String,
     threadId: Schema.NullOr(Schema.String),
     causationId: Schema.NullOr(Schema.String),
     effectId: Schema.NullOr(Schema.String),
-    ts: Schema.Number,
+    ts: Schema.Finite,
 });
 export const TimelineSchema = Schema.mutable(Schema.Array(TimelineEntrySchema));
 export const timeline = defineProjection({

package/dist/core/protocol.d.ts

@@ -1,27 +1,27 @@
 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;
-}>]>;
+import { WaitConditionSchema, type WaitCondition } from './effects';
 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 definitionVersion: Schema.withDecodingDefaultKey<Schema.String, never>;
         readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly requestedThreadId: Schema.optional<Schema.NullOr<Schema.String>>;
     }>;
     'run.completed': Schema.Struct<{
         readonly output: Schema.NullOr<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
         readonly error: Schema.NullOr<Schema.String>;
     }>;
+    'run.cancelled': Schema.Struct<{
+        readonly reason: Schema.optional<Schema.String>;
+    }>;
     'thread.started': Schema.Struct<{
         readonly threadId: Schema.String;
         readonly kind: Schema.String;
         readonly definitionName: Schema.String;
+        readonly definitionVersion: Schema.withDecodingDefaultKey<Schema.String, never>;
         readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
         readonly parentThreadId: Schema.NullOr<Schema.String>;
     }>;
@@ -37,6 +37,9 @@ export declare const protocolCatalog: import("./catalog").EventCatalog<"runtime"
         readonly threadId: Schema.String;
         readonly reason: Schema.optional<Schema.String>;
     }>;
+    'thread.cancel.requested': Schema.Struct<{
+        readonly threadId: Schema.String;
+    }>;
     'wait.registered': Schema.Struct<{
         readonly waitId: Schema.String;
         readonly threadId: Schema.optional<Schema.String>;
@@ -44,7 +47,7 @@ export declare const protocolCatalog: import("./catalog").EventCatalog<"runtime"
             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 timerAt: Schema.Finite;
         }>]>;
         readonly tag: Schema.optional<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
     }>;
@@ -60,7 +63,7 @@ export declare const protocolCatalog: import("./catalog").EventCatalog<"runtime"
     'timer.set': Schema.Struct<{
         readonly timerId: Schema.String;
         readonly waitId: Schema.String;
-        readonly wakeAt: Schema.Number;
+        readonly wakeAt: Schema.Finite;
     }>;
     'timer.fired': Schema.Struct<{
         readonly timerId: Schema.String;
@@ -70,8 +73,62 @@ export declare const protocolCatalog: import("./catalog").EventCatalog<"runtime"
         readonly effectId: Schema.String;
         readonly error: Schema.String;
     }>;
+    'effect.attempt.started': Schema.Struct<{
+        readonly effectId: Schema.String;
+        readonly attempt: Schema.Finite;
+    }>;
+    'effect.queued': Schema.Struct<{
+        readonly effectId: Schema.String;
+        readonly attempt: Schema.Finite;
+        readonly deadlineAt: Schema.NullOr<Schema.Finite>;
+    }>;
+    'effect.dispatched': Schema.Struct<{
+        readonly effectId: Schema.String;
+        readonly attempt: Schema.Finite;
+        readonly deadlineAt: Schema.NullOr<Schema.Finite>;
+    }>;
+    'effect.worker.started': Schema.Struct<{
+        readonly effectId: Schema.String;
+        readonly attempt: Schema.Finite;
+        readonly deadlineAt: Schema.NullOr<Schema.Finite>;
+    }>;
+    'effect.heartbeat': Schema.Struct<{
+        readonly effectId: Schema.String;
+        readonly attempt: Schema.Finite;
+        readonly heartbeatAt: Schema.Finite;
+        readonly deadlineAt: Schema.NullOr<Schema.Finite>;
+    }>;
+    'effect.cancel.requested': Schema.Struct<{
+        readonly effectId: Schema.String;
+        readonly attempt: Schema.Finite;
+        readonly deadlineAt: Schema.NullOr<Schema.Finite>;
+    }>;
+    'effect.cancelled': Schema.Struct<{
+        readonly effectId: Schema.String;
+        readonly attempt: Schema.Finite;
+    }>;
+    'effect.completed': Schema.Struct<{
+        readonly effectId: Schema.String;
+        readonly attempt: Schema.Finite;
+    }>;
+    'effect.timed_out': Schema.Struct<{
+        readonly effectId: Schema.String;
+        readonly attempt: Schema.Finite;
+        readonly timeout: Schema.String;
+    }>;
+    'effect.ambiguous': Schema.Struct<{
+        readonly effectId: Schema.String;
+        readonly attempt: Schema.Finite;
+        readonly error: Schema.String;
+    }>;
+    'effect.retry.scheduled': Schema.Struct<{
+        readonly effectId: Schema.String;
+        readonly attempt: Schema.Finite;
+        readonly nextAttemptAt: Schema.Finite;
+        readonly error: Schema.String;
+    }>;
     'snapshot.taken': Schema.Struct<{
-        readonly seq: Schema.Number;
+        readonly seq: Schema.Finite;
         readonly stateHash: Schema.String;
         readonly state: Schema.optional<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
     }>;
@@ -81,7 +138,7 @@ export declare const protocolCatalog: import("./catalog").EventCatalog<"runtime"
 }>;
 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 declare const PROTOCOL_TYPES: readonly ['runtime.run.started', 'runtime.run.completed', 'runtime.run.cancelled', 'runtime.thread.started', 'runtime.thread.completed', 'runtime.thread.failed', 'runtime.thread.cancelled', 'runtime.thread.cancel.requested', 'runtime.wait.registered', 'runtime.wait.satisfied', 'runtime.timer.set', 'runtime.timer.fired', 'runtime.effect.failed', 'runtime.effect.attempt.started', 'runtime.effect.queued', 'runtime.effect.dispatched', 'runtime.effect.worker.started', 'runtime.effect.heartbeat', 'runtime.effect.cancel.requested', 'runtime.effect.cancelled', 'runtime.effect.completed', 'runtime.effect.timed_out', 'runtime.effect.ambiguous', 'runtime.effect.retry.scheduled', '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']>;