@mondaydotcomorg/atp-compiler 0.17.14

package/__tests__/unit/detector.test.ts

@@ -0,0 +1,346 @@
+import { AsyncIterationDetector } from '../../src/transformer/detector';
+
+describe('AsyncIterationDetector', () => {
+	let detector: AsyncIterationDetector;
+
+	beforeEach(() => {
+		detector = new AsyncIterationDetector();
+	});
+
+	describe('for-of loops with await', () => {
+		it('should detect for-of loop with await inside', () => {
+			const code = `
+        for (const item of items) {
+          await atp.llm.call({ prompt: item });
+        }
+      `;
+
+			const result = detector.detect(code);
+
+			expect(result.needsTransform).toBe(true);
+			expect(result.patterns).toContain('for-of-await');
+		});
+
+		it('should not detect for-of loop without await', () => {
+			const code = `
+        for (const item of items) {
+          console.log(item);
+        }
+      `;
+
+			const result = detector.detect(code);
+
+			expect(result.needsTransform).toBe(false);
+			expect(result.patterns).not.toContain('for-of-await');
+		});
+
+		it('should detect nested for-of with await', () => {
+			const code = `
+        for (const outer of outerItems) {
+          for (const inner of innerItems) {
+            await api.process(outer, inner);
+          }
+        }
+      `;
+
+			const result = detector.detect(code);
+
+			expect(result.needsTransform).toBe(true);
+			expect(result.patterns).toContain('for-of-await');
+		});
+	});
+
+	describe('while loops with await', () => {
+		it('should detect while loop with await inside', () => {
+			const code = `
+        while (condition) {
+          await atp.llm.call({ prompt: 'test' });
+        }
+      `;
+
+			const result = detector.detect(code);
+
+			expect(result.needsTransform).toBe(true);
+			expect(result.patterns).toContain('while-await');
+		});
+
+		it('should not detect while loop without await', () => {
+			const code = `
+        while (condition) {
+          console.log('test');
+        }
+      `;
+
+			const result = detector.detect(code);
+
+			expect(result.needsTransform).toBe(false);
+			expect(result.patterns).not.toContain('while-await');
+		});
+	});
+
+	describe('array.map with async callback', () => {
+		it('should detect map with async callback', () => {
+			const code = `
+        const results = items.map(async (item) => {
+          return await atp.llm.call({ prompt: item });
+        });
+      `;
+
+			const result = detector.detect(code);
+
+			expect(result.needsTransform).toBe(true);
+			expect(result.patterns).toContain('map-async');
+		});
+
+		it('should not detect map with sync callback', () => {
+			const code = `
+        const results = items.map((item) => {
+          return item * 2;
+        });
+      `;
+
+			const result = detector.detect(code);
+
+			expect(result.needsTransform).toBe(false);
+			expect(result.patterns).not.toContain('map-async');
+		});
+	});
+
+	describe('array.forEach with async callback', () => {
+		it('should detect forEach with async callback', () => {
+			const code = `
+        items.forEach(async (item) => {
+          await atp.llm.call({ prompt: item });
+        });
+      `;
+
+			const result = detector.detect(code);
+
+			expect(result.needsTransform).toBe(true);
+			expect(result.patterns).toContain('forEach-async');
+		});
+	});
+
+	describe('array.filter with async callback', () => {
+		it('should detect filter with async callback', () => {
+			const code = `
+        const filtered = items.filter(async (item) => {
+          const result = await atp.llm.call({ prompt: item });
+          return result === 'yes';
+        });
+      `;
+
+			const result = detector.detect(code);
+
+			expect(result.needsTransform).toBe(true);
+			expect(result.patterns).toContain('filter-async');
+		});
+	});
+
+	describe('array.reduce with async callback', () => {
+		it('should detect reduce with async callback', () => {
+			const code = `
+        const sum = items.reduce(async (acc, item) => {
+          const result = await atp.llm.call({ prompt: item });
+          return acc + result;
+        }, 0);
+      `;
+
+			const result = detector.detect(code);
+
+			expect(result.needsTransform).toBe(true);
+			expect(result.patterns).toContain('reduce-async');
+		});
+	});
+
+	describe('array.find with async callback', () => {
+		it('should detect find with async callback', () => {
+			const code = `
+        const found = items.find(async (item) => {
+          const result = await atp.llm.call({ prompt: item });
+          return result === 'match';
+        });
+      `;
+
+			const result = detector.detect(code);
+
+			expect(result.needsTransform).toBe(true);
+			expect(result.patterns).toContain('find-async');
+		});
+	});
+
+	describe('array.some with async callback', () => {
+		it('should detect some with async callback', () => {
+			const code = `
+        const hasMatch = items.some(async (item) => {
+          const result = await atp.llm.call({ prompt: item });
+          return result === 'yes';
+        });
+      `;
+
+			const result = detector.detect(code);
+
+			expect(result.needsTransform).toBe(true);
+			expect(result.patterns).toContain('some-async');
+		});
+	});
+
+	describe('array.every with async callback', () => {
+		it('should detect every with async callback', () => {
+			const code = `
+        const allMatch = items.every(async (item) => {
+          const result = await atp.llm.call({ prompt: item });
+          return result === 'yes';
+        });
+      `;
+
+			const result = detector.detect(code);
+
+			expect(result.needsTransform).toBe(true);
+			expect(result.patterns).toContain('every-async');
+		});
+	});
+
+	describe('array.flatMap with async callback', () => {
+		it('should detect flatMap with async callback', () => {
+			const code = `
+        const flattened = items.flatMap(async (item) => {
+          const results = await atp.llm.call({ prompt: item });
+          return results.split(',');
+        });
+      `;
+
+			const result = detector.detect(code);
+
+			expect(result.needsTransform).toBe(true);
+			expect(result.patterns).toContain('flatMap-async');
+		});
+	});
+
+	describe('Promise.all', () => {
+		it('should detect Promise.all', () => {
+			const code = `
+        const results = await Promise.all([
+          fetch('url1'),
+          fetch('url2'),
+        ]);
+      `;
+
+			const result = detector.detect(code);
+
+			expect(result.needsTransform).toBe(true);
+			expect(result.patterns).toContain('promise-all');
+		});
+
+		it('should detect batchable Promise.all with direct pausable calls', () => {
+			const code = `
+        const results = await Promise.all([
+          atp.llm.call({ prompt: 'Q1' }),
+          atp.llm.call({ prompt: 'Q2' }),
+          atp.llm.call({ prompt: 'Q3' }),
+        ]);
+      `;
+
+			const result = detector.detect(code);
+
+			expect(result.needsTransform).toBe(true);
+			expect(result.patterns).toContain('promise-all');
+			expect(result.batchableParallel).toBe(true);
+		});
+
+		it('should not mark Promise.all as batchable with complex logic', () => {
+			const code = `
+        const results = await Promise.all(
+          items.map(async (item) => {
+            const step1 = await atp.llm.call({ prompt: item });
+            return await process(step1);
+          })
+        );
+      `;
+
+			const result = detector.detect(code);
+
+			expect(result.needsTransform).toBe(true);
+			expect(result.patterns).toContain('promise-all');
+			expect(result.batchableParallel).toBe(false);
+		});
+	});
+
+	describe('Promise.allSettled', () => {
+		it('should detect Promise.allSettled', () => {
+			const code = `
+        const results = await Promise.allSettled([
+          fetch('url1'),
+          fetch('url2'),
+        ]);
+      `;
+
+			const result = detector.detect(code);
+
+			expect(result.needsTransform).toBe(true);
+			expect(result.patterns).toContain('promise-allSettled');
+		});
+	});
+
+	describe('multiple patterns', () => {
+		it('should detect multiple patterns in same code', () => {
+			const code = `
+        for (const item of items) {
+          await atp.llm.call({ prompt: item });
+        }
+        
+        const results = items.map(async (item) => {
+          return await atp.llm.call({ prompt: item });
+        });
+        
+        const parallel = await Promise.all([
+          atp.llm.call({ prompt: 'Q1' }),
+          atp.llm.call({ prompt: 'Q2' }),
+        ]);
+      `;
+
+			const result = detector.detect(code);
+
+			expect(result.needsTransform).toBe(true);
+			expect(result.patterns).toContain('for-of-await');
+			expect(result.patterns).toContain('map-async');
+			expect(result.patterns).toContain('promise-all');
+			expect(result.batchableParallel).toBe(true);
+		});
+	});
+
+	describe('edge cases', () => {
+		it('should handle empty loops', () => {
+			const code = `
+        for (const item of items) {
+        }
+      `;
+
+			const result = detector.detect(code);
+
+			expect(result.needsTransform).toBe(false);
+		});
+
+		it('should handle malformed code gracefully', () => {
+			const code = `this is not valid javascript`;
+
+			const result = detector.detect(code);
+
+			expect(result.needsTransform).toBe(false);
+			expect(result.patterns).toEqual([]);
+		});
+
+		it('should handle code with no async patterns', () => {
+			const code = `
+        const x = 1;
+        const y = 2;
+        console.log(x + y);
+      `;
+
+			const result = detector.detect(code);
+
+			expect(result.needsTransform).toBe(false);
+			expect(result.patterns).toEqual([]);
+		});
+	});
+});

