@bluelibs/runner 5.3.0 → 5.4.0

package/dist/node/node.cjs

@@ -1,14 +1,14 @@
 'use strict';
 
-var http2 = require('http');
-var https = require('https');
-var stream = require('stream');
 var lruCache = require('lru-cache');
 var crypto = require('crypto');
+var http2 = require('http');
+var stream = require('stream');
 var Busboy = require('busboy');
 var fs3 = require('fs');
 var os = require('os');
 var path3 = require('path');
+var https = require('https');
 var timers = require('timers');
 var module$1 = require('module');
 var async_hooks = require('async_hooks');
@@ -31,13 +31,13 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
-var http2__namespace = /*#__PURE__*/_interopNamespace(http2);
-var https__namespace = /*#__PURE__*/_interopNamespace(https);
 var crypto__namespace = /*#__PURE__*/_interopNamespace(crypto);
+var http2__namespace = /*#__PURE__*/_interopNamespace(http2);
 var Busboy__namespace = /*#__PURE__*/_interopNamespace(Busboy);
 var fs3__namespace = /*#__PURE__*/_interopNamespace(fs3);
 var os__namespace = /*#__PURE__*/_interopNamespace(os);
 var path3__namespace = /*#__PURE__*/_interopNamespace(path3);
+var https__namespace = /*#__PURE__*/_interopNamespace(https);
 
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -52,16 +52,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))
@@ -78,875 +71,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__namespace : http2__namespace;
-}
-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 stream.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$1) {
-  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");
-      stream.pipeline(stream$1, 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({
@@ -28623,7 +27747,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"
 );
@@ -28672,228 +27795,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) => {
@@ -29231,20 +28132,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;
   }
@@ -29253,6 +28201,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) {
@@ -29307,9 +28272,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({
@@ -29367,6 +28337,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 {
@@ -29435,63 +28409,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(
@@ -29540,7 +28457,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?`
@@ -29628,10 +28545,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) {
@@ -30126,12 +29178,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";
@@ -30639,8 +29685,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();
@@ -31399,29 +30561,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);
@@ -31624,11 +30782,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({
@@ -33118,11 +32271,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 = [];
@@ -33179,6 +32539,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");
@@ -33245,12 +32614,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) {
@@ -33261,24 +32625,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) {
@@ -33290,12 +32644,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);
       }
     }
   };
@@ -34229,6 +33578,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) {
@@ -34336,7 +33713,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).
@@ -34479,46 +33865,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
@@ -34715,19 +34090,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 {
@@ -34736,6 +34338,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);
@@ -34872,195 +34486,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;
@@ -35994,6 +35427,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) {
@@ -36058,6 +35548,7 @@ var Store = class {
   }
   lock() {
     this.#isLocked = true;
+    this.registry.lockAll();
   }
   checkLock() {
     if (this.#isLocked) {
@@ -36199,58 +35690,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.
@@ -36533,7 +35973,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;
@@ -36622,13 +36062,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 {
@@ -36827,7 +36260,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;
@@ -36838,39 +36270,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) {
@@ -36916,14 +36324,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";
@@ -37087,14 +36487,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";
@@ -37150,14 +36542,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);
     },
@@ -37233,14 +36625,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
@@ -37329,14 +36721,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) {
@@ -37351,7 +36735,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);
     },
@@ -37399,14 +36783,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";
@@ -37480,7 +36856,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);
     },
@@ -37557,14 +36933,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";
@@ -37645,7 +37013,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);
     },
@@ -37717,7 +37085,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);
     },
@@ -37928,7 +37296,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);
     },
@@ -38133,7 +37501,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);
     },
@@ -38193,14 +37561,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);
     },
@@ -38309,7 +37677,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);
     },
@@ -38361,7 +37729,6 @@ function override(base) {
 __name(override, "override");
 
 // src/public.ts
-init_http_fetch_tunnel_resource();
 var globals = {
   events: globalEvents,
   resources: globalResources,
@@ -38370,7 +37737,6 @@ var globals = {
   tunnels,
   debug
 };
-var createContext2 = createContext;
 var r = Object.freeze({
   resource,
   task,
@@ -39656,7 +39022,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,
@@ -39668,7 +39034,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;
@@ -39864,7 +39230,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(
@@ -39973,7 +39339,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(
@@ -40239,27 +39605,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__namespace : http2__namespace;
+}
+__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 stream.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$1) {
+  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");
+      stream.pipeline(stream$1, 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 = {
@@ -40622,9 +40448,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() {
@@ -40652,6 +40479,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);
@@ -44386,50 +44230,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:
@@ -44717,7 +44517,6 @@ serve-static/index.js:
    *)
 */
 
-exports.DependencyProcessor = DependencyProcessor;
 exports.DurableAuditEntryKind = DurableAuditEntryKind;
 exports.DurableContext = DurableContext;
 exports.DurableExecutionError = DurableExecutionError;
@@ -44725,88 +44524,45 @@ exports.DurableOperator = DurableOperator;
 exports.DurableResource = DurableResource;
 exports.DurableService = DurableService;
 exports.DurableWorker = DurableWorker;
-exports.Errors = errors_exports;
-exports.EventManager = EventManager;
 exports.ExecutionStatus = ExecutionStatus;
-exports.LogPrinter = LogPrinter;
-exports.Logger = Logger;
 exports.MemoryEventBus = MemoryEventBus;
 exports.MemoryQueue = MemoryQueue;
 exports.MemoryStore = MemoryStore;
-exports.MiddlewareManager = MiddlewareManager;
 exports.NodeInputFile = NodeInputFile;
 exports.NoopEventBus = NoopEventBus;
-exports.PlatformAdapter = PlatformAdapter;
-exports.Queue = Queue;
 exports.RabbitMQQueue = RabbitMQQueue;
 exports.RedisEventBus = RedisEventBus;
 exports.RedisStore = RedisStore;
-exports.ResourceInitializer = ResourceInitializer;
-exports.RunResult = RunResult;
-exports.RunnerError = RunnerError;
 exports.ScheduleStatus = ScheduleStatus;
 exports.ScheduleType = ScheduleType;
-exports.Semaphore = Semaphore;
-exports.Serializer = Serializer;
 exports.StepBuilder = StepBuilder;
-exports.Store = Store;
 exports.SuspensionSignal = SuspensionSignal;
-exports.SymbolPolicy = SymbolPolicy;
-exports.SymbolPolicyErrorMessage = SymbolPolicyErrorMessage;
-exports.TaskRunner = TaskRunner;
 exports.TimerStatus = TimerStatus;
 exports.TimerType = TimerType;
-exports.allFalse = allFalse;
-exports.asyncContext = defineAsyncContext;
-exports.bindProcessErrorHandler = bindProcessErrorHandler;
-exports.createContext = createContext2;
 exports.createDashboardMiddleware = createDashboardMiddleware;
-exports.createDefaultUnhandledError = createDefaultUnhandledError;
 exports.createDurableAuditEntryId = createDurableAuditEntryId;
 exports.createDurableRunnerAuditEmitter = createDurableRunnerAuditEmitter;
 exports.createDurableStepId = createDurableStepId;
 exports.createDurableTestSetup = createDurableTestSetup;
-exports.createExposureFetch = createExposureFetch;
-exports.createHttpClient = createHttpClient;
 exports.createHttpMixedClient = createHttpMixedClient;
 exports.createHttpSmartClient = createHttpSmartClient;
 exports.createNodeFile = createNodeFile;
 exports.createRunnerDurableRuntime = createRunnerDurableRuntime;
-exports.createTestResource = createTestResource;
-exports.debug = debug;
-exports.debugLevels = debugLevels;
-exports.definitions = defs_exports;
 exports.disposeDurableService = disposeDurableService;
 exports.durableEvents = durableEvents;
 exports.durableEventsArray = durableEventsArray;
 exports.durableResource = durableResource;
 exports.durableWorkflowTag = durableWorkflowTag;
-exports.event = defineEvent;
-exports.getConfig = getConfig;
-exports.globals = globals2;
+exports.globals = globals;
 exports.hasExposureContext = hasExposureContext;
-exports.hook = defineHook;
 exports.initDurableService = initDurableService;
 exports.initDurableWorker = initDurableWorker;
 exports.isDurableInternalStepId = isDurableInternalStepId;
-exports.journal = journal;
-exports.levelNormal = levelNormal;
-exports.levelVerbose = levelVerbose;
 exports.memoryDurableResource = memoryDurableResource;
 exports.nodeExposure = nodeExposure;
-exports.normalizeError = normalizeError;
-exports.override = defineOverride;
-exports.r = r;
 exports.readInputFileToBuffer = readInputFileToBuffer;
 exports.redisDurableResource = redisDurableResource;
-exports.resource = defineResource;
-exports.resourceMiddleware = defineResourceMiddleware;
-exports.run = run2;
-exports.safeReportUnhandledError = safeReportUnhandledError;
-exports.setPlatform = setPlatform;
-exports.tag = defineTag;
-exports.task = defineTask;
-exports.taskMiddleware = defineTaskMiddleware;
+exports.run = run;
 exports.useExposureContext = useExposureContext;
 exports.waitUntil = waitUntil;
 exports.writeInputFileToPath = writeInputFileToPath;