veryfront 0.1.623 → 0.1.625

package/esm/src/workflow/worker/executors/process.js

@@ -1,24 +1,24 @@
 /**
- * Process job executor
+ * Process run executor
  *
- * Executes job-backed workflow runs as child processes.
+ * Executes workflow runs as child processes.
  * Useful for local development and testing without containerization.
  *
  * Each workflow runs in a separate Deno subprocess with its own environment.
  */
 import * as dntShim from "../../../../_dnt.shims.js";
-import { WORKFLOW_JOB_PERMISSIONS } from "../../../security/deno-permissions.js";
+import { WORKFLOW_RUN_PERMISSIONS } from "../../../security/deno-permissions.js";
 import { logger as baseLogger } from "../../../utils/index.js";
-const logger = baseLogger.component("process-job-executor");
+const logger = baseLogger.component("process-run-executor");
 /**
- * Process job executor
+ * Process run executor
  *
- * Spawns child processes for each job-backed workflow run.
+ * Spawns child processes for each workflow run.
  * Provides isolation at the process level (separate memory space).
  *
  * @example
  * ```typescript
- * const executor = new ProcessJobExecutor({
+ * const executor = new ProcessRunExecutor({
  *   entrypointPath: "./src/workflow-run-entrypoint.ts",
  *   env: {
  *     REDIS_URL: "redis://localhost:6379",
@@ -31,26 +31,26 @@ const logger = baseLogger.component("process-job-executor");
  * });
  * ```
  */
