@decaf-ts/core 0.17.0 → 0.19.0

package/lib/cjs/tasks/TaskEngine.cjs

@@ -1,30 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TaskEngine = void 0;
-const TaskModel_1 = require("./models/TaskModel.cjs");
-const TaskEventModel_1 = require("./models/TaskEventModel.cjs");
-const TaskHandlerRegistry_1 = require("./TaskHandlerRegistry.cjs");
-const TaskEventBus_1 = require("./TaskEventBus.cjs");
-const Condition_1 = require("./../query/Condition.cjs");
-const TaskStepResultModel_1 = require("./models/TaskStepResultModel.cjs");
-const TaskLogEntryModel_1 = require("./models/TaskLogEntryModel.cjs");
-const TaskBackoffModel_1 = require("./models/TaskBackoffModel.cjs");
-const TaskStepSpecModel_1 = require("./models/TaskStepSpecModel.cjs");
-const constants_1 = require("./constants.cjs");
+const TaskModel_js_1 = require("./models/TaskModel.cjs");
+const TaskEventModel_js_1 = require("./models/TaskEventModel.cjs");
+const TaskHandlerRegistry_js_1 = require("./TaskHandlerRegistry.cjs");
+const TaskEventBus_js_1 = require("./TaskEventBus.cjs");
+const Condition_js_1 = require("./../query/Condition.cjs");
+const TaskStepResultModel_js_1 = require("./models/TaskStepResultModel.cjs");
+const TaskLogEntryModel_js_1 = require("./models/TaskLogEntryModel.cjs");
+const TaskBackoffModel_js_1 = require("./models/TaskBackoffModel.cjs");
+const TaskStepSpecModel_js_1 = require("./models/TaskStepSpecModel.cjs");
+const constants_js_1 = require("./constants.cjs");
 const logging_1 = require("@decaf-ts/logging");
-const ContextualLoggedClass_1 = require("./../utils/ContextualLoggedClass.cjs");
+const ContextualLoggedClass_js_1 = require("./../utils/ContextualLoggedClass.cjs");
 const db_decorators_1 = require("@decaf-ts/db-decorators");
-const utils_1 = require("./utils.cjs");
-const TaskContext_1 = require("./TaskContext.cjs");
-const TaskStateChangeError_1 = require("./TaskStateChangeError.cjs");
-const logging_2 = require("./logging.cjs");
-const TaskErrorModel_1 = require("./models/TaskErrorModel.cjs");
-const TaskTracker_1 = require("./TaskTracker.cjs");
+const utils_js_1 = require("./utils.cjs");
+const TaskContext_js_1 = require("./TaskContext.cjs");
+const TaskStateChangeError_js_1 = require("./TaskStateChangeError.cjs");
+const logging_js_1 = require("./logging.cjs");
+const TaskErrorModel_js_1 = require("./models/TaskErrorModel.cjs");
+const TaskTracker_js_1 = require("./TaskTracker.cjs");
 const transactional_decorators_1 = require("@decaf-ts/transactional-decorators");
