depa-actor 0.1.2 → 0.2.1

package/dist-cjs/execution/stack.cjs

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStackMachine = createStackMachine;
+exports.createInstructionStack = createInstructionStack;
+exports.createOperandStack = createOperandStack;
+class ArrayStackMachine {
+    items;
+    frameBottoms;
+    constructor(state) {
+        this.items = [...(state?.items ?? [])];
+        this.frameBottoms = [...(state?.frameBottoms ?? [])];
+        this.validateFrameBottoms();
+    }
+    get size() {
+        return this.items.length;
+    }
+    get frameDepth() {
+        return this.frameBottoms.length;
+    }
+    push(value) {
+        this.items.push(value);
+    }
+    pushItems(values) {
+        for (const value of values) {
+            this.push(value);
+        }
+    }
+    pop() {
+        return this.items.pop();
+    }
+    peek() {
+        return this.items.at(-1);
+    }
+    pushFrame() {
+        this.frameBottoms.push(this.items.length);
+    }
+    popFrameAllValues() {
+        const frameBottom = this.popFrameBottom();
+        return this.items.splice(frameBottom);
+    }
+    popFrameAndPushTopValue() {
+        const values = this.popFrameAllValues();
+        const topValue = values.at(-1);
+        if (topValue !== undefined) {
+            this.items.push(topValue);
+        }
+        return topValue;
+    }
+    peekBottomOfAllFrames() {
+        return this.items[0];
+    }
+    snapshot() {
+        return {
+            items: [...this.items],
+            frameBottoms: [...this.frameBottoms],
+        };
+    }
+    loadSnapshot(state) {
+        this.items.splice(0, this.items.length, ...(state.items ?? []));
+        this.frameBottoms.splice(0, this.frameBottoms.length, ...(state.frameBottoms ?? []));
+        this.validateFrameBottoms();
+    }
+    popFrameBottom() {
+        const frameBottom = this.frameBottoms.pop();
+        if (frameBottom === undefined) {
+            throw new Error('Cannot pop frame: no frame is open');
+        }
+        return frameBottom;
+    }
+    validateFrameBottoms() {
+        let previous = 0;
+        for (const frameBottom of this.frameBottoms) {
+            if (!Number.isInteger(frameBottom) || frameBottom < previous || frameBottom > this.items.length) {
+                throw new Error(`Invalid frame bottom index: ${frameBottom}`);
+            }
+            previous = frameBottom;
+        }
+    }
+}
+function createStackMachine(state) {
+    return new ArrayStackMachine(state);
+}
+function createInstructionStack(state) {
+    return createStackMachine(state);
+}
+function createOperandStack(state) {
+    return createStackMachine(state);
+}

