@versori/run 0.7.0-alpha.3 → 0.7.0-alpha.6

package/script/src/interpreter/vanilla/VanillaInterpreter.js

@@ -0,0 +1,435 @@
+"use strict";
+/*
+ * Copyright (c) 2025 Versori Group Inc
+ *
+ * Use of this software is governed by the Business Source License 1.1
+ * included in the LICENSE file at the root of this repository.
+ *
+ * Change Date: 2029-01-01
+ * Change License: Apache License, Version 2.0
+ *
+ * As of the Change Date, in accordance with the Business Source License,
+ * use of this software will be governed by the Apache License, Version 2.0.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VanillaInterpreter = void 0;
+const api_1 = __importDefault(require("@opentelemetry/api"));
+const exporter_trace_otlp_proto_1 = require("@opentelemetry/exporter-trace-otlp-proto");
+const resources_1 = require("@opentelemetry/resources");
+const sdk_node_1 = require("@opentelemetry/sdk-node");
+const express_1 = __importDefault(require("express"));
+const rxjs_1 = require("rxjs");
+const configloader_js_1 = require("../../dsl/http/versori/configloader.js");
+const constants_js_1 = require("../../dsl/http/versori/constants.js");
+const cronapi_js_1 = require("../../dsl/http/versori/cronapi.js");
+const Workflow_js_1 = require("../../dsl/Workflow.js");
+const Issues_js_1 = require("../../issues/Issues.js");
+const MemoryKeyValueProvider_js_1 = require("../../kv/memory/MemoryKeyValueProvider.js");
+const SDKKeyValueProvider_js_1 = require("../../kv/sdk/SDKKeyValueProvider.js");
+const ConsoleLogger_js_1 = require("../../observability/logging/ConsoleLogger.js");
+const ObservableCompiler_js_1 = require("./ObservableCompiler.js");
+const Queue_js_1 = require("./Queue.js");
+const VanillaConnectionFactory_js_1 = require("../../connection/VanillaConnectionFactory.js");
+const VanillaContext_js_1 = require("../../context/VanillaContext.js");
+function getKVProvider(runLocal) {
+    if (runLocal) {
+        return Promise.resolve(new MemoryKeyValueProvider_js_1.MemoryKeyValueProvider());
+    }
+    return SDKKeyValueProvider_js_1.SDKKeyValueProvider.fromEnv();
+}
+/**
+ * VanillaInterpreter is an interpreter for executing Versori workflows with support for durable, queue-based workflow
+ * execution. It supports all trigger types including the {@link workflow} trigger which allows workflows to be started
+ * programmatically.
+ *
+ * Unlike {@link DurableInterpreter}, this interpreter is incapable of using connections. Therefore, all fetch requests will need
+ * to use fully qualified URLs and authentication must be handled manually within the workflow.
+ *
+ * @example
+ * ```typescript
+ * import { VanillaInterpreter, workflow, fn } from '@versori/run';
+ *
+ * const processJob = workflow('process-job', { maxAttempts: 3 })
+ *   .then(fn('task', async (ctx) => {
+ *     ctx.log.info('Processing job', { data: ctx.data });
+ *     // ... long-running process
+ *   }));
+ *
+ * const interpreter = new VanillaInterpreter();
+ * interpreter.register(processJob);
+ * await interpreter.start();
+ * ```
+ */
+class VanillaInterpreter {
+    constructor(log, compiler, contextProvider, webhookRouter, cronRouter, cronRegistry, cnxFetchFactory, cronProvider, tracer, cfgReader, queueProvider, otelSDK) {
+        Object.defineProperty(this, "log", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: log
+        });
+        Object.defineProperty(this, "compiler", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: compiler
+        });
+        Object.defineProperty(this, "contextProvider", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: contextProvider
+        });
+        Object.defineProperty(this, "webhookRouter", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: webhookRouter
+        });
+        Object.defineProperty(this, "cronRouter", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: cronRouter
+        });
+        Object.defineProperty(this, "cronRegistry", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: cronRegistry
+        });
+        Object.defineProperty(this, "cnxFetchFactory", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: cnxFetchFactory
+        });
+        Object.defineProperty(this, "cronProvider", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: cronProvider
+        });
+        Object.defineProperty(this, "tracer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: tracer
+        });
+        Object.defineProperty(this, "cfgReader", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: cfgReader
+        });
+        Object.defineProperty(this, "queueProvider", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: queueProvider
+        });
+        Object.defineProperty(this, "otelSDK", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: otelSDK
+        });
+        Object.defineProperty(this, "registeredWorkflows", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "webhookServer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "cronServer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "shutdownServer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "isShuttingDown", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        if (typeof this.log === 'undefined') {
+            throw new Error('VanillaInterpreter should not be instantiated directly. Use VanillaInterpreter.newInstance() instead.');
+        }
+    }
+    static async newInstance(options = {}) {
+        const log = options.logger || new ConsoleLogger_js_1.ConsoleLogger('debug');
+        const compiler = options.compiler || new ObservableCompiler_js_1.ObservableCompiler();
+        const serviceName = Deno.env.get(constants_js_1.envVarProjectId) || 'example-service';
+        const environmentID = Deno.env.get(constants_js_1.envVarEnvId) || 'development';
+        const version = Deno.env.get(constants_js_1.envVarVersion) || '1.0.0';
+        const environment = Deno.env.get(constants_js_1.envVarEnvironmentName) || 'development';
+        const orgId = Deno.env.get(constants_js_1.envVarOrgId) || 'development';
+        const orgSlug = Deno.env.get(constants_js_1.envVarOrgSlug) || 'development';
+        const otelTracesURL = Deno.env.get(constants_js_1.envVarOtelTracesURL);
+        let otelSDK;
+        const configReader = configloader_js_1.VersoriConfigReader.fromEnv(log);
+        const runLocal = Deno.env.get(constants_js_1.envVarLocalRun) === 'true';
+        await waitForReady(log);
+        // Do NOT change these attributes, they are used by the API to filter on
+        const resource = (0, resources_1.resourceFromAttributes)({
+            'service.id': serviceName,
+            'service.environment': environment,
+            'service.environment_id': environmentID,
+            'service.version': version,
+            'service.organisation_id': orgId,
+            'service.organisation_slug': orgSlug,
+        });
+        if (otelTracesURL && serviceName) {
+            otelSDK = new sdk_node_1.NodeSDK({
+                traceExporter: new exporter_trace_otlp_proto_1.OTLPTraceExporter({
+                    url: otelTracesURL,
+                }),
+                serviceName: serviceName,
+                resource: resource,
+            });
+            log.info('Starting OpenTelemetry SDK');
+            otelSDK.start();
+        }
+        const tracer = api_1.default.trace.getTracer(serviceName, version);
+        const queueProvider = await Queue_js_1.QueueImpl.fromEnv(log);
+        const connectionFactory = new VanillaConnectionFactory_js_1.DefaultConnectionFactory();
+        const issuesProvider = new Issues_js_1.IssueImpl(log);
+        if (options.contextProvider) {
+            return new VanillaInterpreter(log, compiler, options.contextProvider, express_1.default.Router(), express_1.default.Router(), new Map(), connectionFactory, cronapi_js_1.CronAPIClient.fromEnv(), tracer, configReader, queueProvider, otelSDK);
+        }
+        const kvp = await getKVProvider(runLocal);
+        const organisationId = Deno.env.get(constants_js_1.envVarOrgId) || 'development';
+        const environmentId = Deno.env.get(constants_js_1.envVarEnvId) || 'development';
+        const ctxProvider = new VanillaContext_js_1.VanillaContextProvider(log, kvp, organisationId, environmentId, issuesProvider);
+        return new VanillaInterpreter(log, compiler, ctxProvider, express_1.default.Router(), express_1.default.Router(), new Map(), connectionFactory, cronapi_js_1.CronAPIClient.fromEnv(), tracer, configReader, queueProvider, otelSDK);
+    }
+    register(workflow, options) {
+        const localAbortController = new AbortController();
+        const combinedSignal = options?.signal
+            ? AbortSignal.any([localAbortController.signal, options.signal])
+            : localAbortController.signal;
+        if (!(workflow instanceof Workflow_js_1.WorkflowImpl)) {
+            throw new Error('workflow is not an instance of WorkflowImpl');
+        }
+        const compilerContext = {
+            compiler: this.compiler,
+            log: this.log,
+            tracer: this.tracer,
+            contextProvider: this.contextProvider,
+            webhookRouter: this.webhookRouter,
+            queueProvider: this.queueProvider,
+            cronRouter: this.cronRouter,
+            cronRegistry: this.cronRegistry,
+            configReader: this.cfgReader,
+            cnxFactory: this.cnxFetchFactory,
+            organisationId: Deno.env.get(constants_js_1.envVarOrgId) || 'development',
+        };
+        const trigger$ = this.compiler.compileTrigger(compilerContext, workflow.trigger, combinedSignal);
+        const task$ = this.compiler.compileTask(compilerContext, workflow.task);
+        const registration = {
+            trigger$,
+            task$,
+            localAbortController,
+            sigintListener: () => {
+                this.log.info('Received SIGINT, shutting down workflow');
+                localAbortController.abort();
+            },
+        };
+        this.registeredWorkflows.push(registration);
+        return registration;
+    }
+    start() {
+        const port = Deno.env.get('PORT') || 3000;
+        const cronPort = Deno.env.get('CRON_PORT') || 3001;
+        const webhookApp = (0, express_1.default)();
+        const cronApp = (0, express_1.default)();
+        cronApp.use(express_1.default.json());
+        this.webhookRouter.get('/health', (_req, res) => {
+            res.json({ status: 'healthy' });
+        });
+        this.cronRouter.get('/health', (_req, res) => {
+            res.json({ status: 'healthy' });
+        });
+        webhookApp.use(this.webhookRouter);
+        cronApp.use(this.cronRouter);
+        for (const registration of this.registeredWorkflows) {
+            Deno.addSignalListener('SIGINT', registration.sigintListener);
+            registration.subscription = registration.trigger$
+                .pipe((0, rxjs_1.tap)((ctx) => {
+                ctx.log.info('VanillaInterpreter.executionStarted', { data: ctx.data });
+            }), (0, rxjs_1.mergeMap)((ctx) => (0, rxjs_1.of)(ctx).pipe(registration.task$, (0, rxjs_1.catchError)((err) => {
+                ctx.log.error('VanillaInterpreter.executionError', {
+                    error: err instanceof Error ? err.toString() : err,
+                });
+                try {
+                    ctx.options.onError?.(ctx.withData(err));
+                }
+                catch (err) {
+                    ctx.log.error('VanillaInterpreter.onErrorError: failed to call onError handler', { error: err instanceof Error ? err.toString() : err });
+                    ctx.options.onError?.(ctx.withData({
+                        message: 'Internal server error',
+                        error: err instanceof Error ? err.toString() : err,
+                    }));
+                }
+                return rxjs_1.EMPTY;
+            }))))
+                .subscribe({
+                next: async (ctx) => {
+                    const durationMs = Date.now() - ctx.startTime.getTime();
+                    ctx.log.info('VanillaInterpreter.executionCompleted', {
+                        durationMs,
+                    });
+                    try {
+                        ctx.options.onSuccess?.(ctx);
+                    }
+                    catch (err) {
+                        ctx.log.error('VanillaInterpreter.onSuccessError: failed to call onSuccess handler', { error: err instanceof Error ? err.toString() : err });
+                        ctx.options.onSuccess?.(ctx.withData({
+                            message: 'Internal server error',
+                            error: err instanceof Error ? err.toString() : err,
+                        }));
+                    }
+                    if (ctx.workflowId) {
+                        this.log.info('Async workflow completed', {
+                            workflowId: ctx.workflowId,
+                        });
+                        const output = ctx.data ? btoa(JSON.stringify(ctx.data)) : undefined;
+                        await ctx.queue?.complete({
+                            id: ctx.workflowId,
+                            output,
+                            status: 'completed',
+                        });
+                    }
+                    this.contextProvider.destroy(ctx);
+                },
+                error: (err) => {
+                    this.log.error('VanillaInterpreter.error', {
+                        error: err instanceof Error ? err.toString() : err,
+                    });
+                    Deno.removeSignalListener('SIGINT', registration.sigintListener);
+                },
+                complete: () => {
+                    this.log.info('VanillaInterpreter.workflowCompleted');
+                    Deno.removeSignalListener('SIGINT', registration.sigintListener);
+                },
+            });
+            registration.subscription.add(() => {
+                registration.subscription = undefined;
+            });
+        }
+        try {
+            this.cronProvider.updateCrons(this.cronRegistry);
+        }
+        catch (err) {
+            this.log.error('VanillaInterpreter.updateCronsError', {
+                error: err instanceof Error ? err.toString() : err,
+            });
+            throw new Error('Unable to register scheduler tasks with central cron provider');
+        }
+        this.webhookServer = webhookApp.listen(port, () => {
+            this.log.info(`Express server listening on port ${port}`);
+        });
+        this.cronServer = cronApp.listen(cronPort, () => {
+            this.log.info(`Cron server listening on port ${cronPort}`);
+        });
+        this.shutdownServer = () => {
+            if (this.isShuttingDown) {
+                return;
+            }
+            this.isShuttingDown = true;
+            this.log.info('Shutting down server');
+            if (this.webhookServer) {
+                this.webhookServer.close();
+            }
+            if (this.cronServer) {
+                this.cronServer.close();
+            }
+            for (const registration of this.registeredWorkflows) {
+                Deno.removeSignalListener('SIGINT', registration.sigintListener);
+                if (registration.subscription) {
+                    registration.subscription.unsubscribe();
+                }
+                registration.localAbortController.abort();
+            }
+            if (this.shutdownServer) {
+                Deno.removeSignalListener('SIGINT', this.shutdownServer);
+            }
+        };
+        Deno.addSignalListener('SIGINT', this.shutdownServer);
+        return new Promise((resolve) => {
+            let serversClosed = 0;
+            const totalServers = [this.webhookServer, this.cronServer].filter(Boolean).length;
+            const checkResolve = () => {
+                serversClosed++;
+                if (serversClosed === totalServers) {
+                    this.log.info('All servers closed');
+                    resolve();
+                }
+            };
+            if (this.webhookServer) {
+                this.webhookServer.on('close', () => {
+                    this.log.info('Webhook server closed');
+                    checkResolve();
+                });
+            }
+            if (this.cronServer) {
+                this.cronServer.on('close', () => {
+                    this.log.info('Cron server closed');
+                    checkResolve();
+                });
+            }
+            if (!this.webhookServer && !this.cronServer) {
+                resolve();
+            }
+        });
+    }
+    stop() {
+        this.otelSDK?.shutdown();
+        if (this.shutdownServer) {
+            this.shutdownServer();
+        }
+        return Promise.resolve();
+    }
+}
+exports.VanillaInterpreter = VanillaInterpreter;
+async function waitForReady(log) {
+    const readyCheckUrl = Deno.env.get('READY_CHECK_URL');
+    if (!readyCheckUrl) {
+        return Promise.resolve();
+    }
+    const maxAttempts = 40;
+    const delay = 500;
+    log.info('VanillaInterpreter.waitForReady: waiting for network to be ready', { readyCheckUrl });
+    for (let i = 0; i < maxAttempts; i++) {
+        try {
+            const response = await fetch(readyCheckUrl);
+            if (response.ok) {
+                log.info('VanillaInterpreter.waitForReady: network is ready');
+                return Promise.resolve();
+            }
+        }
+        catch (err) {
+            log.error('VanillaInterpreter.waitForReadyError', {
+                error: err instanceof Error ? err.toString() : err,
+            });
+        }
+        log.info('VanillaInterpreter.waitForReady: retrying...', { attempt: i });
+        await new Promise((resolve) => setTimeout(resolve, delay));
+    }
+    throw new Error(`Network is not ready after ${maxAttempts * (delay / 1000)} seconds`);
+}

