reqon-dsl 0.2.0 → 0.4.0

package/dist/auth/auth.test.js

@@ -1,255 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { AdaptiveRateLimiter, parseRateLimitHeaders, RateLimitError, RateLimitTimeoutError, } from './rate-limiter.js';
-import { InMemoryTokenStore } from './token-store.js';
-describe('parseRateLimitHeaders', () => {
-    it('parses X-RateLimit headers', () => {
-        const headers = {
-            'X-RateLimit-Limit': '100',
-            'X-RateLimit-Remaining': '42',
-            'X-RateLimit-Reset': '1700000000',
-        };
-        const info = parseRateLimitHeaders(headers);
-        expect(info.limit).toBe(100);
-        expect(info.remaining).toBe(42);
-        expect(info.resetAt).toBeInstanceOf(Date);
-        expect(info.resetAt?.getTime()).toBe(1700000000 * 1000);
-    });
-    it('parses lowercase ratelimit headers', () => {
-        const headers = {
-            'ratelimit-limit': '60',
-            'ratelimit-remaining': '5',
-        };
-        const info = parseRateLimitHeaders(headers);
-        expect(info.limit).toBe(60);
-        expect(info.remaining).toBe(5);
-    });
-    it('parses Retry-After header (seconds)', () => {
-        const headers = {
-            'Retry-After': '30',
-        };
-        const info = parseRateLimitHeaders(headers);
-        expect(info.retryAfter).toBe(30);
-    });
-    it('handles missing headers gracefully', () => {
-        const info = parseRateLimitHeaders({});
-        expect(info.limit).toBeUndefined();
-        expect(info.remaining).toBeUndefined();
-        expect(info.resetAt).toBeUndefined();
-        expect(info.retryAfter).toBeUndefined();
-    });
-});
-describe('AdaptiveRateLimiter', () => {
-    let limiter;
-    beforeEach(() => {
-        limiter = new AdaptiveRateLimiter();
-    });
-    it('allows requests when no limits recorded', async () => {
-        const canProceed = await limiter.canProceed('TestAPI');
-        expect(canProceed).toBe(true);
-    });
-    it('blocks requests when remaining is 0', async () => {
-        const futureReset = new Date(Date.now() + 60000);
-        limiter.recordResponse('TestAPI', {
-            remaining: 0,
-            limit: 100,
-            resetAt: futureReset,
-        });
-        const canProceed = await limiter.canProceed('TestAPI');
-        expect(canProceed).toBe(false);
-    });
-    it('allows requests after reset time passes', async () => {
-        const pastReset = new Date(Date.now() - 1000);
-        limiter.recordResponse('TestAPI', {
-            remaining: 0,
-            limit: 100,
-            resetAt: pastReset,
-        });
-        const canProceed = await limiter.canProceed('TestAPI');
-        expect(canProceed).toBe(true);
-    });
-    it('blocks during retry-after period', async () => {
-        limiter.recordResponse('TestAPI', {
-            retryAfter: 60, // 60 seconds
-        });
-        const canProceed = await limiter.canProceed('TestAPI');
-        expect(canProceed).toBe(false);
-    });
-    it('tracks limits per source', async () => {
-        limiter.recordResponse('API1', { remaining: 0, resetAt: new Date(Date.now() + 60000) });
-        limiter.recordResponse('API2', { remaining: 50, limit: 100 });
-        expect(await limiter.canProceed('API1')).toBe(false);
-        expect(await limiter.canProceed('API2')).toBe(true);
-    });
-    it('tracks limits per endpoint within source', async () => {
-        limiter.recordResponse('API', { remaining: 0, resetAt: new Date(Date.now() + 60000) }, '/invoices');
-        limiter.recordResponse('API', { remaining: 50, limit: 100 }, '/contacts');
-        expect(await limiter.canProceed('API', '/invoices')).toBe(false);
-        expect(await limiter.canProceed('API', '/contacts')).toBe(true);
-    });
-    it('provides accurate status', () => {
-        limiter.recordResponse('TestAPI', {
-            remaining: 42,
-            limit: 100,
-            resetAt: new Date(Date.now() + 60000),
-        });
-        const status = limiter.getStatus('TestAPI');
-        expect(status.remaining).toBe(42);
-        expect(status.limit).toBe(100);
-        expect(status.isLimited).toBe(false);
-    });
-    describe('fail strategy', () => {
-        it('throws RateLimitError immediately when rate limited', async () => {
-            limiter.configure('FailAPI', { strategy: 'fail' });
-            limiter.recordResponse('FailAPI', {
-                remaining: 0,
-                resetAt: new Date(Date.now() + 60000),
-            });
-            await expect(limiter.waitForCapacity('FailAPI')).rejects.toThrow(RateLimitError);
-        });
-        it('includes reset time in error', async () => {
-            limiter.configure('FailAPI', { strategy: 'fail' });
-            const resetAt = new Date(Date.now() + 60000);
-            limiter.recordResponse('FailAPI', { remaining: 0, resetAt });
-            try {
-                await limiter.waitForCapacity('FailAPI');
-                expect.fail('Should have thrown');
-            }
-            catch (error) {
-                expect(error).toBeInstanceOf(RateLimitError);
-                expect(error.resetAt).toEqual(resetAt);
-            }
-        });
-    });
-    describe('pause strategy', () => {
-        it('throws RateLimitTimeoutError when maxWait exceeded', async () => {
-            limiter.configure('PauseAPI', { strategy: 'pause', maxWait: 1 });
-            limiter.recordResponse('PauseAPI', {
-                remaining: 0,
-                resetAt: new Date(Date.now() + 60000), // 60s in future
-            });
-            await expect(limiter.waitForCapacity('PauseAPI')).rejects.toThrow(RateLimitTimeoutError);
-        });
-        it('proceeds after reset time passes', async () => {
-            limiter.configure('PauseAPI', { strategy: 'pause', maxWait: 5 });
-            // Reset in 50ms
-            limiter.recordResponse('PauseAPI', {
-                remaining: 0,
-                resetAt: new Date(Date.now() + 50),
-            });
-            // Should complete without throwing
-            await limiter.waitForCapacity('PauseAPI');
-        });
-    });
-    describe('throttle strategy', () => {
-        it('calculates delay based on remaining requests and reset time', () => {
-            limiter.configure('ThrottleAPI', { strategy: 'throttle' });
-            limiter.recordResponse('ThrottleAPI', {
-                remaining: 10,
-                limit: 100,
-                resetAt: new Date(Date.now() + 10000), // 10s left
-            });
-            const delay = limiter.getThrottleDelay('ThrottleAPI');
-            // 10s / 10 remaining = 1s per request = 1000ms
-            expect(delay).toBeGreaterThanOrEqual(900);
-            expect(delay).toBeLessThanOrEqual(1100);
-        });
-        it('returns 0 delay when not in throttle mode', () => {
-            limiter.configure('PauseAPI', { strategy: 'pause' });
-            limiter.recordResponse('PauseAPI', { remaining: 10, limit: 100 });
-            const delay = limiter.getThrottleDelay('PauseAPI');
-            expect(delay).toBe(0);
-        });
-        it('uses fallback RPM when no rate limit headers', () => {
-            limiter.configure('FallbackAPI', { strategy: 'throttle', fallbackRpm: 60 });
-            limiter.recordResponse('FallbackAPI', {}); // No rate limit info
-            const delay = limiter.getThrottleDelay('FallbackAPI');
-            // 60 RPM = 1 per second = 1000ms intervals
-            expect(delay).toBeLessThanOrEqual(1000);
-        });
-    });
-    describe('callbacks', () => {
-        it('calls onRateLimited when rate limited', async () => {
-            const onRateLimited = vi.fn();
-            limiter.setCallbacks({ onRateLimited });
-            // Use maxWait of 10s so it doesn't timeout immediately (wait is only 50ms)
-            limiter.configure('CallbackAPI', { strategy: 'pause', maxWait: 10 });
-            limiter.recordResponse('CallbackAPI', {
-                remaining: 0,
-                resetAt: new Date(Date.now() + 50), // Resets in 50ms
-            });
-            await limiter.waitForCapacity('CallbackAPI');
-            expect(onRateLimited).toHaveBeenCalledTimes(1);
-            expect(onRateLimited).toHaveBeenCalledWith(expect.objectContaining({
-                source: 'CallbackAPI',
-                strategy: 'pause',
-            }));
-        });
-        it('calls onResumed after waiting completes', async () => {
-            const onResumed = vi.fn();
-            limiter.setCallbacks({ onResumed });
-            limiter.configure('ResumeAPI', { strategy: 'pause', maxWait: 5 });
-            // Reset in 50ms
-            limiter.recordResponse('ResumeAPI', {
-                remaining: 0,
-                resetAt: new Date(Date.now() + 50),
-            });
-            await limiter.waitForCapacity('ResumeAPI');
-            expect(onResumed).toHaveBeenCalledTimes(1);
-            expect(onResumed).toHaveBeenCalledWith(expect.objectContaining({
-                source: 'ResumeAPI',
-            }));
-        });
-    });
-});
-describe('InMemoryTokenStore', () => {
-    let store;
-    beforeEach(() => {
-        store = new InMemoryTokenStore();
-    });
-    it('stores and retrieves tokens', async () => {
-        const tokens = {
-            accessToken: 'access123',
-            refreshToken: 'refresh456',
-            expiresAt: new Date(Date.now() + 3600000),
-        };
-        await store.set('connection-1', tokens);
-        const retrieved = await store.get('connection-1');
-        expect(retrieved?.accessToken).toBe('access123');
-        expect(retrieved?.refreshToken).toBe('refresh456');
-    });
-    it('returns null for unknown connections', async () => {
-        const result = await store.get('unknown');
-        expect(result).toBeNull();
-    });
-    it('deletes tokens', async () => {
-        await store.set('connection-1', { accessToken: 'test' });
-        await store.delete('connection-1');
-        const result = await store.get('connection-1');
-        expect(result).toBeNull();
-    });
-    it('lists all connections', async () => {
-        await store.set('conn-1', { accessToken: 'a' });
-        await store.set('conn-2', { accessToken: 'b' });
-        await store.set('conn-3', { accessToken: 'c' });
-        const connections = await store.list();
-        expect(connections).toHaveLength(3);
-        expect(connections).toContain('conn-1');
-        expect(connections).toContain('conn-2');
-        expect(connections).toContain('conn-3');
-    });
-    it('identifies tokens needing refresh', async () => {
-        // Token expiring in 10 seconds (within 5 min buffer)
-        await store.set('expiring-soon', {
-            accessToken: 'test',
-            expiresAt: new Date(Date.now() + 10000),
-        });
-        // Token not expiring soon
-        await store.set('valid', {
-            accessToken: 'test',
-            expiresAt: new Date(Date.now() + 3600000),
-        });
-        const needsRefresh = await store.getTokensNeedingRefresh(300);
-        expect(needsRefresh).toContain('expiring-soon');
-        expect(needsRefresh).not.toContain('valid');
-    });
-});