package/dist/atp-compiler/src/index.d.ts

@@ -0,0 +1,6 @@
+export * from './types.js';
+export * from './transformer/index.js';
+export * from './runtime/index.js';
+export { ATPCompiler } from './transformer/index.js';
+export { initializeRuntime, cleanupRuntime } from './runtime/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/atp-compiler/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,wBAAwB,CAAC;AACvC,cAAc,oBAAoB,CAAC;AAEnC,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/atp-compiler/src/index.js

@@ -0,0 +1,6 @@
+export * from './types.js';
+export * from './transformer/index.js';
+export * from './runtime/index.js';
+export { ATPCompiler } from './transformer/index.js';
+export { initializeRuntime, cleanupRuntime } from './runtime/index.js';
+//# sourceMappingURL=index.js.map

package/dist/atp-compiler/src/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,wBAAwB,CAAC;AACvC,cAAc,oBAAoB,CAAC;AAEnC,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/atp-compiler/src/runtime/batch-parallel.d.ts

@@ -0,0 +1,3 @@
+import type { BatchCallInfo } from '../types.js';
+export declare function batchParallel<T>(batchCalls: BatchCallInfo[], parallelId: string): Promise<T[]>;
+//# sourceMappingURL=batch-parallel.d.ts.map

package/dist/atp-compiler/src/runtime/batch-parallel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"batch-parallel.d.ts","sourceRoot":"","sources":["../../../../src/runtime/batch-parallel.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAOjD,wBAAsB,aAAa,CAAC,CAAC,EACpC,UAAU,EAAE,aAAa,EAAE,EAC3B,UAAU,EAAE,MAAM,GAChB,OAAO,CAAC,CAAC,EAAE,CAAC,CAUd"}

