nvent 0.4.5 → 0.5.1

package/dist/runtime/adapters/base/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Adapter base utilities
+ * Exported for use by external adapter packages
+ */
+export { StoreValidator, createStoreValidator } from './store-validator.js';
+export type { StoreValidatorOptions } from './store-validator.js';

package/dist/runtime/adapters/base/index.js

@@ -0,0 +1 @@
+export { StoreValidator, createStoreValidator } from "./store-validator.js";

package/dist/runtime/adapters/base/store-validator.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Store Adapter Validation
+ *
+ * Centralized validation logic for index updates to ensure correct usage
+ * across all store adapter implementations.
+ */
+export interface StoreValidatorOptions {
+    /** Adapter name for error messages */
+    adapterName: string;
+    /** Enable counter misuse warnings (default: true in development) */
+    warnCounters?: boolean;
+    /** Throw errors on validation failures (default: true) */
+    throwOnError?: boolean;
+}
+export declare class StoreValidator {
+    private readonly adapterName;
+    private readonly warnCounters;
+    private readonly throwOnError;
+    constructor(options: StoreValidatorOptions);
+    /**
+     * Validate index update payload
+     * Throws error if dot notation keys are detected (except 'version')
+     * Recursively checks all nested objects
+     */
+    validateUpdatePayload(payload: Record<string, any>, method: string): void;
+    /**
+     * Recursively check for dot notation in object keys
+     */
+    private checkDotNotationKeys;
+    /**
+     * Build a nested object suggestion from a dot notation key
+     */
+    private buildNestedObjectSuggestion;
+    /**
+     * Detect potential counter misuse
+     * Logs warnings when numeric fields that look like counters are updated
+     * via update() instead of increment()
+     */
+    private detectCounterMisuse;
+    /**
+     * Check if a field looks like a counter that should use increment()
+     */
+    private isCounterField;
+}
+/**
+ * Factory function to create a validator for an adapter
+ */
+export declare function createStoreValidator(adapterName: string, options?: Partial<StoreValidatorOptions>): StoreValidator;

package/dist/runtime/adapters/base/store-validator.js

@@ -0,0 +1,147 @@
+export class StoreValidator {
+  adapterName;
+  warnCounters;
+  throwOnError;
+  constructor(options) {
+    this.adapterName = options.adapterName;
+    this.warnCounters = options.warnCounters ?? process.env.NODE_ENV === "development";
+    this.throwOnError = options.throwOnError ?? true;
+  }
+  /**
+   * Validate index update payload
+   * Throws error if dot notation keys are detected (except 'version')
+   * Recursively checks all nested objects
+   */
+  validateUpdatePayload(payload, method) {
+    this.checkDotNotationKeys(payload, method, []);
+    if (this.warnCounters) {
+      this.detectCounterMisuse(payload, method);
+    }
+  }
+  /**
+   * Recursively check for dot notation in object keys
+   */
+  checkDotNotationKeys(obj, method, path) {
+    for (const key of Object.keys(obj)) {
+      const currentPath = [...path, key];
+      if (key.includes(".") && key !== "version") {
+        const fullPath = currentPath.join(".");
+        const suggestion = this.buildNestedObjectSuggestion(key);
+        const message = [
+          `[${this.adapterName}] Invalid update payload in ${method}:`,
+          `Dot notation key "${key}" detected at path "${fullPath}".`,
+          `Keys should not contain dots. Split "${key}" into nested objects: ${suggestion}`
+        ].join("\n");
+        console.error(message);
+        if (this.throwOnError) {
+          throw new Error(
+            `Invalid index update: dot notation keys not supported. Key "${key}" at path "${fullPath}" contains dots.`
+          );
+        }
+      }
+      const value = obj[key];
+      if (value && typeof value === "object" && !Array.isArray(value)) {
+        this.checkDotNotationKeys(value, method, currentPath);
+      }
+    }
+  }
+  /**
+   * Build a nested object suggestion from a dot notation key
+   */
+  buildNestedObjectSuggestion(dotKey) {
+    const parts = dotKey.split(".");
+    let suggestion = "{ ";
+    for (let i = 0; i < parts.length - 1; i++) {
+      suggestion += `${parts[i]}: { `;
+    }
+    suggestion += `${parts[parts.length - 1]}: value `;
+    for (let i = 0; i < parts.length - 1; i++) {
+      suggestion += "}";
+    }
+    suggestion += " }";
+    return suggestion;
+  }
+  /**
+   * Detect potential counter misuse
+   * Logs warnings when numeric fields that look like counters are updated
+   * via update() instead of increment()
+   */
+  detectCounterMisuse(payload, method) {
+    const checkNested = (obj, path = []) => {
+      for (const [key, value] of Object.entries(obj)) {
+        const currentPath = [...path, key];
+        if (this.isCounterField(key, value, currentPath)) {
+          console.warn(
+            `[${this.adapterName}] Potential counter misuse in ${method}:`,
+            `Field "${currentPath.join(".")}" is numeric.`,
+            `Consider using index.increment() for atomic updates instead of ${method}.`
+          );
+        }
+        if (value && typeof value === "object" && !Array.isArray(value)) {
+          checkNested(value, currentPath);
+        }
+      }
+    };
+    checkNested(payload);
+  }
+  /**
+   * Check if a field looks like a counter that should use increment()
+   */
+  isCounterField(key, value, path) {
+    if (typeof value !== "number") {
+      return false;
+    }
+    if (path.includes("emittedEvents")) {
+      return false;
+    }
+    const metadataFields = [
+      "stepCount",
+      // Total steps in flow (constant)
+      "timeout",
+      // Timeout duration
+      "delay",
+      // Delay duration
+      "timestamp",
+      // Timestamp values
+      "score",
+      // Score values
+      "priority",
+      // Priority values
+      "version"
+      // Version field
+    ];
+    if (metadataFields.includes(key)) {
+      return false;
+    }
+    if (key.endsWith("At")) {
+      return false;
+    }
+    const counterKeywords = [
+      "count",
+      "total",
+      "running",
+      "awaiting",
+      "success",
+      "failure",
+      "cancel",
+      "pending",
+      "completed",
+      "failed",
+      "retries",
+      "attempts"
+    ];
+    if (counterKeywords.some((keyword) => key.toLowerCase().includes(keyword))) {
+      return true;
+    }
+    if (path.includes("stats")) {
+      return true;
+    }
+    return false;
+  }
+}
+export function createStoreValidator(adapterName, options) {
+  return new StoreValidator({
+    adapterName,
+    ...options
+  });
+}

