@versori/run 0.0.1-alpha.0

package/esm/dsl/tasks/HttpTask.js

@@ -0,0 +1,57 @@
+var _a;
+import { ensureTask } from '../ensureTask.js';
+import { TaskType } from '../Task.js';
+import { BackgroundTask } from './BackgroundTask.js';
+import { CatchTask } from './CatchTask.js';
+import { ChainTask } from './ChainTask.js';
+import { UnpackTask } from './UnpackTask.js';
+export class HttpTaskImpl {
+    constructor(id, opts, fn) {
+        Object.defineProperty(this, _a, {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'Http'
+        });
+        Object.defineProperty(this, "id", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "fn", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "opts", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.id = id;
+        this.fn = fn;
+        this.opts = opts;
+    }
+    then(task) {
+        return new ChainTask(this.clone(), ensureTask(task));
+    }
+    catch(task) {
+        return new CatchTask(this.clone(), ensureTask(task));
+    }
+    background() {
+        return new BackgroundTask(this.clone());
+    }
+    unpack(mapper) {
+        return new UnpackTask(this.clone(), mapper);
+    }
+    clone() {
+        return new HttpTaskImpl(this.id, this.opts, this.fn);
+    }
+}
+_a = TaskType;
+export function http(taskId, opts, fn) {
+    return new HttpTaskImpl(taskId, opts, fn);
+}

package/esm/dsl/tasks/ParallelTask.d.ts

@@ -0,0 +1,18 @@
+import { ArrayTask, Task, Taskable, TaskType } from '../Task.js';
+/**
+ * ParallelTask is a Task which expects an array of elements as input, and applies a Task to each element in parallel.
+ *
+ * The output of the ParallelTask is an array of the outputs of each element, maintaining the original order.
+ */
+export declare class ParallelTask<In, BaseOutElem, BaseOut extends Array<BaseOutElem>, OutElem> implements Task<In, OutElem[]> {
+    [TaskType]: string;
+    _base: Task<In, BaseOut>;
+    _each: Task<BaseOutElem, OutElem>;
+    constructor(base: Task<In, BaseOut>, task: Task<BaseOutElem, OutElem>);
+    then<NextOut>(task: Taskable<OutElem[], NextOut>): Task<In, NextOut>;
+    catch<NextOut>(task: Taskable<Error, NextOut>): Task<In, NextOut>;
+    background(): Task<In, void>;
+    unpack<NextOut2 = OutElem[]>(mapper?: (data: OutElem[]) => NextOut2[]): ArrayTask<In, NextOut2>;
+    clone(): Task<In, OutElem[]>;
+}
+//# sourceMappingURL=ParallelTask.d.ts.map

package/esm/dsl/tasks/ParallelTask.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ParallelTask.d.ts","sourceRoot":"","sources":["../../../src/dsl/tasks/ParallelTask.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAMjE;;;;GAIG;AACH,qBAAa,YAAY,CAAC,EAAE,EAAE,WAAW,EAAE,OAAO,SAAS,KAAK,CAAC,WAAW,CAAC,EAAE,OAAO,CAClF,YAAW,IAAI,CAAC,EAAE,EAAE,OAAO,EAAE,CAAC;IAE9B,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAc;IAEhC,KAAK,EAAE,IAAI,CAAC,EAAE,EAAE,OAAO,CAAC,CAAC;IACzB,KAAK,EAAE,IAAI,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC;gBAEtB,IAAI,EAAE,IAAI,CAAC,EAAE,EAAE,OAAO,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,WAAW,EAAE,OAAO,CAAC;IAKrE,IAAI,CAAC,OAAO,EAAE,IAAI,EAAE,QAAQ,CAAC,OAAO,EAAE,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC,EAAE,EAAE,OAAO,CAAC;IAIpE,KAAK,CAAC,OAAO,EAAE,IAAI,EAAE,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC,EAAE,EAAE,OAAO,CAAC;IAIjE,UAAU,IAAI,IAAI,CAAC,EAAE,EAAE,IAAI,CAAC;IAI5B,MAAM,CAAC,QAAQ,GAAG,OAAO,EAAE,EACvB,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,QAAQ,EAAE,GACzC,SAAS,CAAC,EAAE,EAAE,QAAQ,CAAC;IAI1B,KAAK,IAAI,IAAI,CAAC,EAAE,EAAE,OAAO,EAAE,CAAC;CAG/B"}

package/esm/dsl/tasks/ParallelTask.js

@@ -0,0 +1,52 @@
+var _a;
+import { ensureTask } from '../ensureTask.js';
+import { TaskType } from '../Task.js';
+import { BackgroundTask } from './BackgroundTask.js';
+import { CatchTask } from './CatchTask.js';
+import { ChainTask } from './ChainTask.js';
+import { UnpackTask } from './UnpackTask.js';
+/**
+ * ParallelTask is a Task which expects an array of elements as input, and applies a Task to each element in parallel.
+ *
+ * The output of the ParallelTask is an array of the outputs of each element, maintaining the original order.
+ */
+export class ParallelTask {
+    constructor(base, task) {
+        Object.defineProperty(this, _a, {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'Parallel'
+        });
+        Object.defineProperty(this, "_base", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_each", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this._base = base;
+        this._each = task;
+    }
+    then(task) {
+        return new ChainTask(this.clone(), ensureTask(task));
+    }
+    catch(task) {
+        return new CatchTask(this.clone(), ensureTask(task));
+    }
+    background() {
+        return new BackgroundTask(this.clone());
+    }
+    unpack(mapper) {
+        return new UnpackTask(this.clone(), mapper);
+    }
+    clone() {
+        return new ParallelTask(this._base.clone(), this._each.clone());
+    }
+}
+_a = TaskType;

package/esm/dsl/tasks/SerialTask.d.ts

@@ -0,0 +1,18 @@
+import { ArrayTask, Task, Taskable, TaskType } from '../Task.js';
+/**
+ * SerialTask is a Task which expects an array of elements as input, and applies a Task to each element.
+ *
+ * The output of the SerialTask is an array of the outputs of the each element.
+ */
+export declare class SerialTask<In, BaseOutElem, BaseOut extends Array<BaseOutElem>, OutElem> implements Task<In, OutElem[]> {
+    [TaskType]: string;
+    _base: Task<In, BaseOut>;
+    _each: Task<BaseOutElem, OutElem>;
+    constructor(base: Task<In, BaseOut>, task: Task<BaseOutElem, OutElem>);
+    then<NextOut>(task: Taskable<OutElem[], NextOut>): Task<In, NextOut>;
+    catch<NextOut>(task: Taskable<Error, NextOut>): Task<In, NextOut>;
+    background(): Task<In, void>;
+    unpack<NextOut2 = OutElem[]>(mapper?: (data: OutElem[]) => NextOut2[]): ArrayTask<In, NextOut2>;
+    clone(): Task<In, OutElem[]>;
+}
+//# sourceMappingURL=SerialTask.d.ts.map

package/esm/dsl/tasks/SerialTask.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SerialTask.d.ts","sourceRoot":"","sources":["../../../src/dsl/tasks/SerialTask.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAMjE;;;;GAIG;AACH,qBAAa,UAAU,CAAC,EAAE,EAAE,WAAW,EAAE,OAAO,SAAS,KAAK,CAAC,WAAW,CAAC,EAAE,OAAO,CAChF,YAAW,IAAI,CAAC,EAAE,EAAE,OAAO,EAAE,CAAC;IAE9B,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAY;IAE9B,KAAK,EAAE,IAAI,CAAC,EAAE,EAAE,OAAO,CAAC,CAAC;IACzB,KAAK,EAAE,IAAI,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC;gBAEtB,IAAI,EAAE,IAAI,CAAC,EAAE,EAAE,OAAO,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,WAAW,EAAE,OAAO,CAAC;IAKrE,IAAI,CAAC,OAAO,EAAE,IAAI,EAAE,QAAQ,CAAC,OAAO,EAAE,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC,EAAE,EAAE,OAAO,CAAC;IAIpE,KAAK,CAAC,OAAO,EAAE,IAAI,EAAE,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC,EAAE,EAAE,OAAO,CAAC;IAIjE,UAAU,IAAI,IAAI,CAAC,EAAE,EAAE,IAAI,CAAC;IAI5B,MAAM,CAAC,QAAQ,GAAG,OAAO,EAAE,EACvB,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,QAAQ,EAAE,GACzC,SAAS,CAAC,EAAE,EAAE,QAAQ,CAAC;IAI1B,KAAK,IAAI,IAAI,CAAC,EAAE,EAAE,OAAO,EAAE,CAAC;CAG/B"}

package/esm/dsl/tasks/SerialTask.js

@@ -0,0 +1,52 @@
+var _a;
+import { ensureTask } from '../ensureTask.js';
+import { TaskType } from '../Task.js';
+import { BackgroundTask } from './BackgroundTask.js';
+import { CatchTask } from './CatchTask.js';
+import { ChainTask } from './ChainTask.js';
+import { UnpackTask } from './UnpackTask.js';
+/**
+ * SerialTask is a Task which expects an array of elements as input, and applies a Task to each element.
+ *
+ * The output of the SerialTask is an array of the outputs of the each element.
+ */
+export class SerialTask {
+    constructor(base, task) {
+        Object.defineProperty(this, _a, {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'Serial'
+        });
+        Object.defineProperty(this, "_base", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_each", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this._base = base;
+        this._each = task;
+    }
+    then(task) {
+        return new ChainTask(this.clone(), ensureTask(task));
+    }
+    catch(task) {
+        return new CatchTask(this.clone(), ensureTask(task));
+    }
+    background() {
+        return new BackgroundTask(this.clone());
+    }
+    unpack(mapper) {
+        return new UnpackTask(this.clone(), mapper);
+    }
+    clone() {
+        return new SerialTask(this._base.clone(), this._each.clone());
+    }
+}
+_a = TaskType;

package/esm/dsl/tasks/UnpackTask.d.ts

@@ -0,0 +1,15 @@
+import { ArrayTask, Task, Taskable, TaskType } from '../Task.js';
+export declare class UnpackTask<In, Out, UnpackedOut = Out> implements ArrayTask<In, UnpackedOut> {
+    [TaskType]: string;
+    _base: Task<In, Out>;
+    _mapper?: (data: Out) => UnpackedOut[];
+    constructor(base: Task<In, Out>, mapper?: (data: Out) => UnpackedOut[]);
+    parallel<NextOut>(task: Taskable<UnpackedOut, NextOut, number>): Task<In, NextOut[]>;
+    serial<NextOut>(task: Taskable<UnpackedOut, NextOut, number>): Task<In, NextOut[]>;
+    then<NextOut>(task: Taskable<UnpackedOut[], NextOut>): Task<In, NextOut>;
+    catch<NextOut>(task: Taskable<Error, NextOut>): Task<In, NextOut>;
+    background(): Task<In, void>;
+    unpack<NextOut>(mapper?: (data: UnpackedOut[]) => NextOut[]): ArrayTask<In, NextOut>;
+    clone(): Task<In, UnpackedOut[]>;
+}
+//# sourceMappingURL=UnpackTask.d.ts.map

package/esm/dsl/tasks/UnpackTask.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UnpackTask.d.ts","sourceRoot":"","sources":["../../../src/dsl/tasks/UnpackTask.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAOjE,qBAAa,UAAU,CAAC,EAAE,EAAE,GAAG,EAAE,WAAW,GAAG,GAAG,CAC9C,YAAW,SAAS,CAAC,EAAE,EAAE,WAAW,CAAC;IAErC,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAY;IAE9B,KAAK,EAAE,IAAI,CAAC,EAAE,EAAE,GAAG,CAAC,CAAC;IAErB,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,WAAW,EAAE,CAAC;gBAE3B,IAAI,EAAE,IAAI,CAAC,EAAE,EAAE,GAAG,CAAC,EAAE,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,WAAW,EAAE;IAKtE,QAAQ,CAAC,OAAO,EAAE,IAAI,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,EAAE,MAAM,CAAC,GAAG,IAAI,CAAC,EAAE,EAAE,OAAO,EAAE,CAAC;IAIpF,MAAM,CAAC,OAAO,EAAE,IAAI,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,EAAE,MAAM,CAAC,GAAG,IAAI,CAAC,EAAE,EAAE,OAAO,EAAE,CAAC;IAIlF,IAAI,CAAC,OAAO,EAAE,IAAI,EAAE,QAAQ,CAAC,WAAW,EAAE,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC,EAAE,EAAE,OAAO,CAAC;IAIxE,KAAK,CAAC,OAAO,EAAE,IAAI,EAAE,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC,EAAE,EAAE,OAAO,CAAC;IAIjE,UAAU,IAAI,IAAI,CAAC,EAAE,EAAE,IAAI,CAAC;IAI5B,MAAM,CAAC,OAAO,EAAE,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,WAAW,EAAE,KAAK,OAAO,EAAE,GAAG,SAAS,CAAC,EAAE,EAAE,OAAO,CAAC;IAIpF,KAAK,IAAI,IAAI,CAAC,EAAE,EAAE,WAAW,EAAE,CAAC;CAGnC"}

package/esm/dsl/tasks/UnpackTask.js

@@ -0,0 +1,54 @@
+var _a;
+import { ensureTask } from '../ensureTask.js';
+import { TaskType } from '../Task.js';
+import { BackgroundTask } from './BackgroundTask.js';
+import { CatchTask } from './CatchTask.js';
+import { ChainTask } from './ChainTask.js';
+import { SerialTask } from './SerialTask.js';
+import { ParallelTask } from './ParallelTask.js';
+export class UnpackTask {
+    constructor(base, mapper) {
+        Object.defineProperty(this, _a, {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'Unpack'
+        });
+        Object.defineProperty(this, "_base", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_mapper", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this._base = base;
+        this._mapper = mapper;
+    }
+    parallel(task) {
+        return new ParallelTask(this.clone(), ensureTask(task));
+    }
+    serial(task) {
+        return new SerialTask(this.clone(), ensureTask(task));
+    }
+    then(task) {
+        return new ChainTask(this.clone(), ensureTask(task));
+    }
+    catch(task) {
+        return new CatchTask(this.clone(), ensureTask(task));
+    }
+    background() {
+        return new BackgroundTask(this.clone());
+    }
+    unpack(mapper) {
+        return new UnpackTask(this.clone(), mapper);
+    }
+    clone() {
+        return new UnpackTask(this._base.clone(), this._mapper);
+    }
+}
+_a = TaskType;

package/esm/dsl/triggers/ScheduleTrigger.d.ts

@@ -0,0 +1,14 @@
+import { Taskable } from '../Task.js';
+import { Trigger, TriggerType } from '../Trigger.js';
+import { Workflow } from '../Workflow.js';
+export type ScheduleData = Record<string, never>;
+export declare class ScheduleTrigger implements Trigger<ScheduleData> {
+    id: string;
+    [TriggerType]: string;
+    schedule: string;
+    constructor(id: string, schedule: string);
+    then<OO>(task: Taskable<ScheduleData, OO>): Workflow<OO>;
+    catch<OO>(error: any): Workflow<OO>;
+}
+export declare function schedule(id: string, schedule: string): Workflow<ScheduleData>;
+//# sourceMappingURL=ScheduleTrigger.d.ts.map

package/esm/dsl/triggers/ScheduleTrigger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ScheduleTrigger.d.ts","sourceRoot":"","sources":["../../../src/dsl/triggers/ScheduleTrigger.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AACrD,OAAO,EAAE,QAAQ,EAAgB,MAAM,gBAAgB,CAAC;AAExD,MAAM,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;AAEjD,qBAAa,eAAgB,YAAW,OAAO,CAAC,YAAY,CAAC;IACzD,EAAE,EAAE,MAAM,CAAC;IAEX,CAAC,WAAW,CAAC,EAAE,MAAM,CAAc;IAEnC,QAAQ,EAAE,MAAM,CAAC;gBAEL,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM;IAKxC,IAAI,CAAC,EAAE,EAAE,IAAI,EAAE,QAAQ,CAAC,YAAY,EAAE,EAAE,CAAC,GAAG,QAAQ,CAAC,EAAE,CAAC;IAIxD,KAAK,CAAC,EAAE,EAAE,KAAK,EAAE,GAAG,GAAG,QAAQ,CAAC,EAAE,CAAC;CAGtC;AAED,wBAAgB,QAAQ,CAAC,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,QAAQ,CAAC,YAAY,CAAC,CAE7E"}

package/esm/dsl/triggers/ScheduleTrigger.js

@@ -0,0 +1,38 @@
+var _a;
+import { ensureTask } from "../ensureTask.js";
+import { TriggerType } from '../Trigger.js';
+import { WorkflowImpl } from '../Workflow.js';
+export class ScheduleTrigger {
+    constructor(id, schedule) {
+        Object.defineProperty(this, "id", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, _a, {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'schedule'
+        });
+        Object.defineProperty(this, "schedule", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.id = id;
+        this.schedule = schedule;
+    }
+    then(task) {
+        return new WorkflowImpl(this, ensureTask(task));
+    }
+    catch(error) {
+        return this;
+    }
+}
+_a = TriggerType;
+export function schedule(id, schedule) {
+    return new ScheduleTrigger(id, schedule);
+}

package/esm/interpreter/memory/ExecutionError.d.ts

@@ -0,0 +1,6 @@
+import { Context } from '../../context/Context.js';
+export declare class ExecutionError extends Error {
+    ctx: Context<any>;
+    constructor(ctx: Context<any>, message: string, opts?: ErrorOptions);
+}
+//# sourceMappingURL=ExecutionError.d.ts.map

package/esm/interpreter/memory/ExecutionError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExecutionError.d.ts","sourceRoot":"","sources":["../../../src/interpreter/memory/ExecutionError.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,0BAA0B,CAAC;AAEnD,qBAAa,cAAe,SAAQ,KAAK;IACrC,GAAG,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC;gBAEN,GAAG,EAAE,OAAO,CAAC,GAAG,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,YAAY;CAMtE"}

package/esm/interpreter/memory/ExecutionError.js

@@ -0,0 +1,13 @@
+export class ExecutionError extends Error {
+    constructor(ctx, message, opts) {
+        super(message, opts);
+        Object.defineProperty(this, "ctx", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.name = 'ExecutionError';
+        this.ctx = ctx;
+    }
+}

package/esm/interpreter/memory/MemoryInterpreter.d.ts

@@ -0,0 +1,18 @@
+import { ContextProvider } from '../../context/ContextProvider.js';
+import { Workflow } from '../../dsl/Workflow.js';
+import { Logger } from '../../observability/logging/Logger.js';
+import { ObservableCompiler } from './ObservableCompiler.js';
+export type MemoryInterpreterOptions = {
+    logger?: Logger;
+    compiler?: ObservableCompiler;
+    contextProvider?: ContextProvider;
+    signal?: AbortSignal;
+};
+export declare class MemoryInterpreter {
+    private log;
+    private compiler;
+    private contextProvider;
+    constructor(options?: MemoryInterpreterOptions);
+    run<O>(workflow: Workflow<O>, options?: MemoryInterpreterOptions): Promise<void>;
+}
+//# sourceMappingURL=MemoryInterpreter.d.ts.map

package/esm/interpreter/memory/MemoryInterpreter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MemoryInterpreter.d.ts","sourceRoot":"","sources":["../../../src/interpreter/memory/MemoryInterpreter.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,eAAe,EAAuB,MAAM,kCAAkC,CAAC;AACxF,OAAO,EAAE,QAAQ,EAAgB,MAAM,uBAAuB,CAAC;AAC/D,OAAO,EAAE,MAAM,EAAE,MAAM,uCAAuC,CAAC;AAC/D,OAAO,EAAmB,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAG9E,MAAM,MAAM,wBAAwB,GAAG;IACnC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,kBAAkB,CAAC;IAC9B,eAAe,CAAC,EAAE,eAAe,CAAC;IAClC,MAAM,CAAC,EAAE,WAAW,CAAC;CACxB,CAAC;AAEF,qBAAa,iBAAiB;IAC1B,OAAO,CAAC,GAAG,CAAS;IACpB,OAAO,CAAC,QAAQ,CAAqB;IACrC,OAAO,CAAC,eAAe,CAAkB;gBAE7B,OAAO,GAAE,wBAA6B;IAMlD,GAAG,CAAC,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,EAAE,wBAAwB,GAAG,OAAO,CAAC,IAAI,CAAC;CAyEnF"}

package/esm/interpreter/memory/MemoryInterpreter.js

@@ -0,0 +1,83 @@
+import * as dntShim from "../../_dnt.shims.js";
+import { catchError, EMPTY, mergeMap, of, tap } from 'rxjs';
+import { ContextProviderImpl } from '../../context/ContextProvider.js';
+import { WorkflowImpl } from '../../dsl/Workflow.js';
+import { ObservableCompiler } from './ObservableCompiler.js';
+import { ConsoleLogger } from '../../observability/logging/ConsoleLogger.js';
+export class MemoryInterpreter {
+    constructor(options = {}) {
+        Object.defineProperty(this, "log", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "compiler", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "contextProvider", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.log = options.logger || new ConsoleLogger('debug');
+        this.compiler = options.compiler || new ObservableCompiler();
+        this.contextProvider = options.contextProvider || new ContextProviderImpl(this.log);
+    }
+    run(workflow, options) {
+        const localAbortController = new AbortController();
+        // Combine the local and passed-in abort signals
+        const combinedSignal = options?.signal
+            ? AbortSignal.any([localAbortController.signal, options.signal])
+            : localAbortController.signal;
+        // TODO: test whether this is required once we can run outside of a Deno test.
+        const sigintListener = () => {
+            this.log.info('Received SIGINT, shutting down workflow');
+            localAbortController.abort();
+        };
+        dntShim.Deno.addSignalListener('SIGINT', sigintListener);
+        if (!(workflow instanceof WorkflowImpl)) {
+            throw new Error('workflow is not an instance of WorkflowImpl');
+        }
+        this.log.info('MemoryInterpreter.start', { workflow });
+        const compilerContext = {
+            compiler: this.compiler,
+            log: this.log,
+            contextProvider: this.contextProvider,
+        };
+        const trigger$ = this.compiler.compileTrigger(compilerContext, workflow.trigger, combinedSignal);
+        const task$ = this.compiler.compileTask(compilerContext, workflow.task);
+        return new Promise((resolve, reject) => {
+            trigger$
+                .pipe(tap((ctx) => {
+                ctx.log.info('MemoryInterpreter.executionStarted', { data: ctx.data });
+            }), mergeMap((ctx) => of(ctx).pipe(task$, catchError((error) => {
+                ctx.log.error('MemoryInterpreter.executionError', { error });
+                return EMPTY;
+            }))))
+                .subscribe({
+                next: (ctx) => {
+                    const durationMs = Date.now() - ctx.startTime.getTime();
+                    ctx.log.info('MemoryInterpreter.executionCompleted', {
+                        durationMs,
+                        data: ctx.data,
+                    });
+                },
+                error: (err) => {
+                    this.log.error('MemoryInterpreter.error', { error: err });
+                    dntShim.Deno.removeSignalListener('SIGINT', sigintListener);
+                    reject(err);
+                },
+                complete: () => {
+                    this.log.info('MemoryInterpreter.workflowCompleted');
+                    dntShim.Deno.removeSignalListener('SIGINT', sigintListener);
+                    resolve();
+                },
+            });
+        });
+    }
+}

package/esm/interpreter/memory/ObservableCompiler.d.ts

@@ -0,0 +1,23 @@
+import { Observable, OperatorFunction } from 'rxjs';
+import { Task } from '../../dsl/Task.js';
+import { Logger } from '../../observability/logging/Logger.js';
+import { ContextOperatorFunction, TaskCompiler, TriggerCompiler } from './compilers/types.js';
+import { Trigger } from '../../dsl/Trigger.js';
+import { ContextProvider } from '../../context/ContextProvider.js';
+import { ContextImpl } from '../../context/Context.js';
+export type CompilerContext = {
+    compiler: ObservableCompiler;
+    log: Logger;
+    contextProvider: ContextProvider;
+};
+export type CompilerFunc<In = any, Out = any, T extends Task<In, Out> = Task<In, Out>> = (ctx: CompilerContext, task: T) => OperatorFunction<In, Out>;
+export declare class ObservableCompiler {
+    private taskCompilers;
+    private triggerCompilers;
+    constructor();
+    compileTask<In = any, Out = any, Index = void>(ctx: CompilerContext, task: Task<In, Out>): ContextOperatorFunction<In, Out, Index>;
+    compileTrigger<Out = any, T extends Trigger<Out> = Trigger<Out>>(ctx: CompilerContext, trigger: T, signal: AbortSignal): Observable<ContextImpl<Out, void>>;
+    registerTask<In, Out, T extends Task<In, Out>>(compiler: TaskCompiler<In, Out, T>): void;
+    registerTrigger<Out, T extends Trigger<Out>>(compiler: TriggerCompiler<Out, T>): void;
+}
+//# sourceMappingURL=ObservableCompiler.d.ts.map

package/esm/interpreter/memory/ObservableCompiler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ObservableCompiler.d.ts","sourceRoot":"","sources":["../../../src/interpreter/memory/ObservableCompiler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,MAAM,CAAC;AACpD,OAAO,EAAE,IAAI,EAAY,MAAM,mBAAmB,CAAC;AACnD,OAAO,EAAE,MAAM,EAAE,MAAM,uCAAuC,CAAC;AAO/D,OAAO,EAAE,uBAAuB,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAE9F,OAAO,EAAE,OAAO,EAAe,MAAM,sBAAsB,CAAC;AAE5D,OAAO,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAC;AACnE,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAGvD,MAAM,MAAM,eAAe,GAAG;IAC1B,QAAQ,EAAE,kBAAkB,CAAC;IAC7B,GAAG,EAAE,MAAM,CAAC;IACZ,eAAe,EAAE,eAAe,CAAC;CACpC,CAAC;AAEF,MAAM,MAAM,YAAY,CAAC,EAAE,GAAG,GAAG,EAAE,GAAG,GAAG,GAAG,EAAE,CAAC,SAAS,IAAI,CAAC,EAAE,EAAE,GAAG,CAAC,GAAG,IAAI,CAAC,EAAE,EAAE,GAAG,CAAC,IAAI,CACrF,GAAG,EAAE,eAAe,EACpB,IAAI,EAAE,CAAC,KACN,gBAAgB,CAAC,EAAE,EAAE,GAAG,CAAC,CAAC;AAE/B,qBAAa,kBAAkB;IAC3B,OAAO,CAAC,aAAa,CAAkD;IACvE,OAAO,CAAC,gBAAgB,CAAgD;;IAexE,WAAW,CAAC,EAAE,GAAG,GAAG,EAAE,GAAG,GAAG,GAAG,EAAE,KAAK,GAAG,IAAI,EACzC,GAAG,EAAE,eAAe,EACpB,IAAI,EAAE,IAAI,CAAC,EAAE,EAAE,GAAG,CAAC,GACpB,uBAAuB,CAAC,EAAE,EAAE,GAAG,EAAE,KAAK,CAAC;IAa1C,cAAc,CAAC,GAAG,GAAG,GAAG,EAAE,CAAC,SAAS,OAAO,CAAC,GAAG,CAAC,GAAG,OAAO,CAAC,GAAG,CAAC,EAC3D,GAAG,EAAE,eAAe,EACpB,OAAO,EAAE,CAAC,EACV,MAAM,EAAE,WAAW,GACpB,UAAU,CAAC,WAAW,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;IAarC,YAAY,CAAC,EAAE,EAAE,GAAG,EAAE,CAAC,SAAS,IAAI,CAAC,EAAE,EAAE,GAAG,CAAC,EAAE,QAAQ,EAAE,YAAY,CAAC,EAAE,EAAE,GAAG,EAAE,CAAC,CAAC;IAKjF,eAAe,CAAC,GAAG,EAAE,CAAC,SAAS,OAAO,CAAC,GAAG,CAAC,EAAE,QAAQ,EAAE,eAAe,CAAC,GAAG,EAAE,CAAC,CAAC;CAIjF"}

package/esm/interpreter/memory/ObservableCompiler.js

@@ -0,0 +1,65 @@
+import { TaskType } from '../../dsl/Task.js';
+import { backgroundCompiler } from './compilers/background.js';
+import { catchCompiler } from './compilers/catch.js';
+import { chainCompiler } from './compilers/chain.js';
+import { fnCompiler } from './compilers/fn.js';
+import { parallelCompiler } from './compilers/parallel.js';
+import { serialCompiler } from './compilers/serial.js';
+import { unpackCompiler } from './compilers/unpack.js';
+import { TriggerType } from '../../dsl/Trigger.js';
+import { scheduleCompiler } from './compilers/schedule.js';
+import { httpCompiler } from './compilers/http.js';
+export class ObservableCompiler {
+    constructor() {
+        Object.defineProperty(this, "taskCompilers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "triggerCompilers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        // Register all available compilers
+        this.registerTask(parallelCompiler);
+        this.registerTask(serialCompiler);
+        this.registerTask(catchCompiler);
+        this.registerTask(chainCompiler);
+        this.registerTask(fnCompiler);
+        this.registerTask(backgroundCompiler);
+        this.registerTask(unpackCompiler);
+        this.registerTask(httpCompiler);
+        this.registerTrigger(scheduleCompiler);
+    }
+    compileTask(ctx, task) {
+        const compiler = this.taskCompilers.get(task[TaskType]);
+        if (!compiler) {
+            throw new Error(`No compiler registered for task type: ${task[TaskType]}`);
+        }
+        if (!(task instanceof compiler.ctor)) {
+            throw new Error(`Task type mismatch: expected ${compiler.ctor.name}, got ${task.constructor.name}`);
+        }
+        return compiler.compile(ctx, task);
+    }
+    compileTrigger(ctx, trigger, signal) {
+        const compiler = this.triggerCompilers.get(trigger[TriggerType]);
+        if (!compiler) {
+            throw new Error(`No compiler registered for trigger type: ${trigger[TriggerType]}`);
+        }
+        if (!(trigger instanceof compiler.ctor)) {
+            throw new Error(`Trigger type mismatch: expected ${compiler.ctor.name}, got ${trigger.constructor.name}`);
+        }
+        return compiler.compile(ctx, trigger, signal);
+    }
+    registerTask(compiler) {
+        const task = new compiler.ctor();
+        this.taskCompilers.set(task[TaskType], compiler);
+    }
+    registerTrigger(compiler) {
+        const trigger = new compiler.ctor();
+        this.triggerCompilers.set(trigger[TriggerType], compiler);
+    }
+}

package/esm/interpreter/memory/compilers/background.d.ts

@@ -0,0 +1,4 @@
+import { BackgroundTask } from '../../../dsl/tasks/BackgroundTask.js';
+import { TaskCompiler } from './types.js';
+export declare const backgroundCompiler: TaskCompiler<any, any, BackgroundTask<any, any>>;
+//# sourceMappingURL=background.d.ts.map

package/esm/interpreter/memory/compilers/background.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"background.d.ts","sourceRoot":"","sources":["../../../../src/interpreter/memory/compilers/background.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,cAAc,EAAE,MAAM,sCAAsC,CAAC;AAEtE,OAAO,EAA2B,YAAY,EAAE,MAAM,YAAY,CAAC;AAqCnE,eAAO,MAAM,kBAAkB,EAAE,YAAY,CAAC,GAAG,EAAE,GAAG,EAAE,cAAc,CAAC,GAAG,EAAE,GAAG,CAAC,CAG/E,CAAC"}

package/esm/interpreter/memory/compilers/background.js

@@ -0,0 +1,20 @@
+import { asyncScheduler, catchError, connect, EMPTY, ignoreElements, map, merge, mergeMap, of, subscribeOn, tap } from 'rxjs';
+import { BackgroundTask } from '../../../dsl/tasks/BackgroundTask.js';
+function compileBackground(ctx, task) {
+    const base = ctx.compiler.compileTask(ctx, task._base);
+    return (src) => src.pipe(connect((shared$) => merge(shared$.pipe(mergeMap((ctx) => base(of(ctx)).pipe(subscribeOn(asyncScheduler), tap({
+        next: (ctx) => ctx.log.debug('Background task emitted a value', { data: ctx.data }),
+        complete: () => ctx.log.debug('Background task completed'),
+    }), catchError((error) => {
+        ctx.log.error('Error in background task', {
+            error,
+            inputData: ctx.data,
+            executionId: ctx.executionId,
+        });
+        return EMPTY;
+    }), ignoreElements()))), shared$.pipe(map((ctx) => ctx.withData(void 0))))));
+}
+export const backgroundCompiler = {
+    ctor: BackgroundTask,
+    compile: compileBackground,
+};

package/esm/interpreter/memory/compilers/catch.d.ts

@@ -0,0 +1,4 @@
+import { CatchTask } from '../../../dsl/tasks/CatchTask.js';
+import { TaskCompiler } from './types.js';
+export declare const catchCompiler: TaskCompiler<any, any, CatchTask<any, any>>;
+//# sourceMappingURL=catch.d.ts.map

package/esm/interpreter/memory/compilers/catch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"catch.d.ts","sourceRoot":"","sources":["../../../../src/interpreter/memory/compilers/catch.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AAG5D,OAAO,EAA2B,YAAY,EAAE,MAAM,YAAY,CAAC;AAwBnE,eAAO,MAAM,aAAa,EAAE,YAAY,CAAC,GAAG,EAAE,GAAG,EAAE,SAAS,CAAC,GAAG,EAAE,GAAG,CAAC,CAGrE,CAAC"}

package/esm/interpreter/memory/compilers/catch.js

@@ -0,0 +1,19 @@
+import { catchError, mergeMap, of } from 'rxjs';
+import { CatchTask } from '../../../dsl/tasks/CatchTask.js';
+import { ExecutionError } from '../ExecutionError.js';
+function compileCatch(ctx, task) {
+    const baseOperator = ctx.compiler.compileTask(ctx, task._base);
+    const errorOperator = ctx.compiler.compileTask(ctx, task._errorHandler);
+    return (src) => src.pipe(mergeMap((ctx) => {
+        return baseOperator(of(ctx)).pipe(catchError((error) => {
+            if (error instanceof Error) {
+                return errorOperator(of(ctx.withData(new ExecutionError(ctx, error.message, { cause: error }))));
+            }
+            return errorOperator(of(ctx.withData(new ExecutionError(ctx, `${error}`, { cause: error }))));
+        }));
+    }));
+}
+export const catchCompiler = {
+    ctor: CatchTask,
+    compile: compileCatch,
+};

package/esm/interpreter/memory/compilers/chain.d.ts

@@ -0,0 +1,3 @@
+import { TaskCompiler } from './types.js';
+export declare const chainCompiler: TaskCompiler<any, any, any>;
+//# sourceMappingURL=chain.d.ts.map

package/esm/interpreter/memory/compilers/chain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chain.d.ts","sourceRoot":"","sources":["../../../../src/interpreter/memory/compilers/chain.ts"],"names":[],"mappings":"AAIA,OAAO,EAA2B,YAAY,EAAE,MAAM,YAAY,CAAC;AAYnE,eAAO,MAAM,aAAa,EAAE,YAAY,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAGrD,CAAC"}