@swirls/looms 0.0.1 → 0.1.0

package/dist/core/state.js

@@ -1,11 +1,89 @@
+import { Effect, Schema } from 'effect';
+import { RuntimeEffectSchema, WaitConditionSchema, } from './effects.js';
+import { JsonValueSchema } from './envelope.js';
+import { DEFAULT_DEFINITION_VERSION } from './module.js';
+export const RunStateSchema = Schema.Struct({
+    runId: Schema.String,
+    status: Schema.Union([
+        Schema.Literal('running'),
+        Schema.Literal('completed'),
+        Schema.Literal('failed'),
+        Schema.Literal('cancelled'),
+    ]),
+    rootThreadId: Schema.NullOr(Schema.String),
+    startIdentity: Schema.NullOr(Schema.Struct({
+        kind: Schema.String,
+        definitionName: Schema.String,
+        definitionVersion: Schema.String,
+        input: JsonValueSchema,
+        requestedThreadId: Schema.NullOr(Schema.String),
+        idempotencyKey: Schema.NullOr(Schema.String),
+        rootThreadId: Schema.String,
+    })).pipe(Schema.withDecodingDefaultKey(Effect.succeed(null))),
+    threads: Schema.Record(Schema.String, Schema.Struct({
+        threadId: Schema.String,
+        kind: Schema.String,
+        definitionName: Schema.String,
+        definitionVersion: Schema.String.pipe(Schema.withDecodingDefaultKey(Effect.succeed(DEFAULT_DEFINITION_VERSION))),
+        parentThreadId: Schema.NullOr(Schema.String),
+        status: Schema.Union([
+            Schema.Literal('running'),
+            Schema.Literal('waiting'),
+            Schema.Literal('completed'),
+            Schema.Literal('failed'),
+            Schema.Literal('cancelled'),
+        ]),
+        input: JsonValueSchema,
+        output: Schema.NullOr(JsonValueSchema),
+        error: Schema.NullOr(Schema.String),
+        state: JsonValueSchema,
+    })),
+    waits: Schema.Record(Schema.String, Schema.Struct({
+        waitId: Schema.String,
+        threadId: Schema.String,
+        on: WaitConditionSchema,
+        tag: Schema.optional(JsonValueSchema),
+    })),
+    outstandingEffects: Schema.Array(Schema.Struct({
+        effectId: Schema.String,
+        threadId: Schema.String,
+        causingSeq: Schema.Finite,
+        causingEventId: Schema.String,
+        effect: RuntimeEffectSchema,
+    })),
+    effectExecutions: Schema.Record(Schema.String, Schema.Struct({
+        effectId: Schema.String,
+        attempt: Schema.Finite,
+        status: Schema.Union([
+            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'),
+        ]),
+        nextAttemptAt: Schema.NullOr(Schema.Finite),
+        deadlineAt: Schema.NullOr(Schema.Finite).pipe(Schema.withDecodingDefaultKey(Effect.succeed(null))),
+        startedAt: Schema.NullOr(Schema.Finite).pipe(Schema.withDecodingDefaultKey(Effect.succeed(null))),
+        lastHeartbeatAt: Schema.NullOr(Schema.Finite).pipe(Schema.withDecodingDefaultKey(Effect.succeed(null))),
+        lastError: Schema.NullOr(Schema.String),
+    })).pipe(Schema.withDecodingDefaultKey(Effect.succeed({}))),
+    completedEffectIds: Schema.Array(Schema.String).pipe(Schema.withDecodingDefaultKey(Effect.succeed([]))),
+    processedIdempotencyKeys: Schema.Array(Schema.String).pipe(Schema.withDecodingDefaultKey(Effect.succeed([]))),
+});
 export function emptyRunState(runId) {
     return {
         runId,
         status: 'running',
         rootThreadId: null,
+        startIdentity: null,
         threads: {},
         waits: {},
         outstandingEffects: [],
+        effectExecutions: {},
         completedEffectIds: [],
         processedIdempotencyKeys: [],
     };

package/dist/core/store.d.ts

@@ -1,5 +1,6 @@
 import { Context, Effect, Layer, Stream } from 'effect';
 import { type AppendableEvent, type EventEnvelope } from './envelope';
+import { EventPayloadTooLargeError } from './limits';
 declare const EventStoreError_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: "EventStoreError";
 } & Readonly<A>;
