@fluidgrids/workflows 2026.1027.0 → 2026.1028.1

package/dist/quickjs/index.js

@@ -1,90 +1,265 @@
-import { LowerError } from '../chunk-S34NJE3A.js';
-import '../chunk-BWSLWF2E.js';
-import '../chunk-SS4LT2IP.js';
+import { runIsolateWorker, outcomeToCollection, LowerError } from '../chunk-H7KEVW2M.js';
+import '../chunk-PDHLTDZB.js';
+import { failedTaskResult } from '../chunk-IISBRUWJ.js';
+import '../chunk-5HDSBTBX.js';
+import { buildIdOf } from '../chunk-BD7ZPG53.js';
 import '../chunk-5LUIDMF4.js';
-import '../chunk-PL73GJR4.js';
-import '../chunk-X4HKU3MX.js';
-import '../chunk-REV7ZOA4.js';
-import { newQuickJSWASMModuleFromVariant, newVariant, RELEASE_SYNC, shouldInterruptAfterDeadline } from 'quickjs-emscripten';
+import '../chunk-JZ4TOOLN.js';
+import '../chunk-E2VK7J2C.js';
+import '../chunk-7AAZGVKD.js';
+import { isRecord } from '../chunk-PMCM2OH4.js';
+import '../chunk-4LYSEANA.js';
+import '../chunk-7NQ37GZU.js';
+import '../chunk-DJYMDLV5.js';
+import '../chunk-BO6OVILK.js';
+import { createRequire } from 'module';
+import { pathToFileURL } from 'url';
+import { Worker } from 'worker_threads';
 
