depa-actor 0.1.2 → 0.2.0

package/dist-cjs/execution/commandDeque.cjs

@@ -0,0 +1,430 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultCommandDequeSelector = defaultCommandDequeSelector;
+exports.createCommandDeque = createCommandDeque;
+exports.createCommandDequeGroup = createCommandDequeGroup;
+exports.pushBackCommand = pushBackCommand;
+exports.pushFrontCommand = pushFrontCommand;
+exports.popNextCommand = popNextCommand;
+exports.popFrontCommand = popFrontCommand;
+exports.popBackCommand = popBackCommand;
+exports.pushBackCommandToGroup = pushBackCommandToGroup;
+exports.pushFrontCommandToGroup = pushFrontCommandToGroup;
+exports.popSelectedCommandFromGroup = popSelectedCommandFromGroup;
+exports.takeNextCommandFromGroup = takeNextCommandFromGroup;
+exports.drainCommandDequeFromGroup = drainCommandDequeFromGroup;
+exports.drainWhereCommandDequeFromGroup = drainWhereCommandDequeFromGroup;
+const DEFAULT_DEQUE_ID = 'default';
+const DEFAULT_PRIORITY = 100;
+class SingleCommandDeque {
+    state;
+    sequence;
+    now;
+    idFactory;
+    constructor(options, state, sequence = 0) {
+        this.state = state
+            ? cloneDequeState(state)
+            : {
+                id: options?.id ?? DEFAULT_DEQUE_ID,
+                lane: options?.lane,
+                priority: options?.priority ?? DEFAULT_PRIORITY,
+                items: [],
+            };
+        this.sequence = sequence;
+        this.now = options?.now;
+        this.idFactory = options?.idFactory;
+    }
+    get id() {
+        return this.state.id;
+    }
+    pushBack(command, options) {
+        const item = this.createItem(command, options);
+        this.state.items.push(item);
+        return item;
+    }
+    pushFront(command, options) {
+        const item = this.createItem(command, options);
+        this.state.items.unshift(item);
+        return item;
+    }
+    peekNext() {
+        return this.peekFront();
+    }
+    popNext() {
+        return this.popFront();
+    }
+    peekFront() {
+        return this.state.items[0];
+    }
+    peekBack() {
+        return this.state.items.at(-1);
+    }
+    popFront() {
+        return this.state.items.shift();
+    }
+    popBack() {
+        return this.state.items.pop();
+    }
+    listItems() {
+        return this.state.items.map((item) => ({ ...item }));
+    }
+    getItem(id) {
+        const item = this.state.items.find((candidate) => candidate.id === id);
+        return item ? { ...item } : undefined;
+    }
+    nextAfter(itemId) {
+        const index = this.state.items.findIndex((item) => item.id === itemId);
+        const item = index >= 0 ? this.state.items[index + 1] : undefined;
+        return item ? { ...item } : undefined;
+    }
+    prevBefore(itemId) {
+        const index = this.state.items.findIndex((item) => item.id === itemId);
+        const item = index >= 0 ? this.state.items[index - 1] : undefined;
+        return item ? { ...item } : undefined;
+    }
+    drain() {
+        const drained = this.listItems();
+        this.state.items.length = 0;
+        return drained;
+    }
+    drainWhere(predicate) {
+        const drained = [];
+        const kept = [];
+        for (const item of this.state.items) {
+            if (predicate(item)) {
+                drained.push({ ...item });
+            }
+            else {
+                kept.push(item);
+            }
+        }
+        this.state.items.length = 0;
+        this.state.items.push(...kept);
+        return drained;
+    }
+    hasPending() {
+        return this.state.items.length > 0;
+    }
+    snapshot() {
+        return cloneDequeState(this.state);
+    }
+    createItem(command, options) {
+        const nextSequence = this.sequence + 1;
+        this.sequence = nextSequence;
+        return {
+            id: options?.id ?? this.idFactory?.({ sequence: nextSequence, dequeId: this.state.id }) ?? `cmd-${nextSequence}`,
+            command,
+            insertedAt: options?.insertedAt ?? this.now?.() ?? Date.now(),
+            order: nextSequence,
+        };
+    }
+}
+class MultiCommandDequeGroup {
+    state;
+    selector;
+    now;
+    idFactory;
+    constructor(options, state) {
+        this.state = state
+            ? cloneGroupState(state)
+            : {
+                deques: {},
+                sequence: 0,
+            };
+        this.now = options?.now;
+        this.idFactory = options?.idFactory;
+        this.selector = options?.selector ?? defaultCommandDequeSelector;
+        for (const definition of options?.deques ?? []) {
+            this.ensureDequeState(definition);
+        }
+    }
+    getDeque(dequeId) {
+        if (!this.state.deques[dequeId]) {
+            this.state.deques[dequeId] = {
+                id: dequeId,
+                priority: DEFAULT_PRIORITY,
+                items: [],
+            };
+        }
+        return this.createDequeView(dequeId);
+    }
+    ensureDeque(definition) {
+        const state = this.ensureDequeState(definition);
+        return this.createDequeView(state.id);
+    }
+    pushBack(command, options) {
+        return this.push(command, options, 'back');
+    }
+    pushFront(command, options) {
+        return this.push(command, options, 'front');
+    }
+    selectNext(runtimeState, selector = this.selector) {
+        const selection = selector({ group: this.snapshot(), runtimeState });
+        if (!selection) {
+            return undefined;
+        }
+        return this.resolveSelection(selection);
+    }
+    popSelected(selection) {
+        const deque = this.state.deques[selection.dequeId];
+        if (!deque) {
+            return undefined;
+        }
+        const index = deque.items.findIndex((item) => item.id === selection.itemId);
+        if (index < 0) {
+            return undefined;
+        }
+        const [item] = deque.items.splice(index, 1);
+        return {
+            dequeId: deque.id,
+            itemId: item.id,
+            deque: cloneDequeState(deque),
+            item: { ...item },
+        };
+    }
+    takeNext(runtimeState, selector = this.selector) {
+        const selected = this.selectNext(runtimeState, selector);
+        if (!selected) {
+            return undefined;
+        }
+        return this.popSelected(selected);
+    }
+    drainDeque(dequeId) {
+        const deque = this.state.deques[dequeId];
+        if (!deque) {
+            return [];
+        }
+        const drained = deque.items.map((item) => ({ ...item }));
+        deque.items.length = 0;
+        return drained;
+    }
+    drainWhereDeque(dequeId, predicate) {
+        const deque = this.state.deques[dequeId];
+        if (!deque) {
+            return [];
+        }
+        const drained = [];
+        const kept = [];
+        for (const item of deque.items) {
+            if (predicate(item)) {
+                drained.push({ ...item });
+            }
+            else {
+                kept.push(item);
+            }
+        }
+        deque.items.length = 0;
+        deque.items.push(...kept);
+        return drained;
+    }
+    listDequeIds() {
+        return Object.keys(this.state.deques);
+    }
+    snapshot() {
+        return cloneGroupState(this.state);
+    }
+    push(command, options, side) {
+        const deque = this.ensureDequeState({
+            id: options.dequeId,
+            priority: this.state.deques[options.dequeId]?.priority ?? DEFAULT_PRIORITY,
+        });
+        const nextSequence = this.state.sequence + 1;
+        this.state.sequence = nextSequence;
+        const item = {
+            id: options.id ?? this.idFactory?.({ sequence: nextSequence, dequeId: deque.id }) ?? `cmd-${nextSequence}`,
+            command,
+            insertedAt: options.insertedAt ?? this.now?.() ?? Date.now(),
+            order: nextSequence,
+        };
+        if (side === 'front') {
+            deque.items.unshift(item);
+        }
+        else {
+            deque.items.push(item);
+        }
+        return { ...item };
+    }
+    createDequeView(dequeId) {
+        return {
+            id: dequeId,
+            pushBack: (command, options) => this.pushBack(command, { ...options, dequeId }),
+            pushFront: (command, options) => this.pushFront(command, { ...options, dequeId }),
+            peekNext: () => this.peekDequeFront(dequeId),
+            popNext: () => this.popDequeFront(dequeId),
+            peekFront: () => this.peekDequeFront(dequeId),
+            peekBack: () => this.peekDequeBack(dequeId),
+            popFront: () => this.popDequeFront(dequeId),
+            popBack: () => this.popDequeBack(dequeId),
+            listItems: () => this.state.deques[dequeId]?.items.map((item) => ({ ...item })) ?? [],
+            getItem: (id) => {
+                const item = this.state.deques[dequeId]?.items.find((candidate) => candidate.id === id);
+                return item ? { ...item } : undefined;
+            },
+            nextAfter: (itemId) => this.neighbor(dequeId, itemId, 1),
+            prevBefore: (itemId) => this.neighbor(dequeId, itemId, -1),
+            drain: () => this.drainDeque(dequeId),
+            drainWhere: (predicate) => this.drainWhereDeque(dequeId, predicate),
+            hasPending: () => (this.state.deques[dequeId]?.items.length ?? 0) > 0,
+            snapshot: () => cloneDequeState(this.state.deques[dequeId] ?? this.ensureDequeState({ id: dequeId, priority: DEFAULT_PRIORITY })),
+        };
+    }
+    peekDequeFront(dequeId) {
+        const item = this.state.deques[dequeId]?.items[0];
+        return item ? { ...item } : undefined;
+    }
+    peekDequeBack(dequeId) {
+        const item = this.state.deques[dequeId]?.items.at(-1);
+        return item ? { ...item } : undefined;
+    }
+    popDequeFront(dequeId) {
+        const item = this.state.deques[dequeId]?.items.shift();
+        return item ? { ...item } : undefined;
+    }
+    popDequeBack(dequeId) {
+        const item = this.state.deques[dequeId]?.items.pop();
+        return item ? { ...item } : undefined;
+    }
+    neighbor(dequeId, itemId, offset) {
+        const items = this.state.deques[dequeId]?.items;
+        if (!items) {
+            return undefined;
+        }
+        const index = items.findIndex((item) => item.id === itemId);
+        const item = index >= 0 ? items[index + offset] : undefined;
+        return item ? { ...item } : undefined;
+    }
+    resolveSelection(selection) {
+        const deque = this.state.deques[selection.dequeId];
+        const item = deque?.items.find((candidate) => candidate.id === selection.itemId);
+        if (!deque || !item) {
+            return undefined;
+        }
+        return {
+            dequeId: deque.id,
+            itemId: item.id,
+            deque: cloneDequeState(deque),
+            item: { ...item },
+        };
+    }
+    ensureDequeState(definition) {
+        const existing = this.state.deques[definition.id];
+        if (existing) {
+            if (definition.lane !== undefined) {
+                existing.lane = definition.lane;
+            }
+            existing.priority = definition.priority;
+            return existing;
+        }
+        const created = {
+            id: definition.id,
+            lane: definition.lane,
+            priority: definition.priority,
+            items: [],
+        };
+        this.state.deques[definition.id] = created;
+        return created;
+    }
+}
+function defaultCommandDequeSelector({ group, }) {
+    const candidates = Object.values(group.deques)
+        .filter((deque) => deque.items.length > 0)
+        .map((deque) => ({
+        dequeId: deque.id,
+        priority: deque.priority,
+        item: deque.items[0],
+    }));
+    candidates.sort((a, b) => {
+        if (a.priority !== b.priority) {
+            return a.priority - b.priority;
+        }
+        return a.item.order - b.item.order;
+    });
+    const selected = candidates[0];
+    return selected ? { dequeId: selected.dequeId, itemId: selected.item.id } : undefined;
+}
+function createCommandDeque(options, state) {
+    return new SingleCommandDeque(options, state, maxOrder(state?.items ?? []));
+}
+function createCommandDequeGroup(options, state) {
+    return new MultiCommandDequeGroup(options, state);
+}
+function pushBackCommand(state, command, options) {
+    const deque = createCommandDeque(options, state);
+    const item = deque.pushBack(command, options);
+    return { state: deque.snapshot(), item };
+}
+function pushFrontCommand(state, command, options) {
+    const deque = createCommandDeque(options, state);
+    const item = deque.pushFront(command, options);
+    return { state: deque.snapshot(), item };
+}
+function popNextCommand(state) {
+    const deque = createCommandDeque(undefined, state);
+    const item = deque.popNext();
+    return { state: deque.snapshot(), item };
+}
+function popFrontCommand(state) {
+    const deque = createCommandDeque(undefined, state);
+    const item = deque.popFront();
+    return { state: deque.snapshot(), item };
+}
+function popBackCommand(state) {
+    const deque = createCommandDeque(undefined, state);
+    const item = deque.popBack();
+    return { state: deque.snapshot(), item };
+}
+function pushBackCommandToGroup(state, command, options) {
+    const group = createCommandDequeGroup(options, state);
+    const item = group.pushBack(command, options);
+    return { state: group.snapshot(), item };
+}
+function pushFrontCommandToGroup(state, command, options) {
+    const group = createCommandDequeGroup(options, state);
+    const item = group.pushFront(command, options);
+    return { state: group.snapshot(), item };
+}
+function popSelectedCommandFromGroup(state, selection, options) {
+    const group = createCommandDequeGroup(options, state);
+    const selected = group.popSelected(selection);
+    return {
+        state: group.snapshot(),
+        item: selected?.item,
+        selection: selected,
+    };
+}
+function takeNextCommandFromGroup(state, runtimeState, options) {
+    const group = createCommandDequeGroup(options, state);
+    const selected = group.takeNext(runtimeState);
+    return {
+        state: group.snapshot(),
+        item: selected?.item,
+        selection: selected,
+    };
+}
+function drainCommandDequeFromGroup(state, dequeId, options) {
+    const group = createCommandDequeGroup(options, state);
+    const items = group.drainDeque(dequeId);
+    return { state: group.snapshot(), items };
+}
+function drainWhereCommandDequeFromGroup(state, dequeId, predicate, options) {
+    const group = createCommandDequeGroup(options, state);
+    const items = group.drainWhereDeque(dequeId, predicate);
+    return { state: group.snapshot(), items };
+}
+function cloneDequeState(state) {
+    return {
+        id: state.id,
+        lane: state.lane,
+        priority: state.priority,
+        items: state.items.map((item) => ({ ...item })),
+    };
+}
+function cloneGroupState(state) {
+    return {
+        deques: Object.fromEntries(Object.entries(state.deques).map(([id, deque]) => [id, cloneDequeState(deque)])),
+        sequence: state.sequence,
+    };
+}
+function maxOrder(items) {
+    return items.reduce((max, item) => Math.max(max, item.order), 0);
+}