package/script/src/interpreter/vanilla/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/script/src/interpreter/vanilla/compilers/background.d.ts.map

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

package/script/src/interpreter/vanilla/compilers/background.js

@@ -0,0 +1,37 @@
+"use strict";
+/*
+ * Copyright (c) 2025 Versori Group Inc
+ *
+ * Use of this software is governed by the Business Source License 1.1
+ * included in the LICENSE file at the root of this repository.
+ *
+ * Change Date: 2029-01-01
+ * Change License: Apache License, Version 2.0
+ *
+ * As of the Change Date, in accordance with the Business Source License,
+ * use of this software will be governed by the Apache License, Version 2.0.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.backgroundCompiler = void 0;
+const rxjs_1 = require("rxjs");
+const BackgroundTask_js_1 = require("../../../dsl/tasks/BackgroundTask.js");
+function compileBackground(ctx, task) {
+    const base = ctx.compiler.compileTask(ctx, task._base);
+    return (src) => src.pipe((0, rxjs_1.connect)((shared$) => (0, rxjs_1.merge)(shared$.pipe((0, rxjs_1.mergeMap)((ctx) => base((0, rxjs_1.of)(ctx)).pipe((0, rxjs_1.subscribeOn)(rxjs_1.asyncScheduler), (0, rxjs_1.tap)({
+        next: (ctx) => ctx.log.debug('Background task emitted a value', {
+            data: ctx.data,
+        }),
+        complete: () => ctx.log.debug('Background task completed'),
+    }), (0, rxjs_1.catchError)((error) => {
+        ctx.log.error('Error in background task', {
+            error,
+            inputData: ctx.data,
+            executionId: ctx.executionId,
+        });
+        return rxjs_1.EMPTY;
+    }), (0, rxjs_1.ignoreElements)()))), shared$.pipe((0, rxjs_1.map)((ctx) => ctx.withData(void 0))))));
+}
+exports.backgroundCompiler = {
+    ctor: BackgroundTask_js_1.BackgroundTask,
+    compile: compileBackground,
+};

package/script/src/interpreter/vanilla/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/script/src/interpreter/vanilla/compilers/catch.d.ts.map

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

package/script/src/interpreter/vanilla/compilers/catch.js

@@ -0,0 +1,78 @@
+"use strict";
+/*
+ * Copyright (c) 2025 Versori Group Inc
+ *
+ * Use of this software is governed by the Business Source License 1.1
+ * included in the LICENSE file at the root of this repository.
+ *
+ * Change Date: 2029-01-01
+ * Change License: Apache License, Version 2.0
+ *
+ * As of the Change Date, in accordance with the Business Source License,
+ * use of this software will be governed by the Apache License, Version 2.0.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.catchCompiler = void 0;
+const rxjs_1 = require("rxjs");
+const CatchTask_js_1 = require("../../../dsl/tasks/CatchTask.js");
+const ExecutionError_js_1 = require("../ExecutionError.js");
+function compileCatch(compilerCtx, task) {
+    const baseOperator = compilerCtx.compiler.compileTask(compilerCtx, task._base);
+    const errorOperator = compilerCtx.compiler.compileTask(compilerCtx, task._errorHandler);
+    return (src) => {
+        return src.pipe((0, rxjs_1.mergeMap)((ctx) => {
+            return baseOperator((0, rxjs_1.of)(ctx)).pipe((0, rxjs_1.catchError)((error) => {
+                return compilerCtx.tracer.startActiveSpan(`catch`, (span) => {
+                    span.setAttribute('execution.id', ctx.executionId);
+                    span.setAttribute('task.type', 'catch');
+                    if (error instanceof Error) {
+                        span.recordException(error);
+                        span.setAttribute('error.message', error.message);
+                        span.setAttribute('error.stack', error.stack ?? '');
+                        span.end();
+                        ctx.log.error('execution has encountered an error', {
+                            error: error.message,
+                            stack: error.stack,
+                        });
+                        // TODO: Do we want to submit issues for the VanillaInterpreter or not?
+                        // compilerCtx.issueProvider.submitIssue({
+                        //     annotations: {
+                        //         'error': error.message,
+                        //         'stack': error.stack || '',
+                        //         'workflowId': ctx.options.workflowId || ctx.workflowId || '',
+                        //         'executionId': ctx.executionId,
+                        //         'activationId': ctx.activation.id,
+                        //         'activationExternalId': ctx.activation?.user.externalId,
+                        //     },
+                        //     reason: 'error',
+                        //     severity: 'high',
+                        // });
+                        return errorOperator((0, rxjs_1.of)(ctx.withData(new ExecutionError_js_1.ExecutionError(ctx, error.message, { cause: error }))));
+                    }
+                    ctx.log.error('execution has encountered an error', {
+                        error: error,
+                    });
+                    // compilerCtx.issueProvider.submitIssue({
+                    //     annotations: {
+                    //         'error': error.message,
+                    //         'stack': error.stack || '',
+                    //         'workflowId': ctx.options.workflowId || ctx.workflowId || '',
+                    //         'executionId': ctx.executionId,
+                    //         'activationId': ctx.activation.id,
+                    //         'activationExternalId': ctx.activation?.user.externalId,
+                    //     },
+                    //     reason: 'error',
+                    //     severity: 'low',
+                    // });
+                    span.setAttribute('error', `${error}`);
+                    span.end();
+                    return errorOperator((0, rxjs_1.of)(ctx.withData(new ExecutionError_js_1.ExecutionError(ctx, `${error}`, { cause: error }))));
+                });
+            }));
+        }));
+    };
+}
+exports.catchCompiler = {
+    ctor: CatchTask_js_1.CatchTask,
+    compile: compileCatch,
+};

package/script/src/interpreter/vanilla/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/script/src/interpreter/vanilla/compilers/chain.d.ts.map

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

package/script/src/interpreter/vanilla/compilers/chain.js

@@ -0,0 +1,24 @@
+"use strict";
+/*
+ * Copyright (c) 2025 Versori Group Inc
+ *
+ * Use of this software is governed by the Business Source License 1.1
+ * included in the LICENSE file at the root of this repository.
+ *
+ * Change Date: 2029-01-01
+ * Change License: Apache License, Version 2.0
+ *
+ * As of the Change Date, in accordance with the Business Source License,
+ * use of this software will be governed by the Apache License, Version 2.0.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chainCompiler = void 0;
+const ChainTask_js_1 = require("../../../dsl/tasks/ChainTask.js");
+function compileChain(ctx, task) {
+    const operators = task.tasks.map((t) => ctx.compiler.compileTask(ctx, t));
+    return (src) => operators.reduce((acc, curr) => curr(acc), src);
+}
+exports.chainCompiler = {
+    ctor: ChainTask_js_1.ChainTask,
+    compile: compileChain,
+};

package/script/src/interpreter/vanilla/compilers/durableworkflow.d.ts

@@ -0,0 +1,8 @@
+import { Observable } from 'rxjs';
+import { DurableWorkflowData, DurableWorkflowTrigger } from '../../../dsl/triggers/DurableTrigger.js';
+import { VanillaCompilerContext } from '../ObservableCompiler.js';
+import { TriggerCompiler } from './mod.js';
+import { VanillaContext } from '../../../context/VanillaContext.js';
+export declare function compileDurableWorkflow(ctx: VanillaCompilerContext, trigger: DurableWorkflowTrigger, signal: AbortSignal): Observable<VanillaContext<DurableWorkflowData>>;
+export declare const durableWorkflowCompiler: TriggerCompiler<DurableWorkflowData, DurableWorkflowTrigger>;
+//# sourceMappingURL=durableworkflow.d.ts.map

package/script/src/interpreter/vanilla/compilers/durableworkflow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"durableworkflow.d.ts","sourceRoot":"","sources":["../../../../../src/src/interpreter/vanilla/compilers/durableworkflow.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,UAAU,EAAE,MAAM,MAAM,CAAC;AAClC,OAAO,EACH,mBAAmB,EACnB,sBAAsB,EACzB,MAAM,yCAAyC,CAAC;AACjD,OAAO,EAAqB,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AACrF,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAC3C,OAAO,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AAEpE,wBAAgB,sBAAsB,CAClC,GAAG,EAAE,sBAAsB,EAC3B,OAAO,EAAE,sBAAsB,EAC/B,MAAM,EAAE,WAAW,GACpB,UAAU,CAAC,cAAc,CAAC,mBAAmB,CAAC,CAAC,CAqFjD;AAED,eAAO,MAAM,uBAAuB,EAAE,eAAe,CAAC,mBAAmB,EAAE,sBAAsB,CAI5F,CAAC"}