package/dist/atp-compiler/src/runtime/batch-parallel.js

@@ -0,0 +1,13 @@
+import { BatchPauseExecutionError } from './errors.js';
+import { nextSequenceNumber, getCachedResult, getCallSequenceNumber, } from '@mondaydotcomorg/atp-runtime';
+export async function batchParallel(batchCalls, parallelId) {
+    const currentSequence = getCallSequenceNumber();
+    const cachedResult = getCachedResult(currentSequence);
+    if (cachedResult !== undefined) {
+        nextSequenceNumber();
+        return cachedResult;
+    }
+    const sequenceForPause = nextSequenceNumber();
+    throw new BatchPauseExecutionError(batchCalls, parallelId, sequenceForPause);
+}
+//# sourceMappingURL=batch-parallel.js.map

package/dist/atp-compiler/src/runtime/batch-parallel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"batch-parallel.js","sourceRoot":"","sources":["../../../../src/runtime/batch-parallel.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,MAAM,aAAa,CAAC;AAEvD,OAAO,EACN,kBAAkB,EAClB,eAAe,EACf,qBAAqB,GACrB,MAAM,8BAA8B,CAAC;AAEtC,MAAM,CAAC,KAAK,UAAU,aAAa,CAClC,UAA2B,EAC3B,UAAkB;IAElB,MAAM,eAAe,GAAG,qBAAqB,EAAE,CAAC;IAChD,MAAM,YAAY,GAAG,eAAe,CAAC,eAAe,CAAC,CAAC;IACtD,IAAI,YAAY,KAAK,SAAS,EAAE,CAAC;QAChC,kBAAkB,EAAE,CAAC;QACrB,OAAO,YAAmB,CAAC;IAC5B,CAAC;IAED,MAAM,gBAAgB,GAAG,kBAAkB,EAAE,CAAC;IAC9C,MAAM,IAAI,wBAAwB,CAAC,UAAU,EAAE,UAAU,EAAE,gBAAgB,CAAC,CAAC;AAC9E,CAAC"}

