hammerkit 1.5.0 → 1.6.0-alpha.1

package/dist/executer/process-manager.spec.js

@@ -1,90 +1,53 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const process_manager_1 = require("./process-manager");
-const environment_mock_1 = require("./environment-mock");
-const abort_event_1 = require("../utils/abort-event");
+const work_item_status_1 = require("../planner/work-item-status");
+const empty_writable_1 = require("../utils/empty-writable");
 describe('process-manager', () => {
+    function fakeWorkItem(id) {
+        return {
+            id: () => '',
+            status: (0, work_item_status_1.statusConsole)((0, empty_writable_1.emptyWritable)()).context((0, work_item_status_1.logContext)('task', { name: id })),
+            deps: [],
+            aliases: [id],
+            needs: [],
+            requiredBy: [],
+            name: id,
+            data: null,
+            state: null,
+            runtime: null,
+        };
+    }
     it('should complete on success', async () => {
-        const manager = new process_manager_1.ProcessManager((0, environment_mock_1.environmentMock)(process.cwd()), 0);
-        let currentIndex = 0;
-        const expectedEvents = ['started', 'ended'];
-        manager.on((evt) => {
-            expect(evt.type).toBe(expectedEvents[currentIndex++]);
-        });
-        manager.task({ type: 'task', name: 'test-success', id: 'a' }, () => new Promise((resolve) => setTimeout(() => resolve(), 100)));
-        await manager.onComplete();
-        expect(currentIndex).toBe(2);
+        const manager = new process_manager_1.ProcessManager(0);
+        let called = false;
+        await manager.task(fakeWorkItem('a'), () => new Promise((resolve) => setTimeout(() => {
+            called = true;
+            resolve();
+        }, 100)));
+        expect(called).toBeTruthy();
     });
-    it('should complete on error', async () => {
-        const manager = new process_manager_1.ProcessManager((0, environment_mock_1.environmentMock)(process.cwd()), 0);
-        let currentIndex = 0;
-        const expectedEvents = ['started', 'ended'];
-        manager.on((evt) => {
-            expect(evt.type).toBe(expectedEvents[currentIndex++]);
-        });
-        manager.task({ type: 'task', name: 'test-error', id: 'a' }, () => new Promise((resolve, reject) => setTimeout(() => reject(new Error('3')), 100)));
-        await manager.onComplete();
-        expect(currentIndex).toBe(2);
+    it('should throw error', async () => {
+        const manager = new process_manager_1.ProcessManager(0);
+        await expect(manager.task(fakeWorkItem('a'), () => new Promise((resolve, reject) => setTimeout(() => reject(new Error('3')), 100)))).rejects.toThrow('3');
     });
     it('should not start more than worker count', async () => {
-        const manager = new process_manager_1.ProcessManager((0, environment_mock_1.environmentMock)(process.cwd()), 1);
-        const processes = [];
-        let concurrencyCount = 0;
-        let hasOversteppedLimits = false;
-        manager.on((evt) => {
-            if (evt.type === 'started') {
-                concurrencyCount++;
-            }
-            else if (evt.type === 'ended') {
-                concurrencyCount--;
-                processes.push(evt.context.id);
-            }
-            if (concurrencyCount > 1) {
-                hasOversteppedLimits = true;
-            }
-        });
-        manager.task({ type: 'task', name: 'test-success', id: 'a' }, () => new Promise((resolve) => setTimeout(() => resolve(), 100)));
-        manager.task({ type: 'task', name: 'test-success', id: 'b' }, () => new Promise((resolve) => setTimeout(() => resolve(), 100)));
-        manager.task({ type: 'task', name: 'test-success', id: 'c' }, () => new Promise((resolve) => setTimeout(() => resolve(), 100)));
-        await manager.onComplete();
-        expect(processes).toEqual(['a', 'b', 'c']);
-        expect(hasOversteppedLimits).toBeFalsy();
-        expect(concurrencyCount).toBe(0);
-    });
-    it('should terminate on abort', async () => {
-        const env = (0, environment_mock_1.environmentMock)(process.cwd());
-        const manager = new process_manager_1.ProcessManager(env, 0);
-        manager.task({ type: 'task', name: 'test-success', id: 'a' }, (abort) => new Promise((resolve) => {
-            (0, abort_event_1.listenOnAbort)(abort.signal, resolve);
-        }));
-        setTimeout(() => {
-            env.abortCtrl.abort();
-        }, 200);
-        await manager.onComplete();
-    });
-    it('should abort if task with same id is already started', async () => {
-        const manager = new process_manager_1.ProcessManager((0, environment_mock_1.environmentMock)(process.cwd()), 0);
-        const processes = [];
+        const manager = new process_manager_1.ProcessManager(1);
         let concurrencyCount = 0;
-        let hasOversteppedLimits = false;
-        manager.on((evt) => {
-            if (evt.type === 'started') {
-                concurrencyCount++;
-            }
-            else if (evt.type === 'ended') {
+        const fakeAction = () => new Promise((resolve) => {
+            expect(concurrencyCount).toBe(0);
+            concurrencyCount++;
+            setTimeout(() => {
+                expect(concurrencyCount).toBe(1);
                 concurrencyCount--;
-                processes.push(evt.context.id);
-            }
-            if (concurrencyCount > 1) {
-                hasOversteppedLimits = true;
-            }
+                resolve();
+            }, 100);
         });
-        const abortController = manager.task({ type: 'task', name: 'test-success', id: 'a' }, () => new Promise((resolve) => setTimeout(() => resolve(), 200)));
-        manager.task({ type: 'task', name: 'test-success', id: 'a' }, () => new Promise((resolve) => setTimeout(() => resolve(), 100)));
-        expect(abortController.signal.aborted).toBeTruthy();
-        await manager.onComplete();
-        expect(processes).toEqual(['a', 'a']);
-        expect(hasOversteppedLimits).toBeFalsy();
+        await Promise.all([
+            manager.task(fakeWorkItem('a'), fakeAction),
+            manager.task(fakeWorkItem('b'), fakeAction),
+            manager.task(fakeWorkItem('c'), fakeAction),
+        ]);
         expect(concurrencyCount).toBe(0);
     });
 });

package/dist/executer/reset-work-tree.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resetWorkTree = void 0;
+const state_1 = require("./state");
+function resetWorkTree(workTree, type) {
+    return {
+        tasks: Object.entries(workTree.tasks).reduce((tasks, [key, task]) => {
+            task.state = new state_1.State({
+                type: 'pending',
+                stateKey: null,
+            });
+            tasks[key] = task;
+            return tasks;
+        }, {}),
+        services: Object.entries(workTree.services).reduce((services, [key, service]) => {
+            if (type === 'execute' && service.requiredBy.length === 0) {
+                return services;
+            }
+            service.state = new state_1.State({
+                type: 'pending',
+                stateKey: null,
+            });
+            services[key] = service;
+            return services;
+        }, {}),
+        environment: workTree.environment,
+    };
+}
+exports.resetWorkTree = resetWorkTree;
+//# sourceMappingURL=reset-work-tree.js.map

package/dist/executer/scheduler/check-for-loop.js

@@ -1,19 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.checkForLoop = void 0;
-const plan_work_nodes_1 = require("../../planner/utils/plan-work-nodes");
+const plan_work_tasks_1 = require("../../planner/utils/plan-work-tasks");
 const validate_1 = require("../../planner/validate");
-function checkForLoop(state) {
-    for (const nodeState of (0, plan_work_nodes_1.iterateWorkNodes)(state.node)) {
-        const cyclePath = (0, validate_1.hasCycle)(nodeState.node, []);
+function checkForLoop(workTree) {
+    for (const task of (0, plan_work_tasks_1.iterateWorkTasks)(workTree)) {
+        const cyclePath = (0, validate_1.hasDependencyCycle)(task, []) ?? (0, validate_1.hasMixedCycle)(task, []);
         if (cyclePath && cyclePath.length > 0) {
             const errorMessage = `task cycle detected ${cyclePath.map((n) => n.name).join(' -> ')}`;
-            state.node[nodeState.node.id] = {
+            task.state.set({
                 type: 'error',
-                node: nodeState.node,
                 stateKey: null,
                 errorMessage,
-            };
+            });
+        }
+    }
+    for (const service of (0, plan_work_tasks_1.iterateWorkServices)(workTree)) {
+        const cyclePath = (0, validate_1.hasNeedCycle)(service, []) ?? (0, validate_1.hasMixedCycle)(service, []);
+        if (cyclePath && cyclePath.length > 0) {
+            const errorMessage = `service cycle detected ${cyclePath.map((n) => n.name).join(' -> ')}`;
+            service.state.set({
+                type: 'error',
+                stateKey: null,
+                errorMessage,
+            });
         }
     }
 }

package/dist/executer/scheduler/{scheduler-state.js → dependency-state.js}

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=scheduler-state.js.map
+//# sourceMappingURL=dependency-state.js.map

package/dist/executer/scheduler/enqueue-next.js

@@ -1,27 +1,91 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.checkCacheState = void 0;
-const read_work_node_cache_1 = require("../../optimizer/read-work-node-cache");
-const get_work_node_cache_stats_1 = require("../../optimizer/get-work-node-cache-stats");
-async function checkCacheState(node, defaultCacheMethod, environment) {
-    const status = environment.status.task(node);
-    const caching = node.caching ?? defaultCacheMethod;
-    const currentStats = await (0, get_work_node_cache_stats_1.getWorkNodeCacheStats)(node, environment);
-    const stateKey = (0, get_work_node_cache_stats_1.getStateKey)(currentStats, caching);
-    if (caching === 'none') {
-        status.write('debug', `${node.name} is skipping cache check, because caching is disabled`);
-        return { cached: false, stateKey };
+const get_work_cache_stats_1 = require("../../optimizer/get-work-cache-stats");
+const work_item_1 = require("../../planner/work-item");
+const get_cache_directory_1 = require("../../optimizer/get-cache-directory");
+const cache_metadata_1 = require("../cache-metadata");
+const work_task_cache_description_1 = require("../../optimizer/work-task-cache-description");
+const log_1 = require("../../log");
+const crypto_1 = require("crypto");
+function resolveEffective(item, fallbackMethod) {
+    const declared = item.data.caching;
+    if (declared.implicit) {
+        return { ...declared, method: fallbackMethod };
     }
-    const cache = await (0, read_work_node_cache_1.readCache)(node, environment);
-    if (cache === null) {
-        status.write('debug', `${node.name} is skipping cache check, because there was none found`);
-        return { cached: false, stateKey };
+    return declared;
+}
+// Fold a task's own state key together with the state keys of its dependencies.
+// A change anywhere in the dependency subtree must change the resulting key, so
+// that a downstream task is invalidated when an upstream source changes — even
+// if the downstream task's own sources are untouched.
+function combineStateKeys(ownKey, depKeys) {
+    if (depKeys.length === 0) {
+        return ownKey;
+    }
+    // Sort so the key is independent of dependency declaration order.
+    const sorted = [...depKeys].sort();
+    return (0, crypto_1.createHash)('md5')
+        .update([ownKey, ...sorted].join(','))
+        .digest('hex');
+}
+// Compute an item's effective state key from its source files plus the effective
+// state keys of its dependencies, recursively. This is derived purely from the
+// work tree and the filesystem, so it does not depend on scheduler/run state —
+// important because checkCacheState runs before dependencies are awaited.
+async function resolveEffectiveStateKey(item, defaultCacheMethod, environment, memo) {
+    const existing = memo.get(item.id());
+    if (existing !== undefined) {
+        return existing;
+    }
+    const resolved = resolveEffective(item, defaultCacheMethod);
+    // Always hash with a concrete method; `none` only disables the cache *check*
+    // for that task, its sources still influence what depends on it.
+    const method = resolved.method === 'none' ? defaultCacheMethod : resolved.method;
+    const stats = await (0, get_work_cache_stats_1.getWorkCacheStats)(item.data, environment);
+    const ownKey = (0, get_work_cache_stats_1.getStateKey)(stats, method);
+    const depKeys = [];
+    for (const dep of item.deps) {
+        depKeys.push(await resolveEffectiveStateKey(dep, defaultCacheMethod, environment, memo));
+    }
+    const combined = combineStateKeys(ownKey, depKeys);
+    memo.set(item.id(), combined);
+    return combined;
+}
+async function checkCacheState(item, defaultCacheMethod, environment) {
+    const resolved = resolveEffective(item, defaultCacheMethod);
+    const currentStats = await (0, get_work_cache_stats_1.getWorkCacheStats)(item.data, environment);
+    const ownKey = (0, get_work_cache_stats_1.getStateKey)(currentStats, resolved.method === 'none' ? defaultCacheMethod : resolved.method);
+    const memo = new Map();
+    const depKeys = [];
+    for (const dep of item.deps) {
+        depKeys.push(await resolveEffectiveStateKey(dep, defaultCacheMethod, environment, memo));
+    }
+    const stateKey = combineStateKeys(ownKey, depKeys);
+    if (resolved.method === 'none') {
+        item.status.write('debug', `${item.name} is skipping cache check, because caching is disabled`);
+        return { cached: false, stateKey, resolved };
+    }
+    if ((0, work_item_1.isWorkTaskItem)(item)) {
+        const runtimeStateKey = await item.runtime.currentStateKey(environment);
+        if (runtimeStateKey === stateKey) {
+            return { cached: true, stateKey, resolved };
+        }
+        try {
+            const cacheDir = (0, get_cache_directory_1.getCacheDirectory)(item.id());
+            const pulled = await resolved.backend.pull(item.id(), stateKey, cacheDir, environment);
+            if (pulled) {
+                item.status.write('info', `${item.name} pulled from cache "${resolved.name}" (${resolved.backend.type})`);
+                await item.runtime.restore(environment, cacheDir);
+                await (0, cache_metadata_1.writeCacheMetadata)(environment, item.id(), currentStats, (0, work_task_cache_description_1.getWorkTaskCacheDescription)(item.data));
+                return { cached: true, stateKey, resolved };
+            }
+        }
+        catch (e) {
+            item.status.write('warn', `${item.name} failed to pull from cache "${resolved.name}": ${(0, log_1.getErrorMessage)(e)} — continuing with local execution`);
+        }
     }
-    const cacheKey = (0, get_work_node_cache_stats_1.getStateKey)(cache, caching);
-    return {
-        cached: cacheKey === stateKey,
-        stateKey,
-    };
+    return { cached: false, stateKey, resolved };
 }
 exports.checkCacheState = checkCacheState;
 //# sourceMappingURL=enqueue-next.js.map

package/dist/executer/scheduler/enqueue-next.spec.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = require("path");
+const os_1 = require("os");
+const fs_1 = require("fs");
+const environment_mock_1 = require("../environment-mock");
+const enqueue_next_1 = require("./enqueue-next");
+const local_cache_backend_1 = require("../../cache/backends/local-cache-backend");
+const state_1 = require("../state");
+describe('checkCacheState', () => {
+    let scratch;
+    let remoteDir;
+    let machineHome;
+    let originalHome;
+    beforeEach(() => {
+        scratch = (0, fs_1.mkdtempSync)((0, path_1.join)((0, os_1.tmpdir)(), 'hammerkit-enqueue-'));
+        remoteDir = (0, fs_1.mkdtempSync)((0, path_1.join)((0, os_1.tmpdir)(), 'hammerkit-remote-'));
+        machineHome = (0, fs_1.mkdtempSync)((0, path_1.join)((0, os_1.tmpdir)(), 'hammerkit-home-'));
+        originalHome = process.env.HOME;
+        if (process.platform === 'win32') {
+            process.env.APPDATA = machineHome;
+        }
+        else {
+            process.env.HOME = machineHome;
+        }
+    });
+    afterEach(() => {
+        (0, fs_1.rmSync)(scratch, { recursive: true, force: true });
+        (0, fs_1.rmSync)(remoteDir, { recursive: true, force: true });
+        (0, fs_1.rmSync)(machineHome, { recursive: true, force: true });
+        if (originalHome !== undefined) {
+            process.env.HOME = originalHome;
+        }
+        else {
+            delete process.env.HOME;
+        }
+    });
+    // empty remote → backend.pull always misses, so a key mismatch yields cached:false
+    function makeResolved(method) {
+        return {
+            name: 'remote',
+            method,
+            backend: (0, local_cache_backend_1.createLocalCacheBackend)({ type: 'local', path: remoteDir }),
+            implicit: false,
+        };
+    }
+    function makeTask(id, options) {
+        const storedStateKey = options.storedStateKey ?? null;
+        return {
+            id: () => id,
+            name: id,
+            status: { write: vi.fn() },
+            data: {
+                type: 'local-task',
+                name: id,
+                cwd: scratch,
+                cmds: [],
+                generates: [],
+                src: (options.srcFiles ?? []).map((absolutePath) => ({
+                    absolutePath,
+                    source: absolutePath,
+                    matcher: () => true,
+                    inherited: null,
+                    isFile: true,
+                })),
+                envs: { variables: {}, replacements: [] },
+                labels: {},
+                shell: '/bin/sh',
+                caching: options.resolved,
+                description: null,
+                scope: {},
+            },
+            needs: [],
+            deps: options.deps ?? [],
+            requiredBy: [],
+            state: new state_1.State({ type: 'pending', stateKey: null }),
+            runtime: {
+                async initialize() { },
+                async remove() { },
+                async execute() { },
+                async stop() { },
+                async archive() { },
+                async restore() { },
+                async currentStateKey() {
+                    return storedStateKey;
+                },
+            },
+        };
+    }
+    it('reports cached:false when caching method is none', async () => {
+        const env = (0, environment_mock_1.environmentMock)(scratch);
+        const task = makeTask('none-task', { resolved: makeResolved('none') });
+        const result = await (0, enqueue_next_1.checkCacheState)(task, 'checksum', env);
+        expect(result.cached).toBe(false);
+    });
+    it('reports cached:true when the stored key matches the effective key', async () => {
+        const env = (0, environment_mock_1.environmentMock)(scratch);
+        const probe = makeTask('hit-task', { resolved: makeResolved('checksum') });
+        const { stateKey } = await (0, enqueue_next_1.checkCacheState)(probe, 'checksum', env);
+        const task = makeTask('hit-task', { resolved: makeResolved('checksum'), storedStateKey: stateKey });
+        const result = await (0, enqueue_next_1.checkCacheState)(task, 'checksum', env);
+        expect(result.cached).toBe(true);
+        expect(result.stateKey).toBe(stateKey);
+    });
+    it('invalidates a downstream task when an upstream dependency source changes', async () => {
+        const env = (0, environment_mock_1.environmentMock)(scratch);
+        const upstreamSrc = (0, path_1.join)(scratch, 'upstream.txt');
+        (0, fs_1.writeFileSync)(upstreamSrc, 'v1');
+        const makeUpstream = () => makeTask('upstream', { resolved: makeResolved('checksum'), srcFiles: [upstreamSrc] });
+        const makeDownstream = (storedStateKey) => makeTask('downstream', { resolved: makeResolved('checksum'), deps: [makeUpstream()], storedStateKey });
+        // First pass: capture the downstream effective key and pretend it was stored.
+        const keyBefore = (await (0, enqueue_next_1.checkCacheState)(makeDownstream(null), 'checksum', env)).stateKey;
+        const cachedHit = await (0, enqueue_next_1.checkCacheState)(makeDownstream(keyBefore), 'checksum', env);
+        expect(cachedHit.cached).toBe(true);
+        // Change ONLY the upstream source — downstream's own sources are untouched.
+        (0, fs_1.writeFileSync)(upstreamSrc, 'v2-changed');
+        const afterChange = await (0, enqueue_next_1.checkCacheState)(makeDownstream(keyBefore), 'checksum', env);
+        expect(afterChange.stateKey).not.toBe(keyBefore);
+        expect(afterChange.cached).toBe(false);
+    });
+    it('produces a stable key regardless of dependency declaration order', async () => {
+        const env = (0, environment_mock_1.environmentMock)(scratch);
+        const aSrc = (0, path_1.join)(scratch, 'a.txt');
+        const bSrc = (0, path_1.join)(scratch, 'b.txt');
+        (0, fs_1.writeFileSync)(aSrc, 'a');
+        (0, fs_1.writeFileSync)(bSrc, 'b');
+        const depA = () => makeTask('dep-a', { resolved: makeResolved('checksum'), srcFiles: [aSrc] });
+        const depB = () => makeTask('dep-b', { resolved: makeResolved('checksum'), srcFiles: [bSrc] });
+        const forward = makeTask('root', { resolved: makeResolved('checksum'), deps: [depA(), depB()] });
+        const reversed = makeTask('root', { resolved: makeResolved('checksum'), deps: [depB(), depA()] });
+        const keyForward = (await (0, enqueue_next_1.checkCacheState)(forward, 'checksum', env)).stateKey;
+        const keyReversed = (await (0, enqueue_next_1.checkCacheState)(reversed, 'checksum', env)).stateKey;
+        expect(keyForward).toBe(keyReversed);
+    });
+});
+//# sourceMappingURL=enqueue-next.spec.js.map

package/dist/executer/scheduler/{node-state.js → need-state.js}

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=node-state.js.map
+//# sourceMappingURL=need-state.js.map

package/dist/{parser/build-file.js → executer/scheduler/task-state.js}

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=build-file.js.map
+//# sourceMappingURL=task-state.js.map

package/dist/executer/set-user-permission.js

@@ -4,7 +4,7 @@ exports.setUserPermission = void 0;
 const execute_docker_1 = require("./execute-docker");
 async function setUserPermission(directory, status, environment, container, user) {
     status.write('debug', `set permission on ${directory}`);
-    const result = await (0, execute_docker_1.execCommand)(status, environment, container, '/', ['chown', user, directory], null, undefined, undefined);
+    const result = await (0, execute_docker_1.execCommand)(status, environment, container, '/', ['chown', user, directory], null, undefined, new AbortController().signal);
     if (result.type === 'canceled') {
         return;
     }

package/dist/executer/state-resolver.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.awaitState = exports.isState = exports.untilChanged = void 0;
+const abort_event_1 = require("../utils/abort-event");
+const abort_1 = require("./abort");
+function untilChanged(key, state, abort) {
+    return new Promise((resolve, reject) => {
+        const handle = state.on(key, (value) => {
+            handle.close();
+            abortListener.close();
+            resolve(value);
+        });
+        const abortListener = (0, abort_event_1.listenOnAbort)(abort, () => {
+            handle.close();
+            reject(new abort_1.AbortError());
+        });
+    });
+}
+exports.untilChanged = untilChanged;
+function isState(key, state, condition, abort) {
+    if (condition(state.current)) {
+        return Promise.resolve(state.current);
+    }
+    return new Promise((resolve, reject) => {
+        const listener = state.on(key, (value) => {
+            if (!condition(value)) {
+                return;
+            }
+            abortListener.close();
+            resolve(value);
+            listener.close();
+        });
+        const abortListener = (0, abort_event_1.listenOnAbort)(abort, () => {
+            listener.close();
+            reject(new abort_1.AbortError());
+        });
+    });
+}
+exports.isState = isState;
+function awaitState(key, state, condition, abort) {
+    return new Promise((resolve, reject) => {
+        if (condition(state.current)) {
+            resolve();
+            return;
+        }
+        const listener = state.on(key, (value) => {
+            if (!condition(value)) {
+                return;
+            }
+            listener.close();
+            abortListener.close();
+            resolve();
+        });
+        const abortListener = (0, abort_event_1.listenOnAbort)(abort, () => {
+            listener.close();
+            reject(new abort_1.AbortError());
+        });
+    });
+}
+exports.awaitState = awaitState;
+//# sourceMappingURL=state-resolver.js.map

package/dist/executer/state-resolver.spec.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const state_resolver_1 = require("./state-resolver");
+const state_1 = require("./state");
+const abort_1 = require("./abort");
+describe('state-resolver', () => {
+    it('should resolve state', async () => {
+        const state = new state_1.State('a');
+        const isB = (val) => val === 'b';
+        const result = (0, state_resolver_1.isState)('test-state', state, isB, new AbortController().signal);
+        state.set('c');
+        state.set('a');
+        state.set('b');
+        await result;
+    });
+    it('should resolve state if already in', async () => {
+        const state = new state_1.State('b');
+        const isB = (val) => val === 'b';
+        await (0, state_resolver_1.isState)('test-state', state, isB, new AbortController().signal);
+    });
+    it('isState rejects with AbortError when aborted before the condition is met', async () => {
+        const state = new state_1.State('a');
+        const isB = (val) => val === 'b';
+        const abort = new AbortController();
+        const result = (0, state_resolver_1.isState)('test-state', state, isB, abort.signal);
+        abort.abort();
+        await expect(result).rejects.toBeInstanceOf(abort_1.AbortError);
+    });
+    it('awaitState rejects with AbortError when aborted before the condition is met', async () => {
+        const state = new state_1.State('a');
+        const abort = new AbortController();
+        const result = (0, state_resolver_1.awaitState)('test-state', state, (val) => val === 'b', abort.signal);
+        abort.abort();
+        await expect(result).rejects.toBeInstanceOf(abort_1.AbortError);
+    });
+});
+//# sourceMappingURL=state-resolver.spec.js.map

package/dist/executer/state.js

@@ -2,46 +2,52 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.State = void 0;
 class State {
-    constructor(current) {
+    constructor(current, options) {
         this.current = current;
+        this.options = options;
         this.listeners = [];
-    }
-    assignState(state, newValue) {
-        const currentKeys = Object.keys(state);
-        const newKeys = Object.keys(newValue);
-        const keysToRemove = currentKeys.filter((k) => newKeys.indexOf(k) === -1);
-        for (const key of keysToRemove) {
-            delete state[key];
-        }
-        for (const key of newKeys) {
-            state[key] = newValue[key];
+        this.handles = [];
+        if (this.options?.subStates) {
+            this.attachToStores(this.options.subStates);
         }
     }
-    resetNode(newState) {
-        const state = this.current.node[newState.node.id];
-        this.assignState(state, newState);
-        this.notifyListeners(this.current);
-        return state;
-    }
-    patchNode(newState, stateKey) {
-        const state = this.current.node[newState.node.id];
-        if (state.stateKey === stateKey) {
-            this.assignState(state, newState);
-            this.notifyListeners(this.current);
+    attachToStores(subStates) {
+        for (const state of subStates) {
+            this.handles.push(state.on('sub-state-forward', () => {
+                this.notifyListeners(this.current);
+            }));
         }
-        return state;
     }
-    patchService(newState) {
-        this.assignState(this.current.service[newState.service.id], newState);
-        this.notifyListeners(this.current);
+    set(newState) {
+        this.current = newState;
+        this.notifyListeners(newState);
+        return this.current;
     }
-    on(listener) {
-        this.listeners.push(listener);
-        listener(this.current);
+    on(key, listener) {
+        this.listeners.push({ key, listener });
+        return {
+            close: () => {
+                const index = this.listeners.findIndex((l) => l.key === key && l.listener === listener);
+                if (index >= 0) {
+                    this.listeners.splice(index, 1);
+                }
+                else {
+                    // TODO warn
+                }
+            },
+        };
     }
     notifyListeners(evt) {
-        for (const listener of this.listeners) {
-            listener(evt);
+        for (const listener of [...this.listeners]) {
+            listener.listener(evt);
+        }
+    }
+    close() {
+        for (const handle of this.handles) {
+            handle.close();
+        }
+        if (this.options?.onDestroy) {
+            this.options?.onDestroy();
         }
     }
 }