package/dist/errors/errors.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/errors/errors.test.js

@@ -1,165 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { ReqonError, ParseError, LexerError, RuntimeError, ValidationError, formatErrors, getSourceLine, getSourceContext, } from './index.js';
-import { ReqonLexer } from '../lexer/index.js';
-import { ReqonParser } from '../parser/index.js';
-describe('Error classes', () => {
-    describe('ReqonError', () => {
-        it('should format error with location', () => {
-            const error = new ReqonError('Something went wrong', { line: 5, column: 10 });
-            const formatted = error.format();
-            expect(formatted).toContain('ReqonError: Something went wrong');
-            expect(formatted).toContain('5:10');
-        });
-        it('should format error with source context', () => {
-            const source = `mission Test {
-  source API {
-    auth: bearer,
-    base: "https://api.example.com"
-  }
-}`;
-            const error = new ReqonError('Unexpected token', { line: 3, column: 5 }, { source });
-            const formatted = error.format();
-            expect(formatted).toContain('auth: bearer,');
-            expect(formatted).toContain('3 |');
-            expect(formatted).toContain('^');
-        });
-        it('should include file path when provided', () => {
-            const error = new ReqonError('Test error', { line: 1, column: 1 }, { source: 'test', filePath: '/path/to/file.reqon' });
-            const formatted = error.format();
-            expect(formatted).toContain('/path/to/file.reqon:');
-        });
-    });
-    describe('ParseError', () => {
-        it('should include token value in format', () => {
-            const error = new ParseError("Expected '{'", { line: 2, column: 15 }, undefined, 'identifier');
-            const formatted = error.format();
-            expect(formatted).toContain("found: 'identifier'");
-        });
-        it('should format with source context and pointer', () => {
-            const source = `mission Test {
-  source API auth: bearer
-}`;
-            const error = new ParseError("Expected '{'", { line: 2, column: 14 }, { source }, 'auth');
-            const formatted = error.format();
-            expect(formatted).toContain('ParseError');
-            expect(formatted).toContain('2:14');
-            expect(formatted).toContain('source API auth: bearer');
-            expect(formatted).toContain('^');
-        });
-    });
-    describe('LexerError', () => {
-        it('should format with source context', () => {
-            const source = 'mission Test { @ }';
-            const error = new LexerError("Unexpected character '@'", { line: 1, column: 16 }, { source });
-            const formatted = error.format();
-            expect(formatted).toContain('LexerError');
-            expect(formatted).toContain("Unexpected character '@'");
-        });
-    });
-    describe('RuntimeError', () => {
-        it('should include action and step info', () => {
-            const error = new RuntimeError('Request failed with status 404', { line: 5, column: 3 }, undefined, { action: 'FetchData', stepType: 'fetch' });
-            const formatted = error.format();
-            expect(formatted).toContain('in action: FetchData');
-            expect(formatted).toContain('at step: fetch');
-        });
-    });
-    describe('ValidationError', () => {
-        it('should include severity', () => {
-            const error = new ValidationError('Value must be positive', { line: 10, column: 5 }, undefined, { severity: 'warning' });
-            expect(error.severity).toBe('warning');
-        });
-    });
-});
-describe('formatErrors', () => {
-    it('should format multiple errors', () => {
-        const errors = [
-            new ParseError('Error 1', { line: 1, column: 1 }),
-            new ParseError('Error 2', { line: 5, column: 10 }),
-        ];
-        const formatted = formatErrors(errors);
-        expect(formatted).toContain('Error 1');
-        expect(formatted).toContain('Error 2');
-        expect(formatted).toContain('1:1');
-        expect(formatted).toContain('5:10');
-    });
-});
-describe('getSourceLine', () => {
-    it('should return the correct line', () => {
-        const source = 'line1\nline2\nline3';
-        expect(getSourceLine(source, 1)).toBe('line1');
-        expect(getSourceLine(source, 2)).toBe('line2');
-        expect(getSourceLine(source, 3)).toBe('line3');
-    });
-    it('should return undefined for out of range', () => {
-        const source = 'line1\nline2';
-        expect(getSourceLine(source, 5)).toBeUndefined();
-    });
-});
-describe('getSourceContext', () => {
-    it('should return surrounding lines', () => {
-        const source = 'line1\nline2\nline3\nline4\nline5';
-        const context = getSourceContext(source, 3, 1);
-        expect(context.lines).toHaveLength(3);
-        expect(context.lines[0]).toEqual({ num: 2, text: 'line2' });
-        expect(context.lines[1]).toEqual({ num: 3, text: 'line3' });
-        expect(context.lines[2]).toEqual({ num: 4, text: 'line4' });
-        expect(context.errorLineIndex).toBe(1);
-    });
-});
-describe('Integration with parser', () => {
-    it('should produce ParseError with source context', () => {
-        const source = `mission Test {
-  source API {
-    auth: bearer
-  }
-
-  action Fetch {
-    fetch GET "/items
-  }
-
-  run Fetch
-}`;
-        const lexer = new ReqonLexer(source);
-        expect(() => lexer.tokenize()).toThrow();
-        try {
-            lexer.tokenize();
-        }
-        catch (e) {
-            expect(e).toBeInstanceOf(Error);
-            const error = e;
-            expect(error.message).toContain('Unterminated string');
-        }
-    });
-    it('should produce ParseError for syntax errors', () => {
-        const source = `mission Test {
-  source API {
-    auth: bearer,
-    base: "https://api.example.com"
-  }
-
-  action Fetch
-    fetch GET "/items"
-  }
-
-  run Fetch
-}`;
-        const lexer = new ReqonLexer(source);
-        const tokens = lexer.tokenize();
-        const parser = new ReqonParser(tokens, source, 'test.reqon');
-        expect(() => parser.parse()).toThrow();
-        try {
-            parser.parse();
-        }
-        catch (e) {
-            expect(e).toBeInstanceOf(ParseError);
-            const error = e;
-            expect(error.location.line).toBeGreaterThan(0);
-            expect(error.context?.source).toBe(source);
-            expect(error.context?.filePath).toBe('test.reqon');
-            const formatted = error.format();
-            expect(formatted).toContain('test.reqon:');
-            expect(formatted).toContain('ParseError');
-        }
-    });
-});

