depa-actor 0.1.2 → 0.2.1

package/dist-cjs/dispatch/ActorDispatchAdapter.cjs

@@ -0,0 +1,125 @@
+"use strict";
+/**
+ * depa-actor — Dispatch Bridge
+ *
+ * Drives the depa-processor `DispatchEngine` (all 7 strategies) from the actor
+ * side. The envelope → DispatchRequest adaptation and the actor `tag` overlay
+ * live HERE, in depa-actor — the generic `DispatchEngine` / `DispatchStrategyConfig`
+ * stay free of any actor (`envelope` / `tag` / `ActorSelf`) knowledge.
+ *
+ * Two orthogonal axes:
+ *   1. `tag` — actor's first-level route (which mailbox). Selecting a handler by
+ *      tag is the actor system's job (`ActorDef.handlers[tag]`); a dispatch handler
+ *      built here is slotted UNDER a tag, so tag selection happens upstream.
+ *      `tag` is NOT a DispatchStrategyType — it is an orthogonal overlay dimension.
+ *   2. `strategy` — one of the 7 `DispatchStrategyType` values, used as the
+ *      second-level resolution within the selected tag.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDispatchHandler = createDispatchHandler;
+const depa_processor_1 = require("depa-processor");
+// ─── Internal helpers ────────────────────────────────────────────────
+function isStrategyConfig(routes) {
+    return routes instanceof depa_processor_1.DispatchStrategyConfig;
+}
+/**
+ * Build a `DispatchStrategyConfig<void>` from a plain key → handler map for the
+ * supported key-based strategies. The map values are pre-bound to `(self, envelope)`
+ * by capturing the current dispatch's `self` / `envelope` via a thunk.
+ */
+function buildKeyBasedConfig(strategy, routes, self, envelope) {
+    const handlerMap = new Map();
+    for (const [key, handler] of Object.entries(routes)) {
+        handlerMap.set(key, () => handler(self, envelope));
+    }
+    switch (strategy) {
+        case depa_processor_1.DispatchStrategyType.ROUTE_KEY:
+            return depa_processor_1.DispatchStrategyConfig.forRouteKeyStrategy({
+                handlerMap: handlerMap,
+            });
+        case depa_processor_1.DispatchStrategyType.ENUM:
+            return depa_processor_1.DispatchStrategyConfig.forEnumStrategy({
+                handlerMap,
+            });
+        case depa_processor_1.DispatchStrategyType.COMMAND_TABLE:
+            return depa_processor_1.DispatchStrategyConfig.forCommandStrategy({
+                commandConverter: (command) => handlerMap.has(command) ? command : null,
+                handlerExtractor: (commandEnum) => handlerMap.get(commandEnum) ?? null,
+            });
+        default:
+            throw new Error(`createDispatchHandler: strategy ${strategy} requires a prebuilt ` +
+                `DispatchStrategyConfig in 'routes' (plain key→handler maps support ` +
+                `ROUTE_KEY / ENUM / COMMAND_TABLE only).`);
+    }
+}
+/** Build the strategy-appropriate DispatchRequest from the envelope. */
+function buildRequest(strategy, envelope, extractors) {
+    const input = extractors?.inputOf ? extractors.inputOf(envelope) : envelope.payload;
+    const routeKey = extractors?.routeKeyOf
+        ? extractors.routeKeyOf(envelope)
+        : envelope.tag;
+    const path = extractors?.pathOf ? extractors.pathOf(envelope) : envelope.tag;
+    switch (strategy) {
+        case depa_processor_1.DispatchStrategyType.CLASS:
+            return (0, depa_processor_1.createClassDispatchRequest)(input);
+        case depa_processor_1.DispatchStrategyType.ROUTE_KEY:
+            return (0, depa_processor_1.createRouteKeyDispatchRequest)(routeKey, input, false);
+        case depa_processor_1.DispatchStrategyType.ENUM:
+            return (0, depa_processor_1.createEnumDispatchRequest)(extractors?.enumOf ? extractors.enumOf(envelope) : envelope.tag, input);
+        case depa_processor_1.DispatchStrategyType.ROUTE_KEY_TO_ENUM:
+            return (0, depa_processor_1.createRouteKeyToEnumDispatchRequest)(routeKey, input);
+        case depa_processor_1.DispatchStrategyType.COMMAND_TABLE:
+            return (0, depa_processor_1.createCommandDispatchRequest)(routeKey, input);
+        case depa_processor_1.DispatchStrategyType.PATH:
+            return (0, depa_processor_1.createPathDispatchRequest)({
+                runtime: undefined,
+                request: input,
+                path,
+            });
+        case depa_processor_1.DispatchStrategyType.ACTION_PATH:
+            return (0, depa_processor_1.createActionPathDispatchRequest)({
+                runtime: undefined,
+                request: input,
+                action: extractors?.actionOf ? extractors.actionOf(envelope) : undefined,
+                path,
+            });
+        default:
+            throw new Error(`createDispatchHandler: unknown strategy ${String(strategy)}`);
+    }
+}
+// ─── createDispatchHandler ───────────────────────────────────────────
+/**
+ * Creates an ActorHandler that resolves an envelope to a sub-handler via one of
+ * the 7 depa-processor dispatch strategies (opt-in, per-handler — DX form C / B2).
+ *
+ * Object-param signature: `{ strategy, routes, defaultHandler?, extractors? }`.
+ *
+ * Composability:
+ *  - slot the returned handler under a `tag` in `ActorDef.handlers` → `tag` overlay
+ *    (first-level) + `strategy` (second-level), the two axes are orthogonal.
+ *  - the resolved sub-handler may itself be a `createPipelineHandler(...)` result,
+ *    so dispatch and pipeline nest freely.
+ *
+ * No declarative `ActorDef.dispatch` field and no global feature flag / enableXxx
+ * API exist — enabling rich dispatch is expressed purely by import + composition.
+ */
+function createDispatchHandler(params) {
+    const { strategy, routes, defaultHandler, extractors } = params;
+    return async (self, envelope) => {
+        const config = isStrategyConfig(routes)
+            ? routes
+            : buildKeyBasedConfig(strategy, routes, self, envelope);
+        const engine = new depa_processor_1.DispatchEngine();
+        engine.registerStrategy(config);
+        const request = buildRequest(strategy, envelope, extractors);
+        const result = await engine.dispatch(request);
+        if (result.isHandled()) {
+            // Await the sub-handler's (possibly async) side effect.
+            await result.getResult();
+            return;
+        }
+        if (defaultHandler) {
+            await defaultHandler(self, envelope);
+        }
+    };
+}

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; } });