package/dist/atp-compiler/src/runtime/checkpoint-manager.d.ts

@@ -0,0 +1,19 @@
+import type { CacheProvider } from '@mondaydotcomorg/atp-protocol';
+import type { LoopCheckpoint } from '../types.js';
+export declare class CheckpointManager {
+    private cache;
+    private executionId;
+    private prefix;
+    constructor(executionId: string, cache: CacheProvider, prefix?: string);
+    save(checkpoint: LoopCheckpoint): Promise<void>;
+    load(loopId: string): Promise<LoopCheckpoint | null>;
+    clear(loopId: string): Promise<void>;
+    clearAll(): Promise<void>;
+    private getKey;
+    getExecutionId(): string;
+}
+export declare function setCheckpointManager(manager: CheckpointManager): void;
+export declare function getCheckpointManager(): CheckpointManager;
+export declare function clearCheckpointManager(): void;
+export declare function hasCheckpointManager(): boolean;
+//# sourceMappingURL=checkpoint-manager.d.ts.map

package/dist/atp-compiler/src/runtime/checkpoint-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkpoint-manager.d.ts","sourceRoot":"","sources":["../../../../src/runtime/checkpoint-manager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AACnE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAMlD,qBAAa,iBAAiB;IAC7B,OAAO,CAAC,KAAK,CAAgB;IAC7B,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,MAAM,CAAS;gBAEX,WAAW,EAAE,MAAM,EAAE,KAAK,EAAE,aAAa,EAAE,MAAM,SAAe;IAMtE,IAAI,CAAC,UAAU,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;IAwB/C,IAAI,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC;IAqBpD,KAAK,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAWpC,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAE/B,OAAO,CAAC,MAAM;IAId,cAAc,IAAI,MAAM;CAGxB;AAID,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,iBAAiB,GAAG,IAAI,CAErE;AAED,wBAAgB,oBAAoB,IAAI,iBAAiB,CAKxD;AAED,wBAAgB,sBAAsB,IAAI,IAAI,CAE7C;AAED,wBAAgB,oBAAoB,IAAI,OAAO,CAE9C"}

package/dist/atp-compiler/src/runtime/checkpoint-manager.js

