@versori/run 0.5.0-alpha.6 → 0.5.1

package/esm/src/interpreter/memory/compilers/webhook.js

@@ -18,7 +18,6 @@ import { Observable } from 'rxjs';
 import { createActIdDynamicWebhookMiddleware, createStaticWebhookMiddleware, createUserIdDynamicWebhookMiddleware, } from '../../../dsl/http/versori/webhookmiddleware.js';
 import { WebhookTrigger } from '../../../dsl/triggers/WebhookTrigger.js';
 import { envVarEnvId } from '../../../internal/constants.js';
-import { sendTaskStartEvent } from '../../../internal/supervisor.js';
 const xml2jsDefaults = {
     explicitArray: false,
     normalize: false,
@@ -69,7 +68,7 @@ export const webhookCompiler = {
             throw new Error('Invalid response mode, must be either "sync" or "async"');
         }
         const method = trigger.options.method || 'post';
-        const validMethods = ['get', 'post', 'put', 'delete', 'patch', 'options', 'head'];
+        const validMethods = ['get', 'post', 'put', 'delete', 'patch', 'options', 'head', 'all'];
         if (method !== method.toLowerCase()) {
             throw new Error(`HTTP method must be in lowercase: ${method} on webhook ${trigger.id}`);
         }
@@ -85,7 +84,6 @@ export const webhookCompiler = {
             onError = trigger.options.response.onError;
         }
         const ctxOptionsFn = (req, res) => ({
-            workflowId: trigger.id,
             onSuccess: (ctx) => {
                 if (isSync) {
                     sendResponse(res, onSuccess(ctx));
@@ -98,21 +96,20 @@ export const webhookCompiler = {
             },
             request: req,
         });
+        const routeMiddleware = [];
         if (!trigger.options.request?.rawBody) {
-            ctx.webhookRouter.use(express.json({ limit: '50mb' }));
-            ctx.webhookRouter.use(xmlparser(xml2jsDefaults));
+            routeMiddleware.push(express.json({ limit: '50mb', type: ['application/json', '*/*+json'] }));
+            routeMiddleware.push(xmlparser(xml2jsDefaults));
         }
         else {
-            ctx.webhookRouter.use(express.raw({ type: '*/*', limit: '50mb' }));
+            routeMiddleware.push(express.raw({ type: '*/*', limit: '50mb' }));
         }
         return new Observable((subscriber) => {
             if (!ctx.webhookRouter) {
                 throw new Error('Router not available in compiler context');
             }
-            ctx.log.info('webhook endpoint added', {
-                id: trigger.id,
-                method,
-            });
+            // add the webhook endpoint to the router
+            ctx.log.info('webhook endpoint added:', { trigger });
             if (corsOptions) {
                 if (typeof corsOptions === 'boolean') {
                     ctx.webhookRouter.use(cors());
@@ -121,9 +118,8 @@ export const webhookCompiler = {
                     ctx.webhookRouter.use(cors(corsOptions));
                 }
             }
-            ctx.webhookRegistry.set(trigger.id, { method, path: `/${trigger.id}`, options: trigger.options });
             // endpoint for sans user because I'm not quite sure how the dynamic routing works
-            ctx.webhookRouter[method](`/${trigger.id}`, createStaticWebhookMiddleware({
+            ctx.webhookRouter[method](`/${trigger.id}`, ...routeMiddleware, createStaticWebhookMiddleware({
                 id: trigger.id,
                 organisationId: ctx.organisationId,
                 environmentId: Deno.env.get(envVarEnvId) ?? '',
@@ -133,17 +129,12 @@ export const webhookCompiler = {
                 cfgReader: ctx.configReader,
                 log: ctx.log,
             }), async (req, res) => {
-                await ctx.tracer.startActiveSpan(`webhook-${trigger.id}`, async (span) => {
+                await ctx.tracer.startActiveSpan(`webhook-${trigger.id}`, (span) => {
                     span.setAttribute('task.id', trigger.id);
-                    span.setAttribute('workflow.id', trigger.id);
                     span.setAttribute('task.type', 'webhook');
-                    span.setAttribute('type', 'task');
                     const staticActivation = res.locals.activation;
-                    let executionCtx = ctx.contextProvider.create(staticActivation, req.body, ctxOptionsFn(req, res));
-                    const spanContext = span.spanContext();
-                    executionCtx = executionCtx.withLogger(executionCtx.log.child({ spanId: spanContext.spanId, traceId: spanContext.traceId }));
+                    const executionCtx = ctx.contextProvider.create(staticActivation, req.body, ctxOptionsFn(req, res));
                     span.setAttribute('execution.id', executionCtx.executionId);
-                    await sendTaskStartEvent(trigger.id, executionCtx, span);
                     try {
                         subscriber.next(executionCtx);
                         if (isAsync) {
@@ -164,7 +155,7 @@ export const webhookCompiler = {
                 });
             });
             // this endpoint will trigger the workflow for each activation given by the external user ID
-            ctx.webhookRouter[method](`/${trigger.id}/users/:userId`, createUserIdDynamicWebhookMiddleware({
+            ctx.webhookRouter[method](`/${trigger.id}/users/:userId`, ...routeMiddleware, createUserIdDynamicWebhookMiddleware({
                 id: trigger.id,
                 connName: trigger.options.connection,
                 organisationId: ctx.organisationId,
@@ -174,11 +165,9 @@ export const webhookCompiler = {
                 cfgReader: ctx.configReader,
                 log: ctx.log,
             }), async (req, res) => {
-                await ctx.tracer.startActiveSpan(`webhook-${trigger.id}`, async (span) => {
+                await ctx.tracer.startActiveSpan(`webhook-${trigger.id}`, (span) => {
                     span.setAttribute('task.id', trigger.id);
-                    span.setAttribute('workflow.id', trigger.id);
                     span.setAttribute('task.type', 'webhook');
-                    span.setAttribute('type', 'task');
                     span.setAttribute('user.id', req.params.userId);
                     const userId = req.params.userId;
                     // Right now we only support a user having one activation
@@ -195,10 +184,7 @@ export const webhookCompiler = {
                         span.end();
                         return;
                     }
-                    let executionCtx = ctx.contextProvider.create(activation, req.body, ctxOptionsFn(req, res));
-                    await sendTaskStartEvent(trigger.id, executionCtx, span);
-                    const spanContext = span.spanContext();
-                    executionCtx = executionCtx.withLogger(executionCtx.log.child({ spanId: spanContext.spanId, traceId: spanContext.traceId }));
+                    const executionCtx = ctx.contextProvider.create(activation, req.body, ctxOptionsFn(req, res));
                     span.setAttribute('execution.id', executionCtx.executionId);
                     const errors = [];
                     try {
@@ -225,7 +211,7 @@ export const webhookCompiler = {
                 });
             });
             // this endpoint will trigger the workflow only for the activation given by its ID
-            ctx.webhookRouter[method](`/${trigger.id}/activations/:activationId`, createActIdDynamicWebhookMiddleware({
+            ctx.webhookRouter[method](`/${trigger.id}/activations/:activationId`, ...routeMiddleware, createActIdDynamicWebhookMiddleware({
                 id: trigger.id,
                 organisationId: ctx.organisationId,
                 environmentId: Deno.env.get(envVarEnvId) ?? '',
@@ -235,11 +221,9 @@ export const webhookCompiler = {
                 cfgReader: ctx.configReader,
                 log: ctx.log,
             }), async (req, res) => {
-                await ctx.tracer.startActiveSpan(`webhook-${trigger.id}`, async (span) => {
+                await ctx.tracer.startActiveSpan(`webhook-${trigger.id}`, (span) => {
                     span.setAttribute('task.id', trigger.id);
-                    span.setAttribute('workflow.id', trigger.id);
                     span.setAttribute('task.type', 'webhook');
-                    span.setAttribute('type', 'task');
                     span.setAttribute('activation.id', req.params.activationId);
                     const activation = res.locals.activation;
                     const activationId = activation?.id ?? req.params.activationId;
@@ -254,11 +238,8 @@ export const webhookCompiler = {
                         span.end();
                         return;
                     }
-                    let activationCtx = ctx.contextProvider.create(activation, req.body, ctxOptionsFn(req, res));
-                    const spanContext = span.spanContext();
-                    activationCtx = activationCtx.withLogger(activationCtx.log.child({ spanId: spanContext.spanId, traceId: spanContext.traceId }));
+                    const activationCtx = ctx.contextProvider.create(activation, req.body, ctxOptionsFn(req, res));
                     span.setAttribute('execution.id', activationCtx.executionId);
-                    await sendTaskStartEvent(trigger.id, activationCtx, span);
                     try {
                         subscriber.next(activationCtx);
                         if (isAsync) {

package/esm/src/interpreter/mod.d.ts

@@ -13,4 +13,5 @@
  */
 export * from './memory/mod.js';
 export * as durable from './durable/mod.js';
+export * as vanilla from './vanilla/mod.js';
 //# sourceMappingURL=mod.d.ts.map

package/esm/src/interpreter/mod.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../../src/src/interpreter/mod.ts"],"names":[],"mappings":"AAaA;;;;;;;;;;;;GAYG;AACH,cAAc,iBAAiB,CAAC;AAChC,OAAO,KAAK,OAAO,MAAM,kBAAkB,CAAC"}
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../../src/src/interpreter/mod.ts"],"names":[],"mappings":"AAaA;;;;;;;;;;;;GAYG;AACH,cAAc,iBAAiB,CAAC;AAChC,OAAO,KAAK,OAAO,MAAM,kBAAkB,CAAC;AAC5C,OAAO,KAAK,OAAO,MAAM,kBAAkB,CAAC"}

package/esm/src/interpreter/mod.js

@@ -25,3 +25,4 @@
  */
 export * from './memory/mod.js';
 export * as durable from './durable/mod.js';
+export * as vanilla from './vanilla/mod.js';

package/esm/src/interpreter/vanilla/ExecutionError.d.ts

@@ -0,0 +1,25 @@
+import { Context } from '../../context/Context.js';
+/**
+ * ExecutionError wraps errors that occur during durable workflow execution, providing access to the context at the
+ * time of the error. This is used with the {@link VanillaInterpreter}.
+ *
+ */
+export declare class ExecutionError extends Error {
+    /**
+     * The workflow context at the time the error occurred.
+     */
+    ctx: Context<any>;
+    /**
+     * Create a new ExecutionError.
+     *
+     * @param ctx The workflow context at the time of the error.
+     * @param message The error message.
+     * @param opts Optional error options.
+     */
+    constructor(ctx: Context<any>, message: string, opts?: ErrorOptions);
+    toJSON(): {
+        name: string;
+        message: string;
+    };
+}
+//# sourceMappingURL=ExecutionError.d.ts.map

package/esm/src/interpreter/vanilla/ExecutionError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExecutionError.d.ts","sourceRoot":"","sources":["../../../../src/src/interpreter/vanilla/ExecutionError.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,OAAO,EAAE,MAAM,0BAA0B,CAAC;AAEnD;;;;GAIG;AACH,qBAAa,cAAe,SAAQ,KAAK;IACrC;;OAEG;IACH,GAAG,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC;IAElB;;;;;;OAMG;gBACS,GAAG,EAAE,OAAO,CAAC,GAAG,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,YAAY;IAOnE,MAAM;;;;CAMT"}

package/esm/src/interpreter/vanilla/ExecutionError.js

@@ -0,0 +1,46 @@
+/*
+ * 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.
+ */
+/**
+ * ExecutionError wraps errors that occur during durable workflow execution, providing access to the context at the
+ * time of the error. This is used with the {@link VanillaInterpreter}.
+ *
+ */
+export class ExecutionError extends Error {
+    /**
+     * Create a new ExecutionError.
+     *
+     * @param ctx The workflow context at the time of the error.
+     * @param message The error message.
+     * @param opts Optional error options.
+     */
+    constructor(ctx, message, opts) {
+        super(message, opts);
+        /**
+         * The workflow context at the time the error occurred.
+         */
+        Object.defineProperty(this, "ctx", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.name = 'ExecutionError';
+        this.ctx = ctx;
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            message: this.message,
+        };
+    }
+}

package/esm/src/interpreter/vanilla/ObservableCompiler.d.ts

@@ -0,0 +1,38 @@
+import { Tracer } from '@opentelemetry/api';
+import { Activation } from '../../services/platform/mod.js';
+import { Router } from 'express';
+import { Observable, OperatorFunction } from 'rxjs';
+import { ConnectionFactory } from '../../connection/types.js';
+import { ContextProvider } from '../../context/ContextProvider.js';
+import { VanillaContext } from '../../context/VanillaContext.js';
+import { ConfigReader } from '../../dsl/http/types.js';
+import { Task } from '../../dsl/Task.js';
+import { Trigger } from '../../dsl/Trigger.js';
+import { Logger } from '../../observability/logging/Logger.js';
+import { QueueAPI } from '../durable/Queue.js';
+import { ContextOperatorFunction, TaskCompiler, TriggerCompiler } from './compilers/types.js';
+export type VanillaCompilerContext = {
+    compiler: ObservableCompiler;
+    log: Logger;
+    tracer: Tracer;
+    contextProvider: ContextProvider;
+    cnxFactory: ConnectionFactory;
+    queueProvider: QueueAPI;
+    webhookRouter: Router;
+    cronRouter: Router;
+    configReader: ConfigReader;
+    cronRegistry: Map<string, string>;
+    organisationId: string;
+};
+export declare const VanillaActivation: Activation;
+export type CompilerFunc<In = any, Out = any, T extends Task<In, Out> = Task<In, Out>> = (ctx: VanillaCompilerContext, task: T) => OperatorFunction<In, Out>;
+export declare class ObservableCompiler {
+    private taskCompilers;
+    private triggerCompilers;
+    constructor();
+    compileTask<In = any, Out = any, Index = void>(ctx: VanillaCompilerContext, task: Task<In, Out>): ContextOperatorFunction<In, Out, Index>;
+    compileTrigger<Out = any, T extends Trigger<Out> = Trigger<Out>>(ctx: VanillaCompilerContext, trigger: T, signal: AbortSignal): Observable<VanillaContext<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/src/interpreter/vanilla/ObservableCompiler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ObservableCompiler.d.ts","sourceRoot":"","sources":["../../../../src/src/interpreter/vanilla/ObservableCompiler.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAC5C,OAAO,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAC;AAC5D,OAAO,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AACjC,OAAO,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,MAAM,CAAC;AACpD,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAC9D,OAAO,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAC;AACnE,OAAO,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AACvD,OAAO,EAAE,IAAI,EAAY,MAAM,mBAAmB,CAAC;AACnD,OAAO,EAAE,OAAO,EAAe,MAAM,sBAAsB,CAAC;AAC5D,OAAO,EAAE,MAAM,EAAE,MAAM,uCAAuC,CAAC;AAC/D,OAAO,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAU/C,OAAO,EAAE,uBAAuB,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAI9F,MAAM,MAAM,sBAAsB,GAAG;IACjC,QAAQ,EAAE,kBAAkB,CAAC;IAC7B,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,eAAe,EAAE,eAAe,CAAC;IACjC,UAAU,EAAE,iBAAiB,CAAC;IAC9B,aAAa,EAAE,QAAQ,CAAC;IACxB,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,YAAY,CAAC;IAC3B,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAClC,cAAc,EAAE,MAAM,CAAC;CAC1B,CAAC;AAEF,eAAO,MAAM,iBAAiB,EAAE,UAa/B,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,sBAAsB,EAC3B,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;;IAkBxE,WAAW,CAAC,EAAE,GAAG,GAAG,EAAE,GAAG,GAAG,GAAG,EAAE,KAAK,GAAG,IAAI,EACzC,GAAG,EAAE,sBAAsB,EAC3B,IAAI,EAAE,IAAI,CAAC,EAAE,EAAE,GAAG,CAAC,GACpB,uBAAuB,CAAC,EAAE,EAAE,GAAG,EAAE,KAAK,CAAC;IAe1C,cAAc,CAAC,GAAG,GAAG,GAAG,EAAE,CAAC,SAAS,OAAO,CAAC,GAAG,CAAC,GAAG,OAAO,CAAC,GAAG,CAAC,EAC3D,GAAG,EAAE,sBAAsB,EAC3B,OAAO,EAAE,CAAC,EACV,MAAM,EAAE,WAAW,GACpB,UAAU,CAAC,cAAc,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;IAexC,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/src/interpreter/vanilla/ObservableCompiler.js

@@ -0,0 +1,95 @@
+/*
+ * 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.
+ */
+import { TaskType } from '../../dsl/Task.js';
+import { TriggerType } from '../../dsl/Trigger.js';
+import { backgroundCompiler } from './compilers/background.js';
+import { catchCompiler } from './compilers/catch.js';
+import { chainCompiler } from './compilers/chain.js';
+import { durableWorkflowCompiler } from './compilers/durableworkflow.js';
+import { fnCompiler } from './compilers/fn.js';
+import { httpCompiler } from './compilers/http.js';
+import { parallelCompiler } from './compilers/parallel.js';
+import { scheduleCompiler } from './compilers/schedule.js';
+import { serialCompiler } from './compilers/serial.js';
+import { unpackCompiler } from './compilers/unpack.js';
+import { webhookCompiler } from './compilers/webhook.js';
+export const VanillaActivation = {
+    id: 'vanilla-webhook-activation',
+    user: {
+        id: 'vanilla-user-id',
+        externalId: 'vanilla-user-external-id',
+        displayName: 'Vanilla User',
+        organisationId: 'vanilla-org-id',
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+    },
+    connections: [],
+    dynamicVariables: {},
+    environment: undefined,
+};
+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);
+        this.registerTrigger(webhookCompiler);
+        this.registerTrigger(durableWorkflowCompiler);
+    }
+    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/src/interpreter/vanilla/VanillaInterpreter.d.ts

@@ -0,0 +1,96 @@
+import { Tracer } from '@opentelemetry/api';
+import { NodeSDK } from '@opentelemetry/sdk-node';
+import { Router } from 'express';
+import { Observable, Subscription } from 'rxjs';
+import { DefaultConnectionFactory } from '../../connection/VanillaConnectionFactory.js';
+import { ContextProvider } from '../../context/ContextProvider.js';
+import { VanillaContext, VanillaContextProvider } from '../../context/VanillaContext.js';
+import { ConfigReader, CronProvider } from '../../dsl/http/types.js';
+import { Workflow } from '../../dsl/Workflow.js';
+import { Logger } from '../../observability/logging/Logger.js';
+import { QueueAPI } from '../durable/Queue.js';
+import { ContextOperatorFunction } from './compilers/types.js';
+import { ObservableCompiler } from './ObservableCompiler.js';
+/**
+ * VanillaInterpreterOptions
+ *  configures the behavior of the {@link VanillaInterpreter}.
+ */
+export type VanillaInterpreterOptions = {
+    /**
+     * Custom logger instance. Defaults to ConsoleLogger.
+     */
+    logger?: Logger;
+    /**
+     * Custom compiler for workflow execution. Advanced use only.
+     */
+    compiler?: ObservableCompiler;
+    /**
+     * Custom context provider. Advanced use only.
+     */
+    contextProvider?: VanillaContextProvider;
+    /**
+     * Abort signal to cancel workflow execution.
+     */
+    signal?: AbortSignal;
+    /**
+     * Skip loading Versori credentials. Useful for local development.
+     */
+    skipVersoriCredentials?: boolean;
+};
+type Registration = {
+    triggerName: string;
+    trigger$: Observable<VanillaContext<any, void>>;
+    task$: ContextOperatorFunction<any, any, any>;
+    localAbortController: AbortController;
+    sigintListener: () => void;
+    subscription?: Subscription;
+};
+/**
+ * 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();
+ * ```
+ */
+export declare class VanillaInterpreter {
+    private readonly log;
+    private readonly compiler;
+    private readonly contextProvider;
+    private readonly webhookRouter;
+    private readonly cronRouter;
+    private readonly cronRegistry;
+    private readonly cnxFetchFactory;
+    private readonly cronProvider;
+    private readonly tracer;
+    private readonly cfgReader;
+    private readonly queueProvider;
+    private readonly otelSDK?;
+    private registeredWorkflows;
+    private webhookServer?;
+    private cronServer?;
+    private shutdownServer?;
+    private isShuttingDown;
+    constructor(log: Logger, compiler: ObservableCompiler, contextProvider: ContextProvider, webhookRouter: Router, cronRouter: Router, cronRegistry: Map<string, string>, cnxFetchFactory: DefaultConnectionFactory, cronProvider: CronProvider, tracer: Tracer, cfgReader: ConfigReader, queueProvider: QueueAPI, otelSDK?: NodeSDK | undefined);
+    static newInstance(options?: VanillaInterpreterOptions): Promise<VanillaInterpreter>;
+    register<O>(workflow: Workflow<O>, options?: VanillaInterpreterOptions): Registration;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+}
+export {};
+//# sourceMappingURL=VanillaInterpreter.d.ts.map

package/esm/src/interpreter/vanilla/VanillaInterpreter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VanillaInterpreter.d.ts","sourceRoot":"","sources":["../../../../src/src/interpreter/vanilla/VanillaInterpreter.ts"],"names":[],"mappings":"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"}