package/dist-cjs/index.cjs

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_ORCHESTRATOR_OPTIONS = exports.DispatchStrategyConfig = exports.DispatchStrategyType = exports.createDispatchHandler = exports.createPipelineHandler = exports.dispatchInstructions = exports.takeNextCommandFromGroup = exports.pushFrontCommandToGroup = exports.pushFrontCommand = exports.pushBackCommandToGroup = exports.pushBackCommand = exports.popSelectedCommandFromGroup = exports.popNextCommand = exports.popFrontCommand = exports.popBackCommand = exports.drainWhereCommandDequeFromGroup = exports.drainCommandDequeFromGroup = exports.defaultCommandDequeSelector = exports.createCommandDequeGroup = exports.createCommandDeque = exports.createOperandStack = exports.createInstructionStack = exports.createStackMachine = exports.createRuntimeIndexHook = exports.RuntimeIndexHook = exports.createPersistenceEffectPort = exports.createRecoveryHooks = exports.createSnapshotCodec = exports.createCompletionBindingRegistry = exports.createCompletionSignalRegistry = exports.CompletionBindingRegistry = exports.CompletionSignalRegistry = exports.ActorRuntime = exports.createActorRefEndpoint = exports.rebuildActorRegistrations = exports.unregisterActor = exports.dispatchActor = exports.resolveActor = exports.registerActor = exports.createLocalActorAddressingRuntime = exports.parseActorRegistrationReceipt = exports.parseActorOwnerSnapshot = exports.parseActorSelector = exports.parseActorAddress = exports.actorAddressKey = exports.ActorAddressingError = exports.ACTOR_REGISTRATION_SCHEMA_VERSION = exports.ACTOR_OWNER_SNAPSHOT_SCHEMA_VERSION = exports.ACTOR_ADDRESS_SCHEMA_VERSION = exports.ActorSystem = void 0;
+exports.dispatchEffects = exports.createAiAgentSchedulerHooks = exports.scheduleOne = exports.selectNextFiberId = exports.computeEffectivePriority = exports.applyFailure = exports.reduceOrchestrator = exports.createOrchestratorState = void 0;
+var ActorSystem_js_1 = require("./core/ActorSystem.cjs");
+Object.defineProperty(exports, "ActorSystem", { enumerable: true, get: function () { return ActorSystem_js_1.ActorSystem; } });
+var addressing_js_1 = require("./addressing.cjs");
+Object.defineProperty(exports, "ACTOR_ADDRESS_SCHEMA_VERSION", { enumerable: true, get: function () { return addressing_js_1.ACTOR_ADDRESS_SCHEMA_VERSION; } });
+Object.defineProperty(exports, "ACTOR_OWNER_SNAPSHOT_SCHEMA_VERSION", { enumerable: true, get: function () { return addressing_js_1.ACTOR_OWNER_SNAPSHOT_SCHEMA_VERSION; } });
+Object.defineProperty(exports, "ACTOR_REGISTRATION_SCHEMA_VERSION", { enumerable: true, get: function () { return addressing_js_1.ACTOR_REGISTRATION_SCHEMA_VERSION; } });
+Object.defineProperty(exports, "ActorAddressingError", { enumerable: true, get: function () { return addressing_js_1.ActorAddressingError; } });
+Object.defineProperty(exports, "actorAddressKey", { enumerable: true, get: function () { return addressing_js_1.actorAddressKey; } });
+Object.defineProperty(exports, "parseActorAddress", { enumerable: true, get: function () { return addressing_js_1.parseActorAddress; } });
+Object.defineProperty(exports, "parseActorSelector", { enumerable: true, get: function () { return addressing_js_1.parseActorSelector; } });
+Object.defineProperty(exports, "parseActorOwnerSnapshot", { enumerable: true, get: function () { return addressing_js_1.parseActorOwnerSnapshot; } });
+Object.defineProperty(exports, "parseActorRegistrationReceipt", { enumerable: true, get: function () { return addressing_js_1.parseActorRegistrationReceipt; } });
+Object.defineProperty(exports, "createLocalActorAddressingRuntime", { enumerable: true, get: function () { return addressing_js_1.createLocalActorAddressingRuntime; } });
+Object.defineProperty(exports, "registerActor", { enumerable: true, get: function () { return addressing_js_1.registerActor; } });
+Object.defineProperty(exports, "resolveActor", { enumerable: true, get: function () { return addressing_js_1.resolveActor; } });
+Object.defineProperty(exports, "dispatchActor", { enumerable: true, get: function () { return addressing_js_1.dispatchActor; } });
+Object.defineProperty(exports, "unregisterActor", { enumerable: true, get: function () { return addressing_js_1.unregisterActor; } });
+Object.defineProperty(exports, "rebuildActorRegistrations", { enumerable: true, get: function () { return addressing_js_1.rebuildActorRegistrations; } });
+Object.defineProperty(exports, "createActorRefEndpoint", { enumerable: true, get: function () { return addressing_js_1.createActorRefEndpoint; } });
+var ActorRuntime_js_1 = require("./runtime/ActorRuntime.cjs");
+Object.defineProperty(exports, "ActorRuntime", { enumerable: true, get: function () { return ActorRuntime_js_1.ActorRuntime; } });
+var completion_js_1 = require("./runtime/completion.cjs");
+Object.defineProperty(exports, "CompletionSignalRegistry", { enumerable: true, get: function () { return completion_js_1.CompletionSignalRegistry; } });
+Object.defineProperty(exports, "CompletionBindingRegistry", { enumerable: true, get: function () { return completion_js_1.CompletionBindingRegistry; } });
+Object.defineProperty(exports, "createCompletionSignalRegistry", { enumerable: true, get: function () { return completion_js_1.createCompletionSignalRegistry; } });
+Object.defineProperty(exports, "createCompletionBindingRegistry", { enumerable: true, get: function () { return completion_js_1.createCompletionBindingRegistry; } });
+var snapshot_js_1 = require("./runtime/snapshot.cjs");
+Object.defineProperty(exports, "createSnapshotCodec", { enumerable: true, get: function () { return snapshot_js_1.createSnapshotCodec; } });
+Object.defineProperty(exports, "createRecoveryHooks", { enumerable: true, get: function () { return snapshot_js_1.createRecoveryHooks; } });
+Object.defineProperty(exports, "createPersistenceEffectPort", { enumerable: true, get: function () { return snapshot_js_1.createPersistenceEffectPort; } });
+var indexing_js_1 = require("./runtime/indexing.cjs");
+Object.defineProperty(exports, "RuntimeIndexHook", { enumerable: true, get: function () { return indexing_js_1.RuntimeIndexHook; } });
+Object.defineProperty(exports, "createRuntimeIndexHook", { enumerable: true, get: function () { return indexing_js_1.createRuntimeIndexHook; } });
+var index_js_1 = require("./execution/index.cjs");
+Object.defineProperty(exports, "createStackMachine", { enumerable: true, get: function () { return index_js_1.createStackMachine; } });
+Object.defineProperty(exports, "createInstructionStack", { enumerable: true, get: function () { return index_js_1.createInstructionStack; } });
+Object.defineProperty(exports, "createOperandStack", { enumerable: true, get: function () { return index_js_1.createOperandStack; } });
+Object.defineProperty(exports, "createCommandDeque", { enumerable: true, get: function () { return index_js_1.createCommandDeque; } });
+Object.defineProperty(exports, "createCommandDequeGroup", { enumerable: true, get: function () { return index_js_1.createCommandDequeGroup; } });
+Object.defineProperty(exports, "defaultCommandDequeSelector", { enumerable: true, get: function () { return index_js_1.defaultCommandDequeSelector; } });
+Object.defineProperty(exports, "drainCommandDequeFromGroup", { enumerable: true, get: function () { return index_js_1.drainCommandDequeFromGroup; } });
+Object.defineProperty(exports, "drainWhereCommandDequeFromGroup", { enumerable: true, get: function () { return index_js_1.drainWhereCommandDequeFromGroup; } });
+Object.defineProperty(exports, "popBackCommand", { enumerable: true, get: function () { return index_js_1.popBackCommand; } });
+Object.defineProperty(exports, "popFrontCommand", { enumerable: true, get: function () { return index_js_1.popFrontCommand; } });
+Object.defineProperty(exports, "popNextCommand", { enumerable: true, get: function () { return index_js_1.popNextCommand; } });
+Object.defineProperty(exports, "popSelectedCommandFromGroup", { enumerable: true, get: function () { return index_js_1.popSelectedCommandFromGroup; } });
+Object.defineProperty(exports, "pushBackCommand", { enumerable: true, get: function () { return index_js_1.pushBackCommand; } });
+Object.defineProperty(exports, "pushBackCommandToGroup", { enumerable: true, get: function () { return index_js_1.pushBackCommandToGroup; } });
+Object.defineProperty(exports, "pushFrontCommand", { enumerable: true, get: function () { return index_js_1.pushFrontCommand; } });
+Object.defineProperty(exports, "pushFrontCommandToGroup", { enumerable: true, get: function () { return index_js_1.pushFrontCommandToGroup; } });
+Object.defineProperty(exports, "takeNextCommandFromGroup", { enumerable: true, get: function () { return index_js_1.takeNextCommandFromGroup; } });
+Object.defineProperty(exports, "dispatchInstructions", { enumerable: true, get: function () { return index_js_1.dispatchInstructions; } });
+var ActorPipeline_js_1 = require("./pipeline/ActorPipeline.cjs");
+Object.defineProperty(exports, "createPipelineHandler", { enumerable: true, get: function () { return ActorPipeline_js_1.createPipelineHandler; } });
+var ActorDispatchAdapter_js_1 = require("./dispatch/ActorDispatchAdapter.cjs");
+Object.defineProperty(exports, "createDispatchHandler", { enumerable: true, get: function () { return ActorDispatchAdapter_js_1.createDispatchHandler; } });
+// Dispatch strategy enum + the common-tier strategy config factories
+// (ROUTE_KEY / ENUM / COMMAND_TABLE). Advanced strategies (PATH / ACTION_PATH +
+// AntPathMatcher / PathActionMatchRule), manifest-* and router/ stay in
+// depa-processor and are imported directly by users who need them.
+var depa_processor_1 = require("depa-processor");
+Object.defineProperty(exports, "DispatchStrategyType", { enumerable: true, get: function () { return depa_processor_1.DispatchStrategyType; } });
+Object.defineProperty(exports, "DispatchStrategyConfig", { enumerable: true, get: function () { return depa_processor_1.DispatchStrategyConfig; } });
+var index_js_2 = require("./orchestration/index.cjs");
+Object.defineProperty(exports, "DEFAULT_ORCHESTRATOR_OPTIONS", { enumerable: true, get: function () { return index_js_2.DEFAULT_ORCHESTRATOR_OPTIONS; } });
+Object.defineProperty(exports, "createOrchestratorState", { enumerable: true, get: function () { return index_js_2.createOrchestratorState; } });
+Object.defineProperty(exports, "reduceOrchestrator", { enumerable: true, get: function () { return index_js_2.reduceOrchestrator; } });
+Object.defineProperty(exports, "applyFailure", { enumerable: true, get: function () { return index_js_2.applyFailure; } });
+Object.defineProperty(exports, "computeEffectivePriority", { enumerable: true, get: function () { return index_js_2.computeEffectivePriority; } });
+Object.defineProperty(exports, "selectNextFiberId", { enumerable: true, get: function () { return index_js_2.selectNextFiberId; } });
+Object.defineProperty(exports, "scheduleOne", { enumerable: true, get: function () { return index_js_2.scheduleOne; } });
+Object.defineProperty(exports, "createAiAgentSchedulerHooks", { enumerable: true, get: function () { return index_js_2.createAiAgentSchedulerHooks; } });
+Object.defineProperty(exports, "dispatchEffects", { enumerable: true, get: function () { return index_js_2.dispatchEffects; } });