@@ -0,0 +1,81 @@
+import { CheckpointError, CheckpointOperation } from './errors.js';
+const MAX_CHECKPOINT_SIZE = 10 * 1024 * 1024;
+const CHECKPOINT_TTL = 3600;
+export class CheckpointManager {
+    cache;
+    executionId;
+    prefix;
+    constructor(executionId, cache, prefix = 'checkpoint') {
+        this.executionId = executionId;
+        this.cache = cache;
+        this.prefix = prefix;
+    }
+    async save(checkpoint) {
+        const key = this.getKey(checkpoint.loopId);
+        try {
+            const serialized = JSON.stringify(checkpoint);
+            if (serialized.length > MAX_CHECKPOINT_SIZE) {
+                throw new CheckpointError(`Checkpoint size ${serialized.length} exceeds maximum ${MAX_CHECKPOINT_SIZE}`, checkpoint.loopId, CheckpointOperation.SAVE);
+            }
+            await this.cache.set(key, checkpoint, CHECKPOINT_TTL);
+        }
+        catch (error) {
+            if (error instanceof CheckpointError) {
+                throw error;
+            }
+            const message = error instanceof Error ? error.message : String(error);
+            throw new CheckpointError(message, checkpoint.loopId, CheckpointOperation.SAVE);
+        }
+    }
+    async load(loopId) {
+        const key = this.getKey(loopId);
+        try {
+            const checkpoint = await this.cache.get(key);
+            if (!checkpoint) {
+                return null;
+            }
+            if (checkpoint.completed && checkpoint.completed instanceof Array) {
+                checkpoint.completed = new Set(checkpoint.completed);
+            }
+            return checkpoint;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new CheckpointError(message, loopId, CheckpointOperation.LOAD);
+        }
+    }
+    async clear(loopId) {
+        const key = this.getKey(loopId);
+        try {
+            await this.cache.delete(key);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new CheckpointError(message, loopId, CheckpointOperation.CLEAR);
+        }
+    }
+    async clearAll() { }
+    getKey(loopId) {
+        return `${this.prefix}:${this.executionId}:${loopId}`;
+    }
+    getExecutionId() {
+        return this.executionId;
+    }
+}
+let globalCheckpointManager = null;
+export function setCheckpointManager(manager) {
+    globalCheckpointManager = manager;
+}
+export function getCheckpointManager() {
+    if (!globalCheckpointManager) {
+        throw new Error('CheckpointManager not initialized');
+    }
+    return globalCheckpointManager;
+}
+export function clearCheckpointManager() {
+    globalCheckpointManager = null;
+}
+export function hasCheckpointManager() {
+    return globalCheckpointManager !== null;
+}
+//# sourceMappingURL=checkpoint-manager.js.map

package/dist/atp-compiler/src/runtime/checkpoint-manager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkpoint-manager.js","sourceRoot":"","sources":["../../../../src/runtime/checkpoint-manager.ts"],"names":[],"mappings":"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"}

package/dist/atp-compiler/src/runtime/context.d.ts

@@ -0,0 +1,8 @@
+import type { RuntimeContext } from '../types.js';
+export declare function setRuntimeContext(context: RuntimeContext): void;
+export declare function getRuntimeContext(): RuntimeContext;
+export declare function clearRuntimeContext(): void;
+export declare function hasRuntimeContext(): boolean;
+export declare function generateUniqueId(prefix: string): string;
+export declare function resetIdCounter(): void;
+//# sourceMappingURL=context.d.ts.map

package/dist/atp-compiler/src/runtime/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../../../src/runtime/context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAIlD,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,cAAc,GAAG,IAAI,CAE/D;AAED,wBAAgB,iBAAiB,IAAI,cAAc,CAMlD;AAED,wBAAgB,mBAAmB,IAAI,IAAI,CAE1C;AAED,wBAAgB,iBAAiB,IAAI,OAAO,CAE3C;AAID,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAEvD;AAED,wBAAgB,cAAc,IAAI,IAAI,CAErC"}

package/dist/atp-compiler/src/runtime/context.js

