@bluelibs/runner 5.3.0 → 5.4.0

package/dist/node/node.mjs

@@ -1,13 +1,13 @@
-import * as http2 from 'http';
-import * as https from 'https';
-import { pipeline, Readable, Transform, PassThrough } from 'stream';
 import { LRUCache } from 'lru-cache';
 import * as crypto from 'crypto';
+import * as http2 from 'http';
+import { pipeline, Transform, Readable, PassThrough } from 'stream';
 import * as Busboy from 'busboy';
 import * as fs3 from 'fs';
 import * as os from 'os';
 import * as path3 from 'path';
 import { join } from 'path';
+import * as https from 'https';
 import { setTimeout as setTimeout$1, clearTimeout as clearTimeout$1 } from 'timers';
 import { createRequire } from 'module';
 import { AsyncLocalStorage } from 'async_hooks';
@@ -25,16 +25,9 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   if (typeof require !== "undefined") return require.apply(this, arguments);
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
 var __commonJS = (cb, mod) => function __require2() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -51,875 +44,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   __defProp(target, "default", { value: mod, enumerable: true }) ,
   mod
 ));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/serializer/regexp-validator.ts
-var regexp_validator_exports = {};
-__export(regexp_validator_exports, {
-  assertRegExpPayload: () => assertRegExpPayload,
-  isBoundedQuantifier: () => isBoundedQuantifier,
-  isQuantifierAt: () => isQuantifierAt,
-  isQuantifierChar: () => isQuantifierChar,
-  isRegExpPatternSafe: () => isRegExpPatternSafe
-});
-var isQuantifierAt, isQuantifierChar, isBoundedQuantifier, isRegExpPatternSafe, assertRegExpPayload;
-var init_regexp_validator = __esm({
-  "src/serializer/regexp-validator.ts"() {
-    isQuantifierAt = /* @__PURE__ */ __name((pattern, index) => {
-      if (index >= pattern.length) {
-        return false;
-      }
-      const char = pattern[index];
-      if (char === "*" || char === "+" || char === "?") {
-        return true;
-      }
-      if (char === "{") {
-        return isBoundedQuantifier(pattern, index);
-      }
-      return false;
-    }, "isQuantifierAt");
-    isQuantifierChar = /* @__PURE__ */ __name((char, pattern, index) => {
-      if (char === "*" || char === "+") {
-        return true;
-      }
-      if (char === "?") {
-        if (index > 0 && pattern[index - 1] === "(") {
-          return false;
-        }
-        return true;
-      }
-      if (char === "{") {
-        return isBoundedQuantifier(pattern, index);
-      }
-      return false;
-    }, "isQuantifierChar");
-    isBoundedQuantifier = /* @__PURE__ */ __name((pattern, index) => {
-      let sawDigit = false;
-      let sawComma = false;
-      for (let i = index + 1; i < pattern.length; i += 1) {
-        const char = pattern[i];
-        if (char >= "0" && char <= "9") {
-          sawDigit = true;
-          continue;
-        }
-        if (char === "," && !sawComma) {
-          sawComma = true;
-          continue;
-        }
-        if (char === "}") {
-          return sawDigit;
-        }
-        return false;
-      }
-      return false;
-    }, "isBoundedQuantifier");
-    isRegExpPatternSafe = /* @__PURE__ */ __name((pattern) => {
-      const groupStack = [];
-      let escaped = false;
-      let inCharClass = false;
-      for (let index = 0; index < pattern.length; index += 1) {
-        const char = pattern[index];
-        if (escaped) {
-          escaped = false;
-          continue;
-        }
-        if (char === "\\") {
-          escaped = true;
-          continue;
-        }
-        if (inCharClass) {
-          if (char === "]") {
-            inCharClass = false;
-          }
-          continue;
-        }
-        if (char === "[") {
-          inCharClass = true;
-          continue;
-        }
-        if (char === "(") {
-          groupStack.push({ hasQuantifier: false });
-          if (pattern[index + 1] === "?") {
-            index += 1;
-          }
-          continue;
-        }
-        if (char === ")") {
-          const group = groupStack.pop();
-          if (group?.hasQuantifier && isQuantifierAt(pattern, index + 1)) {
-            return false;
-          }
-          if (group?.hasQuantifier && groupStack.length > 0) {
-            groupStack[groupStack.length - 1].hasQuantifier = true;
-          }
-          continue;
-        }
-        if (isQuantifierChar(char, pattern, index)) {
-          if (groupStack.length > 0) {
-            groupStack[groupStack.length - 1].hasQuantifier = true;
-          }
-        }
-      }
-      return true;
-    }, "isRegExpPatternSafe");
-    assertRegExpPayload = /* @__PURE__ */ __name((value, options) => {
-      if (!value || typeof value !== "object") {
-        throw new Error("Invalid RegExp payload");
-      }
-      const record = value;
-      if (typeof record.pattern !== "string" || typeof record.flags !== "string") {
-        throw new Error("Invalid RegExp payload");
-      }
-      if (record.pattern.length > options.maxPatternLength) {
-        throw new Error(
-          `RegExp pattern exceeds limit (${options.maxPatternLength})`
-        );
-      }
-      if (!options.allowUnsafe && !isRegExpPatternSafe(record.pattern)) {
-        throw new Error("Unsafe RegExp pattern");
-      }
-      return { pattern: record.pattern, flags: record.flags };
-    }, "assertRegExpPayload");
-  }
-});
-
-// src/globals/resources/tunnel/protocol.ts
-function toTunnelError(input, fallbackMessage) {
-  if (input instanceof Error) {
-    return new TunnelError("UNKNOWN", input.message);
-  }
-  if (input && typeof input === "object" && "code" in input && "message" in input) {
-    const typed = input;
-    if (typeof typed.message === "string" && typeof typed.code === "string") {
-      const pe = input;
-      const msg = pe.message || fallbackMessage || "Tunnel error";
-      return new TunnelError(pe.code, msg, pe.details, {
-        httpCode: pe.httpCode,
-        id: pe.id,
-        data: pe.data
-      });
-    }
-  }
-  if (input && typeof input === "object" && "message" in input) {
-    const typed = input;
-    if (typeof typed.message === "string") {
-      return new TunnelError("UNKNOWN", typed.message);
-    }
-  }
-  return new TunnelError(
-    "UNKNOWN",
-    typeof input === "string" && input || fallbackMessage || "Tunnel error"
-  );
-}
-function assertOkEnvelope(envelope, opts) {
-  if (!envelope || typeof envelope !== "object") {
-    throw new TunnelError(
-      "INVALID_RESPONSE",
-      opts?.fallbackMessage || "Invalid or empty response"
-    );
-  }
-  if (envelope.ok) {
-    return envelope.result;
-  }
-  if (envelope.error) {
-    return (() => {
-      throw toTunnelError(envelope.error, opts?.fallbackMessage);
-    })();
-  }
-  throw new TunnelError("UNKNOWN", opts?.fallbackMessage || "Tunnel error");
-}
-var TunnelError;
-var init_protocol = __esm({
-  "src/globals/resources/tunnel/protocol.ts"() {
-    TunnelError = class extends Error {
-      static {
-        __name(this, "TunnelError");
-      }
-      constructor(code, message, details, extras) {
-        super(message);
-        this.name = "TunnelError";
-        this.code = code;
-        this.details = details;
-        this.httpCode = extras?.httpCode;
-        this.id = extras?.id;
-        this.data = extras?.data;
-      }
-    };
-    __name(toTunnelError, "toTunnelError");
-    __name(assertOkEnvelope, "assertOkEnvelope");
-  }
-});
-
-// src/globals/resources/tunnel/error-utils.ts
-function normalizeError(input) {
-  return input instanceof Error ? input : new Error(String(input));
-}
-var init_error_utils = __esm({
-  "src/globals/resources/tunnel/error-utils.ts"() {
-    __name(normalizeError, "normalizeError");
-  }
-});
-
-// src/http-fetch-tunnel.resource.ts
-async function postSerialized(options) {
-  const {
-    fetch: fetchFn,
-    url,
-    body,
-    headers,
-    timeoutMs,
-    serializer: serializer3,
-    onRequest,
-    contextHeaderText
-  } = options;
-  const controller = timeoutMs && timeoutMs > 0 ? new AbortController() : void 0;
-  let timeout;
-  try {
-    if (controller) {
-      timeout = setTimeout(() => controller.abort(), timeoutMs);
-    }
-    const reqHeaders = {
-      "content-type": "application/json; charset=utf-8",
-      ...headers
-    };
-    if (contextHeaderText) reqHeaders["x-runner-context"] = contextHeaderText;
-    if (onRequest) await onRequest({ url, headers: reqHeaders });
-    const res = await fetchFn(url, {
-      method: "POST",
-      headers: reqHeaders,
-      body: serializer3.stringify(body),
-      signal: controller?.signal
-    });
-    const text = await res.text();
-    const json2 = text ? serializer3.parse(text) : void 0;
-    return json2;
-  } finally {
-    if (timeout) clearTimeout(timeout);
-  }
-}
-function createExposureFetch(cfg) {
-  const baseUrl = cfg?.baseUrl?.replace(/\/$/, "");
-  if (!baseUrl) throw new Error("createExposureFetch requires baseUrl");
-  const headerName = (cfg?.auth?.header ?? "x-runner-token").toLowerCase();
-  const buildHeaders = /* @__PURE__ */ __name(() => {
-    const headers = {};
-    if (cfg?.auth?.token) headers[headerName] = cfg.auth.token;
-    return headers;
-  }, "buildHeaders");
-  const fetchImpl = cfg.fetchImpl ?? globalThis.fetch;
-  if (typeof fetchImpl !== "function") {
-    throw new Error(
-      "global fetch is not available; provide fetchImpl in config"
-    );
-  }
-  const buildContextHeader = /* @__PURE__ */ __name(() => {
-    if (!cfg.contexts || cfg.contexts.length === 0) return void 0;
-    const map = {};
-    for (const ctx of cfg.contexts) {
-      try {
-        const v = ctx.use();
-        map[ctx.id] = ctx.serialize(v);
-      } catch {
-      }
-    }
-    const keys = Object.keys(map);
-    if (keys.length === 0) return void 0;
-    return cfg.serializer.stringify(map);
-  }, "buildContextHeader");
-  return {
-    async task(id2, input) {
-      const url = `${baseUrl}/task/${encodeURIComponent(id2)}`;
-      const r2 = await postSerialized({
-        fetch: fetchImpl,
-        url,
-        body: { input },
-        headers: buildHeaders(),
-        timeoutMs: cfg?.timeoutMs,
-        serializer: cfg.serializer,
-        onRequest: cfg?.onRequest,
-        contextHeaderText: buildContextHeader()
-      });
-      try {
-        return assertOkEnvelope(r2, { fallbackMessage: "Tunnel task error" });
-      } catch (e) {
-        const te = e;
-        if (cfg.errorRegistry && te.id && te.data) {
-          const helper = cfg.errorRegistry.get(String(te.id));
-          if (helper) helper.throw(te.data);
-        }
-        throw e;
-      }
-    },
-    async event(id2, payload) {
-      const url = `${baseUrl}/event/${encodeURIComponent(id2)}`;
-      const r2 = await postSerialized({
-        fetch: fetchImpl,
-        url,
-        body: { payload },
-        headers: buildHeaders(),
-        timeoutMs: cfg?.timeoutMs,
-        serializer: cfg.serializer,
-        onRequest: cfg?.onRequest,
-        contextHeaderText: buildContextHeader()
-      });
-      try {
-        assertOkEnvelope(r2, { fallbackMessage: "Tunnel event error" });
-      } catch (e) {
-        const te = e;
-        if (cfg.errorRegistry && te.id && te.data) {
-          const helper = cfg.errorRegistry.get(String(te.id));
-          if (helper) helper.throw(te.data);
-        }
-        throw e;
-      }
-    },
-    async eventWithResult(id2, payload) {
-      const url = `${baseUrl}/event/${encodeURIComponent(id2)}`;
-      const r2 = await postSerialized({
-        fetch: fetchImpl,
-        url,
-        body: { payload, returnPayload: true },
-        headers: buildHeaders(),
-        timeoutMs: cfg?.timeoutMs,
-        serializer: cfg.serializer,
-        onRequest: cfg?.onRequest,
-        contextHeaderText: buildContextHeader()
-      });
-      if (r2 && typeof r2 === "object" && r2.ok && !("result" in r2)) {
-        throw new TunnelError(
-          "INVALID_RESPONSE",
-          "Tunnel event returnPayload requested but server did not include result. Upgrade the exposure server."
-        );
-      }
-      try {
-        return assertOkEnvelope(r2, {
-          fallbackMessage: "Tunnel event error"
-        });
-      } catch (e) {
-        const te = e;
-        if (cfg.errorRegistry && te.id && te.data) {
-          const helper = cfg.errorRegistry.get(String(te.id));
-          if (helper) helper.throw(te.data);
-        }
-        throw e;
-      }
-    }
-  };
-}
-var init_http_fetch_tunnel_resource = __esm({
-  "src/http-fetch-tunnel.resource.ts"() {
-    init_protocol();
-    init_error_utils();
-    __name(postSerialized, "postSerialized");
-    __name(createExposureFetch, "createExposureFetch");
-  }
-});
-
-// src/node/upload/manifest.ts
-function buildNodeManifest(input) {
-  const files = [];
-  function visit(value) {
-    if (!value || typeof value !== "object") return value;
-    const potentialFile = value;
-    if (potentialFile.$runnerFile === "File" && typeof potentialFile.id === "string") {
-      const id2 = potentialFile.id;
-      const meta = potentialFile.meta;
-      const local = potentialFile._node;
-      if (local?.buffer) {
-        files.push({
-          id: id2,
-          meta,
-          source: { type: "buffer", buffer: local.buffer }
-        });
-      } else if (local?.stream) {
-        files.push({
-          id: id2,
-          meta,
-          source: { type: "stream", stream: local.stream }
-        });
-      }
-      const copy = { $runnerFile: "File", id: id2, meta };
-      return copy;
-    }
-    if (Array.isArray(value)) {
-      return value.map((x) => visit(x));
-    }
-    const out = {};
-    const obj = value;
-    for (const k of Object.keys(obj)) {
-      out[k] = visit(obj[k]);
-    }
-    return out;
-  }
-  __name(visit, "visit");
-  const cloned = visit(input);
-  return { input: cloned, files };
-}
-var init_manifest = __esm({
-  "src/node/upload/manifest.ts"() {
-    __name(buildNodeManifest, "buildNodeManifest");
-  }
-});
-
-// src/node/http/http-smart-client.model.ts
-var http_smart_client_model_exports = {};
-__export(http_smart_client_model_exports, {
-  createHttpSmartClient: () => createHttpSmartClient
-});
-function isReadable(value) {
-  return !!value && typeof value.pipe === "function";
-}
-function hasNodeFile(value) {
-  const isNodeFileSentinel = /* @__PURE__ */ __name((v) => {
-    if (!v || typeof v !== "object") return false;
-    const rec = v;
-    if (rec.$runnerFile !== "File") return false;
-    if (typeof rec.id !== "string") return false;
-    const node = rec._node;
-    if (!node || typeof node !== "object") return false;
-    const n = node;
-    return Boolean(n.stream || n.buffer);
-  }, "isNodeFileSentinel");
-  const visit = /* @__PURE__ */ __name((v) => {
-    if (isNodeFileSentinel(v)) return true;
-    if (!v || typeof v !== "object") return false;
-    if (Array.isArray(v)) return v.some(visit);
-    for (const k of Object.keys(v)) {
-      if (visit(v[k])) return true;
-    }
-    return false;
-  }, "visit");
-  return visit(value);
-}
-function toHeaders2(auth) {
-  const headers = {};
-  if (auth?.token)
-    headers[(auth.header ?? "x-runner-token").toLowerCase()] = auth.token;
-  return headers;
-}
-function requestLib(url) {
-  return url.protocol === "https:" ? https : http2;
-}
-async function postJson(cfg, url, body) {
-  const serializer3 = cfg.serializer;
-  const parsed = new URL(url);
-  const lib = requestLib(parsed);
-  const headers = {
-    "content-type": "application/json; charset=utf-8",
-    ...toHeaders2(cfg.auth)
-  };
-  if (cfg.contexts && cfg.contexts.length > 0) {
-    const map = {};
-    for (const ctx of cfg.contexts) {
-      try {
-        const v = ctx.use();
-        map[ctx.id] = ctx.serialize(v);
-      } catch {
-      }
-    }
-    if (Object.keys(map).length > 0) {
-      headers["x-runner-context"] = cfg.serializer.stringify(map);
-    }
-  }
-  if (cfg.onRequest) await cfg.onRequest({ url, headers });
-  return await new Promise((resolve, reject) => {
-    const req = lib.request(
-      {
-        method: "POST",
-        protocol: parsed.protocol,
-        hostname: parsed.hostname,
-        port: parsed.port,
-        path: parsed.pathname + parsed.search,
-        headers,
-        timeout: cfg.timeoutMs
-      },
-      (res) => {
-        const chunks = [];
-        res.on("data", (c) => {
-          chunks.push(Buffer.isBuffer(c) ? c : Buffer.from(String(c)));
-        });
-        res.on("end", () => {
-          const text = Buffer.concat(chunks).toString(
-            "utf8"
-          );
-          const json2 = text ? serializer3.parse(text) : void 0;
-          resolve(json2);
-        });
-      }
-    );
-    req.on("error", reject);
-    req.write(serializer3.stringify(body));
-    req.end();
-  });
-}
-function escapeHeaderValue(value) {
-  return value.replace(/"/g, '\\"');
-}
-function encodeMultipart(manifestText, files, boundary) {
-  async function* gen() {
-    const CRLF = "\r\n";
-    const boundaryLine = `--${boundary}`;
-    const partHeader = /* @__PURE__ */ __name((name, options) => {
-      const h = [boundaryLine + CRLF];
-      const cd = [
-        `Content-Disposition: form-data; name="${escapeHeaderValue(name)}"`
-      ];
-      if (options?.filename) {
-        cd.push(`; filename="${escapeHeaderValue(options.filename)}"`);
-      }
-      h.push(cd.join("") + CRLF);
-      if (options?.headers) {
-        for (const k of Object.keys(options.headers)) {
-          h.push(`${k}: ${options.headers[k]}` + CRLF);
-        }
-      }
-      h.push(CRLF);
-      return Buffer.from(h.join(""), "utf8");
-    }, "partHeader");
-    yield partHeader("__manifest");
-    yield Buffer.from(manifestText, "utf8");
-    yield Buffer.from(CRLF, "utf8");
-    for (const entry of files) {
-      const filename = entry.meta?.name ?? "upload";
-      const contentType = entry.meta?.type ?? "application/octet-stream";
-      const headers = {
-        "Content-Type": contentType
-      };
-      yield partHeader(`file:${entry.id}`, { headers, filename });
-      if (entry.source.type === "buffer") {
-        yield entry.source.buffer;
-      } else {
-        for await (const chunk of entry.source.stream) {
-          yield Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk));
-        }
-      }
-      yield Buffer.from(CRLF, "utf8");
-    }
-    yield Buffer.from(boundaryLine + "--" + CRLF, "utf8");
-  }
-  __name(gen, "gen");
-  return Readable.from(gen());
-}
-async function postMultipart(cfg, url, manifestText, files) {
-  const parsed = new URL(url);
-  const lib = requestLib(parsed);
-  const boundary = `runner-${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
-  const body = encodeMultipart(manifestText, files, boundary);
-  const headers = {
-    "content-type": `multipart/form-data; boundary=${boundary}`,
-    ...toHeaders2(cfg.auth)
-  };
-  if (cfg.contexts && cfg.contexts.length > 0) {
-    const map = {};
-    for (const ctx of cfg.contexts) {
-      try {
-        const v = ctx.use();
-        map[ctx.id] = ctx.serialize(v);
-      } catch {
-      }
-    }
-    if (Object.keys(map).length > 0) {
-      headers["x-runner-context"] = cfg.serializer.stringify(map);
-    }
-  }
-  if (cfg.onRequest) await cfg.onRequest({ url, headers });
-  return await new Promise(
-    (resolve, reject) => {
-      const req = lib.request(
-        {
-          method: "POST",
-          protocol: parsed.protocol,
-          hostname: parsed.hostname,
-          port: parsed.port,
-          path: parsed.pathname + parsed.search,
-          headers,
-          timeout: cfg.timeoutMs
-        },
-        (res) => resolve({ stream: res, res })
-      );
-      req.on("error", reject);
-      body.on("error", (e) => req.destroy(e));
-      body.pipe(req);
-    }
-  );
-}
-async function postOctetStream(cfg, url, stream) {
-  const parsed = new URL(url);
-  const lib = requestLib(parsed);
-  const headers = {
-    "content-type": "application/octet-stream",
-    ...toHeaders2(cfg.auth)
-  };
-  if (cfg.contexts && cfg.contexts.length > 0) {
-    const map = {};
-    for (const ctx of cfg.contexts) {
-      try {
-        const v = ctx.use();
-        map[ctx.id] = ctx.serialize(v);
-      } catch {
-      }
-    }
-    if (Object.keys(map).length > 0) {
-      headers["x-runner-context"] = cfg.serializer.stringify(map);
-    }
-  }
-  if (cfg.onRequest) await cfg.onRequest({ url, headers });
-  return await new Promise(
-    (resolve, reject) => {
-      let settled = false;
-      const cleanup = [];
-      const resolveOnce = /* @__PURE__ */ __name((value) => {
-        settled = true;
-        cleanup.forEach((fn) => fn());
-        resolve(value);
-      }, "resolveOnce");
-      const rejectOnce = /* @__PURE__ */ __name((error2) => {
-        settled = true;
-        cleanup.forEach((fn) => fn());
-        reject(error2 instanceof Error ? error2 : new Error(String(error2)));
-      }, "rejectOnce");
-      const req = lib.request(
-        {
-          method: "POST",
-          protocol: parsed.protocol,
-          hostname: parsed.hostname,
-          port: parsed.port,
-          path: parsed.pathname + parsed.search,
-          headers,
-          timeout: cfg.timeoutMs
-        },
-        (res) => {
-          setImmediate(() => {
-            if (!settled)
-              resolveOnce({ stream: res, res });
-          });
-        }
-      );
-      const onReqError = /* @__PURE__ */ __name((e) => rejectOnce(e), "onReqError");
-      req.on("error", onReqError);
-      cleanup.push(() => req.removeListener("error", onReqError));
-      const onPipelineDone = /* @__PURE__ */ __name((err) => {
-        if (err) rejectOnce(err);
-      }, "onPipelineDone");
-      pipeline(stream, req, onPipelineDone);
-    }
-  );
-}
-function parseMaybeJsonResponse(res, serializer3) {
-  const contentType = String(res.headers["content-type"]);
-  if (/^application\/json/i.test(contentType)) {
-    const chunks = [];
-    return new Promise((resolve, reject) => {
-      res.on("data", (c) => {
-        chunks.push(Buffer.isBuffer(c) ? c : Buffer.from(String(c)));
-      });
-      res.on("end", () => {
-        try {
-          const text = Buffer.concat(chunks).toString(
-            "utf8"
-          );
-          const json2 = text ? serializer3.parse(text) : void 0;
-          resolve(json2);
-        } catch (e) {
-          reject(e);
-        }
-      });
-      res.on("error", reject);
-    });
-  }
-  return Promise.resolve(res);
-}
-function rethrowTyped(registry, error2) {
-  if (registry && error2 && typeof error2 === "object") {
-    const err = error2;
-    if (err.id && err.data) {
-      const helper = registry.get(String(err.id));
-      if (helper) helper.throw(err.data);
-    }
-  }
-  throw error2;
-}
-function createHttpSmartClient(cfg) {
-  const baseUrl = cfg.baseUrl.replace(/\/$/, "");
-  if (!baseUrl) throw new Error("createHttpSmartClient requires baseUrl");
-  const serializer3 = cfg.serializer;
-  return {
-    async task(id2, input) {
-      const url = `${baseUrl}/task/${encodeURIComponent(id2)}`;
-      if (isReadable(input)) {
-        const { res } = await postOctetStream(cfg, url, input);
-        return res;
-      }
-      if (hasNodeFile(input)) {
-        const manifest = buildNodeManifest(input);
-        const manifestText = serializer3.stringify({
-          input: manifest.input
-        });
-        try {
-          const { res } = await postMultipart(
-            cfg,
-            url,
-            manifestText,
-            manifest.files
-          );
-          const maybe = await parseMaybeJsonResponse(
-            res,
-            serializer3
-          );
-          if (isReadable(maybe)) return maybe;
-          return assertOkEnvelope(maybe, {
-            fallbackMessage: "Tunnel task error"
-          });
-        } catch (error2) {
-          rethrowTyped(cfg.errorRegistry, error2);
-        }
-      }
-      try {
-        const r2 = await postJson(cfg, url, { input });
-        return assertOkEnvelope(r2, {
-          fallbackMessage: "Tunnel task error"
-        });
-      } catch (error2) {
-        rethrowTyped(cfg.errorRegistry, error2);
-      }
-    },
-    async event(id2, payload) {
-      const url = `${baseUrl}/event/${encodeURIComponent(id2)}`;
-      try {
-        const r2 = await postJson(cfg, url, { payload });
-        assertOkEnvelope(r2, { fallbackMessage: "Tunnel event error" });
-      } catch (error2) {
-        rethrowTyped(cfg.errorRegistry, error2);
-      }
-    },
-    async eventWithResult(id2, payload) {
-      const url = `${baseUrl}/event/${encodeURIComponent(id2)}`;
-      try {
-        const r2 = await postJson(cfg, url, {
-          payload,
-          returnPayload: true
-        });
-        if (r2 && typeof r2 === "object" && r2.ok && !("result" in r2)) {
-          throw new TunnelError(
-            "INVALID_RESPONSE",
-            "Tunnel event returnPayload requested but server did not include result. Upgrade the exposure server."
-          );
-        }
-        return assertOkEnvelope(r2, {
-          fallbackMessage: "Tunnel event error"
-        });
-      } catch (error2) {
-        rethrowTyped(cfg.errorRegistry, error2);
-      }
-    }
-  };
-}
-var init_http_smart_client_model = __esm({
-  "src/node/http/http-smart-client.model.ts"() {
-    init_protocol();
-    init_manifest();
-    __name(isReadable, "isReadable");
-    __name(hasNodeFile, "hasNodeFile");
-    __name(toHeaders2, "toHeaders");
-    __name(requestLib, "requestLib");
-    __name(postJson, "postJson");
-    __name(escapeHeaderValue, "escapeHeaderValue");
-    __name(encodeMultipart, "encodeMultipart");
-    __name(postMultipart, "postMultipart");
-    __name(postOctetStream, "postOctetStream");
-    __name(parseMaybeJsonResponse, "parseMaybeJsonResponse");
-    __name(rethrowTyped, "rethrowTyped");
-    __name(createHttpSmartClient, "createHttpSmartClient");
-  }
-});
-
-// src/node/http/http-mixed-client.ts
-var http_mixed_client_exports = {};
-__export(http_mixed_client_exports, {
-  createHttpMixedClient: () => createHttpMixedClient
-});
-function isReadable2(value) {
-  return !!value && typeof value.pipe === "function";
-}
-function hasNodeFile2(value) {
-  const isNodeFileSentinel = /* @__PURE__ */ __name((v) => {
-    if (!v || typeof v !== "object") return false;
-    const rec = v;
-    if (rec.$runnerFile !== "File") return false;
-    if (typeof rec.id !== "string") return false;
-    const node = rec._node;
-    if (!node || typeof node !== "object") return false;
-    const n = node;
-    return Boolean(n.stream || n.buffer);
-  }, "isNodeFileSentinel");
-  const visit = /* @__PURE__ */ __name((v) => {
-    if (isNodeFileSentinel(v)) return true;
-    if (!v || typeof v !== "object") return false;
-    if (Array.isArray(v)) return v.some(visit);
-    for (const k of Object.keys(v)) {
-      if (visit(v[k])) return true;
-    }
-    return false;
-  }, "visit");
-  return visit(value);
-}
-async function shouldForceSmart(cfg, id2, input) {
-  if (!cfg.forceSmart) return false;
-  if (cfg.forceSmart === true) return true;
-  return await cfg.forceSmart({ id: id2, input });
-}
-function createHttpMixedClient(cfg) {
-  const baseUrl = cfg.baseUrl?.replace(/\/$/, "");
-  if (!baseUrl) throw new Error("createMixedHttpClient requires baseUrl");
-  const fetchClient = createExposureFetch({
-    baseUrl,
-    auth: cfg.auth,
-    timeoutMs: cfg.timeoutMs,
-    fetchImpl: cfg.fetchImpl,
-    serializer: cfg.serializer,
-    onRequest: cfg.onRequest,
-    contexts: cfg.contexts,
-    errorRegistry: cfg.errorRegistry
-  });
-  const smartClient = createHttpSmartClient({
-    baseUrl,
-    auth: cfg.auth,
-    timeoutMs: cfg.timeoutMs,
-    serializer: cfg.serializer,
-    onRequest: cfg.onRequest,
-    contexts: cfg.contexts,
-    errorRegistry: cfg.errorRegistry
-  });
-  return {
-    async task(id2, input) {
-      if (isReadable2(input) || hasNodeFile2(input) || await shouldForceSmart(cfg, id2, input)) {
-        return await smartClient.task(id2, input);
-      }
-      return await fetchClient.task(id2, input);
-    },
-    async event(id2, payload) {
-      return await fetchClient.event(id2, payload);
-    },
-    async eventWithResult(id2, payload) {
-      if (!fetchClient.eventWithResult) {
-        throw new Error(
-          "createHttpMixedClient: eventWithResult not available on underlying tunnel client."
-        );
-      }
-      return await fetchClient.eventWithResult(id2, payload);
-    }
-  };
-}
-var init_http_mixed_client = __esm({
-  "src/node/http/http-mixed-client.ts"() {
-    init_http_fetch_tunnel_resource();
-    init_http_smart_client_model();
-    __name(isReadable2, "isReadable");
-    __name(hasNodeFile2, "hasNodeFile");
-    __name(shouldForceSmart, "shouldForceSmart");
-    __name(createHttpMixedClient, "createHttpMixedClient");
-  }
-});
 
 // node_modules/ms/index.js
 var require_ms = __commonJS({
@@ -28596,7 +27720,6 @@ var symbolResourceWithConfig = Symbol.for(
 );
 var symbolEvent = Symbol.for("runner.event");
 var symbolError = Symbol.for("runner.error");
-var symbolMiddleware = Symbol.for("runner.middleware");
 var symbolTaskMiddleware = Symbol.for(
   "runner.taskMiddleware"
 );
@@ -28645,228 +27768,6 @@ function getCallerFile() {
 }
 __name(getCallerFile, "getCallerFile");
 
-// src/defs.ts
-var defs_exports = {};
-__export(defs_exports, {
-  CONTRACT: () => CONTRACT,
-  HookDependencyState: () => HookDependencyState,
-  RunnerMode: () => RunnerMode,
-  isOneOf: () => isOneOf,
-  onAnyOf: () => onAnyOf,
-  symbolAsyncContext: () => symbolAsyncContext,
-  symbolError: () => symbolError,
-  symbolEvent: () => symbolEvent,
-  symbolFilePath: () => symbolFilePath,
-  symbolForkedFrom: () => symbolForkedFrom,
-  symbolHook: () => symbolHook,
-  symbolMiddleware: () => symbolMiddleware,
-  symbolMiddlewareConfigured: () => symbolMiddlewareConfigured,
-  symbolOptionalDependency: () => symbolOptionalDependency,
-  symbolPhantomTask: () => symbolPhantomTask,
-  symbolResource: () => symbolResource,
-  symbolResourceMiddleware: () => symbolResourceMiddleware,
-  symbolResourceWithConfig: () => symbolResourceWithConfig,
-  symbolTag: () => symbolTag,
-  symbolTagConfigured: () => symbolTagConfigured,
-  symbolTask: () => symbolTask,
-  symbolTaskMiddleware: () => symbolTaskMiddleware,
-  symbolTunneledBy: () => symbolTunneledBy
-});
-
-// src/types/event.ts
-function onAnyOf(...defs) {
-  return defs;
-}
-__name(onAnyOf, "onAnyOf");
-function isOneOf(emission, defs) {
-  return defs.some((d) => d.id === emission.id);
-}
-__name(isOneOf, "isOneOf");
-
-// src/types/runner.ts
-var RunnerMode = /* @__PURE__ */ ((RunnerMode2) => {
-  RunnerMode2["TEST"] = "test";
-  RunnerMode2["DEV"] = "dev";
-  RunnerMode2["PROD"] = "prod";
-  return RunnerMode2;
-})(RunnerMode || {});
-
-// src/types/contracts.ts
-var CONTRACT = Symbol.for("runner.contract");
-
-// src/types/storeTypes.ts
-var HookDependencyState = /* @__PURE__ */ ((HookDependencyState2) => {
-  HookDependencyState2["Pending"] = "pending";
-  HookDependencyState2["Computing"] = "computing";
-  HookDependencyState2["Ready"] = "ready";
-  return HookDependencyState2;
-})(HookDependencyState || {});
-
-// src/definers/tools.ts
-function isTask(definition) {
-  return definition && definition[symbolTask];
-}
-__name(isTask, "isTask");
-function isResource(definition) {
-  return definition && definition[symbolResource];
-}
-__name(isResource, "isResource");
-function isResourceWithConfig(definition) {
-  return definition && definition[symbolResourceWithConfig];
-}
-__name(isResourceWithConfig, "isResourceWithConfig");
-function isEvent(definition) {
-  return definition && definition[symbolEvent];
-}
-__name(isEvent, "isEvent");
-function isHook(definition) {
-  return definition && definition[symbolHook];
-}
-__name(isHook, "isHook");
-function isTaskMiddleware(definition) {
-  return definition && definition[symbolTaskMiddleware];
-}
-__name(isTaskMiddleware, "isTaskMiddleware");
-function isResourceMiddleware(definition) {
-  return definition && definition[symbolResourceMiddleware];
-}
-__name(isResourceMiddleware, "isResourceMiddleware");
-function isTag(definition) {
-  return definition && definition[symbolTag];
-}
-__name(isTag, "isTag");
-function isOptional(definition) {
-  return definition && definition[symbolOptionalDependency];
-}
-__name(isOptional, "isOptional");
-function isError(definition) {
-  return Boolean(definition && definition[symbolError]);
-}
-__name(isError, "isError");
-function isAsyncContext(definition) {
-  return Boolean(definition && definition[symbolAsyncContext]);
-}
-__name(isAsyncContext, "isAsyncContext");
-
-// src/tools/throws.ts
-function invalidThrowsEntryError(owner, item) {
-  const got = item === null ? "null" : Array.isArray(item) ? "array" : typeof item === "object" ? "object" : typeof item;
-  return new Error(
-    `Invalid throws entry for ${owner.kind} ${owner.id}: expected error id string or Error helper, got ${got}`
-  );
-}
-__name(invalidThrowsEntryError, "invalidThrowsEntryError");
-function toErrorIdList(owner, list) {
-  const ids = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const item of list) {
-    let id2;
-    if (typeof item === "string") {
-      if (item.trim().length === 0) {
-        throw invalidThrowsEntryError(owner, item);
-      }
-      id2 = item;
-    } else if (isError(item)) {
-      id2 = item.id;
-      if (typeof id2 !== "string" || id2.trim().length === 0) {
-        throw invalidThrowsEntryError(owner, item);
-      }
-    } else {
-      throw invalidThrowsEntryError(owner, item);
-    }
-    if (seen.has(id2)) continue;
-    seen.add(id2);
-    ids.push(id2);
-  }
-  return ids;
-}
-__name(toErrorIdList, "toErrorIdList");
-function normalizeThrows(owner, throwsList) {
-  if (throwsList === void 0) return void 0;
-  return toErrorIdList(owner, throwsList);
-}
-__name(normalizeThrows, "normalizeThrows");
-
-// src/definers/defineTask.ts
-function defineTask(taskConfig) {
-  const filePath = getCallerFile();
-  const id2 = taskConfig.id;
-  return {
-    [symbolTask]: true,
-    [symbolFilePath]: filePath,
-    id: id2,
-    dependencies: taskConfig.dependencies || {},
-    middleware: taskConfig.middleware || [],
-    run: taskConfig.run,
-    inputSchema: taskConfig.inputSchema,
-    resultSchema: taskConfig.resultSchema,
-    meta: taskConfig.meta || {},
-    tags: taskConfig.tags || [],
-    throws: normalizeThrows({ kind: "task", id: id2 }, taskConfig.throws),
-    // autorun,
-    optional() {
-      return {
-        inner: this,
-        [symbolOptionalDependency]: true
-      };
-    }
-  };
-}
-__name(defineTask, "defineTask");
-defineTask.phantom = (taskConfig) => {
-  const taskDef = defineTask({
-    ...taskConfig,
-    run: /* @__PURE__ */ __name(async (_input) => {
-      return void 0;
-    }, "run")
-  });
-  taskDef[symbolPhantomTask] = true;
-  return taskDef;
-};
-
-// src/definers/defineHook.ts
-function defineHook(hookDef) {
-  const filePath = getCallerFile();
-  return {
-    [symbolHook]: true,
-    [symbolFilePath]: filePath,
-    id: hookDef.id,
-    dependencies: hookDef.dependencies || {},
-    on: hookDef.on,
-    order: hookDef.order,
-    run: hookDef.run,
-    meta: hookDef.meta || {},
-    tags: hookDef.tags || []
-  };
-}
-__name(defineHook, "defineHook");
-
-// src/errors.ts
-var errors_exports = {};
-__export(errors_exports, {
-  builderIncompleteError: () => builderIncompleteError,
-  cancellationError: () => cancellationError,
-  circularDependenciesError: () => circularDependenciesError,
-  contextError: () => contextError,
-  dependencyNotFoundError: () => dependencyNotFoundError,
-  duplicateRegistrationError: () => duplicateRegistrationError,
-  eventCycleError: () => eventCycleError,
-  eventEmissionCycleError: () => eventEmissionCycleError,
-  eventNotFoundError: () => eventNotFoundError,
-  isCancellationError: () => isCancellationError,
-  lockedError: () => lockedError,
-  middlewareNotRegisteredError: () => middlewareNotRegisteredError,
-  phantomTaskNotRoutedError: () => phantomTaskNotRoutedError,
-  platformUnsupportedFunctionError: () => platformUnsupportedFunctionError,
-  resourceNotFoundError: () => resourceNotFoundError,
-  storeAlreadyInitializedError: () => storeAlreadyInitializedError,
-  tagNotFoundError: () => tagNotFoundError,
-  taskNotRegisteredError: () => taskNotRegisteredError,
-  tunnelOwnershipConflictError: () => tunnelOwnershipConflictError,
-  unknownItemTypeError: () => unknownItemTypeError,
-  validationError: () => validationError
-});
-
 // src/definers/defineError.ts
 var isValidHttpCode = /* @__PURE__ */ __name((value) => Number.isInteger(value) && value >= 100 && value <= 599, "isValidHttpCode");
 var assertHttpCode = /* @__PURE__ */ __name((value) => {
@@ -29204,20 +28105,67 @@ var EdgePlatformAdapter = class extends BrowserPlatformAdapter {
   constructor() {
     super(...arguments);
     this.id = "edge";
+    this.alsClass = null;
+    this.alsProbed = false;
   }
   static {
     __name(this, "EdgePlatformAdapter");
   }
+  async init() {
+    await this.probeAsyncLocalStorage();
+  }
+  /**
+   * Attempt to discover AsyncLocalStorage from the runtime.
+   * Checks globalThis first, then tries `import("node:async_hooks")`.
+   */
+  probeGlobalAsyncLocalStorage() {
+    if (this.alsClass) return true;
+    const g = globalThis;
+    if (typeof g.AsyncLocalStorage === "function") {
+      this.alsClass = g.AsyncLocalStorage;
+      return true;
+    }
+    return false;
+  }
+  async probeAsyncLocalStorage() {
+    if (this.alsProbed) return;
+    if (this.probeGlobalAsyncLocalStorage()) {
+      this.alsProbed = true;
+      return;
+    }
+    try {
+      const mod = await import('async_hooks');
+      if (mod?.AsyncLocalStorage) {
+        this.alsClass = mod.AsyncLocalStorage;
+      }
+    } catch {
+    } finally {
+      this.alsProbed = true;
+    }
+  }
   onShutdownSignal(_handler) {
     return () => {
     };
   }
+  hasAsyncLocalStorage() {
+    this.probeGlobalAsyncLocalStorage();
+    return this.alsClass !== null;
+  }
+  createAsyncLocalStorage() {
+    this.probeGlobalAsyncLocalStorage();
+    if (this.alsClass) {
+      return new this.alsClass();
+    }
+    return super.createAsyncLocalStorage();
+  }
 };
 
 // src/platform/adapters/universal-generic.ts
 var GenericUniversalPlatformAdapter = class {
   constructor() {
     this.id = "universal";
+    this.alsClass = null;
+    this.alsProbed = false;
     this.setTimeout = globalThis.setTimeout;
     this.clearTimeout = globalThis.clearTimeout;
   }
@@ -29226,6 +28174,23 @@ var GenericUniversalPlatformAdapter = class {
   }
   async init() {
   }
+  probeAsyncLocalStorage() {
+    if (this.alsProbed) return;
+    this.alsProbed = true;
+    const g = globalThis;
+    if (typeof g.Deno === "undefined") return;
+    if (typeof g.AsyncLocalStorage === "function") {
+      this.alsClass = g.AsyncLocalStorage;
+      return;
+    }
+    try {
+      const mod = __require("async_hooks");
+      if (mod?.AsyncLocalStorage) {
+        this.alsClass = mod.AsyncLocalStorage;
+      }
+    } catch {
+    }
+  }
   onUncaughtException(handler) {
     const tgt = globalThis;
     if (tgt.addEventListener) {
@@ -29280,9 +28245,14 @@ var GenericUniversalPlatformAdapter = class {
     return void 0;
   }
   hasAsyncLocalStorage() {
-    return false;
+    this.probeAsyncLocalStorage();
+    return this.alsClass !== null;
   }
   createAsyncLocalStorage() {
+    this.probeAsyncLocalStorage();
+    if (this.alsClass) {
+      return new this.alsClass();
+    }
     return {
       getStore: /* @__PURE__ */ __name(() => {
         platformUnsupportedFunctionError.throw({
@@ -29340,6 +28310,10 @@ var UniversalPlatformAdapter = class {
     if (this.inner) return;
     const kind = detectEnvironment();
     const global2 = globalThis;
+    if (typeof global2.Deno !== "undefined") {
+      this.inner = new GenericUniversalPlatformAdapter();
+      return;
+    }
     if (typeof global2.document !== "undefined" || typeof global2.addEventListener === "function") {
       this.inner = new BrowserPlatformAdapter();
     } else {
@@ -29408,63 +28382,6 @@ function getPlatform() {
   return platformInstance;
 }
 __name(getPlatform, "getPlatform");
-function setPlatform(adapter) {
-  platformInstance = adapter;
-  adapter.id;
-}
-__name(setPlatform, "setPlatform");
-var PlatformAdapter = class {
-  static {
-    __name(this, "PlatformAdapter");
-  }
-  constructor(env) {
-    const kind = env ?? detectEnvironment();
-    this.env = kind;
-    switch (kind) {
-      case "node":
-        this.inner = new NodePlatformAdapter();
-        break;
-      case "browser":
-        this.inner = new BrowserPlatformAdapter();
-        break;
-      case "edge":
-        this.inner = new EdgePlatformAdapter();
-        break;
-      case "universal":
-        this.inner = new GenericUniversalPlatformAdapter();
-        break;
-      default:
-        this.inner = new UniversalPlatformAdapter();
-    }
-    this.id = this.inner.id;
-    this.setTimeout = this.inner.setTimeout;
-    this.clearTimeout = this.inner.clearTimeout;
-  }
-  async init() {
-    return this.inner.init();
-  }
-  onUncaughtException(handler) {
-    return this.inner.onUncaughtException(handler);
-  }
-  onUnhandledRejection(handler) {
-    return this.inner.onUnhandledRejection(handler);
-  }
-  onShutdownSignal(handler) {
-    return this.inner.onShutdownSignal(handler);
-  }
-  exit(code) {
-    return this.inner.exit(code);
-  }
-  getEnv(key) {
-    return this.inner.getEnv(key);
-  }
-  hasAsyncLocalStorage() {
-    return this.inner.hasAsyncLocalStorage();
-  }
-  createAsyncLocalStorage() {
-    return this.inner.createAsyncLocalStorage();
-  }
-};
 
 // src/errors.ts
 var duplicateRegistrationError = error("runner.errors.duplicateRegistration").format(
@@ -29513,7 +28430,7 @@ var eventNotFoundError = error(
 ).remediation(
   ({ id: id2 }) => `Add the event "${id2.toString()}" to a parent resource via .register([yourEvent]). Ensure the event definition is built with r.event("${id2.toString()}").build().`
 ).build();
-var resourceNotFoundError = error(
+error(
   "runner.errors.resourceNotFound"
 ).format(
   ({ id: id2 }) => `Resource "${id2.toString()}" not found. Did you forget to register it or are you using the correct id?`
@@ -29601,10 +28518,145 @@ var builderIncompleteError = error("runner.errors.builderIncomplete").format(({
 }).remediation(
   ({ missingFields }) => `Add the missing builder steps: ${missingFields.map((f) => `.${f}()`).join(", ")} before calling .build().`
 ).build();
-function isCancellationError(err) {
-  return cancellationError.is(err);
+
+// src/definers/tools.ts
+function isTask(definition) {
+  return definition && definition[symbolTask];
+}
+__name(isTask, "isTask");
+function isResource(definition) {
+  return definition && definition[symbolResource];
+}
+__name(isResource, "isResource");
+function isResourceWithConfig(definition) {
+  return definition && definition[symbolResourceWithConfig];
+}
+__name(isResourceWithConfig, "isResourceWithConfig");
+function isEvent(definition) {
+  return definition && definition[symbolEvent];
+}
+__name(isEvent, "isEvent");
+function isHook(definition) {
+  return definition && definition[symbolHook];
+}
+__name(isHook, "isHook");
+function isTaskMiddleware(definition) {
+  return definition && definition[symbolTaskMiddleware];
+}
+__name(isTaskMiddleware, "isTaskMiddleware");
+function isResourceMiddleware(definition) {
+  return definition && definition[symbolResourceMiddleware];
+}
+__name(isResourceMiddleware, "isResourceMiddleware");
+function isTag(definition) {
+  return definition && definition[symbolTag];
+}
+__name(isTag, "isTag");
+function isOptional(definition) {
+  return definition && definition[symbolOptionalDependency];
+}
+__name(isOptional, "isOptional");
+function isError(definition) {
+  return Boolean(definition && definition[symbolError]);
+}
+__name(isError, "isError");
+function isAsyncContext(definition) {
+  return Boolean(definition && definition[symbolAsyncContext]);
+}
+__name(isAsyncContext, "isAsyncContext");
+
+// src/tools/throws.ts
+function invalidThrowsEntryError(owner, item) {
+  const got = item === null ? "null" : Array.isArray(item) ? "array" : typeof item === "object" ? "object" : typeof item;
+  return new Error(
+    `Invalid throws entry for ${owner.kind} ${owner.id}: expected error id string or Error helper, got ${got}`
+  );
+}
+__name(invalidThrowsEntryError, "invalidThrowsEntryError");
+function toErrorIdList(owner, list) {
+  const ids = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const item of list) {
+    let id2;
+    if (typeof item === "string") {
+      if (item.trim().length === 0) {
+        throw invalidThrowsEntryError(owner, item);
+      }
+      id2 = item;
+    } else if (isError(item)) {
+      id2 = item.id;
+      if (typeof id2 !== "string" || id2.trim().length === 0) {
+        throw invalidThrowsEntryError(owner, item);
+      }
+    } else {
+      throw invalidThrowsEntryError(owner, item);
+    }
+    if (seen.has(id2)) continue;
+    seen.add(id2);
+    ids.push(id2);
+  }
+  return ids;
+}
+__name(toErrorIdList, "toErrorIdList");
+function normalizeThrows(owner, throwsList) {
+  if (throwsList === void 0) return void 0;
+  return toErrorIdList(owner, throwsList);
+}
+__name(normalizeThrows, "normalizeThrows");
+
+// src/definers/defineTask.ts
+function defineTask(taskConfig) {
+  const filePath = getCallerFile();
+  const id2 = taskConfig.id;
+  return {
+    [symbolTask]: true,
+    [symbolFilePath]: filePath,
+    id: id2,
+    dependencies: taskConfig.dependencies || {},
+    middleware: taskConfig.middleware || [],
+    run: taskConfig.run,
+    inputSchema: taskConfig.inputSchema,
+    resultSchema: taskConfig.resultSchema,
+    meta: taskConfig.meta || {},
+    tags: taskConfig.tags || [],
+    throws: normalizeThrows({ kind: "task", id: id2 }, taskConfig.throws),
+    // autorun,
+    optional() {
+      return {
+        inner: this,
+        [symbolOptionalDependency]: true
+      };
+    }
+  };
+}
+__name(defineTask, "defineTask");
+defineTask.phantom = (taskConfig) => {
+  const taskDef = defineTask({
+    ...taskConfig,
+    run: /* @__PURE__ */ __name(async (_input) => {
+      phantomTaskNotRoutedError.throw({ taskId: taskConfig.id });
+    }, "run")
+  });
+  taskDef[symbolPhantomTask] = true;
+  return taskDef;
+};
+
+// src/definers/defineHook.ts
+function defineHook(hookDef) {
+  const filePath = getCallerFile();
+  return {
+    [symbolHook]: true,
+    [symbolFilePath]: filePath,
+    id: hookDef.id,
+    dependencies: hookDef.dependencies || {},
+    on: hookDef.on,
+    order: hookDef.order,
+    run: hookDef.run,
+    meta: hookDef.meta || {},
+    tags: hookDef.tags || []
+  };
 }
-__name(isCancellationError, "isCancellationError");
+__name(defineHook, "defineHook");
 
 // src/definers/resourceFork.ts
 function resolveReId(forkId, options) {
@@ -30099,12 +29151,6 @@ var SymbolPolicy = /* @__PURE__ */ ((SymbolPolicy2) => {
   SymbolPolicy2["Disabled"] = "Disabled";
   return SymbolPolicy2;
 })(SymbolPolicy || {});
-var SymbolPolicyErrorMessage = /* @__PURE__ */ ((SymbolPolicyErrorMessage2) => {
-  SymbolPolicyErrorMessage2["GlobalSymbolsNotAllowed"] = "Global symbols are not allowed";
-  SymbolPolicyErrorMessage2["SymbolsNotAllowed"] = "Symbols are not allowed";
-  SymbolPolicyErrorMessage2["UnsupportedSymbolPolicy"] = "Unsupported symbol policy";
-  return SymbolPolicyErrorMessage2;
-})(SymbolPolicyErrorMessage || {});
 
 // src/serializer/binary-builtins.ts
 var INVALID_PAYLOAD_MESSAGE_PREFIX = "Invalid";
@@ -30612,8 +29658,124 @@ var builtInTypes = [
   ...binaryBuiltInTypes
 ];
 
+// src/serializer/regexp-validator.ts
+var isQuantifierAt = /* @__PURE__ */ __name((pattern, index) => {
+  if (index >= pattern.length) {
+    return false;
+  }
+  const char = pattern[index];
+  if (char === "*" || char === "+" || char === "?") {
+    return true;
+  }
+  if (char === "{") {
+    return isBoundedQuantifier(pattern, index);
+  }
+  return false;
+}, "isQuantifierAt");
+var isQuantifierChar = /* @__PURE__ */ __name((char, pattern, index) => {
+  if (char === "*" || char === "+") {
+    return true;
+  }
+  if (char === "?") {
+    if (index > 0 && pattern[index - 1] === "(") {
+      return false;
+    }
+    return true;
+  }
+  if (char === "{") {
+    return isBoundedQuantifier(pattern, index);
+  }
+  return false;
+}, "isQuantifierChar");
+var isBoundedQuantifier = /* @__PURE__ */ __name((pattern, index) => {
+  let sawDigit = false;
+  let sawComma = false;
+  for (let i = index + 1; i < pattern.length; i += 1) {
+    const char = pattern[i];
+    if (char >= "0" && char <= "9") {
+      sawDigit = true;
+      continue;
+    }
+    if (char === "," && !sawComma) {
+      sawComma = true;
+      continue;
+    }
+    if (char === "}") {
+      return sawDigit;
+    }
+    return false;
+  }
+  return false;
+}, "isBoundedQuantifier");
+var isRegExpPatternSafe = /* @__PURE__ */ __name((pattern) => {
+  const groupStack = [];
+  let escaped = false;
+  let inCharClass = false;
+  for (let index = 0; index < pattern.length; index += 1) {
+    const char = pattern[index];
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (char === "\\") {
+      escaped = true;
+      continue;
+    }
+    if (inCharClass) {
+      if (char === "]") {
+        inCharClass = false;
+      }
+      continue;
+    }
+    if (char === "[") {
+      inCharClass = true;
+      continue;
+    }
+    if (char === "(") {
+      groupStack.push({ hasQuantifier: false });
+      if (pattern[index + 1] === "?") {
+        index += 1;
+      }
+      continue;
+    }
+    if (char === ")") {
+      const group = groupStack.pop();
+      if (group?.hasQuantifier && isQuantifierAt(pattern, index + 1)) {
+        return false;
+      }
+      if (group?.hasQuantifier && groupStack.length > 0) {
+        groupStack[groupStack.length - 1].hasQuantifier = true;
+      }
+      continue;
+    }
+    if (isQuantifierChar(char, pattern, index)) {
+      if (groupStack.length > 0) {
+        groupStack[groupStack.length - 1].hasQuantifier = true;
+      }
+    }
+  }
+  return true;
+}, "isRegExpPatternSafe");
+var assertRegExpPayload = /* @__PURE__ */ __name((value, options) => {
+  if (!value || typeof value !== "object") {
+    throw new Error("Invalid RegExp payload");
+  }
+  const record = value;
+  if (typeof record.pattern !== "string" || typeof record.flags !== "string") {
+    throw new Error("Invalid RegExp payload");
+  }
+  if (record.pattern.length > options.maxPatternLength) {
+    throw new Error(
+      `RegExp pattern exceeds limit (${options.maxPatternLength})`
+    );
+  }
+  if (!options.allowUnsafe && !isRegExpPatternSafe(record.pattern)) {
+    throw new Error("Unsafe RegExp pattern");
+  }
+  return { pattern: record.pattern, flags: record.flags };
+}, "assertRegExpPayload");
+
 // src/serializer/type-registry.ts
-init_regexp_validator();
 var TypeRegistry = class {
   constructor(options) {
     this.typeRegistry = /* @__PURE__ */ new Map();
@@ -31372,29 +30534,25 @@ var Serializer = class {
      * @internal - Exposed for testing RegExp safety validation
      */
     this.isRegExpPatternSafe = /* @__PURE__ */ __name((pattern) => {
-      const { isRegExpPatternSafe: check } = (init_regexp_validator(), __toCommonJS(regexp_validator_exports));
-      return check(pattern);
+      return isRegExpPatternSafe(pattern);
     }, "isRegExpPatternSafe");
     /**
      * @internal - Exposed for testing quantifier detection
      */
     this.isQuantifierAt = /* @__PURE__ */ __name((pattern, index) => {
-      const { isQuantifierAt: check } = (init_regexp_validator(), __toCommonJS(regexp_validator_exports));
-      return check(pattern, index);
+      return isQuantifierAt(pattern, index);
     }, "isQuantifierAt");
     /**
      * @internal - Exposed for testing quantifier character detection
      */
     this.isQuantifierChar = /* @__PURE__ */ __name((char, pattern, index) => {
-      const { isQuantifierChar: check } = (init_regexp_validator(), __toCommonJS(regexp_validator_exports));
-      return check(char, pattern, index);
+      return isQuantifierChar(char, pattern, index);
     }, "isQuantifierChar");
     /**
      * @internal - Exposed for testing bounded quantifier detection
      */
     this.isBoundedQuantifier = /* @__PURE__ */ __name((pattern, index) => {
-      const { isBoundedQuantifier: check } = (init_regexp_validator(), __toCommonJS(regexp_validator_exports));
-      return check(pattern, index);
+      return isBoundedQuantifier(pattern, index);
     }, "isBoundedQuantifier");
     this.indent = options.pretty ? 2 : void 0;
     this.maxDepth = normalizeMaxDepth(options.maxDepth, DEFAULT_MAX_DEPTH);
@@ -31597,11 +30755,6 @@ function defineAsyncContext(def, filePath) {
   return api;
 }
 __name(defineAsyncContext, "defineAsyncContext");
-function createContext(name) {
-  const id2 = name ?? `context.${Math.random().toString(36).slice(2)}.${Date.now()}`;
-  return defineAsyncContext({ id: id2 });
-}
-__name(createContext, "createContext");
 
 // src/globals/resources/debug/debug.tag.ts
 var debugTag = defineTag({
@@ -33091,11 +32244,218 @@ var queueResource = defineResource({
   }
 });
 
-// src/http-client.ts
-init_protocol();
-init_http_fetch_tunnel_resource();
+// src/globals/resources/tunnel/protocol.ts
+var TunnelError = class extends Error {
+  static {
+    __name(this, "TunnelError");
+  }
+  constructor(code, message, details, extras) {
+    super(message);
+    this.name = "TunnelError";
+    this.code = code;
+    this.details = details;
+    this.httpCode = extras?.httpCode;
+    this.id = extras?.id;
+    this.data = extras?.data;
+  }
+};
+function toTunnelError(input, fallbackMessage) {
+  if (input instanceof Error) {
+    return new TunnelError("UNKNOWN", input.message);
+  }
+  if (input && typeof input === "object" && "code" in input && "message" in input) {
+    const typed = input;
+    if (typeof typed.message === "string" && typeof typed.code === "string") {
+      const pe = input;
+      const msg = pe.message || fallbackMessage || "Tunnel error";
+      return new TunnelError(pe.code, msg, pe.details, {
+        httpCode: pe.httpCode,
+        id: pe.id,
+        data: pe.data
+      });
+    }
+  }
+  if (input && typeof input === "object" && "message" in input) {
+    const typed = input;
+    if (typeof typed.message === "string") {
+      return new TunnelError("UNKNOWN", typed.message);
+    }
+  }
+  return new TunnelError(
+    "UNKNOWN",
+    typeof input === "string" && input || fallbackMessage || "Tunnel error"
+  );
+}
+__name(toTunnelError, "toTunnelError");
+function assertOkEnvelope(envelope, opts) {
+  if (!envelope || typeof envelope !== "object") {
+    throw new TunnelError(
+      "INVALID_RESPONSE",
+      opts?.fallbackMessage || "Invalid or empty response"
+    );
+  }
+  if (envelope.ok) {
+    return envelope.result;
+  }
+  if (envelope.error) {
+    return (() => {
+      throw toTunnelError(envelope.error, opts?.fallbackMessage);
+    })();
+  }
+  throw new TunnelError("UNKNOWN", opts?.fallbackMessage || "Tunnel error");
+}
+__name(assertOkEnvelope, "assertOkEnvelope");
 
-// src/tunnels/buildUniversalManifest.ts
+// src/http-fetch-tunnel.resource.ts
+async function postSerialized(options) {
+  const {
+    fetch: fetchFn,
+    url,
+    body,
+    headers,
+    timeoutMs,
+    serializer: serializer3,
+    onRequest,
+    contextHeaderText
+  } = options;
+  const controller = timeoutMs && timeoutMs > 0 ? new AbortController() : void 0;
+  let timeout;
+  try {
+    if (controller) {
+      timeout = setTimeout(() => controller.abort(), timeoutMs);
+    }
+    const reqHeaders = {
+      "content-type": "application/json; charset=utf-8",
+      ...headers
+    };
+    if (contextHeaderText) reqHeaders["x-runner-context"] = contextHeaderText;
+    if (onRequest) await onRequest({ url, headers: reqHeaders });
+    const res = await fetchFn(url, {
+      method: "POST",
+      headers: reqHeaders,
+      body: serializer3.stringify(body),
+      signal: controller?.signal
+    });
+    const text = await res.text();
+    const json2 = text ? serializer3.parse(text) : void 0;
+    return json2;
+  } finally {
+    if (timeout) clearTimeout(timeout);
+  }
+}
+__name(postSerialized, "postSerialized");
+function createExposureFetch(cfg) {
+  const baseUrl = cfg?.baseUrl?.replace(/\/$/, "");
+  if (!baseUrl) throw new Error("createExposureFetch requires baseUrl");
+  const headerName = (cfg?.auth?.header ?? "x-runner-token").toLowerCase();
+  const buildHeaders = /* @__PURE__ */ __name(() => {
+    const headers = {};
+    if (cfg?.auth?.token) headers[headerName] = cfg.auth.token;
+    return headers;
+  }, "buildHeaders");
+  const fetchImpl = cfg.fetchImpl ?? globalThis.fetch;
+  if (typeof fetchImpl !== "function") {
+    throw new Error(
+      "global fetch is not available; provide fetchImpl in config"
+    );
+  }
+  const buildContextHeader = /* @__PURE__ */ __name(() => {
+    if (!cfg.contexts || cfg.contexts.length === 0) return void 0;
+    const map = {};
+    for (const ctx of cfg.contexts) {
+      try {
+        const v = ctx.use();
+        map[ctx.id] = ctx.serialize(v);
+      } catch {
+      }
+    }
+    const keys = Object.keys(map);
+    if (keys.length === 0) return void 0;
+    return cfg.serializer.stringify(map);
+  }, "buildContextHeader");
+  return {
+    async task(id2, input) {
+      const url = `${baseUrl}/task/${encodeURIComponent(id2)}`;
+      const r2 = await postSerialized({
+        fetch: fetchImpl,
+        url,
+        body: { input },
+        headers: buildHeaders(),
+        timeoutMs: cfg?.timeoutMs,
+        serializer: cfg.serializer,
+        onRequest: cfg?.onRequest,
+        contextHeaderText: buildContextHeader()
+      });
+      try {
+        return assertOkEnvelope(r2, { fallbackMessage: "Tunnel task error" });
+      } catch (e) {
+        const te = e;
+        if (cfg.errorRegistry && te.id && te.data) {
+          const helper = cfg.errorRegistry.get(String(te.id));
+          if (helper) helper.throw(te.data);
+        }
+        throw e;
+      }
+    },
+    async event(id2, payload) {
+      const url = `${baseUrl}/event/${encodeURIComponent(id2)}`;
+      const r2 = await postSerialized({
+        fetch: fetchImpl,
+        url,
+        body: { payload },
+        headers: buildHeaders(),
+        timeoutMs: cfg?.timeoutMs,
+        serializer: cfg.serializer,
+        onRequest: cfg?.onRequest,
+        contextHeaderText: buildContextHeader()
+      });
+      try {
+        assertOkEnvelope(r2, { fallbackMessage: "Tunnel event error" });
+      } catch (e) {
+        const te = e;
+        if (cfg.errorRegistry && te.id && te.data) {
+          const helper = cfg.errorRegistry.get(String(te.id));
+          if (helper) helper.throw(te.data);
+        }
+        throw e;
+      }
+    },
+    async eventWithResult(id2, payload) {
+      const url = `${baseUrl}/event/${encodeURIComponent(id2)}`;
+      const r2 = await postSerialized({
+        fetch: fetchImpl,
+        url,
+        body: { payload, returnPayload: true },
+        headers: buildHeaders(),
+        timeoutMs: cfg?.timeoutMs,
+        serializer: cfg.serializer,
+        onRequest: cfg?.onRequest,
+        contextHeaderText: buildContextHeader()
+      });
+      if (r2 && typeof r2 === "object" && r2.ok && !("result" in r2)) {
+        throw new TunnelError(
+          "INVALID_RESPONSE",
+          "Tunnel event returnPayload requested but server did not include result. Upgrade the exposure server."
+        );
+      }
+      try {
+        return assertOkEnvelope(r2, {
+          fallbackMessage: "Tunnel event error"
+        });
+      } catch (e) {
+        const te = e;
+        if (cfg.errorRegistry && te.id && te.data) {
+          const helper = cfg.errorRegistry.get(String(te.id));
+          if (helper) helper.throw(te.data);
+        }
+        throw e;
+      }
+    }
+  };
+}
+__name(createExposureFetch, "createExposureFetch");
+
+// src/tools/buildUniversalManifest.ts
 function buildUniversalManifest(input) {
   const nodeFiles = [];
   const webFiles = [];
@@ -33152,6 +32512,15 @@ function toHeaders(auth) {
   return headers;
 }
 __name(toHeaders, "toHeaders");
+function rethrowWithRegistry(e, errorRegistry) {
+  const te = e;
+  if (errorRegistry && te.id && te.data) {
+    const helper = errorRegistry.get(String(te.id));
+    if (helper) helper.throw(te.data);
+  }
+  throw e;
+}
+__name(rethrowWithRegistry, "rethrowWithRegistry");
 function createHttpClient(cfg) {
   const baseUrl = cfg.baseUrl.replace(/\/$/, "");
   if (!baseUrl) throw new Error("createHttpClient requires baseUrl");
@@ -33218,12 +32587,7 @@ function createHttpClient(cfg) {
             fallbackMessage: "Tunnel task error"
           });
         } catch (e) {
-          const te = e;
-          if (cfg.errorRegistry && te.id && te.data) {
-            const helper = cfg.errorRegistry.get(String(te.id));
-            if (helper) helper.throw(te.data);
-          }
-          throw e;
+          rethrowWithRegistry(e, cfg.errorRegistry);
         }
       }
       if (manifest.nodeFiles.length > 0) {
@@ -33234,24 +32598,14 @@ function createHttpClient(cfg) {
       try {
         return await fetchClient.task(id2, input);
       } catch (e) {
-        const te = e;
-        if (cfg.errorRegistry && te.id && te.data) {
-          const helper = cfg.errorRegistry.get(String(te.id));
-          if (helper) helper.throw(te.data);
-        }
-        throw e;
+        rethrowWithRegistry(e, cfg.errorRegistry);
       }
     },
     async event(id2, payload) {
       try {
         return await fetchClient.event(id2, payload);
       } catch (e) {
-        const te = e;
-        if (cfg.errorRegistry && te.id && te.data) {
-          const helper = cfg.errorRegistry.get(String(te.id));
-          if (helper) helper.throw(te.data);
-        }
-        throw e;
+        rethrowWithRegistry(e, cfg.errorRegistry);
       }
     },
     async eventWithResult(id2, payload) {
@@ -33263,12 +32617,7 @@ function createHttpClient(cfg) {
         }
         return await fetchClient.eventWithResult(id2, payload);
       } catch (e) {
-        const te = e;
-        if (cfg.errorRegistry && te.id && te.data) {
-          const helper = cfg.errorRegistry.get(String(te.id));
-          if (helper) helper.throw(te.data);
-        }
-        throw e;
+        rethrowWithRegistry(e, cfg.errorRegistry);
       }
     }
   };
@@ -34202,6 +33551,34 @@ var Logger = class _Logger {
   }
 };
 
+// src/models/utils/dependencyStrategies.ts
+var dependencyStrategies = [
+  {
+    matches: isResource,
+    getStoreMap: /* @__PURE__ */ __name((store2) => store2.resources, "getStoreMap")
+  },
+  {
+    matches: isTask,
+    getStoreMap: /* @__PURE__ */ __name((store2) => store2.tasks, "getStoreMap")
+  },
+  {
+    matches: isEvent,
+    getStoreMap: /* @__PURE__ */ __name((store2) => store2.events, "getStoreMap")
+  },
+  {
+    matches: isError,
+    getStoreMap: /* @__PURE__ */ __name((store2) => store2.errors, "getStoreMap")
+  },
+  {
+    matches: isAsyncContext,
+    getStoreMap: /* @__PURE__ */ __name((store2) => store2.asyncContexts, "getStoreMap")
+  }
+];
+function findDependencyStrategy(item) {
+  return dependencyStrategies.find((s) => s.matches(item));
+}
+__name(findDependencyStrategy, "findDependencyStrategy");
+
 // src/models/DependencyProcessor.ts
 var DependencyProcessor = class {
   constructor(store2, eventManager, taskRunner, logger) {
@@ -34309,7 +33686,16 @@ var DependencyProcessor = class {
       }
       throw error2;
     }
-    throw new Error(`${prefix}: ${String(error2)}`);
+    const wrapper = new Error(`${prefix}: ${String(error2)}`);
+    Object.defineProperty(wrapper, "resourceId", {
+      value: resourceId,
+      configurable: true
+    });
+    Object.defineProperty(wrapper, "cause", {
+      value: error2,
+      configurable: true
+    });
+    throw wrapper;
   }
   /**
    * Computes and caches dependencies for a resource (if not already computed).
@@ -34452,46 +33838,35 @@ var DependencyProcessor = class {
     return object;
   }
   async extractDependency(object, source) {
-    this.logger.trace(`Extracting dependency -> ${source} -> ${object?.id}`);
+    this.logger.trace(
+      `Extracting dependency -> ${source} -> ${object?.id}`
+    );
+    let isOpt = false;
+    let item = object;
     if (isOptional(object)) {
-      const inner = object.inner;
-      if (isResource(inner)) {
-        const exists = this.store.resources.get(inner.id) !== void 0;
-        return exists ? this.extractResourceDependency(inner) : void 0;
-      } else if (isTask(inner)) {
-        const exists = this.store.tasks.get(inner.id) !== void 0;
-        return exists ? this.extractTaskDependency(inner) : void 0;
-      } else if (isEvent(inner)) {
-        const exists = this.store.events.get(inner.id) !== void 0;
-        return exists ? this.extractEventDependency(inner, source) : void 0;
-      } else if (isError(inner)) {
-        const exists = this.store.errors.get(inner.id) !== void 0;
-        return exists ? inner : void 0;
-      } else if (isAsyncContext(inner)) {
-        const exists = this.store.asyncContexts.get(inner.id) !== void 0;
-        return exists ? inner : void 0;
-      }
-      unknownItemTypeError.throw({ item: inner });
-    }
-    if (isResource(object)) {
-      return this.extractResourceDependency(object);
-    } else if (isTask(object)) {
-      return this.extractTaskDependency(object);
-    } else if (isEvent(object)) {
-      return this.extractEventDependency(object, source);
-    } else if (isError(object)) {
-      if (this.store.errors.get(object.id) === void 0) {
-        dependencyNotFoundError.throw({ key: `Error ${object.id}` });
-      }
-      return object;
-    } else if (isAsyncContext(object)) {
-      if (this.store.asyncContexts.get(object.id) === void 0) {
-        dependencyNotFoundError.throw({ key: `AsyncContext ${object.id}` });
-      }
-      return object;
-    } else {
-      unknownItemTypeError.throw({ item: object });
+      isOpt = true;
+      item = object.inner;
+    }
+    const itemWithId = item;
+    const strategy = findDependencyStrategy(item);
+    if (!strategy) {
+      return unknownItemTypeError.throw({ item });
     }
+    if (isOpt) {
+      const exists = strategy.getStoreMap(this.store).has(itemWithId.id);
+      if (!exists) return void 0;
+    }
+    if (isResource(item)) return this.extractResourceDependency(item);
+    if (isTask(item)) return this.extractTaskDependency(item);
+    if (isEvent(item)) return this.extractEventDependency(item, source);
+    if (!isOpt) {
+      const exists = strategy.getStoreMap(this.store).has(itemWithId.id);
+      if (!exists) {
+        const label = isError(item) ? "Error" : "AsyncContext";
+        dependencyNotFoundError.throw({ key: `${label} ${itemWithId.id}` });
+      }
+    }
+    return item;
   }
   /**
    * Converts the event into a running functions with real inputs
@@ -34688,19 +34063,246 @@ var StoreValidator = class {
   }
 };
 
+// src/models/utils/buildDependencyGraph.ts
+function setupBlankNodes(registry, nodeMap, dependents) {
+  for (const task2 of registry.tasks.values()) {
+    const node = {
+      id: task2.task.id,
+      dependencies: {}
+    };
+    nodeMap.set(task2.task.id, node);
+    dependents.push(node);
+  }
+  for (const middleware of registry.taskMiddlewares.values()) {
+    const node = {
+      id: middleware.middleware.id,
+      dependencies: {}
+    };
+    nodeMap.set(middleware.middleware.id, node);
+    dependents.push(node);
+  }
+  for (const middleware of registry.resourceMiddlewares.values()) {
+    const node = {
+      id: middleware.middleware.id,
+      dependencies: {}
+    };
+    nodeMap.set(middleware.middleware.id, node);
+    dependents.push(node);
+  }
+  for (const resource2 of registry.resources.values()) {
+    const node = {
+      id: resource2.resource.id,
+      dependencies: {}
+    };
+    nodeMap.set(resource2.resource.id, node);
+    dependents.push(node);
+  }
+  for (const hook2 of registry.hooks.values()) {
+    const node = {
+      id: hook2.hook.id,
+      dependencies: {}
+    };
+    nodeMap.set(hook2.hook.id, node);
+    dependents.push(node);
+  }
+}
+__name(setupBlankNodes, "setupBlankNodes");
+function buildDependencyGraph(registry) {
+  const depenedants = [];
+  const nodeMap = /* @__PURE__ */ new Map();
+  setupBlankNodes(registry, nodeMap, depenedants);
+  for (const task2 of registry.tasks.values()) {
+    const node = nodeMap.get(task2.task.id);
+    if (task2.task.dependencies) {
+      for (const [depKey, depItem] of Object.entries(task2.task.dependencies)) {
+        const candidate = isOptional(depItem) ? depItem.inner : depItem;
+        const depNode = nodeMap.get(candidate.id);
+        if (depNode) {
+          node.dependencies[depKey] = depNode;
+        }
+      }
+    }
+    const t = task2.task;
+    for (const middleware of t.middleware) {
+      const middlewareNode = nodeMap.get(middleware.id);
+      if (middlewareNode) {
+        node.dependencies[middleware.id] = middlewareNode;
+      }
+    }
+  }
+  for (const storeTaskMiddleware of registry.taskMiddlewares.values()) {
+    const node = nodeMap.get(storeTaskMiddleware.middleware.id);
+    const { middleware } = storeTaskMiddleware;
+    if (middleware.dependencies) {
+      for (const [depKey, depItem] of Object.entries(middleware.dependencies)) {
+        const candidate = isOptional(depItem) ? depItem.inner : depItem;
+        const depNode = nodeMap.get(candidate.id);
+        if (depNode) {
+          node.dependencies[depKey] = depNode;
+        }
+      }
+    }
+    if (middleware.everywhere) {
+      const filter = typeof middleware.everywhere === "function" ? middleware.everywhere : () => true;
+      for (const task2 of registry.tasks.values()) {
+        if (filter(task2.task)) {
+          const taskNode = nodeMap.get(task2.task.id);
+          taskNode.dependencies[`__middleware.${middleware.id}`] = node;
+        }
+      }
+    }
+  }
+  for (const storeResourceMiddleware of registry.resourceMiddlewares.values()) {
+    const node = nodeMap.get(storeResourceMiddleware.middleware.id);
+    const { middleware } = storeResourceMiddleware;
+    if (middleware.dependencies) {
+      for (const [depKey, depItem] of Object.entries(middleware.dependencies)) {
+        const candidate = isOptional(depItem) ? depItem.inner : depItem;
+        const depNode = nodeMap.get(candidate.id);
+        if (depNode) {
+          node.dependencies[depKey] = depNode;
+        }
+      }
+    }
+    if (middleware.everywhere) {
+      const filter = typeof middleware.everywhere === "function" ? middleware.everywhere : () => true;
+      for (const resource2 of registry.resources.values()) {
+        if (filter(resource2.resource)) {
+          const resourceNode = nodeMap.get(resource2.resource.id);
+          resourceNode.dependencies[`__middleware.${middleware.id}`] = node;
+        }
+      }
+    }
+  }
+  for (const resource2 of registry.resources.values()) {
+    const node = nodeMap.get(resource2.resource.id);
+    if (resource2.resource.dependencies) {
+      for (const [depKey, depItem] of Object.entries(
+        resource2.resource.dependencies
+      )) {
+        const candidate = isOptional(depItem) ? depItem.inner : depItem;
+        const depNode = nodeMap.get(candidate.id);
+        if (depNode) {
+          node.dependencies[depKey] = depNode;
+        }
+      }
+    }
+    for (const middleware of resource2.resource.middleware) {
+      const middlewareNode = nodeMap.get(middleware.id);
+      if (middlewareNode) {
+        node.dependencies[middleware.id] = middlewareNode;
+      }
+    }
+  }
+  for (const hook2 of registry.hooks.values()) {
+    const node = nodeMap.get(hook2.hook.id);
+    if (hook2.hook.dependencies) {
+      for (const [depKey, depItem] of Object.entries(hook2.hook.dependencies)) {
+        const candidate = isOptional(depItem) ? depItem.inner : depItem;
+        const depNode = nodeMap.get(candidate.id);
+        if (depNode) {
+          node.dependencies[depKey] = depNode;
+        }
+      }
+    }
+  }
+  return depenedants;
+}
+__name(buildDependencyGraph, "buildDependencyGraph");
+function buildEventEmissionGraph(registry) {
+  const nodes = /* @__PURE__ */ new Map();
+  for (const e of registry.events.values()) {
+    nodes.set(e.event.id, { id: e.event.id, dependencies: {} });
+  }
+  for (const h of registry.hooks.values()) {
+    const listened = [];
+    const on = h.hook.on;
+    if (on === "*") continue;
+    if (Array.isArray(on))
+      listened.push(...on.map((e) => e.id));
+    else listened.push(on.id);
+    const depEvents = [];
+    const deps = h.hook.dependencies;
+    if (deps) {
+      for (const value of Object.values(deps)) {
+        const candidate = isOptional(value) ? value.inner : value;
+        if (candidate && isEvent(candidate)) {
+          depEvents.push(candidate.id);
+        }
+      }
+    }
+    for (const srcId of listened) {
+      const srcNode = nodes.get(srcId);
+      if (!srcNode) continue;
+      for (const dstId of depEvents) {
+        if (srcId === dstId) continue;
+        const dstNode = nodes.get(dstId);
+        if (dstNode) {
+          srcNode.dependencies[dstId] = dstNode;
+        }
+      }
+    }
+  }
+  return Array.from(nodes.values());
+}
+__name(buildEventEmissionGraph, "buildEventEmissionGraph");
+
+// src/tools/LockableMap.ts
+var LockableMap = class extends Map {
+  static {
+    __name(this, "LockableMap");
+  }
+  #locked = false;
+  #name;
+  constructor(name) {
+    super();
+    this.#name = name ?? "LockableMap";
+  }
+  /** Whether the map is currently locked. */
+  get locked() {
+    return this.#locked;
+  }
+  /** Permanently lock the map — no further mutations allowed. */
+  lock() {
+    this.#locked = true;
+  }
+  /** @throws if the map is locked */
+  throwIfLocked() {
+    if (this.#locked) {
+      throw new Error(`Cannot modify "${this.#name}" \u2014 the map is locked.`);
+    }
+  }
+  set(key, value) {
+    this.throwIfLocked();
+    return super.set(key, value);
+  }
+  delete(key) {
+    this.throwIfLocked();
+    return super.delete(key);
+  }
+  clear() {
+    this.throwIfLocked();
+    super.clear();
+  }
+};
+
 // src/models/StoreRegistry.ts
 var StoreRegistry = class {
   constructor(store2) {
     this.store = store2;
-    this.tasks = /* @__PURE__ */ new Map();
-    this.resources = /* @__PURE__ */ new Map();
-    this.events = /* @__PURE__ */ new Map();
-    this.taskMiddlewares = /* @__PURE__ */ new Map();
-    this.resourceMiddlewares = /* @__PURE__ */ new Map();
-    this.hooks = /* @__PURE__ */ new Map();
-    this.tags = /* @__PURE__ */ new Map();
-    this.asyncContexts = /* @__PURE__ */ new Map();
-    this.errors = /* @__PURE__ */ new Map();
+    this.tasks = new LockableMap("tasks");
+    this.resources = new LockableMap(
+      "resources"
+    );
+    this.events = new LockableMap("events");
+    this.taskMiddlewares = new LockableMap("taskMiddlewares");
+    this.resourceMiddlewares = new LockableMap("resourceMiddlewares");
+    this.hooks = new LockableMap("hooks");
+    this.tags = new LockableMap("tags");
+    this.asyncContexts = new LockableMap(
+      "asyncContexts"
+    );
+    this.errors = new LockableMap("errors");
     this.validator = new StoreValidator(this);
   }
   static {
@@ -34709,6 +34311,18 @@ var StoreRegistry = class {
   getValidator() {
     return this.validator;
   }
+  /** Lock every map in the registry, preventing further mutations. */
+  lockAll() {
+    this.tasks.lock();
+    this.resources.lock();
+    this.events.lock();
+    this.taskMiddlewares.lock();
+    this.resourceMiddlewares.lock();
+    this.hooks.lock();
+    this.tags.lock();
+    this.asyncContexts.lock();
+    this.errors.lock();
+  }
   storeGenericItem(item) {
     if (isTask(item)) {
       this.storeTask(item);
@@ -34845,195 +34459,14 @@ var StoreRegistry = class {
   }
   // Feels like a dependencyProcessor task?
   getDependentNodes() {
-    const depenedants = [];
-    const nodeMap = /* @__PURE__ */ new Map();
-    this.setupBlankNodes(nodeMap, depenedants);
-    for (const task2 of this.tasks.values()) {
-      const node = nodeMap.get(task2.task.id);
-      if (task2.task.dependencies) {
-        for (const [depKey, depItem] of Object.entries(
-          task2.task.dependencies
-        )) {
-          const candidate = isOptional(depItem) ? depItem.inner : depItem;
-          const depNode = nodeMap.get(candidate.id);
-          if (depNode) {
-            node.dependencies[depKey] = depNode;
-          }
-        }
-      }
-      const t = task2.task;
-      for (const middleware of t.middleware) {
-        const middlewareNode = nodeMap.get(middleware.id);
-        if (middlewareNode) {
-          node.dependencies[middleware.id] = middlewareNode;
-        }
-      }
-    }
-    for (const storeTaskMiddleware of this.taskMiddlewares.values()) {
-      const node = nodeMap.get(storeTaskMiddleware.middleware.id);
-      const { middleware } = storeTaskMiddleware;
-      if (middleware.dependencies) {
-        for (const [depKey, depItem] of Object.entries(
-          middleware.dependencies
-        )) {
-          const candidate = isOptional(depItem) ? depItem.inner : depItem;
-          const depNode = nodeMap.get(candidate.id);
-          if (depNode) {
-            node.dependencies[depKey] = depNode;
-          }
-        }
-      }
-      if (middleware.everywhere) {
-        const filter = typeof middleware.everywhere === "function" ? middleware.everywhere : () => true;
-        for (const task2 of this.tasks.values()) {
-          if (filter(task2.task)) {
-            const taskNode = nodeMap.get(task2.task.id);
-            taskNode.dependencies[`__middleware.${middleware.id}`] = node;
-          }
-        }
-      }
-    }
-    for (const storeResourceMiddleware of this.resourceMiddlewares.values()) {
-      const node = nodeMap.get(storeResourceMiddleware.middleware.id);
-      const { middleware } = storeResourceMiddleware;
-      if (middleware.dependencies) {
-        for (const [depKey, depItem] of Object.entries(
-          middleware.dependencies
-        )) {
-          const candidate = isOptional(depItem) ? depItem.inner : depItem;
-          const depNode = nodeMap.get(candidate.id);
-          if (depNode) {
-            node.dependencies[depKey] = depNode;
-          }
-        }
-      }
-      if (middleware.everywhere) {
-        const filter = typeof middleware.everywhere === "function" ? middleware.everywhere : () => true;
-        for (const resource2 of this.resources.values()) {
-          if (filter(resource2.resource)) {
-            const resourceNode = nodeMap.get(resource2.resource.id);
-            resourceNode.dependencies[`__middleware.${middleware.id}`] = node;
-          }
-        }
-      }
-    }
-    for (const resource2 of this.resources.values()) {
-      const node = nodeMap.get(resource2.resource.id);
-      if (resource2.resource.dependencies) {
-        for (const [depKey, depItem] of Object.entries(
-          resource2.resource.dependencies
-        )) {
-          const candidate = isOptional(depItem) ? depItem.inner : depItem;
-          const depNode = nodeMap.get(candidate.id);
-          if (depNode) {
-            node.dependencies[depKey] = depNode;
-          }
-        }
-      }
-      for (const middleware of resource2.resource.middleware) {
-        const middlewareNode = nodeMap.get(middleware.id);
-        if (middlewareNode) {
-          node.dependencies[middleware.id] = middlewareNode;
-        }
-      }
-    }
-    for (const hook2 of this.hooks.values()) {
-      const node = nodeMap.get(hook2.hook.id);
-      if (hook2.hook.dependencies) {
-        for (const [depKey, depItem] of Object.entries(
-          hook2.hook.dependencies
-        )) {
-          const candidate = isOptional(depItem) ? depItem.inner : depItem;
-          const depNode = nodeMap.get(candidate.id);
-          if (depNode) {
-            node.dependencies[depKey] = depNode;
-          }
-        }
-      }
-    }
-    return depenedants;
+    return buildDependencyGraph(this);
   }
   /**
    * Builds a directed graph of event emissions based on hooks listening to events
    * and their dependencies on events (emission capability). Ignores wildcard hooks by default.
    */
   buildEventEmissionGraph() {
-    const nodes = /* @__PURE__ */ new Map();
-    for (const e of this.events.values()) {
-      nodes.set(e.event.id, { id: e.event.id, dependencies: {} });
-    }
-    for (const h of this.hooks.values()) {
-      const listened = [];
-      const on = h.hook.on;
-      if (on === "*") continue;
-      if (Array.isArray(on))
-        listened.push(...on.map((e) => e.id));
-      else listened.push(on.id);
-      const depEvents = [];
-      const deps = h.hook.dependencies;
-      if (deps) {
-        for (const value of Object.values(deps)) {
-          const candidate = isOptional(value) ? value.inner : value;
-          if (candidate && isEvent(candidate)) {
-            depEvents.push(candidate.id);
-          }
-        }
-      }
-      for (const srcId of listened) {
-        const srcNode = nodes.get(srcId);
-        if (!srcNode) continue;
-        for (const dstId of depEvents) {
-          if (srcId === dstId) continue;
-          const dstNode = nodes.get(dstId);
-          if (dstNode) {
-            srcNode.dependencies[dstId] = dstNode;
-          }
-        }
-      }
-    }
-    return Array.from(nodes.values());
-  }
-  setupBlankNodes(nodeMap, depenedants) {
-    for (const task2 of this.tasks.values()) {
-      const node = {
-        id: task2.task.id,
-        dependencies: {}
-      };
-      nodeMap.set(task2.task.id, node);
-      depenedants.push(node);
-    }
-    for (const middleware of this.taskMiddlewares.values()) {
-      const node = {
-        id: middleware.middleware.id,
-        dependencies: {}
-      };
-      nodeMap.set(middleware.middleware.id, node);
-      depenedants.push(node);
-    }
-    for (const middleware of this.resourceMiddlewares.values()) {
-      const node = {
-        id: middleware.middleware.id,
-        dependencies: {}
-      };
-      nodeMap.set(middleware.middleware.id, node);
-      depenedants.push(node);
-    }
-    for (const resource2 of this.resources.values()) {
-      const node = {
-        id: resource2.resource.id,
-        dependencies: {}
-      };
-      nodeMap.set(resource2.resource.id, node);
-      depenedants.push(node);
-    }
-    for (const hook2 of this.hooks.values()) {
-      const node = {
-        id: hook2.hook.id,
-        dependencies: {}
-      };
-      nodeMap.set(hook2.hook.id, node);
-      depenedants.push(node);
-    }
+    return buildEventEmissionGraph(this);
   }
   getTasksWithTag(tag2) {
     const tagId = typeof tag2 === "string" ? tag2 : tag2.id;
@@ -35967,6 +35400,63 @@ function detectRunnerMode(explicitMode) {
 }
 __name(detectRunnerMode, "detectRunnerMode");
 
+// src/models/utils/disposeOrder.ts
+function getResourcesInDisposeOrder(resources, initializedResourceIds) {
+  const initializedResources = Array.from(resources.values()).filter(
+    (r2) => r2.isInitialized
+  );
+  const initOrderHasAllInitialized = initializedResourceIds.length === initializedResources.length && initializedResources.every(
+    (r2) => initializedResourceIds.includes(r2.resource.id)
+  );
+  if (initOrderHasAllInitialized) {
+    const byId = new Map(
+      initializedResources.map((r2) => [r2.resource.id, r2])
+    );
+    return initializedResourceIds.slice().reverse().map((id2) => byId.get(id2)).filter((r2) => Boolean(r2));
+  }
+  const visitState = /* @__PURE__ */ new Map();
+  const initOrder = [];
+  let cycleDetected = false;
+  const getDependencyIds = /* @__PURE__ */ __name((resource2) => {
+    const raw = resource2.resource.dependencies;
+    if (!raw) return [];
+    const deps = raw;
+    if (!deps || typeof deps !== "object") return [];
+    const out = [];
+    const collect = /* @__PURE__ */ __name((value) => {
+      if (isOptional(value)) {
+        collect(value.inner);
+        return;
+      }
+      if (isResource(value)) {
+        out.push(value.id);
+      }
+    }, "collect");
+    Object.values(deps).forEach(collect);
+    return out;
+  }, "getDependencyIds");
+  const visit = /* @__PURE__ */ __name((resourceId) => {
+    const state = visitState.get(resourceId);
+    if (state === "visited") return;
+    if (state === "visiting") {
+      cycleDetected = true;
+      return;
+    }
+    const resource2 = resources.get(resourceId);
+    if (!resource2) return;
+    visitState.set(resourceId, "visiting");
+    getDependencyIds(resource2).forEach(visit);
+    visitState.set(resourceId, "visited");
+    initOrder.push(resource2);
+  }, "visit");
+  initializedResources.forEach((r2) => visit(r2.resource.id));
+  if (cycleDetected) {
+    return initializedResources.slice().reverse();
+  }
+  return initOrder.reverse();
+}
+__name(getResourcesInDisposeOrder, "getResourcesInDisposeOrder");
+
 // src/models/Store.ts
 var Store = class {
   constructor(eventManager, logger, onUnhandledError, mode) {
@@ -36031,6 +35521,7 @@ var Store = class {
   }
   lock() {
     this.#isLocked = true;
+    this.registry.lockAll();
   }
   checkLock() {
     if (this.#isLocked) {
@@ -36172,58 +35663,7 @@ var Store = class {
     this.initializedResourceIds.push(resourceId);
   }
   getResourcesInDisposeOrder() {
-    const initializedResources = Array.from(this.resources.values()).filter(
-      (r2) => r2.isInitialized
-    );
-    const initOrderHasAllInitialized = this.initializedResourceIds.length === initializedResources.length && initializedResources.every(
-      (r2) => this.initializedResourceIds.includes(r2.resource.id)
-    );
-    if (initOrderHasAllInitialized) {
-      const byId = new Map(
-        initializedResources.map((r2) => [r2.resource.id, r2])
-      );
-      return this.initializedResourceIds.slice().reverse().map((id2) => byId.get(id2)).filter((r2) => Boolean(r2));
-    }
-    const visitState = /* @__PURE__ */ new Map();
-    const initOrder = [];
-    let cycleDetected = false;
-    const getDependencyIds = /* @__PURE__ */ __name((resource2) => {
-      const raw = resource2.resource.dependencies;
-      if (!raw) return [];
-      const deps = raw;
-      if (!deps || typeof deps !== "object") return [];
-      const out = [];
-      const collect = /* @__PURE__ */ __name((value) => {
-        if (isOptional(value)) {
-          collect(value.inner);
-          return;
-        }
-        if (isResource(value)) {
-          out.push(value.id);
-        }
-      }, "collect");
-      Object.values(deps).forEach(collect);
-      return out;
-    }, "getDependencyIds");
-    const visit = /* @__PURE__ */ __name((resourceId) => {
-      const state = visitState.get(resourceId);
-      if (state === "visited") return;
-      if (state === "visiting") {
-        cycleDetected = true;
-        return;
-      }
-      const resource2 = this.resources.get(resourceId);
-      if (!resource2) return;
-      visitState.set(resourceId, "visiting");
-      getDependencyIds(resource2).forEach(visit);
-      visitState.set(resourceId, "visited");
-      initOrder.push(resource2);
-    }, "visit");
-    initializedResources.forEach((r2) => visit(r2.resource.id));
-    if (cycleDetected) {
-      return initializedResources.slice().reverse();
-    }
-    return initOrder.reverse();
+    return getResourcesInDisposeOrder(this.resources, this.initializedResourceIds);
   }
   /**
    * Internal, avoid using this method directly.
@@ -36506,7 +35946,7 @@ var debugResource = defineResource({
   tags: [globalTags.system]
 });
 
-// src/processHooks.ts
+// src/tools/processShutdownHooks.ts
 var platform2 = getPlatform();
 var activeErrorHandlers = /* @__PURE__ */ new Set();
 var processSafetyNetsInstalled = false;
@@ -36595,13 +36035,6 @@ function bindProcessErrorHandler(handler) {
   };
 }
 __name(bindProcessErrorHandler, "bindProcessErrorHandler");
-async function safeReportUnhandledError(handler, info) {
-  try {
-    await handler(info);
-  } catch {
-  }
-}
-__name(safeReportUnhandledError, "safeReportUnhandledError");
 
 // src/models/RunResult.ts
 var RunResult = class {
@@ -36800,7 +36233,6 @@ function extractResourceAndConfig(resourceOrResourceWithConfig) {
 __name(extractResourceAndConfig, "extractResourceAndConfig");
 
 // src/globals/tunnels/index.ts
-init_http_fetch_tunnel_resource();
 var http = Object.freeze({
   createClient(cfg) {
     const { url, ...rest } = cfg;
@@ -36811,39 +36243,15 @@ var tunnels = Object.freeze({
   http
 });
 
-// src/testing.ts
-var testResourceCounter = 0;
-function createTestResource(root, options) {
-  return defineResource({
-    id: `testing.${root.id}.${++testResourceCounter}`,
-    register: [root],
-    overrides: options?.overrides || [],
-    dependencies: {
-      taskRunner: globalResources.taskRunner,
-      store: globalResources.store,
-      logger: globalResources.logger,
-      eventManager: globalResources.eventManager
-    },
-    async init(_, deps) {
-      return buildTestFacade(deps);
-    }
-  });
-}
-__name(createTestResource, "createTestResource");
-function buildTestFacade(deps) {
-  return {
-    // Run a task within the fully initialized ecosystem
-    runTask: /* @__PURE__ */ __name((task2, ...args) => deps.taskRunner.run(task2, ...args), "runTask"),
-    // Access a resource value by id (string or symbol)
-    getResource: /* @__PURE__ */ __name((id2) => deps.store.resources.get(id2)?.value, "getResource"),
-    // Expose internals when needed in tests (not recommended for app usage)
-    taskRunner: deps.taskRunner,
-    store: deps.store,
-    logger: deps.logger,
-    eventManager: deps.eventManager
-  };
+// src/definers/builders/shared/mergeUtils.ts
+function mergeArray(existing, addition, override2) {
+  const toArray = [...addition];
+  if (override2 || !existing) {
+    return toArray;
+  }
+  return [...existing, ...toArray];
 }
-__name(buildTestFacade, "buildTestFacade");
+__name(mergeArray, "mergeArray");
 
 // src/definers/builders/resource/utils.ts
 function clone2(s, patch) {
@@ -36889,14 +36297,6 @@ function mergeRegister(existing, addition, override2) {
   ];
 }
 __name(mergeRegister, "mergeRegister");
-function mergeArray(existing, addition, override2) {
-  const toArray = [...addition];
-  if (override2 || !existing) {
-    return toArray;
-  }
-  return [...existing, ...toArray];
-}
-__name(mergeArray, "mergeArray");
 function mergeDependencies(existing, addition, override2) {
   const isFnExisting = typeof existing === "function";
   const isFnAddition = typeof addition === "function";
@@ -37060,14 +36460,6 @@ function clone3(s, patch) {
   });
 }
 __name(clone3, "clone");
-function mergeArray2(existing, addition, override2) {
-  const toArray = [...addition];
-  if (override2 || !existing) {
-    return toArray;
-  }
-  return [...existing, ...toArray];
-}
-__name(mergeArray2, "mergeArray");
 function mergeDependencies2(existing, addition, override2) {
   const isFnExisting = typeof existing === "function";
   const isFnAddition = typeof addition === "function";
@@ -37123,14 +36515,14 @@ function makeTaskBuilder(state) {
     middleware(mw, options) {
       const override2 = options?.override ?? false;
       const next = clone3(state, {
-        middleware: mergeArray2(state.middleware, mw, override2)
+        middleware: mergeArray(state.middleware, mw, override2)
       });
       return makeTaskBuilder(next);
     },
     tags(t, options) {
       const override2 = options?.override ?? false;
       const next = clone3(state, {
-        tags: mergeArray2(state.tags, t, override2)
+        tags: mergeArray(state.tags, t, override2)
       });
       return makeTaskBuilder(next);
     },
@@ -37206,14 +36598,14 @@ function makePhantomTaskBuilder(state) {
     middleware(mw, options) {
       const override2 = options?.override ?? false;
       const next = clone3(state, {
-        middleware: mergeArray2(state.middleware, mw, override2)
+        middleware: mergeArray(state.middleware, mw, override2)
       });
       return makePhantomTaskBuilder(next);
     },
     tags(t, options) {
       const override2 = options?.override ?? false;
       const next = clone3(state, {
-        tags: mergeArray2(state.tags, t, override2)
+        tags: mergeArray(state.tags, t, override2)
       });
       return makePhantomTaskBuilder(
         next
@@ -37302,14 +36694,6 @@ function clone4(s, patch) {
   });
 }
 __name(clone4, "clone");
-function mergeArray3(existing, addition, override2) {
-  const toArray = [...addition];
-  if (override2 || !existing) {
-    return toArray;
-  }
-  return [...existing, ...toArray];
-}
-__name(mergeArray3, "mergeArray");
 
 // src/definers/builders/event/fluent-builder.ts
 function makeEventBuilder(state) {
@@ -37324,7 +36708,7 @@ function makeEventBuilder(state) {
     tags(t, options) {
       const override2 = options?.override ?? false;
       const next = clone4(state, {
-        tags: mergeArray3(state.tags, t, override2)
+        tags: mergeArray(state.tags, t, override2)
       });
       return makeEventBuilder(next);
     },
@@ -37372,14 +36756,6 @@ function clone5(s, patch) {
   });
 }
 __name(clone5, "clone");
-function mergeArray4(existing, addition, override2) {
-  const toArray = [...addition];
-  if (override2 || !existing) {
-    return toArray;
-  }
-  return [...existing, ...toArray];
-}
-__name(mergeArray4, "mergeArray");
 function mergeDependencies3(existing, addition, override2) {
   const isFnExisting = typeof existing === "function";
   const isFnAddition = typeof addition === "function";
@@ -37453,7 +36829,7 @@ function makeHookBuilder(state) {
     tags(t, options) {
       const override2 = options?.override ?? false;
       const next = clone5(state, {
-        tags: mergeArray4(state.tags, t, override2)
+        tags: mergeArray(state.tags, t, override2)
       });
       return makeHookBuilder(next);
     },
@@ -37530,14 +36906,6 @@ function cloneRes(s, patch) {
   });
 }
 __name(cloneRes, "cloneRes");
-function mergeArray5(existing, addition, override2) {
-  const toArray = [...addition];
-  if (override2 || !existing) {
-    return toArray;
-  }
-  return [...existing, ...toArray];
-}
-__name(mergeArray5, "mergeArray");
 function mergeDependencies4(existing, addition, override2) {
   const isFnExisting = typeof existing === "function";
   const isFnAddition = typeof addition === "function";
@@ -37618,7 +36986,7 @@ function makeTaskMiddlewareBuilder(state) {
     tags(t, options) {
       const override2 = options?.override ?? false;
       const next = cloneTask(state, {
-        tags: mergeArray5(state.tags, t, override2)
+        tags: mergeArray(state.tags, t, override2)
       });
       return makeTaskMiddlewareBuilder(next);
     },
@@ -37690,7 +37058,7 @@ function makeResourceMiddlewareBuilder(state) {
     tags(t, options) {
       const override2 = options?.override ?? false;
       const next = cloneRes(state, {
-        tags: mergeArray5(state.tags, t, override2)
+        tags: mergeArray(state.tags, t, override2)
       });
       return makeResourceMiddlewareBuilder(next);
     },
@@ -37901,7 +37269,7 @@ function makeHookOverrideBuilder(base, state) {
     tags(t, options) {
       const override2 = options?.override ?? false;
       const next = cloneHookState(state, {
-        tags: mergeArray4(state.tags, t, override2)
+        tags: mergeArray(state.tags, t, override2)
       });
       return makeHookOverrideBuilder(base, next);
     },
@@ -38106,7 +37474,7 @@ function makeResourceMiddlewareOverrideBuilder(base, state) {
     tags(t, options) {
       const override2 = options?.override ?? false;
       const next = cloneResourceMiddlewareState(state, {
-        tags: mergeArray5(state.tags, t, override2)
+        tags: mergeArray(state.tags, t, override2)
       });
       return makeResourceMiddlewareOverrideBuilder(base, next);
     },
@@ -38166,14 +37534,14 @@ function makeTaskOverrideBuilder(base, state) {
     middleware(mw, options) {
       const override2 = options?.override ?? false;
       const next = cloneTaskState(state, {
-        middleware: mergeArray2(state.middleware, mw, override2)
+        middleware: mergeArray(state.middleware, mw, override2)
       });
       return makeTaskOverrideBuilder(base, next);
     },
     tags(t, options) {
       const override2 = options?.override ?? false;
       const next = cloneTaskState(state, {
-        tags: mergeArray2(state.tags, t, override2)
+        tags: mergeArray(state.tags, t, override2)
       });
       return makeTaskOverrideBuilder(base, next);
     },
@@ -38282,7 +37650,7 @@ function makeTaskMiddlewareOverrideBuilder(base, state) {
     tags(t, options) {
       const override2 = options?.override ?? false;
       const next = cloneTaskMiddlewareState(state, {
-        tags: mergeArray5(state.tags, t, override2)
+        tags: mergeArray(state.tags, t, override2)
       });
       return makeTaskMiddlewareOverrideBuilder(base, next);
     },
@@ -38334,7 +37702,6 @@ function override(base) {
 __name(override, "override");
 
 // src/public.ts
-init_http_fetch_tunnel_resource();
 var globals = {
   events: globalEvents,
   resources: globalResources,
@@ -38343,7 +37710,6 @@ var globals = {
   tunnels,
   debug
 };
-var createContext2 = createContext;
 var r = Object.freeze({
   resource,
   task,
@@ -39629,7 +38995,7 @@ var withExposureContext = /* @__PURE__ */ __name((req, res, controller, deps, fn
     } catch {
     }
   }
-  const run3 = /* @__PURE__ */ __name(() => ExposureRequestContext.provide(
+  const run2 = /* @__PURE__ */ __name(() => ExposureRequestContext.provide(
     {
       req,
       res,
@@ -39641,7 +39007,7 @@ var withExposureContext = /* @__PURE__ */ __name((req, res, controller, deps, fn
     },
     userWrapped
   ), "run");
-  return Promise.resolve(run3());
+  return Promise.resolve(run2());
 }, "withExposureContext");
 var withUserContexts = /* @__PURE__ */ __name((req, deps, fn) => {
   const { store: store2, serializer: serializer3 } = deps;
@@ -39837,7 +39203,7 @@ var createTaskHandler = /* @__PURE__ */ __name((deps) => {
       applyCorsActual(req, res, cors);
       respondJson(res, jsonOkResponse({ result }), serializer3);
     } catch (error2) {
-      if (isCancellationError(error2)) {
+      if (cancellationError.is(error2)) {
         if (!res.writableEnded && !res.headersSent) {
           applyCorsActual(req, res, cors);
           respondJson(
@@ -39946,7 +39312,7 @@ var createEventHandler = /* @__PURE__ */ __name((deps) => {
         serializer3
       );
     } catch (error2) {
-      if (isCancellationError(error2)) {
+      if (cancellationError.is(error2)) {
         if (!res.writableEnded && !res.headersSent) {
           applyCorsActual(req, res, cors);
           respondJson(
@@ -40212,27 +39578,487 @@ async function writeInputFileToPath(file, targetPath) {
 }
 __name(writeInputFileToPath, "writeInputFileToPath");
 
-// src/node/http/index.ts
-init_http_smart_client_model();
-init_http_mixed_client();
-
-// src/node/http/http-smart-client.factory.resource.ts
-var httpSmartClientFactory = defineResource({
-  id: "globals.resources.httpSmartClientFactory",
-  meta: {
-    title: "HTTP Smart Client Factory (Node)",
-    description: "Factory placeholder for Node Smart HTTP clients. Value is supplied at runtime by the Node run() wrapper to auto-inject serializer, error registry, and async contexts."
+// src/node/upload/manifest.ts
+function buildNodeManifest(input) {
+  const files = [];
+  function visit(value) {
+    if (!value || typeof value !== "object") return value;
+    const potentialFile = value;
+    if (potentialFile.$runnerFile === "File" && typeof potentialFile.id === "string") {
+      const id2 = potentialFile.id;
+      const meta = potentialFile.meta;
+      const local = potentialFile._node;
+      if (local?.buffer) {
+        files.push({
+          id: id2,
+          meta,
+          source: { type: "buffer", buffer: local.buffer }
+        });
+      } else if (local?.stream) {
+        files.push({
+          id: id2,
+          meta,
+          source: { type: "stream", stream: local.stream }
+        });
+      }
+      const copy = { $runnerFile: "File", id: id2, meta };
+      return copy;
+    }
+    if (Array.isArray(value)) {
+      return value.map((x) => visit(x));
+    }
+    const out = {};
+    const obj = value;
+    for (const k of Object.keys(obj)) {
+      out[k] = visit(obj[k]);
+    }
+    return out;
   }
-});
+  __name(visit, "visit");
+  const cloned = visit(input);
+  return { input: cloned, files };
+}
+__name(buildNodeManifest, "buildNodeManifest");
 
-// src/node/http/http-mixed-client.factory.resource.ts
-var httpMixedClientFactory = defineResource({
-  id: "globals.resources.httpMixedClientFactory",
-  meta: {
-    title: "HTTP Mixed Client Factory (Node)",
-    description: "Factory placeholder for Node Mixed HTTP clients. Value is supplied at runtime by the Node run() wrapper to auto-inject serializer, error registry, and async contexts."
+// src/node/http/http-smart-client.model.ts
+function isReadable(value) {
+  return !!value && typeof value.pipe === "function";
+}
+__name(isReadable, "isReadable");
+function hasNodeFile(value) {
+  const isNodeFileSentinel = /* @__PURE__ */ __name((v) => {
+    if (!v || typeof v !== "object") return false;
+    const rec = v;
+    if (rec.$runnerFile !== "File") return false;
+    if (typeof rec.id !== "string") return false;
+    const node = rec._node;
+    if (!node || typeof node !== "object") return false;
+    const n = node;
+    return Boolean(n.stream || n.buffer);
+  }, "isNodeFileSentinel");
+  const visit = /* @__PURE__ */ __name((v) => {
+    if (isNodeFileSentinel(v)) return true;
+    if (!v || typeof v !== "object") return false;
+    if (Array.isArray(v)) return v.some(visit);
+    for (const k of Object.keys(v)) {
+      if (visit(v[k])) return true;
+    }
+    return false;
+  }, "visit");
+  return visit(value);
+}
+__name(hasNodeFile, "hasNodeFile");
+function toHeaders2(auth) {
+  const headers = {};
+  if (auth?.token)
+    headers[(auth.header ?? "x-runner-token").toLowerCase()] = auth.token;
+  return headers;
+}
+__name(toHeaders2, "toHeaders");
+function requestLib(url) {
+  return url.protocol === "https:" ? https : http2;
+}
+__name(requestLib, "requestLib");
+async function postJson(cfg, url, body) {
+  const serializer3 = cfg.serializer;
+  const parsed = new URL(url);
+  const lib = requestLib(parsed);
+  const headers = {
+    "content-type": "application/json; charset=utf-8",
+    ...toHeaders2(cfg.auth)
+  };
+  if (cfg.contexts && cfg.contexts.length > 0) {
+    const map = {};
+    for (const ctx of cfg.contexts) {
+      try {
+        const v = ctx.use();
+        map[ctx.id] = ctx.serialize(v);
+      } catch {
+      }
+    }
+    if (Object.keys(map).length > 0) {
+      headers["x-runner-context"] = cfg.serializer.stringify(map);
+    }
   }
-});
+  if (cfg.onRequest) await cfg.onRequest({ url, headers });
+  return await new Promise((resolve, reject) => {
+    const req = lib.request(
+      {
+        method: "POST",
+        protocol: parsed.protocol,
+        hostname: parsed.hostname,
+        port: parsed.port,
+        path: parsed.pathname + parsed.search,
+        headers,
+        timeout: cfg.timeoutMs
+      },
+      (res) => {
+        const chunks = [];
+        res.on("data", (c) => {
+          chunks.push(Buffer.isBuffer(c) ? c : Buffer.from(String(c)));
+        });
+        res.on("end", () => {
+          const text = Buffer.concat(chunks).toString(
+            "utf8"
+          );
+          const json2 = text ? serializer3.parse(text) : void 0;
+          resolve(json2);
+        });
+      }
+    );
+    req.on("error", reject);
+    req.write(serializer3.stringify(body));
+    req.end();
+  });
+}
+__name(postJson, "postJson");
+function escapeHeaderValue(value) {
+  return value.replace(/"/g, '\\"');
+}
+__name(escapeHeaderValue, "escapeHeaderValue");
+function encodeMultipart(manifestText, files, boundary) {
+  async function* gen() {
+    const CRLF = "\r\n";
+    const boundaryLine = `--${boundary}`;
+    const partHeader = /* @__PURE__ */ __name((name, options) => {
+      const h = [boundaryLine + CRLF];
+      const cd = [
+        `Content-Disposition: form-data; name="${escapeHeaderValue(name)}"`
+      ];
+      if (options?.filename) {
+        cd.push(`; filename="${escapeHeaderValue(options.filename)}"`);
+      }
+      h.push(cd.join("") + CRLF);
+      if (options?.headers) {
+        for (const k of Object.keys(options.headers)) {
+          h.push(`${k}: ${options.headers[k]}` + CRLF);
+        }
+      }
+      h.push(CRLF);
+      return Buffer.from(h.join(""), "utf8");
+    }, "partHeader");
+    yield partHeader("__manifest");
+    yield Buffer.from(manifestText, "utf8");
+    yield Buffer.from(CRLF, "utf8");
+    for (const entry of files) {
+      const filename = entry.meta?.name ?? "upload";
+      const contentType = entry.meta?.type ?? "application/octet-stream";
+      const headers = {
+        "Content-Type": contentType
+      };
+      yield partHeader(`file:${entry.id}`, { headers, filename });
+      if (entry.source.type === "buffer") {
+        yield entry.source.buffer;
+      } else {
+        for await (const chunk of entry.source.stream) {
+          yield Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk));
+        }
+      }
+      yield Buffer.from(CRLF, "utf8");
+    }
+    yield Buffer.from(boundaryLine + "--" + CRLF, "utf8");
+  }
+  __name(gen, "gen");
+  return Readable.from(gen());
+}
+__name(encodeMultipart, "encodeMultipart");
+async function postMultipart(cfg, url, manifestText, files) {
+  const parsed = new URL(url);
+  const lib = requestLib(parsed);
+  const boundary = `runner-${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+  const body = encodeMultipart(manifestText, files, boundary);
+  const headers = {
+    "content-type": `multipart/form-data; boundary=${boundary}`,
+    ...toHeaders2(cfg.auth)
+  };
+  if (cfg.contexts && cfg.contexts.length > 0) {
+    const map = {};
+    for (const ctx of cfg.contexts) {
+      try {
+        const v = ctx.use();
+        map[ctx.id] = ctx.serialize(v);
+      } catch {
+      }
+    }
+    if (Object.keys(map).length > 0) {
+      headers["x-runner-context"] = cfg.serializer.stringify(map);
+    }
+  }
+  if (cfg.onRequest) await cfg.onRequest({ url, headers });
+  return await new Promise(
+    (resolve, reject) => {
+      const req = lib.request(
+        {
+          method: "POST",
+          protocol: parsed.protocol,
+          hostname: parsed.hostname,
+          port: parsed.port,
+          path: parsed.pathname + parsed.search,
+          headers,
+          timeout: cfg.timeoutMs
+        },
+        (res) => resolve({ stream: res, res })
+      );
+      req.on("error", reject);
+      body.on("error", (e) => req.destroy(e));
+      body.pipe(req);
+    }
+  );
+}
+__name(postMultipart, "postMultipart");
+async function postOctetStream(cfg, url, stream) {
+  const parsed = new URL(url);
+  const lib = requestLib(parsed);
+  const headers = {
+    "content-type": "application/octet-stream",
+    ...toHeaders2(cfg.auth)
+  };
+  if (cfg.contexts && cfg.contexts.length > 0) {
+    const map = {};
+    for (const ctx of cfg.contexts) {
+      try {
+        const v = ctx.use();
+        map[ctx.id] = ctx.serialize(v);
+      } catch {
+      }
+    }
+    if (Object.keys(map).length > 0) {
+      headers["x-runner-context"] = cfg.serializer.stringify(map);
+    }
+  }
+  if (cfg.onRequest) await cfg.onRequest({ url, headers });
+  return await new Promise(
+    (resolve, reject) => {
+      let settled = false;
+      const cleanup = [];
+      const resolveOnce = /* @__PURE__ */ __name((value) => {
+        settled = true;
+        cleanup.forEach((fn) => fn());
+        resolve(value);
+      }, "resolveOnce");
+      const rejectOnce = /* @__PURE__ */ __name((error2) => {
+        settled = true;
+        cleanup.forEach((fn) => fn());
+        reject(error2 instanceof Error ? error2 : new Error(String(error2)));
+      }, "rejectOnce");
+      const req = lib.request(
+        {
+          method: "POST",
+          protocol: parsed.protocol,
+          hostname: parsed.hostname,
+          port: parsed.port,
+          path: parsed.pathname + parsed.search,
+          headers,
+          timeout: cfg.timeoutMs
+        },
+        (res) => {
+          setImmediate(() => {
+            if (!settled)
+              resolveOnce({ stream: res, res });
+          });
+        }
+      );
+      const onReqError = /* @__PURE__ */ __name((e) => rejectOnce(e), "onReqError");
+      req.on("error", onReqError);
+      cleanup.push(() => req.removeListener("error", onReqError));
+      const onPipelineDone = /* @__PURE__ */ __name((err) => {
+        if (err) rejectOnce(err);
+      }, "onPipelineDone");
+      pipeline(stream, req, onPipelineDone);
+    }
+  );
+}
+__name(postOctetStream, "postOctetStream");
+function parseMaybeJsonResponse(res, serializer3) {
+  const contentType = String(res.headers["content-type"]);
+  if (/^application\/json/i.test(contentType)) {
+    const chunks = [];
+    return new Promise((resolve, reject) => {
+      res.on("data", (c) => {
+        chunks.push(Buffer.isBuffer(c) ? c : Buffer.from(String(c)));
+      });
+      res.on("end", () => {
+        try {
+          const text = Buffer.concat(chunks).toString(
+            "utf8"
+          );
+          const json2 = text ? serializer3.parse(text) : void 0;
+          resolve(json2);
+        } catch (e) {
+          reject(e);
+        }
+      });
+      res.on("error", reject);
+    });
+  }
+  return Promise.resolve(res);
+}
+__name(parseMaybeJsonResponse, "parseMaybeJsonResponse");
+function rethrowTyped(registry, error2) {
+  if (registry && error2 && typeof error2 === "object") {
+    const err = error2;
+    if (err.id && err.data) {
+      const helper = registry.get(String(err.id));
+      if (helper) helper.throw(err.data);
+    }
+  }
+  throw error2;
+}
+__name(rethrowTyped, "rethrowTyped");
+function createHttpSmartClient(cfg) {
+  const baseUrl = cfg.baseUrl.replace(/\/$/, "");
+  if (!baseUrl) throw new Error("createHttpSmartClient requires baseUrl");
+  const serializer3 = cfg.serializer;
+  return {
+    async task(id2, input) {
+      const url = `${baseUrl}/task/${encodeURIComponent(id2)}`;
+      if (isReadable(input)) {
+        const { res } = await postOctetStream(cfg, url, input);
+        return res;
+      }
+      if (hasNodeFile(input)) {
+        const manifest = buildNodeManifest(input);
+        const manifestText = serializer3.stringify({
+          input: manifest.input
+        });
+        try {
+          const { res } = await postMultipart(
+            cfg,
+            url,
+            manifestText,
+            manifest.files
+          );
+          const maybe = await parseMaybeJsonResponse(
+            res,
+            serializer3
+          );
+          if (isReadable(maybe)) return maybe;
+          return assertOkEnvelope(maybe, {
+            fallbackMessage: "Tunnel task error"
+          });
+        } catch (error2) {
+          rethrowTyped(cfg.errorRegistry, error2);
+        }
+      }
+      try {
+        const r2 = await postJson(cfg, url, { input });
+        return assertOkEnvelope(r2, {
+          fallbackMessage: "Tunnel task error"
+        });
+      } catch (error2) {
+        rethrowTyped(cfg.errorRegistry, error2);
+      }
+    },
+    async event(id2, payload) {
+      const url = `${baseUrl}/event/${encodeURIComponent(id2)}`;
+      try {
+        const r2 = await postJson(cfg, url, { payload });
+        assertOkEnvelope(r2, { fallbackMessage: "Tunnel event error" });
+      } catch (error2) {
+        rethrowTyped(cfg.errorRegistry, error2);
+      }
+    },
+    async eventWithResult(id2, payload) {
+      const url = `${baseUrl}/event/${encodeURIComponent(id2)}`;
+      try {
+        const r2 = await postJson(cfg, url, {
+          payload,
+          returnPayload: true
+        });
+        if (r2 && typeof r2 === "object" && r2.ok && !("result" in r2)) {
+          throw new TunnelError(
+            "INVALID_RESPONSE",
+            "Tunnel event returnPayload requested but server did not include result. Upgrade the exposure server."
+          );
+        }
+        return assertOkEnvelope(r2, {
+          fallbackMessage: "Tunnel event error"
+        });
+      } catch (error2) {
+        rethrowTyped(cfg.errorRegistry, error2);
+      }
+    }
+  };
+}
+__name(createHttpSmartClient, "createHttpSmartClient");
+
+// src/node/http/http-mixed-client.ts
+function isReadable2(value) {
+  return !!value && typeof value.pipe === "function";
+}
+__name(isReadable2, "isReadable");
+function hasNodeFile2(value) {
+  const isNodeFileSentinel = /* @__PURE__ */ __name((v) => {
+    if (!v || typeof v !== "object") return false;
+    const rec = v;
+    if (rec.$runnerFile !== "File") return false;
+    if (typeof rec.id !== "string") return false;
+    const node = rec._node;
+    if (!node || typeof node !== "object") return false;
+    const n = node;
+    return Boolean(n.stream || n.buffer);
+  }, "isNodeFileSentinel");
+  const visit = /* @__PURE__ */ __name((v) => {
+    if (isNodeFileSentinel(v)) return true;
+    if (!v || typeof v !== "object") return false;
+    if (Array.isArray(v)) return v.some(visit);
+    for (const k of Object.keys(v)) {
+      if (visit(v[k])) return true;
+    }
+    return false;
+  }, "visit");
+  return visit(value);
+}
+__name(hasNodeFile2, "hasNodeFile");
+async function shouldForceSmart(cfg, id2, input) {
+  if (!cfg.forceSmart) return false;
+  if (cfg.forceSmart === true) return true;
+  return await cfg.forceSmart({ id: id2, input });
+}
+__name(shouldForceSmart, "shouldForceSmart");
+function createHttpMixedClient(cfg) {
+  const baseUrl = cfg.baseUrl?.replace(/\/$/, "");
+  if (!baseUrl) throw new Error("createMixedHttpClient requires baseUrl");
+  const fetchClient = createExposureFetch({
+    baseUrl,
+    auth: cfg.auth,
+    timeoutMs: cfg.timeoutMs,
+    fetchImpl: cfg.fetchImpl,
+    serializer: cfg.serializer,
+    onRequest: cfg.onRequest,
+    contexts: cfg.contexts,
+    errorRegistry: cfg.errorRegistry
+  });
+  const smartClient = createHttpSmartClient({
+    baseUrl,
+    auth: cfg.auth,
+    timeoutMs: cfg.timeoutMs,
+    serializer: cfg.serializer,
+    onRequest: cfg.onRequest,
+    contexts: cfg.contexts,
+    errorRegistry: cfg.errorRegistry
+  });
+  return {
+    async task(id2, input) {
+      if (isReadable2(input) || hasNodeFile2(input) || await shouldForceSmart(cfg, id2, input)) {
+        return await smartClient.task(id2, input);
+      }
+      return await fetchClient.task(id2, input);
+    },
+    async event(id2, payload) {
+      return await fetchClient.event(id2, payload);
+    },
+    async eventWithResult(id2, payload) {
+      if (!fetchClient.eventWithResult) {
+        throw new Error(
+          "createHttpMixedClient: eventWithResult not available on underlying tunnel client."
+        );
+      }
+      return await fetchClient.eventWithResult(id2, payload);
+    }
+  };
+}
+__name(createHttpMixedClient, "createHttpMixedClient");
 
 // src/node/durable/core/types.ts
 var ExecutionStatus = {
@@ -40595,9 +40421,10 @@ var DurableResource = class _DurableResource {
       );
     }
     const deps = storeTask.computedDependencies;
+    const resolvedInput = this.resolveDescribeInput(effectiveTask, input);
     return await recordFlowShape(async (ctx) => {
       const depsWithRecorder = this.injectRecorderIntoDurableDeps(deps, ctx);
-      await effectiveTask.run(input, depsWithRecorder);
+      await effectiveTask.run(resolvedInput, depsWithRecorder);
     });
   }
   getWorkflows() {
@@ -40625,6 +40452,23 @@ var DurableResource = class _DurableResource {
     }
     return next;
   }