package/dist/runtime/adapters/builtin/file-queue.d.ts

@@ -8,7 +8,7 @@
  * - Single instance only (no distributed lock)
  *
  * Storage format:
- * - {dataDir}/queues/{queueName}/jobs/{jobId}.json - Individual job files
+ * - {dataDir}/{queueName}/jobs/{jobId}.json - Individual job files
  * - Jobs are loaded on init and kept in memory with fastq
  */
 import type { QueueAdapter, JobInput, Job, JobsQuery, ScheduleOptions, JobCounts, QueueEvent, WorkerHandler, WorkerOptions } from '../interfaces/queue.js';
@@ -48,6 +48,20 @@ export declare class FileQueueAdapter implements QueueAdapter {
     startProcessingQueue(queueName: string): void;
     private updateJobState;
     private emitEvent;
+    /**
+     * Clean up completed jobs based on removeOnComplete option
+     * - true: delete immediately
+     * - false/undefined: keep forever
+     * - number: keep last N jobs, delete older ones
+     */
+    private cleanupCompletedJobs;
+    /**
+     * Clean up failed jobs based on removeOnFail option
+     * - true: delete immediately
+     * - false/undefined: keep forever
+     * - number: keep last N jobs, delete older ones
+     */
+    private cleanupFailedJobs;
     private generateId;
     private scheduleCronJob;
 }

package/dist/runtime/adapters/builtin/file-queue.js