@@ -59,8 +60,31 @@ export declare class EventStoreFencedError extends EventStoreFencedError_base<{
 }> {
     constructor(runId: string, token: string);
 }
-export type EventStoreAppendError = EventStoreError | EventStoreConflictError | EventStoreFencedError;
-export type AnyEventStoreError = EventStoreError | EventStoreConflictError | EventStoreTruncationError | EventStoreTrimmedError | EventStoreFencedError;
+declare const UnsafeEventStoreTrimError_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: "UnsafeEventStoreTrimError";
+} & Readonly<A>;
+export declare class UnsafeEventStoreTrimError extends UnsafeEventStoreTrimError_base<{
+    readonly runId: string;
+    readonly trimThrough: number;
+    readonly message: string;
+}> {
+    constructor(runId: string, trimThrough: number);
+}
+export type EventStoreTrimCoverage = {
+    /** Durable archive contains every event through this sequence. */
+    readonly archiveCursor: number;
+    readonly requiredProjectors?: never;
+    readonly projectorCursors?: never;
+} | {
+    readonly archiveCursor?: never;
+    /** Authoritative identities of every projector required before trimming. */
+    readonly requiredProjectors: readonly string[];
+    /** Durable checkpoint by projector identity. Every required projector must be present. */
+    readonly projectorCursors: Readonly<Record<string, number>>;
+};
+export declare function trimEventStoreSafely(store: EventStore, runId: string, beforeSeq: number, coverage: EventStoreTrimCoverage): Effect.Effect<void, EventStoreError | UnsafeEventStoreTrimError>;
+export type EventStoreAppendError = EventStoreError | EventStoreConflictError | EventStoreFencedError | EventPayloadTooLargeError;
+export type AnyEventStoreError = EventStoreError | EventStoreConflictError | EventStoreTruncationError | EventStoreTrimmedError | EventStoreFencedError | EventPayloadTooLargeError;
 export declare function isEventStoreError(err: unknown): err is AnyEventStoreError;
 export interface StreamBounds {
     readonly head: number;
@@ -68,6 +92,16 @@ export interface StreamBounds {
 }
 export interface AppendOptions {
     readonly expectedTail?: number;
+    /**
+     * Atomically claims an ingress command with the append. Reusing the key
+     * returns a deduplicated result without appending events. Stores without a
+     * command table may ignore this; callers must pair it with `expectedTail`
+     * so a retried command conflicts instead of appending twice.
+     */
+    readonly idempotency?: {
+        readonly key: string;
+        readonly fingerprint?: string;
+    };
     /** Set the stream fencing token atomically in this batch (`''` clears). */
     readonly fence?: string;
     /** Must match the stream's current fencing token, or the append fails. */
@@ -92,6 +126,7 @@ export declare function paginatePages<T, SCursor, E = never, R = never>(options:
 export interface AppendResult {
     sequences: number[];
     tail: number;
+    deduplicated?: boolean;
 }
 export interface EventStore {
     readonly append: (runId: string, events: ReadonlyArray<AppendableEvent>, options?: AppendOptions) => Effect.Effect<AppendResult, EventStoreAppendError>;
@@ -128,7 +163,7 @@ export interface EventStore {
     readonly subscribe: (runId: string, options?: {
         fromSeq?: number;
     }) => Stream.Stream<EventEnvelope, EventStoreError>;
-    readonly listRuns: () => Effect.Effect<string[], EventStoreError>;
+    readonly listRuns: Effect.Effect<string[], EventStoreError>;
 }
 /**
  * Utility to read an EventStore as a Stream.Stream, using `store.readStream` if implemented

package/dist/core/store.js

@@ -1,5 +1,6 @@
 import { Context, Data, Effect, Layer, Option, Queue, Ref, Stream } from 'effect';
 import { withAssignedSeq } from './envelope.js';
+import { assertEventByteLimits, EventPayloadTooLargeError } from './limits.js';
 export class EventStoreError extends Data.TaggedError('EventStoreError') {
     conflict;
     cause;
@@ -55,12 +56,34 @@ export class EventStoreFencedError extends Data.TaggedError('EventStoreFencedErr
         this.name = 'EventStoreFencedError';
     }
 }
+export class UnsafeEventStoreTrimError extends Data.TaggedError('UnsafeEventStoreTrimError') {
+    constructor(runId, trimThrough) {
+        super({
+            runId,
+            trimThrough,
+            message: `UnsafeEventStoreTrim: refusing to trim run "${runId}" through seq ${trimThrough}; no archive or complete projector checkpoint coverage was supplied`,
+        });
+        this.name = 'UnsafeEventStoreTrimError';
+    }
+}
+export function trimEventStoreSafely(store, runId, beforeSeq, coverage) {
+    const trimThrough = Math.max(0, beforeSeq - 1);
+    const covered = coverage.archiveCursor !== undefined
+        ? coverage.archiveCursor >= trimThrough
+        : coverage.requiredProjectors.length > 0 &&
+            coverage.requiredProjectors.every((projector) => (coverage.projectorCursors[projector] ?? -1) >= trimThrough);
+    if (!store.trim || !covered) {
+        return Effect.fail(new UnsafeEventStoreTrimError(runId, trimThrough));
+    }
+    return store.trim(runId, beforeSeq);
+}
 export function isEventStoreError(err) {
     return (err instanceof EventStoreError ||
         err instanceof EventStoreConflictError ||
         err instanceof EventStoreTruncationError ||
         err instanceof EventStoreTrimmedError ||
-        err instanceof EventStoreFencedError);
+        err instanceof EventStoreFencedError ||
+        err instanceof EventPayloadTooLargeError);
 }
 /**
  * Pure Effect-native stream pagination primitive.
@@ -99,16 +122,41 @@ export const makeMemoryEventStore = Effect.gen(function* () {
         if (existing) {
             return existing;
         }
-        const created = { events: [], waiters: [], head: 1, tail: 0 };
+        const created = {
+            events: [],
+            waiters: [],
+            head: 1,
+            tail: 0,
+            commands: new Map(),
+        };
         map.set(runId, created);
         return created;
     };
     const service = {
         append: (runId, events, options) => Effect.gen(function* () {
+            yield* Effect.try({
+                try: () => assertEventByteLimits(runId, events),
+                catch: (cause) => cause instanceof EventPayloadTooLargeError
+                    ? cause
+                    : new EventStoreError('event size validation failed', cause),
+            });
             const sequences = [];
+            let deduplicated = false;
             yield* Ref.update(logs, (map) => {
                 const next = new Map(map);
                 const log = getOrCreate(next, runId);
+                const command = options?.idempotency
+                    ? log.commands.get(options.idempotency.key)
+                    : undefined;
+                if (command) {
+                    if (options?.idempotency?.fingerprint !== undefined &&
+                        command.fingerprint !== undefined &&
+                        command.fingerprint !== options.idempotency.fingerprint) {
+                        throw new EventStoreError(`Idempotency key "${options.idempotency.key}" was reused with different content`);
+                    }
+                    deduplicated = true;
+                    return map;
+                }
                 if (options?.expectedTail !== undefined && log.tail !== options.expectedTail) {
                     throw new EventStoreConflictError(runId, options.expectedTail, log.tail);
                 }
@@ -135,7 +183,14 @@ export const makeMemoryEventStore = Effect.gen(function* () {
                     head: log.head,
                     tail: nextTail,
                     fenceToken,
+                    commands: new Map(log.commands),
                 };
+                if (options?.idempotency) {
+                    updated.commands.set(options.idempotency.key, {
+                        fingerprint: options.idempotency.fingerprint,
+                        committedTail: nextTail,
+                    });
+                }
                 next.set(runId, updated);
                 for (const event of appended) {
                     for (const waiter of log.waiters) {
@@ -145,11 +200,16 @@ export const makeMemoryEventStore = Effect.gen(function* () {
                 return next;
             }).pipe(Effect.catchDefect((cause) => Effect.fail(cause instanceof EventStoreConflictError ||
                 cause instanceof EventStoreFencedError ||
-                cause instanceof EventStoreError
+                cause instanceof EventStoreError ||
+                cause instanceof EventPayloadTooLargeError
                 ? cause
                 : new EventStoreError('append failed', cause))));
             const tail = yield* service.tail(runId);
-            return { sequences, tail };
+            const result = { sequences, tail };
+            if (deduplicated) {
+                result.deduplicated = true;
+            }
+            return result;
         }),
         read: (runId, options) => Effect.gen(function* () {
             const map = yield* Ref.get(logs);
@@ -174,21 +234,19 @@ export const makeMemoryEventStore = Effect.gen(function* () {
             }
             return { head: log.head, tail: log.tail };
         }),
-        trim: (runId, beforeSeq) => Effect.gen(function* () {
-            yield* Ref.update(logs, (map) => {
-                const log = map.get(runId);
-                if (!log) {
-                    return map;
-                }
-                const next = new Map(map);
-                const retained = log.events.filter((e) => e.seq >= beforeSeq);
-                next.set(runId, {
-                    ...log,
-                    events: retained,
-                    head: Math.max(log.head, beforeSeq),
-                });
-                return next;
+        trim: (runId, beforeSeq) => Ref.update(logs, (map) => {
+            const log = map.get(runId);
+            if (!log) {
+                return map;
+            }
+            const next = new Map(map);
+            const retained = log.events.filter((e) => e.seq >= beforeSeq);
+            next.set(runId, {
+                ...log,
+                events: retained,
+                head: Math.max(log.head, beforeSeq),
             });
+            return next;
         }),
         subscribe: (runId, options) => Stream.callback((queue) => Effect.gen(function* () {
             const fromSeq = options?.fromSeq ?? 1;
@@ -219,10 +277,7 @@ export const makeMemoryEventStore = Effect.gen(function* () {
                 }
             }));
         })),
-        listRuns: () => Effect.gen(function* () {
-            const map = yield* Ref.get(logs);
-            return [...map.keys()];
-        }),
+        listRuns: Ref.get(logs).pipe(Effect.map((map) => [...map.keys()])),
     };
     return service;
 });

package/dist/core/thread.d.ts

@@ -7,6 +7,7 @@ export interface StartContext<TInput = JsonValue> {
     readonly threadId: string;
     readonly parentThreadId: string | null;
     readonly definitionName: string;
+    readonly definitionVersion: string;
     readonly input: TInput;
 }
 export interface ThreadContext {
@@ -22,20 +23,20 @@ export interface ThreadDefinition<S = any> {
     step(state: S, event: EventEnvelope, ctx: ThreadContext): S;
     effects(state: S, ctx: ThreadContext): RuntimeEffect[];
 }
-export declare function defineThread<TShape, TInputSchema extends SchemaInput | undefined = undefined>(def: {
-    readonly kind: string;
-    readonly shape: TShape;
-    readonly input?: TInputSchema;
-    initialState(ctx: StartContext<InferDefinedSchema<TInputSchema>>): InferSchemaOutput<TShape>;
-    step(state: InferSchemaOutput<TShape>, event: EventEnvelope, ctx: ThreadContext): InferSchemaOutput<TShape>;
-    effects?(state: InferSchemaOutput<TShape>, ctx: ThreadContext): RuntimeEffect[];
-}): ThreadDefinition<InferSchemaOutput<TShape>>;
 export declare function defineThread<S = JsonValue, TInputSchema extends SchemaInput | undefined = undefined>(def: {
     readonly kind: string;
-    readonly shape?: unknown;
+    readonly shape?: undefined;
     readonly input?: TInputSchema;
     initialState(ctx: StartContext<InferDefinedSchema<TInputSchema>>): S;
     step(state: S, event: EventEnvelope, ctx: ThreadContext): S;
     effects?(state: S, ctx: ThreadContext): RuntimeEffect[];
 }): ThreadDefinition<S>;
+export declare function defineThread<TShape extends SchemaInput, TInputSchema extends SchemaInput | undefined = undefined>(def: {
+    readonly kind: string;
+    readonly shape: TShape;
+    readonly input?: TInputSchema;
+    initialState(ctx: StartContext<InferDefinedSchema<TInputSchema>>): InferSchemaOutput<TShape>;
+    step(state: NoInfer<InferSchemaOutput<TShape>>, event: EventEnvelope, ctx: ThreadContext): InferSchemaOutput<TShape>;
+    effects?(state: NoInfer<InferSchemaOutput<TShape>>, ctx: ThreadContext): RuntimeEffect[];
+}): ThreadDefinition<InferSchemaOutput<TShape>>;
 export declare function isTerminalStatus(status: ThreadStatus): boolean;

package/dist/core/types.d.ts

@@ -9,15 +9,12 @@ export type JsonValue = JsonPrimitive | JsonArray | JsonObject;
 export interface JsonPayload {
     readonly [key: string]: JsonValue | JsonPayload | readonly (JsonValue | JsonPayload)[] | undefined;
 }
-/**
- * Recursively remove keys with `undefined` values from an object,
- * matching wire JSON serialization behavior where undefined properties drop.
- */
-export declare function cleanUndefined<T>(value: T): T;
+export declare const stringifyJson: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string;
+export declare const stringifyJsonPretty: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string;
+/** Convert a value to its JSON wire representation, dropping undefined object properties. */
+export declare function cleanUndefined(value: unknown): JsonValue;
 /** Mark a JSON-serializable struct as a log payload, stripping undefined fields. */
-export declare function asJson<T>(payload: T): JsonValue;
-/** Recover a typed struct previously written as JSON. */
-export declare function fromJsonStruct<T>(value: JsonValue): T;
+export declare const asJson: typeof cleanUndefined;
 export declare function isJsonObject(value: unknown): value is {
     [key: string]: JsonValue;
 };

package/dist/core/types.js

@@ -1,36 +1,40 @@
-import { Predicate } from 'effect';
-/**
- * Recursively remove keys with `undefined` values from an object,
- * matching wire JSON serialization behavior where undefined properties drop.
- */
-export function cleanUndefined(value) {
+import { Predicate, Schema } from 'effect';
+const encodeUnknownJson = Schema.encodeSync(Schema.fromJsonString(Schema.Unknown));
+const encodeUnknownJsonPretty = Schema.encodeSync(Schema.fromJsonString(Schema.Unknown, { space: 2 }));
+export const stringifyJson = encodeUnknownJson;
+export const stringifyJsonPretty = encodeUnknownJsonPretty;
+// This recursive serializer is the parser for unknown JSON-like boundary values.
+// oxlint-disable-next-line anti-slop/no-unknown-parameters
+function cleanJsonValue(value) {
+    if (value === null || Predicate.isString(value) || Predicate.isBoolean(value)) {
+        return value;
+    }
+    if (Predicate.isNumber(value)) {
+        return Number.isFinite(value) ? value : null;
+    }
     if (Array.isArray(value)) {
-        // SAFETY: Mapping recursively over an array preserves array structure.
-        return value.map(cleanUndefined);
+        return value.map((item) => cleanJsonValue(item) ?? null);
     }
-    if (value === null || !Predicate.isObject(value)) {
-        return value;
+    if (!Predicate.isReadonlyObject(value)) {
+        return undefined;
     }
     const result = {};
-    for (const [k, v] of Object.entries(value)) {
-        if (v !== undefined) {
-            // SAFETY: cleanUndefined produces JSON-compatible values from JSON-like inputs.
-            result[k] = cleanUndefined(v);
+    for (const [key, nested] of Object.entries(value)) {
+        const cleaned = cleanJsonValue(nested);
+        if (cleaned !== undefined) {
+            result[key] = cleaned;
         }
     }
-    // SAFETY: Rebuilding an object without undefined keys preserves its record shape.
     return result;
 }
-/** Mark a JSON-serializable struct as a log payload, stripping undefined fields. */
-export function asJson(payload) {
-    // SAFETY: cleanUndefined ensures undefined keys drop as they would across the wire.
-    return cleanUndefined(payload);
-}
-/** Recover a typed struct previously written as JSON. */
-export function fromJsonStruct(value) {
-    // SAFETY: value is a JSON struct previously produced as T.
-    return value;
+/** Convert a value to its JSON wire representation, dropping undefined object properties. */
+// Public JSON normalization intentionally accepts unknown input and returns the parsed domain type.
+// oxlint-disable-next-line anti-slop/no-unknown-parameters
+export function cleanUndefined(value) {
+    return cleanJsonValue(value) ?? null;
 }
+/** Mark a JSON-serializable struct as a log payload, stripping undefined fields. */
+export const asJson = cleanUndefined;
 export function isJsonObject(value) {
     return Predicate.isObject(value) && !Array.isArray(value);
 }

package/dist/core/validate-event.js

@@ -1,4 +1,4 @@
-import { Data, Effect } from 'effect';
+import { Data, Effect, Predicate, Schema } from 'effect';
 import { validateInputEffect } from './schema.js';
 import { cleanUndefined } from './types.js';
 export class InvalidEventError extends Data.TaggedError('InvalidEventError') {
@@ -25,16 +25,26 @@ function findCatalogAndEntry(catalogs, type) {
     }
     return undefined;
 }
+function isStandardSchema(entry) {
+    return Predicate.isReadonlyObject(entry) && '~standard' in entry;
+}
+function isEffectSchema(entry) {
+    return Schema.isSchema(entry);
+}
 export function validateEventInput(catalogs, input) {
     const match = findCatalogAndEntry(catalogs, input.type);
     if (!match) {
         return Effect.succeed(input);
     }
     const cleanedPayload = cleanUndefined(input.payload);
-    // SAFETY: match.entry is a catalog entry (Schema, StandardSchema, or payload marker).
-    return validateInputEffect(match.entry, cleanedPayload).pipe(Effect.map((validatedPayload) => ({
+    const validated = isEffectSchema(match.entry)
+        ? validateInputEffect(match.entry, cleanedPayload)
+        : isStandardSchema(match.entry)
+            ? validateInputEffect(match.entry, cleanedPayload)
+            : Effect.succeed(cleanedPayload);
+    return validated.pipe(Effect.map((validatedPayload) => ({
         ...input,
-        payload: validatedPayload,
+        payload: cleanUndefined(validatedPayload),
     })), Effect.mapError((err) => new InvalidEventError(input.type, `Invalid payload for event "${input.type}": ${err.message}`, err.issues)));
 }
 export function validateEventsEffect(catalogs, events) {

package/dist/core/worker-callback.d.ts

@@ -0,0 +1,17 @@
+import type { EventInput } from './envelope';
+/** Identifies one attempt of an effect executed by an external worker. */
+export interface WorkerCallback {
+    readonly effectId: string;
+    readonly attempt: number;
+}
+/** What an external worker reports about an effect attempt. */
+export type WorkerCallbackInput = (WorkerCallback & {
+    readonly kind: 'started' | 'heartbeat' | 'cancelled';
+}) | (WorkerCallback & {
+    readonly kind: 'complete';
+    readonly events: ReadonlyArray<EventInput>;
+}) | (WorkerCallback & {
+    readonly kind: 'fail';
+    readonly error: string;
+});
+export type WorkerCallbackKind = WorkerCallbackInput['kind'];

package/dist/core/worker-callback.js

@@ -0,0 +1 @@
+export {};

package/dist/debugger/components/event-stream.js

@@ -1,8 +1,9 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useVirtualizer } from '@tanstack/react-virtual';
+import { Effect, Fiber } from 'effect';
 import { Check, Search, SlidersHorizontal } from 'lucide-react';
 import { DropdownMenu as DropdownMenuPrimitive } from 'radix-ui';
-import { memo, useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { defaultEventCatalog } from '../events/catalog.js';
 import { cn, shortId } from '../lib/cn.js';
 import { getEventMeta } from '../lib/event-meta.js';
@@ -53,17 +54,17 @@ export function EventStream({ events, startedAt, threadId, threadLabel, selected
             return () => undefined;
         }
         followLock.current = true;
-        let timer;
+        let followRelease;
         const rafId = requestAnimationFrame(() => {
             virtualizer.scrollToIndex(visible.length - 1, { align: 'end' });
-            timer = setTimeout(() => {
+            followRelease = Effect.runFork(Effect.sleep(50).pipe(Effect.andThen(Effect.sync(() => {
                 followLock.current = false;
-            }, 50);
+            }))));
         });
         return () => {
             cancelAnimationFrame(rafId);
-            if (timer !== undefined) {
-                clearTimeout(timer);
+            if (followRelease !== undefined) {
+                Effect.runFork(Fiber.interrupt(followRelease));
             }
             followLock.current = false;
         };
@@ -107,13 +108,11 @@ export function EventStream({ events, startedAt, threadId, threadLabel, selected
                 ? (renderInspector?.(selected) ?? (_jsx(EventInspector, { event: selected, loadReplayStep: loadReplayStep })))
                 : null] }));
 }
-// SAFETY: memoized EventRow preserves generic EventRowProps contract.
-const EventRow = memo(function EventRow({ event, catalog, startedAt, selected, onSelectSeq, }) {
+function EventRow({ event, catalog, startedAt, selected, onSelectSeq, }) {
     const meta = getEventMeta(event, catalog);
     const offset = startedAt !== undefined ? Math.max(0, event.ts - startedAt) : undefined;
     const handleClick = useCallback(() => {
         onSelectSeq(selected ? undefined : event.seq);
     }, [onSelectSeq, selected, event.seq]);
     return (_jsxs("button", { type: "button", onClick: handleClick, title: [meta.summary.title, meta.summary.detail].filter(Boolean).join(' — '), className: cn('flex w-full items-start gap-1.5 rounded-sm px-1.5 py-1 text-left font-mono text-[11px]', selected ? 'bg-accent' : 'hover:bg-accent/40', event.ephemeral && 'opacity-50'), children: [_jsx("span", { className: cn('mt-1.5 size-1.5 shrink-0 rounded-full', catalog.familyClass(meta.family)) }), _jsx("span", { className: "text-muted-foreground w-6 shrink-0 text-right tabular-nums", children: event.seq }), _jsx("span", { className: "debugger-event-offset text-muted-foreground w-10 shrink-0 text-right tabular-nums", children: offset !== undefined ? `+${offset}` : '' }), _jsxs("span", { className: "min-w-0 flex-1 truncate whitespace-nowrap", children: [_jsx("span", { className: "text-foreground", children: meta.summary.title }), meta.summary.detail ? (_jsx("span", { className: "text-muted-foreground ml-1", children: meta.summary.detail })) : null] }), event.causationId ? (_jsxs("span", { className: "debugger-event-causation text-muted-foreground shrink-0", children: ["\u2190 ", shortId(event.causationId)] })) : null, event.threadId ? (_jsx("span", { className: "debugger-event-thread text-muted-foreground shrink-0", children: shortId(event.threadId) })) : null] }));
-    // SAFETY: memoized EventRow preserves generic EventRowProps contract.
-});
+}

package/dist/debugger/events/protocol-summarize.js

@@ -25,6 +25,8 @@ export function summarizeProtocolEvent(event) {
                 title: text(payload.error) ? 'run failed' : 'run completed',
                 detail: text(payload.error) ?? compactJson(payload.output ?? null),
             };
+        case 'runtime.run.cancelled':
+            return { title: 'run cancelled', detail: text(payload.reason) };
         case 'runtime.thread.started':
             return {
                 title: 'thread started',
@@ -58,10 +60,34 @@ export function summarizeProtocolEvent(event) {
             return { title: 'timer fired' };
         case 'runtime.effect.failed':
             return { title: 'effect failed', detail: text(payload.error) };
+        case 'runtime.effect.attempt.started':
+            return { title: 'effect attempt started', detail: numeric(payload.attempt) };
+        case 'runtime.effect.queued':
+            return { title: 'effect queued', detail: numeric(payload.attempt) };
+        case 'runtime.effect.dispatched':
+            return { title: 'effect dispatched', detail: numeric(payload.attempt) };
+        case 'runtime.effect.worker.started':
+            return { title: 'worker started effect', detail: numeric(payload.attempt) };
+        case 'runtime.effect.heartbeat':
+            return { title: 'effect heartbeat', detail: numeric(payload.attempt) };
+        case 'runtime.effect.completed':
+            return { title: 'effect completed', detail: numeric(payload.attempt) };
+        case 'runtime.effect.cancel.requested':
+            return { title: 'effect cancellation requested', detail: numeric(payload.attempt) };
+        case 'runtime.effect.cancelled':
+            return { title: 'effect cancelled', detail: numeric(payload.attempt) };
+        case 'runtime.effect.timed_out':
+            return { title: 'effect timed out', detail: text(payload.timeout) };
+        case 'runtime.effect.ambiguous':
+            return { title: 'effect outcome ambiguous', detail: text(payload.error) };
+        case 'runtime.effect.retry.scheduled':
+            return { title: 'effect retry scheduled', detail: text(payload.error) };
         case 'runtime.snapshot.taken':
             return { title: 'snapshot', detail: `seq ${numeric(payload.seq) ?? ''}` };
         case 'runtime.signal.received':
             return { title: 'signal', detail: compactJson(event.payload) };
+        case 'runtime.thread.cancel.requested':
+            return { title: 'thread cancellation requested', detail: text(payload.threadId) };
         default: {
             const exhaustiveType = event.type;
             return { title: 'event', detail: compactJson(obj(exhaustiveType)) };

package/dist/debugger/lib/event-meta.js

@@ -12,8 +12,7 @@ export function getEventMeta(event, catalog) {
         : searchText(event, catalog ? catalog.summarize : summarizeEvent);
     const meta = { summary, searchText: text, family };
     metaCache.set(event, {
-        // SAFETY: EventStreamCatalog is covariant over event for cache identity compares.
-        catalog: catalog,
+        catalog,
         meta,
     });
     return meta;

package/dist/evaluator/definitions-store.d.ts

@@ -0,0 +1,11 @@
+import { Context, Layer } from 'effect';
+import type { EvaluatorDefinition } from './definitions';
+export interface EvaluatorDefinitionStore {
+    get(name: string): EvaluatorDefinition | undefined;
+}
+declare const EvaluatorDefinitionsTag_base: Context.ServiceClass<EvaluatorDefinitionsTag, "looms/EvaluatorDefinitions", EvaluatorDefinitionStore>;
+export declare class EvaluatorDefinitionsTag extends EvaluatorDefinitionsTag_base {
+}
+export declare function makeEvaluatorDefinitionStore(definitions: ReadonlyArray<EvaluatorDefinition>): EvaluatorDefinitionStore;
+export declare const EvaluatorDefinitionsLive: (definitions: ReadonlyArray<EvaluatorDefinition>) => Layer.Layer<EvaluatorDefinitionsTag, never, never>;
+export {};

package/dist/evaluator/definitions-store.js

@@ -0,0 +1,8 @@
+import { Context, Layer } from 'effect';
+export class EvaluatorDefinitionsTag extends Context.Service()('looms/EvaluatorDefinitions') {
+}
+export function makeEvaluatorDefinitionStore(definitions) {
+    const map = new Map(definitions.map((def) => [def.name, def]));
+    return { get: (name) => map.get(name) };
+}
+export const EvaluatorDefinitionsLive = (definitions) => Layer.succeed(EvaluatorDefinitionsTag, makeEvaluatorDefinitionStore(definitions));