package/dist-cjs/execution/dispatcher.cjs

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dispatchInstructions = dispatchInstructions;
+function dispatchInstructions(context, resolveHandler, options) {
+    const maxInstructions = options?.maxInstructions ?? Number.POSITIVE_INFINITY;
+    const effects = [];
+    const trace = [];
+    let executed = 0;
+    const finish = (stopReason, stopDetail, error) => {
+        options?.hooks?.onStop?.({ stopReason, stopDetail, executed });
+        const result = { executed, stopReason, effects, trace };
+        if (stopDetail !== undefined) {
+            result.stopDetail = stopDetail;
+        }
+        if (error !== undefined) {
+            result.error = error;
+        }
+        return result;
+    };
+    while (executed < maxInstructions) {
+        const customStop = options?.shouldStop?.({ executed });
+        if (customStop) {
+            return finish('custom', customStop);
+        }
+        const instruction = context.instructionStack.pop();
+        if (!instruction) {
+            return finish('instruction_stack_empty');
+        }
+        options?.hooks?.beforeInstruction?.({ instruction, executed });
+        const handler = resolveHandler(instruction.opcode);
+        if (!handler) {
+            trace.push({ instruction, result: 'missing_handler' });
+            options?.hooks?.afterInstruction?.({ instruction, executed, result: 'missing_handler' });
+            return finish('missing_handler');
+        }
+        try {
+            const handlerResult = handler({
+                runtime: context.runtime,
+                instruction,
+                instructionStack: context.instructionStack,
+                operandStack: context.operandStack,
+            });
+            executed += 1;
+            if (handlerResult?.effects) {
+                effects.push(...handlerResult.effects);
+                options?.hooks?.onHandlerEffects?.({
+                    instruction,
+                    effects: handlerResult.effects,
+                    executed,
+                });
+            }
+            if (handlerResult?.yield) {
+                trace.push({ instruction, result: 'yield' });
+                const stopDetail = handlerResult.yieldReason;
+                options?.hooks?.afterInstruction?.({ instruction, executed, result: 'yield' });
+                return finish('yield_requested', stopDetail);
+            }
+            if (handlerResult?.stop) {
+                trace.push({ instruction, result: 'stop' });
+                const stopDetail = handlerResult.stopReason;
+                const stopReason = stopDetail === undefined ? 'handler_requested_stop' : 'custom';
+                options?.hooks?.afterInstruction?.({ instruction, executed, result: 'stop' });
+                return finish(stopReason, stopDetail);
+            }
+            trace.push({ instruction, result: 'ok' });
+            options?.hooks?.afterInstruction?.({ instruction, executed, result: 'ok' });
+        }
+        catch (error) {
+            trace.push({
+                instruction,
+                result: 'error',
+                error: error instanceof Error ? error.message : String(error),
+            });
+            options?.hooks?.afterInstruction?.({ instruction, executed, result: 'error' });
+            return finish('error', undefined, error);
+        }
+    }
+    return finish('budget_exhausted');
+}