@@ -17,12 +17,12 @@ export class FileQueueAdapter {
   }
   async init() {
     if (this.initialized) return;
-    await fs.mkdir(join(this.options.dataDir, "queues"), { recursive: true });
+    await fs.mkdir(this.options.dataDir, { recursive: true });
     await this.loadJobsFromDisk();
     this.initialized = true;
   }
   async loadJobsFromDisk() {
-    const queuesDir = join(this.options.dataDir, "queues");
+    const queuesDir = this.options.dataDir;
     try {
       const queueNames = await fs.readdir(queuesDir);
       for (const queueName of queueNames) {
@@ -43,13 +43,13 @@ export class FileQueueAdapter {
     }
   }
   async persistJob(queueName, job) {
-    const jobsDir = join(this.options.dataDir, "queues", queueName, "jobs");
+    const jobsDir = join(this.options.dataDir, queueName, "jobs");
     await fs.mkdir(jobsDir, { recursive: true });
     const jobPath = join(jobsDir, `${job.id}.json`);
     await fs.writeFile(jobPath, JSON.stringify(job, null, 2));
   }
   async deleteJobFile(queueName, jobId) {
-    const jobPath = join(this.options.dataDir, "queues", queueName, "jobs", `${jobId}.json`);
+    const jobPath = join(this.options.dataDir, queueName, "jobs", `${jobId}.json`);
     try {
       await fs.unlink(jobPath);
     } catch {
@@ -78,7 +78,7 @@ export class FileQueueAdapter {
     this.emitEvent(queueName, "waiting", { jobId, job: internalJob });
     const workerInfo = this.workers.get(queueName);
     if (workerInfo && !workerInfo.paused) {
-      workerInfo.queue.push({ jobId, jobName: job.name, data: job.data }).catch(() => {
+      workerInfo.queue.push({ jobId, jobName: job.name, data: internalJob.data }).catch(() => {
       });
     }
     return jobId;
@@ -285,12 +285,17 @@ export class FileQueueAdapter {
           opts: { attempts: maxAttempts, ...storedJob.opts }
         };
         const result = await handler2(jobLike, {});
+        if (result && typeof result === "object" && result.awaiting === true) {
+          this.jobs.delete(task.jobId);
+          await this.deleteJobFile(queueName, task.jobId);
+          return result;
+        }
         await this.updateJobState(queueName, task.jobId, "completed", {
           returnvalue: result,
           finishedOn: Date.now()
         });
         this.emitEvent(queueName, "completed", { jobId: task.jobId, returnvalue: result });
-        await this.deleteJobFile(queueName, task.jobId);
+        await this.cleanupCompletedJobs(queueName, storedJob.opts?.removeOnComplete);
         return result;
       } catch (err) {
         const newAttemptCount = currentAttempts + 1;
@@ -331,6 +336,7 @@ export class FileQueueAdapter {
           attemptsMade: newAttemptCount,
           maxAttempts
         });
+        await this.cleanupFailedJobs(queueName, storedJob.opts?.removeOnFail);
         throw err;
       }
     };
@@ -388,6 +394,64 @@ export class FileQueueAdapter {
       }
     }
   }
+  /**
+   * Clean up completed jobs based on removeOnComplete option
+   * - true: delete immediately
+   * - false/undefined: keep forever
+   * - number: keep last N jobs, delete older ones
+   */
+  async cleanupCompletedJobs(queueName, removeOnComplete) {
+    if (removeOnComplete === false || removeOnComplete === void 0) {
+      return;
+    }
+    if (removeOnComplete === true) {
+      const completedJobs = Array.from(this.jobs.values()).filter(
+        (j) => j.state === "completed" && j.data?.__queueName === queueName
+      );
+      for (const job of completedJobs) {
+        this.jobs.delete(job.id);
+        await this.deleteJobFile(queueName, job.id);
+      }
+      return;
+    }
+    if (typeof removeOnComplete === "number") {
+      const completedJobs = Array.from(this.jobs.values()).filter((j) => j.state === "completed" && j.data?.__queueName === queueName).sort((a, b) => (b.finishedOn || 0) - (a.finishedOn || 0));
+      const jobsToDelete = completedJobs.slice(removeOnComplete);
+      for (const job of jobsToDelete) {
+        this.jobs.delete(job.id);
+        await this.deleteJobFile(queueName, job.id);
+      }
+    }
+  }
+  /**
+   * Clean up failed jobs based on removeOnFail option
+   * - true: delete immediately
+   * - false/undefined: keep forever
+   * - number: keep last N jobs, delete older ones
+   */
+  async cleanupFailedJobs(queueName, removeOnFail) {
+    if (removeOnFail === false || removeOnFail === void 0) {
+      return;
+    }
+    if (removeOnFail === true) {
+      const failedJobs = Array.from(this.jobs.values()).filter(
+        (j) => j.state === "failed" && j.data?.__queueName === queueName
+      );
+      for (const job of failedJobs) {
+        this.jobs.delete(job.id);
+        await this.deleteJobFile(queueName, job.id);
+      }
+      return;
+    }
+    if (typeof removeOnFail === "number") {
+      const failedJobs = Array.from(this.jobs.values()).filter((j) => j.state === "failed" && j.data?.__queueName === queueName).sort((a, b) => (b.finishedOn || 0) - (a.finishedOn || 0));
+      const jobsToDelete = failedJobs.slice(removeOnFail);
+      for (const job of jobsToDelete) {
+        this.jobs.delete(job.id);
+        await this.deleteJobFile(queueName, job.id);
+      }
+    }
+  }
   generateId() {
     return `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
   }

package/dist/runtime/adapters/builtin/file-store.d.ts

@@ -7,14 +7,13 @@
  * - Survives restarts
  * - Single instance only
  *
- * Storage format (matches existing file adapter):
- * - {dataDir}/{subject}.ndjson - Event streams (append-only NDJSON)
+ * Storage format:
+ * - {dataDir}/streams/{subject}.ndjson - Event streams (append-only NDJSON)
  * - {dataDir}/indices/{key}.json - Sorted indices (JSON arrays)
- * - {dataDir}/docs/{collection}/{id}.json - Documents (individual JSON files)
  * - {dataDir}/kv/{key}.json - KV store (individual JSON files)
  */
-import { MemoryStoreAdapter, type MemoryStoreAdapterOptions } from './memory-store.js';
-export interface FileStoreAdapterOptions extends MemoryStoreAdapterOptions {
+import { MemoryStoreAdapter } from './memory-store.js';
+export interface FileStoreAdapterOptions {
     dataDir: string;
 }
 /**
@@ -23,24 +22,11 @@ export interface FileStoreAdapterOptions extends MemoryStoreAdapterOptions {
  */
 export declare class FileStoreAdapter extends MemoryStoreAdapter {
     private options;
-    private parentKvGet;
-    private parentKvSet;
-    private parentKvDelete;
-    private parentKvClear;
-    private parentKvIncrement;
     constructor(options: FileStoreAdapterOptions);
     private streamPath;
     private indexPath;
-    private docPath;
     private kvPath;
     init(): Promise<void>;
     private loadFromDisk;
-    append(subject: string, event: Omit<import('../interfaces/store').EventRecord, 'id' | 'ts'>): Promise<import("..").EventRecord>;
-    save(collection: string, id: string, doc: Record<string, any>): Promise<void>;
-    delete(collection: string, id: string): Promise<void>;
-    indexAdd(key: string, id: string, score: number, metadata?: Record<string, any>): Promise<void>;
-    indexUpdate(key: string, id: string, metadata: Record<string, any>): Promise<boolean>;
-    indexUpdateWithRetry(key: string, id: string, metadata: Record<string, any>, maxRetries?: number): Promise<void>;
-    indexIncrement(key: string, id: string, field: string, increment?: number): Promise<number>;
     close(): Promise<void>;
 }

package/dist/runtime/adapters/builtin/file-store.js

@@ -12,32 +12,22 @@ async function ensureDir(path) {
 }
 export class FileStoreAdapter extends MemoryStoreAdapter {
   options;
-  parentKvGet;
-  parentKvSet;
-  parentKvDelete;
-  parentKvClear;
-  parentKvIncrement;
   constructor(options) {
-    super(options);
+    super();
     this.options = options;
-    const tempKv = this.kv;
-    this.parentKvGet = tempKv.get;
-    this.parentKvSet = tempKv.set;
-    this.parentKvDelete = tempKv.delete;
-    this.parentKvClear = tempKv.clear;
-    this.parentKvIncrement = tempKv.increment;
+    const parentKv = this.kv;
+    const parentStream = this.stream;
+    const parentIndex = this.index;
     this.kv = {
-      get: async (key) => {
-        return this.parentKvGet(key);
-      },
+      get: parentKv.get,
       set: async (key, value, ttl) => {
-        await this.parentKvSet(key, value, ttl);
+        await parentKv.set(key, value, ttl);
         const path = this.kvPath(key);
         await ensureDir(dirname(path));
         await fs.writeFile(path, JSON.stringify(value), "utf-8");
       },
       delete: async (key) => {
-        await this.parentKvDelete(key);
+        await parentKv.delete(key);
         const path = this.kvPath(key);
         try {
           await fs.unlink(path);
@@ -45,7 +35,7 @@ export class FileStoreAdapter extends MemoryStoreAdapter {
         }
       },
       clear: async (pattern) => {
-        const count = await this.parentKvClear(pattern);
+        const count = await parentKv.clear(pattern);
         try {
           const kvDir = join(this.options.dataDir, "kv");
           const files = await fs.readdir(kvDir);
@@ -62,13 +52,94 @@ export class FileStoreAdapter extends MemoryStoreAdapter {
         return count;
       },
       increment: async (key, by = 1) => {
-        const result = await this.parentKvIncrement(key, by);
+        const result = await parentKv.increment(key, by);
         const path = this.kvPath(key);
         await ensureDir(dirname(path));
         await fs.writeFile(path, JSON.stringify(result), "utf-8");
         return result;
       }
     };
+    this.stream = {
+      append: async (subject, event) => {
+        const result = await parentStream.append(subject, event);
+        const path = this.streamPath(subject);
+        await ensureDir(dirname(path));
+        await fs.appendFile(path, JSON.stringify(result) + "\n", "utf-8");
+        return result;
+      },
+      read: parentStream.read,
+      subscribe: parentStream.subscribe,
+      delete: async (subject) => {
+        const deleted = parentStream.delete ? await parentStream.delete(subject) : false;
+        if (deleted) {
+          const path = this.streamPath(subject);
+          try {
+            await fs.unlink(path);
+          } catch {
+          }
+        }
+        return deleted;
+      }
+    };
+    this.index = {
+      add: async (key, id, score, metadata) => {
+        await parentIndex.add(key, id, score, metadata);
+        const self = this;
+        const index = self.sortedIndices?.get(key);
+        if (index) {
+          const path = this.indexPath(key);
+          await ensureDir(dirname(path));
+          await fs.writeFile(path, JSON.stringify(index, null, 2), "utf-8");
+        }
+      },
+      get: parentIndex.get,
+      read: parentIndex.read,
+      update: async (key, id, metadata) => {
+        const result = await parentIndex.update(key, id, metadata);
+        const self = this;
+        const index = self.sortedIndices?.get(key);
+        if (index) {
+          const path = this.indexPath(key);
+          await ensureDir(dirname(path));
+          await fs.writeFile(path, JSON.stringify(index, null, 2), "utf-8");
+        }
+        return result;
+      },
+      updateWithRetry: async (key, id, metadata, maxRetries) => {
+        await parentIndex.updateWithRetry(key, id, metadata, maxRetries);
+        const self = this;
+        const index = self.sortedIndices?.get(key);
+        if (index) {
+          const path = this.indexPath(key);
+          await ensureDir(dirname(path));
+          await fs.writeFile(path, JSON.stringify(index, null, 2), "utf-8");
+        }
+      },
+      increment: async (key, id, field, increment) => {
+        const result = await parentIndex.increment(key, id, field, increment);
+        const self = this;
+        const index = self.sortedIndices?.get(key);
+        if (index) {
+          const path = this.indexPath(key);
+          await ensureDir(dirname(path));
+          await fs.writeFile(path, JSON.stringify(index, null, 2), "utf-8");
+        }
+        return result;
+      },
+      delete: async (key, id) => {
+        const deleted = await parentIndex.delete(key, id);
+        if (deleted) {
+          const self = this;
+          const index = self.sortedIndices?.get(key);
+          if (index) {
+            const path = this.indexPath(key);
+            await ensureDir(dirname(path));
+            await fs.writeFile(path, JSON.stringify(index, null, 2), "utf-8");
+          }
+        }
+        return deleted;
+      }
+    };
   }
   streamPath(subject) {
     return join(this.options.dataDir, "streams", sanitize(subject) + ".ndjson");
@@ -76,9 +147,6 @@ export class FileStoreAdapter extends MemoryStoreAdapter {
   indexPath(key) {
     return join(this.options.dataDir, "indices", sanitize(key) + ".json");
   }
-  docPath(collection, id) {
-    return join(this.options.dataDir, "docs", collection, `${id}.json`);
-  }
   kvPath(key) {
     return join(this.options.dataDir, "kv", `${sanitize(key)}.json`);
   }
@@ -86,7 +154,6 @@ export class FileStoreAdapter extends MemoryStoreAdapter {
     await ensureDir(this.options.dataDir);
     await ensureDir(join(this.options.dataDir, "streams"));
     await ensureDir(join(this.options.dataDir, "indices"));
-    await ensureDir(join(this.options.dataDir, "docs"));
     await ensureDir(join(this.options.dataDir, "kv"));
     await this.loadFromDisk();
   }
@@ -119,27 +186,6 @@ export class FileStoreAdapter extends MemoryStoreAdapter {
       }
     } catch {
     }
-    try {
-      const docsDir = join(this.options.dataDir, "docs");
-      const collections = await fs.readdir(docsDir);
-      for (const collection of collections) {
-        const collectionDir = join(docsDir, collection);
-        const docFiles = await fs.readdir(collectionDir);
-        if (!self.documents) self.documents = /* @__PURE__ */ new Map();
-        if (!self.documents.has(collection)) {
-          self.documents.set(collection, /* @__PURE__ */ new Map());
-        }
-        const collectionMap = self.documents.get(collection);
-        for (const file of docFiles) {
-          if (!file.endsWith(".json")) continue;
-          const id = file.replace(".json", "");
-          const content = await fs.readFile(join(collectionDir, file), "utf-8");
-          const doc = JSON.parse(content);
-          collectionMap.set(id, doc);
-        }
-      }
-    } catch {
-    }
     try {
       const kvDir = join(this.options.dataDir, "kv");
       const kvFiles = await fs.readdir(kvDir);
@@ -154,71 +200,6 @@ export class FileStoreAdapter extends MemoryStoreAdapter {
     } catch {
     }
   }
-  // Override methods to add persistence
-  async append(subject, event) {
-    const result = await super.append(subject, event);
-    const path = this.streamPath(subject);
-    await ensureDir(dirname(path));
-    await fs.appendFile(path, JSON.stringify(result) + "\n", "utf-8");
-    return result;
-  }
-  async save(collection, id, doc) {
-    await super.save(collection, id, doc);
-    const path = this.docPath(collection, id);
-    await ensureDir(dirname(path));
-    await fs.writeFile(path, JSON.stringify(doc, null, 2), "utf-8");
-  }
-  async delete(collection, id) {
-    await super.delete(collection, id);
-    const path = this.docPath(collection, id);
-    try {
-      await fs.unlink(path);
-    } catch {
-    }
-  }
-  // Override index operations
-  async indexAdd(key, id, score, metadata) {
-    await super.indexAdd(key, id, score, metadata);
-    const self = this;
-    const index = self.sortedIndices?.get(key);
-    if (index) {
-      const path = this.indexPath(key);
-      await ensureDir(dirname(path));
-      await fs.writeFile(path, JSON.stringify(index, null, 2), "utf-8");
-    }
-  }
-  async indexUpdate(key, id, metadata) {
-    const result = await super.indexUpdate(key, id, metadata);
-    const self = this;
-    const index = self.sortedIndices?.get(key);
-    if (index) {
-      const path = this.indexPath(key);
-      await ensureDir(dirname(path));
-      await fs.writeFile(path, JSON.stringify(index, null, 2), "utf-8");
-    }
-    return result;
-  }
-  async indexUpdateWithRetry(key, id, metadata, maxRetries) {
-    await super.indexUpdateWithRetry(key, id, metadata, maxRetries);
-    const self = this;
-    const index = self.sortedIndices?.get(key);
-    if (index) {
-      const path = this.indexPath(key);
-      await ensureDir(dirname(path));
-      await fs.writeFile(path, JSON.stringify(index, null, 2), "utf-8");
-    }
-  }
-  async indexIncrement(key, id, field, increment) {
-    const result = await super.indexIncrement(key, id, field, increment);
-    const self = this;
-    const index = self.sortedIndices?.get(key);
-    if (index) {
-      const path = this.indexPath(key);
-      await ensureDir(dirname(path));
-      await fs.writeFile(path, JSON.stringify(index, null, 2), "utf-8");
-    }
-    return result;
-  }
   async close() {
     await super.close();
   }

package/dist/runtime/adapters/builtin/memory-queue.js

@@ -158,6 +158,10 @@ export class MemoryQueueAdapter {
           queueName
           // Add more context as needed
         });
+        if (result && typeof result === "object" && result.awaiting === true) {
+          this.jobs.delete(task.jobId);
+          return result;
+        }
         this.updateJobState(task.jobId, "completed", {
           returnvalue: result,
           finishedOn: Date.now()