@swirls/looms 0.0.2 → 0.1.0

package/dist/core/schema.js

@@ -7,65 +7,17 @@ export class InvalidInputError extends Data.TaggedError('InvalidInputError') {
         this.issues = issues;
     }
 }
-function toStandard(candidate) {
-    if (!candidate) {
-        return undefined;
-    }
-    if (Schema.isSchema(candidate)) {
-        // SAFETY: Effect Schema converts to StandardSchemaV1 via official helper.
-        return Schema.toStandardSchemaV1(candidate);
-    }
-    if (Predicate.isObject(candidate) && '~standard' in candidate) {
-        // SAFETY: verified '~standard' property exists on object.
-        return candidate;
+function isStandardSchema(candidate) {
+    if (!Predicate.isReadonlyObject(candidate) || !('~standard' in candidate)) {
+        return false;
     }
-    if (Predicate.isObject(candidate) && 'safeParse' in candidate) {
-        // SAFETY: candidate has safeParse property verified by key check.
-        const safeParse = candidate.safeParse;
-        if (Predicate.isFunction(safeParse)) {
-            // SAFETY: verified safeParse is a function matching the Zod safeParse contract.
-            const zodSchema = candidate;
-            return {
-                '~standard': {
-                    version: 1,
-                    vendor: 'zod-compat',
-                    validate(raw) {
-                        const res = zodSchema.safeParse(raw);
-                        if (res.success) {
-                            return { value: res.data };
-                        }
-                        return {
-                            issues: res.error.issues.map((issue) => ({
-                                message: issue.message,
-                                path: issue.path,
-                            })),
-                        };
-                    },
-                },
-            };
-        }
-    }
-    return undefined;
+    const standard = candidate['~standard'];
+    return (Predicate.isReadonlyObject(standard) &&
+        'validate' in standard &&
+        Predicate.isFunction(standard.validate));
 }
-function extractSchema(schemaOrDef) {
-    const direct = toStandard(schemaOrDef);
-    if (direct) {
-        return direct;
-    }
-    if (schemaOrDef && Predicate.isObject(schemaOrDef)) {
-        if ('schema' in schemaOrDef) {
-            // SAFETY: verified schemaOrDef has schema property.
-            const fromSchema = toStandard(schemaOrDef.schema);
-            if (fromSchema) {
-                return fromSchema;
-            }
-        }
-        if ('input' in schemaOrDef) {
-            // SAFETY: Verified schemaOrDef has input property.
-            return toStandard(schemaOrDef.input);
-        }
-    }
-    return undefined;
+function toStandard(candidate) {
+    return isStandardSchema(candidate) ? candidate : Schema.toStandardSchemaV1(candidate);
 }
 function formatIssue(issue) {
     if (!issue.path || issue.path.length === 0) {
@@ -85,39 +37,33 @@ function formatIssue(issue) {
         .join('.');
     return `${pathStr}: ${issue.message}`;
 }
-export function validateInputEffect(schemaOrDef, raw) {
-    const schema = extractSchema(schemaOrDef);
+function decodeInput(schema, raw) {
     if (!schema) {
-        // SAFETY: when no schema is provided, raw JsonValue is accepted as TInput.
         return Effect.succeed(raw);
     }
-    return Effect.gen(function* () {
-        let result = schema['~standard'].validate(raw);
-        if (result instanceof Promise) {
-            result = yield* Effect.tryPromise({
-                // SAFETY: Standard Schema validate() returns this Promise when async.
-                try: () => result,
-                catch: (cause) => new InvalidInputError(`Schema validation failed: ${cause instanceof Error ? cause.message : String(cause)}`),
-            });
-        }
+    const standard = toStandard(schema);
+    return Effect.tryPromise({
+        try: () => Promise.resolve(standard['~standard'].validate(raw)),
+        catch: (cause) => new InvalidInputError(`Schema validation failed: ${cause instanceof Error ? cause.message : String(cause)}`),
+    }).pipe(Effect.flatMap((result) => {
         if (result.issues !== undefined) {
             const text = result.issues.map(formatIssue).join(', ');
-            return yield* Effect.fail(new InvalidInputError(`Invalid input: ${text}`, result.issues));
+            return new InvalidInputError(`Invalid input: ${text}`, result.issues);
         }
-        return result.value;
-    });
+        return Effect.succeed(result.value);
+    }));
+}
+export function validateInputEffect(schema, raw) {
+    return decodeInput(schema, raw);
 }
-export async function validateInput(schemaOrDef, raw) {
-    return Effect.runPromise(validateInputEffect(schemaOrDef, raw));
+export function validateInput(schema, raw) {
+    return Effect.runPromise(decodeInput(schema, raw));
 }
-export function validateInputSync(schemaOrDef, raw) {
-    const schema = extractSchema(schemaOrDef);
+export function validateInputSync(schema, raw) {
     if (!schema) {
-        // SAFETY: when no schema is provided, raw JsonValue is accepted as TInput.
         return raw;
     }
-    // SAFETY: StandardSchemaV1.validate returns Result<TInput> or Promise<Result<TInput>>.
-    const result = schema['~standard'].validate(raw);
+    const result = toStandard(schema)['~standard'].validate(raw);
     if (result instanceof Promise) {
         throw new Error('Async schema validation is not supported in synchronous context');
     }
@@ -125,6 +71,5 @@ export function validateInputSync(schemaOrDef, raw) {
         const text = result.issues.map(formatIssue).join(', ');
         throw new InvalidInputError(`Invalid input: ${text}`, result.issues);
     }
-    // SAFETY: When result.issues is undefined, result is SuccessResult.
     return result.value;
 }

package/dist/core/serialize.js

@@ -23,11 +23,9 @@ export function createKeyedSerializer() {
         tails.set(key, cleanup);
         return next;
     };
-    const drain = async (key) => {
+    const drain = (key) => {
         const pending = tails.get(key);
-        if (pending) {
-            await pending;
-        }
+        return pending ? pending.then(() => undefined) : Promise.resolve();
     };
     const clear = (key) => {
         if (key !== undefined) {

package/dist/core/snapshot-store.d.ts

@@ -1,4 +1,5 @@
 import { Context, Effect, Option } from 'effect';
+import { SnapshotPayloadTooLargeError } from './limits';
 import type { RunState } from './state';
 import type { EventStore } from './store';
 /**
@@ -25,7 +26,7 @@ export declare class SnapshotStoreError extends SnapshotStoreError_base<{
 }
 export interface SnapshotStore {
     readonly loadLatest: (runId: string) => Effect.Effect<Option.Option<RunSnapshot>, SnapshotStoreError>;
-    readonly save: (snapshot: RunSnapshot) => Effect.Effect<void, SnapshotStoreError>;
+    readonly save: (snapshot: RunSnapshot) => Effect.Effect<void, SnapshotStoreError | SnapshotPayloadTooLargeError>;
     readonly listCursors?: (runId: string) => Effect.Effect<number[], SnapshotStoreError>;
     readonly prune?: (runId: string, keepLatest: number) => Effect.Effect<void, SnapshotStoreError>;
 }

package/dist/core/snapshot-store.js

@@ -1,4 +1,5 @@
 import { Context, Data, Effect, Option, Ref } from 'effect';
+import { assertSnapshotByteLimit, SnapshotPayloadTooLargeError } from './limits.js';
 export class SnapshotStoreError extends Data.TaggedError('SnapshotStoreError') {
     constructor(text, cause) {
         super({ message: text, cause });
@@ -29,12 +30,17 @@ export const makeMemorySnapshotStore = Effect.gen(function* () {
             }
             return Option.some(list[list.length - 1]);
         }),
-        save: (snapshot) => Ref.update(snapshots, (map) => {
+        save: (snapshot) => Effect.try({
+            try: () => assertSnapshotByteLimit(snapshot),
+            catch: (cause) => cause instanceof SnapshotPayloadTooLargeError
+                ? cause
+                : new SnapshotStoreError('snapshot size validation failed', cause),
+        }).pipe(Effect.andThen(Ref.update(snapshots, (map) => {
             const next = new Map(map);
             const existing = next.get(snapshot.runId) ?? [];
             next.set(snapshot.runId, [...existing, snapshot]);
             return next;
-        }),
+        }))),
         listCursors: (runId) => Effect.gen(function* () {
             const map = yield* Ref.get(snapshots);
             return (map.get(runId) ?? []).map((item) => item.cursor);

package/dist/core/snapshots.d.ts

@@ -5,7 +5,7 @@ import { type RunState } from './state';
 import { type JsonValue } from './types';
 export declare const DEFAULT_SNAPSHOT_EVERY = 200;
 export declare const SnapshotTakenPayloadSchema: 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>>;
 }>;
@@ -16,6 +16,10 @@ export declare function runStateToJson(state: RunState): JsonValue;
 export declare function buildSnapshotEvent(runId: string, events: readonly EventEnvelope[], registry: FoldRegistry, options?: {
     includeState?: boolean;
 }): EventEnvelope;
+/**
+ * Pointer-only snapshot marker. Inline `state` only when provided and
+ * serialized state is at most `maxInlineBytes` (default 256 KiB).
+ */
 export declare function buildSnapshotMarker(runId: string, cursor: number, stateHash: string, options?: {
     state?: RunState;
     maxInlineBytes?: number;

package/dist/core/snapshots.js

@@ -3,16 +3,17 @@ import { bytesToHex } from '@noble/hashes/utils.js';
 import { Schema } from 'effect';
 import { createEvent, JsonValueSchema } from './envelope.js';
 import { foldRun } from './fold.js';
-import { emptyRunState } from './state.js';
-import { asJson, fromJsonStruct } from './types.js';
+import { utf8JsonBytes } from './limits.js';
+import { emptyRunState, RunStateSchema } from './state.js';
+import { asJson, stringifyJson } from './types.js';
 export const DEFAULT_SNAPSHOT_EVERY = 200;
 export const SnapshotTakenPayloadSchema = Schema.Struct({
-    seq: Schema.Number,
+    seq: Schema.Finite,
     stateHash: Schema.String,
     state: Schema.optional(JsonValueSchema),
 });
 export function hashRunState(state) {
-    const json = JSON.stringify(state);
+    const json = stringifyJson(state);
     return bytesToHex(sha256(new TextEncoder().encode(json))).slice(0, 16);
 }
 export function shouldTakeSnapshot(events, every = DEFAULT_SNAPSHOT_EVERY) {
@@ -33,8 +34,7 @@ export function shouldTakeSnapshot(events, every = DEFAULT_SNAPSHOT_EVERY) {
 }
 export const DEFAULT_MAX_INLINE_SNAPSHOT_BYTES = 256 * 1024;
 export function runStateToJson(state) {
-    const raw = JSON.parse(JSON.stringify(state));
-    return Schema.decodeUnknownSync(JsonValueSchema)(raw);
+    return asJson(state);
 }
 export function buildSnapshotEvent(runId, events, registry, options) {
     const state = foldRun(events, registry, { runId });
@@ -45,22 +45,17 @@ export function buildSnapshotEvent(runId, events, registry, options) {
 }
 /**
  * Pointer-only snapshot marker. Inline `state` only when provided and
- * `JSON.stringify(state).length <= maxInlineBytes` (default 256 KiB).
+ * serialized state is at most `maxInlineBytes` (default 256 KiB).
  */
-let warnedInlineSkip = false;
 export function buildSnapshotMarker(runId, cursor, stateHash, options) {
     const maxInlineBytes = options?.maxInlineBytes ?? DEFAULT_MAX_INLINE_SNAPSHOT_BYTES;
     let payload = asJson({ seq: cursor, stateHash });
     if (options?.state !== undefined) {
         const encoded = runStateToJson(options.state);
-        const bytes = JSON.stringify(encoded).length;
+        const bytes = utf8JsonBytes(encoded);
         if (bytes <= maxInlineBytes) {
             payload = asJson({ seq: cursor, stateHash, state: encoded });
         }
-        else if (!warnedInlineSkip) {
-            warnedInlineSkip = true;
-            console.warn(`[looms] snapshot state is ${bytes} bytes (limit ${maxInlineBytes}); writing a pointer-only marker`);
-        }
     }
     return createEvent(runId, {
         type: 'runtime.snapshot.taken',
@@ -86,11 +81,11 @@ export function foldFromSnapshots(events, registry, options) {
     if (decoded.state !== undefined) {
         const trailing = events.filter((e) => e.seq > decoded.seq);
         if (trailing.length === 0) {
-            return fromJsonStruct(decoded.state);
+            return Schema.decodeUnknownSync(RunStateSchema)(decoded.state);
         }
         return foldRun(trailing, registry, {
             runId,
-            initial: fromJsonStruct(decoded.state),
+            initial: Schema.decodeUnknownSync(RunStateSchema)(decoded.state),
         });
     }
     return foldRun(events, registry, { runId });

package/dist/core/sqlite-store.js

@@ -1,6 +1,8 @@
 import { Effect, Option, Queue, Schema, Stream } from 'effect';
 import { EventEnvelopeSchema, fromWireEvent, withAssignedSeq } from './envelope.js';
+import { assertEventByteLimits, assertSnapshotByteLimit, EventPayloadTooLargeError, SnapshotPayloadTooLargeError, } from './limits.js';
 import { SnapshotStoreError, withSnapshotStore, } from './snapshot-store.js';
+import { RunStateSchema } from './state.js';
 import { EventStoreConflictError, EventStoreError, EventStoreFencedError, } from './store.js';
 export const SQLITE_EVENT_STORE_SCHEMA = `
 CREATE TABLE IF NOT EXISTS looms_streams (
@@ -25,11 +27,19 @@ CREATE TABLE IF NOT EXISTS looms_snapshots (
   state TEXT NOT NULL,
   PRIMARY KEY (run_id, cursor)
 );
+
+CREATE TABLE IF NOT EXISTS looms_commands (
+  run_id TEXT NOT NULL,
+  idempotency_key TEXT NOT NULL,
+  fingerprint TEXT,
+  committed_tail INTEGER NOT NULL,
+  PRIMARY KEY (run_id, idempotency_key)
+);
 `.trim();
 const StreamRowSchema = Schema.Struct({
     run_id: Schema.String,
-    head: Schema.Number,
-    tail: Schema.Number,
+    head: Schema.Finite,
+    tail: Schema.Finite,
     fence_token: Schema.NullOr(Schema.String),
 });
 const EventRowSchema = Schema.Struct({
@@ -37,25 +47,30 @@ const EventRowSchema = Schema.Struct({
 });
 const SnapshotRowSchema = Schema.Struct({
     run_id: Schema.String,
-    cursor: Schema.Number,
+    cursor: Schema.Finite,
     state_hash: Schema.String,
-    taken_at: Schema.Number,
+    taken_at: Schema.Finite,
     state: Schema.String,
 });
 const RunIdRowSchema = Schema.Struct({
     run_id: Schema.String,
 });
 const CursorRowSchema = Schema.Struct({
-    cursor: Schema.Number,
+    cursor: Schema.Finite,
+});
+const CommandRowSchema = Schema.Struct({
+    fingerprint: Schema.NullOr(Schema.String),
+    committed_tail: Schema.Finite,
 });
 const decodeEventBody = Schema.decodeUnknownSync(Schema.fromJsonString(EventEnvelopeSchema));
-const decodeRunState = Schema.decodeUnknownSync(Schema.fromJsonString(Schema.Unknown));
+const decodeRunState = Schema.decodeUnknownSync(Schema.fromJsonString(RunStateSchema));
 const encodeJson = Schema.encodeSync(Schema.fromJsonString(Schema.Unknown));
 const decodeStreamRow = Schema.decodeUnknownSync(StreamRowSchema);
 const decodeEventRow = Schema.decodeUnknownSync(EventRowSchema);
 const decodeSnapshotRow = Schema.decodeUnknownSync(SnapshotRowSchema);
 const decodeRunIdRow = Schema.decodeUnknownSync(RunIdRowSchema);
 const decodeCursorRow = Schema.decodeUnknownSync(CursorRowSchema);
+const decodeCommandRow = Schema.decodeUnknownSync(CommandRowSchema);
 /** Adapter for Cloudflare Durable Object `ctx.storage.sql`. */
 export function sqlStorageExec(sql, options) {
     return {
@@ -100,7 +115,6 @@ function parseEvent(body) {
     return fromWireEvent(decodeEventBody(body));
 }
 function toSnapshot(row) {
-    // SAFETY: snapshot state is a JSON-encoded RunState written by this store.
     const state = decodeRunState(row.state);
     return {
         runId: row.run_id,
@@ -121,6 +135,7 @@ function createSqliteSnapshotStore(exec) {
         }),
         save: (snapshot) => Effect.try({
             try: () => {
+                assertSnapshotByteLimit(snapshot);
                 exec.run(`INSERT INTO looms_snapshots (run_id, cursor, state_hash, taken_at, state)
              VALUES (?, ?, ?, ?, ?)
              ON CONFLICT (run_id, cursor) DO UPDATE SET
@@ -134,7 +149,9 @@ function createSqliteSnapshotStore(exec) {
                     encodeJson(snapshot.state),
                 ]);
             },
-            catch: (cause) => new SnapshotStoreError(`Failed to save snapshot for ${snapshot.runId}`, cause),
+            catch: (cause) => cause instanceof SnapshotPayloadTooLargeError
+                ? cause
+                : new SnapshotStoreError(`Failed to save snapshot for ${snapshot.runId}`, cause),
         }),
         listCursors: (runId) => Effect.try({
             try: () => exec
@@ -194,11 +211,33 @@ function createSqliteEventStore(exec) {
     const service = {
         append: (runId, events, options) => Effect.try({
             try: () => {
-                if (events.length === 0 && options?.fence === undefined) {
+                assertEventByteLimits(runId, events);
+                if (events.length === 0 &&
+                    options?.fence === undefined &&
+                    options?.idempotency === undefined) {
                     return { sequences: [], tail: getStream(runId).tail };
                 }
                 return runInTransaction(exec, () => {
                     const log = ensureStream(runId);
+                    const idempotency = options?.idempotency;
+                    if (idempotency) {
+                        const [commandRow] = exec.rows(`SELECT fingerprint, committed_tail
+                 FROM looms_commands
+                 WHERE run_id = ? AND idempotency_key = ?`, [runId, idempotency.key]);
+                        if (commandRow !== undefined) {
+                            const command = decodeCommandRow(commandRow);
+                            if (idempotency.fingerprint !== undefined &&
+                                command.fingerprint !== null &&
+                                command.fingerprint !== idempotency.fingerprint) {
+                                throw new EventStoreError(`Idempotency key "${idempotency.key}" was reused with different content`);
+                            }
+                            return {
+                                sequences: [],
+                                tail: getStream(runId).tail,
+                                deduplicated: true,
+                            };
+                        }
+                    }
                     if (options?.expectedTail !== undefined && log.tail !== options.expectedTail) {
                         throw new EventStoreConflictError(runId, options.expectedTail, log.tail);
                     }
@@ -231,13 +270,19 @@ function createSqliteEventStore(exec) {
                ON CONFLICT (run_id) DO UPDATE SET
                  tail = excluded.tail,
                  fence_token = excluded.fence_token`, [runId, log.head, nextTail, fenceToken]);
+                    if (idempotency) {
+                        exec.run(`INSERT INTO looms_commands
+                   (run_id, idempotency_key, fingerprint, committed_tail)
+                 VALUES (?, ?, ?, ?)`, [runId, idempotency.key, idempotency.fingerprint ?? null, nextTail]);
+                    }
                     notify(runId, appended);
                     return { sequences, tail: nextTail };
                 });
             },
             catch: (cause) => cause instanceof EventStoreConflictError ||
                 cause instanceof EventStoreFencedError ||
-                cause instanceof EventStoreError
+                cause instanceof EventStoreError ||
+                cause instanceof EventPayloadTooLargeError
                 ? cause
                 : new EventStoreError(`append failed for ${runId}`, cause),
         }),
@@ -308,7 +353,7 @@ function createSqliteEventStore(exec) {
                 }
             }));
         })),
-        listRuns: () => Effect.try({
+        listRuns: Effect.try({
             try: () => exec
                 .rows('SELECT run_id FROM looms_streams ORDER BY run_id ASC')
                 .map((row) => decodeRunIdRow(row).run_id),

package/dist/core/state.d.ts

@@ -1,9 +1,11 @@
-import type { RuntimeEffect, WaitCondition } from './effects';
+import { Schema } from 'effect';
+import { type RuntimeEffect, type WaitCondition } from './effects';
 import type { JsonValue, ThreadStatus, RunStatus } from './types';
 export interface ThreadRecord {
     threadId: string;
     kind: string;
     definitionName: string;
+    definitionVersion: string;
     parentThreadId: string | null;
     status: ThreadStatus;
     input: JsonValue;
@@ -24,20 +26,156 @@ export interface OutstandingEffect {
     causingEventId: string;
     effect: RuntimeEffect;
 }
+export interface EffectExecutionRecord {
+    effectId: string;
+    attempt: number;
+    status: 'queued' | 'dispatched' | 'started' | 'heartbeat' | 'retry_wait' | 'cancel_requested' | 'timed_out' | 'ambiguous' | 'running';
+    nextAttemptAt: number | null;
+    deadlineAt: number | null;
+    /** When the current attempt started executing, locally or on a worker. */
+    startedAt: number | null;
+    lastHeartbeatAt: number | null;
+    lastError: string | null;
+}
+export interface RunStartIdentity {
+    kind: string;
+    definitionName: string;
+    definitionVersion: string;
+    input: JsonValue;
+    requestedThreadId: string | null;
+    idempotencyKey: string | null;
+    rootThreadId: string;
+}
 export interface RunState {
     runId: string;
     status: RunStatus;
     rootThreadId: string | null;
+    startIdentity: RunStartIdentity | null;
     threads: {
         [threadId: string]: ThreadRecord;
     };
     waits: {
         [waitId: string]: WaitRecord;
     };
-    outstandingEffects: OutstandingEffect[];
-    completedEffectIds?: string[];
-    processedIdempotencyKeys?: string[];
+    outstandingEffects: readonly OutstandingEffect[];
+    effectExecutions: {
+        [effectId: string]: EffectExecutionRecord;
+    };
+    completedEffectIds: readonly string[];
+    processedIdempotencyKeys: readonly string[];
 }
+export declare const RunStateSchema: 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>;
+}>;
 export declare function emptyRunState(runId: string): RunState;
 export declare function isRunTerminal(state: RunState): boolean;
 export declare function isRunParked(state: RunState): boolean;