package/dist-cjs/orchestration/index.cjs

@@ -0,0 +1,19 @@
+"use strict";
+// depa-actor — Orchestration (Fiber Scheduling)
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dispatchEffects = exports.createAiAgentSchedulerHooks = exports.scheduleOne = exports.selectNextFiberId = exports.computeEffectivePriority = exports.applyFailure = exports.reduceOrchestrator = exports.createOrchestratorState = exports.DEFAULT_ORCHESTRATOR_OPTIONS = void 0;
+var types_js_1 = require("./types.cjs");
+Object.defineProperty(exports, "DEFAULT_ORCHESTRATOR_OPTIONS", { enumerable: true, get: function () { return types_js_1.DEFAULT_ORCHESTRATOR_OPTIONS; } });
+var reducer_js_1 = require("./reducer.cjs");
+Object.defineProperty(exports, "createOrchestratorState", { enumerable: true, get: function () { return reducer_js_1.createOrchestratorState; } });
+Object.defineProperty(exports, "reduceOrchestrator", { enumerable: true, get: function () { return reducer_js_1.reduceOrchestrator; } });
+var recovery_js_1 = require("./recovery.cjs");
+Object.defineProperty(exports, "applyFailure", { enumerable: true, get: function () { return recovery_js_1.applyFailure; } });
+var scheduler_js_1 = require("./scheduler.cjs");
+Object.defineProperty(exports, "computeEffectivePriority", { enumerable: true, get: function () { return scheduler_js_1.computeEffectivePriority; } });
+Object.defineProperty(exports, "selectNextFiberId", { enumerable: true, get: function () { return scheduler_js_1.selectNextFiberId; } });
+Object.defineProperty(exports, "scheduleOne", { enumerable: true, get: function () { return scheduler_js_1.scheduleOne; } });
+var aiAgent_js_1 = require("./presets/aiAgent.cjs");
+Object.defineProperty(exports, "createAiAgentSchedulerHooks", { enumerable: true, get: function () { return aiAgent_js_1.createAiAgentSchedulerHooks; } });
+var runtimeAdapter_js_1 = require("./runtimeAdapter.cjs");
+Object.defineProperty(exports, "dispatchEffects", { enumerable: true, get: function () { return runtimeAdapter_js_1.dispatchEffects; } });