-export class ProcessJobExecutor {
+export class ProcessRunExecutor {
     config;
-    activeJobs = new Map();
+    activeExecutions = new Map();
     constructor(config) {
         this.config = {
             command: "deno",
-            args: ["run", ...WORKFLOW_JOB_PERMISSIONS],
+            args: ["run", ...WORKFLOW_RUN_PERMISSIONS],
             debug: false,
             ...config,
         };
     }
-    createJob(jobConfig) {
-        const { jobId, run, managerId, timeout, env, debug } = jobConfig;
+    createRunExecution(executionConfig) {
+        const { executionId, run, managerId, timeout, env, debug } = executionConfig;
         // Build environment variables
         const processEnv = {
             ...this.config.env,
             ...env,
-            MODE: "job",
+            MODE: "run",
             WORKFLOW_RUN_ID: run.id,
-            JOB_ID: jobId,
+            RUN_EXECUTION_ID: executionId,
         };
         // Add tenant context
         if (run._tenant) {
@@ -77,8 +77,8 @@ export class ProcessJobExecutor {
             stderr: "piped",
         });
         const process = command.spawn();
-        const job = {
-            jobId,
+        const execution = {
+            executionId,
             runId: run.id,
             managerId,
             process,
@@ -86,83 +86,83 @@ export class ProcessJobExecutor {
             createdAt: new Date(),
             startedAt: new Date(),
         };
-        this.activeJobs.set(jobId, job);
+        this.activeExecutions.set(executionId, execution);
         if (debug || this.config.debug) {
-            logger.info(`Spawned process for job ${jobId}, run ${run.id}`);
+            logger.info(`Spawned process for run execution ${executionId}, run ${run.id}`);
         }
         // Monitor the process in background
-        this.monitorProcess(job, timeout);
-        return Promise.resolve(jobId);
+        this.monitorProcess(execution, timeout);
+        return Promise.resolve(executionId);
     }
-    getJobStatus(jobId) {
-        const job = this.activeJobs.get(jobId);
-        if (!job) {
+    getRunExecutionStatus(executionId) {
+        const execution = this.activeExecutions.get(executionId);
+        if (!execution) {
             return Promise.resolve(null);
         }
-        return Promise.resolve(this.toJobInfo(job));
+        return Promise.resolve(this.toRunExecutionInfo(execution));
     }
-    listJobs(managerId) {
-        const jobs = [];
-        for (const job of this.activeJobs.values()) {
-            if (job.managerId === managerId) {
-                jobs.push(this.toJobInfo(job));
+    listRunExecutions(managerId) {
+        const executions = [];
+        for (const execution of this.activeExecutions.values()) {
+            if (execution.managerId === managerId) {
+                executions.push(this.toRunExecutionInfo(execution));
             }
         }
-        return Promise.resolve(jobs);
+        return Promise.resolve(executions);
     }
-    deleteJob(jobId) {
-        const job = this.activeJobs.get(jobId);
-        if (!job) {
+    deleteRunExecution(executionId) {
+        const execution = this.activeExecutions.get(executionId);
+        if (!execution) {
             return Promise.resolve();
         }
         // Kill the process if still running
-        if (job.status === "running" || job.status === "pending") {
+        if (execution.status === "running" || execution.status === "pending") {
             try {
-                job.process.kill("SIGTERM");
+                execution.process.kill("SIGTERM");
             }
             catch (_) {
                 /* expected: process may already be dead */
             }
         }
-        if (job.timeoutId)
-            clearTimeout(job.timeoutId);
-        this.activeJobs.delete(jobId);
+        if (execution.timeoutId)
+            clearTimeout(execution.timeoutId);
+        this.activeExecutions.delete(executionId);
         if (this.config.debug) {
-            logger.info(`Deleted job ${jobId}`);
+            logger.info(`Deleted run execution ${executionId}`);
         }
         return Promise.resolve();
     }
     destroy() {
         // Kill all active processes and clear their timers
-        for (const job of this.activeJobs.values()) {
-            if (job.timeoutId)
-                clearTimeout(job.timeoutId);
-            if (job.status === "running" || job.status === "pending") {
+        for (const execution of this.activeExecutions.values()) {
+            if (execution.timeoutId)
+                clearTimeout(execution.timeoutId);
+            if (execution.status === "running" || execution.status === "pending") {
                 try {
-                    job.process.kill("SIGTERM");
+                    execution.process.kill("SIGTERM");
                 }
                 catch (_) {
                     /* expected: process may already be dead */
                 }
             }
         }
-        this.activeJobs.clear();
+        this.activeExecutions.clear();
         return Promise.resolve();
     }
     /**
      * Monitor a process and update its status when it exits
      */
-    monitorProcess(job, timeout) {
+    monitorProcess(execution, timeout) {
         // Set up timeout
-        job.timeoutId = dntShim.setTimeout(() => {
-            job.timeoutId = undefined;
-            if (job.status === "running") {
+        execution.timeoutId = dntShim.setTimeout(() => {
+            execution.timeoutId = undefined;
+            if (execution.status === "running") {
                 try {
-                    job.process.kill("SIGTERM");
-                    job.status = "failed";
-                    job.error = `Job timed out after ${timeout}ms`;
-                    job.completedAt = new Date();
-                    logger.warn(`Job ${job.jobId} timed out`);
+                    execution.process.kill("SIGTERM");
+                    execution.status = "failed";
+                    execution.error = `Run execution timed out after ${timeout}ms`;
+                    execution.completedAt = new Date();
+                    logger.warn(`Run execution ${execution.executionId} timed out`);
                 }
                 catch (_) {
                     /* expected: process may already be dead */
@@ -172,53 +172,53 @@ export class ProcessJobExecutor {
         // Wait for process to complete (fire-and-forget with error handling)
         void (async () => {
             try {
-                const status = await job.process.status;
-                clearTimeout(job.timeoutId);
-                job.timeoutId = undefined;
-                job.completedAt = new Date();
-                if (job.status === "failed") {
+                const status = await execution.process.status;
+                clearTimeout(execution.timeoutId);
+                execution.timeoutId = undefined;
+                execution.completedAt = new Date();
+                if (execution.status === "failed") {
                     // Already marked as failed (e.g. timeout) — don't overwrite
                     return;
                 }
                 if (status.success) {
-                    job.status = "succeeded";
+                    execution.status = "succeeded";
                     if (this.config.debug) {
-                        logger.info(`Job ${job.jobId} succeeded`);
+                        logger.info(`Run execution ${execution.executionId} succeeded`);
                     }
                 }
                 else {
-                    job.status = "failed";
-                    job.error = `Process exited with code ${status.code}`;
-                    logger.error(`Job ${job.jobId} failed with code ${status.code}`);
+                    execution.status = "failed";
+                    execution.error = `Process exited with code ${status.code}`;
+                    logger.error(`Run execution ${execution.executionId} failed with code ${status.code}`);
                 }
             }
             catch (error) {
-                clearTimeout(job.timeoutId);
-                job.timeoutId = undefined;
-                job.status = "failed";
-                job.error = error instanceof Error ? error.message : String(error);
-                job.completedAt = new Date();
-                logger.error(`Job ${job.jobId} error:`, error);
+                clearTimeout(execution.timeoutId);
+                execution.timeoutId = undefined;
+                execution.status = "failed";
+                execution.error = error instanceof Error ? error.message : String(error);
+                execution.completedAt = new Date();
+                logger.error(`Run execution ${execution.executionId} error:`, error);
             }
         })();
         // Log stdout/stderr in debug mode
         if (this.config.debug) {
-            this.streamOutput(job);
+            this.streamOutput(execution);
         }
     }
     /**
      * Stream process output to logs
      */
-    streamOutput(job) {
+    streamOutput(execution) {
         const decoder = new TextDecoder();
         // Stream stdout
-        const stdout = job.process.stdout;
+        const stdout = execution.process.stdout;
         if (stdout) {
             (async () => {
                 for await (const chunk of stdout) {
                     const text = decoder.decode(chunk).trim();
                     if (text) {
-                        logger.debug(`[Job ${job.jobId}] ${text}`);
+                        logger.debug(`[RunExecution ${execution.executionId}] ${text}`);
                     }
                 }
             })().catch(() => {
@@ -226,13 +226,13 @@ export class ProcessJobExecutor {
             });
         }
         // Stream stderr
-        const stderr = job.process.stderr;
+        const stderr = execution.process.stderr;
         if (stderr) {
             (async () => {
                 for await (const chunk of stderr) {
                     const text = decoder.decode(chunk).trim();
                     if (text) {
-                        logger.error(`[Job ${job.jobId}] ${text}`);
+                        logger.error(`[RunExecution ${execution.executionId}] ${text}`);
                     }
                 }
             })().catch(() => {
@@ -241,19 +241,19 @@ export class ProcessJobExecutor {
         }
     }
     /**
-     * Convert tracked job to JobInfo
+     * Convert tracked execution to RunExecutionInfo
      */
-    toJobInfo(job) {
+    toRunExecutionInfo(execution) {
         return {
-            jobId: job.jobId,
-            runId: job.runId,
-            status: job.status,
-            createdAt: job.createdAt,
-            startedAt: job.startedAt,
-            completedAt: job.completedAt,
-            error: job.error,
+            executionId: execution.executionId,
+            runId: execution.runId,
+            status: execution.status,
+            createdAt: execution.createdAt,
+            startedAt: execution.startedAt,
+            completedAt: execution.completedAt,
+            error: execution.error,
             metadata: {
-                pid: job.process.pid,
+                pid: execution.process.pid,
                 command: this.config.command,
             },
         };

package/esm/src/workflow/worker/executors/types.d.ts

@@ -1,26 +1,25 @@
 /**
- * Job executor interface
+ * Run executor interface
  *
- * Abstraction layer for executing job-backed workflow runs in isolated
- * environments.
+ * Abstraction layer for executing workflow runs in isolated environments.
  * Implementations can target different runtimes:
- * - K8s Jobs
+ * - Kubernetes Jobs
  * - Docker containers
  * - Local processes
  * - Cloud Run / Lambda / Fargate
  */
 import type { WorkflowRun } from "../../types.js";
 /**
- * Job configuration passed to executor
+ * Run execution configuration passed to executor
  */
-export interface JobConfig {
-    /** Unique job ID */
-    jobId: string;
+export interface RunExecutionConfig {
+    /** Unique execution ID */
+    executionId: string;
     /** Workflow run to execute */
     run: WorkflowRun;
     /** Manager ID for tracking */
     managerId: string;
-    /** Job timeout in milliseconds */
+    /** Run timeout in milliseconds */
     timeout: number;
     /** Environment variables to inject */
     env: Record<string, string>;
@@ -28,24 +27,24 @@ export interface JobConfig {
     debug?: boolean;
 }
 /**
- * Job execution status
+ * Run execution status
  */
-export type JobStatus = "pending" | "running" | "succeeded" | "failed" | "unknown";
+export type RunExecutionStatus = "pending" | "running" | "succeeded" | "failed" | "unknown";
 /**
- * Job information returned by executor
+ * Run execution information returned by executor
  */
-export interface JobInfo {
-    /** Unique job identifier */
-    jobId: string;
+export interface RunExecutionInfo {
+    /** Unique execution identifier */
+    executionId: string;
     /** Workflow run ID */
     runId: string;
     /** Current status */
-    status: JobStatus;
-    /** When job was created */
+    status: RunExecutionStatus;
+    /** When execution was created */
     createdAt: Date;
-    /** When job started executing */
+    /** When execution started */
     startedAt?: Date;
-    /** When job completed */
+    /** When execution completed */
     completedAt?: Date;
     /** Error message if failed */
     error?: string;
@@ -53,14 +52,14 @@ export interface JobInfo {
     metadata?: Record<string, unknown>;
 }
 /**
- * Job Executor Interface
+ * Run Executor Interface
  *
- * Abstracts the runtime environment for executing job-backed workflow runs.
+ * Abstracts the runtime environment for executing workflow runs.
  * Each implementation handles the specifics of its target platform.
  *
  * @example K8s
  * ```typescript
- * const executor = new K8sJobExecutor({
+ * const executor = new K8sRunExecutor({
  *   namespace: "workflows",
  *   image: "my-app:latest",
  * });
@@ -68,7 +67,7 @@ export interface JobInfo {
  *
  * @example Docker
  * ```typescript
- * const executor = new DockerJobExecutor({
+ * const executor = new DockerRunExecutor({
  *   image: "my-app:latest",
  *   network: "workflow-network",
  * });
@@ -76,34 +75,34 @@ export interface JobInfo {
  *
  * @example Local Process
  * ```typescript
- * const executor = new ProcessJobExecutor({
+ * const executor = new ProcessRunExecutor({
  *   command: "deno",
- *   args: ["run", "job-entrypoint.ts"],
+ *   args: ["run", "run-entrypoint.ts"],
  * });
  * ```
  */
-export interface JobExecutor {
+export interface RunExecutor {
     /**
-     * Create and start a job for a workflow run.
-     * @returns Job ID
+     * Create and start an isolated execution for a workflow run.
+     * @returns Execution ID
      */
-    createJob(config: JobConfig): Promise<string>;
+    createRunExecution(config: RunExecutionConfig): Promise<string>;
     /**
-     * Get the current status of a job
+     * Get the current status of an execution.
      */
-    getJobStatus(jobId: string): Promise<JobInfo | null>;
+    getRunExecutionStatus(executionId: string): Promise<RunExecutionInfo | null>;
     /**
-     * List all active jobs created by a specific manager
+     * List all active executions created by a specific manager.
      */
-    listJobs(managerId: string): Promise<JobInfo[]>;
+    listRunExecutions(managerId: string): Promise<RunExecutionInfo[]>;
     /**
-     * Delete/cleanup a job
-     * Called after job completion or for manual cleanup
+     * Delete/cleanup an execution.
+     * Called after completion or for manual cleanup.
      */
-    deleteJob(jobId: string): Promise<void>;
+    deleteRunExecution(executionId: string): Promise<void>;
     /**
      * Initialize the executor (optional)
-     * Called once before first job creation
+     * Called once before first execution creation.
      */
     initialize?(): Promise<void>;
     /**
@@ -113,7 +112,7 @@ export interface JobExecutor {
     destroy?(): Promise<void>;
 }
 /**
- * Type guard to check if an object implements JobExecutor
+ * Type guard to check if an object implements RunExecutor
  */
-export declare function isJobExecutor(obj: unknown): obj is JobExecutor;
+export declare function isRunExecutor(obj: unknown): obj is RunExecutor;
 //# sourceMappingURL=types.d.ts.map

package/esm/src/workflow/worker/executors/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/src/workflow/worker/executors/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAElD;;GAEG;AACH,MAAM,WAAW,SAAS;IACxB,oBAAoB;IACpB,KAAK,EAAE,MAAM,CAAC;IAEd,8BAA8B;IAC9B,GAAG,EAAE,WAAW,CAAC;IAEjB,8BAA8B;IAC9B,SAAS,EAAE,MAAM,CAAC;IAElB,kCAAkC;IAClC,OAAO,EAAE,MAAM,CAAC;IAEhB,sCAAsC;IACtC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAE5B,2BAA2B;IAC3B,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED;;GAEG;AACH,MAAM,MAAM,SAAS,GAAG,SAAS,GAAG,SAAS,GAAG,WAAW,GAAG,QAAQ,GAAG,SAAS,CAAC;AAEnF;;GAEG;AACH,MAAM,WAAW,OAAO;IACtB,4BAA4B;IAC5B,KAAK,EAAE,MAAM,CAAC;IAEd,sBAAsB;IACtB,KAAK,EAAE,MAAM,CAAC;IAEd,qBAAqB;IACrB,MAAM,EAAE,SAAS,CAAC;IAElB,2BAA2B;IAC3B,SAAS,EAAE,IAAI,CAAC;IAEhB,iCAAiC;IACjC,SAAS,CAAC,EAAE,IAAI,CAAC;IAEjB,yBAAyB;IACzB,WAAW,CAAC,EAAE,IAAI,CAAC;IAEnB,8BAA8B;IAC9B,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf,iCAAiC;IACjC,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,MAAM,WAAW,WAAW;IAC1B;;;OAGG;IACH,SAAS,CAAC,MAAM,EAAE,SAAS,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAE9C;;OAEG;IACH,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC,CAAC;IAErD;;OAEG;IACH,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC;IAEhD;;;OAGG;IACH,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAExC;;;OAGG;IACH,UAAU,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAE7B;;;OAGG;IACH,OAAO,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC3B;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,WAAW,CAS9D"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/src/workflow/worker/executors/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAElD;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,0BAA0B;IAC1B,WAAW,EAAE,MAAM,CAAC;IAEpB,8BAA8B;IAC9B,GAAG,EAAE,WAAW,CAAC;IAEjB,8BAA8B;IAC9B,SAAS,EAAE,MAAM,CAAC;IAElB,kCAAkC;IAClC,OAAO,EAAE,MAAM,CAAC;IAEhB,sCAAsC;IACtC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAE5B,2BAA2B;IAC3B,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED;;GAEG;AACH,MAAM,MAAM,kBAAkB,GAAG,SAAS,GAAG,SAAS,GAAG,WAAW,GAAG,QAAQ,GAAG,SAAS,CAAC;AAE5F;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,kCAAkC;IAClC,WAAW,EAAE,MAAM,CAAC;IAEpB,sBAAsB;IACtB,KAAK,EAAE,MAAM,CAAC;IAEd,qBAAqB;IACrB,MAAM,EAAE,kBAAkB,CAAC;IAE3B,iCAAiC;IACjC,SAAS,EAAE,IAAI,CAAC;IAEhB,6BAA6B;IAC7B,SAAS,CAAC,EAAE,IAAI,CAAC;IAEjB,+BAA+B;IAC/B,WAAW,CAAC,EAAE,IAAI,CAAC;IAEnB,8BAA8B;IAC9B,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf,iCAAiC;IACjC,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,MAAM,WAAW,WAAW;IAC1B;;;OAGG;IACH,kBAAkB,CAAC,MAAM,EAAE,kBAAkB,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAEhE;;OAEG;IACH,qBAAqB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,GAAG,IAAI,CAAC,CAAC;IAE7E;;OAEG;IACH,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAAC;IAElE;;;OAGG;IACH,kBAAkB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEvD;;;OAGG;IACH,UAAU,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAE7B;;;OAGG;IACH,OAAO,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC3B;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,WAAW,CAS9D"}

package/esm/src/workflow/worker/executors/types.js

@@ -1,23 +1,22 @@
 /**
- * Job executor interface
+ * Run executor interface
  *
- * Abstraction layer for executing job-backed workflow runs in isolated
- * environments.
+ * Abstraction layer for executing workflow runs in isolated environments.
  * Implementations can target different runtimes:
- * - K8s Jobs
+ * - Kubernetes Jobs
  * - Docker containers
  * - Local processes
  * - Cloud Run / Lambda / Fargate
  */
 /**
- * Type guard to check if an object implements JobExecutor
+ * Type guard to check if an object implements RunExecutor
  */
-export function isJobExecutor(obj) {
+export function isRunExecutor(obj) {
     if (!obj || typeof obj !== "object")
         return false;
     const executor = obj;
-    return (typeof executor.createJob === "function" &&
-        typeof executor.getJobStatus === "function" &&
-        typeof executor.listJobs === "function" &&
-        typeof executor.deleteJob === "function");
+    return (typeof executor.createRunExecution === "function" &&
+        typeof executor.getRunExecutionStatus === "function" &&
+        typeof executor.listRunExecutions === "function" &&
+        typeof executor.deleteRunExecution === "function");
 }

package/esm/src/workflow/worker/index.d.ts

@@ -10,23 +10,23 @@
  *    - Good for trusted code or single-tenant deployments
  *    - Simple setup, lower overhead
  *
- * 2. **WorkflowRunManager + K8sJobExecutor** - Kubernetes Job-backed execution
+ * 2. **WorkflowRunManager + K8sRunExecutor** - Kubernetes-resource-backed execution
  *    - Each workflow runs in an ephemeral container
  *    - Complete tenant isolation (no shared state)
  *    - Required for multi-tenant untrusted code execution
  *
- * 3. **WorkflowRunManager + ProcessJobExecutor** - Local process execution
+ * 3. **WorkflowRunManager + ProcessRunExecutor** - Local process execution
  *    - Spawns child processes for each workflow
  *    - Good for local development without K8s/Docker
  *    - Mirrors production behavior
  *
- * A workflow run can be backed by a job executor without introducing another
+ * A workflow run can be backed by a run executor without introducing another
  * user-visible execution type.
  */
 import "../../../_dnt.polyfills.js";
 export { createWorkflowWorker, type WorkerStats, type WorkerStatus, WorkflowWorker, type WorkflowWorkerConfig, } from "./workflow-worker.js";
-export { createWorkflowRunManager, type ManagerStats, type ManagerStatus, WorkflowRunManager, type WorkflowRunManagerConfig, } from "./job-manager.js";
-export { isJobExecutor, type JobConfig, type JobExecutor, type JobInfo, type JobStatus, type K8sClient, K8sJobExecutor, type K8sJobExecutorConfig, type K8sJobSpec, type K8sJobStatusResponse, ProcessJobExecutor, type ProcessJobExecutorConfig, } from "./executors/index.js";
-export { createWorkflowRunEntrypoint, type CreateWorkflowRunEntrypointOptions, EXIT_CODES, runWorkflowRun, type WorkflowRunEntrypointConfig, } from "./job-entrypoint.js";
-export { createDynamicWorkflowRunEntrypoint, type CreateDynamicWorkflowRunEntrypointOptions, DYNAMIC_EXIT_CODES, type DynamicWorkflowRunEntrypointConfig, runDynamicWorkflowRun, } from "./dynamic-job-entrypoint.js";
+export { createWorkflowRunManager, type ManagerStats, type ManagerStatus, WorkflowRunManager, type WorkflowRunManagerConfig, } from "./run-manager.js";
+export { isRunExecutor, type K8sClient, type K8sRunExecutionSpec, type K8sRunExecutionStatusResponse, K8sRunExecutor, type K8sRunExecutorConfig, ProcessRunExecutor, type ProcessRunExecutorConfig, type RunExecutionConfig, type RunExecutionInfo, type RunExecutionStatus, type RunExecutor, } from "./executors/index.js";
+export { createWorkflowRunEntrypoint, type CreateWorkflowRunEntrypointOptions, EXIT_CODES, runWorkflowRun, type WorkflowRunEntrypointConfig, } from "./run-entrypoint.js";
+export { createDynamicWorkflowRunEntrypoint, type CreateDynamicWorkflowRunEntrypointOptions, DYNAMIC_EXIT_CODES, type DynamicWorkflowRunEntrypointConfig, runDynamicWorkflowRun, } from "./dynamic-run-entrypoint.js";
 //# sourceMappingURL=index.d.ts.map

package/esm/src/workflow/worker/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/src/workflow/worker/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAGH,OAAO,4BAA4B,CAAC;AAEpC,OAAO,EACL,oBAAoB,EACpB,KAAK,WAAW,EAChB,KAAK,YAAY,EACjB,cAAc,EACd,KAAK,oBAAoB,GAC1B,MAAM,sBAAsB,CAAC;AAG9B,OAAO,EACL,wBAAwB,EACxB,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,kBAAkB,EAClB,KAAK,wBAAwB,GAC9B,MAAM,kBAAkB,CAAC;AAG1B,OAAO,EACL,aAAa,EACb,KAAK,SAAS,EACd,KAAK,WAAW,EAChB,KAAK,OAAO,EACZ,KAAK,SAAS,EACd,KAAK,SAAS,EACd,cAAc,EACd,KAAK,oBAAoB,EACzB,KAAK,UAAU,EACf,KAAK,oBAAoB,EACzB,kBAAkB,EAClB,KAAK,wBAAwB,GAC9B,MAAM,sBAAsB,CAAC;AAI9B,OAAO,EACL,2BAA2B,EAC3B,KAAK,kCAAkC,EACvC,UAAU,EACV,cAAc,EACd,KAAK,2BAA2B,GACjC,MAAM,qBAAqB,CAAC;AAI7B,OAAO,EACL,kCAAkC,EAClC,KAAK,yCAAyC,EAC9C,kBAAkB,EAClB,KAAK,kCAAkC,EACvC,qBAAqB,GACtB,MAAM,6BAA6B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/src/workflow/worker/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAGH,OAAO,4BAA4B,CAAC;AAEpC,OAAO,EACL,oBAAoB,EACpB,KAAK,WAAW,EAChB,KAAK,YAAY,EACjB,cAAc,EACd,KAAK,oBAAoB,GAC1B,MAAM,sBAAsB,CAAC;AAG9B,OAAO,EACL,wBAAwB,EACxB,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,kBAAkB,EAClB,KAAK,wBAAwB,GAC9B,MAAM,kBAAkB,CAAC;AAG1B,OAAO,EACL,aAAa,EACb,KAAK,SAAS,EACd,KAAK,mBAAmB,EACxB,KAAK,6BAA6B,EAClC,cAAc,EACd,KAAK,oBAAoB,EACzB,kBAAkB,EAClB,KAAK,wBAAwB,EAC7B,KAAK,kBAAkB,EACvB,KAAK,gBAAgB,EACrB,KAAK,kBAAkB,EACvB,KAAK,WAAW,GACjB,MAAM,sBAAsB,CAAC;AAI9B,OAAO,EACL,2BAA2B,EAC3B,KAAK,kCAAkC,EACvC,UAAU,EACV,cAAc,EACd,KAAK,2BAA2B,GACjC,MAAM,qBAAqB,CAAC;AAI7B,OAAO,EACL,kCAAkC,EAClC,KAAK,yCAAyC,EAC9C,kBAAkB,EAClB,KAAK,kCAAkC,EACvC,qBAAqB,GACtB,MAAM,6BAA6B,CAAC"}

package/esm/src/workflow/worker/index.js

@@ -10,29 +10,29 @@
  *    - Good for trusted code or single-tenant deployments
  *    - Simple setup, lower overhead
  *
- * 2. **WorkflowRunManager + K8sJobExecutor** - Kubernetes Job-backed execution
+ * 2. **WorkflowRunManager + K8sRunExecutor** - Kubernetes-resource-backed execution
  *    - Each workflow runs in an ephemeral container
  *    - Complete tenant isolation (no shared state)
  *    - Required for multi-tenant untrusted code execution
  *
- * 3. **WorkflowRunManager + ProcessJobExecutor** - Local process execution
+ * 3. **WorkflowRunManager + ProcessRunExecutor** - Local process execution
  *    - Spawns child processes for each workflow
  *    - Good for local development without K8s/Docker
  *    - Mirrors production behavior
  *
- * A workflow run can be backed by a job executor without introducing another
+ * A workflow run can be backed by a run executor without introducing another
  * user-visible execution type.
  */
 // In-process worker (single-tenant / trusted code)
 import "../../../_dnt.polyfills.js";
 export { createWorkflowWorker, WorkflowWorker, } from "./workflow-worker.js";
-// Job-backed workflow run execution (multi-tenant / untrusted code)
-export { createWorkflowRunManager, WorkflowRunManager, } from "./job-manager.js";
-// Job Executors (pluggable runtime backends)
-export { isJobExecutor, K8sJobExecutor, ProcessJobExecutor, } from "./executors/index.js";
+// Isolated workflow run execution (multi-tenant / untrusted code)
+export { createWorkflowRunManager, WorkflowRunManager, } from "./run-manager.js";
+// Run executors (pluggable runtime backends)
+export { isRunExecutor, K8sRunExecutor, ProcessRunExecutor, } from "./executors/index.js";
 // Workflow run entrypoint (runs inside ephemeral container/process)
 // Use this when workflows are pre-bundled in the container
-export { createWorkflowRunEntrypoint, EXIT_CODES, runWorkflowRun, } from "./job-entrypoint.js";
+export { createWorkflowRunEntrypoint, EXIT_CODES, runWorkflowRun, } from "./run-entrypoint.js";
 // Dynamic workflow run entrypoint (discovers workflows at runtime)
 // Use this when workflows are stored in Veryfront API
-export { createDynamicWorkflowRunEntrypoint, DYNAMIC_EXIT_CODES, runDynamicWorkflowRun, } from "./dynamic-job-entrypoint.js";
+export { createDynamicWorkflowRunEntrypoint, DYNAMIC_EXIT_CODES, runDynamicWorkflowRun, } from "./dynamic-run-entrypoint.js";

package/esm/src/workflow/worker/{job-entrypoint.d.ts → run-entrypoint.d.ts}

@@ -1,7 +1,7 @@
 /**
  * Workflow run entrypoint
  *
- * Runs inside an ephemeral K8s Job container.
+ * Runs inside an ephemeral run execution container.
  * Executes a single workflow run in complete isolation.
  *
  * Environment variables:
@@ -45,7 +45,7 @@ export declare const EXIT_CODES: {
 /**
  * Run the workflow run entrypoint
  *
- * This function is the main entrypoint for workflow execution in a K8s Job.
+ * This function is the main entrypoint for isolated workflow execution.
  * It should be called from your container's main script.
  *
  * @example
@@ -103,4 +103,4 @@ export interface CreateWorkflowRunEntrypointOptions {
 }
 /** Create a workflow run entrypoint. */
 export declare function createWorkflowRunEntrypoint(options: CreateWorkflowRunEntrypointOptions): Promise<() => Promise<number>>;
-//# sourceMappingURL=job-entrypoint.d.ts.map
+//# sourceMappingURL=run-entrypoint.d.ts.map

package/esm/src/workflow/worker/{job-entrypoint.d.ts.map → run-entrypoint.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"job-entrypoint.d.ts","sourceRoot":"","sources":["../../../../src/src/workflow/worker/job-entrypoint.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAIH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAC5D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AACzE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAWtD;;GAEG;AACH,MAAM,WAAW,2BAA2B;IAC1C,uCAAuC;IACvC,OAAO,EAAE,eAAe,CAAC;IAEzB,wBAAwB;IACxB,QAAQ,EAAE,gBAAgB,CAAC;IAE3B,2BAA2B;IAC3B,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED;;GAEG;AACH,eAAO,MAAM,UAAU;;;;;CAKb,CAAC;AAEX;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAsB,cAAc,CAAC,MAAM,EAAE,2BAA2B,GAAG,OAAO,CAAC,MAAM,CAAC,CAgEzF;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,WAAW,kCAAkC;IACjD,4BAA4B;IAC5B,QAAQ,EAAE,MAAM,CAAC;IAEjB,4BAA4B;IAC5B,SAAS,EAAE,KAAK,CAAC;QAAE,UAAU,EAAE,kBAAkB,CAAA;KAAE,CAAC,CAAC;IAErD,2BAA2B;IAC3B,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,wCAAwC;AACxC,wBAAsB,2BAA2B,CAC/C,OAAO,EAAE,kCAAkC,GAC1C,OAAO,CAAC,MAAM,OAAO,CAAC,MAAM,CAAC,CAAC,CA0BhC"}
+{"version":3,"file":"run-entrypoint.d.ts","sourceRoot":"","sources":["../../../../src/src/workflow/worker/run-entrypoint.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAIH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAC5D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AACzE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAWtD;;GAEG;AACH,MAAM,WAAW,2BAA2B;IAC1C,uCAAuC;IACvC,OAAO,EAAE,eAAe,CAAC;IAEzB,wBAAwB;IACxB,QAAQ,EAAE,gBAAgB,CAAC;IAE3B,2BAA2B;IAC3B,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED;;GAEG;AACH,eAAO,MAAM,UAAU;;;;;CAKb,CAAC;AAEX;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAsB,cAAc,CAAC,MAAM,EAAE,2BAA2B,GAAG,OAAO,CAAC,MAAM,CAAC,CAgEzF;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,WAAW,kCAAkC;IACjD,4BAA4B;IAC5B,QAAQ,EAAE,MAAM,CAAC;IAEjB,4BAA4B;IAC5B,SAAS,EAAE,KAAK,CAAC;QAAE,UAAU,EAAE,kBAAkB,CAAA;KAAE,CAAC,CAAC;IAErD,2BAA2B;IAC3B,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,wCAAwC;AACxC,wBAAsB,2BAA2B,CAC/C,OAAO,EAAE,kCAAkC,GAC1C,OAAO,CAAC,MAAM,OAAO,CAAC,MAAM,CAAC,CAAC,CA0BhC"}

package/esm/src/workflow/worker/{job-entrypoint.js → run-entrypoint.js}

@@ -1,7 +1,7 @@
 /**
  * Workflow run entrypoint
  *
- * Runs inside an ephemeral K8s Job container.
+ * Runs inside an ephemeral run execution container.
  * Executes a single workflow run in complete isolation.
  *
  * Environment variables:
@@ -35,7 +35,7 @@ export const EXIT_CODES = {
 /**
  * Run the workflow run entrypoint
  *
- * This function is the main entrypoint for workflow execution in a K8s Job.
+ * This function is the main entrypoint for isolated workflow execution.
  * It should be called from your container's main script.
  *
  * @example