package/dist/execution/execution.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/execution/execution.test.js

@@ -1,246 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { rmSync, existsSync } from 'node:fs';
-import { createExecutionState, findResumePoint, canResume, getProgress, getExecutionSummary, } from './state.js';
-import { FileExecutionStore, MemoryExecutionStore } from './store.js';
-const TEST_DIR = '.reqon-test-executions';
-describe('ExecutionState', () => {
-    describe('createExecutionState', () => {
-        it('creates initial state with pending stages', () => {
-            const state = createExecutionState({
-                mission: 'TestMission',
-                stages: ['FetchData', 'ProcessData', 'StoreResults'],
-            });
-            expect(state.mission).toBe('TestMission');
-            expect(state.status).toBe('pending');
-            expect(state.stages).toHaveLength(3);
-            expect(state.stages[0].action).toBe('FetchData');
-            expect(state.stages[0].status).toBe('pending');
-            expect(state.id).toMatch(/^exec_/);
-        });
-        it('includes metadata', () => {
-            const state = createExecutionState({
-                mission: 'Test',
-                stages: ['A'],
-                metadata: { tenant: 'acme', userId: '123' },
-            });
-            expect(state.metadata).toEqual({ tenant: 'acme', userId: '123' });
-        });
-    });
-    describe('findResumePoint', () => {
-        it('returns 0 for fresh execution', () => {
-            const state = createExecutionState({
-                mission: 'Test',
-                stages: ['A', 'B', 'C'],
-            });
-            expect(findResumePoint(state)).toBe(0);
-        });
-        it('returns index of first non-completed stage', () => {
-            const state = createExecutionState({
-                mission: 'Test',
-                stages: ['A', 'B', 'C'],
-            });
-            state.stages[0].status = 'completed';
-            state.stages[1].status = 'failed';
-            expect(findResumePoint(state)).toBe(1);
-        });
-        it('returns -1 when all stages complete', () => {
-            const state = createExecutionState({
-                mission: 'Test',
-                stages: ['A', 'B'],
-            });
-            state.stages[0].status = 'completed';
-            state.stages[1].status = 'completed';
-            expect(findResumePoint(state)).toBe(-1);
-        });
-        it('skips over skipped stages', () => {
-            const state = createExecutionState({
-                mission: 'Test',
-                stages: ['A', 'B', 'C'],
-            });
-            state.stages[0].status = 'completed';
-            state.stages[1].status = 'skipped';
-            expect(findResumePoint(state)).toBe(2);
-        });
-    });
-    describe('canResume', () => {
-        it('returns true for failed executions', () => {
-            const state = createExecutionState({ mission: 'Test', stages: ['A'] });
-            state.status = 'failed';
-            expect(canResume(state)).toBe(true);
-        });
-        it('returns true for paused executions', () => {
-            const state = createExecutionState({ mission: 'Test', stages: ['A'] });
-            state.status = 'paused';
-            expect(canResume(state)).toBe(true);
-        });
-        it('returns false for completed executions', () => {
-            const state = createExecutionState({ mission: 'Test', stages: ['A'] });
-            state.status = 'completed';
-            expect(canResume(state)).toBe(false);
-        });
-        it('returns false for running executions', () => {
-            const state = createExecutionState({ mission: 'Test', stages: ['A'] });
-            state.status = 'running';
-            expect(canResume(state)).toBe(false);
-        });
-    });
-    describe('getProgress', () => {
-        it('returns 0 for no completed stages', () => {
-            const state = createExecutionState({
-                mission: 'Test',
-                stages: ['A', 'B', 'C', 'D'],
-            });
-            expect(getProgress(state)).toBe(0);
-        });
-        it('returns 50 for half completed', () => {
-            const state = createExecutionState({
-                mission: 'Test',
-                stages: ['A', 'B', 'C', 'D'],
-            });
-            state.stages[0].status = 'completed';
-            state.stages[1].status = 'completed';
-            expect(getProgress(state)).toBe(50);
-        });
-        it('returns 100 for all completed', () => {
-            const state = createExecutionState({
-                mission: 'Test',
-                stages: ['A', 'B'],
-            });
-            state.stages[0].status = 'completed';
-            state.stages[1].status = 'completed';
-            expect(getProgress(state)).toBe(100);
-        });
-        it('counts skipped as progress', () => {
-            const state = createExecutionState({
-                mission: 'Test',
-                stages: ['A', 'B'],
-            });
-            state.stages[0].status = 'completed';
-            state.stages[1].status = 'skipped';
-            expect(getProgress(state)).toBe(100);
-        });
-    });
-    describe('getExecutionSummary', () => {
-        it('generates readable summary', () => {
-            const state = createExecutionState({
-                mission: 'SyncInvoices',
-                stages: ['Fetch', 'Process', 'Store'],
-            });
-            state.stages[0].status = 'completed';
-            state.stages[1].status = 'failed';
-            state.status = 'failed';
-            const summary = getExecutionSummary(state);
-            expect(summary).toContain('SyncInvoices');
-            expect(summary).toContain('failed');
-            expect(summary).toContain('1 completed');
-            expect(summary).toContain('1 failed');
-            expect(summary).toContain('1 pending');
-        });
-    });
-});
-describe('MemoryExecutionStore', () => {
-    let store;
-    beforeEach(() => {
-        store = new MemoryExecutionStore();
-    });
-    it('saves and loads execution state', async () => {
-        const state = createExecutionState({
-            mission: 'Test',
-            stages: ['A', 'B'],
-        });
-        await store.save(state);
-        const loaded = await store.load(state.id);
-        expect(loaded).not.toBeNull();
-        expect(loaded.id).toBe(state.id);
-        expect(loaded.mission).toBe('Test');
-    });
-    it('returns null for unknown ID', async () => {
-        const loaded = await store.load('nonexistent');
-        expect(loaded).toBeNull();
-    });
-    it('lists by mission', async () => {
-        const state1 = createExecutionState({ mission: 'A', stages: ['X'] });
-        const state2 = createExecutionState({ mission: 'B', stages: ['X'] });
-        const state3 = createExecutionState({ mission: 'A', stages: ['X'] });
-        await store.save(state1);
-        await store.save(state2);
-        await store.save(state3);
-        const aExecutions = await store.listByMission('A');
-        expect(aExecutions).toHaveLength(2);
-    });
-    it('finds resumable executions', async () => {
-        const completed = createExecutionState({ mission: 'Test', stages: ['A'] });
-        completed.status = 'completed';
-        const failed = createExecutionState({ mission: 'Test', stages: ['A'] });
-        failed.status = 'failed';
-        const paused = createExecutionState({ mission: 'Test', stages: ['A'] });
-        paused.status = 'paused';
-        await store.save(completed);
-        await store.save(failed);
-        await store.save(paused);
-        const resumable = await store.findResumable('Test');
-        expect(resumable).toHaveLength(2);
-    });
-    it('deletes execution state', async () => {
-        const state = createExecutionState({ mission: 'Test', stages: ['A'] });
-        await store.save(state);
-        await store.delete(state.id);
-        const loaded = await store.load(state.id);
-        expect(loaded).toBeNull();
-    });
-});
-describe('FileExecutionStore', () => {
-    let store;
-    beforeEach(() => {
-        if (existsSync(TEST_DIR)) {
-            rmSync(TEST_DIR, { recursive: true, force: true });
-        }
-        store = new FileExecutionStore(TEST_DIR);
-    });
-    afterEach(() => {
-        if (existsSync(TEST_DIR)) {
-            rmSync(TEST_DIR, { recursive: true, force: true });
-        }
-    });
-    it('creates directory if not exists', async () => {
-        // Trigger initialization by calling any async method
-        await store.listRecent();
-        expect(existsSync(TEST_DIR)).toBe(true);
-    });
-    it('persists state to disk', async () => {
-        const state = createExecutionState({
-            mission: 'Persistent',
-            stages: ['A', 'B'],
-        });
-        state.stages[0].status = 'completed';
-        await store.save(state);
-        // Create new store instance
-        const newStore = new FileExecutionStore(TEST_DIR);
-        const loaded = await newStore.load(state.id);
-        expect(loaded).not.toBeNull();
-        expect(loaded.stages[0].status).toBe('completed');
-    });
-    it('preserves Date objects', async () => {
-        const state = createExecutionState({
-            mission: 'Test',
-            stages: ['A'],
-        });
-        state.stages[0].startedAt = new Date();
-        state.stages[0].completedAt = new Date();
-        await store.save(state);
-        const loaded = await store.load(state.id);
-        expect(loaded.startedAt).toBeInstanceOf(Date);
-        expect(loaded.stages[0].startedAt).toBeInstanceOf(Date);
-        expect(loaded.stages[0].completedAt).toBeInstanceOf(Date);
-    });
-    it('finds latest execution for mission', async () => {
-        const older = createExecutionState({ mission: 'Test', stages: ['A'] });
-        older.startedAt = new Date(Date.now() - 10000);
-        const newer = createExecutionState({ mission: 'Test', stages: ['A'] });
-        newer.startedAt = new Date();
-        await store.save(older);
-        await store.save(newer);
-        const latest = await store.findLatest('Test');
-        expect(latest.id).toBe(newer.id);
-    });
-});

package/dist/integration.test.d.ts

@@ -1 +0,0 @@
-export {};