package/dist-cjs/orchestration/presets/aiAgent.cjs

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAiAgentSchedulerHooks = createAiAgentSchedulerHooks;
+function isAiHumanWaitReason(reason) {
+    return reason === 'human_clarification' || reason === 'human_approval' || reason === 'human_answer';
+}
+function getEffectiveSuspendPolicy(fiber) {
+    const raw = fiber?.suspendPolicy;
+    return raw === 'continue_others' || raw === 'pause_all' ? raw : undefined;
+}
+function isBlockingLaneForPauseAll(lane) {
+    // Treat any non-background lane as blocking by default.
+    if (lane === 'background' || lane === 'collective') {
+        return false;
+    }
+    return true;
+}
+function isAllowedLaneDuringPauseAll(lane) {
+    return lane === 'background' || lane === 'collective';
+}
+function hasPauseAllHumanWaitInBlockingLane(state) {
+    return Object.values(state.fibers).some((fiber) => {
+        return (fiber?.status === 'suspended' &&
+            isAiHumanWaitReason(fiber?.waitingReason) &&
+            getEffectiveSuspendPolicy(fiber) === 'pause_all' &&
+            isBlockingLaneForPauseAll(fiber?.lane));
+    });
+}
+// AIAgent-compatible scheduling hooks:
+// - When a pause_all human wait exists in a blocking lane (interactive/member), only allow background/collective lanes.
+function createAiAgentSchedulerHooks() {
+    return {
+        filterCandidate: ({ state, fiber }) => {
+            if (!hasPauseAllHumanWaitInBlockingLane(state)) {
+                return true;
+            }
+            return isAllowedLaneDuringPauseAll(fiber?.lane);
+        },
+    };
+}