package/dist-cjs/execution/index.cjs

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 = void 0;
+var stack_js_1 = require("./stack.cjs");
+Object.defineProperty(exports, "createStackMachine", { enumerable: true, get: function () { return stack_js_1.createStackMachine; } });
+Object.defineProperty(exports, "createInstructionStack", { enumerable: true, get: function () { return stack_js_1.createInstructionStack; } });
+Object.defineProperty(exports, "createOperandStack", { enumerable: true, get: function () { return stack_js_1.createOperandStack; } });
+var commandDeque_js_1 = require("./commandDeque.cjs");
+Object.defineProperty(exports, "createCommandDeque", { enumerable: true, get: function () { return commandDeque_js_1.createCommandDeque; } });
+Object.defineProperty(exports, "createCommandDequeGroup", { enumerable: true, get: function () { return commandDeque_js_1.createCommandDequeGroup; } });
+Object.defineProperty(exports, "defaultCommandDequeSelector", { enumerable: true, get: function () { return commandDeque_js_1.defaultCommandDequeSelector; } });
+Object.defineProperty(exports, "drainCommandDequeFromGroup", { enumerable: true, get: function () { return commandDeque_js_1.drainCommandDequeFromGroup; } });
+Object.defineProperty(exports, "drainWhereCommandDequeFromGroup", { enumerable: true, get: function () { return commandDeque_js_1.drainWhereCommandDequeFromGroup; } });
+Object.defineProperty(exports, "popBackCommand", { enumerable: true, get: function () { return commandDeque_js_1.popBackCommand; } });
+Object.defineProperty(exports, "popFrontCommand", { enumerable: true, get: function () { return commandDeque_js_1.popFrontCommand; } });
+Object.defineProperty(exports, "popNextCommand", { enumerable: true, get: function () { return commandDeque_js_1.popNextCommand; } });
+Object.defineProperty(exports, "popSelectedCommandFromGroup", { enumerable: true, get: function () { return commandDeque_js_1.popSelectedCommandFromGroup; } });
+Object.defineProperty(exports, "pushBackCommand", { enumerable: true, get: function () { return commandDeque_js_1.pushBackCommand; } });
+Object.defineProperty(exports, "pushBackCommandToGroup", { enumerable: true, get: function () { return commandDeque_js_1.pushBackCommandToGroup; } });
+Object.defineProperty(exports, "pushFrontCommand", { enumerable: true, get: function () { return commandDeque_js_1.pushFrontCommand; } });
+Object.defineProperty(exports, "pushFrontCommandToGroup", { enumerable: true, get: function () { return commandDeque_js_1.pushFrontCommandToGroup; } });
+Object.defineProperty(exports, "takeNextCommandFromGroup", { enumerable: true, get: function () { return commandDeque_js_1.takeNextCommandFromGroup; } });
+var dispatcher_js_1 = require("./dispatcher.cjs");
+Object.defineProperty(exports, "dispatchInstructions", { enumerable: true, get: function () { return dispatcher_js_1.dispatchInstructions; } });

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,52 @@
+"use strict";
+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 = 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.ActorSystem = void 0;
+var ActorSystem_js_1 = require("./core/ActorSystem.cjs");
+Object.defineProperty(exports, "ActorSystem", { enumerable: true, get: function () { return ActorSystem_js_1.ActorSystem; } });
+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; } });
+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; } });