@swirls/looms 0.0.1 → 0.1.0

package/dist/core/protocol.js

@@ -1,29 +1,30 @@
-import { Schema } from 'effect';
+import { Effect, Schema } from 'effect';
 import { defineEventCatalog } from './catalog.js';
+import { WaitConditionSchema } from './effects.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]);
+import { DEFAULT_DEFINITION_VERSION } from './module.js';
+const DefinitionVersionSchema = Schema.String.pipe(Schema.withDecodingDefaultKey(Effect.succeed(DEFAULT_DEFINITION_VERSION)));
 export const protocolCatalog = defineEventCatalog('runtime', {
     'run.started': Schema.Struct({
         rootThreadId: Schema.optional(Schema.String),
         kind: Schema.String,
         definitionName: Schema.String,
+        definitionVersion: DefinitionVersionSchema,
         input: JsonValueSchema,
+        requestedThreadId: Schema.optional(Schema.NullOr(Schema.String)),
     }),
     'run.completed': Schema.Struct({
         output: Schema.NullOr(JsonValueSchema),
         error: Schema.NullOr(Schema.String),
     }),
+    'run.cancelled': Schema.Struct({
+        reason: Schema.optional(Schema.String),
+    }),
     'thread.started': Schema.Struct({
         threadId: Schema.String,
         kind: Schema.String,
         definitionName: Schema.String,
+        definitionVersion: DefinitionVersionSchema,
         input: JsonValueSchema,
         parentThreadId: Schema.NullOr(Schema.String),
     }),
@@ -39,6 +40,9 @@ export const protocolCatalog = defineEventCatalog('runtime', {
         threadId: Schema.String,
         reason: Schema.optional(Schema.String),
     }),
+    'thread.cancel.requested': Schema.Struct({
+        threadId: Schema.String,
+    }),
     'wait.registered': Schema.Struct({
         waitId: Schema.String,
         threadId: Schema.optional(Schema.String),
@@ -57,7 +61,7 @@ export const protocolCatalog = defineEventCatalog('runtime', {
     'timer.set': Schema.Struct({
         timerId: Schema.String,
         waitId: Schema.String,
-        wakeAt: Schema.Number,
+        wakeAt: Schema.Finite,
     }),
     'timer.fired': Schema.Struct({
         timerId: Schema.String,
@@ -67,8 +71,62 @@ export const protocolCatalog = defineEventCatalog('runtime', {
         effectId: Schema.String,
         error: Schema.String,
     }),
+    'effect.attempt.started': Schema.Struct({
+        effectId: Schema.String,
+        attempt: Schema.Finite,
+    }),
+    'effect.queued': Schema.Struct({
+        effectId: Schema.String,
+        attempt: Schema.Finite,
+        deadlineAt: Schema.NullOr(Schema.Finite),
+    }),
+    'effect.dispatched': Schema.Struct({
+        effectId: Schema.String,
+        attempt: Schema.Finite,
+        deadlineAt: Schema.NullOr(Schema.Finite),
+    }),
+    'effect.worker.started': Schema.Struct({
+        effectId: Schema.String,
+        attempt: Schema.Finite,
+        deadlineAt: Schema.NullOr(Schema.Finite),
+    }),
+    'effect.heartbeat': Schema.Struct({
+        effectId: Schema.String,
+        attempt: Schema.Finite,
+        heartbeatAt: Schema.Finite,
+        deadlineAt: Schema.NullOr(Schema.Finite),
+    }),
+    'effect.cancel.requested': Schema.Struct({
+        effectId: Schema.String,
+        attempt: Schema.Finite,
+        deadlineAt: Schema.NullOr(Schema.Finite),
+    }),
+    'effect.cancelled': Schema.Struct({
+        effectId: Schema.String,
+        attempt: Schema.Finite,
+    }),
+    'effect.completed': Schema.Struct({
+        effectId: Schema.String,
+        attempt: Schema.Finite,
+    }),
+    'effect.timed_out': Schema.Struct({
+        effectId: Schema.String,
+        attempt: Schema.Finite,
+        timeout: Schema.String,
+    }),
+    'effect.ambiguous': Schema.Struct({
+        effectId: Schema.String,
+        attempt: Schema.Finite,
+        error: Schema.String,
+    }),
+    'effect.retry.scheduled': Schema.Struct({
+        effectId: Schema.String,
+        attempt: Schema.Finite,
+        nextAttemptAt: Schema.Finite,
+        error: Schema.String,
+    }),
     'snapshot.taken': Schema.Struct({
-        seq: Schema.Number,
+        seq: Schema.Finite,
         stateHash: Schema.String,
         state: Schema.optional(JsonValueSchema),
     }),
@@ -79,15 +137,28 @@ export const protocolCatalog = defineEventCatalog('runtime', {
 export const PROTOCOL_TYPES = [
     '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',
 ];

package/dist/core/replay.d.ts

@@ -1,5 +1,6 @@
-import type { RuntimeEffect } from './effects';
-import type { EventEnvelope } from './envelope';
+import { Schema } from 'effect';
+import { type RuntimeEffect } from './effects';
+import { type EventEnvelope } from './envelope';
 import { type FoldRegistry } from './fold';
 import { type RunState } from './state';
 export interface ReplayStep {
@@ -7,7 +8,315 @@ export interface ReplayStep {
     event: EventEnvelope;
     before: RunState;
     after: RunState;
-    effects: RuntimeEffect[];
+    effects: readonly RuntimeEffect[];
 }
+export declare const ReplayStepSchema: Schema.Struct<{
+    readonly seq: Schema.Finite;
+    readonly event: Schema.Struct<{
+        readonly id: Schema.String;
+        readonly runId: Schema.String;
+        readonly seq: Schema.Finite;
+        readonly ts: Schema.Finite;
+        readonly type: Schema.String;
+        readonly payload: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly threadId: Schema.NullOr<Schema.String>;
+        readonly parentThreadId: Schema.optional<Schema.NullOr<Schema.String>>;
+        readonly causationId: Schema.optional<Schema.NullOr<Schema.String>>;
+        readonly correlationId: Schema.optional<Schema.NullOr<Schema.String>>;
+        readonly effectId: Schema.optional<Schema.NullOr<Schema.String>>;
+        readonly origin: Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"thread">;
+            readonly threadId: Schema.String;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"external">;
+            readonly actorId: Schema.optional<Schema.String>;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"system">;
+        }>]>;
+        readonly ephemeral: Schema.optional<Schema.Boolean>;
+        readonly idempotencyKey: Schema.optional<Schema.NullOr<Schema.String>>;
+    }>;
+    readonly before: Schema.Struct<{
+        readonly runId: Schema.String;
+        readonly status: Schema.Union<readonly [Schema.Literal<"running">, Schema.Literal<"completed">, Schema.Literal<"failed">, Schema.Literal<"cancelled">]>;
+        readonly rootThreadId: Schema.NullOr<Schema.String>;
+        readonly startIdentity: Schema.withDecodingDefaultKey<Schema.NullOr<Schema.Struct<{
+            readonly kind: Schema.String;
+            readonly definitionName: Schema.String;
+            readonly definitionVersion: Schema.String;
+            readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly requestedThreadId: Schema.NullOr<Schema.String>;
+            readonly idempotencyKey: Schema.NullOr<Schema.String>;
+            readonly rootThreadId: Schema.String;
+        }>>, never>;
+        readonly threads: Schema.$Record<Schema.String, Schema.Struct<{
+            readonly threadId: Schema.String;
+            readonly kind: Schema.String;
+            readonly definitionName: Schema.String;
+            readonly definitionVersion: Schema.withDecodingDefaultKey<Schema.String, never>;
+            readonly parentThreadId: Schema.NullOr<Schema.String>;
+            readonly status: Schema.Union<readonly [Schema.Literal<"running">, Schema.Literal<"waiting">, Schema.Literal<"completed">, Schema.Literal<"failed">, Schema.Literal<"cancelled">]>;
+            readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly output: Schema.NullOr<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+            readonly error: Schema.NullOr<Schema.String>;
+            readonly state: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        }>>;
+        readonly waits: Schema.$Record<Schema.String, Schema.Struct<{
+            readonly waitId: Schema.String;
+            readonly threadId: 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.Finite;
+            }>]>;
+            readonly tag: Schema.optional<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+        }>>;
+        readonly outstandingEffects: Schema.$Array<Schema.Struct<{
+            readonly effectId: Schema.String;
+            readonly threadId: Schema.String;
+            readonly causingSeq: Schema.Finite;
+            readonly causingEventId: Schema.String;
+            readonly effect: Schema.Union<readonly [Schema.Struct<{
+                readonly type: Schema.Literal<"runtime.spawn">;
+                readonly childThreadId: 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>;
+            }>, Schema.Struct<{
+                readonly type: Schema.Literal<"runtime.wait">;
+                readonly waitId: 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.Finite;
+                }>]>;
+                readonly tag: Schema.optional<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+            }>, Schema.Struct<{
+                readonly type: Schema.Literal<"runtime.emit">;
+                readonly event: Schema.Struct<{
+                    readonly type: Schema.String;
+                    readonly payload: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+                    readonly threadId: Schema.optional<Schema.NullOr<Schema.String>>;
+                    readonly parentThreadId: Schema.optional<Schema.NullOr<Schema.String>>;
+                    readonly causationId: Schema.optional<Schema.NullOr<Schema.String>>;
+                    readonly correlationId: Schema.optional<Schema.NullOr<Schema.String>>;
+                    readonly effectId: Schema.optional<Schema.NullOr<Schema.String>>;
+                    readonly origin: Schema.optional<Schema.Union<readonly [Schema.Struct<{
+                        readonly type: Schema.Literal<"thread">;
+                        readonly threadId: Schema.String;
+                    }>, Schema.Struct<{
+                        readonly type: Schema.Literal<"external">;
+                        readonly actorId: Schema.optional<Schema.String>;
+                    }>, Schema.Struct<{
+                        readonly type: Schema.Literal<"system">;
+                    }>]>>;
+                    readonly ephemeral: Schema.optional<Schema.Boolean>;
+                    readonly id: Schema.optional<Schema.String>;
+                    readonly ts: Schema.optional<Schema.Finite>;
+                    readonly idempotencyKey: Schema.optional<Schema.NullOr<Schema.String>>;
+                }>;
+                readonly tag: Schema.optional<Schema.String>;
+            }>, Schema.Struct<{
+                readonly type: Schema.Literal<"runtime.complete">;
+                readonly output: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            }>, Schema.Struct<{
+                readonly type: Schema.Literal<"runtime.fail">;
+                readonly error: Schema.String;
+            }>, Schema.Struct<{
+                readonly type: Schema.Literal<"runtime.cancel">;
+                readonly threadId: Schema.String;
+                readonly tag: Schema.optional<Schema.String>;
+            }>, Schema.Struct<{
+                readonly type: Schema.String;
+                readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+                readonly tag: Schema.optional<Schema.String>;
+            }>]>;
+        }>>;
+        readonly effectExecutions: Schema.withDecodingDefaultKey<Schema.$Record<Schema.String, Schema.Struct<{
+            readonly effectId: Schema.String;
+            readonly attempt: Schema.Finite;
+            readonly status: Schema.Union<readonly [Schema.Literal<"queued">, Schema.Literal<"dispatched">, Schema.Literal<"started">, Schema.Literal<"heartbeat">, Schema.Literal<"retry_wait">, Schema.Literal<"cancel_requested">, Schema.Literal<"timed_out">, Schema.Literal<"ambiguous">, Schema.Literal<"running">]>;
+            readonly nextAttemptAt: Schema.NullOr<Schema.Finite>;
+            readonly deadlineAt: Schema.withDecodingDefaultKey<Schema.NullOr<Schema.Finite>, never>;
+            readonly startedAt: Schema.withDecodingDefaultKey<Schema.NullOr<Schema.Finite>, never>;
+            readonly lastHeartbeatAt: Schema.withDecodingDefaultKey<Schema.NullOr<Schema.Finite>, never>;
+            readonly lastError: Schema.NullOr<Schema.String>;
+        }>>, never>;
+        readonly completedEffectIds: Schema.withDecodingDefaultKey<Schema.$Array<Schema.String>, never>;
+        readonly processedIdempotencyKeys: Schema.withDecodingDefaultKey<Schema.$Array<Schema.String>, never>;
+    }>;
+    readonly after: Schema.Struct<{
+        readonly runId: Schema.String;
+        readonly status: Schema.Union<readonly [Schema.Literal<"running">, Schema.Literal<"completed">, Schema.Literal<"failed">, Schema.Literal<"cancelled">]>;
+        readonly rootThreadId: Schema.NullOr<Schema.String>;
+        readonly startIdentity: Schema.withDecodingDefaultKey<Schema.NullOr<Schema.Struct<{
+            readonly kind: Schema.String;
+            readonly definitionName: Schema.String;
+            readonly definitionVersion: Schema.String;
+            readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly requestedThreadId: Schema.NullOr<Schema.String>;
+            readonly idempotencyKey: Schema.NullOr<Schema.String>;
+            readonly rootThreadId: Schema.String;
+        }>>, never>;
+        readonly threads: Schema.$Record<Schema.String, Schema.Struct<{
+            readonly threadId: Schema.String;
+            readonly kind: Schema.String;
+            readonly definitionName: Schema.String;
+            readonly definitionVersion: Schema.withDecodingDefaultKey<Schema.String, never>;
+            readonly parentThreadId: Schema.NullOr<Schema.String>;
+            readonly status: Schema.Union<readonly [Schema.Literal<"running">, Schema.Literal<"waiting">, Schema.Literal<"completed">, Schema.Literal<"failed">, Schema.Literal<"cancelled">]>;
+            readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly output: Schema.NullOr<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+            readonly error: Schema.NullOr<Schema.String>;
+            readonly state: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        }>>;
+        readonly waits: Schema.$Record<Schema.String, Schema.Struct<{
+            readonly waitId: Schema.String;
+            readonly threadId: 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.Finite;
+            }>]>;
+            readonly tag: Schema.optional<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+        }>>;
+        readonly outstandingEffects: Schema.$Array<Schema.Struct<{
+            readonly effectId: Schema.String;
+            readonly threadId: Schema.String;
+            readonly causingSeq: Schema.Finite;
+            readonly causingEventId: Schema.String;
+            readonly effect: Schema.Union<readonly [Schema.Struct<{
+                readonly type: Schema.Literal<"runtime.spawn">;
+                readonly childThreadId: 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>;
+            }>, Schema.Struct<{
+                readonly type: Schema.Literal<"runtime.wait">;
+                readonly waitId: 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.Finite;
+                }>]>;
+                readonly tag: Schema.optional<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+            }>, Schema.Struct<{
+                readonly type: Schema.Literal<"runtime.emit">;
+                readonly event: Schema.Struct<{
+                    readonly type: Schema.String;
+                    readonly payload: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+                    readonly threadId: Schema.optional<Schema.NullOr<Schema.String>>;
+                    readonly parentThreadId: Schema.optional<Schema.NullOr<Schema.String>>;
+                    readonly causationId: Schema.optional<Schema.NullOr<Schema.String>>;
+                    readonly correlationId: Schema.optional<Schema.NullOr<Schema.String>>;
+                    readonly effectId: Schema.optional<Schema.NullOr<Schema.String>>;
+                    readonly origin: Schema.optional<Schema.Union<readonly [Schema.Struct<{
+                        readonly type: Schema.Literal<"thread">;
+                        readonly threadId: Schema.String;
+                    }>, Schema.Struct<{
+                        readonly type: Schema.Literal<"external">;
+                        readonly actorId: Schema.optional<Schema.String>;
+                    }>, Schema.Struct<{
+                        readonly type: Schema.Literal<"system">;
+                    }>]>>;
+                    readonly ephemeral: Schema.optional<Schema.Boolean>;
+                    readonly id: Schema.optional<Schema.String>;
+                    readonly ts: Schema.optional<Schema.Finite>;
+                    readonly idempotencyKey: Schema.optional<Schema.NullOr<Schema.String>>;
+                }>;
+                readonly tag: Schema.optional<Schema.String>;
+            }>, Schema.Struct<{
+                readonly type: Schema.Literal<"runtime.complete">;
+                readonly output: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            }>, Schema.Struct<{
+                readonly type: Schema.Literal<"runtime.fail">;
+                readonly error: Schema.String;
+            }>, Schema.Struct<{
+                readonly type: Schema.Literal<"runtime.cancel">;
+                readonly threadId: Schema.String;
+                readonly tag: Schema.optional<Schema.String>;
+            }>, Schema.Struct<{
+                readonly type: Schema.String;
+                readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+                readonly tag: Schema.optional<Schema.String>;
+            }>]>;
+        }>>;
+        readonly effectExecutions: Schema.withDecodingDefaultKey<Schema.$Record<Schema.String, Schema.Struct<{
+            readonly effectId: Schema.String;
+            readonly attempt: Schema.Finite;
+            readonly status: Schema.Union<readonly [Schema.Literal<"queued">, Schema.Literal<"dispatched">, Schema.Literal<"started">, Schema.Literal<"heartbeat">, Schema.Literal<"retry_wait">, Schema.Literal<"cancel_requested">, Schema.Literal<"timed_out">, Schema.Literal<"ambiguous">, Schema.Literal<"running">]>;
+            readonly nextAttemptAt: Schema.NullOr<Schema.Finite>;
+            readonly deadlineAt: Schema.withDecodingDefaultKey<Schema.NullOr<Schema.Finite>, never>;
+            readonly startedAt: Schema.withDecodingDefaultKey<Schema.NullOr<Schema.Finite>, never>;
+            readonly lastHeartbeatAt: Schema.withDecodingDefaultKey<Schema.NullOr<Schema.Finite>, never>;
+            readonly lastError: Schema.NullOr<Schema.String>;
+        }>>, never>;
+        readonly completedEffectIds: Schema.withDecodingDefaultKey<Schema.$Array<Schema.String>, never>;
+        readonly processedIdempotencyKeys: Schema.withDecodingDefaultKey<Schema.$Array<Schema.String>, never>;
+    }>;
+    readonly effects: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"runtime.spawn">;
+        readonly childThreadId: 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>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"runtime.wait">;
+        readonly waitId: 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.Finite;
+        }>]>;
+        readonly tag: Schema.optional<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"runtime.emit">;
+        readonly event: Schema.Struct<{
+            readonly type: Schema.String;
+            readonly payload: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly threadId: Schema.optional<Schema.NullOr<Schema.String>>;
+            readonly parentThreadId: Schema.optional<Schema.NullOr<Schema.String>>;
+            readonly causationId: Schema.optional<Schema.NullOr<Schema.String>>;
+            readonly correlationId: Schema.optional<Schema.NullOr<Schema.String>>;
+            readonly effectId: Schema.optional<Schema.NullOr<Schema.String>>;
+            readonly origin: Schema.optional<Schema.Union<readonly [Schema.Struct<{
+                readonly type: Schema.Literal<"thread">;
+                readonly threadId: Schema.String;
+            }>, Schema.Struct<{
+                readonly type: Schema.Literal<"external">;
+                readonly actorId: Schema.optional<Schema.String>;
+            }>, Schema.Struct<{
+                readonly type: Schema.Literal<"system">;
+            }>]>>;
+            readonly ephemeral: Schema.optional<Schema.Boolean>;
+            readonly id: Schema.optional<Schema.String>;
+            readonly ts: Schema.optional<Schema.Finite>;
+            readonly idempotencyKey: Schema.optional<Schema.NullOr<Schema.String>>;
+        }>;
+        readonly tag: Schema.optional<Schema.String>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"runtime.complete">;
+        readonly output: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"runtime.fail">;
+        readonly error: Schema.String;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"runtime.cancel">;
+        readonly threadId: Schema.String;
+        readonly tag: Schema.optional<Schema.String>;
+    }>, Schema.Struct<{
+        readonly type: Schema.String;
+        readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly tag: Schema.optional<Schema.String>;
+    }>]>>;
+}>;
 export declare function replayTo(events: readonly EventEnvelope[], registry: FoldRegistry, seq: number): ReplayStep | null;
 export declare function replayAll(events: readonly EventEnvelope[], registry: FoldRegistry): ReplayStep[];