package/dist-cjs/orchestration/recovery.cjs

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyFailure = applyFailure;
+function cloneFiberMap(state) {
+    return { ...state.fibers };
+}
+function buildDeadLetterEffects(state, fiber, reason) {
+    const effects = [
+        {
+            kind: 'dead_letter',
+            fiberId: fiber.id,
+            reason,
+        },
+    ];
+    const route = state.options.deadLetterFactory?.(fiber, reason);
+    if (route) {
+        effects.push({
+            kind: 'dead_letter',
+            fiberId: fiber.id,
+            reason,
+            to: route.to,
+            step: route.step,
+        });
+    }
+    return effects;
+}
+function computeRetryDelay(retryDelayMs, retryBackoffMultiplier, attempts) {
+    const base = Math.max(0, retryDelayMs);
+    const multiplier = Math.max(1, retryBackoffMultiplier);
+    return Math.floor(base * Math.pow(multiplier, Math.max(0, attempts - 1)));
+}
+function applyFailure(state, fiberId, now, error) {
+    const fiber = state.fibers[fiberId];
+    if (!fiber) {
+        return { state, effects: [] };
+    }
+    if (fiber.status === 'completed' || fiber.status === 'cancelled' || fiber.status === 'dead_letter') {
+        return { state, effects: [] };
+    }
+    const nextFibers = cloneFiberMap(state);
+    if (state.options.retryEnabled && fiber.attempts < fiber.maxAttempts) {
+        const nextAttempts = fiber.attempts + 1;
+        const delay = computeRetryDelay(state.options.retryDelayMs, state.options.retryBackoffMultiplier, nextAttempts);
+        const updated = {
+            ...fiber,
+            status: 'suspended',
+            waitingReason: 'retry_backoff',
+            suspendPolicy: undefined,
+            retryAt: now + delay,
+            timeoutAt: undefined,
+            attempts: nextAttempts,
+            lastError: error,
+            updatedAt: now,
+        };
+        nextFibers[fiberId] = updated;
+        return {
+            state: {
+                ...state,
+                fibers: nextFibers,
+            },
+            effects: [],
+        };
+    }
+    if (state.options.deadLetterEnabled) {
+        const updated = {
+            ...fiber,
+            status: 'dead_letter',
+            waitingReason: undefined,
+            suspendPolicy: undefined,
+            retryAt: undefined,
+            lastError: error,
+            updatedAt: now,
+        };
+        nextFibers[fiberId] = updated;
+        const deadLetters = [
+            ...state.deadLetters,
+            {
+                fiberId: fiber.id,
+                actorId: fiber.actorId,
+                reason: error,
+                at: now,
+                attempts: fiber.attempts,
+                step: fiber.step,
+            },
+        ];
+        return {
+            state: {
+                ...state,
+                fibers: nextFibers,
+                deadLetters,
+            },
+            effects: buildDeadLetterEffects(state, updated, error),
+        };
+    }
+    const updated = {
+        ...fiber,
+        status: 'failed',
+        waitingReason: undefined,
+        suspendPolicy: undefined,
+        retryAt: undefined,
+        lastError: error,
+        updatedAt: now,
+    };
+    nextFibers[fiberId] = updated;
+    return {
+        state: {
+            ...state,
+            fibers: nextFibers,
+        },
+        effects: [],
+    };
+}