-var WASM_PAGE_BYTES = 64 * 1024;
-var ENGINE_HEADROOM_BYTES = 32 * 1024 * 1024;
-var INITIAL_ENGINE_BYTES = 16 * 1024 * 1024;
-function errorMessage(ctx, handle) {
-  const dumped = ctx.dump(handle);
-  if (typeof dumped === "object" && dumped !== null && "message" in dumped)
-    return String(dumped.message);
-  return String(dumped);
+// src/generated/quickjs-worker-source.ts
+var QUICKJS_WORKER_SOURCE = '"use strict";\n\nvar import_node_worker_threads = require("node:worker_threads");\n\nfunction isRecord(value) {\n  return typeof value === "object" && value !== null && !Array.isArray(value);\n}\n\nvar DETERMINISM_VIOLATION = "DeterminismViolation";\nvar DETERMINISM_PRELUDE = `(() => {\n  const NAME = ${JSON.stringify(DETERMINISM_VIOLATION)};\n  const fail = (what) => {\n    const error = new Error(\n      what + " is not allowed in workflow code: lowering must give the same IR on every build. Read times and random values at run time instead (for example wf.now)."\n    );\n    error.name = NAME;\n    throw error;\n  };\n  const lock = (target, key, value) =>\n    Object.defineProperty(target, key, { value, writable: false, enumerable: false, configurable: false });\n  const RealDate = Date;\n  const LockedDate = function Date(...args) {\n    if (new.target === undefined) return fail("Date()");\n    if (args.length === 0) return fail("new Date()");\n    return Reflect.construct(RealDate, args, new.target);\n  };\n  lock(LockedDate, "prototype", RealDate.prototype);\n  lock(RealDate.prototype, "constructor", LockedDate);\n  lock(LockedDate, "now", function now() { return fail("Date.now()"); });\n  lock(LockedDate, "parse", RealDate.parse);\n  lock(LockedDate, "UTC", RealDate.UTC);\n  lock(globalThis, "Date", LockedDate);\n  lock(Math, "random", function random() { return fail("Math.random()"); });\n  const crypto = globalThis.crypto;\n  if (crypto !== null && typeof crypto === "object") {\n    for (const name of ["getRandomValues", "randomUUID"]) {\n      if (typeof crypto[name] === "function") lock(crypto, name, function () { return fail("crypto." + name + "()"); });\n    }\n  }\n  const DateTimeFormat = typeof Intl === "object" && Intl !== null ? Intl.DateTimeFormat : undefined;\n  if (typeof DateTimeFormat === "function") {\n    const proto = DateTimeFormat.prototype;\n    const format = Object.getOwnPropertyDescriptor(proto, "format");\n    if (format && typeof format.get === "function") {\n      const get = format.get;\n      Object.defineProperty(proto, "format", {\n        get() {\n          const bound = get.call(this);\n          return (date) => (date === undefined ? fail("Intl.DateTimeFormat format()") : bound(date));\n        },\n        enumerable: false,\n        configurable: false,\n      });\n    }\n    const formatToParts = proto.formatToParts;\n    if (typeof formatToParts === "function") {\n      lock(proto, "formatToParts", function (date) {\n        return date === undefined ? fail("Intl.DateTimeFormat formatToParts()") : formatToParts.call(this, date);\n      });\n    }\n  }\n})();\n`;\nfunction failure(kind, message) {\n  return { ok: false, failure: kind, message };\n}\nfunction failureForErrorName(name) {\n  return name === DETERMINISM_VIOLATION ? "determinism" : "error";\n}\n\nfunction isQuickJSApi(value) {\n  return isRecord(value) && typeof value["newQuickJSWASMModuleFromVariant"] === "function" && typeof value["newVariant"] === "function" && typeof value["shouldInterruptAfterDeadline"] === "function" && value["RELEASE_SYNC"] !== void 0;\n}\nvar WASM_PAGE_BYTES = 64 * 1024;\nvar ENGINE_HEADROOM_BYTES = 32 * 1024 * 1024;\nvar INITIAL_ENGINE_BYTES = 16 * 1024 * 1024;\nfunction describe(ctx, handle) {\n  const dumped = ctx.dump(handle);\n  if (isRecord(dumped)) {\n    const name = typeof dumped["name"] === "string" ? dumped["name"] : "Error";\n    const message = dumped["message"];\n    return {\n      name,\n      message: typeof message === "string" ? message : message === void 0 ? JSON.stringify(dumped) : String(message)\n    };\n  }\n  return { name: "Error", message: String(dumped) };\n}\nasync function evaluateInQuickJS(api, code, limits) {\n  const maximum = Math.ceil((limits.memoryLimitBytes + ENGINE_HEADROOM_BYTES) / WASM_PAGE_BYTES);\n  const initial = Math.min(maximum, INITIAL_ENGINE_BYTES / WASM_PAGE_BYTES);\n  const engine = await api.newQuickJSWASMModuleFromVariant(\n    api.newVariant(api.RELEASE_SYNC, { wasmMemory: new WebAssembly.Memory({ initial, maximum }) })\n  );\n  const runtime = engine.newRuntime();\n  const deadline = Date.now() + limits.timeoutMs;\n  runtime.setMemoryLimit(limits.memoryLimitBytes);\n  runtime.setMaxStackSize(limits.maxStackSizeBytes);\n  runtime.setInterruptHandler(api.shouldInterruptAfterDeadline(deadline));\n  const ctx = runtime.newContext();\n  const handles = [];\n  const timedOut = () => failure("timeout", `Evaluating the workflow code timed out after ${limits.timeoutMs} ms`);\n  const thrown = (handle) => {\n    const { name, message } = describe(ctx, handle);\n    handle.dispose();\n    if (Date.now() > deadline && /interrupted/.test(message)) return timedOut();\n    return failure(failureForErrorName(name), message);\n  };\n  try {\n    const prelude = ctx.evalCode(DETERMINISM_PRELUDE, "determinism-prelude.js", { type: "global" });\n    if (prelude.error) return thrown(prelude.error);\n    prelude.value.dispose();\n    const result = ctx.evalCode(code, "workflow-bundle.mjs", { type: "module" });\n    if (result.error) return thrown(result.error);\n    let namespace = result.value;\n    handles.push(namespace);\n    const state = ctx.getPromiseState(namespace);\n    if (!(state.type === "fulfilled" && state.notAPromise === true)) {\n      if (state.type === "fulfilled") state.value.dispose();\n      else if (state.type === "rejected") state.error.dispose();\n      while (runtime.hasPendingJob()) {\n        if (Date.now() > deadline) return timedOut();\n        const jobs = runtime.executePendingJobs();\n        if (jobs.error) return thrown(jobs.error);\n      }\n      const settled = ctx.getPromiseState(namespace);\n      if (settled.type === "rejected") return thrown(settled.error);\n      if (settled.type === "pending")\n        return failure("error", "The workflow module never finished evaluating");\n      namespace = settled.value;\n      handles.push(namespace);\n    }\n    const exported = ctx.getProp(namespace, "__fluidgrids");\n    handles.push(exported);\n    if (ctx.typeof(exported) !== "string")\n      return failure("no-collection", "The bundle did not export a workflow collection");\n    return { ok: true, value: ctx.getString(exported) };\n  } catch (error) {\n    return failure("error", error instanceof Error ? error.message : String(error));\n  } finally {\n    for (const handle of handles.reverse()) if (handle.alive) handle.dispose();\n    ctx.dispose();\n    runtime.dispose();\n  }\n}\n\nprocess.on("unhandledRejection", () => void 0);\nasync function main(input) {\n  if (!isRecord(input) || typeof input["code"] !== "string" || typeof input["moduleUrl"] !== "string" || !isRecord(input["limits"]))\n    return failure("crashed", "The evaluation worker received no bundle");\n  const { timeoutMs, memoryLimitBytes, maxStackSizeBytes } = input["limits"];\n  if (typeof timeoutMs !== "number" || typeof memoryLimitBytes !== "number" || typeof maxStackSizeBytes !== "number")\n    return failure("crashed", "The evaluation worker received no limits");\n  const loaded = await import(input["moduleUrl"]);\n  const api = isQuickJSApi(loaded) ? loaded : isRecord(loaded) && isQuickJSApi(loaded["default"]) ? loaded["default"] : void 0;\n  if (!api) return failure("crashed", "quickjs-emscripten could not be loaded");\n  return evaluateInQuickJS(api, input["code"], {\n    timeoutMs,\n    memoryLimitBytes,\n    maxStackSizeBytes\n  });\n}\nmain(import_node_worker_threads.workerData).then(\n  (outcome) => import_node_worker_threads.parentPort?.postMessage(outcome),\n  (error) => import_node_worker_threads.parentPort?.postMessage(\n    failure("crashed", error instanceof Error ? error.message : String(error))\n  )\n);\n';
+
+// src/generated/quickjs-task-worker-source.ts
+var QUICKJS_TASK_WORKER_SOURCE = '"use strict";\n\nvar import_node_worker_threads = require("node:worker_threads");\n\nfunction isRecord(value) {\n  return typeof value === "object" && value !== null && !Array.isArray(value);\n}\n\nfunction isQuickJSApi(value) {\n  return isRecord(value) && typeof value["newQuickJSWASMModuleFromVariant"] === "function" && typeof value["newVariant"] === "function" && typeof value["shouldInterruptAfterDeadline"] === "function" && value["RELEASE_SYNC"] !== void 0;\n}\nvar WASM_PAGE_BYTES = 64 * 1024;\nvar ENGINE_HEADROOM_BYTES = 32 * 1024 * 1024;\nvar INITIAL_ENGINE_BYTES = 16 * 1024 * 1024;\n\nvar HISTORY_PROTOCOL = 1;\nvar DEFAULT_HISTORY_LIMIT = { events: 1e4, bytes: 16 * 1024 * 1024 };\n\nvar SHIM_VIOLATION = "DeterminismViolation";\nvar SHIM_HOOK = "__fluidgridsShims";\nvar TASK_PRELUDE = `(() => {\n  const NAME = ${JSON.stringify(SHIM_VIOLATION)};\n  const fail = (what) => {\n    const error = new Error(what + " is not allowed in workflow code: use ctx.now(), ctx.random(), ctx.sleep() or an activity.");\n    error.name = NAME;\n    throw error;\n  };\n  let hooks = null;\n  const now = (what) => (hooks !== null ? hooks.now() : fail(what + " outside a workflow task"));\n  const lock = (target, key, value) =>\n    Object.defineProperty(target, key, { value, writable: false, enumerable: false, configurable: false });\n  const RealDate = Date;\n  // ---- Built-ins that differ between hosts and engines --------------------\n  // Local time is UTC whatever the host\'s TZ, locale formatting is fixed\n  // (en-US shapes, no ICU), Intl is absent and garbage collection cannot be\n  // observed, so QuickJS and vm on any host run workflow code the same way.\n  const proto = RealDate.prototype;\n  const hostOffset = proto.getTimezoneOffset;\n  const realParse = RealDate.parse;\n  const isInvalid = (date) => Number.isNaN(proto.getTime.call(date));\n  for (const unit of ["FullYear", "Month", "Date", "Day", "Hours", "Minutes", "Seconds", "Milliseconds"]) {\n    lock(proto, "get" + unit, proto["getUTC" + unit]);\n    if (unit !== "Day") lock(proto, "set" + unit, proto["setUTC" + unit]);\n  }\n  lock(proto, "getTimezoneOffset", function getTimezoneOffset() { return isInvalid(this) ? NaN : 0; });\n  if (typeof proto.getYear === "function")\n    lock(proto, "getYear", function getYear() { return isInvalid(this) ? NaN : this.getUTCFullYear() - 1900; });\n  if (typeof proto.setYear === "function")\n    lock(proto, "setYear", function setYear(value) {\n      const year = Number(value);\n      if (Number.isNaN(year)) return this.setTime(NaN);\n      const whole = Math.trunc(year);\n      const base = new RealDate(isInvalid(this) ? 0 : this.getTime());\n      base.setUTCFullYear(whole >= 0 && whole <= 99 ? 1900 + whole : whole);\n      return this.setTime(base.getTime());\n    });\n  const DAYS = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];\n  const MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];\n  const pad = (value, width) => String(value).padStart(width, "0");\n  const yearText = (year) => (year < 0 ? "-" + pad(-year, 6) : pad(year, 4));\n  const dateText = (d) =>\n    DAYS[d.getUTCDay()] + " " + MONTHS[d.getUTCMonth()] + " " + pad(d.getUTCDate(), 2) + " " + yearText(d.getUTCFullYear());\n  const timeText = (d) =>\n    pad(d.getUTCHours(), 2) + ":" + pad(d.getUTCMinutes(), 2) + ":" + pad(d.getUTCSeconds(), 2) + " GMT+0000 (Coordinated Universal Time)";\n  const localeDate = (d) => d.getUTCMonth() + 1 + "/" + d.getUTCDate() + "/" + d.getUTCFullYear();\n  const localeTime = (d) => {\n    const hours = d.getUTCHours();\n    return ((hours + 11) % 12) + 1 + ":" + pad(d.getUTCMinutes(), 2) + ":" + pad(d.getUTCSeconds(), 2) + (hours < 12 ? " AM" : " PM");\n  };\n  const formatter = (format) => function () { return isInvalid(this) ? "Invalid Date" : format(this); };\n  lock(proto, "toString", formatter((d) => dateText(d) + " " + timeText(d)));\n  lock(proto, "toDateString", formatter(dateText));\n  lock(proto, "toTimeString", formatter(timeText));\n  lock(proto, "toLocaleString", formatter((d) => localeDate(d) + ", " + localeTime(d)));\n  lock(proto, "toLocaleDateString", formatter(localeDate));\n  lock(proto, "toLocaleTimeString", formatter(localeTime));\n  // A date-time without an offset is local time to the host\'s parser; read it as UTC.\n  const DATE_ONLY = /^[+-]?\\\\d{4,6}(?:-\\\\d{2}(?:-\\\\d{2})?)?$/;\n  const ZONE_AFTER_TIME = /\\\\d:\\\\d{2}(?::\\\\d{2}(?:[.,]\\\\d+)?)?\\\\s*(?:[AP]M\\\\s*)?(?:Z|[+-]\\\\d{2}(?::?\\\\d{2})?|[ECMP][SD]T)\\\\s*(?:\\\\([^)]*\\\\))?\\\\s*$/i;\n  const NAMED_ZONE = /\\\\b(?:GMT|UTC|UT)\\\\b(?:\\\\s*[+-]\\\\d{2}:?\\\\d{2})?\\\\s*(?:\\\\([^)]*\\\\))?\\\\s*$/i;\n  const parse = function parse(value) {\n    const text = String(value);\n    const time = realParse(text);\n    if (Number.isNaN(time)) return time;\n    const trimmed = text.trim();\n    if (DATE_ONLY.test(trimmed) || ZONE_AFTER_TIME.test(trimmed) || NAMED_ZONE.test(trimmed)) return time;\n    return time - hostOffset.call(new RealDate(time)) * 60000;\n  };\n  const toTimeValue = (value) => {\n    if (value instanceof RealDate) return value.getTime();\n    let primitive = value;\n    if (typeof value === "object" && value !== null) {\n      primitive = value.valueOf();\n      if (typeof primitive === "object" && primitive !== null) primitive = String(value);\n    }\n    return typeof primitive === "string" ? parse(primitive) : primitive;\n  };\n  // ---- Number, string and array locale methods ----------------------------\n  const group = (digits) => digits.replace(/\\\\B(?=(\\\\d{3})+(?!\\\\d))/g, ",");\n  lock(Number.prototype, "toLocaleString", function toLocaleString() {\n    const x = Number.prototype.valueOf.call(this);\n    if (Number.isNaN(x)) return "NaN";\n    const sign = x < 0 || Object.is(x, -0) ? "-" : "";\n    const abs = Math.abs(x);\n    if (abs === Infinity) return sign + "\\\\u221e";\n    const fixed = abs < 1e21 ? abs.toFixed(3) : BigInt(abs).toString() + ".000";\n    const [whole, fraction] = fixed.split(".");\n    const kept = fraction.replace(/0+$/, "");\n    return sign + group(whole) + (kept === "" ? "" : "." + kept);\n  });\n  if (typeof BigInt === "function")\n    lock(BigInt.prototype, "toLocaleString", function toLocaleString() {\n      const text = BigInt.prototype.toString.call(this);\n      return text.startsWith("-") ? "-" + group(text.slice(1)) : group(text);\n    });\n  lock(String.prototype, "localeCompare", function localeCompare(that) {\n    const a = String(this);\n    const b = String(that);\n    return a < b ? -1 : a > b ? 1 : 0;\n  });\n  lock(String.prototype, "toLocaleUpperCase", function toLocaleUpperCase() { return String(this).toUpperCase(); });\n  lock(String.prototype, "toLocaleLowerCase", function toLocaleLowerCase() { return String(this).toLowerCase(); });\n  const listLocale = function toLocaleString() {\n    return Array.prototype.map.call(this, (item) => (item === null || item === undefined ? "" : item.toLocaleString())).join(",");\n  };\n  lock(Array.prototype, "toLocaleString", listLocale);\n  lock(Object.getPrototypeOf(Uint8Array.prototype), "toLocaleString", listLocale);\n  // ---- Absent or refused ---------------------------------------------------\n  if (!Reflect.deleteProperty(globalThis, "Intl")) lock(globalThis, "Intl", undefined);\n  for (const name of ["WeakRef", "FinalizationRegistry"]) {\n    lock(globalThis, name, function () { return fail(name + " (garbage collection is not deterministic)"); });\n  }\n  const LockedDate = function Date(...args) {\n    if (new.target === undefined) return new RealDate(now("Date()")).toString();\n    if (args.length === 0) return Reflect.construct(RealDate, [now("new Date()")], new.target);\n    if (args.length === 1) return Reflect.construct(RealDate, [toTimeValue(args[0])], new.target);\n    return Reflect.construct(RealDate, [RealDate.UTC(...args)], new.target);\n  };\n  lock(LockedDate, "prototype", RealDate.prototype);\n  lock(RealDate.prototype, "constructor", LockedDate);\n  lock(LockedDate, "now", function now_() { return now("Date.now()"); });\n  lock(LockedDate, "parse", parse);\n  lock(LockedDate, "UTC", RealDate.UTC);\n  lock(globalThis, "Date", LockedDate);\n  lock(Math, "random", function random() {\n    return hooks !== null ? hooks.random() : fail("Math.random() outside a workflow task");\n  });\n  const crypto = globalThis.crypto;\n  if (crypto !== null && typeof crypto === "object") {\n    if (typeof crypto.getRandomValues === "function")\n      lock(crypto, "getRandomValues", function getRandomValues(array) {\n        if (hooks === null) return fail("crypto.getRandomValues() outside a workflow task");\n        for (let i = 0; i < array.length; i++) array[i] = Math.floor(hooks.random() * 256);\n        return array;\n      });\n    if (typeof crypto.randomUUID === "function")\n      lock(crypto, "randomUUID", function randomUUID() { return fail("crypto.randomUUID(): use ctx.uuid()"); });\n  }\n  for (const name of ["setTimeout", "setInterval", "setImmediate", "clearTimeout", "clearInterval", "clearImmediate"]) {\n    lock(globalThis, name, function () { return fail(name + "(): use ctx.sleep()"); });\n  }\n  for (const name of ["fetch", "XMLHttpRequest", "WebSocket", "EventSource"]) {\n    lock(globalThis, name, function () { return fail(name + ": do I/O in an activity (ctx.run)"); });\n  }\n  Object.defineProperty(globalThis, ${JSON.stringify(SHIM_HOOK)}, {\n    value: Object.freeze({\n      attach(next) { hooks = next; },\n      detach() { hooks = null; },\n    }),\n    writable: false,\n    enumerable: false,\n    configurable: true,\n  });\n})();\n`;\n\nvar WASM_PAGE_BYTES2 = 64 * 1024;\nvar HOST_STACK_OVERFLOW = /maximum call stack size exceeded|too much recursion/i;\nvar ENGINE_HEADROOM_BYTES2 = 32 * 1024 * 1024;\nvar INITIAL_ENGINE_BYTES2 = 16 * 1024 * 1024;\nasync function createTaskModule(api, memoryLimitBytes) {\n  const maximum = Math.ceil((memoryLimitBytes + ENGINE_HEADROOM_BYTES2) / WASM_PAGE_BYTES2);\n  const initial = Math.min(maximum, INITIAL_ENGINE_BYTES2 / WASM_PAGE_BYTES2);\n  return api.newQuickJSWASMModuleFromVariant(\n    api.newVariant(api.RELEASE_SYNC, { wasmMemory: new WebAssembly.Memory({ initial, maximum }) })\n  );\n}\nfunction describe(ctx, handle) {\n  const dumped = ctx.dump(handle);\n  if (isRecord(dumped)) {\n    const name = typeof dumped["name"] === "string" ? dumped["name"] : "Error";\n    const message = typeof dumped["message"] === "string" ? dumped["message"] : JSON.stringify(dumped);\n    return { name, message };\n  }\n  return { name: "Error", message: String(dumped) };\n}\nvar TaskError = class extends Error {\n  constructor(cause, message, fatal = false) {\n    super(message);\n    this.cause = cause;\n    this.fatal = fatal;\n  }\n  cause;\n  fatal;\n};\nfunction runTaskInQuickJS(api, module2, code, requestJson, limits) {\n  const disposed = { failed: false };\n  const outcome = runTask(api, module2, code, requestJson, limits, disposed);\n  return disposed.failed && outcome.fatal !== true ? { ...outcome, fatal: true } : outcome;\n}\nfunction runTask(api, module2, code, requestJson, limits, disposed) {\n  let runtime;\n  let ctx;\n  const handles = [];\n  const deadline = Date.now() + limits.timeoutMs;\n  try {\n    runtime = module2.newRuntime();\n    runtime.setMemoryLimit(limits.memoryLimitBytes);\n    runtime.setMaxStackSize(limits.maxStackSizeBytes);\n    runtime.setInterruptHandler(api.shouldInterruptAfterDeadline(deadline));\n    const rt = runtime;\n    const context = rt.newContext();\n    ctx = context;\n    const fail = (handle, during) => {\n      const { name, message } = describe(context, handle);\n      handle.dispose();\n      if (Date.now() > deadline && /interrupted/i.test(message))\n        throw new TaskError(\n          "TASK_TIMEOUT",\n          `The workflow task ran past its ${limits.timeoutMs} ms budget`\n        );\n      if (/out of memory/i.test(message) || name === "InternalError" && /memory/i.test(message))\n        throw new TaskError("ISOLATE_MEMORY", `The workflow task ran out of memory ${during}`);\n      if (name === "DeterminismViolation") throw new TaskError("NON_DETERMINISM", message);\n      throw new TaskError("WORKFLOW_CODE_ERROR", `${name}: ${message} (${during})`);\n    };\n    const drain = (during) => {\n      while (rt.hasPendingJob()) {\n        if (Date.now() > deadline)\n          throw new TaskError(\n            "TASK_TIMEOUT",\n            `The workflow task ran past its ${limits.timeoutMs} ms budget`\n          );\n        const jobs = rt.executePendingJobs();\n        if (jobs.error) fail(jobs.error, during);\n      }\n    };\n    const prelude = context.evalCode(TASK_PRELUDE, "fluidgrids-task-prelude.js", {\n      type: "global"\n    });\n    if (prelude.error) fail(prelude.error, "in the task prelude");\n    else prelude.value.dispose();\n    const evaluated = context.evalCode(code, "workflow-bundle.mjs", { type: "module" });\n    if (evaluated.error) fail(evaluated.error, "while loading the bundle");\n    else {\n      handles.push(evaluated.value);\n      drain("while loading the bundle");\n      const state = context.getPromiseState(evaluated.value);\n      if (state.type === "rejected") fail(state.error, "while loading the bundle");\n      else if (state.type === "fulfilled" && state.notAPromise !== true) state.value.dispose();\n    }\n    const abi = context.getProp(context.global, "__fluidgridsRuntime");\n    handles.push(abi);\n    if (context.typeof(abi) !== "object")\n      throw new TaskError(\n        "INVALID_REQUEST",\n        "The bundle has no workflow runtime (build it with @fluidgrids/workflows 2026.1028 or later)"\n      );\n    const protocol = context.getProp(abi, "protocol");\n    const protocolValue = context.dump(protocol);\n    protocol.dispose();\n    if (protocolValue !== HISTORY_PROTOCOL)\n      throw new TaskError(\n        "PROTOCOL_MISMATCH",\n        `The bundle speaks runtime protocol ${String(protocolValue)}; this host speaks ${HISTORY_PROTOCOL}`\n      );\n    const call = (name, args) => {\n      const fn = context.getProp(abi, name);\n      try {\n        const result = context.callFunction(fn, abi, ...args);\n        if (result.error) return fail(result.error, `in ${name}()`);\n        return result.value;\n      } finally {\n        fn.dispose();\n      }\n    };\n    const request = context.newString(requestJson);\n    handles.push(request);\n    call("start", [request]).dispose();\n    drain("in the workflow code");\n    for (; ; ) {\n      const step = call("step", []);\n      const value = context.dump(step);\n      step.dispose();\n      drain("in the workflow code");\n      if (value !== "more") break;\n    }\n    const completed = call("complete", []);\n    const resultValue = context.dump(completed);\n    completed.dispose();\n    if (typeof resultValue !== "string")\n      throw new TaskError("INTERNAL", "The runtime returned no result");\n    return { ok: true, resultJson: resultValue };\n  } catch (error) {\n    if (error instanceof TaskError)\n      return {\n        ok: false,\n        cause: error.cause,\n        message: error.message,\n        ...error.fatal ? { fatal: true } : {}\n      };\n    const message = error instanceof Error ? error.message : String(error);\n    if (HOST_STACK_OVERFLOW.test(message))\n      return {\n        ok: false,\n        cause: "WORKFLOW_CODE_ERROR",\n        message: `RangeError: stack overflow (the engine\'s host stack ran out: ${message})`,\n        fatal: true\n      };\n    return {\n      ok: false,\n      cause: /memory|out of bounds|abort/i.test(message) ? "ISOLATE_MEMORY" : "INTERNAL",\n      message,\n      fatal: true\n    };\n  } finally {\n    for (const handle of handles.reverse()) if (handle.alive) handle.dispose();\n    try {\n      ctx?.dispose();\n      runtime?.dispose();\n    } catch {\n      disposed.failed = true;\n    }\n  }\n}\n\nprocess.on("unhandledRejection", () => void 0);\nasync function main(input) {\n  const port = import_node_worker_threads.parentPort;\n  if (!port) return;\n  if (!isRecord(input) || typeof input["moduleUrl"] !== "string" || typeof input["memoryLimitBytes"] !== "number") {\n    port.postMessage({ type: "fatal", message: "The task worker received no configuration" });\n    return;\n  }\n  const loaded = await import(input["moduleUrl"]);\n  const api = isQuickJSApi(loaded) ? loaded : isRecord(loaded) && isQuickJSApi(loaded["default"]) ? loaded["default"] : void 0;\n  if (!api) {\n    port.postMessage({ type: "fatal", message: "quickjs-emscripten could not be loaded" });\n    return;\n  }\n  const module2 = await createTaskModule(api, input["memoryLimitBytes"]);\n  port.on("message", (message) => {\n    if (!isRecord(message) || message["type"] !== "task") return;\n    const id = message["id"];\n    const limits = message["limits"];\n    let outcome;\n    if (typeof message["code"] !== "string" || typeof message["requestJson"] !== "string" || !isRecord(limits) || typeof limits["timeoutMs"] !== "number" || typeof limits["memoryLimitBytes"] !== "number" || typeof limits["maxStackSizeBytes"] !== "number")\n      outcome = {\n        ok: false,\n        cause: "INTERNAL",\n        message: "The task worker received a malformed task"\n      };\n    else\n      outcome = runTaskInQuickJS(api, module2, message["code"], message["requestJson"], {\n        timeoutMs: limits["timeoutMs"],\n        memoryLimitBytes: limits["memoryLimitBytes"],\n        maxStackSizeBytes: limits["maxStackSizeBytes"]\n      });\n    port.postMessage({ type: "result", id, outcome });\n    if (outcome.fatal === true) process.exit(1);\n  });\n  port.postMessage({ type: "ready" });\n}\nmain(import_node_worker_threads.workerData).catch((error) => {\n  import_node_worker_threads.parentPort?.postMessage({\n    type: "fatal",\n    message: error instanceof Error ? error.message : String(error)\n  });\n});\n';
+
+// src/quickjs/task-runner.ts
+var MAX_START_FAILURES = 3;
+var DEFAULT_MAX_STACK_SIZE_BYTES = 256 * 1024;
+function quickjsModuleUrl() {
+  return pathToFileURL(createRequire(import.meta.url).resolve("quickjs-emscripten")).href;
 }
-function createQuickJSEvaluator(options = {}) {
-  const timeoutMs = options.timeoutMs ?? 5e3;
-  const memoryLimitBytes = options.memoryLimitBytes ?? 64 * 1024 * 1024;
-  const maxStackSizeBytes = options.maxStackSizeBytes ?? 1024 * 1024;
-  return {
-    format: "esm",
-    async evaluate(code) {
-      const maximum = Math.ceil((memoryLimitBytes + ENGINE_HEADROOM_BYTES) / WASM_PAGE_BYTES);
-      const initial = Math.min(maximum, INITIAL_ENGINE_BYTES / WASM_PAGE_BYTES);
-      const engine = await newQuickJSWASMModuleFromVariant(
-        newVariant(RELEASE_SYNC, { wasmMemory: new WebAssembly.Memory({ initial, maximum }) })
+function parseResult(outcome) {
+  if (!isRecord(outcome))
+    return failedTaskResult("INTERNAL", "The task worker returned no outcome");
+  const typed = outcome;
+  if (typed.ok === true && typeof typed.resultJson === "string") {
+    try {
+      const parsed = JSON.parse(typed.resultJson);
+      if (isRecord(parsed) && typeof parsed["outcome"] === "string" && Array.isArray(parsed["commands"]))
+        return parsed;
+    } catch {
+    }
+    return failedTaskResult("INTERNAL", "The runtime returned an invalid result");
+  }
+  if (typed.ok === false && typeof typed.cause === "string")
+    return failedTaskResult(typed.cause, String(typed.message));
+  return failedTaskResult("INTERNAL", "The task worker returned an invalid outcome");
+}
+function createWorkflowTaskRunner(options = {}) {
+  const poolSize = Math.max(1, Math.floor(options.poolSize ?? 4));
+  const memoryLimitBytes = options.memoryLimitBytes ?? 128 * 1024 * 1024;
+  const maxStackSizeBytes = options.maxStackSizeBytes ?? DEFAULT_MAX_STACK_SIZE_BYTES;
+  const defaultTimeoutMs = options.timeoutMs ?? 1e4;
+  const cacheEntries = Math.max(1, options.bundleCacheEntries ?? 64);
+  const startupTimeoutMs = options.startupTimeoutMs ?? 15e3;
+  const verified = /* @__PURE__ */ new Map();
+  const queue = [];
+  const slots = [];
+  let closed = false;
+  let moduleUrl;
+  let nextJobId = 0;
+  let startFailures = 0;
+  const finish = (slot, result) => {
+    const job = slot.job;
+    slot.job = void 0;
+    if (slot.timer !== void 0) clearTimeout(slot.timer);
+    slot.timer = void 0;
+    job?.resolve(result);
+  };
+  const replace = (slot) => {
+    void slot.worker.terminate();
+    const index = slots.indexOf(slot);
+    if (index >= 0) slots.splice(index, 1);
+    if (!closed) spawn();
+    pump();
+  };
+  const startFailed = (slot, reason) => {
+    startFailures += 1;
+    if (startFailures < MAX_START_FAILURES) {
+      replace(slot);
+      return;
+    }
+    startFailures = 0;
+    void slot.worker.terminate();
+    const index = slots.indexOf(slot);
+    if (index >= 0) slots.splice(index, 1);
+    if (slots.some((entry) => entry.ready)) return;
+    for (const job of queue.splice(0))
+      job.resolve(
+        failedTaskResult("INTERNAL", `The workflow task threads could not start: ${reason}`)
       );
-      const runtime = engine.newRuntime();
-      const deadline = Date.now() + timeoutMs;
-      runtime.setMemoryLimit(memoryLimitBytes);
-      runtime.setMaxStackSize(maxStackSizeBytes);
-      runtime.setInterruptHandler(shouldInterruptAfterDeadline(deadline));
-      const ctx = runtime.newContext();
-      const handles = [];
-      try {
-        const result = ctx.evalCode(code, "workflow-bundle.mjs", { type: "module" });
-        if (result.error) {
-          const message = errorMessage(ctx, result.error);
-          result.error.dispose();
-          throw new LowerError(`Evaluating the workflow code failed: ${message}`);
-        }
-        let namespace = result.value;
-        handles.push(namespace);
-        const state = ctx.getPromiseState(namespace);
-        if (!(state.type === "fulfilled" && state.notAPromise === true)) {
-          if (state.type === "fulfilled") state.value.dispose();
-          else if (state.type === "rejected") state.error.dispose();
-          while (runtime.hasPendingJob()) {
-            if (Date.now() > deadline)
-              throw new LowerError("Evaluating the workflow code timed out");
-            const jobs = runtime.executePendingJobs();
-            if (jobs.error) {
-              const message = errorMessage(ctx, jobs.error);
-              jobs.error.dispose();
-              throw new LowerError(`Evaluating the workflow code failed: ${message}`);
-            }
-          }
-          const settled = ctx.getPromiseState(namespace);
-          if (settled.type === "rejected") {
-            const message = errorMessage(ctx, settled.error);
-            settled.error.dispose();
-            throw new LowerError(`Evaluating the workflow code failed: ${message}`);
-          }
-          if (settled.type === "pending")
-            throw new LowerError("The workflow module never finished evaluating");
-          namespace = settled.value;
-          handles.push(namespace);
+  };
+  const spawn = () => {
+    moduleUrl ??= quickjsModuleUrl();
+    const worker = new Worker(QUICKJS_TASK_WORKER_SOURCE, {
+      eval: true,
+      workerData: { moduleUrl, memoryLimitBytes }
+    });
+    const slot = { worker, ready: false, jobId: 0 };
+    slots.push(slot);
+    const startup = setTimeout(() => {
+      if (!slot.ready) startFailed(slot, `no thread was ready within ${startupTimeoutMs} ms`);
+    }, startupTimeoutMs);
+    worker.on("message", (message) => {
+      if (!isRecord(message)) return;
+      if (message["type"] === "ready") {
+        clearTimeout(startup);
+        slot.ready = true;
+        startFailures = 0;
+        pump();
+      } else if (message["type"] === "result" && message["id"] === slot.jobId && slot.job) {
+        const outcome = message["outcome"];
+        finish(slot, parseResult(outcome));
+        if (isRecord(outcome) && outcome["fatal"] === true) replace(slot);
+        else pump();
+      } else if (message["type"] === "fatal") {
+        clearTimeout(startup);
+        if (!slot.ready) {
+          startFailed(slot, String(message["message"]));
+          return;
         }
-        const exported = ctx.getProp(namespace, "__fluidgrids");
-        handles.push(exported);
-        if (ctx.typeof(exported) !== "string")
-          throw new LowerError("The bundle did not export a workflow collection");
-        return ctx.getString(exported);
+        if (slot.job) finish(slot, failedTaskResult("INTERNAL", String(message["message"])));
+        replace(slot);
+      }
+    });
+    worker.on("error", (error) => {
+      clearTimeout(startup);
+      const outOfMemory = "code" in error && error.code === "ERR_WORKER_OUT_OF_MEMORY";
+      if (slot.job)
+        finish(
+          slot,
+          failedTaskResult(
+            outOfMemory ? "ISOLATE_MEMORY" : "INTERNAL",
+            outOfMemory ? "The workflow task ran out of memory" : `The task thread failed: ${error.message}`
+          )
+        );
+    });
+    worker.on("exit", () => {
+      clearTimeout(startup);
+      if (!slots.includes(slot)) return;
+      if (!slot.ready) {
+        startFailed(slot, "the thread exited while starting");
+        return;
+      }
+      if (slot.job) finish(slot, failedTaskResult("INTERNAL", "The task thread exited"));
+      replace(slot);
+    });
+  };
+  const pump = () => {
+    for (const slot of slots) {
+      if (!slot.ready || slot.job) continue;
+      const job = queue.shift();
+      if (!job) return;
+      nextJobId += 1;
+      slot.jobId = nextJobId;
+      slot.job = job;
+      slot.timer = setTimeout(() => {
+        finish(
+          slot,
+          failedTaskResult(
+            "TASK_TIMEOUT",
+            `The workflow task ran past its ${job.timeoutMs} ms budget`
+          )
+        );
+        replace(slot);
+      }, job.timeoutMs + 250);
+      slot.worker.postMessage({
+        type: "task",
+        id: slot.jobId,
+        code: job.code,
+        requestJson: job.requestJson,
+        limits: { timeoutMs: job.timeoutMs, memoryLimitBytes, maxStackSizeBytes }
+      });
+    }
+  };
+  const verify = (code, buildId) => {
+    const known = verified.get(buildId);
+    if (known === code) {
+      verified.delete(buildId);
+      verified.set(buildId, code);
+      return true;
+    }
+    if (buildIdOf(code) !== buildId) return false;
+    verified.delete(buildId);
+    verified.set(buildId, code);
+    while (verified.size > cacheEntries) {
+      const oldest = verified.keys().next().value;
+      if (oldest === void 0) break;
+      verified.delete(oldest);
+    }
+    return true;
+  };
+  return {
+    run(bundle, request, runOptions = {}) {
+      if (closed) return Promise.resolve(failedTaskResult("INTERNAL", "The task runner is closed"));
+      const code = typeof bundle === "string" ? bundle : bundle.code;
+      const buildId = typeof bundle === "string" ? void 0 : bundle.buildId;
+      if (buildId !== void 0 && !verify(code, buildId))
+        return Promise.resolve(
+          failedTaskResult("BUNDLE_INTEGRITY", `The bundle does not hash to ${buildId}`)
+        );
+      let requestJson;
+      try {
+        requestJson = JSON.stringify(request);
       } catch (error) {
-        if (error instanceof LowerError) throw error;
-        const message = error instanceof Error ? error.message : String(error);
-        throw new LowerError(`Evaluating the workflow code failed: ${message}`);
-      } finally {
-        for (const handle of handles.reverse()) if (handle.alive) handle.dispose();
-        ctx.dispose();
-        runtime.dispose();
+        return Promise.resolve(
+          failedTaskResult(
+            "INVALID_REQUEST",
+            error instanceof Error ? error.message : String(error)
+          )
+        );
       }
+      if (slots.length === 0) for (let index = 0; index < poolSize; index++) spawn();
+      return new Promise((resolve) => {
+        queue.push({
+          code,
+          requestJson,
+          timeoutMs: runOptions.timeoutMs ?? defaultTimeoutMs,
+          resolve
+        });
+        pump();
+      });
+    },
+    async close() {
+      closed = true;
+      for (const job of queue.splice(0))
+        job.resolve(failedTaskResult("INTERNAL", "The task runner is closed"));
+      const all = slots.splice(0);
+      for (const slot of all)
+        if (slot.job) finish(slot, failedTaskResult("INTERNAL", "The task runner is closed"));
+      await Promise.all(all.map((slot) => slot.worker.terminate()));
+    }
+  };
+}
+
+// src/quickjs/index.ts
+function quickjsModuleUrl2() {
+  try {
+    return pathToFileURL(createRequire(import.meta.url).resolve("quickjs-emscripten")).href;
+  } catch (error) {
+    throw new LowerError(
+      `quickjs-emscripten cannot be resolved: ${error instanceof Error ? error.message : String(error)}`,
+      "crashed"
+    );
+  }
+}
+function createQuickJSEvaluator(options = {}) {
+  const limits = {
+    timeoutMs: options.timeoutMs ?? 5e3,
+    memoryLimitBytes: options.memoryLimitBytes ?? 64 * 1024 * 1024,
+    maxStackSizeBytes: options.maxStackSizeBytes ?? 1024 * 1024
+  };
+  return {
+    format: "esm",
+    async evaluate(code) {
+      const outcome = await runIsolateWorker({
+        source: QUICKJS_WORKER_SOURCE,
+        workerData: { code, limits, moduleUrl: quickjsModuleUrl2() },
+        timeoutMs: limits.timeoutMs
+      });
+      return outcomeToCollection(outcome);
     }
   };
 }
 
-export { createQuickJSEvaluator };
+export { DEFAULT_MAX_STACK_SIZE_BYTES, createQuickJSEvaluator, createWorkflowTaskRunner };