package/dist/core/replay.js

@@ -1,5 +1,15 @@
+import { Schema } from 'effect';
+import { RuntimeEffectSchema } from './effects.js';
+import { EventEnvelopeSchema } from './envelope.js';
 import { foldEvent, foldRun } from './fold.js';
-import { emptyRunState } from './state.js';
+import { emptyRunState, RunStateSchema } from './state.js';
+export const ReplayStepSchema = Schema.Struct({
+    seq: Schema.Finite,
+    event: EventEnvelopeSchema,
+    before: RunStateSchema,
+    after: RunStateSchema,
+    effects: Schema.Array(RuntimeEffectSchema),
+});
 export function replayTo(events, registry, seq) {
     const target = events.find((event) => event.seq === seq && !event.ephemeral);
     if (!target) {

package/dist/core/schema.d.ts

@@ -11,25 +11,14 @@ export declare class InvalidInputError extends InvalidInputError_base<{
     readonly issues: ReadonlyArray<StandardSchemaV1.Issue>;
     constructor(text: string, issues?: ReadonlyArray<StandardSchemaV1.Issue>);
 }
-export type SchemaInput = StandardSchemaV1<any, any> | Schema.Top | Schema.Schema<any> | {
-    _output: any;
-};
-export type InferSchemaOutput<T> = T extends Schema.Schema<infer Out> ? Out : T extends Schema.Top ? Schema.Schema.Type<T> : T extends StandardSchemaV1<any, infer Out> ? Out : T extends {
-    _output: infer Out;
-} ? Out : never;
+export type SchemaInput = StandardSchemaV1<any, any> | Schema.ConstraintDecoder<unknown>;
+export type InferSchemaOutput<T> = T extends Schema.Schema<infer Out> ? Out : T extends Schema.ConstraintDecoder<unknown> ? Schema.Schema.Type<T> : T extends StandardSchemaV1<any, infer Out> ? Out : never;
 /** Output of an optional `input` / `shape` schema, or `TFallback` when the schema is omitted. */
 export type InferDefinedSchema<T, TFallback = JsonValue> = [T] extends [undefined] ? TFallback : InferSchemaOutput<NonNullable<T>>;
-type SchemaCandidate<TInput> = StandardSchemaV1<JsonValue, TInput> | StandardSchemaV1<unknown, TInput> | StandardSchemaV1<any, TInput> | Schema.Schema<TInput> | {
-    _output: TInput;
-} | {
-    input?: StandardSchemaV1<JsonValue, TInput> | StandardSchemaV1<unknown, TInput> | StandardSchemaV1<any, TInput> | Schema.Schema<TInput> | {
-        _output: TInput;
-    };
-    schema?: StandardSchemaV1<JsonValue, TInput> | StandardSchemaV1<unknown, TInput> | StandardSchemaV1<any, TInput> | Schema.Schema<TInput> | {
-        _output: TInput;
-    };
-} | null | undefined;
-export declare function validateInputEffect<TInput = JsonValue>(schemaOrDef: SchemaCandidate<TInput>, raw: JsonValue): Effect.Effect<TInput, InvalidInputError>;
-export declare function validateInput<TInput = JsonValue>(schemaOrDef: SchemaCandidate<TInput>, raw: JsonValue): Promise<TInput>;
-export declare function validateInputSync<TInput = JsonValue>(schemaOrDef: SchemaCandidate<TInput>, raw: JsonValue): TInput;
+type ValidatedInput<TSchema extends SchemaInput | null | undefined> = TSchema extends SchemaInput ? InferSchemaOutput<TSchema> : JsonValue;
+export declare function validateInputEffect<TSchema extends SchemaInput | null | undefined>(schema: TSchema, raw: JsonValue): Effect.Effect<ValidatedInput<TSchema>, InvalidInputError>;
+export declare function validateInput<TSchema extends SchemaInput>(schema: TSchema, raw: JsonValue): Promise<InferSchemaOutput<TSchema>>;
+export declare function validateInput(schema: null | undefined, raw: JsonValue): Promise<JsonValue>;
+export declare function validateInputSync<TSchema extends SchemaInput>(schema: TSchema, raw: JsonValue): InferSchemaOutput<TSchema>;
+export declare function validateInputSync(schema: null | undefined, raw: JsonValue): JsonValue;
 export {};