+  resolveDescribeInput(task2, input) {
+    if (input !== void 0) {
+      return input;
+    }
+    const tagConfig = durableWorkflowTag.extract(task2.tags);
+    if (!tagConfig?.defaults) {
+      return void 0;
+    }
+    try {
+      return structuredClone(tagConfig.defaults);
+    } catch (error2) {
+      const originalMessage = error2 instanceof Error ? error2.message : String(error2);
+      throw new Error(
+        `Cannot describe task "${task2.id}": durableWorkflowTag.defaults could not be cloned. Ensure defaults contain only structured-cloneable values. Original error: ${originalMessage}`
+      );
+    }
+  }
   start(task2, input, options) {
     if (typeof task2 === "string") {
       return this.service.start(task2, input, options);
@@ -44359,50 +44203,6 @@ var redisDurableResource = r.resource("base.durable.redis").register([durableWor
   if (!ctx.runtimeConfig) return;
   await disposeDurableService(durable.service, ctx.runtimeConfig);
 }).build();
-
-// src/node/node.ts
-var globals2 = {
-  ...globals,
-  resources: {
-    ...globals.resources,
-    httpSmartClientFactory,
-    httpMixedClientFactory
-  }
-};
-async function run2(root, config) {
-  const rt = await run(root, config);
-  const store2 = await rt.getResourceValue(globals.resources.store);
-  store2.storeGenericItem(httpSmartClientFactory);
-  store2.storeGenericItem(httpMixedClientFactory);
-  const serializer3 = await rt.getResourceValue(
-    globals.resources.serializer
-  );
-  const errorRegistry = /* @__PURE__ */ new Map();
-  for (const [id2, helper] of store2.errors) errorRegistry.set(id2, helper);
-  const contexts = Array.from(store2.asyncContexts.values());
-  const smartEntry = store2.resources.get(httpSmartClientFactory.id);
-  if (smartEntry && !smartEntry.isInitialized) {
-    smartEntry.value = (cfg) => (init_http_smart_client_model(), __toCommonJS(http_smart_client_model_exports)).createHttpSmartClient({
-      ...cfg,
-      serializer: serializer3,
-      contexts,
-      errorRegistry
-    });
-    smartEntry.isInitialized = true;
-  }
-  const mixedEntry = store2.resources.get(httpMixedClientFactory.id);
-  if (mixedEntry && !mixedEntry.isInitialized) {
-    mixedEntry.value = (cfg) => (init_http_mixed_client(), __toCommonJS(http_mixed_client_exports)).createHttpMixedClient({
-      ...cfg,
-      serializer: serializer3,
-      contexts,
-      errorRegistry
-    });
-    mixedEntry.isInitialized = true;
-  }
-  return rt;
-}
-__name(run2, "run");
 /*! Bundled license information:
 
 depd/index.js:
@@ -44690,6 +44490,6 @@ serve-static/index.js:
    *)
 */
 
-export { DependencyProcessor, DurableAuditEntryKind, DurableContext, DurableExecutionError, DurableOperator, DurableResource, DurableService, DurableWorker, errors_exports as Errors, EventManager, ExecutionStatus, LogPrinter, Logger, MemoryEventBus, MemoryQueue, MemoryStore, MiddlewareManager, NodeInputFile, NoopEventBus, PlatformAdapter, Queue, RabbitMQQueue, RedisEventBus, RedisStore, ResourceInitializer, RunResult, RunnerError, ScheduleStatus, ScheduleType, Semaphore, Serializer, StepBuilder, Store, SuspensionSignal, SymbolPolicy, SymbolPolicyErrorMessage, TaskRunner, TimerStatus, TimerType, allFalse, defineAsyncContext as asyncContext, bindProcessErrorHandler, createContext2 as createContext, createDashboardMiddleware, createDefaultUnhandledError, createDurableAuditEntryId, createDurableRunnerAuditEmitter, createDurableStepId, createDurableTestSetup, createExposureFetch, createHttpClient, createHttpMixedClient, createHttpSmartClient, createNodeFile, createRunnerDurableRuntime, createTestResource, debug, debugLevels, defs_exports as definitions, disposeDurableService, durableEvents, durableEventsArray, durableResource, durableWorkflowTag, defineEvent as event, getConfig, globals2 as globals, hasExposureContext, defineHook as hook, initDurableService, initDurableWorker, isDurableInternalStepId, journal, levelNormal, levelVerbose, memoryDurableResource, nodeExposure, normalizeError, defineOverride as override, r, readInputFileToBuffer, redisDurableResource, defineResource as resource, defineResourceMiddleware as resourceMiddleware, run2 as run, safeReportUnhandledError, setPlatform, defineTag as tag, defineTask as task, defineTaskMiddleware as taskMiddleware, useExposureContext, waitUntil, writeInputFileToPath };
+export { DurableAuditEntryKind, DurableContext, DurableExecutionError, DurableOperator, DurableResource, DurableService, DurableWorker, ExecutionStatus, MemoryEventBus, MemoryQueue, MemoryStore, NodeInputFile, NoopEventBus, RabbitMQQueue, RedisEventBus, RedisStore, ScheduleStatus, ScheduleType, StepBuilder, SuspensionSignal, TimerStatus, TimerType, createDashboardMiddleware, createDurableAuditEntryId, createDurableRunnerAuditEmitter, createDurableStepId, createDurableTestSetup, createHttpMixedClient, createHttpSmartClient, createNodeFile, createRunnerDurableRuntime, disposeDurableService, durableEvents, durableEventsArray, durableResource, durableWorkflowTag, globals, hasExposureContext, initDurableService, initDurableWorker, isDurableInternalStepId, memoryDurableResource, nodeExposure, readInputFileToBuffer, redisDurableResource, run, useExposureContext, waitUntil, writeInputFileToPath };
 //# sourceMappingURL=node.mjs.map
 //# sourceMappingURL=node.mjs.map