package/dist-cjs/orchestration/reducer.cjs

@@ -0,0 +1,276 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createOrchestratorState = createOrchestratorState;
+exports.reduceOrchestrator = reduceOrchestrator;
+const recovery_js_1 = require("./recovery.cjs");
+const types_js_1 = require("./types.cjs");
+function isTerminalStatus(status) {
+    return status === 'completed' || status === 'cancelled' || status === 'failed' || status === 'dead_letter';
+}
+function cloneFiberMap(state) {
+    return { ...state.fibers };
+}
+function upsertParentChildRelation(fibers, fiber, now) {
+    if (!fiber.parentId) {
+        return;
+    }
+    const parent = fibers[fiber.parentId];
+    if (!parent) {
+        return;
+    }
+    if (!parent.childIds.includes(fiber.id)) {
+        fibers[fiber.parentId] = {
+            ...parent,
+            childIds: [...parent.childIds, fiber.id],
+            updatedAt: now,
+        };
+    }
+}
+function createFiberRecord(input, now, order, state) {
+    const timeoutMs = input.timeoutMs ?? state.options.defaultTimeoutMs;
+    return {
+        id: input.id,
+        actorId: input.actorId,
+        parentId: input.parentId,
+        childIds: [],
+        lane: input.lane ?? 'default',
+        status: 'ready',
+        basePriority: input.basePriority,
+        age: 0,
+        attempts: 0,
+        maxAttempts: Math.max(0, input.maxAttempts ?? 0),
+        step: input.step,
+        waitingReason: undefined,
+        suspendPolicy: undefined,
+        timeoutMs: timeoutMs > 0 ? timeoutMs : undefined,
+        timeoutAt: undefined,
+        retryAt: undefined,
+        lastError: undefined,
+        order,
+        createdAt: now,
+        updatedAt: now,
+    };
+}
+function createOrchestratorState(options) {
+    const raw = (options ?? {});
+    const effectiveDefault = raw.defaultSuspendPolicy ??
+        types_js_1.DEFAULT_ORCHESTRATOR_OPTIONS.defaultSuspendPolicy;
+    const base = {
+        ...types_js_1.DEFAULT_ORCHESTRATOR_OPTIONS,
+        ...raw,
+    };
+    return {
+        options: {
+            ...base,
+            defaultSuspendPolicy: effectiveDefault,
+        },
+        fibers: {},
+        deadLetters: [],
+        sequence: 0,
+    };
+}
+function applyTick(state, now) {
+    let nextState = state;
+    let aggregatedEffects = [];
+    const ids = Object.keys(state.fibers);
+    for (const id of ids) {
+        const fiber = nextState.fibers[id];
+        if (!fiber) {
+            continue;
+        }
+        if (isTerminalStatus(fiber.status)) {
+            continue;
+        }
+        if (nextState.options.timeoutEnabled &&
+            fiber.timeoutAt !== undefined &&
+            now >= fiber.timeoutAt &&
+            (fiber.status === 'running' || fiber.status === 'ready' || fiber.status === 'suspended')) {
+            const timed = (0, recovery_js_1.applyFailure)(nextState, id, now, 'timeout');
+            nextState = timed.state;
+            aggregatedEffects = [...aggregatedEffects, ...timed.effects];
+            continue;
+        }
+        const iter = nextState.fibers[id];
+        if (iter &&
+            iter.status === 'suspended' &&
+            iter.waitingReason === 'retry_backoff' &&
+            iter.retryAt !== undefined &&
+            now >= iter.retryAt) {
+            nextState = {
+                ...nextState,
+                fibers: {
+                    ...nextState.fibers,
+                    [id]: {
+                        ...iter,
+                        status: 'ready',
+                        waitingReason: undefined,
+                        retryAt: undefined,
+                        timeoutAt: undefined,
+                        updatedAt: now,
+                    },
+                },
+            };
+        }
+    }
+    return {
+        state: nextState,
+        effects: aggregatedEffects,
+    };
+}
+function reduceOrchestrator(state, action) {
+    if (action.type === 'tick') {
+        return applyTick(state, action.now);
+    }
+    if (action.type === 'spawn') {
+        const nextSequence = state.sequence + 1;
+        const nextFibers = cloneFiberMap(state);
+        const record = createFiberRecord(action.fiber, action.now, nextSequence, state);
+        nextFibers[action.fiber.id] = record;
+        upsertParentChildRelation(nextFibers, action.fiber, action.now);
+        return {
+            state: {
+                ...state,
+                sequence: nextSequence,
+                fibers: nextFibers,
+            },
+            effects: [],
+        };
+    }
+    const current = state.fibers[action.fiberId];
+    if (!current) {
+        return { state, effects: [] };
+    }
+    if (action.type === 'yield') {
+        if (isTerminalStatus(current.status)) {
+            return { state, effects: [] };
+        }
+        return {
+            state: {
+                ...state,
+                fibers: {
+                    ...state.fibers,
+                    [action.fiberId]: {
+                        ...current,
+                        status: 'ready',
+                        waitingReason: undefined,
+                        suspendPolicy: undefined,
+                        timeoutAt: undefined,
+                        step: action.nextStep ?? current.step,
+                        updatedAt: action.now,
+                    },
+                },
+            },
+            effects: [],
+        };
+    }
+    if (action.type === 'suspend') {
+        if (isTerminalStatus(current.status)) {
+            return { state, effects: [] };
+        }
+        const effectivePolicy = action.suspendPolicy ??
+            state.options.defaultSuspendPolicy ??
+            'continue_others';
+        return {
+            state: {
+                ...state,
+                fibers: {
+                    ...state.fibers,
+                    [action.fiberId]: {
+                        ...current,
+                        status: 'suspended',
+                        waitingReason: action.reason,
+                        suspendPolicy: effectivePolicy,
+                        timeoutAt: undefined,
+                        updatedAt: action.now,
+                    },
+                },
+            },
+            effects: [],
+        };
+    }
+    if (action.type === 'resume') {
+        if (isTerminalStatus(current.status)) {
+            return { state, effects: [] };
+        }
+        return {
+            state: {
+                ...state,
+                fibers: {
+                    ...state.fibers,
+                    [action.fiberId]: {
+                        ...current,
+                        status: 'ready',
+                        waitingReason: undefined,
+                        suspendPolicy: undefined,
+                        retryAt: undefined,
+                        timeoutAt: undefined,
+                        step: action.nextStep ?? current.step,
+                        updatedAt: action.now,
+                    },
+                },
+            },
+            effects: [],
+        };
+    }
+    if (action.type === 'complete') {
+        return {
+            state: {
+                ...state,
+                fibers: {
+                    ...state.fibers,
+                    [action.fiberId]: {
+                        ...current,
+                        status: 'completed',
+                        waitingReason: undefined,
+                        suspendPolicy: undefined,
+                        timeoutAt: undefined,
+                        updatedAt: action.now,
+                    },
+                },
+            },
+            effects: [],
+        };
+    }
+    if (action.type === 'fail') {
+        return (0, recovery_js_1.applyFailure)(state, action.fiberId, action.now, action.error);
+    }
+    if (action.type === 'cancel') {
+        const nextFibers = cloneFiberMap(state);
+        const queue = [action.fiberId];
+        const seen = new Set();
+        while (queue.length > 0) {
+            const id = queue.shift();
+            if (seen.has(id)) {
+                continue;
+            }
+            seen.add(id);
+            const item = nextFibers[id];
+            if (!item) {
+                continue;
+            }
+            nextFibers[id] = {
+                ...item,
+                status: 'cancelled',
+                waitingReason: undefined,
+                suspendPolicy: undefined,
+                timeoutAt: undefined,
+                retryAt: undefined,
+                lastError: action.reason,
+                updatedAt: action.now,
+            };
+            if (action.propagateToChildren) {
+                for (const childId of item.childIds) {
+                    queue.push(childId);
+                }
+            }
+        }
+        return {
+            state: {
+                ...state,
+                fibers: nextFibers,
+            },
+            effects: [],
+        };
+    }
+    return { state, effects: [] };
+}

package/dist-cjs/orchestration/runtimeAdapter.cjs

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dispatchEffects = dispatchEffects;
+function dispatchEffects(runtime, effects, senderId) {
+    const from = senderId ?? '__fiber_scheduler__';
+    for (const effect of effects) {
+        if (effect.kind === 'send') {
+            runtime.sendFrom(from, effect.to, effect.step.tag, effect.step.payload);
+        }
+        if (effect.kind === 'dead_letter' && effect.to && effect.step) {
+            runtime.sendFrom(from, effect.to, effect.step.tag, effect.step.payload);
+        }
+    }
+}