@swirls/looms 0.0.2 → 0.1.0

package/dist/workflow/threads.js

@@ -1,35 +1,235 @@
-import { Predicate, Schema } from 'effect';
-import { asJson, createWaitId, emit, fail, invoke, isWithdrawnError, spawn, wait, } from '@swirls/looms/core';
-import {} from './definitions.js';
+import { Effect, Predicate, Schema } from 'effect';
+import { cancel, createWaitId, DEFAULT_DEFINITION_VERSION, EventInputSchema, emit, fail, invoke, isJsonObject, isWithdrawnError, RuntimeEffectSchema, spawn, stableEffectId, wait, utf8JsonBytes, waitOutcome, } from '@swirls/looms/core';
+import { NodeStateSchema } from './definitions.js';
 import { runNodeEffect, scheduleEffect } from './effects.js';
+import { iterationChildWorkflowId, nodeRunKey, WorkflowValueTooLargeError } from './graph.js';
 import { workflowModule } from './scope.js';
 export { NodeStateSchema, NodeStatusSchema } from './definitions.js';
-// SAFETY: WorkflowState is folded by reducers; Schema.Unknown is a typed placeholder, not a decoder.
-export const WorkflowStateSchema = Schema.Unknown;
+const attemptNumber = Schema.Finite.pipe(Schema.withDecodingDefaultKey(Effect.succeed(1)));
+export const WorkflowPendingSpawnSchema = Schema.Struct({
+    childThreadId: Schema.String,
+    kind: Schema.String,
+    definitionName: Schema.String,
+    definitionVersion: Schema.String,
+    nodeId: Schema.String,
+    attempt: attemptNumber,
+    input: Schema.Json,
+    loopIndex: Schema.NullOr(Schema.Finite).pipe(Schema.withDecodingDefaultKey(Effect.succeed(null))),
+});
+export const WorkflowPendingMapSchema = Schema.Struct({
+    nodeId: Schema.String,
+    attempt: attemptNumber,
+    kind: Schema.String,
+    definitionName: Schema.String,
+    definitionVersion: Schema.String,
+    items: Schema.Array(Schema.Json),
+    concurrency: Schema.Finite,
+    limitBytes: Schema.Finite,
+    /** Items before this index have been started; later ones wait for a free slot. */
+    nextIndex: Schema.Finite,
+    outputs: Schema.Record(Schema.String, Schema.Json),
+});
+export const WorkflowPendingSleepSchema = Schema.Struct({
+    waitId: Schema.String,
+    wakeAt: Schema.Finite,
+    nodeId: Schema.String,
+});
+export const WorkflowPendingEffectsSchema = Schema.Struct({
+    nodeId: Schema.String,
+    effects: Schema.mutable(Schema.Array(RuntimeEffectSchema)),
+});
+export const WorkflowPendingEmitSchema = Schema.Struct({
+    id: Schema.String,
+    event: EventInputSchema,
+});
+export const WorkflowStateSchema = Schema.Struct({
+    definitionName: Schema.optional(Schema.String),
+    definitionVersion: Schema.optional(Schema.String),
+    nodes: Schema.Record(Schema.String, NodeStateSchema),
+    concurrency: Schema.Finite,
+    input: Schema.Json,
+    nodeIds: Schema.mutable(Schema.Array(Schema.String)),
+    needsSchedule: Schema.Boolean,
+    runningNodes: Schema.mutable(Schema.Array(Schema.String)),
+    pendingSpawns: Schema.mutable(Schema.Array(WorkflowPendingSpawnSchema)),
+    pendingMaps: Schema.mutable(Schema.Array(WorkflowPendingMapSchema)).pipe(Schema.withDecodingDefaultKey(Effect.succeed([]))),
+    pendingSleeps: Schema.mutable(Schema.Array(WorkflowPendingSleepSchema)),
+    pendingEffects: Schema.mutable(Schema.Array(WorkflowPendingEffectsSchema)),
+    pendingEmits: Schema.mutable(Schema.Array(WorkflowPendingEmitSchema)),
+    /** Children of stopped nodes that were still running; each is cancelled once. */
+    pendingCancels: Schema.mutable(Schema.Array(Schema.String)).pipe(Schema.withDecodingDefaultKey(Effect.succeed([]))),
+    status: Schema.Union([
+        Schema.Literal('running'),
+        Schema.Literal('completed'),
+        Schema.Literal('failed'),
+    ]),
+    error: Schema.NullOr(Schema.String),
+});
+const initialWorkflowStatus = 'running';
 function scheduleInvocation(state) {
     return invoke(scheduleEffect, {
         definitionName: state.definitionName,
+        definitionVersion: state.definitionVersion ?? DEFAULT_DEFINITION_VERSION,
         nodes: state.nodes,
         input: state.input,
     });
 }
 function runNodeInvocation(state, nodeId) {
-    const results = {};
-    for (const [id, node] of Object.entries(state.nodes)) {
-        results[id] = node.result;
-    }
+    const node = state.nodes[nodeId];
+    const attempts = node?.attempts ?? 1;
     return invoke(runNodeEffect, {
         definitionName: state.definitionName,
+        definitionVersion: state.definitionVersion ?? DEFAULT_DEFINITION_VERSION,
         nodeId,
+        attempt: attempts,
+        iteration: node?.iteration,
         input: state.input,
-        results,
-    }, `runNode_${nodeId}`);
+        nodes: state.nodes,
+    }, `runNode_${nodeRunKey(nodeId, attempts, node?.iteration?.index)}`);
+}
+function spawnAndWait(threadId, child, childThreadId, input, tag) {
+    return [
+        spawn({
+            childThreadId,
+            kind: child.kind,
+            definitionName: child.definitionName,
+            definitionVersion: child.definitionVersion,
+            input,
+        }),
+        wait({
+            waitId: createWaitId(threadId, `spawn_${childThreadId}`),
+            on: {
+                type: ['runtime.thread.completed', 'runtime.thread.failed'],
+                match: { threadId: childThreadId },
+            },
+            tag,
+        }),
+    ];
+}
+function mapChildThreadId(threadId, map, index) {
+    return iterationChildWorkflowId(threadId, map.nodeId, 'map', map.attempt, index);
+}
+/** Every effect a node currently needs, attributed to that node. */
+function nodeEffects(state, threadId) {
+    const effects = [];
+    const add = (nodeId, items) => {
+        for (const effect of items) {
+            effects.push({ nodeId, effect });
+        }
+    };
+    for (const nodeId of state.runningNodes) {
+        add(nodeId, [runNodeInvocation(state, nodeId)]);
+    }
+    for (const item of state.pendingSpawns) {
+        const tag = { nodeId: item.nodeId, attempt: item.attempt };
+        add(item.nodeId, spawnAndWait(threadId, item, item.childThreadId, item.input, {
+            ...tag,
+            loopIndex: item.loopIndex,
+        }));
+    }
+    for (const map of state.pendingMaps) {
+        for (let index = 0; index < map.nextIndex; index++) {
+            if (!(String(index) in map.outputs)) {
+                add(map.nodeId, spawnAndWait(threadId, map, mapChildThreadId(threadId, map, index), map.items[index] ?? null, { nodeId: map.nodeId, attempt: map.attempt, index }));
+            }
+        }
+    }
+    for (const sleep of state.pendingSleeps) {
+        add(sleep.nodeId, [
+            wait({ waitId: sleep.waitId, on: { timerAt: sleep.wakeAt }, tag: { nodeId: sleep.nodeId } }),
+        ]);
+    }
+    for (const pending of state.pendingEffects) {
+        add(pending.nodeId, pending.effects);
+    }
+    return effects;
+}
+function nodeIdForEffect(state, threadId, effectId) {
+    const match = nodeEffects(state, threadId).find((item) => stableEffectId(threadId, item.effect) === effectId);
+    return match?.nodeId ?? null;
+}
+/** Children a node started that have not reported back yet. */
+function unsettledChildren(state, nodeId, threadId) {
+    const children = state.pendingSpawns
+        .filter((item) => item.nodeId === nodeId)
+        .map((item) => item.childThreadId);
+    for (const map of state.pendingMaps) {
+        if (map.nodeId !== nodeId) {
+            continue;
+        }
+        for (let index = 0; index < map.nextIndex; index++) {
+            if (!(String(index) in map.outputs)) {
+                children.push(mapChildThreadId(threadId, map, index));
+            }
+        }
+    }
+    return children;
+}
+/**
+ * Drops a node's pending work and cancels the children it leaves running. `settled` is the child
+ * whose result is finishing the node, which must not be cancelled.
+ */
+function withoutPendingWork(state, nodeId, threadId, settled = null) {
+    const cancels = unsettledChildren(state, nodeId, threadId).filter((childThreadId) => childThreadId !== settled && !state.pendingCancels.includes(childThreadId));
+    return {
+        ...state,
+        pendingCancels: cancels.length === 0 ? state.pendingCancels : [...state.pendingCancels, ...cancels],
+        pendingSpawns: state.pendingSpawns.filter((item) => item.nodeId !== nodeId),
+        pendingMaps: state.pendingMaps.filter((item) => item.nodeId !== nodeId),
+        pendingSleeps: state.pendingSleeps.filter((item) => item.nodeId !== nodeId),
+        pendingEffects: state.pendingEffects.filter((item) => item.nodeId !== nodeId),
+    };
+}
+function stopNode(state, nodeId, threadId) {
+    return {
+        ...withoutPendingWork(state, nodeId, threadId),
+        runningNodes: state.runningNodes.filter((id) => id !== nodeId),
+    };
+}
+/** Drops a node's pending work and emits the event that durably finishes it. */
+function finishNode(state, nodeId, result, error, threadId, settled = null) {
+    const id = `finished_${nodeId}`;
+    const event = {
+        type: 'workflow.node.finished',
+        payload: { nodeId, result, error },
+        threadId,
+    };
+    return {
+        ...withoutPendingWork(state, nodeId, threadId, settled),
+        pendingEmits: [...state.pendingEmits.filter((item) => item.id !== id), { id, event }],
+    };
+}
+function recordMapOutput(state, map, index, output, threadId) {
+    if (String(index) in map.outputs) {
+        return state;
+    }
+    const settled = mapChildThreadId(threadId, map, index);
+    const outputs = { ...map.outputs, [String(index)]: output };
+    const size = utf8JsonBytes(outputs);
+    if (size > map.limitBytes) {
+        const error = new WorkflowValueTooLargeError(`Node ${map.nodeId} outputs`, size, map.limitBytes);
+        return finishNode(state, map.nodeId, null, error.message, threadId, settled);
+    }
+    if (Object.keys(outputs).length === map.items.length) {
+        const ordered = map.items.map((_, i) => outputs[String(i)] ?? null);
+        return finishNode(state, map.nodeId, ordered, null, threadId, settled);
+    }
+    const nextIndex = Math.min(map.items.length, map.nextIndex + 1);
+    return {
+        ...state,
+        pendingMaps: state.pendingMaps.map((item) => item.nodeId === map.nodeId ? { ...item, outputs, nextIndex } : item),
+    };
+}
+function isCurrentAttempt(state, nodeId, attempt) {
+    const node = state.nodes[nodeId];
+    return node?.status === 'running' && (attempt === undefined || attempt === node.attempts);
 }
 export const workflowThread = workflowModule.thread({
     kind: 'workflow',
     shape: WorkflowStateSchema,
     initialState: (ctx) => ({
         definitionName: ctx.definitionName,
+        definitionVersion: ctx.definitionVersion,
         nodes: {},
         concurrency: 8,
         input: ctx.input,
@@ -37,10 +237,12 @@ export const workflowThread = workflowModule.thread({
         needsSchedule: false,
         runningNodes: [],
         pendingSpawns: [],
+        pendingMaps: [],
         pendingSleeps: [],
         pendingEffects: [],
         pendingEmits: [],
-        status: 'running',
+        pendingCancels: [],
+        status: initialWorkflowStatus,
         error: null,
     }),
     step(state, event, ctx) {
@@ -48,6 +250,7 @@ export const workflowThread = workflowModule.thread({
             case 'runtime.thread.started': {
                 const payload = event.payload;
                 const defName = payload.definitionName || state.definitionName;
+                const defVersion = payload.definitionVersion ?? state.definitionVersion ?? DEFAULT_DEFINITION_VERSION;
                 const inputObj = Predicate.isObject(payload.input) ? payload.input : {};
                 const nodeIds = Array.isArray(inputObj.nodeIds)
                     ? inputObj.nodeIds.filter(Predicate.isString)
@@ -59,6 +262,7 @@ export const workflowThread = workflowModule.thread({
                 return {
                     ...state,
                     definitionName: defName,
+                    definitionVersion: defVersion,
                     nodes,
                     nodeIds,
                     input: payload.input ?? state.input,
@@ -74,7 +278,12 @@ export const workflowThread = workflowModule.thread({
                     ...state,
                     nodes: {
                         ...state.nodes,
-                        [nodeId]: { status: 'running', result: null, error: null },
+                        [nodeId]: {
+                            status: 'running',
+                            result: null,
+                            error: null,
+                            attempts: (state.nodes[nodeId]?.attempts ?? 0) + 1,
+                        },
                     },
                     runningNodes: state.runningNodes.includes(nodeId)
                         ? state.runningNodes
@@ -83,46 +292,71 @@ export const workflowThread = workflowModule.thread({
                 };
             }
             case 'workflow.node.finished': {
-                const { nodeId, result, error } = event.payload;
+                const { nodeId, result, error, branch } = event.payload;
                 if (!nodeId) {
                     return state;
                 }
                 const failed = Predicate.isString(error) && error.length > 0;
                 return {
-                    ...state,
+                    ...stopNode(state, nodeId, ctx.threadId),
                     nodes: {
                         ...state.nodes,
                         [nodeId]: {
                             status: failed ? 'failed' : 'completed',
                             result: result ?? null,
                             error: failed ? error : null,
+                            attempts: state.nodes[nodeId]?.attempts ?? 1,
+                            branch,
                         },
                     },
-                    runningNodes: state.runningNodes.filter((id) => id !== nodeId),
-                    pendingSpawns: state.pendingSpawns.filter((item) => item.nodeId !== nodeId),
-                    pendingSleeps: state.pendingSleeps.filter((item) => item.nodeId !== nodeId),
-                    pendingEffects: state.pendingEffects.filter((item) => item.nodeId !== nodeId),
                     pendingEmits: state.pendingEmits.filter((item) => item.id !== `finished_${nodeId}`),
-                    status: failed ? 'failed' : state.status,
                     error: failed ? error : state.error,
-                    needsSchedule: !failed,
+                    needsSchedule: true,
+                };
+            }
+            case 'workflow.node.skipped': {
+                const { nodeId, reason, cause } = event.payload;
+                return {
+                    ...stopNode(state, nodeId, ctx.threadId),
+                    nodes: {
+                        ...state.nodes,
+                        [nodeId]: {
+                            status: 'skipped',
+                            result: null,
+                            error: reason,
+                            attempts: state.nodes[nodeId]?.attempts ?? 0,
+                            skipCause: cause,
+                        },
+                    },
+                    needsSchedule: true,
                 };
             }
             case 'workflow.spawn.requested': {
-                const { childThreadId, kind, definitionName, nodeId, input } = event.payload;
-                if (!childThreadId || !kind || !definitionName || !nodeId) {
+                const { nodeId } = event.payload;
+                if (!isCurrentAttempt(state, nodeId, event.payload.attempt)) {
                     return state;
                 }
                 return {
                     ...state,
                     pendingSpawns: [
                         ...state.pendingSpawns.filter((item) => item.nodeId !== nodeId),
+                        event.payload,
+                    ],
+                };
+            }
+            case 'workflow.map.requested': {
+                const { nodeId } = event.payload;
+                if (!isCurrentAttempt(state, nodeId, event.payload.attempt)) {
+                    return state;
+                }
+                return {
+                    ...state,
+                    pendingMaps: [
+                        ...state.pendingMaps.filter((item) => item.nodeId !== nodeId),
                         {
-                            childThreadId,
-                            kind,
-                            definitionName,
-                            nodeId,
-                            input: input ?? null,
+                            ...event.payload,
+                            nextIndex: Math.min(event.payload.concurrency, event.payload.items.length),
+                            outputs: {},
                         },
                     ],
                 };
@@ -146,13 +380,16 @@ export const workflowThread = workflowModule.thread({
                 if (!nodeId) {
                     return state;
                 }
+                const attempts = state.nodes[nodeId]?.attempts ?? 1;
+                const key = nodeRunKey(nodeId, attempts, state.nodes[nodeId]?.iteration?.index);
                 const taggedEffects = effects.map((effect, idx) => {
                     if (effect.type === 'runtime.wait' && 'on' in effect) {
-                        const tag = Predicate.isObject(effect.tag) ? { ...effect.tag, nodeId } : { nodeId };
+                        const scope = { nodeId, attempt: attempts };
+                        const tag = Predicate.isObject(effect.tag) ? { ...effect.tag, ...scope } : scope;
                         return { ...effect, tag };
                     }
                     if (!('tag' in effect && Predicate.isString(effect.tag))) {
-                        return { ...effect, tag: `${nodeId}_${effect.type}_${idx}` };
+                        return { ...effect, tag: `${key}_${effect.type}_${idx}` };
                     }
                     return effect;
                 });
@@ -169,72 +406,58 @@ export const workflowThread = workflowModule.thread({
                 if (isWithdrawnError(error)) {
                     return state;
                 }
-                const running = Object.entries(state.nodes).find(([, node]) => node.status === 'running');
-                if (!running) {
+                const effectId = event.payload.effectId;
+                const nodeId = Predicate.isString(effectId)
+                    ? nodeIdForEffect(state, ctx.threadId, effectId)
+                    : null;
+                if (!nodeId) {
                     return state;
                 }
-                const nodeId = running[0];
                 const message = `Node ${nodeId} failed: ${error}`;
                 return {
-                    ...state,
+                    ...finishNode(stopNode(state, nodeId, ctx.threadId), nodeId, null, message, ctx.threadId),
                     nodes: {
                         ...state.nodes,
-                        [nodeId]: { status: 'failed', result: null, error: message },
-                    },
-                    runningNodes: state.runningNodes.filter((id) => id !== nodeId),
-                    pendingSpawns: state.pendingSpawns.filter((item) => item.nodeId !== nodeId),
-                    pendingSleeps: state.pendingSleeps.filter((item) => item.nodeId !== nodeId),
-                    pendingEffects: state.pendingEffects.filter((item) => item.nodeId !== nodeId),
-                    pendingEmits: [
-                        ...state.pendingEmits.filter((item) => item.id !== `finished_${nodeId}`),
-                        {
-                            id: `finished_${nodeId}`,
-                            event: {
-                                type: 'workflow.node.finished',
-                                payload: { nodeId, result: null, error: message },
-                                threadId: ctx.threadId,
-                            },
+                        [nodeId]: {
+                            status: 'failed',
+                            result: null,
+                            error: message,
+                            attempts: state.nodes[nodeId]?.attempts,
                         },
-                    ],
+                    },
                 };
             }
             case 'runtime.wait.satisfied': {
                 const tag = event.payload.tag;
-                if (!Predicate.isObject(tag)) {
+                if (!isJsonObject(tag) || !Predicate.isString(tag.nodeId)) {
                     return state;
                 }
-                const nodeId = Predicate.isString(tag.nodeId) ? tag.nodeId : undefined;
-                if (!nodeId) {
+                const nodeId = tag.nodeId;
+                if (!isCurrentAttempt(state, nodeId, tag.attempt)) {
                     return state;
                 }
-                const embedded = event.payload.event;
-                const embeddedObj = Predicate.isObject(embedded) && Predicate.isObject(embedded.payload)
-                    ? embedded.payload
-                    : {};
-                const error = Predicate.isString(embeddedObj.error) ? embeddedObj.error : null;
-                const result = embeddedObj.output ?? (Predicate.isObject(embedded) ? embedded.payload : { waited: true });
-                return {
-                    ...state,
-                    pendingSpawns: state.pendingSpawns.filter((item) => item.nodeId !== nodeId),
-                    pendingSleeps: state.pendingSleeps.filter((item) => item.nodeId !== nodeId),
-                    pendingEffects: state.pendingEffects.filter((item) => item.nodeId !== nodeId),
-                    pendingEmits: [
-                        ...state.pendingEmits.filter((item) => item.id !== `finished_${nodeId}`),
-                        {
-                            id: `finished_${nodeId}`,
-                            event: {
-                                type: 'workflow.node.finished',
-                                payload: {
-                                    nodeId,
-                                    // SAFETY: result is serialized to a JSON-compatible node execution result.
-                                    result: asJson(result) ?? null,
-                                    error,
-                                },
-                                threadId: ctx.threadId,
-                            },
+                const { result, error } = waitOutcome(event.payload.event, tag, { waited: true });
+                const map = state.pendingMaps.find((item) => item.nodeId === nodeId);
+                if (error === null && map && Predicate.isNumber(tag.index)) {
+                    return recordMapOutput(state, map, tag.index, result, ctx.threadId);
+                }
+                const node = state.nodes[nodeId];
+                if (error === null && node && Predicate.isNumber(tag.loopIndex)) {
+                    return {
+                        ...state,
+                        nodes: {
+                            ...state.nodes,
+                            [nodeId]: { ...node, iteration: { index: tag.loopIndex + 1, previous: result } },
                         },
-                    ],
-                };
+                        pendingSpawns: state.pendingSpawns.filter((item) => item.nodeId !== nodeId),
+                    };
+                }
+                const satisfied = event.payload.event;
+                const satisfiedPayload = Predicate.isObject(satisfied) ? satisfied.payload : undefined;
+                const settled = Predicate.isObject(satisfiedPayload) && Predicate.isString(satisfiedPayload.threadId)
+                    ? satisfiedPayload.threadId
+                    : null;
+                return finishNode(state, nodeId, result, error, ctx.threadId, settled);
             }
             default:
                 return state;
@@ -245,40 +468,15 @@ export const workflowThread = workflowModule.thread({
         if (state.needsSchedule) {
             effects.push(scheduleInvocation(state));
         }
-        for (const nodeId of state.runningNodes) {
-            effects.push(runNodeInvocation(state, nodeId));
-        }
-        for (const spawnReq of state.pendingSpawns) {
-            const waitId = createWaitId(ctx.threadId, `spawn_${spawnReq.childThreadId}`);
-            effects.push(spawn({
-                childThreadId: spawnReq.childThreadId,
-                kind: spawnReq.kind,
-                definitionName: spawnReq.definitionName,
-                input: spawnReq.input,
-            }), wait({
-                waitId,
-                on: {
-                    type: ['runtime.thread.completed', 'runtime.thread.failed'],
-                    match: { threadId: spawnReq.childThreadId },
-                },
-                tag: { nodeId: spawnReq.nodeId },
-            }));
-        }
-        for (const sleepReq of state.pendingSleeps) {
-            effects.push(wait({
-                waitId: sleepReq.waitId,
-                on: { timerAt: sleepReq.wakeAt },
-                tag: { nodeId: sleepReq.nodeId },
-            }));
-        }
-        for (const effectReq of state.pendingEffects) {
-            for (const eff of effectReq.effects) {
-                effects.push(eff);
-            }
+        for (const item of nodeEffects(state, ctx.threadId)) {
+            effects.push(item.effect);
         }
         for (const emitReq of state.pendingEmits) {
             effects.push(emit(emitReq.event));
         }
+        for (const childThreadId of state.pendingCancels) {
+            effects.push(cancel(childThreadId));
+        }
         if (state.status === 'failed') {
             effects.push(fail(state.error ?? 'Workflow execution failed'));
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swirls/looms",
-  "version": "0.0.2",
+  "version": "0.1.0",
   "description": "Pluggable event-sourced runtime for durable agents and workflows",
   "homepage": "https://github.com/ByteSliceHQ/looms#readme",
   "bugs": {
@@ -65,6 +65,10 @@
       "types": "./dist/debugger/index.d.ts",
       "import": "./dist/debugger/index.js"
     },
+    "./evaluator": {
+      "types": "./dist/evaluator/index.d.ts",
+      "import": "./dist/evaluator/index.js"
+    },
     "./projectors": {
       "types": "./dist/projectors/index.d.ts",
       "import": "./dist/projectors/index.js"
@@ -144,6 +148,7 @@
     "@looms/cloudflare": "workspace:*",
     "@looms/core": "workspace:*",
     "@looms/debugger": "workspace:*",
+    "@looms/evaluator": "workspace:*",
     "@looms/projectors": "workspace:*",
     "@looms/react": "workspace:*",
     "@looms/runtime": "workspace:*",
@@ -151,7 +156,7 @@
     "@looms/testing": "workspace:*",
     "@looms/workflow": "workspace:*",
     "@types/bun": "^1.3.9",
-    "ai": "^7.0.92",
+    "ai": "^7.0.105",
     "postgres": "^3.4.0",
     "react": "19",
     "react-dom": "19",

package/dist/runtime/events-api.d.ts

@@ -1,4 +0,0 @@
-import { encodeLoomsEvent, type EncodedLoomsEvent, type EventStore } from '@swirls/looms/core';
-import type { LoomsRuntime } from './runtime';
-export { encodeLoomsEvent, type EncodedLoomsEvent };
-export declare function handleEventsApi(req: Request, runtime: LoomsRuntime, store: EventStore): Promise<Response>;

package/dist/runtime/events-api.js

@@ -1,84 +0,0 @@
-import { Effect, Predicate } from 'effect';
-import { decodeAppendableEvent, encodeLoomsEvent, EventStoreConflictError, EventStoreTag, } from '@swirls/looms/core';
-import { createEventStreamResponse } from './sse.js';
-export { encodeLoomsEvent };
-function readCursor(req, url) {
-    const lastEventId = req.headers.get('last-event-id');
-    const raw = lastEventId !== null && lastEventId !== ''
-        ? lastEventId
-        : (url.searchParams.get('cursor') ?? '0');
-    const parsed = Number(raw);
-    return Number.isFinite(parsed) && parsed >= 0 ? parsed : 0;
-}
-function readRunId(url) {
-    return url.searchParams.get('runId');
-}
-export async function handleEventsApi(req, runtime, store) {
-    const url = new URL(req.url);
-    if (req.method === 'HEAD') {
-        return new Response(null, { status: 200 });
-    }
-    if (req.method === 'GET') {
-        const runId = readRunId(url);
-        if (!runId) {
-            return Response.json({ error: 'runId required' }, { status: 400 });
-        }
-        const cursor = readCursor(req, url);
-        const acceptHeader = req.headers.get('accept') ?? '';
-        const isLive = url.searchParams.get('live') === 'true' ||
-            url.searchParams.get('live') === '1' ||
-            acceptHeader.includes('text/event-stream');
-        if (!isLive) {
-            const events = await Effect.runPromise(store.read(runId, { fromSeq: cursor + 1 }));
-            const bounds = store.bounds
-                ? await Effect.runPromise(store.bounds(runId))
-                : { head: events[0]?.seq ?? 1, tail: await Effect.runPromise(store.tail(runId)) };
-            return Response.json({
-                batch: events.map(encodeLoomsEvent),
-                head: bounds.head,
-                tail: bounds.tail,
-            });
-        }
-        return createEventStreamResponse({
-            signal: req.signal,
-            request: req,
-            store,
-            runId,
-            fromSeq: cursor + 1,
-        });
-    }
-    if (req.method === 'POST') {
-        const body = await req.json();
-        const runId = readRunId(url) ??
-            (Predicate.isReadonlyObject(body) && Predicate.isString(body.runId) ? body.runId : null);
-        if (!runId) {
-            return Response.json({ error: 'runId required' }, { status: 400 });
-        }
-        const batch = Predicate.isReadonlyObject(body) && Array.isArray(body.batch) ? body.batch : [];
-        const expectedTail = Predicate.isReadonlyObject(body) && Predicate.isNumber(body.expectedTail)
-            ? body.expectedTail
-            : 0;
-        const tail = await Effect.runPromise(store.tail(runId));
-        if (expectedTail !== tail) {
-            return Response.json({ _tag: 'ServerAheadError', expected: expectedTail, actual: tail }, { status: 409 });
-        }
-        const appendable = batch
-            .map((item) => {
-            // SAFETY: push batch items are host-encoded envelopes.
-            return decodeAppendableEvent(item, runId);
-        })
-            .filter((item) => item !== undefined);
-        try {
-            await Effect.runPromise(store.append(runId, appendable, { expectedTail }));
-        }
-        catch (err) {
-            if (err instanceof EventStoreConflictError) {
-                return Response.json({ _tag: 'ServerAheadError', expected: err.expectedTail, actual: err.actualTail }, { status: 409 });
-            }
-            throw err;
-        }
-        await Effect.runPromise(Effect.provideService(runtime.wake(runId), EventStoreTag, store));
-        return Response.json({ ok: true });
-    }
-    return new Response('Method Not Allowed', { status: 405 });
-}