-const index_1 = require("./../persistence/index.cjs");
-class TaskEngine extends ContextualLoggedClass_1.AbsContextual {
+const index_js_1 = require("./../persistence/index.cjs");
+class TaskEngine extends ContextualLoggedClass_js_1.AbsContextual {
     get Context() {
-        return TaskContext_1.TaskContext;
+        return TaskContext_js_1.TaskContext;
     }
     get adapter() {
         if (!this._adapter) {
@@ -43,7 +43,7 @@ class TaskEngine extends ContextualLoggedClass_1.AbsContextual {
     get tasks() {
         if (this._tasks)
             return this._tasks;
-        this._tasks = new (this.adapter.repository())(this.adapter, TaskModel_1.TaskModel, true).override({
+        this._tasks = new (this.adapter.repository())(this.adapter, TaskModel_js_1.TaskModel, true).override({
             afterQueryHandlers: true,
         });
         return this._tasks;
@@ -51,13 +51,13 @@ class TaskEngine extends ContextualLoggedClass_1.AbsContextual {
     get events() {
         if (this._events)
             return this._events;
-        this._events = new (this.adapter.repository())(this.adapter, TaskEventModel_1.TaskEventModel, true).override({
+        this._events = new (this.adapter.repository())(this.adapter, TaskEventModel_js_1.TaskEventModel, true).override({
             afterQueryHandlers: true,
         });
         return this._events;
     }
     static createTaskContext(base, overrides) {
-        const ctx = new TaskContext_1.TaskContext(base);
+        const ctx = new TaskContext_js_1.TaskContext(base);
         if (overrides && Object.keys(overrides).length) {
             return ctx.accumulate(overrides);
         }
@@ -68,11 +68,11 @@ class TaskEngine extends ContextualLoggedClass_1.AbsContextual {
         this.config = config;
         this.lock = new transactional_decorators_1.Lock();
         this.running = false;
-        const autoShutdown = Object.assign({}, constants_1.DefaultTaskEngineConfig.autoShutdown, config.autoShutdown);
-        this.config = Object.assign({}, constants_1.DefaultTaskEngineConfig, config, {
+        const autoShutdown = Object.assign({}, constants_js_1.DefaultTaskEngineConfig.autoShutdown, config.autoShutdown);
+        this.config = Object.assign({}, constants_js_1.DefaultTaskEngineConfig, config, {
             autoShutdown,
-            bus: config.bus || new TaskEventBus_1.TaskEventBus(),
-            registry: config.registry || new TaskHandlerRegistry_1.TaskHandlerRegistry(),
+            bus: config.bus || new TaskEventBus_js_1.TaskEventBus(),
+            registry: config.registry || new TaskHandlerRegistry_js_1.TaskHandlerRegistry(),
         });
         this.idleDelayMs = this.config.pollMsIdle;
     }
@@ -83,14 +83,14 @@ class TaskEngine extends ContextualLoggedClass_1.AbsContextual {
         log.info(`${task.classification} task registered under ${t.id}`);
         if (!track)
             return t;
-        const tracker = new TaskTracker_1.TaskTracker(this.bus, t);
+        const tracker = new TaskTracker_js_1.TaskTracker(this.bus, t);
         return { task: t, tracker };
     }
     schedule(task, track = false, ...args) {
         return {
             for: async (when) => {
                 const scheduledTo = when instanceof Date ? when : when.build();
-                task.status = constants_1.TaskStatus.SCHEDULED;
+                task.status = constants_js_1.TaskStatus.SCHEDULED;
                 task.scheduledTo = scheduledTo;
                 task.nextRunAt = undefined;
                 task.leaseOwner = undefined;
@@ -105,17 +105,17 @@ class TaskEngine extends ContextualLoggedClass_1.AbsContextual {
         let task = await this.tasks.read(id, ctx);
         task = await this.ensureTaskError(task, ctx);
         log.info(`${task.classification} task found with id ${id}`);
-        const tracker = new TaskTracker_1.TaskTracker(this.bus, task);
+        const tracker = new TaskTracker_js_1.TaskTracker(this.bus, task);
         return { task, tracker };
     }
     async ensureTaskError(task, ctx) {
-        if (![constants_1.TaskStatus.FAILED, constants_1.TaskStatus.CANCELED].includes(task.status) ||
+        if (![constants_js_1.TaskStatus.FAILED, constants_js_1.TaskStatus.CANCELED].includes(task.status) ||
             task.error) {
             return task;
         }
         let current = task;
         for (let attempt = 0; attempt < 6; attempt += 1) {
-            await (0, utils_1.sleep)(20);
+            await (0, utils_js_1.sleep)(20);
             try {
                 const latest = await this.tasks.read(current.id, ctx);
                 if (latest.error)
@@ -131,10 +131,10 @@ class TaskEngine extends ContextualLoggedClass_1.AbsContextual {
     async cancel(id, ...args) {
         const { ctx } = (await this.logCtx(args, "cancel", true)).for(this.cancel);
         const t = await this.tasks.read(id, ctx);
-        if (t.status === constants_1.TaskStatus.SUCCEEDED || t.status === constants_1.TaskStatus.FAILED)
+        if (t.status === constants_js_1.TaskStatus.SUCCEEDED || t.status === constants_js_1.TaskStatus.FAILED)
             return t;
-        t.status = constants_1.TaskStatus.CANCELED;
-        const cancelError = new TaskErrorModel_1.TaskErrorModel({
+        t.status = constants_js_1.TaskStatus.CANCELED;
+        const cancelError = new TaskErrorModel_js_1.TaskErrorModel({
             message: `Task ${t.id} canceled`,
             code: 400,
         });
@@ -144,7 +144,7 @@ class TaskEngine extends ContextualLoggedClass_1.AbsContextual {
         t.nextRunAt = undefined;
         t.scheduledTo = undefined;
         const saved = await this.tasks.update(t, ctx);
-        await this.emitStatus(ctx, saved, constants_1.TaskStatus.CANCELED, cancelError);
+        await this.emitStatus(ctx, saved, constants_js_1.TaskStatus.CANCELED, cancelError);
         return saved;
     }
     async isRunning() {
@@ -164,7 +164,7 @@ class TaskEngine extends ContextualLoggedClass_1.AbsContextual {
         void this.loop(ctx);
     }
     async stop(...args) {
-        const { ctx, log } = (await this.logCtx(args, index_1.PersistenceKeys.SHUTDOWN, true)).for(this.stop);
+        const { ctx, log } = (await this.logCtx(args, index_js_1.PersistenceKeys.SHUTDOWN, true)).for(this.stop);
         await this.lock.acquire();
         if (!this.running)
             log.warn(`stop method called when task engine was not running`);
@@ -172,7 +172,7 @@ class TaskEngine extends ContextualLoggedClass_1.AbsContextual {
         this.lock.release();
         const runningTasks = await this.tasks
             .select(["id"])
-            .where(Condition_1.Condition.attr("status").eq(constants_1.TaskStatus.RUNNING))
+            .where(Condition_js_1.Condition.attr("status").eq(constants_js_1.TaskStatus.RUNNING))
             .execute(ctx);
         const timeout = ctx.getOrUndefined?.("gracefulShutdownMsTimeout") ??
             this.config.gracefulShutdownMsTimeout;
@@ -233,7 +233,7 @@ class TaskEngine extends ContextualLoggedClass_1.AbsContextual {
                 this.idleDelayMs = this.config.pollMsIdle;
             }
             const waitMs = idle ? this.idleDelayMs : this.config.pollMsBusy;
-            await (0, utils_1.sleep)(Math.max(waitMs, 0));
+            await (0, utils_js_1.sleep)(Math.max(waitMs, 0));
         }
     }
     async claimBatch(ctx) {
@@ -243,16 +243,16 @@ class TaskEngine extends ContextualLoggedClass_1.AbsContextual {
         // - PENDING
         // - WAITING_RETRY with nextRunAt <= now
         // - RUNNING with expired lease (recovery)
-        const condPending = Condition_1.Condition.attribute("status").eq(constants_1.TaskStatus.PENDING);
-        const condRetry = Condition_1.Condition.attribute("status")
-            .eq(constants_1.TaskStatus.WAITING_RETRY)
-            .and(Condition_1.Condition.attribute("nextRunAt").lte(now));
-        const condLeaseExpired = Condition_1.Condition.attribute("status")
-            .eq(constants_1.TaskStatus.RUNNING)
-            .and(Condition_1.Condition.attribute("leaseExpiry").lte(now));
-        const condScheduled = Condition_1.Condition.attribute("status")
-            .eq(constants_1.TaskStatus.SCHEDULED)
-            .and(Condition_1.Condition.attribute("scheduledTo").lte(now));
+        const condPending = Condition_js_1.Condition.attribute("status").eq(constants_js_1.TaskStatus.PENDING);
+        const condRetry = Condition_js_1.Condition.attribute("status")
+            .eq(constants_js_1.TaskStatus.WAITING_RETRY)
+            .and(Condition_js_1.Condition.attribute("nextRunAt").lte(now));
+        const condLeaseExpired = Condition_js_1.Condition.attribute("status")
+            .eq(constants_js_1.TaskStatus.RUNNING)
+            .and(Condition_js_1.Condition.attribute("leaseExpiry").lte(now));
+        const condScheduled = Condition_js_1.Condition.attribute("status")
+            .eq(constants_js_1.TaskStatus.SCHEDULED)
+            .and(Condition_js_1.Condition.attribute("scheduledTo").lte(now));
         const runnable = condPending
             .or(condRetry)
             .or(condLeaseExpired)
@@ -288,9 +288,9 @@ class TaskEngine extends ContextualLoggedClass_1.AbsContextual {
         const runnable = await this.isRunnable(source, ctx);
         if (!runnable)
             return null;
-        const claimed = new TaskModel_1.TaskModel({
+        const claimed = new TaskModel_js_1.TaskModel({
             ...source,
-            status: constants_1.TaskStatus.RUNNING,
+            status: constants_js_1.TaskStatus.RUNNING,
             leaseOwner: this.config.workerId.toString(),
             leaseExpiry: new Date(now + (parseInt(this.config.leaseMs.toString()) || 60_000)),
             scheduledTo: undefined,
@@ -307,9 +307,9 @@ class TaskEngine extends ContextualLoggedClass_1.AbsContextual {
     }
     isTaskFinished(status) {
         return [
-            constants_1.TaskStatus.SUCCEEDED,
-            constants_1.TaskStatus.FAILED,
-            constants_1.TaskStatus.CANCELED,
+            constants_js_1.TaskStatus.SUCCEEDED,
+            constants_js_1.TaskStatus.FAILED,
+            constants_js_1.TaskStatus.CANCELED,
         ].includes(status);
     }
     parseTaskDependency(value) {
@@ -397,7 +397,7 @@ class TaskEngine extends ContextualLoggedClass_1.AbsContextual {
         return true;
     }
     getStepLock(task, stepIndex) {
-        if (task.atomicity !== constants_1.TaskType.COMPOSITE)
+        if (task.atomicity !== constants_js_1.TaskType.COMPOSITE)
             return undefined;
         const steps = this.normalizeSteps(task.steps);
         if (!steps.length)
@@ -415,7 +415,7 @@ class TaskEngine extends ContextualLoggedClass_1.AbsContextual {
             return false;
         const runningTasks = await this.tasks
             .select()
-            .where(Condition_1.Condition.attribute("status").eq(constants_1.TaskStatus.RUNNING))
+            .where(Condition_js_1.Condition.attribute("status").eq(constants_js_1.TaskStatus.RUNNING))
             .execute(ctx);
         for (const running of runningTasks) {
             if (running.id === task.id)
@@ -435,7 +435,7 @@ class TaskEngine extends ContextualLoggedClass_1.AbsContextual {
         const dependenciesSatisfied = await this.areDependenciesSatisfied(dependencies, ctx);
         if (!dependenciesSatisfied)
             return false;
-        const stepIndex = task.atomicity === constants_1.TaskType.COMPOSITE
+        const stepIndex = task.atomicity === constants_js_1.TaskType.COMPOSITE
             ? (task.currentStep ?? 0)
             : undefined;
         return !(await this.hasLockConflict(task, stepIndex, ctx));
@@ -448,9 +448,9 @@ class TaskEngine extends ContextualLoggedClass_1.AbsContextual {
         // eslint-disable-next-line @typescript-eslint/no-this-alias
         const engine = this;
         let logPipeQueue = Promise.resolve();
-        const taskCtx = new TaskContext_1.TaskContext(ctx).accumulate({
+        const taskCtx = new TaskContext_js_1.TaskContext(ctx).accumulate({
             taskId: task.id,
-            logger: new logging_2.TaskLogger(log, this.config.streamBufferSize, this.config.maxLoggingBuffer),
+            logger: new logging_js_1.TaskLogger(log, this.config.streamBufferSize, this.config.maxLoggingBuffer),
             attempt: task.attempt,
             resultCache: { "task.attempt": task.attempt },
             pipe: async function (...args) {
@@ -485,12 +485,12 @@ class TaskEngine extends ContextualLoggedClass_1.AbsContextual {
                 }
             },
         });
-        await this.emitStatus(taskCtx, task, constants_1.TaskStatus.RUNNING);
+        await this.emitStatus(taskCtx, task, constants_js_1.TaskStatus.RUNNING);
         let activeHandler;
         let activeInput;
         try {
             let output;
-            if (task.atomicity === constants_1.TaskType.COMPOSITE) {
+            if (task.atomicity === constants_js_1.TaskType.COMPOSITE) {
                 output = await this.runComposite(task, taskCtx);
                 try {
                     const latest = await this.tasks.read(task.id, taskCtx);
@@ -517,7 +517,7 @@ class TaskEngine extends ContextualLoggedClass_1.AbsContextual {
                 await taskCtx.flush();
                 log.verbose(`handler finished for ${task.id}`);
             }
-            task.status = constants_1.TaskStatus.SUCCEEDED;
+            task.status = constants_js_1.TaskStatus.SUCCEEDED;
             task.output = output;
             task.error = undefined;
             task.leaseOwner = undefined;
@@ -526,7 +526,7 @@ class TaskEngine extends ContextualLoggedClass_1.AbsContextual {
             Object.assign(task, persisted);
             taskCtx.logger.info(`task ${task.id} success state ${task.status}`);
             log.info(`task ${task.id} success state ${task.status} attempt ${task.attempt}`);
-            await this.emitStatus(taskCtx, task, constants_1.TaskStatus.SUCCEEDED, output);
+            await this.emitStatus(taskCtx, task, constants_js_1.TaskStatus.SUCCEEDED, output);
         }
         catch (err) {
             // Ensure buffered handler logs are persisted before we emit any engine-generated logs/events.
@@ -544,7 +544,7 @@ class TaskEngine extends ContextualLoggedClass_1.AbsContextual {
             catch {
                 // keep best-effort task state for retries/failures
             }
-            if (err instanceof TaskStateChangeError_1.TaskStateChangeError) {
+            if (err instanceof TaskStateChangeError_js_1.TaskStateChangeError) {
                 await this.handleTaskStateChange(err.request, task, taskCtx);
                 return;
             }
@@ -555,22 +555,22 @@ class TaskEngine extends ContextualLoggedClass_1.AbsContextual {
                 log.error("task handler catch() hook failed", catchErr);
             }
             log.error("task execution error", err);
-            if (task.atomicity === constants_1.TaskType.COMPOSITE) {
+            if (task.atomicity === constants_js_1.TaskType.COMPOSITE) {
                 const normalizedResults = this.normalizeStepResults(task.stepResults);
                 task.stepResults = normalizedResults;
                 if (task.currentStep == null) {
-                    const failedIdx = normalizedResults.findIndex((step) => step.status === constants_1.TaskStatus.FAILED);
+                    const failedIdx = normalizedResults.findIndex((step) => step.status === constants_js_1.TaskStatus.FAILED);
                     if (failedIdx >= 0)
                         task.currentStep = failedIdx;
                 }
             }
             const nextAttempt = (task.attempt ?? 0) + 1;
-            const serialized = (0, utils_1.serializeError)(err);
+            const serialized = (0, utils_js_1.serializeError)(err);
             if (nextAttempt < task.maxAttempts) {
-                const delay = (0, utils_1.computeBackoffMs)(nextAttempt, this.normalizeBackoff(task.backoff));
+                const delay = (0, utils_js_1.computeBackoffMs)(nextAttempt, this.normalizeBackoff(task.backoff));
                 const nextRunAt = new Date(Date.now() + delay);
                 task.attempt = nextAttempt;
-                task.status = constants_1.TaskStatus.WAITING_RETRY;
+                task.status = constants_js_1.TaskStatus.WAITING_RETRY;
                 task.nextRunAt = nextRunAt;
                 task.error = serialized;
                 task.leaseOwner = undefined;
@@ -583,11 +583,11 @@ class TaskEngine extends ContextualLoggedClass_1.AbsContextual {
                     delayMs: delay,
                     attempt: nextAttempt,
                 });
-                await this.emitStatus(taskCtx, task, constants_1.TaskStatus.WAITING_RETRY, serialized, err);
+                await this.emitStatus(taskCtx, task, constants_js_1.TaskStatus.WAITING_RETRY, serialized, err);
             }
             else {
                 task.attempt = nextAttempt;
-                task.status = constants_1.TaskStatus.FAILED;
+                task.status = constants_js_1.TaskStatus.FAILED;
                 task.error = serialized;
                 task.leaseOwner = undefined;
                 task.leaseExpiry = undefined;
@@ -597,7 +597,7 @@ class TaskEngine extends ContextualLoggedClass_1.AbsContextual {
                 await taskCtx.pipe(logging_1.LogLevel.error, `Task failed (max attempts reached)`, {
                     maxAttempts: task.maxAttempts,
                 });
-                await this.emitStatus(taskCtx, task, constants_1.TaskStatus.FAILED, serialized, err);
+                await this.emitStatus(taskCtx, task, constants_js_1.TaskStatus.FAILED, serialized, err);
             }
         }
     }
@@ -605,38 +605,38 @@ class TaskEngine extends ContextualLoggedClass_1.AbsContextual {
         task.leaseOwner = undefined;
         task.leaseExpiry = undefined;
         switch (request.status) {
-            case constants_1.TaskStatus.CANCELED: {
+            case constants_js_1.TaskStatus.CANCELED: {
                 const cancelError = request.error ??
-                    new TaskErrorModel_1.TaskErrorModel({
+                    new TaskErrorModel_js_1.TaskErrorModel({
                         message: `Task ${task.id} canceled`,
                     });
-                task.status = constants_1.TaskStatus.CANCELED;
+                task.status = constants_js_1.TaskStatus.CANCELED;
                 task.error = cancelError;
                 task.nextRunAt = undefined;
                 task.scheduledTo = undefined;
                 task = await this.tasks.update(task, ctx);
-                await this.emitStatus(ctx, task, constants_1.TaskStatus.CANCELED, cancelError);
+                await this.emitStatus(ctx, task, constants_js_1.TaskStatus.CANCELED, cancelError);
                 await ctx.pipe(logging_1.LogLevel.warn, `Task canceled via context`);
                 return;
             }
-            case constants_1.TaskStatus.WAITING_RETRY: {
+            case constants_js_1.TaskStatus.WAITING_RETRY: {
                 const nextAttempt = (task.attempt ?? 0) + 1;
                 const backoff = this.normalizeBackoff(task.backoff);
-                const delay = (0, utils_1.computeBackoffMs)(nextAttempt, backoff);
+                const delay = (0, utils_js_1.computeBackoffMs)(nextAttempt, backoff);
                 const nextRunAt = request.scheduledTo instanceof Date
                     ? request.scheduledTo
                     : new Date(Date.now() + delay);
                 const retryError = request.error ??
-                    new TaskErrorModel_1.TaskErrorModel({
+                    new TaskErrorModel_js_1.TaskErrorModel({
                         message: `Task ${task.id} requested retry`,
                     });
-                task.status = constants_1.TaskStatus.WAITING_RETRY;
+                task.status = constants_js_1.TaskStatus.WAITING_RETRY;
                 task.attempt = nextAttempt;
                 task.error = retryError;
                 task.nextRunAt = nextRunAt;
                 task.scheduledTo = undefined;
                 task = await this.tasks.update(task, ctx);
-                await this.emitStatus(ctx, task, constants_1.TaskStatus.WAITING_RETRY, retryError);
+                await this.emitStatus(ctx, task, constants_js_1.TaskStatus.WAITING_RETRY, retryError);
                 await ctx.pipe(logging_1.LogLevel.warn, `Retry requested`, {
                     nextRunAt,
                     delayMs: delay,
@@ -644,19 +644,19 @@ class TaskEngine extends ContextualLoggedClass_1.AbsContextual {
                 });
                 return;
             }
-            case constants_1.TaskStatus.SCHEDULED: {
+            case constants_js_1.TaskStatus.SCHEDULED: {
                 if (!request.scheduledTo)
                     throw new db_decorators_1.InternalError("Scheduled state requires a target date");
                 const rescheduleError = request.error ??
-                    new TaskErrorModel_1.TaskErrorModel({
+                    new TaskErrorModel_js_1.TaskErrorModel({
                         message: `Task ${task.id} rescheduled`,
                     });
-                task.status = constants_1.TaskStatus.SCHEDULED;
+                task.status = constants_js_1.TaskStatus.SCHEDULED;
                 task.scheduledTo = request.scheduledTo;
                 task.error = rescheduleError;
                 task.nextRunAt = undefined;
                 task = await this.tasks.update(task, ctx);
-                await this.emitStatus(ctx, task, constants_1.TaskStatus.SCHEDULED, rescheduleError);
+                await this.emitStatus(ctx, task, constants_js_1.TaskStatus.SCHEDULED, rescheduleError);
                 await ctx.pipe(logging_1.LogLevel.info, `Task rescheduled`, {
                     scheduledTo: request.scheduledTo.toISOString(),
                 });
@@ -673,13 +673,13 @@ class TaskEngine extends ContextualLoggedClass_1.AbsContextual {
         const results = this.normalizeStepResults(task.stepResults);
         const cacheResult = (key, value) => {
             context.cacheResult(key, value);
-            if (ctx instanceof TaskContext_1.TaskContext && ctx !== context) {
+            if (ctx instanceof TaskContext_js_1.TaskContext && ctx !== context) {
                 ctx.cacheResult(key, value);
             }
         };
         for (let i = 0; i < results.length; i += 1) {
             const existing = results[i];
-            if (existing?.status === constants_1.TaskStatus.SUCCEEDED) {
+            if (existing?.status === constants_js_1.TaskStatus.SUCCEEDED) {
                 const prevStep = steps[i];
                 if (!prevStep)
                     continue;
@@ -722,7 +722,7 @@ class TaskEngine extends ContextualLoggedClass_1.AbsContextual {
                 const persisted = await this.tasks.update(task, context);
                 Object.assign(task, persisted);
                 steps = this.normalizeSteps(task.steps);
-                const updateEvent = await this.persistEvent(context, task.id, constants_1.TaskEventType.UPDATE, {
+                const updateEvent = await this.persistEvent(context, task.id, constants_js_1.TaskEventType.UPDATE, {
                     status: "update",
                     currentStep: stepIndex,
                     totalSteps: steps.length,
@@ -742,8 +742,8 @@ class TaskEngine extends ContextualLoggedClass_1.AbsContextual {
                 // Ensure step-tagged logs are flushed before advancing the step pointer.
                 await context.flush();
                 const now = new Date();
-                results[stepIndex] = new TaskStepResultModel_1.TaskStepResultModel({
-                    status: constants_1.TaskStatus.SUCCEEDED,
+                results[stepIndex] = new TaskStepResultModel_js_1.TaskStepResultModel({
+                    status: constants_js_1.TaskStatus.SUCCEEDED,
                     output: out,
                     createdAt: now,
                     updatedAt: now,
@@ -772,15 +772,15 @@ class TaskEngine extends ContextualLoggedClass_1.AbsContextual {
                     });
                 }
                 const now = new Date();
-                results[idx] = new TaskStepResultModel_1.TaskStepResultModel({
-                    status: constants_1.TaskStatus.FAILED,
-                    error: (0, utils_1.serializeError)(err),
+                results[idx] = new TaskStepResultModel_js_1.TaskStepResultModel({
+                    status: constants_js_1.TaskStatus.FAILED,
+                    error: (0, utils_js_1.serializeError)(err),
                     createdAt: now,
                     updatedAt: now,
                 });
                 task.stepResults = results;
                 task.currentStep = idx;
-                task.error = (0, utils_1.serializeError)(err);
+                task.error = (0, utils_js_1.serializeError)(err);
                 // persist failure context before throwing (retry logic happens outside)
                 const persisted = await this.tasks.update(task);
                 Object.assign(task, persisted);
@@ -790,7 +790,7 @@ class TaskEngine extends ContextualLoggedClass_1.AbsContextual {
         return { stepResults: results };
     }
     normalizeBackoff(backoff) {
-        if (backoff instanceof TaskBackoffModel_1.TaskBackoffModel)
+        if (backoff instanceof TaskBackoffModel_js_1.TaskBackoffModel)
             return backoff;
         let payload = backoff ?? {};
         if (typeof payload === "string") {
@@ -801,7 +801,7 @@ class TaskEngine extends ContextualLoggedClass_1.AbsContextual {
                 payload = {};
             }
         }
-        return new TaskBackoffModel_1.TaskBackoffModel(payload);
+        return new TaskBackoffModel_js_1.TaskBackoffModel(payload);
     }
     normalizeSteps(steps) {
         if (!steps)
@@ -820,7 +820,7 @@ class TaskEngine extends ContextualLoggedClass_1.AbsContextual {
         if (!Array.isArray(payload))
             return [];
         return payload.map((step) => {
-            if (step instanceof TaskStepSpecModel_1.TaskStepSpecModel)
+            if (step instanceof TaskStepSpecModel_js_1.TaskStepSpecModel)
                 return step;
             let value = step;
             if (typeof value === "string") {
@@ -831,7 +831,7 @@ class TaskEngine extends ContextualLoggedClass_1.AbsContextual {
                     value = {};
                 }
             }
-            return new TaskStepSpecModel_1.TaskStepSpecModel(value);
+            return new TaskStepSpecModel_js_1.TaskStepSpecModel(value);
         });
     }
     normalizeStepResults(results) {
@@ -851,7 +851,7 @@ class TaskEngine extends ContextualLoggedClass_1.AbsContextual {
         if (!Array.isArray(payload))
             return [];
         return payload.map((result) => {
-            if (result instanceof TaskStepResultModel_1.TaskStepResultModel)
+            if (result instanceof TaskStepResultModel_js_1.TaskStepResultModel)
                 return result;
             let value = result;
             if (typeof value === "string") {
@@ -862,7 +862,7 @@ class TaskEngine extends ContextualLoggedClass_1.AbsContextual {
                     value = {};
                 }
             }
-            return new TaskStepResultModel_1.TaskStepResultModel(value);
+            return new TaskStepResultModel_js_1.TaskStepResultModel(value);
         });
     }
     // -------------------------
@@ -870,13 +870,13 @@ class TaskEngine extends ContextualLoggedClass_1.AbsContextual {
     // -------------------------
     async appendLog(ctx, task, logEntries) {
         const isMulti = Array.isArray(logEntries) && Array.isArray(logEntries[0]);
-        const step = task.atomicity === constants_1.TaskType.COMPOSITE
-            ? ctx instanceof TaskContext_1.TaskContext
+        const step = task.atomicity === constants_js_1.TaskType.COMPOSITE
+            ? ctx instanceof TaskContext_js_1.TaskContext
                 ? (ctx.step ?? task.currentStep)
                 : task.currentStep
             : undefined;
         const entries = (isMulti ? logEntries : [logEntries]).map(([level, msg, meta]) => {
-            return new TaskLogEntryModel_1.TaskLogEntryModel({
+            return new TaskLogEntryModel_js_1.TaskLogEntryModel({
                 level,
                 msg,
                 meta,
@@ -893,11 +893,11 @@ class TaskEngine extends ContextualLoggedClass_1.AbsContextual {
         }
     }
     async emitStatus(ctx, task, status, outputOrError, originalError) {
-        if (ctx instanceof TaskContext_1.TaskContext) {
+        if (ctx instanceof TaskContext_js_1.TaskContext) {
             await ctx.flush();
         }
         const payload = { status };
-        if (outputOrError && outputOrError instanceof TaskErrorModel_1.TaskErrorModel)
+        if (outputOrError && outputOrError instanceof TaskErrorModel_js_1.TaskErrorModel)
             payload.error = outputOrError;
         else if (outputOrError)
             payload.output = outputOrError;
@@ -905,18 +905,18 @@ class TaskEngine extends ContextualLoggedClass_1.AbsContextual {
             payload.nextRunAt = task.nextRunAt;
         if (task.scheduledTo)
             payload.scheduledTo = task.scheduledTo;
-        const persisted = await this.persistEvent(ctx, task.id, constants_1.TaskEventType.STATUS, payload);
+        const persisted = await this.persistEvent(ctx, task.id, constants_js_1.TaskEventType.STATUS, payload);
         const emittedPayload = originalError !== undefined
             ? Object.assign({}, payload, { originalError })
             : payload;
-        const emitted = new TaskEventModel_1.TaskEventModel({
+        const emitted = new TaskEventModel_js_1.TaskEventModel({
             ...persisted,
             payload: emittedPayload,
         });
         this.bus.emit(emitted, ctx);
     }
     async emitLog(ctx, taskId, entries) {
-        const evt = await this.persistEvent(ctx, taskId, constants_1.TaskEventType.LOG, entries.map((e) => ({
+        const evt = await this.persistEvent(ctx, taskId, constants_js_1.TaskEventType.LOG, entries.map((e) => ({
             ts: e.ts,
             level: e.level,
             msg: e.msg,
@@ -946,11 +946,11 @@ class TaskEngine extends ContextualLoggedClass_1.AbsContextual {
         return [[level, msg, meta]];
     }
     async emitProgress(ctx, taskId, data) {
-        const evt = await this.persistEvent(ctx, taskId, constants_1.TaskEventType.PROGRESS, data);
+        const evt = await this.persistEvent(ctx, taskId, constants_js_1.TaskEventType.PROGRESS, data);
         this.bus.emit(evt, ctx);
     }
     async persistEvent(ctx, taskId, type, payload) {
-        const evt = new TaskEventModel_1.TaskEventModel({ taskId, classification: type, payload });
+        const evt = new TaskEventModel_js_1.TaskEventModel({ taskId, classification: type, payload });
         const created = await this.events.create(evt, ctx);
         return created;
     }
@@ -958,8 +958,9 @@ class TaskEngine extends ContextualLoggedClass_1.AbsContextual {
         return `TaskEngine<${this.config.adapter.alias}>`;
     }
     async context(operation, overrides, ...args) {
-        return this.adapter.context(operation, overrides, TaskModel_1.TaskModel, ...args);
+        return this.adapter.context(operation, overrides, TaskModel_js_1.TaskModel, ...args);
     }
 }
 exports.TaskEngine = TaskEngine;
+//# sourceMappingURL=TaskEngine.js.map
 //# sourceMappingURL=TaskEngine.js.map