@swirls/looms 0.3.0 → 0.5.0

package/dist/react/store.js

@@ -1,9 +1,9 @@
 import { Data, Effect, Fiber, Option, Predicate, Schema } from 'effect';
-import { decodeLoomsEvent, stringifyJson, } from '@swirls/looms/core';
+import { decodeLoomsEvent, readSubscriptionData, stringifyJson, } from '@swirls/looms/core';
 import { EventIndex, ProjectionCache } from './derived.js';
 import { materializeEvents } from './materialize.js';
 import { createNotifyScheduler } from './notify.js';
-import { consumeSseStreamEffect, eventsFromSseData } from './sse.js';
+import { consumeSseStreamEffect } from './sse.js';
 import { emptyTables } from './tables.js';
 class LoomsStoreError extends Data.TaggedError('LoomsStoreError') {
     constructor(message, cause) {
@@ -11,6 +11,18 @@ class LoomsStoreError extends Data.TaggedError('LoomsStoreError') {
         this.name = 'LoomsStoreError';
     }
 }
+function socketConstructor(options) {
+    if (options.transport !== 'websocket' && options.transport !== 'auto') {
+        return undefined;
+    }
+    if (options.webSocket) {
+        return options.webSocket;
+    }
+    if (!('WebSocket' in globalThis) || !Predicate.isFunction(globalThis.WebSocket)) {
+        return undefined;
+    }
+    return globalThis.WebSocket;
+}
 function eventSourceCtor() {
     if (typeof EventSource === 'undefined') {
         return undefined;
@@ -42,6 +54,7 @@ export function createLoomsStore(options) {
     let liveStarted = false;
     let liveAbort;
     let eventSource;
+    let socket;
     let reconnectFiber;
     let syncing = null;
     const publishedEvents = () => {
@@ -88,11 +101,33 @@ export function createLoomsStore(options) {
         version += 1;
         notify.schedule();
     };
-    const applyEncoded = (data) => {
-        applyBatch(eventsFromSseData(data, options.storeId));
+    const applyLiveData = (data) => {
+        const read = readSubscriptionData(data, options.storeId);
+        switch (read.kind) {
+            case 'events':
+                applyBatch(read.events.slice());
+                return 'continue';
+            case 'resync':
+                fromSeq = read.head;
+                return 'resync';
+            case 'hello':
+            case 'ignore':
+                return 'continue';
+            default: {
+                const unexpected = read;
+                return unexpected;
+            }
+        }
     };
     const liveUrl = () => {
-        return `${endpoint}/runs/${encodeURIComponent(options.storeId)}/events?live=true&fromSeq=${fromSeq}`;
+        const params = new URLSearchParams({ live: 'true', fromSeq: String(fromSeq) });
+        if (options.threadId) {
+            params.set('threadId', options.threadId);
+        }
+        if (options.includeEphemeral === false) {
+            params.set('includeEphemeral', 'false');
+        }
+        return `${endpoint}/runs/${encodeURIComponent(options.storeId)}/events?${params.toString()}`;
     };
     const pull = Effect.gen(function* () {
         const url = `${endpoint}/runs/${encodeURIComponent(options.storeId)}/events?fromSeq=${fromSeq}`;
@@ -135,7 +170,7 @@ export function createLoomsStore(options) {
         });
         return syncing;
     };
-    const scheduleReconnect = (Ctor) => {
+    const scheduleReconnect = (start) => {
         if (disposed || !liveStarted || reconnectFiber !== undefined) {
             return;
         }
@@ -150,7 +185,7 @@ export function createLoomsStore(options) {
                 catch: (cause) => new LoomsStoreError('Event resync failed', cause),
             }).pipe(Effect.ignore);
             if (!disposed && liveStarted) {
-                startEventSource(Ctor);
+                start();
             }
         }));
     };
@@ -165,7 +200,16 @@ export function createLoomsStore(options) {
             setStatus('live');
         });
         es.addEventListener('message', (msg) => {
-            applyEncoded(msg.data);
+            if (applyLiveData(msg.data) === 'resync') {
+                es.close();
+                if (eventSource === es) {
+                    eventSource = undefined;
+                }
+                setStatus('reconnecting');
+                scheduleReconnect(() => {
+                    startEventSource(Ctor);
+                });
+            }
         });
         es.addEventListener('error', () => {
             live = es.readyState === Ctor.OPEN;
@@ -178,7 +222,9 @@ export function createLoomsStore(options) {
                 if (eventSource === es) {
                     eventSource = undefined;
                 }
-                scheduleReconnect(Ctor);
+                scheduleReconnect(() => {
+                    startEventSource(Ctor);
+                });
             }
             else if (!live) {
                 setStatus('reconnecting');
@@ -209,9 +255,7 @@ export function createLoomsStore(options) {
                     }
                     live = true;
                     setStatus('live');
-                    return yield* consumeSseStreamEffect(body, (frame) => {
-                        applyEncoded(frame.data);
-                    });
+                    return yield* consumeSseStreamEffect(body, (frame) => applyLiveData(frame.data) === 'resync' ? false : undefined);
                 }).pipe(Effect.catch(() => Effect.sync(() => {
                     live = false;
                     if (!disposed) {
@@ -226,12 +270,58 @@ export function createLoomsStore(options) {
         });
         void Effect.runPromise(run, { signal: controller.signal }).catch(() => undefined);
     };
+    const startWebSocket = (Ctor) => {
+        if (disposed || !liveStarted) {
+            return;
+        }
+        let url;
+        try {
+            const http = new URL(liveUrl());
+            http.protocol = http.protocol === 'https:' ? 'wss:' : 'ws:';
+            url = http.toString();
+        }
+        catch {
+            startFetchStream();
+            return;
+        }
+        const ws = new Ctor(url);
+        socket = ws;
+        ws.addEventListener('open', () => {
+            live = true;
+            setStatus('live');
+        });
+        ws.addEventListener('message', (event) => {
+            if (!Predicate.isString(event.data)) {
+                return;
+            }
+            if (applyLiveData(event.data) === 'resync') {
+                ws.close();
+            }
+        });
+        ws.addEventListener('close', () => {
+            live = false;
+            if (socket === ws) {
+                socket = undefined;
+            }
+            if (!disposed && liveStarted) {
+                setStatus('reconnecting');
+                scheduleReconnect(() => {
+                    startWebSocket(Ctor);
+                });
+            }
+        });
+    };
     const startLive = () => {
         if (!options.storeId || (liveStarted && !disposed)) {
             return;
         }
         liveStarted = true;
         disposed = false;
+        const socketCtor = socketConstructor(options);
+        if (socketCtor) {
+            startWebSocket(socketCtor);
+            return;
+        }
         const ctor = options.fetch === undefined ? eventSourceCtor() : undefined;
         if (ctor) {
             startEventSource(ctor);
@@ -249,6 +339,8 @@ export function createLoomsStore(options) {
         }
         eventSource?.close();
         eventSource = undefined;
+        socket?.close();
+        socket = undefined;
         liveAbort?.abort();
         liveAbort = undefined;
     };

package/dist/react/tables.d.ts

@@ -1,10 +1,13 @@
-import type { RunStatus, ThreadStatus } from '@swirls/looms/core';
+import type { RunAttributes, RunLaunchSource, RunStatus, ThreadStatus } from '@swirls/looms/core';
 export interface RunRow {
     runId: string;
     status: RunStatus;
     rootThreadId: string | null;
     kind: string | null;
     definitionName: string | null;
+    /** The effect in another run that launched this one. */
+    launchedBy: RunLaunchSource | null;
+    attributes: RunAttributes;
 }
 export interface ThreadRow {
     threadId: string;

package/dist/runtime/cancellation.d.ts

@@ -1,4 +1,4 @@
-import { type ComposedRegistry } from '@swirls/looms/core';
+import { type ComposedRegistry, type RunLauncher } from '@swirls/looms/core';
 import type { RunIngress } from './ingress';
 import { type RuntimeObserver } from './observer';
 import type { RuntimeRepository } from './repository';
@@ -12,5 +12,6 @@ export interface CancellationOptions {
     readonly observer?: RuntimeObserver;
     readonly wake: LoomsRuntime['wake'];
     readonly withRunIngress: RunIngress;
+    readonly launcher: () => RunLauncher;
 }
 export declare function createCancellation(options: CancellationOptions): LoomsRuntime['cancel'];

package/dist/runtime/cancellation.js

@@ -75,6 +75,32 @@ export function createCancellation(options) {
             const store = yield* EventStoreTag;
             const now = yield* Clock.currentTimeMillis;
             return yield* repository.commit(store, runId, (current) => {
+                const rootCancel = threadId === undefined || threadId === current.state.rootThreadId;
+                const deferClose = rootCancel &&
+                    !current.state.childCloseSent &&
+                    current.state.launchedRuns.some((child) => child.close === 'wait');
+                if (deferClose) {
+                    const requested = createEvent(runId, {
+                        type: 'runtime.child.close.requested',
+                        payload: { policy: 'wait' },
+                        threadId: current.state.rootThreadId,
+                        origin: { type: 'system' },
+                        idempotencyKey: `child-close:${current.state.rootThreadId ?? runId}`,
+                    });
+                    return Effect.succeed({
+                        events: [requested],
+                        value: {
+                            plan: {
+                                events: [],
+                                threadIds: new Set(),
+                                workerCancellations: [],
+                            },
+                            now,
+                            childRunIds: current.state.launchedRuns.map((child) => child.runId),
+                        },
+                        idempotencyKey: `signal:child-close:${current.state.rootThreadId ?? runId}`,
+                    });
+                }
                 const plan = planCancellation({
                     runId,
                     seq: current.seq,
@@ -84,14 +110,21 @@ export function createCancellation(options) {
                     worker,
                     now,
                 });
+                const childRunIds = [];
                 return Effect.succeed({
                     events: plan.events,
-                    value: { plan, now },
+                    value: { plan, now, childRunIds },
                     idempotencyKey: `signal:cancel:${threadId ?? current.state.rootThreadId ?? ''}`,
                 });
             });
         }));
-        const { plan, now } = committed.value;
+        const { plan, now, childRunIds } = committed.value;
+        if (childRunIds.length > 0) {
+            yield* Effect.forEach(childRunIds, (childRunId) => options.launcher().cancel(childRunId), {
+                concurrency: 1,
+                discard: true,
+            });
+        }
         if (committed.append) {
             executionContexts.abort(runId, plan.threadIds, 'Effect cancelled');
             for (const { item, execution } of plan.workerCancellations) {

package/dist/runtime/child-run.d.ts

@@ -0,0 +1,10 @@
+import { Effect } from 'effect';
+import { type EventInput, type RunLauncher, type RunState } from '@swirls/looms/core';
+/** Tell the launching run that this child has reached a terminal status. */
+export declare function notifyLaunchingParent(launcher: RunLauncher, runId: string, state: RunState): Effect.Effect<void, Error>;
+/**
+ * When a run asked to wait for child cancellation and those children are gone, cancel the
+ * run's own threads. The caller appends these events from the parent wake, which must not
+ * call `runtime.cancel` on itself.
+ */
+export declare function childCloseCancellations(state: RunState): EventInput[];

package/dist/runtime/child-run.js

@@ -0,0 +1,58 @@
+import { Effect } from 'effect';
+import { descendantThreadIds, isTerminalStatus, } from '@swirls/looms/core';
+/** Tell the launching run that this child has reached a terminal status. */
+export function notifyLaunchingParent(launcher, runId, state) {
+    const launchedBy = state.startIdentity?.launchedBy;
+    const status = state.status;
+    if (!launchedBy || status === 'running') {
+        return Effect.void;
+    }
+    const root = state.rootThreadId ? state.threads[state.rootThreadId] : undefined;
+    const error = status === 'completed' ? null : (root?.error ?? status);
+    return launcher.signal(launchedBy.runId, [
+        {
+            type: 'runtime.child.settled',
+            payload: {
+                runId,
+                status,
+                output: root?.output ?? null,
+                error,
+            },
+            threadId: launchedBy.threadId,
+            idempotencyKey: `child-settled:${runId}`,
+            origin: { type: 'run', runId },
+        },
+    ], { idempotencyKey: `child-settled:${runId}` });
+}
+/**
+ * When a run asked to wait for child cancellation and those children are gone, cancel the
+ * run's own threads. The caller appends these events from the parent wake, which must not
+ * call `runtime.cancel` on itself.
+ */
+export function childCloseCancellations(state) {
+    if (!state.closeWaiting || state.launchedRuns.some((run) => run.close === 'wait')) {
+        return [];
+    }
+    const rootId = state.rootThreadId;
+    if (!rootId) {
+        return [];
+    }
+    const root = state.threads[rootId];
+    if (!root || isTerminalStatus(root.status)) {
+        return [];
+    }
+    const ids = [...descendantThreadIds(state, rootId).toReversed(), rootId];
+    return ids.flatMap((threadId) => {
+        const record = state.threads[threadId];
+        if (!record || isTerminalStatus(record.status)) {
+            return [];
+        }
+        return [
+            {
+                type: 'runtime.thread.cancelled',
+                payload: { threadId, reason: 'cancelled' },
+                threadId,
+            },
+        ];
+    });
+}

package/dist/runtime/deadline-transition-planner.js

@@ -1,4 +1,4 @@
-import { createEvent, foldRun, isRunTerminal, isWaitOnTimer, } from '@swirls/looms/core';
+import { createEvent, deferredUntil, foldRun, isRunTerminal, isWaitOnTimer, } from '@swirls/looms/core';
 import { waitSatisfiedEvents } from './helpers.js';
 import { planAttemptFailure } from './retry-policy.js';
 const EMPTY_PLAN = {
@@ -122,7 +122,16 @@ export function nextRuntimeDeadline(state, after = Number.NEGATIVE_INFINITY) {
         execution.deadlineAt > after
         ? [execution.deadlineAt]
         : []);
-    const deadlines = [...timers, ...executions];
+    const deferred = terminal
+        ? []
+        : state.outstandingEffects.flatMap((item) => {
+            if (state.effectExecutions[item.effectId]) {
+                return [];
+            }
+            const at = deferredUntil(item.effect);
+            return at !== undefined && at > after ? [at] : [];
+        });
+    const deadlines = [...timers, ...executions, ...deferred];
     return deadlines.length > 0 ? Math.min(...deadlines) : undefined;
 }
 function cancellationAmbiguous(runId, effectId, attempt) {

package/dist/runtime/dispatch-effect.d.ts

@@ -1,4 +1,4 @@
 import type { Context, ManagedRuntime } from 'effect';
 import { Effect } from 'effect';
-import { type ComposedRegistry, type EffectContext, type EventInput, type RegisteredDefinition, type RuntimeEffect } from '@swirls/looms/core';
-export declare function dispatchEffect(registry: ComposedRegistry, services: ManagedRuntime.ManagedRuntime<Context.Service.Any, never>, definitions: ReadonlyMap<string, RegisteredDefinition>, effect: RuntimeEffect, ctx: EffectContext): Effect.Effect<ReadonlyArray<EventInput>, Error>;
+import { type ComposedRegistry, type EffectContext, type EventInput, type DefinitionResolver, type RunLauncher, type RuntimeEffect } from '@swirls/looms/core';
+export declare function dispatchEffect(registry: ComposedRegistry, services: ManagedRuntime.ManagedRuntime<Context.Service.Any, never>, definitions: DefinitionResolver, launcher: RunLauncher, effect: RuntimeEffect, ctx: EffectContext): Effect.Effect<ReadonlyArray<EventInput>, Error>;

package/dist/runtime/dispatch-effect.js

@@ -1,7 +1,28 @@
-import { Effect } from 'effect';
-import { asJson, isPrimitiveEffect, isWaitOnTimer, } from '@swirls/looms/core';
+import { Effect, Predicate } from 'effect';
+import { asJson, isPrimitiveEffect, isWaitOnTimer, readEffectFailure, RunLauncherTag, } from '@swirls/looms/core';
 import { threadStartedEvents } from './helpers.js';
-export function dispatchEffect(registry, services, definitions, effect, ctx) {
+function causeMessage(cause) {
+    if (Predicate.isString(cause)) {
+        return cause;
+    }
+    if (cause instanceof Error) {
+        return cause.message;
+    }
+    return String(cause);
+}
+function failedAttempt(effectId, threadId, cause) {
+    const failure = readEffectFailure(cause);
+    const error = failure?.error ?? causeMessage(cause);
+    const payload = { effectId, error };
+    if (failure?.nonRetryable) {
+        payload.nonRetryable = true;
+    }
+    if (failure?.retryAfterMs !== undefined) {
+        payload.retryAfterMs = failure.retryAfterMs;
+    }
+    return { type: 'runtime.effect.failed', payload, threadId };
+}
+export function dispatchEffect(registry, services, definitions, launcher, effect, ctx) {
     const currentThreadId = ctx.threadId;
     const baseDispatch = (eff, effCtx) => {
         if (isPrimitiveEffect(eff)) {
@@ -67,6 +88,20 @@ export function dispatchEffect(registry, services, definitions, effect, ctx) {
                         },
                     ]);
                 }
+                case 'runtime.launch':
+                    return launcher
+                        .launch({
+                        runId: eff.runId,
+                        kind: eff.kind,
+                        definitionName: eff.definitionName,
+                        definitionVersion: eff.definitionVersion,
+                        input: eff.input,
+                        idempotencyKey: eff.runId,
+                        close: eff.close,
+                    })
+                        .pipe(Effect.map(() => []));
+                case 'runtime.cancelRun':
+                    return launcher.cancel(eff.runId).pipe(Effect.map(() => []));
                 default: {
                     const exhaustiveCheck = eff;
                     return exhaustiveCheck;
@@ -76,28 +111,17 @@ export function dispatchEffect(registry, services, definitions, effect, ctx) {
         const handler = registry.effects.get(eff.type);
         if (!handler) {
             return Effect.succeed([
-                {
-                    type: 'runtime.effect.failed',
-                    payload: { effectId: effCtx.effectId, error: `No handler for ${eff.type}` },
-                    threadId: currentThreadId,
-                },
+                failedAttempt(effCtx.effectId, currentThreadId, `No handler for ${eff.type}`),
             ]);
         }
         const input = 'input' in eff ? eff.input : {};
         const execution = Effect.gen(function* () {
             const serviceContext = yield* services.contextEffect;
-            return yield* handler.execute(input, effCtx).pipe(Effect.provide(serviceContext));
+            return yield* handler
+                .execute(input, effCtx)
+                .pipe(Effect.provideService(RunLauncherTag, launcher), Effect.provide(serviceContext));
         });
-        return execution.pipe(Effect.catch((err) => Effect.succeed([
-            {
-                type: 'runtime.effect.failed',
-                payload: {
-                    effectId: effCtx.effectId,
-                    error: err instanceof Error ? err.message : String(err),
-                },
-                threadId: currentThreadId,
-            },
-        ])));
+        return execution.pipe(Effect.catch((err) => Effect.succeed([failedAttempt(effCtx.effectId, currentThreadId, err)])));
     };
     if (registry.middleware && registry.middleware.length > 0) {
         const pipeline = registry.middleware.reduceRight((next, mw) => (e, c) => mw(e, c, next), baseDispatch);

package/dist/runtime/errors.d.ts

@@ -1,4 +1,4 @@
-import type { JsonValue, RunStartIdentity as DurableRunStartIdentity } from '@swirls/looms/core';
+import type { JsonValue, RunAttributes, RunLaunchSource, RunStartIdentity as DurableRunStartIdentity } from '@swirls/looms/core';
 export interface RunStartIdentity {
     readonly kind: string;
     readonly definitionName: string;
@@ -6,6 +6,19 @@ export interface RunStartIdentity {
     readonly input: JsonValue;
     readonly requestedThreadId: string | null;
     readonly idempotencyKey: string | null;
+    readonly launchedBy: RunLaunchSource | null;
+    readonly correlationId: string | null;
+    readonly attributes: RunAttributes;
+}
+declare const SecretContextConflictError_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: "SecretContextConflictError";
+} & Readonly<A>;
+/** The stored secret context differs. The message never includes the secret values. */
+export declare class SecretContextConflictError extends SecretContextConflictError_base<{
+    readonly runId: string;
+    readonly message: string;
+}> {
+    constructor(runId: string);
 }
 declare const StartRunConflictError_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: "StartRunConflictError";

package/dist/runtime/errors.js

@@ -1,4 +1,14 @@
 import { Data } from 'effect';
+/** The stored secret context differs. The message never includes the secret values. */
+export class SecretContextConflictError extends Data.TaggedError('SecretContextConflictError') {
+    constructor(runId) {
+        super({
+            runId,
+            message: `Run "${runId}" already has a different secret context`,
+        });
+        this.name = 'SecretContextConflictError';
+    }
+}
 export class StartRunConflictError extends Data.TaggedError('StartRunConflictError') {
     constructor(runId, requested, existing, mismatches) {
         super({

package/dist/runtime/filesystem-blob-store.d.ts

@@ -0,0 +1,6 @@
+import { type BlobStore } from '@swirls/looms/core';
+/**
+ * Content-addressed blob store rooted at `directory`. For Bun and Node hosts.
+ * A Durable Object should use `r2BlobStore` instead.
+ */
+export declare function filesystemBlobStore(directory: string): BlobStore;

package/dist/runtime/filesystem-blob-store.js

@@ -0,0 +1,59 @@
+import { mkdir, readdir, readFile, rm, stat, writeFile } from 'node:fs/promises';
+import { Data, Effect, Predicate } from 'effect';
+import { blobStoreFromBytes, BlobStoreError } from '@swirls/looms/core';
+class MissingBlobFile extends Data.TaggedError('MissingBlobFile') {
+}
+/**
+ * Content-addressed blob store rooted at `directory`. For Bun and Node hosts.
+ * A Durable Object should use `r2BlobStore` instead.
+ */
+export function filesystemBlobStore(directory) {
+    return blobStoreFromBytes(filesystemBlobBytes(directory));
+}
+function filesystemBlobBytes(directory) {
+    return {
+        read: (key) => readOptional(`${directory}/${key}`, key),
+        write: (key, body) => Effect.tryPromise({
+            try: () => mkdir(`${directory}/${folderOf(key)}`, { recursive: true }),
+            catch: (cause) => new BlobStoreError(`Unable to create a directory for blob key ${key}`, cause),
+        }).pipe(Effect.andThen(Effect.tryPromise({
+            try: () => writeFile(`${directory}/${key}`, body),
+            catch: (cause) => new BlobStoreError(`Unable to write blob key ${key}`, cause),
+        }))),
+        remove: (key) => Effect.tryPromise({
+            try: () => rm(`${directory}/${key}`, { force: true }),
+            catch: (cause) => new BlobStoreError(`Unable to delete blob key ${key}`, cause),
+        }),
+        exists: (key) => Effect.tryPromise({
+            try: () => stat(`${directory}/${key}`),
+            catch: (cause) => isMissingFile(cause)
+                ? new MissingBlobFile()
+                : new BlobStoreError(`Unable to check blob key ${key}`, cause),
+        }).pipe(Effect.as(true), Effect.catchTag('MissingBlobFile', () => Effect.succeed(false))),
+        list: (prefix) => listFolder(directory, prefix),
+    };
+}
+function readOptional(path, key) {
+    return Effect.tryPromise({
+        try: () => readFile(path),
+        catch: (cause) => isMissingFile(cause)
+            ? new MissingBlobFile()
+            : new BlobStoreError(`Unable to read blob key ${key}`, cause),
+    }).pipe(Effect.catchTag('MissingBlobFile', () => Effect.succeed(null)), Effect.map((body) => (body === null ? null : new Uint8Array(body))));
+}
+function listFolder(directory, prefix) {
+    const folder = prefix.endsWith('/') ? prefix.slice(0, -1) : prefix;
+    return Effect.tryPromise({
+        try: () => readdir(`${directory}/${folder}`),
+        catch: (cause) => isMissingFile(cause)
+            ? new MissingBlobFile()
+            : new BlobStoreError(`Unable to list blob keys ${prefix}`, cause),
+    }).pipe(Effect.catchTag('MissingBlobFile', () => Effect.succeed([])), Effect.map((names) => names.map((name) => `${folder}/${name}`)));
+}
+function folderOf(key) {
+    const slash = key.lastIndexOf('/');
+    return slash < 0 ? '' : key.slice(0, slash);
+}
+function isMissingFile(cause) {
+    return Predicate.isObject(cause) && 'code' in cause && cause.code === 'ENOENT';
+}

package/dist/runtime/helpers.d.ts

@@ -1,8 +1,17 @@
-import { Effect, Layer, type Context } from 'effect';
-import { type AnyRuntimeModule, type AppendableEvent, type EventCatalog, type EventEnvelope, type EventInput, type EventOrigin, type EventStore, InvalidEventError, type JsonValue, type OutstandingEffect, type RegisteredDefinition, type RunCursor, type RunState, type SnapshotStore } from '@swirls/looms/core';
+import { Effect, Layer, type Context, type Types } from 'effect';
+import { type AnyRuntimeModule, type AppendableEvent, type EventCatalog, type EventEnvelope, type EventInput, type EventOrigin, type EventStore, InvalidEventError, type DefinitionResolveError, type DefinitionResolver, type JsonValue, type OutstandingEffect, type RetryPolicy, type SecretContext, type TraceContext, type RunCursor, type RunState, type SnapshotStore } from '@swirls/looms/core';
 import type { EffectWorkerTask } from './types';
-export declare function workerTask(runId: string, item: OutstandingEffect, attempt: number): EffectWorkerTask;
-declare const UnknownDefinitionError_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 & {
+/** What a dispatch carries beyond the effect itself. */
+export interface WorkerTaskExtras {
+    /** Progress from the previous attempt's last heartbeat. */
+    readonly details?: JsonValue | null;
+    readonly secrets?: SecretContext;
+    readonly trace?: TraceContext | null;
+    readonly retry?: RetryPolicy;
+    readonly scheduleToStartAt?: number | null;
+}
+export declare function workerTask(runId: string, item: OutstandingEffect, attempt: number, extras?: WorkerTaskExtras): EffectWorkerTask;
+declare const UnknownDefinitionError_base: new <A extends Record<string, any> = {}>(args: Types.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
     readonly _tag: "UnknownDefinitionError";
 } & Readonly<A>;
 export declare class UnknownDefinitionError extends UnknownDefinitionError_base<{
@@ -34,14 +43,14 @@ export declare function groupOutstanding(items: readonly {
  * A future third producer of thread.started must call this; do not emit the
  * event with raw input.
  */
-export declare function threadStartedEvents(definitions: ReadonlyMap<string, RegisteredDefinition>, args: {
+export declare function threadStartedEvents(definitions: DefinitionResolver, args: {
     kind: string;
     definitionName: string;
     definitionVersion: string;
     input: JsonValue;
     threadId: string;
     parentThreadId: string | null;
-}): Effect.Effect<ReadonlyArray<EventInput>, UnknownDefinitionError>;
+}): Effect.Effect<ReadonlyArray<EventInput>, UnknownDefinitionError | DefinitionResolveError>;
 export declare function synthesizedThreadFailed(before: RunState, after: RunState, written: readonly EventEnvelope[]): EventInput[];
 /** Cancel whatever is still live below each thread `written` cancels, deepest first. */
 export declare function cascadedCancellations(state: RunState, written: readonly EventEnvelope[]): EventInput[];