@@ -0,0 +1,25 @@
+const contextStack = [];
+export function setRuntimeContext(context) {
+    contextStack.push(context);
+}
+export function getRuntimeContext() {
+    const context = contextStack[contextStack.length - 1];
+    if (!context) {
+        throw new Error('No runtime context available. Compiler runtime not properly initialized.');
+    }
+    return context;
+}
+export function clearRuntimeContext() {
+    contextStack.pop();
+}
+export function hasRuntimeContext() {
+    return contextStack.length > 0;
+}
+let idCounter = 0;
+export function generateUniqueId(prefix) {
+    return `${prefix}_${Date.now()}_${idCounter++}`;
+}
+export function resetIdCounter() {
+    idCounter = 0;
+}
+//# sourceMappingURL=context.js.map

package/dist/atp-compiler/src/runtime/context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.js","sourceRoot":"","sources":["../../../../src/runtime/context.ts"],"names":[],"mappings":"AAEA,MAAM,YAAY,GAAqB,EAAE,CAAC;AAE1C,MAAM,UAAU,iBAAiB,CAAC,OAAuB;IACxD,YAAY,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;AAC5B,CAAC;AAED,MAAM,UAAU,iBAAiB;IAChC,MAAM,OAAO,GAAG,YAAY,CAAC,YAAY,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IACtD,IAAI,CAAC,OAAO,EAAE,CAAC;QACd,MAAM,IAAI,KAAK,CAAC,0EAA0E,CAAC,CAAC;IAC7F,CAAC;IACD,OAAO,OAAO,CAAC;AAChB,CAAC;AAED,MAAM,UAAU,mBAAmB;IAClC,YAAY,CAAC,GAAG,EAAE,CAAC;AACpB,CAAC;AAED,MAAM,UAAU,iBAAiB;IAChC,OAAO,YAAY,CAAC,MAAM,GAAG,CAAC,CAAC;AAChC,CAAC;AAED,IAAI,SAAS,GAAG,CAAC,CAAC;AAElB,MAAM,UAAU,gBAAgB,CAAC,MAAc;IAC9C,OAAO,GAAG,MAAM,IAAI,IAAI,CAAC,GAAG,EAAE,IAAI,SAAS,EAAE,EAAE,CAAC;AACjD,CAAC;AAED,MAAM,UAAU,cAAc;IAC7B,SAAS,GAAG,CAAC,CAAC;AACf,CAAC"}

package/dist/atp-compiler/src/runtime/errors.d.ts

@@ -0,0 +1,38 @@
+import type { BatchCallInfo } from '../types.js';
+export declare enum CheckpointOperation {
+    SAVE = "save",
+    LOAD = "load",
+    CLEAR = "clear"
+}
+export declare class BatchPauseExecutionError extends Error {
+    readonly calls: BatchCallInfo[];
+    readonly batchId: string;
+    readonly sequenceNumber: number;
+    constructor(calls: BatchCallInfo[], batchId: string, sequenceNumber: number);
+}
+export declare class CheckpointError extends Error {
+    readonly checkpointId: string;
+    readonly operation: CheckpointOperation;
+    constructor(message: string, checkpointId: string, operation: CheckpointOperation);
+}
+export declare class TransformationError extends Error {
+    readonly code: string;
+    readonly pattern: string;
+    readonly location?: {
+        line: number;
+        column: number;
+    };
+    constructor(message: string, code: string, pattern: string, location?: {
+        line: number;
+        column: number;
+    });
+}
+export declare class InfiniteLoopDetectionError extends Error {
+    readonly loopId: string;
+    readonly iterationCount: number;
+    constructor(loopId: string, iterationCount: number);
+}
+export declare function isBatchPauseError(error: unknown): error is BatchPauseExecutionError;
+export declare function isCheckpointError(error: unknown): error is CheckpointError;
+export declare function isTransformationError(error: unknown): error is TransformationError;
+//# sourceMappingURL=errors.d.ts.map

