@swirls/looms 0.0.2 → 0.2.0

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

@@ -1,6 +1,6 @@
 import type { StandardSchemaV1 } from '@standard-schema/spec';
 import { Effect, Schema } from 'effect';
-import type { JsonValue } from './types';
+import { type JsonValue } from './types';
 declare const InvalidInputError_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: "InvalidInputError";
 } & Readonly<A>;
@@ -11,25 +11,16 @@ 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;
+/** JSON Schema for a definition input, when the schema can describe itself. */
+export declare function jsonSchemaOfInput(input: SchemaInput | null | undefined): JsonValue | undefined;
 export {};

package/dist/core/schema.js

@@ -1,4 +1,5 @@
 import { Data, Effect, Predicate, Schema } from 'effect';
+import { isJsonObject } from './types.js';
 export class InvalidInputError extends Data.TaggedError('InvalidInputError') {
     issues;
     constructor(text, issues = []) {
@@ -7,65 +8,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;
-    }
-    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,
-                            })),
-                        };
-                    },
-                },
-            };
-        }
+function isStandardSchema(candidate) {
+    if (!Predicate.isReadonlyObject(candidate) || !('~standard' in candidate)) {
+        return false;
     }
-    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 +38,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 async function validateInput(schemaOrDef, raw) {
-    return Effect.runPromise(validateInputEffect(schemaOrDef, raw));
+export function validateInputEffect(schema, raw) {
+    return decodeInput(schema, raw);
 }
-export function validateInputSync(schemaOrDef, raw) {
-    const schema = extractSchema(schemaOrDef);
+export function validateInput(schema, raw) {
+    return Effect.runPromise(decodeInput(schema, raw));
+}
+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 +72,42 @@ 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;
 }
+function isStandardJsonSchemaHolder(value) {
+    return '~standard' in value;
+}
+function jsonSchemaFromHolder(value) {
+    if (!isStandardJsonSchemaHolder(value)) {
+        return undefined;
+    }
+    const input = value['~standard'].jsonSchema?.input;
+    if (!input) {
+        return undefined;
+    }
+    try {
+        const schema = input({ target: 'draft-2020-12' });
+        return isJsonObject(schema) ? schema : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** JSON Schema for a definition input, when the schema can describe itself. */
+export function jsonSchemaOfInput(input) {
+    if (!input) {
+        return undefined;
+    }
+    if (isStandardSchema(input)) {
+        return jsonSchemaFromHolder(input);
+    }
+    if (!Schema.isSchema(input)) {
+        return undefined;
+    }
+    try {
+        return jsonSchemaFromHolder(Schema.toStandardJSONSchemaV1(input));
+    }
+    catch {
+        return undefined;
+    }
+}

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,6 @@
 import { Context, Effect, Option } from 'effect';
+import { SnapshotPayloadTooLargeError } from './limits';
+import type { RunSummary } from './published';
 import type { RunState } from './state';
 import type { EventStore } from './store';
 /**
@@ -25,9 +27,12 @@ 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>;
+    /** Upsert the list-row for a run. Written where the cursor already advanced. */
+    readonly saveHeader: (header: RunSummary) => Effect.Effect<void, SnapshotStoreError>;
+    readonly listHeaders: Effect.Effect<readonly RunSummary[], SnapshotStoreError>;
 }
 declare const SnapshotStoreTag_base: Context.ServiceClass<SnapshotStoreTag, "looms/SnapshotStore", SnapshotStore>;
 export declare class SnapshotStoreTag extends SnapshotStoreTag_base {

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 });
@@ -20,6 +21,7 @@ export function snapshotStoreOf(store) {
 }
 export const makeMemorySnapshotStore = Effect.gen(function* () {
     const snapshots = yield* Ref.make(new Map());
+    const headers = yield* Ref.make(new Map());
     const service = {
         loadLatest: (runId) => Effect.gen(function* () {
             const map = yield* Ref.get(snapshots);
@@ -29,12 +31,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);
@@ -48,6 +55,12 @@ export const makeMemorySnapshotStore = Effect.gen(function* () {
             next.set(runId, list.slice(list.length - keepLatest));
             return next;
         }),
+        saveHeader: (header) => Ref.update(headers, (map) => {
+            const next = new Map(map);
+            next.set(header.runId, header);
+            return next;
+        }),
+        listHeaders: Ref.get(headers).pipe(Effect.map((map) => [...map.values()])),
     };
     return service;
 });