@swirls/looms 0.0.2 → 0.1.0

package/dist/runtime/run-execution-context.js

@@ -0,0 +1,56 @@
+import { RuntimeExecutionError } from './errors.js';
+function createRunExecutionContext() {
+    return {
+        activeEffects: new Map(),
+        waking: false,
+        wakeAgain: false,
+        wakeCompletion: null,
+        resolveWakeCompletion: null,
+        ingress: null,
+        liveStore: undefined,
+        liveCount: 0,
+    };
+}
+function isIdle(context) {
+    return (!context.waking &&
+        !context.wakeAgain &&
+        context.wakeCompletion === null &&
+        context.resolveWakeCompletion === null &&
+        context.ingress === null &&
+        context.liveStore === undefined &&
+        context.liveCount === 0 &&
+        context.activeEffects.size === 0);
+}
+export class RunExecutionContexts {
+    runs = new Map();
+    get(runId) {
+        const current = this.runs.get(runId);
+        if (current) {
+            return current;
+        }
+        const created = createRunExecutionContext();
+        this.runs.set(runId, created);
+        return created;
+    }
+    peek(runId) {
+        return this.runs.get(runId);
+    }
+    /** Abort in-process effects owned by the given threads. */
+    abort(runId, threadIds, message) {
+        const activeEffects = this.runs.get(runId)?.activeEffects;
+        if (!activeEffects || threadIds.size === 0) {
+            return;
+        }
+        for (const active of activeEffects.values()) {
+            if (threadIds.has(active.threadId)) {
+                active.controller.abort(new RuntimeExecutionError(message));
+            }
+        }
+    }
+    releaseIfIdle(runId) {
+        const context = this.runs.get(runId);
+        if (context && isIdle(context)) {
+            this.runs.delete(runId);
+        }
+    }
+}

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

@@ -0,0 +1,4 @@
+import { Effect } from 'effect';
+import type { RunState } from '@swirls/looms/core';
+import { RuntimeExecutionError, StartRunConflictError, type RunStartIdentity } from './errors';
+export declare function assertSameDurableStart(runId: string, state: RunState, requested: RunStartIdentity): Effect.Effect<string, RuntimeExecutionError | StartRunConflictError>;

package/dist/runtime/run-start.js

@@ -0,0 +1,44 @@
+import { Effect, Predicate } from 'effect';
+import { RuntimeExecutionError, StartRunConflictError } from './errors.js';
+function canonicalJson(value) {
+    if (Array.isArray(value)) {
+        return `[${value.map(canonicalJson).join(',')}]`;
+    }
+    if (Predicate.isObject(value)) {
+        const keys = Object.keys(value);
+        // oxlint-disable-next-line unicorn/no-array-sort
+        keys.sort();
+        return `{${keys
+            .map((key) => `${JSON.stringify(key)}:${canonicalJson(value[key] ?? null)}`)
+            .join(',')}}`;
+    }
+    return JSON.stringify(value);
+}
+export function assertSameDurableStart(runId, state, requested) {
+    const existing = state.startIdentity;
+    if (!existing) {
+        return Effect.fail(new RuntimeExecutionError(`Run "${runId}" has durable state but no start identity; its legacy snapshot cannot safely validate a retry`));
+    }
+    const mismatches = [];
+    if (existing.kind !== requested.kind) {
+        mismatches.push('kind');
+    }
+    if (existing.definitionName !== requested.definitionName) {
+        mismatches.push('definitionName');
+    }
+    if (existing.definitionVersion !== requested.definitionVersion) {
+        mismatches.push('definitionVersion');
+    }
+    if (canonicalJson(existing.input) !== canonicalJson(requested.input)) {
+        mismatches.push('input');
+    }
+    if (existing.requestedThreadId !== requested.requestedThreadId) {
+        mismatches.push('requestedThreadId');
+    }
+    if (existing.idempotencyKey !== requested.idempotencyKey) {
+        mismatches.push('idempotencyKey');
+    }
+    return mismatches.length > 0
+        ? Effect.fail(new StartRunConflictError(runId, requested, existing, mismatches))
+        : Effect.succeed(existing.rootThreadId);
+}

package/dist/runtime/runtime.d.ts

@@ -1,91 +1,10 @@
-import { Effect } from 'effect';
-import type { EventStoreError, EventStoreFencedError, EventStoreTruncationError } from '@swirls/looms/core';
-import { EventStoreTag, EventStoreTrimmedError, type AnyRuntimeModule, type ComposedRegistry, type EventEnvelope, type EventInput, type EventStore, type JsonValue, type ProjectionDefinition, type ReplayStep, type RunState, type SnapshotStore } from '@swirls/looms/core';
-import { type WakeScheduler } from './wake-scheduler';
+import { type AnyRuntimeModule } from '@swirls/looms/core';
 export type { RegisteredDefinition } from '@swirls/looms/core';
 export type { WakeScheduler } from './wake-scheduler';
 export { createTimeoutScheduler } from './wake-scheduler';