package/dist/atp-compiler/src/runtime/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../../src/runtime/errors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAEjD,oBAAY,mBAAmB;IAC9B,IAAI,SAAS;IACb,IAAI,SAAS;IACb,KAAK,UAAU;CACf;AAED,qBAAa,wBAAyB,SAAQ,KAAK;IAClD,SAAgB,KAAK,EAAE,aAAa,EAAE,CAAC;IACvC,SAAgB,OAAO,EAAE,MAAM,CAAC;IAChC,SAAgB,cAAc,EAAE,MAAM,CAAC;gBAE3B,KAAK,EAAE,aAAa,EAAE,EAAE,OAAO,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM;CAO3E;AAED,qBAAa,eAAgB,SAAQ,KAAK;IACzC,SAAgB,YAAY,EAAE,MAAM,CAAC;IACrC,SAAgB,SAAS,EAAE,mBAAmB,CAAC;gBAEnC,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,SAAS,EAAE,mBAAmB;CAMjF;AAED,qBAAa,mBAAoB,SAAQ,KAAK;IAC7C,SAAgB,IAAI,EAAE,MAAM,CAAC;IAC7B,SAAgB,OAAO,EAAE,MAAM,CAAC;IAChC,SAAgB,QAAQ,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;gBAG3D,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,QAAQ,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE;CAS5C;AAED,qBAAa,0BAA2B,SAAQ,KAAK;IACpD,SAAgB,MAAM,EAAE,MAAM,CAAC;IAC/B,SAAgB,cAAc,EAAE,MAAM,CAAC;gBAE3B,MAAM,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM;CAQlD;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,wBAAwB,CAEnF;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,eAAe,CAE1E;AAED,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,mBAAmB,CAElF"}

package/dist/atp-compiler/src/runtime/errors.js

@@ -0,0 +1,61 @@
+export var CheckpointOperation;
+(function (CheckpointOperation) {
+    CheckpointOperation["SAVE"] = "save";
+    CheckpointOperation["LOAD"] = "load";
+    CheckpointOperation["CLEAR"] = "clear";
+})(CheckpointOperation || (CheckpointOperation = {}));
+export class BatchPauseExecutionError extends Error {
+    calls;
+    batchId;
+    sequenceNumber;
+    constructor(calls, batchId, sequenceNumber) {
+        super(`Batch pause for parallel execution (${calls.length} callbacks)`);
+        this.name = 'BatchPauseExecutionError';
+        this.calls = calls;
+        this.batchId = batchId;
+        this.sequenceNumber = sequenceNumber;
+    }
+}
+export class CheckpointError extends Error {
+    checkpointId;
+    operation;
+    constructor(message, checkpointId, operation) {
+        super(`Checkpoint ${operation} failed for ${checkpointId}: ${message}`);
+        this.name = 'CheckpointError';
+        this.checkpointId = checkpointId;
+        this.operation = operation;
+    }
+}
+export class TransformationError extends Error {
+    code;
+    pattern;
+    location;
+    constructor(message, code, pattern, location) {
+        const loc = location ? ` at line ${location.line}:${location.column}` : '';
+        super(`Transformation failed for ${pattern}${loc}: ${message}`);
+        this.name = 'TransformationError';
+        this.code = code;
+        this.pattern = pattern;
+        this.location = location;
+    }
+}
+export class InfiniteLoopDetectionError extends Error {
+    loopId;
+    iterationCount;
+    constructor(loopId, iterationCount) {
+        super(`Infinite loop detected: ${loopId} exceeded ${iterationCount} iterations without completing`);
+        this.name = 'InfiniteLoopDetectionError';
+        this.loopId = loopId;
+        this.iterationCount = iterationCount;
+    }
+}
+export function isBatchPauseError(error) {
+    return error instanceof BatchPauseExecutionError;
+}
+export function isCheckpointError(error) {
+    return error instanceof CheckpointError;
+}
+export function isTransformationError(error) {
+    return error instanceof TransformationError;
+}
+//# sourceMappingURL=errors.js.map