-declare const DuplicateEffectDispatchError_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: "DuplicateEffectDispatchError";
-} & Readonly<A>;
-export declare class DuplicateEffectDispatchError extends DuplicateEffectDispatchError_base<{
-    readonly runId: string;
-    readonly effectId: string;
-    readonly threadId: string;
-    readonly message: string;
-}> {
-    constructor(runId: string, effectId: string, threadId: string);
-}
-declare const MaxWakeIterationsError_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: "MaxWakeIterationsError";
-} & Readonly<A>;
-export declare class MaxWakeIterationsError extends MaxWakeIterationsError_base<{
-    readonly runId: string;
-    readonly maxIterations: number;
-    readonly message: string;
-}> {
-    constructor(runId: string, maxIterations: number);
-}
-export type WakeError = DuplicateEffectDispatchError | MaxWakeIterationsError | EventStoreTruncationError | EventStoreTrimmedError | EventStoreFencedError | EventStoreError | Error;
-export interface CreateRuntimeOptions<TModules extends readonly AnyRuntimeModule[] = readonly AnyRuntimeModule[]> {
-    readonly modules: TModules;
-    readonly store?: EventStore;
-    /**
-     * Durable events between mid-wake snapshots. Default 200; `0` disables.
-     * A snapshot is always taken when a wake parks, so this only bounds replay
-     * after a crash inside one long wake.
-     */
-    readonly snapshotEvery?: number;
-    readonly maxWakeIterations?: number;
-    /** Defaults to the EventStore's attached store or an in-memory SnapshotStore. */
-    readonly snapshotStore?: SnapshotStore;
-    /** Trim the event log behind the oldest kept snapshot. Also sets how many snapshots to keep. */
-    readonly trimAfterSnapshot?: {
-        keepSnapshots: number;
-    };
-    /**
-     * Cursors to keep in process between calls. Default `0`: every call starts
-     * from the store (snapshot + delta). A cached cursor is validated against
-     * `store.tail` before use.
-     */
-    readonly runCacheSize?: number;
-    /**
-     * Pluggable wake scheduler for timer waits.
-     * Defaults to an in-process setTimeout scheduler.
-     */
-    readonly scheduler?: WakeScheduler;
-}
-export interface StartRunArgs {
-    kind: string;
-    definitionName: string;
-    input?: JsonValue;
-    runId?: string;
-    threadId?: string;
-    idempotencyKey?: string;
-}
-export interface StartResult {
-    runId: string;
-    threadId: string;
-    state: RunState;
-}
-export interface LoomsRuntime<TModules extends readonly AnyRuntimeModule[] = readonly AnyRuntimeModule[]> {
-    readonly modules: TModules;
-    readonly registry: ComposedRegistry;
-    startRun(args: StartRunArgs): Effect.Effect<StartResult, Error | EventStoreError, EventStoreTag>;
-    signal(runId: string, events: ReadonlyArray<EventInput>, options?: {
-        idempotencyKey?: string;
-    }): Effect.Effect<RunState, Error | EventStoreError, EventStoreTag>;
-    wake(runId: string): Effect.Effect<RunState, WakeError, EventStoreTag>;
-    getRun(runId: string): Effect.Effect<RunState, EventStoreTruncationError | EventStoreTrimmedError | EventStoreError, EventStoreTag>;
-    getEvents(runId: string, options?: {
-        fromSeq?: number;
-        limit?: number;
-    }): Effect.Effect<EventEnvelope[], EventStoreError, EventStoreTag>;
-    project<S>(runId: string, definition: ProjectionDefinition<S>): Effect.Effect<S, EventStoreError, EventStoreTag>;
-    replayTo(runId: string, seq: number): Effect.Effect<ReplayStep | null, EventStoreError, EventStoreTag>;
-    cancel(runId: string, threadId?: string): Effect.Effect<RunState, Error | EventStoreError, EventStoreTag>;
-    listRuns(): Effect.Effect<string[], EventStoreError, EventStoreTag>;
-    rescanTimers(): Effect.Effect<number, EventStoreTruncationError | EventStoreTrimmedError | EventStoreError, EventStoreTag>;
-    dispose(): void;
-}
+export { DuplicateEffectDispatchError, MaxWakeIterationsError, StartRunConflictError, } from './errors';
+export { RunOverloadedError } from './ingress';
+export type { CreateRuntimeOptions, EffectWorker, EffectWorkerTask, LoomsRuntime, RunOperationalStatus, StartResult, StartRunArgs, WakeError, } from './types';
+export type { WorkerCallback, WorkerCallbackInput } from '@swirls/looms/core';
+import type { CreateRuntimeOptions, LoomsRuntime } from './types';
 export declare function createRuntime<const TModules extends readonly AnyRuntimeModule[]>(options: CreateRuntimeOptions<TModules>): LoomsRuntime<TModules>;