package/dist/atp-compiler/src/runtime/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../../../../src/runtime/errors.ts"],"names":[],"mappings":"AAEA,MAAM,CAAN,IAAY,mBAIX;AAJD,WAAY,mBAAmB;IAC9B,oCAAa,CAAA;IACb,oCAAa,CAAA;IACb,sCAAe,CAAA;AAChB,CAAC,EAJW,mBAAmB,KAAnB,mBAAmB,QAI9B;AAED,MAAM,OAAO,wBAAyB,SAAQ,KAAK;IAClC,KAAK,CAAkB;IACvB,OAAO,CAAS;IAChB,cAAc,CAAS;IAEvC,YAAY,KAAsB,EAAE,OAAe,EAAE,cAAsB;QAC1E,KAAK,CAAC,uCAAuC,KAAK,CAAC,MAAM,aAAa,CAAC,CAAC;QACxE,IAAI,CAAC,IAAI,GAAG,0BAA0B,CAAC;QACvC,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QACvB,IAAI,CAAC,cAAc,GAAG,cAAc,CAAC;IACtC,CAAC;CACD;AAED,MAAM,OAAO,eAAgB,SAAQ,KAAK;IACzB,YAAY,CAAS;IACrB,SAAS,CAAsB;IAE/C,YAAY,OAAe,EAAE,YAAoB,EAAE,SAA8B;QAChF,KAAK,CAAC,cAAc,SAAS,eAAe,YAAY,KAAK,OAAO,EAAE,CAAC,CAAC;QACxE,IAAI,CAAC,IAAI,GAAG,iBAAiB,CAAC;QAC9B,IAAI,CAAC,YAAY,GAAG,YAAY,CAAC;QACjC,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;IAC5B,CAAC;CACD;AAED,MAAM,OAAO,mBAAoB,SAAQ,KAAK;IAC7B,IAAI,CAAS;IACb,OAAO,CAAS;IAChB,QAAQ,CAAoC;IAE5D,YACC,OAAe,EACf,IAAY,EACZ,OAAe,EACf,QAA2C;QAE3C,MAAM,GAAG,GAAG,QAAQ,CAAC,CAAC,CAAC,YAAY,QAAQ,CAAC,IAAI,IAAI,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QAC3E,KAAK,CAAC,6BAA6B,OAAO,GAAG,GAAG,KAAK,OAAO,EAAE,CAAC,CAAC;QAChE,IAAI,CAAC,IAAI,GAAG,qBAAqB,CAAC;QAClC,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QACvB,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;IAC1B,CAAC;CACD;AAED,MAAM,OAAO,0BAA2B,SAAQ,KAAK;IACpC,MAAM,CAAS;IACf,cAAc,CAAS;IAEvC,YAAY,MAAc,EAAE,cAAsB;QACjD,KAAK,CACJ,2BAA2B,MAAM,aAAa,cAAc,gCAAgC,CAC5F,CAAC;QACF,IAAI,CAAC,IAAI,GAAG,4BAA4B,CAAC;QACzC,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,cAAc,GAAG,cAAc,CAAC;IACtC,CAAC;CACD;AAED,MAAM,UAAU,iBAAiB,CAAC,KAAc;IAC/C,OAAO,KAAK,YAAY,wBAAwB,CAAC;AAClD,CAAC;AAED,MAAM,UAAU,iBAAiB,CAAC,KAAc;IAC/C,OAAO,KAAK,YAAY,eAAe,CAAC;AACzC,CAAC;AAED,MAAM,UAAU,qBAAqB,CAAC,KAAc;IACnD,OAAO,KAAK,YAAY,mBAAmB,CAAC;AAC7C,CAAC"}