@bluelibs/runner 5.2.1 → 5.4.0

package/dist/node/node.mjs

@@ -1,13 +1,13 @@
-import * as http2 from 'http';
-import * as https from 'https';
-import { pipeline, Readable, Transform, PassThrough } from 'stream';
 import { LRUCache } from 'lru-cache';
 import * as crypto from 'crypto';
+import * as http2 from 'http';
+import { pipeline, Transform, Readable, PassThrough } from 'stream';
 import * as Busboy from 'busboy';
 import * as fs3 from 'fs';
 import * as os from 'os';
 import * as path3 from 'path';
 import { join } from 'path';
+import * as https from 'https';
 import { setTimeout as setTimeout$1, clearTimeout as clearTimeout$1 } from 'timers';
 import { createRequire } from 'module';
 import { AsyncLocalStorage } from 'async_hooks';
@@ -25,16 +25,9 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   if (typeof require !== "undefined") return require.apply(this, arguments);
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
 var __commonJS = (cb, mod) => function __require2() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -51,873 +44,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   __defProp(target, "default", { value: mod, enumerable: true }) ,
   mod
 ));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/serializer/regexp-validator.ts
-var regexp_validator_exports = {};
-__export(regexp_validator_exports, {
-  assertRegExpPayload: () => assertRegExpPayload,
-  isBoundedQuantifier: () => isBoundedQuantifier,
-  isQuantifierAt: () => isQuantifierAt,
-  isQuantifierChar: () => isQuantifierChar,
-  isRegExpPatternSafe: () => isRegExpPatternSafe
-});
-var isQuantifierAt, isQuantifierChar, isBoundedQuantifier, isRegExpPatternSafe, assertRegExpPayload;
-var init_regexp_validator = __esm({
-  "src/serializer/regexp-validator.ts"() {
-    isQuantifierAt = /* @__PURE__ */ __name((pattern, index) => {
-      if (index >= pattern.length) {
-        return false;
-      }
-      const char = pattern[index];
-      if (char === "*" || char === "+" || char === "?") {
-        return true;
-      }
-      if (char === "{") {
-        return isBoundedQuantifier(pattern, index);
-      }
-      return false;
-    }, "isQuantifierAt");
-    isQuantifierChar = /* @__PURE__ */ __name((char, pattern, index) => {
-      if (char === "*" || char === "+") {
-        return true;
-      }
-      if (char === "?") {
-        if (index > 0 && pattern[index - 1] === "(") {
-          return false;
-        }
-        return true;
-      }
-      if (char === "{") {
-        return isBoundedQuantifier(pattern, index);
-      }
-      return false;
-    }, "isQuantifierChar");
-    isBoundedQuantifier = /* @__PURE__ */ __name((pattern, index) => {
-      let sawDigit = false;
-      let sawComma = false;
-      for (let i = index + 1; i < pattern.length; i += 1) {
-        const char = pattern[i];
-        if (char >= "0" && char <= "9") {
-          sawDigit = true;
-          continue;
-        }
-        if (char === "," && !sawComma) {
-          sawComma = true;
-          continue;
-        }
-        if (char === "}") {
-          return sawDigit;
-        }
-        return false;
-      }
-      return false;
-    }, "isBoundedQuantifier");
-    isRegExpPatternSafe = /* @__PURE__ */ __name((pattern) => {
-      const groupStack = [];
-      let escaped = false;
-      let inCharClass = false;
-      for (let index = 0; index < pattern.length; index += 1) {
-        const char = pattern[index];
-        if (escaped) {
-          escaped = false;
-          continue;
-        }
-        if (char === "\\") {
-          escaped = true;
-          continue;
-        }
-        if (inCharClass) {
-          if (char === "]") {
-            inCharClass = false;
-          }
-          continue;
-        }
-        if (char === "[") {
-          inCharClass = true;
-          continue;
-        }
-        if (char === "(") {
-          groupStack.push({ hasQuantifier: false });
-          if (pattern[index + 1] === "?") {
-            index += 1;
-          }
-          continue;
-        }
-        if (char === ")") {
-          const group = groupStack.pop();
-          if (group?.hasQuantifier && isQuantifierAt(pattern, index + 1)) {
-            return false;
-          }
-          if (group?.hasQuantifier && groupStack.length > 0) {
-            groupStack[groupStack.length - 1].hasQuantifier = true;
-          }
-          continue;
-        }
-        if (isQuantifierChar(char, pattern, index)) {
-          if (groupStack.length > 0) {
-            groupStack[groupStack.length - 1].hasQuantifier = true;
-          }
-        }
-      }
-      return true;
-    }, "isRegExpPatternSafe");
-    assertRegExpPayload = /* @__PURE__ */ __name((value, options) => {
-      if (!value || typeof value !== "object") {
-        throw new Error("Invalid RegExp payload");
-      }
-      const record = value;
-      if (typeof record.pattern !== "string" || typeof record.flags !== "string") {
-        throw new Error("Invalid RegExp payload");
-      }
-      if (record.pattern.length > options.maxPatternLength) {
-        throw new Error(
-          `RegExp pattern exceeds limit (${options.maxPatternLength})`
-        );
-      }
-      if (!options.allowUnsafe && !isRegExpPatternSafe(record.pattern)) {
-        throw new Error("Unsafe RegExp pattern");
-      }
-      return { pattern: record.pattern, flags: record.flags };
-    }, "assertRegExpPayload");
-  }
-});
-
-// src/globals/resources/tunnel/protocol.ts
-function toTunnelError(input, fallbackMessage) {
-  if (input instanceof Error) {
-    return new TunnelError("UNKNOWN", input.message);
-  }
-  if (input && typeof input === "object" && "code" in input && "message" in input) {
-    const typed = input;
-    if (typeof typed.message === "string" && typeof typed.code === "string") {
-      const pe = input;
-      const msg = pe.message || fallbackMessage || "Tunnel error";
-      return new TunnelError(pe.code, msg, pe.details, {
-        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.id = extras?.id;
-        this.data = extras?.data;
-      }
-    };
-    __name(toTunnelError, "toTunnelError");
-    __name(assertOkEnvelope, "assertOkEnvelope");
-  }
-});
-
-// src/globals/resources/tunnel/error-utils.ts
-function normalizeError(input) {
-  return input instanceof Error ? input : new Error(String(input));
-}
-var init_error_utils = __esm({
-  "src/globals/resources/tunnel/error-utils.ts"() {
-    __name(normalizeError, "normalizeError");
-  }
-});
-
-// src/http-fetch-tunnel.resource.ts
-async function postSerialized(options) {
-  const {
-    fetch: fetchFn,
-    url,
-    body,
-    headers,
-    timeoutMs,
-    serializer: serializer3,
-    onRequest,
-    contextHeaderText
-  } = options;
-  const controller = timeoutMs && timeoutMs > 0 ? new AbortController() : void 0;
-  let timeout;
-  try {
-    if (controller) {
-      timeout = setTimeout(() => controller.abort(), timeoutMs);
-    }
-    const reqHeaders = {
-      "content-type": "application/json; charset=utf-8",
-      ...headers
-    };
-    if (contextHeaderText) reqHeaders["x-runner-context"] = contextHeaderText;
-    if (onRequest) await onRequest({ url, headers: reqHeaders });
-    const res = await fetchFn(url, {
-      method: "POST",
-      headers: reqHeaders,
-      body: serializer3.stringify(body),
-      signal: controller?.signal
-    });
-    const text = await res.text();
-    const json2 = text ? serializer3.parse(text) : void 0;
-    return json2;
-  } finally {
-    if (timeout) clearTimeout(timeout);
-  }
-}
-function createExposureFetch(cfg) {
-  const baseUrl = cfg?.baseUrl?.replace(/\/$/, "");
-  if (!baseUrl) throw new Error("createExposureFetch requires baseUrl");
-  const headerName = (cfg?.auth?.header ?? "x-runner-token").toLowerCase();
-  const buildHeaders = /* @__PURE__ */ __name(() => {
-    const headers = {};
-    if (cfg?.auth?.token) headers[headerName] = cfg.auth.token;
-    return headers;
-  }, "buildHeaders");
-  const fetchImpl = cfg.fetchImpl ?? globalThis.fetch;
-  if (typeof fetchImpl !== "function") {
-    throw new Error(
-      "global fetch is not available; provide fetchImpl in config"
-    );
-  }
-  const buildContextHeader = /* @__PURE__ */ __name(() => {
-    if (!cfg.contexts || cfg.contexts.length === 0) return void 0;
-    const map = {};
-    for (const ctx of cfg.contexts) {
-      try {
-        const v = ctx.use();
-        map[ctx.id] = ctx.serialize(v);
-      } catch {
-      }
-    }
-    const keys = Object.keys(map);
-    if (keys.length === 0) return void 0;
-    return cfg.serializer.stringify(map);
-  }, "buildContextHeader");
-  return {
-    async task(id2, input) {
-      const url = `${baseUrl}/task/${encodeURIComponent(id2)}`;
-      const r2 = await postSerialized({
-        fetch: fetchImpl,
-        url,
-        body: { input },
-        headers: buildHeaders(),
-        timeoutMs: cfg?.timeoutMs,
-        serializer: cfg.serializer,
-        onRequest: cfg?.onRequest,
-        contextHeaderText: buildContextHeader()
-      });
-      try {
-        return assertOkEnvelope(r2, { fallbackMessage: "Tunnel task error" });
-      } catch (e) {
-        const te = e;
-        if (cfg.errorRegistry && te.id && te.data) {
-          const helper = cfg.errorRegistry.get(String(te.id));
-          if (helper) helper.throw(te.data);
-        }
-        throw e;
-      }
-    },
-    async event(id2, payload) {
-      const url = `${baseUrl}/event/${encodeURIComponent(id2)}`;
-      const r2 = await postSerialized({
-        fetch: fetchImpl,
-        url,
-        body: { payload },
-        headers: buildHeaders(),
-        timeoutMs: cfg?.timeoutMs,
-        serializer: cfg.serializer,
-        onRequest: cfg?.onRequest,
-        contextHeaderText: buildContextHeader()
-      });
-      try {
-        assertOkEnvelope(r2, { fallbackMessage: "Tunnel event error" });
-      } catch (e) {
-        const te = e;
-        if (cfg.errorRegistry && te.id && te.data) {
-          const helper = cfg.errorRegistry.get(String(te.id));
-          if (helper) helper.throw(te.data);
-        }
-        throw e;
-      }
-    },
-    async eventWithResult(id2, payload) {
-      const url = `${baseUrl}/event/${encodeURIComponent(id2)}`;
-      const r2 = await postSerialized({
-        fetch: fetchImpl,
-        url,
-        body: { payload, returnPayload: true },
-        headers: buildHeaders(),
-        timeoutMs: cfg?.timeoutMs,
-        serializer: cfg.serializer,
-        onRequest: cfg?.onRequest,
-        contextHeaderText: buildContextHeader()
-      });
-      if (r2 && typeof r2 === "object" && r2.ok && !("result" in r2)) {
-        throw new TunnelError(
-          "INVALID_RESPONSE",
-          "Tunnel event returnPayload requested but server did not include result. Upgrade the exposure server."
-        );
-      }
-      try {
-        return assertOkEnvelope(r2, {
-          fallbackMessage: "Tunnel event error"
-        });
-      } catch (e) {
-        const te = e;
-        if (cfg.errorRegistry && te.id && te.data) {
-          const helper = cfg.errorRegistry.get(String(te.id));
-          if (helper) helper.throw(te.data);
-        }
-        throw e;
-      }
-    }
-  };
-}
-var init_http_fetch_tunnel_resource = __esm({
-  "src/http-fetch-tunnel.resource.ts"() {
-    init_protocol();
-    init_error_utils();
-    __name(postSerialized, "postSerialized");
-    __name(createExposureFetch, "createExposureFetch");
-  }
-});
-
-// src/node/upload/manifest.ts
-function buildNodeManifest(input) {
-  const files = [];
-  function visit(value) {
-    if (!value || typeof value !== "object") return value;
-    const potentialFile = value;
-    if (potentialFile.$runnerFile === "File" && typeof potentialFile.id === "string") {
-      const id2 = potentialFile.id;
-      const meta = potentialFile.meta;
-      const local = potentialFile._node;
-      if (local?.buffer) {
-        files.push({
-          id: id2,
-          meta,
-          source: { type: "buffer", buffer: local.buffer }
-        });
-      } else if (local?.stream) {
-        files.push({
-          id: id2,
-          meta,
-          source: { type: "stream", stream: local.stream }
-        });
-      }
-      const copy = { $runnerFile: "File", id: id2, meta };
-      return copy;
-    }
-    if (Array.isArray(value)) {
-      return value.map((x) => visit(x));
-    }
-    const out = {};
-    const obj = value;
-    for (const k of Object.keys(obj)) {
-      out[k] = visit(obj[k]);
-    }
-    return out;
-  }
-  __name(visit, "visit");
-  const cloned = visit(input);
-  return { input: cloned, files };
-}
-var init_manifest = __esm({
-  "src/node/upload/manifest.ts"() {
-    __name(buildNodeManifest, "buildNodeManifest");
-  }
-});
-
-// src/node/http/http-smart-client.model.ts
-var http_smart_client_model_exports = {};
-__export(http_smart_client_model_exports, {
-  createHttpSmartClient: () => createHttpSmartClient
-});
-function isReadable(value) {
-  return !!value && typeof value.pipe === "function";
-}
-function hasNodeFile(value) {
-  const isNodeFileSentinel = /* @__PURE__ */ __name((v) => {
-    if (!v || typeof v !== "object") return false;
-    const rec = v;
-    if (rec.$runnerFile !== "File") return false;
-    if (typeof rec.id !== "string") return false;
-    const node = rec._node;
-    if (!node || typeof node !== "object") return false;
-    const n = node;
-    return Boolean(n.stream || n.buffer);
-  }, "isNodeFileSentinel");
-  const visit = /* @__PURE__ */ __name((v) => {
-    if (isNodeFileSentinel(v)) return true;
-    if (!v || typeof v !== "object") return false;
-    if (Array.isArray(v)) return v.some(visit);
-    for (const k of Object.keys(v)) {
-      if (visit(v[k])) return true;
-    }
-    return false;
-  }, "visit");
-  return visit(value);
-}
-function toHeaders2(auth) {
-  const headers = {};
-  if (auth?.token)
-    headers[(auth.header ?? "x-runner-token").toLowerCase()] = auth.token;
-  return headers;
-}
-function requestLib(url) {
-  return url.protocol === "https:" ? https : http2;
-}
-async function postJson(cfg, url, body) {
-  const serializer3 = cfg.serializer;
-  const parsed = new URL(url);
-  const lib = requestLib(parsed);
-  const headers = {
-    "content-type": "application/json; charset=utf-8",
-    ...toHeaders2(cfg.auth)
-  };
-  if (cfg.contexts && cfg.contexts.length > 0) {
-    const map = {};
-    for (const ctx of cfg.contexts) {
-      try {
-        const v = ctx.use();
-        map[ctx.id] = ctx.serialize(v);
-      } catch {
-      }
-    }
-    if (Object.keys(map).length > 0) {
-      headers["x-runner-context"] = cfg.serializer.stringify(map);
-    }
-  }
-  if (cfg.onRequest) await cfg.onRequest({ url, headers });
-  return await new Promise((resolve, reject) => {
-    const req = lib.request(
-      {
-        method: "POST",
-        protocol: parsed.protocol,
-        hostname: parsed.hostname,
-        port: parsed.port,
-        path: parsed.pathname + parsed.search,
-        headers,
-        timeout: cfg.timeoutMs
-      },
-      (res) => {
-        const chunks = [];
-        res.on("data", (c) => {
-          chunks.push(Buffer.isBuffer(c) ? c : Buffer.from(String(c)));
-        });
-        res.on("end", () => {
-          const text = Buffer.concat(chunks).toString(
-            "utf8"
-          );
-          const json2 = text ? serializer3.parse(text) : void 0;
-          resolve(json2);
-        });
-      }
-    );
-    req.on("error", reject);
-    req.write(serializer3.stringify(body));
-    req.end();
-  });
-}
-function escapeHeaderValue(value) {
-  return value.replace(/"/g, '\\"');
-}
-function encodeMultipart(manifestText, files, boundary) {
-  async function* gen() {
-    const CRLF = "\r\n";
-    const boundaryLine = `--${boundary}`;
-    const partHeader = /* @__PURE__ */ __name((name, options) => {
-      const h = [boundaryLine + CRLF];
-      const cd = [
-        `Content-Disposition: form-data; name="${escapeHeaderValue(name)}"`
-      ];
-      if (options?.filename) {
-        cd.push(`; filename="${escapeHeaderValue(options.filename)}"`);
-      }
-      h.push(cd.join("") + CRLF);
-      if (options?.headers) {
-        for (const k of Object.keys(options.headers)) {
-          h.push(`${k}: ${options.headers[k]}` + CRLF);
-        }
-      }
-      h.push(CRLF);
-      return Buffer.from(h.join(""), "utf8");
-    }, "partHeader");
-    yield partHeader("__manifest");
-    yield Buffer.from(manifestText, "utf8");
-    yield Buffer.from(CRLF, "utf8");
-    for (const entry of files) {
-      const filename = entry.meta?.name ?? "upload";
-      const contentType = entry.meta?.type ?? "application/octet-stream";
-      const headers = {
-        "Content-Type": contentType
-      };
-      yield partHeader(`file:${entry.id}`, { headers, filename });
-      if (entry.source.type === "buffer") {
-        yield entry.source.buffer;
-      } else {
-        for await (const chunk of entry.source.stream) {
-          yield Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk));
-        }
-      }
-      yield Buffer.from(CRLF, "utf8");
-    }
-    yield Buffer.from(boundaryLine + "--" + CRLF, "utf8");
-  }
-  __name(gen, "gen");
-  return Readable.from(gen());
-}
-async function postMultipart(cfg, url, manifestText, files) {
-  const parsed = new URL(url);
-  const lib = requestLib(parsed);
-  const boundary = `runner-${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
-  const body = encodeMultipart(manifestText, files, boundary);
-  const headers = {
-    "content-type": `multipart/form-data; boundary=${boundary}`,
-    ...toHeaders2(cfg.auth)
-  };
-  if (cfg.contexts && cfg.contexts.length > 0) {
-    const map = {};
-    for (const ctx of cfg.contexts) {
-      try {
-        const v = ctx.use();
-        map[ctx.id] = ctx.serialize(v);
-      } catch {
-      }
-    }
-    if (Object.keys(map).length > 0) {
-      headers["x-runner-context"] = cfg.serializer.stringify(map);
-    }
-  }
-  if (cfg.onRequest) await cfg.onRequest({ url, headers });
-  return await new Promise(
-    (resolve, reject) => {
-      const req = lib.request(
-        {
-          method: "POST",
-          protocol: parsed.protocol,
-          hostname: parsed.hostname,
-          port: parsed.port,
-          path: parsed.pathname + parsed.search,
-          headers,
-          timeout: cfg.timeoutMs
-        },
-        (res) => resolve({ stream: res, res })
-      );
-      req.on("error", reject);
-      body.on("error", (e) => req.destroy(e));
-      body.pipe(req);
-    }
-  );
-}
-async function postOctetStream(cfg, url, stream) {
-  const parsed = new URL(url);
-  const lib = requestLib(parsed);
-  const headers = {
-    "content-type": "application/octet-stream",
-    ...toHeaders2(cfg.auth)
-  };
-  if (cfg.contexts && cfg.contexts.length > 0) {
-    const map = {};
-    for (const ctx of cfg.contexts) {
-      try {
-        const v = ctx.use();
-        map[ctx.id] = ctx.serialize(v);
-      } catch {
-      }
-    }
-    if (Object.keys(map).length > 0) {
-      headers["x-runner-context"] = cfg.serializer.stringify(map);
-    }
-  }
-  if (cfg.onRequest) await cfg.onRequest({ url, headers });
-  return await new Promise(
-    (resolve, reject) => {
-      let settled = false;
-      const cleanup = [];
-      const resolveOnce = /* @__PURE__ */ __name((value) => {
-        settled = true;
-        cleanup.forEach((fn) => fn());
-        resolve(value);
-      }, "resolveOnce");
-      const rejectOnce = /* @__PURE__ */ __name((error2) => {
-        settled = true;
-        cleanup.forEach((fn) => fn());
-        reject(error2 instanceof Error ? error2 : new Error(String(error2)));
-      }, "rejectOnce");
-      const req = lib.request(
-        {
-          method: "POST",
-          protocol: parsed.protocol,
-          hostname: parsed.hostname,
-          port: parsed.port,
-          path: parsed.pathname + parsed.search,
-          headers,
-          timeout: cfg.timeoutMs
-        },
-        (res) => {
-          setImmediate(() => {
-            if (!settled)
-              resolveOnce({ stream: res, res });
-          });
-        }
-      );
-      const onReqError = /* @__PURE__ */ __name((e) => rejectOnce(e), "onReqError");
-      req.on("error", onReqError);
-      cleanup.push(() => req.removeListener("error", onReqError));
-      const onPipelineDone = /* @__PURE__ */ __name((err) => {
-        if (err) rejectOnce(err);
-      }, "onPipelineDone");
-      pipeline(stream, req, onPipelineDone);
-    }
-  );
-}
-function parseMaybeJsonResponse(res, serializer3) {
-  const contentType = String(res.headers["content-type"]);
-  if (/^application\/json/i.test(contentType)) {
-    const chunks = [];
-    return new Promise((resolve, reject) => {
-      res.on("data", (c) => {
-        chunks.push(Buffer.isBuffer(c) ? c : Buffer.from(String(c)));
-      });
-      res.on("end", () => {
-        try {
-          const text = Buffer.concat(chunks).toString(
-            "utf8"
-          );
-          const json2 = text ? serializer3.parse(text) : void 0;
-          resolve(json2);
-        } catch (e) {
-          reject(e);
-        }
-      });
-      res.on("error", reject);
-    });
-  }
-  return Promise.resolve(res);
-}
-function rethrowTyped(registry, error2) {
-  if (registry && error2 && typeof error2 === "object") {
-    const err = error2;
-    if (err.id && err.data) {
-      const helper = registry.get(String(err.id));
-      if (helper) helper.throw(err.data);
-    }
-  }
-  throw error2;
-}
-function createHttpSmartClient(cfg) {
-  const baseUrl = cfg.baseUrl.replace(/\/$/, "");
-  if (!baseUrl) throw new Error("createHttpSmartClient requires baseUrl");
-  const serializer3 = cfg.serializer;
-  return {
-    async task(id2, input) {
-      const url = `${baseUrl}/task/${encodeURIComponent(id2)}`;
-      if (isReadable(input)) {
-        const { res } = await postOctetStream(cfg, url, input);
-        return res;
-      }
-      if (hasNodeFile(input)) {
-        const manifest = buildNodeManifest(input);
-        const manifestText = serializer3.stringify({
-          input: manifest.input
-        });
-        try {
-          const { res } = await postMultipart(
-            cfg,
-            url,
-            manifestText,
-            manifest.files
-          );
-          const maybe = await parseMaybeJsonResponse(
-            res,
-            serializer3
-          );
-          if (isReadable(maybe)) return maybe;
-          return assertOkEnvelope(maybe, {
-            fallbackMessage: "Tunnel task error"
-          });
-        } catch (error2) {
-          rethrowTyped(cfg.errorRegistry, error2);
-        }
-      }
-      try {
-        const r2 = await postJson(cfg, url, { input });
-        return assertOkEnvelope(r2, {
-          fallbackMessage: "Tunnel task error"
-        });
-      } catch (error2) {
-        rethrowTyped(cfg.errorRegistry, error2);
-      }
-    },
-    async event(id2, payload) {
-      const url = `${baseUrl}/event/${encodeURIComponent(id2)}`;
-      try {
-        const r2 = await postJson(cfg, url, { payload });
-        assertOkEnvelope(r2, { fallbackMessage: "Tunnel event error" });
-      } catch (error2) {
-        rethrowTyped(cfg.errorRegistry, error2);
-      }
-    },
-    async eventWithResult(id2, payload) {
-      const url = `${baseUrl}/event/${encodeURIComponent(id2)}`;
-      try {
-        const r2 = await postJson(cfg, url, {
-          payload,
-          returnPayload: true
-        });
-        if (r2 && typeof r2 === "object" && r2.ok && !("result" in r2)) {
-          throw new TunnelError(
-            "INVALID_RESPONSE",
-            "Tunnel event returnPayload requested but server did not include result. Upgrade the exposure server."
-          );
-        }
-        return assertOkEnvelope(r2, {
-          fallbackMessage: "Tunnel event error"
-        });
-      } catch (error2) {
-        rethrowTyped(cfg.errorRegistry, error2);
-      }
-    }
-  };
-}
-var init_http_smart_client_model = __esm({
-  "src/node/http/http-smart-client.model.ts"() {
-    init_protocol();
-    init_manifest();
-    __name(isReadable, "isReadable");
-    __name(hasNodeFile, "hasNodeFile");
-    __name(toHeaders2, "toHeaders");
-    __name(requestLib, "requestLib");
-    __name(postJson, "postJson");
-    __name(escapeHeaderValue, "escapeHeaderValue");
-    __name(encodeMultipart, "encodeMultipart");
-    __name(postMultipart, "postMultipart");
-    __name(postOctetStream, "postOctetStream");
-    __name(parseMaybeJsonResponse, "parseMaybeJsonResponse");
-    __name(rethrowTyped, "rethrowTyped");
-    __name(createHttpSmartClient, "createHttpSmartClient");
-  }
-});
-
-// src/node/http/http-mixed-client.ts
-var http_mixed_client_exports = {};
-__export(http_mixed_client_exports, {
-  createHttpMixedClient: () => createHttpMixedClient
-});
-function isReadable2(value) {
-  return !!value && typeof value.pipe === "function";
-}
-function hasNodeFile2(value) {
-  const isNodeFileSentinel = /* @__PURE__ */ __name((v) => {
-    if (!v || typeof v !== "object") return false;
-    const rec = v;
-    if (rec.$runnerFile !== "File") return false;
-    if (typeof rec.id !== "string") return false;
-    const node = rec._node;
-    if (!node || typeof node !== "object") return false;
-    const n = node;
-    return Boolean(n.stream || n.buffer);
-  }, "isNodeFileSentinel");
-  const visit = /* @__PURE__ */ __name((v) => {
-    if (isNodeFileSentinel(v)) return true;
-    if (!v || typeof v !== "object") return false;
-    if (Array.isArray(v)) return v.some(visit);
-    for (const k of Object.keys(v)) {
-      if (visit(v[k])) return true;
-    }
-    return false;
-  }, "visit");
-  return visit(value);
-}
-async function shouldForceSmart(cfg, id2, input) {
-  if (!cfg.forceSmart) return false;
-  if (cfg.forceSmart === true) return true;
-  return await cfg.forceSmart({ id: id2, input });
-}
-function createHttpMixedClient(cfg) {
-  const baseUrl = cfg.baseUrl?.replace(/\/$/, "");
-  if (!baseUrl) throw new Error("createMixedHttpClient requires baseUrl");
-  const fetchClient = createExposureFetch({
-    baseUrl,
-    auth: cfg.auth,
-    timeoutMs: cfg.timeoutMs,
-    fetchImpl: cfg.fetchImpl,
-    serializer: cfg.serializer,
-    onRequest: cfg.onRequest,
-    contexts: cfg.contexts,
-    errorRegistry: cfg.errorRegistry
-  });
-  const smartClient = createHttpSmartClient({
-    baseUrl,
-    auth: cfg.auth,
-    timeoutMs: cfg.timeoutMs,
-    serializer: cfg.serializer,
-    onRequest: cfg.onRequest,
-    contexts: cfg.contexts,
-    errorRegistry: cfg.errorRegistry
-  });
-  return {
-    async task(id2, input) {
-      if (isReadable2(input) || hasNodeFile2(input) || await shouldForceSmart(cfg, id2, input)) {
-        return await smartClient.task(id2, input);
-      }
-      return await fetchClient.task(id2, input);
-    },
-    async event(id2, payload) {
-      return await fetchClient.event(id2, payload);
-    },
-    async eventWithResult(id2, payload) {
-      if (!fetchClient.eventWithResult) {
-        throw new Error(
-          "createHttpMixedClient: eventWithResult not available on underlying tunnel client."
-        );
-      }
-      return await fetchClient.eventWithResult(id2, payload);
-    }
-  };
-}
-var init_http_mixed_client = __esm({
-  "src/node/http/http-mixed-client.ts"() {
-    init_http_fetch_tunnel_resource();
-    init_http_smart_client_model();
-    __name(isReadable2, "isReadable");
-    __name(hasNodeFile2, "hasNodeFile");
-    __name(shouldForceSmart, "shouldForceSmart");
-    __name(createHttpMixedClient, "createHttpMixedClient");
-  }
-});
 
 // node_modules/ms/index.js
 var require_ms = __commonJS({
@@ -28588,15 +27714,12 @@ var symbolPhantomTask = Symbol.for(
   "runner.task.phantom"
 );
 var symbolResource = Symbol.for("runner.resource");
-var symbolResourceForkedFrom = Symbol.for(
-  "runner.resourceForkedFrom"
-);
+var symbolForkedFrom = Symbol.for("runner.forkedFrom");
 var symbolResourceWithConfig = Symbol.for(
   "runner.resourceWithConfig"
 );
 var symbolEvent = Symbol.for("runner.event");
 var symbolError = Symbol.for("runner.error");
-var symbolMiddleware = Symbol.for("runner.middleware");
 var symbolTaskMiddleware = Symbol.for(
   "runner.taskMiddleware"
 );
@@ -28645,235 +27768,27 @@ 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,
-  symbolHook: () => symbolHook,
-  symbolMiddleware: () => symbolMiddleware,
-  symbolMiddlewareConfigured: () => symbolMiddlewareConfigured,
-  symbolOptionalDependency: () => symbolOptionalDependency,
-  symbolPhantomTask: () => symbolPhantomTask,
-  symbolResource: () => symbolResource,
-  symbolResourceForkedFrom: () => symbolResourceForkedFrom,
-  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) => {
+  if (!isValidHttpCode(value)) {
+    throw new Error(
+      `Error httpCode must be an integer between 100 and 599. Received: ${value}`
+    );
+  }
+}, "assertHttpCode");
 var RunnerError = class extends Error {
-  constructor(id2, message, data) {
-    super(message);
+  constructor(id2, message, data, httpCode, remediation) {
+    super(
+      remediation !== void 0 ? `${message}
+
+Remediation: ${remediation}` : message
+    );
     this.id = id2;
     this.data = data;
     this.name = id2;
+    this.httpCode = httpCode;
+    this.remediation = remediation;
   }
   static {
     __name(this, "RunnerError");
@@ -28893,10 +27808,20 @@ var ErrorHelper = class {
   get id() {
     return this.definition.id;
   }
+  get httpCode() {
+    return this.definition.httpCode;
+  }
   throw(data) {
     const parsed = this.definition.dataSchema ? this.definition.dataSchema.parse(data) : data;
     const message = this.definition.format(parsed);
-    throw new RunnerError(this.definition.id, message, parsed);
+    const remediation = typeof this.definition.remediation === "function" ? this.definition.remediation(parsed) : this.definition.remediation;
+    throw new RunnerError(
+      this.definition.id,
+      message,
+      parsed,
+      this.definition.httpCode,
+      remediation
+    );
   }
   is(error2) {
     return error2 instanceof RunnerError && error2.name === this.definition.id;
@@ -28909,6 +27834,9 @@ var ErrorHelper = class {
   }
 };
 function defineError(definition, filePath) {
+  if (definition.httpCode !== void 0) {
+    assertHttpCode(definition.httpCode);
+  }
   if (!definition.format) {
     definition.format = (data) => `${JSON.stringify(data)}`;
   }
@@ -28930,9 +27858,22 @@ function clone(s, patch) {
 __name(clone, "clone");
 
 // src/definers/builders/error/fluent-builder.ts
+var isValidHttpCode2 = /* @__PURE__ */ __name((value) => Number.isInteger(value) && value >= 100 && value <= 599, "isValidHttpCode");
+var assertHttpCode2 = /* @__PURE__ */ __name((value) => {
+  if (!isValidHttpCode2(value)) {
+    throw new Error(
+      `Error httpCode must be an integer between 100 and 599. Received: ${value}`
+    );
+  }
+}, "assertHttpCode");
 function makeErrorBuilder(state) {
   const builder = {
     id: state.id,
+    httpCode(code) {
+      assertHttpCode2(code);
+      const next = clone(state, { httpCode: code });
+      return makeErrorBuilder(next);
+    },
     serialize(fn) {
       const next = clone(state, { serialize: fn });
       return makeErrorBuilder(next);
@@ -28949,6 +27890,10 @@ function makeErrorBuilder(state) {
       const next = clone(state, { format: fn });
       return makeErrorBuilder(next);
     },
+    remediation(advice) {
+      const next = clone(state, { remediation: advice });
+      return makeErrorBuilder(next);
+    },
     meta(m) {
       const next = clone(state, { meta: m });
       return makeErrorBuilder(next);
@@ -28957,10 +27902,12 @@ function makeErrorBuilder(state) {
       return defineError(
         {
           id: state.id,
+          httpCode: state.httpCode,
           serialize: state.serialize,
           parse: state.parse,
           dataSchema: state.dataSchema,
           format: state.format,
+          remediation: state.remediation,
           meta: state.meta
         },
         state.filePath
@@ -28977,6 +27924,7 @@ function errorBuilder(id2) {
   const initial = Object.freeze({
     id: id2,
     filePath,
+    httpCode: void 0,
     serialize: void 0,
     parse: void 0,
     dataSchema: void 0,
@@ -28985,7 +27933,13 @@ function errorBuilder(id2) {
   return makeErrorBuilder(initial);
 }
 __name(errorBuilder, "errorBuilder");
-var error = errorBuilder;
+function isRunnerError(error2) {
+  return error2 instanceof RunnerError;
+}
+__name(isRunnerError, "isRunnerError");
+var error = Object.assign(errorBuilder, {
+  is: isRunnerError
+});
 
 // src/platform/adapters/node-als.ts
 async function loadAsyncLocalStorageClass() {
@@ -29151,20 +28105,67 @@ var EdgePlatformAdapter = class extends BrowserPlatformAdapter {
   constructor() {
     super(...arguments);
     this.id = "edge";
+    this.alsClass = null;
+    this.alsProbed = false;
   }
   static {
     __name(this, "EdgePlatformAdapter");
   }
+  async init() {
+    await this.probeAsyncLocalStorage();
+  }
+  /**
+   * Attempt to discover AsyncLocalStorage from the runtime.
+   * Checks globalThis first, then tries `import("node:async_hooks")`.
+   */
+  probeGlobalAsyncLocalStorage() {
+    if (this.alsClass) return true;
+    const g = globalThis;
+    if (typeof g.AsyncLocalStorage === "function") {
+      this.alsClass = g.AsyncLocalStorage;
+      return true;
+    }
+    return false;
+  }
+  async probeAsyncLocalStorage() {
+    if (this.alsProbed) return;
+    if (this.probeGlobalAsyncLocalStorage()) {
+      this.alsProbed = true;
+      return;
+    }
+    try {
+      const mod = await import('async_hooks');
+      if (mod?.AsyncLocalStorage) {
+        this.alsClass = mod.AsyncLocalStorage;
+      }
+    } catch {
+    } finally {
+      this.alsProbed = true;
+    }
+  }
   onShutdownSignal(_handler) {
     return () => {
     };
   }
+  hasAsyncLocalStorage() {
+    this.probeGlobalAsyncLocalStorage();
+    return this.alsClass !== null;
+  }
+  createAsyncLocalStorage() {
+    this.probeGlobalAsyncLocalStorage();
+    if (this.alsClass) {
+      return new this.alsClass();
+    }
+    return super.createAsyncLocalStorage();
+  }
 };
 
 // src/platform/adapters/universal-generic.ts
 var GenericUniversalPlatformAdapter = class {
   constructor() {
     this.id = "universal";
+    this.alsClass = null;
+    this.alsProbed = false;
     this.setTimeout = globalThis.setTimeout;
     this.clearTimeout = globalThis.clearTimeout;
   }
@@ -29173,6 +28174,23 @@ var GenericUniversalPlatformAdapter = class {
   }
   async init() {
   }
+  probeAsyncLocalStorage() {
+    if (this.alsProbed) return;
+    this.alsProbed = true;
+    const g = globalThis;
+    if (typeof g.Deno === "undefined") return;
+    if (typeof g.AsyncLocalStorage === "function") {
+      this.alsClass = g.AsyncLocalStorage;
+      return;
+    }
+    try {
+      const mod = __require("async_hooks");
+      if (mod?.AsyncLocalStorage) {
+        this.alsClass = mod.AsyncLocalStorage;
+      }
+    } catch {
+    }
+  }
   onUncaughtException(handler) {
     const tgt = globalThis;
     if (tgt.addEventListener) {
@@ -29227,9 +28245,14 @@ var GenericUniversalPlatformAdapter = class {
     return void 0;
   }
   hasAsyncLocalStorage() {
-    return false;
+    this.probeAsyncLocalStorage();
+    return this.alsClass !== null;
   }
   createAsyncLocalStorage() {
+    this.probeAsyncLocalStorage();
+    if (this.alsClass) {
+      return new this.alsClass();
+    }
     return {
       getStore: /* @__PURE__ */ __name(() => {
         platformUnsupportedFunctionError.throw({
@@ -29287,6 +28310,10 @@ var UniversalPlatformAdapter = class {
     if (this.inner) return;
     const kind = detectEnvironment();
     const global2 = globalThis;
+    if (typeof global2.Deno !== "undefined") {
+      this.inner = new GenericUniversalPlatformAdapter();
+      return;
+    }
     if (typeof global2.document !== "undefined" || typeof global2.addEventListener === "function") {
       this.inner = new BrowserPlatformAdapter();
     } else {
@@ -29355,70 +28382,17 @@ 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(
   ({ type, id: id2 }) => `${type} "${id2.toString()}" already registered. You might have used the same 'id' in two different components or you may have registered the same element twice.`
+).remediation(
+  ({ type }) => `Ensure each ${type} has a unique id. If you need the same definition in multiple places, use .fork() to create a copy with a new id.`
 ).build();
 var dependencyNotFoundError = error("runner.errors.dependencyNotFound").format(
   ({ key }) => `Dependency ${key.toString()} not found. Did you forget to register it through a resource?`
+).remediation(
+  ({ key }) => `Register the dependency "${key.toString()}" in a parent resource using .register([${key.toString()}]). If the dependency is optional, use .optional() when declaring it.`
 ).build();
 var unknownItemTypeError = error(
   "runner.errors.unknownItemType"
@@ -29426,10 +28400,14 @@ var unknownItemTypeError = error(
   ({ item }) => `Unknown item type: ${String(
     item
   )}. Please ensure you are not using different versions of '@bluelibs/runner'`
+).remediation(
+  "Check that all packages depend on the same version of '@bluelibs/runner'. Run 'npm ls @bluelibs/runner' to detect duplicates."
 ).build();
 var contextError = error(
   "runner.errors.context"
-).format(({ details }) => details ?? "Context error").build();
+).format(({ details }) => details ?? "Context error").remediation(
+  "Verify the async context is registered in a parent resource and that .provide() was called before .use(). If the context is optional, use .optional() when declaring the dependency."
+).build();
 var circularDependenciesError = error("runner.errors.circularDependencies").format(({ cycles }) => {
   const cycleDetails = cycles.map((cycle) => `  \u2022 ${cycle}`).join("\n");
   const hasMiddleware = cycles.some((cycle) => cycle.includes("middleware"));
@@ -29442,36 +28420,54 @@ var circularDependenciesError = error("runner.errors.circularDependencies").form
   }
   return `Circular dependencies detected:
 ${cycleDetails}${guidance}`;
-}).build();
+}).remediation(
+  "Break the cycle by extracting shared state into a new resource that both sides depend on, or use events for indirect communication."
+).build();
 var eventNotFoundError = error(
   "runner.errors.eventNotFound"
 ).format(
   ({ id: id2 }) => `Event "${id2.toString()}" not found. Did you forget to register it?`
+).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?`
+).remediation(
+  ({ id: id2 }) => `Register the resource "${id2.toString()}" in a parent resource via .register([yourResource]). Verify the id string matches exactly (ids are case-sensitive).`
 ).build();
 var middlewareNotRegisteredError = error("runner.errors.middlewareNotRegistered").format(
   ({ type, source, middlewareId }) => `Middleware inside ${type} "${source}" depends on "${middlewareId}" but it's not registered. Did you forget to register it?`
+).remediation(
+  ({ middlewareId }) => `Register the middleware "${middlewareId}" alongside its consumer in a parent resource via .register([yourMiddleware]).`
 ).build();
 var tagNotFoundError = error(
   "runner.errors.tagNotFound"
 ).format(
   ({ id: id2 }) => `Tag "${id2}" not registered. Did you forget to register it inside a resource?`
+).remediation(
+  ({ id: id2 }) => `Register the tag "${id2}" in a parent resource via .register([yourTag]). Tags must be registered before they can be queried.`
 ).build();
 var lockedError = error(
   "runner.errors.locked"
 ).format(
   ({ what }) => `Cannot modify the ${what.toString()} when it is locked.`
+).remediation(
+  ({ what }) => `The ${what.toString()} is locked after initialization. Perform all modifications before calling run().`
 ).build();
 var storeAlreadyInitializedError = error(
   "runner.errors.storeAlreadyInitialized"
-).format(() => "Store already initialized. Cannot reinitialize.").build();
+).format(() => "Store already initialized. Cannot reinitialize.").remediation(
+  "Do not call run() more than once on the same resource tree. Create a fresh resource if you need a separate runtime."
+).build();
 var validationError = error("runner.errors.validation").format(({ subject, id: id2, originalError }) => {
   const errorMessage2 = originalError instanceof Error ? originalError.message : String(originalError);
   return `${subject} validation failed for ${id2.toString()}: ${errorMessage2}`;
+}).remediation(({ subject, id: id2 }) => {
+  const lower = subject.toLowerCase();
+  const schemaHint = lower.includes("input") ? "inputSchema" : lower.includes("config") ? "configSchema" : lower.includes("result") ? "resultSchema" : "schema";
+  return `Check the ${subject} passed to "${id2.toString()}". Ensure it matches the schema defined via .${schemaHint}().`;
 }).build();
 var eventCycleError = error("runner.errors.eventCycle").format(({ path: path4 }) => {
   const chain = path4.map((p) => `${p.id}\u2190${p.source}`).join("  ->  ");
@@ -29479,37 +28475,188 @@ var eventCycleError = error("runner.errors.eventCycle").format(({ path: path4 })
   ${chain}
 
 Break the cycle by changing hook logic (avoid mutual emits) or gate with conditions/tags.`;
-}).build();
+}).remediation(
+  "Refactor hooks to avoid circular event emissions. Use conditional guards, split events into finer-grained signals, or introduce an intermediate task to break the cycle."
+).build();
 var eventEmissionCycleError = error("runner.errors.eventEmissionCycle").format(({ cycles }) => {
   const list = cycles.map((c) => `  \u2022 ${c}`).join("\n");
   return `Event emission cycles detected between hooks and events:
 ${list}
 
 This was detected at compile time (dry-run). Break the cycle by avoiding mutual emits between hooks or scoping hooks using tags.`;
-}).build();
+}).remediation(
+  "Redesign the event/hook graph so no hook emits an event that eventually triggers itself. Use tags or conditional logic to prevent re-entrant emissions."
+).build();
 var platformUnsupportedFunctionError = error("runner.errors.platformUnsupportedFunction").format(
   ({ functionName }) => `Platform function not supported in this environment: ${functionName}. Detected platform: ${detectEnvironment()}.`
+).remediation(
+  ({ functionName }) => `The function "${functionName}" requires a Node.js environment. If running in a browser or edge runtime, use a platform-compatible alternative or guard the call with a platform check.`
 ).build();
 var cancellationError = error(
   "runner.errors.cancellation"
-).format(({ reason }) => reason || "Operation cancelled").build();
+).format(({ reason }) => reason || "Operation cancelled").remediation(
+  "The operation was cancelled, typically via an AbortController signal. If this is unexpected, check timeout middleware settings or ensure the caller is not aborting prematurely."
+).build();
 var tunnelOwnershipConflictError = error("runner.errors.tunnelOwnershipConflict").format(
   ({ taskId, currentOwnerId, attemptedOwnerId }) => `Task "${taskId}" is already tunneled by resource "${currentOwnerId}". Resource "${attemptedOwnerId}" cannot tunnel it again. Ensure each task is owned by a single tunnel client.`
+).remediation(
+  ({ taskId }) => `Each task can only be tunneled by one client. Remove the duplicate tunnel registration for "${taskId}" or split the task into separate definitions with distinct ids.`
 ).build();
 var phantomTaskNotRoutedError = error("runner.errors.phantomTaskNotRouted").format(
   ({ taskId }) => `Phantom task "${taskId}" is not routed through any tunnel. Ensure a tunnel client selects this task id (or avoid calling the phantom task directly).`
+).remediation(
+  ({ taskId }) => `Configure a tunnel client resource to select "${taskId}" so it routes to a remote server. Phantom tasks cannot be executed locally \u2014 they only serve as local proxies for remote tasks.`
 ).build();
 var taskNotRegisteredError = error("runner.errors.taskNotRegistered").format(
   ({ taskId }) => `Task "${taskId}" is not registered in the Store. This is an internal error\u2014ensure the task is registered before execution.`
+).remediation(
+  ({ taskId }) => `Register the task "${taskId}" in a parent resource via .register([yourTask]) before calling run(). If this error persists, it may indicate an internal framework bug.`
 ).build();
 var builderIncompleteError = error("runner.errors.builderIncomplete").format(({ type, builderId, missingFields }) => {
   const typeLabel = type === "hook" ? "Hook" : type === "task-middleware" ? "Task middleware" : "Resource middleware";
   return `${typeLabel} "${builderId}" is incomplete. Missing required: ${missingFields.join(", ")}. Call ${missingFields.map((f) => `.${f}()`).join(" and ")} before .build().`;
-}).build();
-function isCancellationError(err) {
-  return cancellationError.is(err);
+}).remediation(
+  ({ missingFields }) => `Add the missing builder steps: ${missingFields.map((f) => `.${f}()`).join(", ")} before calling .build().`
+).build();
+
+// 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(isCancellationError, "isCancellationError");
+__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(defineHook, "defineHook");
 
 // src/definers/resourceFork.ts
 function resolveReId(forkId, options) {
@@ -29739,6 +28886,7 @@ function defineResource(constConfig) {
       };
     },
     fork(newId, options) {
+      const forkCallerFilePath = getCallerFile();
       const forkedParts = resolveForkedRegisterAndDependencies({
         register: constConfig.register,
         dependencies: constConfig.dependencies,
@@ -29750,11 +28898,10 @@ function defineResource(constConfig) {
         id: newId,
         register: forkedParts.register,
         dependencies: forkedParts.dependencies,
-        [symbolFilePath]: filePath
+        [symbolFilePath]: forkCallerFilePath
       });
-      forked[symbolResourceForkedFrom] = {
-        fromId: id2,
-        forkedAtFilePath: getCallerFile()
+      forked[symbolForkedFrom] = {
+        fromId: id2
       };
       return forked;
     }
@@ -29985,7 +29132,7 @@ __name(defineTag, "defineTag");
 
 // src/globals/middleware/requireContext.middleware.ts
 var requireContextTaskMiddleware = defineTaskMiddleware({
-  id: "globals.middleware.requireContext",
+  id: "globals.middleware.task.requireContext",
   async run({ task: task2, next }, _deps, config) {
     if (!config.context) {
       throw new Error(
@@ -30004,12 +29151,6 @@ var SymbolPolicy = /* @__PURE__ */ ((SymbolPolicy2) => {
   SymbolPolicy2["Disabled"] = "Disabled";
   return SymbolPolicy2;
 })(SymbolPolicy || {});
-var SymbolPolicyErrorMessage = /* @__PURE__ */ ((SymbolPolicyErrorMessage2) => {
-  SymbolPolicyErrorMessage2["GlobalSymbolsNotAllowed"] = "Global symbols are not allowed";
-  SymbolPolicyErrorMessage2["SymbolsNotAllowed"] = "Symbols are not allowed";
-  SymbolPolicyErrorMessage2["UnsupportedSymbolPolicy"] = "Unsupported symbol policy";
-  return SymbolPolicyErrorMessage2;
-})(SymbolPolicyErrorMessage || {});
 
 // src/serializer/binary-builtins.ts
 var INVALID_PAYLOAD_MESSAGE_PREFIX = "Invalid";
@@ -30517,8 +29658,124 @@ var builtInTypes = [
   ...binaryBuiltInTypes
 ];
 
+// src/serializer/regexp-validator.ts
+var isQuantifierAt = /* @__PURE__ */ __name((pattern, index) => {
+  if (index >= pattern.length) {
+    return false;
+  }
+  const char = pattern[index];
+  if (char === "*" || char === "+" || char === "?") {
+    return true;
+  }
+  if (char === "{") {
+    return isBoundedQuantifier(pattern, index);
+  }
+  return false;
+}, "isQuantifierAt");
+var isQuantifierChar = /* @__PURE__ */ __name((char, pattern, index) => {
+  if (char === "*" || char === "+") {
+    return true;
+  }
+  if (char === "?") {
+    if (index > 0 && pattern[index - 1] === "(") {
+      return false;
+    }
+    return true;
+  }
+  if (char === "{") {
+    return isBoundedQuantifier(pattern, index);
+  }
+  return false;
+}, "isQuantifierChar");
+var isBoundedQuantifier = /* @__PURE__ */ __name((pattern, index) => {
+  let sawDigit = false;
+  let sawComma = false;
+  for (let i = index + 1; i < pattern.length; i += 1) {
+    const char = pattern[i];
+    if (char >= "0" && char <= "9") {
+      sawDigit = true;
+      continue;
+    }
+    if (char === "," && !sawComma) {
+      sawComma = true;
+      continue;
+    }
+    if (char === "}") {
+      return sawDigit;
+    }
+    return false;
+  }
+  return false;
+}, "isBoundedQuantifier");
+var isRegExpPatternSafe = /* @__PURE__ */ __name((pattern) => {
+  const groupStack = [];
+  let escaped = false;
+  let inCharClass = false;
+  for (let index = 0; index < pattern.length; index += 1) {
+    const char = pattern[index];
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (char === "\\") {
+      escaped = true;
+      continue;
+    }
+    if (inCharClass) {
+      if (char === "]") {
+        inCharClass = false;
+      }
+      continue;
+    }
+    if (char === "[") {
+      inCharClass = true;
+      continue;
+    }
+    if (char === "(") {
+      groupStack.push({ hasQuantifier: false });
+      if (pattern[index + 1] === "?") {
+        index += 1;
+      }
+      continue;
+    }
+    if (char === ")") {
+      const group = groupStack.pop();
+      if (group?.hasQuantifier && isQuantifierAt(pattern, index + 1)) {
+        return false;
+      }
+      if (group?.hasQuantifier && groupStack.length > 0) {
+        groupStack[groupStack.length - 1].hasQuantifier = true;
+      }
+      continue;
+    }
+    if (isQuantifierChar(char, pattern, index)) {
+      if (groupStack.length > 0) {
+        groupStack[groupStack.length - 1].hasQuantifier = true;
+      }
+    }
+  }
+  return true;
+}, "isRegExpPatternSafe");
+var assertRegExpPayload = /* @__PURE__ */ __name((value, options) => {
+  if (!value || typeof value !== "object") {
+    throw new Error("Invalid RegExp payload");
+  }
+  const record = value;
+  if (typeof record.pattern !== "string" || typeof record.flags !== "string") {
+    throw new Error("Invalid RegExp payload");
+  }
+  if (record.pattern.length > options.maxPatternLength) {
+    throw new Error(
+      `RegExp pattern exceeds limit (${options.maxPatternLength})`
+    );
+  }
+  if (!options.allowUnsafe && !isRegExpPatternSafe(record.pattern)) {
+    throw new Error("Unsafe RegExp pattern");
+  }
+  return { pattern: record.pattern, flags: record.flags };
+}, "assertRegExpPayload");
+
 // src/serializer/type-registry.ts
-init_regexp_validator();
 var TypeRegistry = class {
   constructor(options) {
     this.typeRegistry = /* @__PURE__ */ new Map();
@@ -31277,29 +30534,25 @@ var Serializer = class {
      * @internal - Exposed for testing RegExp safety validation
      */
     this.isRegExpPatternSafe = /* @__PURE__ */ __name((pattern) => {
-      const { isRegExpPatternSafe: check } = (init_regexp_validator(), __toCommonJS(regexp_validator_exports));
-      return check(pattern);
+      return isRegExpPatternSafe(pattern);
     }, "isRegExpPatternSafe");
     /**
      * @internal - Exposed for testing quantifier detection
      */
     this.isQuantifierAt = /* @__PURE__ */ __name((pattern, index) => {
-      const { isQuantifierAt: check } = (init_regexp_validator(), __toCommonJS(regexp_validator_exports));
-      return check(pattern, index);
+      return isQuantifierAt(pattern, index);
     }, "isQuantifierAt");
     /**
      * @internal - Exposed for testing quantifier character detection
      */
     this.isQuantifierChar = /* @__PURE__ */ __name((char, pattern, index) => {
-      const { isQuantifierChar: check } = (init_regexp_validator(), __toCommonJS(regexp_validator_exports));
-      return check(char, pattern, index);
+      return isQuantifierChar(char, pattern, index);
     }, "isQuantifierChar");
     /**
      * @internal - Exposed for testing bounded quantifier detection
      */
     this.isBoundedQuantifier = /* @__PURE__ */ __name((pattern, index) => {
-      const { isBoundedQuantifier: check } = (init_regexp_validator(), __toCommonJS(regexp_validator_exports));
-      return check(pattern, index);
+      return isBoundedQuantifier(pattern, index);
     }, "isBoundedQuantifier");
     this.indent = options.pretty ? 2 : void 0;
     this.maxDepth = normalizeMaxDepth(options.maxDepth, DEFAULT_MAX_DEPTH);
@@ -31502,11 +30755,6 @@ function defineAsyncContext(def, filePath) {
   return api;
 }
 __name(defineAsyncContext, "defineAsyncContext");
-function createContext(name) {
-  const id2 = name ?? `context.${Math.random().toString(36).slice(2)}.${Date.now()}`;
-  return defineAsyncContext({ id: id2 });
-}
-__name(createContext, "createContext");
 
 // src/globals/resources/debug/debug.tag.ts
 var debugTag = defineTag({
@@ -31629,7 +30877,7 @@ var cacheFactoryTask = defineTask({
 });
 var journalKeys = {
   /** Whether the result was served from cache (true) or freshly computed (false) */
-  hit: journal.createKey("globals.middleware.cache.hit")
+  hit: journal.createKey("globals.middleware.task.cache.hit")
 };
 var cacheResource = defineResource({
   id: "globals.resources.cache",
@@ -31659,7 +30907,7 @@ var cacheResource = defineResource({
 });
 var defaultKeyBuilder = /* @__PURE__ */ __name((taskId, input) => `${taskId}-${JSON.stringify(input)}`, "defaultKeyBuilder");
 var cacheMiddleware = defineTaskMiddleware({
-  id: "globals.middleware.cache",
+  id: "globals.middleware.task.cache",
   dependencies: { cache: cacheResource },
   async run({ task: task2, next, journal: journal2 }, deps, config) {
     const { cache } = deps;
@@ -31710,11 +30958,11 @@ var CircuitBreakerOpenError = class extends Error {
 var journalKeys2 = {
   /** Current state of the circuit breaker (CLOSED, OPEN, or HALF_OPEN) */
   state: journal.createKey(
-    "globals.middleware.circuitBreaker.state"
+    "globals.middleware.task.circuitBreaker.state"
   ),
   /** Current failure count */
   failures: journal.createKey(
-    "globals.middleware.circuitBreaker.failures"
+    "globals.middleware.task.circuitBreaker.failures"
   )
 };
 var circuitBreakerResource = defineResource({
@@ -31727,7 +30975,7 @@ var circuitBreakerResource = defineResource({
   }, "init")
 });
 var circuitBreakerMiddleware = defineTaskMiddleware({
-  id: "globals.middleware.circuitBreaker",
+  id: "globals.middleware.task.circuitBreaker",
   dependencies: { state: circuitBreakerResource },
   async run({ task: task2, next, journal: journal2 }, { state }, config) {
     const taskId = task2.definition.id;
@@ -32307,12 +31555,12 @@ var EventManager = class {
 
 // src/models/Semaphore.ts
 var SemaphoreEvents = {
-  queued: defineEvent({ id: "semaphore.queued" }),
-  acquired: defineEvent({ id: "semaphore.acquired" }),
-  released: defineEvent({ id: "semaphore.released" }),
-  timeout: defineEvent({ id: "semaphore.timeout" }),
-  aborted: defineEvent({ id: "semaphore.aborted" }),
-  disposed: defineEvent({ id: "semaphore.disposed" })
+  queued: defineEvent({ id: "semaphore.events.queued" }),
+  acquired: defineEvent({ id: "semaphore.events.acquired" }),
+  released: defineEvent({ id: "semaphore.events.released" }),
+  timeout: defineEvent({ id: "semaphore.events.timeout" }),
+  aborted: defineEvent({ id: "semaphore.events.aborted" }),
+  disposed: defineEvent({ id: "semaphore.events.disposed" })
 };
 var Semaphore = class {
   constructor(maxPermits) {
@@ -32585,7 +31833,7 @@ var concurrencyResource = defineResource({
   }), "init")
 });
 var concurrencyTaskMiddleware = defineTaskMiddleware({
-  id: "globals.middleware.concurrency",
+  id: "globals.middleware.task.concurrency",
   dependencies: { state: concurrencyResource },
   async run({ task: task2, next }, { state }, config) {
     let semaphore = config.semaphore;
@@ -32664,14 +31912,16 @@ var RateLimitError = class extends Error {
 var journalKeys3 = {
   /** Number of remaining requests in the current window */
   remaining: journal.createKey(
-    "globals.middleware.rateLimit.remaining"
+    "globals.middleware.task.rateLimit.remaining"
   ),
   /** Timestamp when the current window resets */
   resetTime: journal.createKey(
-    "globals.middleware.rateLimit.resetTime"
+    "globals.middleware.task.rateLimit.resetTime"
   ),
   /** Maximum requests allowed per window */
-  limit: journal.createKey("globals.middleware.rateLimit.limit")
+  limit: journal.createKey(
+    "globals.middleware.task.rateLimit.limit"
+  )
 };
 var rateLimitResource = defineResource({
   id: "globals.resources.rateLimit",
@@ -32683,7 +31933,7 @@ var rateLimitResource = defineResource({
   }, "init")
 });
 var rateLimitTaskMiddleware = defineTaskMiddleware({
-  id: "globals.middleware.rateLimit",
+  id: "globals.middleware.task.rateLimit",
   configSchema: rateLimitConfigSchema,
   dependencies: { state: rateLimitResource },
   async run({ task: task2, next, journal: journal2 }, { state }, config) {
@@ -32731,7 +31981,7 @@ var temporalResource = defineResource({
   }, "init")
 });
 var debounceTaskMiddleware = defineTaskMiddleware({
-  id: "globals.middleware.debounce",
+  id: "globals.middleware.task.debounce",
   dependencies: { state: temporalResource },
   async run({ task: task2, next }, { state }, config) {
     const { debounceStates } = state;
@@ -32768,7 +32018,7 @@ var debounceTaskMiddleware = defineTaskMiddleware({
   }
 });
 var throttleTaskMiddleware = defineTaskMiddleware({
-  id: "globals.middleware.throttle",
+  id: "globals.middleware.task.throttle",
   dependencies: { state: temporalResource },
   async run({ task: task2, next }, { state }, config) {
     const { throttleStates } = state;
@@ -32840,12 +32090,12 @@ var throttleTaskMiddleware = defineTaskMiddleware({
 
 // src/models/Queue.ts
 var QueueEvents = {
-  enqueue: defineEvent({ id: "queue.enqueue" }),
-  start: defineEvent({ id: "queue.start" }),
-  finish: defineEvent({ id: "queue.finish" }),
-  error: defineEvent({ id: "queue.error" }),
-  cancel: defineEvent({ id: "queue.cancel" }),
-  disposed: defineEvent({ id: "queue.disposed" })
+  enqueue: defineEvent({ id: "queue.events.enqueue" }),
+  start: defineEvent({ id: "queue.events.start" }),
+  finish: defineEvent({ id: "queue.events.finish" }),
+  error: defineEvent({ id: "queue.events.error" }),
+  cancel: defineEvent({ id: "queue.events.cancel" }),
+  disposed: defineEvent({ id: "queue.events.disposed" })
 };
 var Queue = class {
   constructor() {
@@ -32994,11 +32244,218 @@ var queueResource = defineResource({
   }
 });
 
-// src/http-client.ts
-init_protocol();
-init_http_fetch_tunnel_resource();
+// src/globals/resources/tunnel/protocol.ts
+var TunnelError = class extends Error {
+  static {
+    __name(this, "TunnelError");
+  }
+  constructor(code, message, details, extras) {
+    super(message);
+    this.name = "TunnelError";
+    this.code = code;
+    this.details = details;
+    this.httpCode = extras?.httpCode;
+    this.id = extras?.id;
+    this.data = extras?.data;
+  }
+};
+function toTunnelError(input, fallbackMessage) {
+  if (input instanceof Error) {
+    return new TunnelError("UNKNOWN", input.message);
+  }
+  if (input && typeof input === "object" && "code" in input && "message" in input) {
+    const typed = input;
+    if (typeof typed.message === "string" && typeof typed.code === "string") {
+      const pe = input;
+      const msg = pe.message || fallbackMessage || "Tunnel error";
+      return new TunnelError(pe.code, msg, pe.details, {
+        httpCode: pe.httpCode,
+        id: pe.id,
+        data: pe.data
+      });
+    }
+  }
+  if (input && typeof input === "object" && "message" in input) {
+    const typed = input;
+    if (typeof typed.message === "string") {
+      return new TunnelError("UNKNOWN", typed.message);
+    }
+  }
+  return new TunnelError(
+    "UNKNOWN",
+    typeof input === "string" && input || fallbackMessage || "Tunnel error"
+  );
+}
+__name(toTunnelError, "toTunnelError");
+function assertOkEnvelope(envelope, opts) {
+  if (!envelope || typeof envelope !== "object") {
+    throw new TunnelError(
+      "INVALID_RESPONSE",
+      opts?.fallbackMessage || "Invalid or empty response"
+    );
+  }
+  if (envelope.ok) {
+    return envelope.result;
+  }
+  if (envelope.error) {
+    return (() => {
+      throw toTunnelError(envelope.error, opts?.fallbackMessage);
+    })();
+  }
+  throw new TunnelError("UNKNOWN", opts?.fallbackMessage || "Tunnel error");
+}
+__name(assertOkEnvelope, "assertOkEnvelope");
 
-// src/tunnels/buildUniversalManifest.ts
+// src/http-fetch-tunnel.resource.ts
+async function postSerialized(options) {
+  const {
+    fetch: fetchFn,
+    url,
+    body,
+    headers,
+    timeoutMs,
+    serializer: serializer3,
+    onRequest,
+    contextHeaderText
+  } = options;
+  const controller = timeoutMs && timeoutMs > 0 ? new AbortController() : void 0;
+  let timeout;
+  try {
+    if (controller) {
+      timeout = setTimeout(() => controller.abort(), timeoutMs);
+    }
+    const reqHeaders = {
+      "content-type": "application/json; charset=utf-8",
+      ...headers
+    };
+    if (contextHeaderText) reqHeaders["x-runner-context"] = contextHeaderText;
+    if (onRequest) await onRequest({ url, headers: reqHeaders });
+    const res = await fetchFn(url, {
+      method: "POST",
+      headers: reqHeaders,
+      body: serializer3.stringify(body),
+      signal: controller?.signal
+    });
+    const text = await res.text();
+    const json2 = text ? serializer3.parse(text) : void 0;
+    return json2;
+  } finally {
+    if (timeout) clearTimeout(timeout);
+  }
+}
+__name(postSerialized, "postSerialized");
+function createExposureFetch(cfg) {
+  const baseUrl = cfg?.baseUrl?.replace(/\/$/, "");
+  if (!baseUrl) throw new Error("createExposureFetch requires baseUrl");
+  const headerName = (cfg?.auth?.header ?? "x-runner-token").toLowerCase();
+  const buildHeaders = /* @__PURE__ */ __name(() => {
+    const headers = {};
+    if (cfg?.auth?.token) headers[headerName] = cfg.auth.token;
+    return headers;
+  }, "buildHeaders");
+  const fetchImpl = cfg.fetchImpl ?? globalThis.fetch;
+  if (typeof fetchImpl !== "function") {
+    throw new Error(
+      "global fetch is not available; provide fetchImpl in config"
+    );
+  }
+  const buildContextHeader = /* @__PURE__ */ __name(() => {
+    if (!cfg.contexts || cfg.contexts.length === 0) return void 0;
+    const map = {};
+    for (const ctx of cfg.contexts) {
+      try {
+        const v = ctx.use();
+        map[ctx.id] = ctx.serialize(v);
+      } catch {
+      }
+    }
+    const keys = Object.keys(map);
+    if (keys.length === 0) return void 0;
+    return cfg.serializer.stringify(map);
+  }, "buildContextHeader");
+  return {
+    async task(id2, input) {
+      const url = `${baseUrl}/task/${encodeURIComponent(id2)}`;
+      const r2 = await postSerialized({
+        fetch: fetchImpl,
+        url,
+        body: { input },
+        headers: buildHeaders(),
+        timeoutMs: cfg?.timeoutMs,
+        serializer: cfg.serializer,
+        onRequest: cfg?.onRequest,
+        contextHeaderText: buildContextHeader()
+      });
+      try {
+        return assertOkEnvelope(r2, { fallbackMessage: "Tunnel task error" });
+      } catch (e) {
+        const te = e;
+        if (cfg.errorRegistry && te.id && te.data) {
+          const helper = cfg.errorRegistry.get(String(te.id));
+          if (helper) helper.throw(te.data);
+        }
+        throw e;
+      }
+    },
+    async event(id2, payload) {
+      const url = `${baseUrl}/event/${encodeURIComponent(id2)}`;
+      const r2 = await postSerialized({
+        fetch: fetchImpl,
+        url,
+        body: { payload },
+        headers: buildHeaders(),
+        timeoutMs: cfg?.timeoutMs,
+        serializer: cfg.serializer,
+        onRequest: cfg?.onRequest,
+        contextHeaderText: buildContextHeader()
+      });
+      try {
+        assertOkEnvelope(r2, { fallbackMessage: "Tunnel event error" });
+      } catch (e) {
+        const te = e;
+        if (cfg.errorRegistry && te.id && te.data) {
+          const helper = cfg.errorRegistry.get(String(te.id));
+          if (helper) helper.throw(te.data);
+        }
+        throw e;
+      }
+    },
+    async eventWithResult(id2, payload) {
+      const url = `${baseUrl}/event/${encodeURIComponent(id2)}`;
+      const r2 = await postSerialized({
+        fetch: fetchImpl,
+        url,
+        body: { payload, returnPayload: true },
+        headers: buildHeaders(),
+        timeoutMs: cfg?.timeoutMs,
+        serializer: cfg.serializer,
+        onRequest: cfg?.onRequest,
+        contextHeaderText: buildContextHeader()
+      });
+      if (r2 && typeof r2 === "object" && r2.ok && !("result" in r2)) {
+        throw new TunnelError(
+          "INVALID_RESPONSE",
+          "Tunnel event returnPayload requested but server did not include result. Upgrade the exposure server."
+        );
+      }
+      try {
+        return assertOkEnvelope(r2, {
+          fallbackMessage: "Tunnel event error"
+        });
+      } catch (e) {
+        const te = e;
+        if (cfg.errorRegistry && te.id && te.data) {
+          const helper = cfg.errorRegistry.get(String(te.id));
+          if (helper) helper.throw(te.data);
+        }
+        throw e;
+      }
+    }
+  };
+}
+__name(createExposureFetch, "createExposureFetch");
+
+// src/tools/buildUniversalManifest.ts
 function buildUniversalManifest(input) {
   const nodeFiles = [];
   const webFiles = [];
@@ -33055,6 +32512,15 @@ function toHeaders(auth) {
   return headers;
 }
 __name(toHeaders, "toHeaders");
+function rethrowWithRegistry(e, errorRegistry) {
+  const te = e;
+  if (errorRegistry && te.id && te.data) {
+    const helper = errorRegistry.get(String(te.id));
+    if (helper) helper.throw(te.data);
+  }
+  throw e;
+}
+__name(rethrowWithRegistry, "rethrowWithRegistry");
 function createHttpClient(cfg) {
   const baseUrl = cfg.baseUrl.replace(/\/$/, "");
   if (!baseUrl) throw new Error("createHttpClient requires baseUrl");
@@ -33121,12 +32587,7 @@ function createHttpClient(cfg) {
             fallbackMessage: "Tunnel task error"
           });
         } catch (e) {
-          const te = e;
-          if (cfg.errorRegistry && te.id && te.data) {
-            const helper = cfg.errorRegistry.get(String(te.id));
-            if (helper) helper.throw(te.data);
-          }
-          throw e;
+          rethrowWithRegistry(e, cfg.errorRegistry);
         }
       }
       if (manifest.nodeFiles.length > 0) {
@@ -33137,24 +32598,14 @@ function createHttpClient(cfg) {
       try {
         return await fetchClient.task(id2, input);
       } catch (e) {
-        const te = e;
-        if (cfg.errorRegistry && te.id && te.data) {
-          const helper = cfg.errorRegistry.get(String(te.id));
-          if (helper) helper.throw(te.data);
-        }
-        throw e;
+        rethrowWithRegistry(e, cfg.errorRegistry);
       }
     },
     async event(id2, payload) {
       try {
         return await fetchClient.event(id2, payload);
       } catch (e) {
-        const te = e;
-        if (cfg.errorRegistry && te.id && te.data) {
-          const helper = cfg.errorRegistry.get(String(te.id));
-          if (helper) helper.throw(te.data);
-        }
-        throw e;
+        rethrowWithRegistry(e, cfg.errorRegistry);
       }
     },
     async eventWithResult(id2, payload) {
@@ -33166,12 +32617,7 @@ function createHttpClient(cfg) {
         }
         return await fetchClient.eventWithResult(id2, payload);
       } catch (e) {
-        const te = e;
-        if (cfg.errorRegistry && te.id && te.data) {
-          const helper = cfg.errorRegistry.get(String(te.id));
-          if (helper) helper.throw(te.data);
-        }
-        throw e;
+        rethrowWithRegistry(e, cfg.errorRegistry);
       }
     }
   };
@@ -33454,13 +32900,15 @@ var retryResourceMiddleware = defineResourceMiddleware({
 var journalKeys6 = {
   /** Whether the fallback path was taken (true) or primary succeeded (false) */
   active: journal.createKey(
-    "globals.middleware.fallback.active"
+    "globals.middleware.task.fallback.active"
   ),
   /** The error that triggered the fallback (only set when active is true) */
-  error: journal.createKey("globals.middleware.fallback.error")
+  error: journal.createKey(
+    "globals.middleware.task.fallback.error"
+  )
 };
 var fallbackTaskMiddleware = defineTaskMiddleware({
-  id: "globals.middleware.fallback",
+  id: "globals.middleware.task.fallback",
   dependencies: {
     taskRunner: globalResources.taskRunner
   },
@@ -34103,6 +33551,34 @@ var Logger = class _Logger {
   }
 };
 
+// src/models/utils/dependencyStrategies.ts
+var dependencyStrategies = [
+  {
+    matches: isResource,
+    getStoreMap: /* @__PURE__ */ __name((store2) => store2.resources, "getStoreMap")
+  },
+  {
+    matches: isTask,
+    getStoreMap: /* @__PURE__ */ __name((store2) => store2.tasks, "getStoreMap")
+  },
+  {
+    matches: isEvent,
+    getStoreMap: /* @__PURE__ */ __name((store2) => store2.events, "getStoreMap")
+  },
+  {
+    matches: isError,
+    getStoreMap: /* @__PURE__ */ __name((store2) => store2.errors, "getStoreMap")
+  },
+  {
+    matches: isAsyncContext,
+    getStoreMap: /* @__PURE__ */ __name((store2) => store2.asyncContexts, "getStoreMap")
+  }
+];
+function findDependencyStrategy(item) {
+  return dependencyStrategies.find((s) => s.matches(item));
+}
+__name(findDependencyStrategy, "findDependencyStrategy");
+
 // src/models/DependencyProcessor.ts
 var DependencyProcessor = class {
   constructor(store2, eventManager, taskRunner, logger) {
@@ -34210,7 +33686,16 @@ var DependencyProcessor = class {
       }
       throw error2;
     }
-    throw new Error(`${prefix}: ${String(error2)}`);
+    const wrapper = new Error(`${prefix}: ${String(error2)}`);
+    Object.defineProperty(wrapper, "resourceId", {
+      value: resourceId,
+      configurable: true
+    });
+    Object.defineProperty(wrapper, "cause", {
+      value: error2,
+      configurable: true
+    });
+    throw wrapper;
   }
   /**
    * Computes and caches dependencies for a resource (if not already computed).
@@ -34353,46 +33838,35 @@ var DependencyProcessor = class {
     return object;
   }
   async extractDependency(object, source) {
-    this.logger.trace(`Extracting dependency -> ${source} -> ${object?.id}`);
+    this.logger.trace(
+      `Extracting dependency -> ${source} -> ${object?.id}`
+    );
+    let isOpt = false;
+    let item = object;
     if (isOptional(object)) {
-      const inner = object.inner;
-      if (isResource(inner)) {
-        const exists = this.store.resources.get(inner.id) !== void 0;
-        return exists ? this.extractResourceDependency(inner) : void 0;
-      } else if (isTask(inner)) {
-        const exists = this.store.tasks.get(inner.id) !== void 0;
-        return exists ? this.extractTaskDependency(inner) : void 0;
-      } else if (isEvent(inner)) {
-        const exists = this.store.events.get(inner.id) !== void 0;
-        return exists ? this.extractEventDependency(inner, source) : void 0;
-      } else if (isError(inner)) {
-        const exists = this.store.errors.get(inner.id) !== void 0;
-        return exists ? inner : void 0;
-      } else if (isAsyncContext(inner)) {
-        const exists = this.store.asyncContexts.get(inner.id) !== void 0;
-        return exists ? inner : void 0;
-      }
-      unknownItemTypeError.throw({ item: inner });
-    }
-    if (isResource(object)) {
-      return this.extractResourceDependency(object);
-    } else if (isTask(object)) {
-      return this.extractTaskDependency(object);
-    } else if (isEvent(object)) {
-      return this.extractEventDependency(object, source);
-    } else if (isError(object)) {
-      if (this.store.errors.get(object.id) === void 0) {
-        dependencyNotFoundError.throw({ key: `Error ${object.id}` });
-      }
-      return object;
-    } else if (isAsyncContext(object)) {
-      if (this.store.asyncContexts.get(object.id) === void 0) {
-        dependencyNotFoundError.throw({ key: `AsyncContext ${object.id}` });
-      }
-      return object;
-    } else {
-      unknownItemTypeError.throw({ item: object });
+      isOpt = true;
+      item = object.inner;
+    }
+    const itemWithId = item;
+    const strategy = findDependencyStrategy(item);
+    if (!strategy) {
+      return unknownItemTypeError.throw({ item });
     }
+    if (isOpt) {
+      const exists = strategy.getStoreMap(this.store).has(itemWithId.id);
+      if (!exists) return void 0;
+    }
+    if (isResource(item)) return this.extractResourceDependency(item);
+    if (isTask(item)) return this.extractTaskDependency(item);
+    if (isEvent(item)) return this.extractEventDependency(item, source);
+    if (!isOpt) {
+      const exists = strategy.getStoreMap(this.store).has(itemWithId.id);
+      if (!exists) {
+        const label = isError(item) ? "Error" : "AsyncContext";
+        dependencyNotFoundError.throw({ key: `${label} ${itemWithId.id}` });
+      }
+    }
+    return item;
   }
   /**
    * Converts the event into a running functions with real inputs
@@ -34589,19 +34063,246 @@ var StoreValidator = class {
   }
 };
 
+// src/models/utils/buildDependencyGraph.ts
+function setupBlankNodes(registry, nodeMap, dependents) {
+  for (const task2 of registry.tasks.values()) {
+    const node = {
+      id: task2.task.id,
+      dependencies: {}
+    };
+    nodeMap.set(task2.task.id, node);
+    dependents.push(node);
+  }
+  for (const middleware of registry.taskMiddlewares.values()) {
+    const node = {
+      id: middleware.middleware.id,
+      dependencies: {}
+    };
+    nodeMap.set(middleware.middleware.id, node);
+    dependents.push(node);
+  }
+  for (const middleware of registry.resourceMiddlewares.values()) {
+    const node = {
+      id: middleware.middleware.id,
+      dependencies: {}
+    };
+    nodeMap.set(middleware.middleware.id, node);
+    dependents.push(node);
+  }
+  for (const resource2 of registry.resources.values()) {
+    const node = {
+      id: resource2.resource.id,
+      dependencies: {}
+    };
+    nodeMap.set(resource2.resource.id, node);
+    dependents.push(node);
+  }
+  for (const hook2 of registry.hooks.values()) {
+    const node = {
+      id: hook2.hook.id,
+      dependencies: {}
+    };
+    nodeMap.set(hook2.hook.id, node);
+    dependents.push(node);
+  }
+}
+__name(setupBlankNodes, "setupBlankNodes");
+function buildDependencyGraph(registry) {
+  const depenedants = [];
+  const nodeMap = /* @__PURE__ */ new Map();
+  setupBlankNodes(registry, nodeMap, depenedants);
+  for (const task2 of registry.tasks.values()) {
+    const node = nodeMap.get(task2.task.id);
+    if (task2.task.dependencies) {
+      for (const [depKey, depItem] of Object.entries(task2.task.dependencies)) {
+        const candidate = isOptional(depItem) ? depItem.inner : depItem;
+        const depNode = nodeMap.get(candidate.id);
+        if (depNode) {
+          node.dependencies[depKey] = depNode;
+        }
+      }
+    }
+    const t = task2.task;
+    for (const middleware of t.middleware) {
+      const middlewareNode = nodeMap.get(middleware.id);
+      if (middlewareNode) {
+        node.dependencies[middleware.id] = middlewareNode;
+      }
+    }
+  }
+  for (const storeTaskMiddleware of registry.taskMiddlewares.values()) {
+    const node = nodeMap.get(storeTaskMiddleware.middleware.id);
+    const { middleware } = storeTaskMiddleware;
+    if (middleware.dependencies) {
+      for (const [depKey, depItem] of Object.entries(middleware.dependencies)) {
+        const candidate = isOptional(depItem) ? depItem.inner : depItem;
+        const depNode = nodeMap.get(candidate.id);
+        if (depNode) {
+          node.dependencies[depKey] = depNode;
+        }
+      }
+    }
+    if (middleware.everywhere) {
+      const filter = typeof middleware.everywhere === "function" ? middleware.everywhere : () => true;
+      for (const task2 of registry.tasks.values()) {
+        if (filter(task2.task)) {
+          const taskNode = nodeMap.get(task2.task.id);
+          taskNode.dependencies[`__middleware.${middleware.id}`] = node;
+        }
+      }
+    }
+  }
+  for (const storeResourceMiddleware of registry.resourceMiddlewares.values()) {
+    const node = nodeMap.get(storeResourceMiddleware.middleware.id);
+    const { middleware } = storeResourceMiddleware;
+    if (middleware.dependencies) {
+      for (const [depKey, depItem] of Object.entries(middleware.dependencies)) {
+        const candidate = isOptional(depItem) ? depItem.inner : depItem;
+        const depNode = nodeMap.get(candidate.id);
+        if (depNode) {
+          node.dependencies[depKey] = depNode;
+        }
+      }
+    }
+    if (middleware.everywhere) {
+      const filter = typeof middleware.everywhere === "function" ? middleware.everywhere : () => true;
+      for (const resource2 of registry.resources.values()) {
+        if (filter(resource2.resource)) {
+          const resourceNode = nodeMap.get(resource2.resource.id);
+          resourceNode.dependencies[`__middleware.${middleware.id}`] = node;
+        }
+      }
+    }
+  }
+  for (const resource2 of registry.resources.values()) {
+    const node = nodeMap.get(resource2.resource.id);
+    if (resource2.resource.dependencies) {
+      for (const [depKey, depItem] of Object.entries(
+        resource2.resource.dependencies
+      )) {
+        const candidate = isOptional(depItem) ? depItem.inner : depItem;
+        const depNode = nodeMap.get(candidate.id);
+        if (depNode) {
+          node.dependencies[depKey] = depNode;
+        }
+      }
+    }
+    for (const middleware of resource2.resource.middleware) {
+      const middlewareNode = nodeMap.get(middleware.id);
+      if (middlewareNode) {
+        node.dependencies[middleware.id] = middlewareNode;
+      }
+    }
+  }
+  for (const hook2 of registry.hooks.values()) {
+    const node = nodeMap.get(hook2.hook.id);
+    if (hook2.hook.dependencies) {
+      for (const [depKey, depItem] of Object.entries(hook2.hook.dependencies)) {
+        const candidate = isOptional(depItem) ? depItem.inner : depItem;
+        const depNode = nodeMap.get(candidate.id);
+        if (depNode) {
+          node.dependencies[depKey] = depNode;
+        }
+      }
+    }
+  }
+  return depenedants;
+}
+__name(buildDependencyGraph, "buildDependencyGraph");
+function buildEventEmissionGraph(registry) {
+  const nodes = /* @__PURE__ */ new Map();
+  for (const e of registry.events.values()) {
+    nodes.set(e.event.id, { id: e.event.id, dependencies: {} });
+  }
+  for (const h of registry.hooks.values()) {
+    const listened = [];
+    const on = h.hook.on;
+    if (on === "*") continue;
+    if (Array.isArray(on))
+      listened.push(...on.map((e) => e.id));
+    else listened.push(on.id);
+    const depEvents = [];
+    const deps = h.hook.dependencies;
+    if (deps) {
+      for (const value of Object.values(deps)) {
+        const candidate = isOptional(value) ? value.inner : value;
+        if (candidate && isEvent(candidate)) {
+          depEvents.push(candidate.id);
+        }
+      }
+    }
+    for (const srcId of listened) {
+      const srcNode = nodes.get(srcId);
+      if (!srcNode) continue;
+      for (const dstId of depEvents) {
+        if (srcId === dstId) continue;
+        const dstNode = nodes.get(dstId);
+        if (dstNode) {
+          srcNode.dependencies[dstId] = dstNode;
+        }
+      }
+    }
+  }
+  return Array.from(nodes.values());
+}
+__name(buildEventEmissionGraph, "buildEventEmissionGraph");
+
+// src/tools/LockableMap.ts
+var LockableMap = class extends Map {
+  static {
+    __name(this, "LockableMap");
+  }
+  #locked = false;
+  #name;
+  constructor(name) {
+    super();
+    this.#name = name ?? "LockableMap";
+  }
+  /** Whether the map is currently locked. */
+  get locked() {
+    return this.#locked;
+  }
+  /** Permanently lock the map — no further mutations allowed. */
+  lock() {
+    this.#locked = true;
+  }
+  /** @throws if the map is locked */
+  throwIfLocked() {
+    if (this.#locked) {
+      throw new Error(`Cannot modify "${this.#name}" \u2014 the map is locked.`);
+    }
+  }
+  set(key, value) {
+    this.throwIfLocked();
+    return super.set(key, value);
+  }
+  delete(key) {
+    this.throwIfLocked();
+    return super.delete(key);
+  }
+  clear() {
+    this.throwIfLocked();
+    super.clear();
+  }
+};
+
 // src/models/StoreRegistry.ts
 var StoreRegistry = class {
   constructor(store2) {
     this.store = store2;
-    this.tasks = /* @__PURE__ */ new Map();
-    this.resources = /* @__PURE__ */ new Map();
-    this.events = /* @__PURE__ */ new Map();
-    this.taskMiddlewares = /* @__PURE__ */ new Map();
-    this.resourceMiddlewares = /* @__PURE__ */ new Map();
-    this.hooks = /* @__PURE__ */ new Map();
-    this.tags = /* @__PURE__ */ new Map();
-    this.asyncContexts = /* @__PURE__ */ new Map();
-    this.errors = /* @__PURE__ */ new Map();
+    this.tasks = new LockableMap("tasks");
+    this.resources = new LockableMap(
+      "resources"
+    );
+    this.events = new LockableMap("events");
+    this.taskMiddlewares = new LockableMap("taskMiddlewares");
+    this.resourceMiddlewares = new LockableMap("resourceMiddlewares");
+    this.hooks = new LockableMap("hooks");
+    this.tags = new LockableMap("tags");
+    this.asyncContexts = new LockableMap(
+      "asyncContexts"
+    );
+    this.errors = new LockableMap("errors");
     this.validator = new StoreValidator(this);
   }
   static {
@@ -34610,6 +34311,18 @@ var StoreRegistry = class {
   getValidator() {
     return this.validator;
   }
+  /** Lock every map in the registry, preventing further mutations. */
+  lockAll() {
+    this.tasks.lock();
+    this.resources.lock();
+    this.events.lock();
+    this.taskMiddlewares.lock();
+    this.resourceMiddlewares.lock();
+    this.hooks.lock();
+    this.tags.lock();
+    this.asyncContexts.lock();
+    this.errors.lock();
+  }
   storeGenericItem(item) {
     if (isTask(item)) {
       this.storeTask(item);
@@ -34746,195 +34459,14 @@ var StoreRegistry = class {
   }
   // Feels like a dependencyProcessor task?
   getDependentNodes() {
-    const depenedants = [];
-    const nodeMap = /* @__PURE__ */ new Map();
-    this.setupBlankNodes(nodeMap, depenedants);
-    for (const task2 of this.tasks.values()) {
-      const node = nodeMap.get(task2.task.id);
-      if (task2.task.dependencies) {
-        for (const [depKey, depItem] of Object.entries(
-          task2.task.dependencies
-        )) {
-          const candidate = isOptional(depItem) ? depItem.inner : depItem;
-          const depNode = nodeMap.get(candidate.id);
-          if (depNode) {
-            node.dependencies[depKey] = depNode;
-          }
-        }
-      }
-      const t = task2.task;
-      for (const middleware of t.middleware) {
-        const middlewareNode = nodeMap.get(middleware.id);
-        if (middlewareNode) {
-          node.dependencies[middleware.id] = middlewareNode;
-        }
-      }
-    }
-    for (const storeTaskMiddleware of this.taskMiddlewares.values()) {
-      const node = nodeMap.get(storeTaskMiddleware.middleware.id);
-      const { middleware } = storeTaskMiddleware;
-      if (middleware.dependencies) {
-        for (const [depKey, depItem] of Object.entries(
-          middleware.dependencies
-        )) {
-          const candidate = isOptional(depItem) ? depItem.inner : depItem;
-          const depNode = nodeMap.get(candidate.id);
-          if (depNode) {
-            node.dependencies[depKey] = depNode;
-          }
-        }
-      }
-      if (middleware.everywhere) {
-        const filter = typeof middleware.everywhere === "function" ? middleware.everywhere : () => true;
-        for (const task2 of this.tasks.values()) {
-          if (filter(task2.task)) {
-            const taskNode = nodeMap.get(task2.task.id);
-            taskNode.dependencies[`__middleware.${middleware.id}`] = node;
-          }
-        }
-      }
-    }
-    for (const storeResourceMiddleware of this.resourceMiddlewares.values()) {
-      const node = nodeMap.get(storeResourceMiddleware.middleware.id);
-      const { middleware } = storeResourceMiddleware;
-      if (middleware.dependencies) {
-        for (const [depKey, depItem] of Object.entries(
-          middleware.dependencies
-        )) {
-          const candidate = isOptional(depItem) ? depItem.inner : depItem;
-          const depNode = nodeMap.get(candidate.id);
-          if (depNode) {
-            node.dependencies[depKey] = depNode;
-          }
-        }
-      }
-      if (middleware.everywhere) {
-        const filter = typeof middleware.everywhere === "function" ? middleware.everywhere : () => true;
-        for (const resource2 of this.resources.values()) {
-          if (filter(resource2.resource)) {
-            const resourceNode = nodeMap.get(resource2.resource.id);
-            resourceNode.dependencies[`__middleware.${middleware.id}`] = node;
-          }
-        }
-      }
-    }
-    for (const resource2 of this.resources.values()) {
-      const node = nodeMap.get(resource2.resource.id);
-      if (resource2.resource.dependencies) {
-        for (const [depKey, depItem] of Object.entries(
-          resource2.resource.dependencies
-        )) {
-          const candidate = isOptional(depItem) ? depItem.inner : depItem;
-          const depNode = nodeMap.get(candidate.id);
-          if (depNode) {
-            node.dependencies[depKey] = depNode;
-          }
-        }
-      }
-      for (const middleware of resource2.resource.middleware) {
-        const middlewareNode = nodeMap.get(middleware.id);
-        if (middlewareNode) {
-          node.dependencies[middleware.id] = middlewareNode;
-        }
-      }
-    }
-    for (const hook2 of this.hooks.values()) {
-      const node = nodeMap.get(hook2.hook.id);
-      if (hook2.hook.dependencies) {
-        for (const [depKey, depItem] of Object.entries(
-          hook2.hook.dependencies
-        )) {
-          const candidate = isOptional(depItem) ? depItem.inner : depItem;
-          const depNode = nodeMap.get(candidate.id);
-          if (depNode) {
-            node.dependencies[depKey] = depNode;
-          }
-        }
-      }
-    }
-    return depenedants;
+    return buildDependencyGraph(this);
   }
   /**
    * Builds a directed graph of event emissions based on hooks listening to events
    * and their dependencies on events (emission capability). Ignores wildcard hooks by default.
    */
   buildEventEmissionGraph() {
-    const nodes = /* @__PURE__ */ new Map();
-    for (const e of this.events.values()) {
-      nodes.set(e.event.id, { id: e.event.id, dependencies: {} });
-    }
-    for (const h of this.hooks.values()) {
-      const listened = [];
-      const on = h.hook.on;
-      if (on === "*") continue;
-      if (Array.isArray(on))
-        listened.push(...on.map((e) => e.id));
-      else listened.push(on.id);
-      const depEvents = [];
-      const deps = h.hook.dependencies;
-      if (deps) {
-        for (const value of Object.values(deps)) {
-          const candidate = isOptional(value) ? value.inner : value;
-          if (candidate && isEvent(candidate)) {
-            depEvents.push(candidate.id);
-          }
-        }
-      }
-      for (const srcId of listened) {
-        const srcNode = nodes.get(srcId);
-        if (!srcNode) continue;
-        for (const dstId of depEvents) {
-          if (srcId === dstId) continue;
-          const dstNode = nodes.get(dstId);
-          if (dstNode) {
-            srcNode.dependencies[dstId] = dstNode;
-          }
-        }
-      }
-    }
-    return Array.from(nodes.values());
-  }
-  setupBlankNodes(nodeMap, depenedants) {
-    for (const task2 of this.tasks.values()) {
-      const node = {
-        id: task2.task.id,
-        dependencies: {}
-      };
-      nodeMap.set(task2.task.id, node);
-      depenedants.push(node);
-    }
-    for (const middleware of this.taskMiddlewares.values()) {
-      const node = {
-        id: middleware.middleware.id,
-        dependencies: {}
-      };
-      nodeMap.set(middleware.middleware.id, node);
-      depenedants.push(node);
-    }
-    for (const middleware of this.resourceMiddlewares.values()) {
-      const node = {
-        id: middleware.middleware.id,
-        dependencies: {}
-      };
-      nodeMap.set(middleware.middleware.id, node);
-      depenedants.push(node);
-    }
-    for (const resource2 of this.resources.values()) {
-      const node = {
-        id: resource2.resource.id,
-        dependencies: {}
-      };
-      nodeMap.set(resource2.resource.id, node);
-      depenedants.push(node);
-    }
-    for (const hook2 of this.hooks.values()) {
-      const node = {
-        id: hook2.hook.id,
-        dependencies: {}
-      };
-      nodeMap.set(hook2.hook.id, node);
-      depenedants.push(node);
-    }
+    return buildEventEmissionGraph(this);
   }
   getTasksWithTag(tag2) {
     const tagId = typeof tag2 === "string" ? tag2 : tag2.id;
@@ -35868,6 +35400,63 @@ function detectRunnerMode(explicitMode) {
 }
 __name(detectRunnerMode, "detectRunnerMode");
 
+// src/models/utils/disposeOrder.ts
+function getResourcesInDisposeOrder(resources, initializedResourceIds) {
+  const initializedResources = Array.from(resources.values()).filter(
+    (r2) => r2.isInitialized
+  );
+  const initOrderHasAllInitialized = initializedResourceIds.length === initializedResources.length && initializedResources.every(
+    (r2) => initializedResourceIds.includes(r2.resource.id)
+  );
+  if (initOrderHasAllInitialized) {
+    const byId = new Map(
+      initializedResources.map((r2) => [r2.resource.id, r2])
+    );
+    return initializedResourceIds.slice().reverse().map((id2) => byId.get(id2)).filter((r2) => Boolean(r2));
+  }
+  const visitState = /* @__PURE__ */ new Map();
+  const initOrder = [];
+  let cycleDetected = false;
+  const getDependencyIds = /* @__PURE__ */ __name((resource2) => {
+    const raw = resource2.resource.dependencies;
+    if (!raw) return [];
+    const deps = raw;
+    if (!deps || typeof deps !== "object") return [];
+    const out = [];
+    const collect = /* @__PURE__ */ __name((value) => {
+      if (isOptional(value)) {
+        collect(value.inner);
+        return;
+      }
+      if (isResource(value)) {
+        out.push(value.id);
+      }
+    }, "collect");
+    Object.values(deps).forEach(collect);
+    return out;
+  }, "getDependencyIds");
+  const visit = /* @__PURE__ */ __name((resourceId) => {
+    const state = visitState.get(resourceId);
+    if (state === "visited") return;
+    if (state === "visiting") {
+      cycleDetected = true;
+      return;
+    }
+    const resource2 = resources.get(resourceId);
+    if (!resource2) return;
+    visitState.set(resourceId, "visiting");
+    getDependencyIds(resource2).forEach(visit);
+    visitState.set(resourceId, "visited");
+    initOrder.push(resource2);
+  }, "visit");
+  initializedResources.forEach((r2) => visit(r2.resource.id));
+  if (cycleDetected) {
+    return initializedResources.slice().reverse();
+  }
+  return initOrder.reverse();
+}
+__name(getResourcesInDisposeOrder, "getResourcesInDisposeOrder");
+
 // src/models/Store.ts
 var Store = class {
   constructor(eventManager, logger, onUnhandledError, mode) {
@@ -35932,6 +35521,7 @@ var Store = class {
   }
   lock() {
     this.#isLocked = true;
+    this.registry.lockAll();
   }
   checkLock() {
     if (this.#isLocked) {
@@ -36073,58 +35663,7 @@ var Store = class {
     this.initializedResourceIds.push(resourceId);
   }
   getResourcesInDisposeOrder() {
-    const initializedResources = Array.from(this.resources.values()).filter(
-      (r2) => r2.isInitialized
-    );
-    const initOrderHasAllInitialized = this.initializedResourceIds.length === initializedResources.length && initializedResources.every(
-      (r2) => this.initializedResourceIds.includes(r2.resource.id)
-    );
-    if (initOrderHasAllInitialized) {
-      const byId = new Map(
-        initializedResources.map((r2) => [r2.resource.id, r2])
-      );
-      return this.initializedResourceIds.slice().reverse().map((id2) => byId.get(id2)).filter((r2) => Boolean(r2));
-    }
-    const visitState = /* @__PURE__ */ new Map();
-    const initOrder = [];
-    let cycleDetected = false;
-    const getDependencyIds = /* @__PURE__ */ __name((resource2) => {
-      const raw = resource2.resource.dependencies;
-      if (!raw) return [];
-      const deps = raw;
-      if (!deps || typeof deps !== "object") return [];
-      const out = [];
-      const collect = /* @__PURE__ */ __name((value) => {
-        if (isOptional(value)) {
-          collect(value.inner);
-          return;
-        }
-        if (isResource(value)) {
-          out.push(value.id);
-        }
-      }, "collect");
-      Object.values(deps).forEach(collect);
-      return out;
-    }, "getDependencyIds");
-    const visit = /* @__PURE__ */ __name((resourceId) => {
-      const state = visitState.get(resourceId);
-      if (state === "visited") return;
-      if (state === "visiting") {
-        cycleDetected = true;
-        return;
-      }
-      const resource2 = this.resources.get(resourceId);
-      if (!resource2) return;
-      visitState.set(resourceId, "visiting");
-      getDependencyIds(resource2).forEach(visit);
-      visitState.set(resourceId, "visited");
-      initOrder.push(resource2);
-    }, "visit");
-    initializedResources.forEach((r2) => visit(r2.resource.id));
-    if (cycleDetected) {
-      return initializedResources.slice().reverse();
-    }
-    return initOrder.reverse();
+    return getResourcesInDisposeOrder(this.resources, this.initializedResourceIds);
   }
   /**
    * Internal, avoid using this method directly.
@@ -36140,21 +35679,11 @@ var Store = class {
   storeGenericItem(item) {
     return this.registry.storeGenericItem(item);
   }
-  /**
-   * Returns all tasks with the given tag.
-   * @param tag - The tag to filter by.
-   * @returns The tasks with the given tag.
-   */
   getTasksWithTag(tag2) {
-    return this.registry.getTasksWithTag(tag2);
+    return typeof tag2 === "string" ? this.registry.getTasksWithTag(tag2) : this.registry.getTasksWithTag(tag2);
   }
-  /**
-   * Returns all resources with the given tag.
-   * @param tag - The tag to filter by.
-   * @returns The resources with the given tag.
-   */
   getResourcesWithTag(tag2) {
-    return this.registry.getResourcesWithTag(tag2);
+    return typeof tag2 === "string" ? this.registry.getResourcesWithTag(tag2) : this.registry.getResourcesWithTag(tag2);
   }
 };
 
@@ -36417,7 +35946,7 @@ var debugResource = defineResource({
   tags: [globalTags.system]
 });
 
-// src/processHooks.ts
+// src/tools/processShutdownHooks.ts
 var platform2 = getPlatform();
 var activeErrorHandlers = /* @__PURE__ */ new Set();
 var processSafetyNetsInstalled = false;
@@ -36506,13 +36035,6 @@ function bindProcessErrorHandler(handler) {
   };
 }
 __name(bindProcessErrorHandler, "bindProcessErrorHandler");
-async function safeReportUnhandledError(handler, info) {
-  try {
-    await handler(info);
-  } catch {
-  }
-}
-__name(safeReportUnhandledError, "safeReportUnhandledError");
 
 // src/models/RunResult.ts
 var RunResult = class {
@@ -36711,7 +36233,6 @@ function extractResourceAndConfig(resourceOrResourceWithConfig) {
 __name(extractResourceAndConfig, "extractResourceAndConfig");
 
 // src/globals/tunnels/index.ts
-init_http_fetch_tunnel_resource();
 var http = Object.freeze({
   createClient(cfg) {
     const { url, ...rest } = cfg;
@@ -36722,39 +36243,15 @@ var tunnels = Object.freeze({
   http
 });
 
-// src/testing.ts
-var testResourceCounter = 0;
-function createTestResource(root, options) {
-  return defineResource({
-    id: `testing.${root.id}.${++testResourceCounter}`,
-    register: [root],
-    overrides: options?.overrides || [],
-    dependencies: {
-      taskRunner: globalResources.taskRunner,
-      store: globalResources.store,
-      logger: globalResources.logger,
-      eventManager: globalResources.eventManager
-    },
-    async init(_, deps) {
-      return buildTestFacade(deps);
-    }
-  });
-}
-__name(createTestResource, "createTestResource");
-function buildTestFacade(deps) {
-  return {
-    // Run a task within the fully initialized ecosystem
-    runTask: /* @__PURE__ */ __name((task2, ...args) => deps.taskRunner.run(task2, ...args), "runTask"),
-    // Access a resource value by id (string or symbol)
-    getResource: /* @__PURE__ */ __name((id2) => deps.store.resources.get(id2)?.value, "getResource"),
-    // Expose internals when needed in tests (not recommended for app usage)
-    taskRunner: deps.taskRunner,
-    store: deps.store,
-    logger: deps.logger,
-    eventManager: deps.eventManager
-  };
+// src/definers/builders/shared/mergeUtils.ts
+function mergeArray(existing, addition, override2) {
+  const toArray = [...addition];
+  if (override2 || !existing) {
+    return toArray;
+  }
+  return [...existing, ...toArray];
 }
-__name(buildTestFacade, "buildTestFacade");
+__name(mergeArray, "mergeArray");
 
 // src/definers/builders/resource/utils.ts
 function clone2(s, patch) {
@@ -36800,14 +36297,6 @@ function mergeRegister(existing, addition, override2) {
   ];
 }
 __name(mergeRegister, "mergeRegister");
-function mergeArray(existing, addition, override2) {
-  const toArray = [...addition];
-  if (override2 || !existing) {
-    return toArray;
-  }
-  return [...existing, ...toArray];
-}
-__name(mergeArray, "mergeArray");
 function mergeDependencies(existing, addition, override2) {
   const isFnExisting = typeof existing === "function";
   const isFnAddition = typeof addition === "function";
@@ -36971,14 +36460,6 @@ function clone3(s, patch) {
   });
 }
 __name(clone3, "clone");
-function mergeArray2(existing, addition, override2) {
-  const toArray = [...addition];
-  if (override2 || !existing) {
-    return toArray;
-  }
-  return [...existing, ...toArray];
-}
-__name(mergeArray2, "mergeArray");
 function mergeDependencies2(existing, addition, override2) {
   const isFnExisting = typeof existing === "function";
   const isFnAddition = typeof addition === "function";
@@ -37034,14 +36515,14 @@ function makeTaskBuilder(state) {
     middleware(mw, options) {
       const override2 = options?.override ?? false;
       const next = clone3(state, {
-        middleware: mergeArray2(state.middleware, mw, override2)
+        middleware: mergeArray(state.middleware, mw, override2)
       });
       return makeTaskBuilder(next);
     },
     tags(t, options) {
       const override2 = options?.override ?? false;
       const next = clone3(state, {
-        tags: mergeArray2(state.tags, t, override2)
+        tags: mergeArray(state.tags, t, override2)
       });
       return makeTaskBuilder(next);
     },
@@ -37117,14 +36598,14 @@ function makePhantomTaskBuilder(state) {
     middleware(mw, options) {
       const override2 = options?.override ?? false;
       const next = clone3(state, {
-        middleware: mergeArray2(state.middleware, mw, override2)
+        middleware: mergeArray(state.middleware, mw, override2)
       });
       return makePhantomTaskBuilder(next);
     },
     tags(t, options) {
       const override2 = options?.override ?? false;
       const next = clone3(state, {
-        tags: mergeArray2(state.tags, t, override2)
+        tags: mergeArray(state.tags, t, override2)
       });
       return makePhantomTaskBuilder(
         next
@@ -37213,14 +36694,6 @@ function clone4(s, patch) {
   });
 }
 __name(clone4, "clone");
-function mergeArray3(existing, addition, override2) {
-  const toArray = [...addition];
-  if (override2 || !existing) {
-    return toArray;
-  }
-  return [...existing, ...toArray];
-}
-__name(mergeArray3, "mergeArray");
 
 // src/definers/builders/event/fluent-builder.ts
 function makeEventBuilder(state) {
@@ -37235,7 +36708,7 @@ function makeEventBuilder(state) {
     tags(t, options) {
       const override2 = options?.override ?? false;
       const next = clone4(state, {
-        tags: mergeArray3(state.tags, t, override2)
+        tags: mergeArray(state.tags, t, override2)
       });
       return makeEventBuilder(next);
     },
@@ -37283,14 +36756,6 @@ function clone5(s, patch) {
   });
 }
 __name(clone5, "clone");
-function mergeArray4(existing, addition, override2) {
-  const toArray = [...addition];
-  if (override2 || !existing) {
-    return toArray;
-  }
-  return [...existing, ...toArray];
-}
-__name(mergeArray4, "mergeArray");
 function mergeDependencies3(existing, addition, override2) {
   const isFnExisting = typeof existing === "function";
   const isFnAddition = typeof addition === "function";
@@ -37364,7 +36829,7 @@ function makeHookBuilder(state) {
     tags(t, options) {
       const override2 = options?.override ?? false;
       const next = clone5(state, {
-        tags: mergeArray4(state.tags, t, override2)
+        tags: mergeArray(state.tags, t, override2)
       });
       return makeHookBuilder(next);
     },
@@ -37441,14 +36906,6 @@ function cloneRes(s, patch) {
   });
 }
 __name(cloneRes, "cloneRes");
-function mergeArray5(existing, addition, override2) {
-  const toArray = [...addition];
-  if (override2 || !existing) {
-    return toArray;
-  }
-  return [...existing, ...toArray];
-}
-__name(mergeArray5, "mergeArray");
 function mergeDependencies4(existing, addition, override2) {
   const isFnExisting = typeof existing === "function";
   const isFnAddition = typeof addition === "function";
@@ -37529,7 +36986,7 @@ function makeTaskMiddlewareBuilder(state) {
     tags(t, options) {
       const override2 = options?.override ?? false;
       const next = cloneTask(state, {
-        tags: mergeArray5(state.tags, t, override2)
+        tags: mergeArray(state.tags, t, override2)
       });
       return makeTaskMiddlewareBuilder(next);
     },
@@ -37601,7 +37058,7 @@ function makeResourceMiddlewareBuilder(state) {
     tags(t, options) {
       const override2 = options?.override ?? false;
       const next = cloneRes(state, {
-        tags: mergeArray5(state.tags, t, override2)
+        tags: mergeArray(state.tags, t, override2)
       });
       return makeResourceMiddlewareBuilder(next);
     },
@@ -37812,7 +37269,7 @@ function makeHookOverrideBuilder(base, state) {
     tags(t, options) {
       const override2 = options?.override ?? false;
       const next = cloneHookState(state, {
-        tags: mergeArray4(state.tags, t, override2)
+        tags: mergeArray(state.tags, t, override2)
       });
       return makeHookOverrideBuilder(base, next);
     },
@@ -38017,7 +37474,7 @@ function makeResourceMiddlewareOverrideBuilder(base, state) {
     tags(t, options) {
       const override2 = options?.override ?? false;
       const next = cloneResourceMiddlewareState(state, {
-        tags: mergeArray5(state.tags, t, override2)
+        tags: mergeArray(state.tags, t, override2)
       });
       return makeResourceMiddlewareOverrideBuilder(base, next);
     },
@@ -38077,14 +37534,14 @@ function makeTaskOverrideBuilder(base, state) {
     middleware(mw, options) {
       const override2 = options?.override ?? false;
       const next = cloneTaskState(state, {
-        middleware: mergeArray2(state.middleware, mw, override2)
+        middleware: mergeArray(state.middleware, mw, override2)
       });
       return makeTaskOverrideBuilder(base, next);
     },
     tags(t, options) {
       const override2 = options?.override ?? false;
       const next = cloneTaskState(state, {
-        tags: mergeArray2(state.tags, t, override2)
+        tags: mergeArray(state.tags, t, override2)
       });
       return makeTaskOverrideBuilder(base, next);
     },
@@ -38193,7 +37650,7 @@ function makeTaskMiddlewareOverrideBuilder(base, state) {
     tags(t, options) {
       const override2 = options?.override ?? false;
       const next = cloneTaskMiddlewareState(state, {
-        tags: mergeArray5(state.tags, t, override2)
+        tags: mergeArray(state.tags, t, override2)
       });
       return makeTaskMiddlewareOverrideBuilder(base, next);
     },
@@ -38245,7 +37702,6 @@ function override(base) {
 __name(override, "override");
 
 // src/public.ts
-init_http_fetch_tunnel_resource();
 var globals = {
   events: globalEvents,
   resources: globalResources,
@@ -38254,7 +37710,6 @@ var globals = {
   tunnels,
   debug
 };
-var createContext2 = createContext;
 var r = Object.freeze({
   resource,
   task,
@@ -39391,6 +38846,7 @@ var UNSAFE_ERROR_FIELDS = /* @__PURE__ */ new Set([
 var isRecord2 = /* @__PURE__ */ __name((value) => !!value && typeof value === "object", "isRecord");
 var isJsonBody = /* @__PURE__ */ __name((value) => isRecord2(value) && typeof value.ok === "boolean", "isJsonBody");
 var toErrorRecord = /* @__PURE__ */ __name((value) => isRecord2(value) ? value : void 0, "toErrorRecord");
+var isValidHttpCode3 = /* @__PURE__ */ __name((value) => typeof value === "number" && Number.isInteger(value) && value >= 100 && value <= 599, "isValidHttpCode");
 var sanitizeErrorResponse = /* @__PURE__ */ __name((response) => {
   const asRecord = isRecord2(response) ? response : void 0;
   const statusRaw = asRecord?.status ?? asRecord?.statusCode;
@@ -39432,6 +38888,9 @@ var sanitizeErrorResponse = /* @__PURE__ */ __name((response) => {
       if (bodyError.data !== void 0) {
         safeError.data = bodyError.data;
       }
+      if (isValidHttpCode3(bodyError.httpCode)) {
+        safeError.httpCode = bodyError.httpCode;
+      }
       return {
         ok: false,
         error: safeError
@@ -39453,11 +38912,19 @@ var resolveAppErrorExtra = /* @__PURE__ */ __name((store2, error2) => {
   try {
     for (const helper of store2.errors.values()) {
       if (helper.is(error2)) {
-        if (!isRecord2(error2)) return { id: void 0, data: void 0 };
+        if (!isRecord2(error2)) {
+          return {
+            id: void 0,
+            data: void 0,
+            httpCode: isValidHttpCode3(helper.httpCode) ? helper.httpCode : void 0
+          };
+        }
         const name = error2["name" /* Name */];
         const id2 = typeof name === "string" ? name : void 0;
         const data = error2["data" /* Data */];
-        return { id: id2, data };
+        const runtimeHttpCode = error2["httpCode" /* HttpCode */];
+        const httpCode = isValidHttpCode3(runtimeHttpCode) ? runtimeHttpCode : isValidHttpCode3(helper.httpCode) ? helper.httpCode : void 0;
+        return { id: id2, data, httpCode };
       }
     }
   } catch {
@@ -39467,6 +38934,7 @@ var resolveAppErrorExtra = /* @__PURE__ */ __name((store2, error2) => {
 var handleRequestError = /* @__PURE__ */ __name((options) => {
   const { error: error2, req, res, store: store2, logger, cors, serializer: serializer3, logKey } = options;
   const appErrorExtra = resolveAppErrorExtra(store2, error2);
+  const responseStatus = appErrorExtra?.httpCode ?? 500;
   const displayMessage = appErrorExtra && error2 instanceof Error && error2.message ? error2.message : "Internal Error" /* InternalError */;
   safeLogError(logger, logKey, { error: errorMessage(error2) });
   applyCorsActual(req, res, cors);
@@ -39474,7 +38942,7 @@ var handleRequestError = /* @__PURE__ */ __name((options) => {
     res,
     sanitizeErrorResponse(
       jsonErrorResponse(
-        500,
+        responseStatus,
         displayMessage,
         "INTERNAL_ERROR" /* InternalError */,
         appErrorExtra
@@ -39486,7 +38954,7 @@ var handleRequestError = /* @__PURE__ */ __name((options) => {
 
 // src/node/exposure/requestContext.ts
 var ExposureRequestContext = defineAsyncContext({
-  id: "platform.node.exposure.request"
+  id: "platform.node.ctx.exposureRequest"
 });
 function useExposureContext() {
   return ExposureRequestContext.use();
@@ -39527,7 +38995,7 @@ var withExposureContext = /* @__PURE__ */ __name((req, res, controller, deps, fn
     } catch {
     }
   }
-  const run3 = /* @__PURE__ */ __name(() => ExposureRequestContext.provide(
+  const run2 = /* @__PURE__ */ __name(() => ExposureRequestContext.provide(
     {
       req,
       res,
@@ -39539,7 +39007,7 @@ var withExposureContext = /* @__PURE__ */ __name((req, res, controller, deps, fn
     },
     userWrapped
   ), "run");
-  return Promise.resolve(run3());
+  return Promise.resolve(run2());
 }, "withExposureContext");
 var withUserContexts = /* @__PURE__ */ __name((req, deps, fn) => {
   const { store: store2, serializer: serializer3 } = deps;
@@ -39735,7 +39203,7 @@ var createTaskHandler = /* @__PURE__ */ __name((deps) => {
       applyCorsActual(req, res, cors);
       respondJson(res, jsonOkResponse({ result }), serializer3);
     } catch (error2) {
-      if (isCancellationError(error2)) {
+      if (cancellationError.is(error2)) {
         if (!res.writableEnded && !res.headersSent) {
           applyCorsActual(req, res, cors);
           respondJson(
@@ -39844,7 +39312,7 @@ var createEventHandler = /* @__PURE__ */ __name((deps) => {
         serializer3
       );
     } catch (error2) {
-      if (isCancellationError(error2)) {
+      if (cancellationError.is(error2)) {
         if (!res.writableEnded && !res.headersSent) {
           applyCorsActual(req, res, cors);
           respondJson(
@@ -39947,190 +39415,650 @@ function createRequestHandlers(deps) {
             events: Array.from(list.eventIds)
           }
         }
-      }),
-      serializer3
-    );
-  }, "handleDiscovery");
-  const handleRequest = /* @__PURE__ */ __name(async (req, res) => {
-    const url = requestUrl(req);
-    const target = router.extract(url.pathname);
-    if (!target) {
-      if (!router.isUnderBase(url.pathname)) {
-        return false;
-      }
-      if (handleCorsPreflight(req, res, cors)) return true;
-      applyCorsActual(req, res, cors);
-      respondJson(res, NOT_FOUND_RESPONSE, serializer3);
-      return true;
-    }
-    if (target.kind === "task") {
-      if (handleCorsPreflight(req, res, cors)) return true;
-      await processTaskRequest(req, res, target.id);
-    } else if (target.kind === "event") {
-      if (handleCorsPreflight(req, res, cors)) return true;
-      await processEventRequest(req, res, target.id);
-    } else if (target.kind === "discovery") {
-      if (handleCorsPreflight(req, res, cors)) return true;
-      await handleDiscovery(req, res);
+      }),
+      serializer3
+    );
+  }, "handleDiscovery");
+  const handleRequest = /* @__PURE__ */ __name(async (req, res) => {
+    const url = requestUrl(req);
+    const target = router.extract(url.pathname);
+    if (!target) {
+      if (!router.isUnderBase(url.pathname)) {
+        return false;
+      }
+      if (handleCorsPreflight(req, res, cors)) return true;
+      applyCorsActual(req, res, cors);
+      respondJson(res, NOT_FOUND_RESPONSE, serializer3);
+      return true;
+    }
+    if (target.kind === "task") {
+      if (handleCorsPreflight(req, res, cors)) return true;
+      await processTaskRequest(req, res, target.id);
+    } else if (target.kind === "event") {
+      if (handleCorsPreflight(req, res, cors)) return true;
+      await processEventRequest(req, res, target.id);
+    } else if (target.kind === "discovery") {
+      if (handleCorsPreflight(req, res, cors)) return true;
+      await handleDiscovery(req, res);
+    }
+    return true;
+  }, "handleRequest");
+  return { handleTask, handleEvent, handleDiscovery, handleRequest };
+}
+__name(createRequestHandlers, "createRequestHandlers");
+
+// src/node/exposure/createNodeExposure.ts
+async function createNodeExposure(cfg, deps) {
+  const { store: store2, taskRunner, eventManager, logger, serializer: serializer3 } = deps;
+  const httpConfig = cfg?.http;
+  const basePath = resolveBasePath(httpConfig?.basePath);
+  const router = createRouter(basePath);
+  const allowList = createAllowListGuard(
+    store2,
+    !!httpConfig?.dangerouslyAllowOpenExposure
+  );
+  const validatorTasks = store2.getTasksWithTag(
+    globalTags.authValidator
+  );
+  const authenticator = createAuthenticator(
+    httpConfig?.auth,
+    taskRunner,
+    validatorTasks
+  );
+  const { handleTask, handleEvent, handleDiscovery, handleRequest } = createRequestHandlers({
+    store: store2,
+    taskRunner,
+    eventManager,
+    logger,
+    authenticator,
+    allowList,
+    router,
+    cors: httpConfig?.cors,
+    serializer: serializer3,
+    limits: httpConfig?.limits
+  });
+  const serverControls = await createExposureServer({
+    httpConfig,
+    handler: handleRequest,
+    logger,
+    basePath
+  });
+  return {
+    handleRequest,
+    handleTask,
+    handleEvent,
+    handleDiscovery,
+    createRequestListener: serverControls.createRequestListener,
+    createServer: serverControls.createServer,
+    attachTo: serverControls.attachTo,
+    server: serverControls.server,
+    basePath,
+    close: serverControls.close
+  };
+}
+__name(createNodeExposure, "createNodeExposure");
+
+// src/node/exposure/resource.ts
+var nodeExposure = defineResource({
+  id: "platform.node.resources.exposure",
+  meta: {
+    title: "Node Exposure (HTTP)",
+    description: "Exposes Runner tasks and events over HTTP so a tunnel client can invoke them."
+  },
+  dependencies: {
+    store: globalResources.store,
+    taskRunner: globalResources.taskRunner,
+    eventManager: globalResources.eventManager,
+    logger: globalResources.logger,
+    serializer: globalResources.serializer
+  },
+  async init(cfg, deps) {
+    return createNodeExposure(cfg, deps);
+  },
+  async dispose(value) {
+    if (value?.close) {
+      await value.close();
+    }
+  }
+});
+
+// src/node/files/createNodeFile.ts
+function createNodeFile(meta, source, id2 = "F1") {
+  return {
+    $runnerFile: "File",
+    id: id2,
+    meta,
+    _node: source
+  };
+}
+__name(createNodeFile, "createNodeFile");
+async function readInputFileToBuffer(file) {
+  const { stream } = await file.resolve();
+  const chunks = [];
+  await new Promise((resolve, reject) => {
+    stream.on("data", (chunk) => {
+      if (Buffer.isBuffer(chunk)) {
+        chunks.push(chunk);
+      } else if (typeof chunk === "string") {
+        chunks.push(Buffer.from(chunk));
+      } else if (chunk !== void 0 && chunk !== null) {
+        chunks.push(Buffer.from(String(chunk)));
+      }
+    });
+    stream.on("end", () => resolve());
+    stream.on("error", (err) => reject(err));
+  });
+  return Buffer.concat(chunks);
+}
+__name(readInputFileToBuffer, "readInputFileToBuffer");
+async function writeInputFileToPath(file, targetPath) {
+  const { stream } = await file.resolve();
+  await fs3.promises.mkdir(path3.dirname(targetPath), {
+    recursive: true
+  });
+  const write = fs3.createWriteStream(targetPath);
+  let bytesWritten = 0;
+  const normalize = new Transform({
+    writableObjectMode: true,
+    transform(chunk, _enc, cb) {
+      const out = Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk));
+      bytesWritten += out.length;
+      cb(null, out);
+    }
+  });
+  await new Promise((resolve, reject) => {
+    pipeline(
+      stream,
+      normalize,
+      write,
+      (err) => err ? reject(err) : resolve()
+    );
+  });
+  return { bytesWritten };
+}
+__name(writeInputFileToPath, "writeInputFileToPath");
+
+// 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-smart-client.model.ts
+function isReadable(value) {
+  return !!value && typeof value.pipe === "function";
+}
+__name(isReadable, "isReadable");
+function hasNodeFile(value) {
+  const isNodeFileSentinel = /* @__PURE__ */ __name((v) => {
+    if (!v || typeof v !== "object") return false;
+    const rec = v;
+    if (rec.$runnerFile !== "File") return false;
+    if (typeof rec.id !== "string") return false;
+    const node = rec._node;
+    if (!node || typeof node !== "object") return false;
+    const n = node;
+    return Boolean(n.stream || n.buffer);
+  }, "isNodeFileSentinel");
+  const visit = /* @__PURE__ */ __name((v) => {
+    if (isNodeFileSentinel(v)) return true;
+    if (!v || typeof v !== "object") return false;
+    if (Array.isArray(v)) return v.some(visit);
+    for (const k of Object.keys(v)) {
+      if (visit(v[k])) return true;
+    }
+    return false;
+  }, "visit");
+  return visit(value);
+}
+__name(hasNodeFile, "hasNodeFile");
+function toHeaders2(auth) {
+  const headers = {};
+  if (auth?.token)
+    headers[(auth.header ?? "x-runner-token").toLowerCase()] = auth.token;
+  return headers;
+}
+__name(toHeaders2, "toHeaders");
+function requestLib(url) {
+  return url.protocol === "https:" ? https : http2;
+}
+__name(requestLib, "requestLib");
+async function postJson(cfg, url, body) {
+  const serializer3 = cfg.serializer;
+  const parsed = new URL(url);
+  const lib = requestLib(parsed);
+  const headers = {
+    "content-type": "application/json; charset=utf-8",
+    ...toHeaders2(cfg.auth)
+  };
+  if (cfg.contexts && cfg.contexts.length > 0) {
+    const map = {};
+    for (const ctx of cfg.contexts) {
+      try {
+        const v = ctx.use();
+        map[ctx.id] = ctx.serialize(v);
+      } catch {
+      }
+    }
+    if (Object.keys(map).length > 0) {
+      headers["x-runner-context"] = cfg.serializer.stringify(map);
+    }
+  }
+  if (cfg.onRequest) await cfg.onRequest({ url, headers });
+  return await new Promise((resolve, reject) => {
+    const req = lib.request(
+      {
+        method: "POST",
+        protocol: parsed.protocol,
+        hostname: parsed.hostname,
+        port: parsed.port,
+        path: parsed.pathname + parsed.search,
+        headers,
+        timeout: cfg.timeoutMs
+      },
+      (res) => {
+        const chunks = [];
+        res.on("data", (c) => {
+          chunks.push(Buffer.isBuffer(c) ? c : Buffer.from(String(c)));
+        });
+        res.on("end", () => {
+          const text = Buffer.concat(chunks).toString(
+            "utf8"
+          );
+          const json2 = text ? serializer3.parse(text) : void 0;
+          resolve(json2);
+        });
+      }
+    );
+    req.on("error", reject);
+    req.write(serializer3.stringify(body));
+    req.end();
+  });
+}
+__name(postJson, "postJson");
+function escapeHeaderValue(value) {
+  return value.replace(/"/g, '\\"');
+}
+__name(escapeHeaderValue, "escapeHeaderValue");
+function encodeMultipart(manifestText, files, boundary) {
+  async function* gen() {
+    const CRLF = "\r\n";
+    const boundaryLine = `--${boundary}`;
+    const partHeader = /* @__PURE__ */ __name((name, options) => {
+      const h = [boundaryLine + CRLF];
+      const cd = [
+        `Content-Disposition: form-data; name="${escapeHeaderValue(name)}"`
+      ];
+      if (options?.filename) {
+        cd.push(`; filename="${escapeHeaderValue(options.filename)}"`);
+      }
+      h.push(cd.join("") + CRLF);
+      if (options?.headers) {
+        for (const k of Object.keys(options.headers)) {
+          h.push(`${k}: ${options.headers[k]}` + CRLF);
+        }
+      }
+      h.push(CRLF);
+      return Buffer.from(h.join(""), "utf8");
+    }, "partHeader");
+    yield partHeader("__manifest");
+    yield Buffer.from(manifestText, "utf8");
+    yield Buffer.from(CRLF, "utf8");
+    for (const entry of files) {
+      const filename = entry.meta?.name ?? "upload";
+      const contentType = entry.meta?.type ?? "application/octet-stream";
+      const headers = {
+        "Content-Type": contentType
+      };
+      yield partHeader(`file:${entry.id}`, { headers, filename });
+      if (entry.source.type === "buffer") {
+        yield entry.source.buffer;
+      } else {
+        for await (const chunk of entry.source.stream) {
+          yield Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk));
+        }
+      }
+      yield Buffer.from(CRLF, "utf8");
+    }
+    yield Buffer.from(boundaryLine + "--" + CRLF, "utf8");
+  }
+  __name(gen, "gen");
+  return Readable.from(gen());
+}
+__name(encodeMultipart, "encodeMultipart");
+async function postMultipart(cfg, url, manifestText, files) {
+  const parsed = new URL(url);
+  const lib = requestLib(parsed);
+  const boundary = `runner-${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+  const body = encodeMultipart(manifestText, files, boundary);
+  const headers = {
+    "content-type": `multipart/form-data; boundary=${boundary}`,
+    ...toHeaders2(cfg.auth)
+  };
+  if (cfg.contexts && cfg.contexts.length > 0) {
+    const map = {};
+    for (const ctx of cfg.contexts) {
+      try {
+        const v = ctx.use();
+        map[ctx.id] = ctx.serialize(v);
+      } catch {
+      }
+    }
+    if (Object.keys(map).length > 0) {
+      headers["x-runner-context"] = cfg.serializer.stringify(map);
+    }
+  }
+  if (cfg.onRequest) await cfg.onRequest({ url, headers });
+  return await new Promise(
+    (resolve, reject) => {
+      const req = lib.request(
+        {
+          method: "POST",
+          protocol: parsed.protocol,
+          hostname: parsed.hostname,
+          port: parsed.port,
+          path: parsed.pathname + parsed.search,
+          headers,
+          timeout: cfg.timeoutMs
+        },
+        (res) => resolve({ stream: res, res })
+      );
+      req.on("error", reject);
+      body.on("error", (e) => req.destroy(e));
+      body.pipe(req);
+    }
+  );
+}
+__name(postMultipart, "postMultipart");
+async function postOctetStream(cfg, url, stream) {
+  const parsed = new URL(url);
+  const lib = requestLib(parsed);
+  const headers = {
+    "content-type": "application/octet-stream",
+    ...toHeaders2(cfg.auth)
+  };
+  if (cfg.contexts && cfg.contexts.length > 0) {
+    const map = {};
+    for (const ctx of cfg.contexts) {
+      try {
+        const v = ctx.use();
+        map[ctx.id] = ctx.serialize(v);
+      } catch {
+      }
+    }
+    if (Object.keys(map).length > 0) {
+      headers["x-runner-context"] = cfg.serializer.stringify(map);
+    }
+  }
+  if (cfg.onRequest) await cfg.onRequest({ url, headers });
+  return await new Promise(
+    (resolve, reject) => {
+      let settled = false;
+      const cleanup = [];
+      const resolveOnce = /* @__PURE__ */ __name((value) => {
+        settled = true;
+        cleanup.forEach((fn) => fn());
+        resolve(value);
+      }, "resolveOnce");
+      const rejectOnce = /* @__PURE__ */ __name((error2) => {
+        settled = true;
+        cleanup.forEach((fn) => fn());
+        reject(error2 instanceof Error ? error2 : new Error(String(error2)));
+      }, "rejectOnce");
+      const req = lib.request(
+        {
+          method: "POST",
+          protocol: parsed.protocol,
+          hostname: parsed.hostname,
+          port: parsed.port,
+          path: parsed.pathname + parsed.search,
+          headers,
+          timeout: cfg.timeoutMs
+        },
+        (res) => {
+          setImmediate(() => {
+            if (!settled)
+              resolveOnce({ stream: res, res });
+          });
+        }
+      );
+      const onReqError = /* @__PURE__ */ __name((e) => rejectOnce(e), "onReqError");
+      req.on("error", onReqError);
+      cleanup.push(() => req.removeListener("error", onReqError));
+      const onPipelineDone = /* @__PURE__ */ __name((err) => {
+        if (err) rejectOnce(err);
+      }, "onPipelineDone");
+      pipeline(stream, req, onPipelineDone);
     }
-    return true;
-  }, "handleRequest");
-  return { handleTask, handleEvent, handleDiscovery, handleRequest };
-}
-__name(createRequestHandlers, "createRequestHandlers");
-
-// src/node/exposure/createNodeExposure.ts
-async function createNodeExposure(cfg, deps) {
-  const { store: store2, taskRunner, eventManager, logger, serializer: serializer3 } = deps;
-  const httpConfig = cfg?.http;
-  const basePath = resolveBasePath(httpConfig?.basePath);
-  const router = createRouter(basePath);
-  const allowList = createAllowListGuard(
-    store2,
-    !!httpConfig?.dangerouslyAllowOpenExposure
-  );
-  const validatorTasks = store2.getTasksWithTag(
-    globalTags.authValidator
-  );
-  const authenticator = createAuthenticator(
-    httpConfig?.auth,
-    taskRunner,
-    validatorTasks
   );
-  const { handleTask, handleEvent, handleDiscovery, handleRequest } = createRequestHandlers({
-    store: store2,
-    taskRunner,
-    eventManager,
-    logger,
-    authenticator,
-    allowList,
-    router,
-    cors: httpConfig?.cors,
-    serializer: serializer3,
-    limits: httpConfig?.limits
-  });
-  const serverControls = await createExposureServer({
-    httpConfig,
-    handler: handleRequest,
-    logger,
-    basePath
-  });
-  return {
-    handleRequest,
-    handleTask,
-    handleEvent,
-    handleDiscovery,
-    createRequestListener: serverControls.createRequestListener,
-    createServer: serverControls.createServer,
-    attachTo: serverControls.attachTo,
-    server: serverControls.server,
-    basePath,
-    close: serverControls.close
-  };
 }
-__name(createNodeExposure, "createNodeExposure");
-
-// src/node/exposure/resource.ts
-var nodeExposure = defineResource({
-  id: "platform.node.resources.exposure",
-  meta: {
-    title: "Node Exposure (HTTP)",
-    description: "Exposes Runner tasks and events over HTTP so a tunnel client can invoke them."
-  },
-  dependencies: {
-    store: globalResources.store,
-    taskRunner: globalResources.taskRunner,
-    eventManager: globalResources.eventManager,
-    logger: globalResources.logger,
-    serializer: globalResources.serializer
-  },
-  async init(cfg, deps) {
-    return createNodeExposure(cfg, deps);
-  },
-  async dispose(value) {
-    if (value?.close) {
-      await value.close();
+__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);
     }
   }
-});
-
-// src/node/files/createNodeFile.ts
-function createNodeFile(meta, source, id2 = "F1") {
+  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 {
-    $runnerFile: "File",
-    id: id2,
-    meta,
-    _node: source
+    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(createNodeFile, "createNodeFile");
-async function readInputFileToBuffer(file) {
-  const { stream } = await file.resolve();
-  const chunks = [];
-  await new Promise((resolve, reject) => {
-    stream.on("data", (chunk) => {
-      if (Buffer.isBuffer(chunk)) {
-        chunks.push(chunk);
-      } else if (typeof chunk === "string") {
-        chunks.push(Buffer.from(chunk));
-      } else if (chunk !== void 0 && chunk !== null) {
-        chunks.push(Buffer.from(String(chunk)));
-      }
-    });
-    stream.on("end", () => resolve());
-    stream.on("error", (err) => reject(err));
-  });
-  return Buffer.concat(chunks);
+__name(createHttpSmartClient, "createHttpSmartClient");
+
+// src/node/http/http-mixed-client.ts
+function isReadable2(value) {
+  return !!value && typeof value.pipe === "function";
 }
-__name(readInputFileToBuffer, "readInputFileToBuffer");
-async function writeInputFileToPath(file, targetPath) {
-  const { stream } = await file.resolve();
-  await fs3.promises.mkdir(path3.dirname(targetPath), {
-    recursive: true
-  });
-  const write = fs3.createWriteStream(targetPath);
-  let bytesWritten = 0;
-  const normalize = new Transform({
-    writableObjectMode: true,
-    transform(chunk, _enc, cb) {
-      const out = Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk));
-      bytesWritten += out.length;
-      cb(null, out);
+__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
   });
-  await new Promise((resolve, reject) => {
-    pipeline(
-      stream,
-      normalize,
-      write,
-      (err) => err ? reject(err) : resolve()
-    );
+  const smartClient = createHttpSmartClient({
+    baseUrl,
+    auth: cfg.auth,
+    timeoutMs: cfg.timeoutMs,
+    serializer: cfg.serializer,
+    onRequest: cfg.onRequest,
+    contexts: cfg.contexts,
+    errorRegistry: cfg.errorRegistry
   });
-  return { bytesWritten };
+  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(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/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."
-  }
-});
+__name(createHttpMixedClient, "createHttpMixedClient");
 
 // src/node/durable/core/types.ts
 var ExecutionStatus = {
@@ -40433,6 +40361,15 @@ async function recordFlowShape(descriptor) {
 }
 __name(recordFlowShape, "recordFlowShape");
 
+// src/node/durable/tags/durableWorkflow.tag.ts
+var durableWorkflowTag = defineTag({
+  id: "globals.tags.durableWorkflow",
+  meta: {
+    title: "Durable Workflow",
+    description: "Marks tasks intended to run as durable workflows so they can be discovered at runtime."
+  }
+});
+
 // src/node/durable/core/DurableResource.ts
 var DurableResource = class _DurableResource {
   constructor(service, contextStorage, store2, runnerStore) {
@@ -40484,11 +40421,20 @@ 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() {
+    if (!this.runnerStore) {
+      throw new Error(
+        "Durable workflow discovery is not available: runner store was not provided to DurableResource. Use a Runner durable resource (durableResource/memoryDurableResource/redisDurableResource) instead of manually constructing DurableResource."
+      );
+    }
+    return this.runnerStore.getTasksWithTag(durableWorkflowTag);
+  }
   injectRecorderIntoDurableDeps(deps, ctx) {
     const next = { ...deps };
     for (const [key, value] of Object.entries(deps)) {
@@ -40506,8 +40452,28 @@ var DurableResource = class _DurableResource {
     }
     return next;
   }
-  startExecution(task2, input, options) {
-    return this.service.startExecution(task2, input, options);
+  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);
+    }
+    return this.service.start(task2, input, options);
   }
   cancelExecution(executionId, reason) {
     return this.service.cancelExecution(executionId, reason);
@@ -40515,16 +40481,22 @@ var DurableResource = class _DurableResource {
   wait(executionId, options) {
     return this.service.wait(executionId, options);
   }
-  execute(task2, input, options) {
-    return this.service.execute(task2, input, options);
-  }
-  executeStrict(task2, input, options) {
-    return this.service.executeStrict(task2, input, options);
+  startAndWait(task2, input, options) {
+    if (typeof task2 === "string") {
+      return this.service.startAndWait(task2, input, options);
+    }
+    return this.service.startAndWait(task2, input, options);
   }
   schedule(task2, input, options) {
+    if (typeof task2 === "string") {
+      return this.service.schedule(task2, input, options);
+    }
     return this.service.schedule(task2, input, options);
   }
   ensureSchedule(task2, input, options) {
+    if (typeof task2 === "string") {
+      return this.service.ensureSchedule(task2, input, options);
+    }
     return this.service.ensureSchedule(task2, input, options);
   }
   pauseSchedule(scheduleId) {
@@ -41047,10 +41019,11 @@ var ScheduleManager = class {
   static {
     __name(this, "ScheduleManager");
   }
-  async ensureSchedule(task2, input, options) {
+  async ensureSchedule(taskRef, input, options) {
     if (!options.cron && options.interval === void 0) {
       throw new Error("ensureSchedule() requires cron or interval");
     }
+    const task2 = this.resolveTaskReference(taskRef, "ensureSchedule");
     this.taskRegistry.register(task2);
     const scheduleId = options.id;
     const lockTtlMs = 1e4;
@@ -41113,7 +41086,8 @@ var ScheduleManager = class {
       }
     }
   }
-  async schedule(task2, input, options) {
+  async schedule(taskRef, input, options) {
+    const task2 = this.resolveTaskReference(taskRef, "schedule");
     this.taskRegistry.register(task2);
     const id2 = options.id ?? createExecutionId();
     if (options.cron || options.interval !== void 0) {
@@ -41196,6 +41170,18 @@ var ScheduleManager = class {
   async remove(id2) {
     await this.store.deleteSchedule(id2);
   }
+  resolveTaskReference(taskRef, apiMethod) {
+    if (typeof taskRef !== "string") {
+      return taskRef;
+    }
+    const resolved = this.taskRegistry.find(taskRef);
+    if (!resolved) {
+      throw new Error(
+        `DurableService.${apiMethod}() could not resolve task id "${taskRef}". Ensure the task is registered in the runtime store.`
+      );
+    }
+    return resolved;
+  }
 };
 
 // src/node/durable/core/managers/SignalHandler.ts
@@ -42086,99 +42072,117 @@ var ExecutionManager = class {
   static {
     __name(this, "ExecutionManager");
   }
-  async startExecution(task2, input, options) {
+  async start(taskRef, input, options) {
+    const task2 = this.resolveTaskReference(taskRef, "start");
     this.taskRegistry.register(task2);
+    this.assertCanExecute();
+    if (options?.idempotencyKey) {
+      return this.startWithIdempotencyKey(
+        task2,
+        input,
+        options.idempotencyKey,
+        options
+      );
+    }
+    const executionId = await this.persistNewExecution(task2, input, options);
+    await this.kickoffWithFailsafe(executionId);
+    return executionId;
+  }
+  // ─── Idempotent start ──────────────────────────────────────────────────────
+  /**
+   * Start a workflow with deduplication: if the same (taskId, idempotencyKey)
+   * was already started, returns the existing executionId instead of creating
+   * a duplicate. Uses a distributed lock to prevent concurrent races.
+   */
+  async startWithIdempotencyKey(task2, input, idempotencyKey, options) {
+    this.assertStoreSupportsIdempotency();
+    return this.withIdempotencyLock(task2.id, idempotencyKey, async () => {
+      const existingId = await this.config.store.getExecutionIdByIdempotencyKey({
+        taskId: task2.id,
+        idempotencyKey
+      });
+      if (existingId) return existingId;
+      const executionId = createExecutionId();
+      const claimed = await this.config.store.setExecutionIdByIdempotencyKey({
+        taskId: task2.id,
+        idempotencyKey,
+        executionId
+      });
+      if (!claimed) {
+        return this.resolveRacedIdempotencyKey(task2.id, idempotencyKey);
+      }
+      await this.persistNewExecution(task2, input, options, executionId);
+      await this.kickoffExecution(executionId);
+      return executionId;
+    });
+  }
+  assertCanExecute() {
     if (!this.config.queue && !this.config.taskExecutor) {
       throw new Error(
         "DurableService requires `taskExecutor` to execute Runner tasks (when no queue is configured). Use `durableResource.fork(...).with(...)` in a Runner runtime, or provide a custom executor in config."
       );
     }
-    const idempotencyKey = options?.idempotencyKey;
-    if (idempotencyKey) {
-      if (!this.config.store.getExecutionIdByIdempotencyKey || !this.config.store.setExecutionIdByIdempotencyKey) {
-        throw new Error(
-          "Durable store does not support execution idempotency keys. Implement getExecutionIdByIdempotencyKey/setExecutionIdByIdempotencyKey on the store to use ExecuteOptions.idempotencyKey."
-        );
-      }
-      const lockTtlMs = 1e4;
-      const lockResource = `idempotency:${task2.id}:${idempotencyKey}`;
-      const canLock = !!this.config.store.acquireLock && !!this.config.store.releaseLock;
-      let lockId = null;
-      if (canLock) {
-        const maxAttempts = 50;
-        for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
-          lockId = await this.config.store.acquireLock(
-            lockResource,
-            lockTtlMs
-          );
-          if (lockId !== null) break;
-          await sleepMs(5);
-        }
-        if (lockId === null) {
-          throw new Error(
-            `Failed to acquire idempotency lock for '${task2.id}:${idempotencyKey}'`
-          );
-        }
-      }
+  }
+  assertStoreSupportsIdempotency() {
+    if (!this.config.store.getExecutionIdByIdempotencyKey || !this.config.store.setExecutionIdByIdempotencyKey) {
+      throw new Error(
+        "Durable store does not support execution idempotency keys. Implement getExecutionIdByIdempotencyKey/setExecutionIdByIdempotencyKey on the store to use ExecuteOptions.idempotencyKey."
+      );
+    }
+  }
+  /**
+   * Acquires a distributed lock around the idempotency check-and-set,
+   * falling back to lock-free operation when the store has no locking support.
+   */
+  async withIdempotencyLock(taskId, idempotencyKey, fn) {
+    const canLock = !!this.config.store.acquireLock && !!this.config.store.releaseLock;
+    if (!canLock) return fn();
+    const lockResource = `idempotency:${taskId}:${idempotencyKey}`;
+    const lockTtlMs = 1e4;
+    const maxAttempts = 50;
+    let lockId = null;
+    for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
+      lockId = await this.config.store.acquireLock(lockResource, lockTtlMs);
+      if (lockId !== null) break;
+      await sleepMs(5);
+    }
+    if (lockId === null) {
+      throw new Error(
+        `Failed to acquire idempotency lock for '${taskId}:${idempotencyKey}'`
+      );
+    }
+    try {
+      return await fn();
+    } finally {
       try {
-        const existing = await this.config.store.getExecutionIdByIdempotencyKey(
-          {
-            taskId: task2.id,
-            idempotencyKey
-          }
-        );
-        if (existing) return existing;
-        const executionId2 = createExecutionId();
-        const setOk = await this.config.store.setExecutionIdByIdempotencyKey({
-          taskId: task2.id,
-          idempotencyKey,
-          executionId: executionId2
-        });
-        if (!setOk) {
-          const raced = await this.config.store.getExecutionIdByIdempotencyKey({
-            taskId: task2.id,
-            idempotencyKey
-          });
-          if (raced) return raced;
-          throw new Error(
-            "Failed to set idempotency mapping but no existing mapping found."
-          );
-        }
-        const execution2 = {
-          id: executionId2,
-          taskId: task2.id,
-          input,
-          status: ExecutionStatus.Pending,
-          attempt: 1,
-          maxAttempts: this.config.execution?.maxAttempts ?? 3,
-          timeout: options?.timeout ?? this.config.execution?.timeout,
-          createdAt: /* @__PURE__ */ new Date(),
-          updatedAt: /* @__PURE__ */ new Date()
-        };
-        await this.config.store.saveExecution(execution2);
-        await this.auditLogger.log({
-          kind: DurableAuditEntryKind.ExecutionStatusChanged,
-          executionId: executionId2,
-          taskId: task2.id,
-          attempt: execution2.attempt,
-          from: null,
-          to: ExecutionStatus.Pending,
-          reason: "created"
-        });
-        await this.kickoffExecution(executionId2);
-        return executionId2;
-      } finally {
-        if (canLock && lockId !== null) {
-          try {
-            await this.config.store.releaseLock(lockResource, lockId);
-          } catch {
-          }
-        }
+        await this.config.store.releaseLock(lockResource, lockId);
+      } catch {
       }
     }
-    const executionId = createExecutionId();
+  }
+  /**
+   * Recovery path: `setExecutionIdByIdempotencyKey` returned false (another
+   * writer won the race), so we re-read the mapping to get their executionId.
+   */
+  async resolveRacedIdempotencyKey(taskId, idempotencyKey) {
+    const racedId = await this.config.store.getExecutionIdByIdempotencyKey({
+      taskId,
+      idempotencyKey
+    });
+    if (racedId) return racedId;
+    throw new Error(
+      "Failed to set idempotency mapping but no existing mapping found."
+    );
+  }
+  // ─── Execution persistence ─────────────────────────────────────────────────
+  /**
+   * Creates a new execution record, persists it to the store, and logs an
+   * audit entry. Returns the executionId.
+   */
+  async persistNewExecution(task2, input, options, executionId) {
+    const id2 = executionId ?? createExecutionId();
     const execution = {
-      id: executionId,
+      id: id2,
       taskId: task2.id,
       input,
       status: ExecutionStatus.Pending,
@@ -42191,37 +42195,40 @@ var ExecutionManager = class {
     await this.config.store.saveExecution(execution);
     await this.auditLogger.log({
       kind: DurableAuditEntryKind.ExecutionStatusChanged,
-      executionId,
+      executionId: id2,
       taskId: task2.id,
       attempt: execution.attempt,
       from: null,
       to: ExecutionStatus.Pending,
       reason: "created"
     });
-    const kickoffTimerId = `kickoff:${executionId}`;
-    const kickoffFailsafeDelayMs = this.config.execution?.kickoffFailsafeDelayMs ?? 1e4;
-    const shouldArmKickoffFailsafe = Boolean(this.config.queue) && kickoffFailsafeDelayMs > 0;
-    if (shouldArmKickoffFailsafe) {
+    return id2;
+  }
+  /**
+   * Kicks off an execution with a failsafe timer for queue mode.
+   * If the queue enqueue succeeds, the timer is cleaned up immediately.
+   * If enqueue fails, the timer remains so the polling loop can retry later.
+   */
+  async kickoffWithFailsafe(executionId) {
+    const failsafeDelayMs = this.config.execution?.kickoffFailsafeDelayMs ?? 1e4;
+    const shouldArmFailsafe = Boolean(this.config.queue) && failsafeDelayMs > 0;
+    if (shouldArmFailsafe) {
+      const timerId = `kickoff:${executionId}`;
       await this.config.store.createTimer({
-        id: kickoffTimerId,
+        id: timerId,
         executionId,
         type: TimerType.Retry,
-        fireAt: new Date(Date.now() + kickoffFailsafeDelayMs),
+        fireAt: new Date(Date.now() + failsafeDelayMs),
         status: TimerStatus.Pending
       });
-    }
-    try {
       await this.kickoffExecution(executionId);
-      if (shouldArmKickoffFailsafe) {
-        try {
-          await this.config.store.deleteTimer(kickoffTimerId);
-        } catch {
-        }
+      try {
+        await this.config.store.deleteTimer(timerId);
+      } catch {
       }
-    } catch (error2) {
-      throw error2;
+      return;
     }
-    return executionId;
+    await this.kickoffExecution(executionId);
   }
   async cancelExecution(executionId, reason) {
     const execution = await this.config.store.getExecution(executionId);
@@ -42252,16 +42259,16 @@ var ExecutionManager = class {
       timestamp: /* @__PURE__ */ new Date()
     });
   }
-  async execute(task2, input, options) {
-    const executionId = await this.startExecution(task2, input, options);
-    return await this.waitManager.waitForResult(executionId, {
+  async startAndWait(taskRef, input, options) {
+    const executionId = await this.start(taskRef, input, options);
+    const data = await this.waitManager.waitForResult(executionId, {
       timeout: options?.timeout,
       waitPollIntervalMs: options?.waitPollIntervalMs
     });
-  }
-  async executeStrict(task2, input, options) {
-    const actualTask = task2;
-    return await this.execute(actualTask, input, options);
+    return {
+      durable: { executionId },
+      data
+    };
   }
   async processExecution(executionId) {
     const execution = await this.config.store.getExecution(executionId);
@@ -42470,6 +42477,18 @@ var ExecutionManager = class {
       });
     }
   }
+  resolveTaskReference(taskRef, apiMethod) {
+    if (typeof taskRef !== "string") {
+      return taskRef;
+    }
+    const resolved = this.taskRegistry.find(taskRef);
+    if (!resolved) {
+      throw new Error(
+        `DurableService.${apiMethod}() could not resolve task id "${taskRef}". Ensure the task is registered in the runtime store.`
+      );
+    }
+    return resolved;
+  }
 };
 var PollingManager = class {
   constructor(workerId, config, store2, queue, maxAttempts, defaultTimeout, taskRegistry, auditLogger, scheduleManager, callbacks) {
@@ -42664,16 +42683,26 @@ var DurableService = class {
     this.config = config;
     this.workerId = config.workerId ?? createExecutionId();
     this.taskRegistry = new TaskRegistry(config.taskResolver);
-    if (config.schedules) {
-      for (const schedule of config.schedules) {
-        this.taskRegistry.register(schedule.task);
-      }
-    }
     if (config.tasks) {
       for (const task2 of config.tasks) {
         this.taskRegistry.register(task2);
       }
     }
+    if (config.schedules) {
+      for (const schedule of config.schedules) {
+        if (typeof schedule.task === "string") {
+          const resolved = this.taskRegistry.find(schedule.task);
+          if (!resolved) {
+            throw new Error(
+              `Cannot initialize durable schedule "${schedule.id}": task "${schedule.task}" is not registered.`
+            );
+          }
+          this.taskRegistry.register(resolved);
+          continue;
+        }
+        this.taskRegistry.register(schedule.task);
+      }
+    }
     this.auditLogger = new AuditLogger(
       { enabled: config.audit?.enabled, emitter: config.audit?.emitter },
       config.store
@@ -42733,17 +42762,18 @@ var DurableService = class {
   findTask(taskId) {
     return this.taskRegistry.find(taskId);
   }
-  async startExecution(task2, input, options) {
-    return this.executionManager.startExecution(task2, input, options);
+  start(task2, input, options) {
+    if (task2 === void 0) {
+      this.pollingManager.start();
+      return;
+    }
+    return this.executionManager.start(task2, input, options);
   }
   async cancelExecution(executionId, reason) {
     await this.executionManager.cancelExecution(executionId, reason);
   }
-  async execute(task2, input, options) {
-    return this.executionManager.execute(task2, input, options);
-  }
-  async executeStrict(task2, input, options) {
-    return this.executionManager.executeStrict(task2, input, options);
+  async startAndWait(task2, input, options) {
+    return this.executionManager.startAndWait(task2, input, options);
   }
   wait(executionId, options) {
     return this.waitManager.waitForResult(executionId, options);
@@ -42762,9 +42792,6 @@ var DurableService = class {
       }
     }
   }
-  start() {
-    this.pollingManager.start();
-  }
   async stop() {
     await this.pollingManager.stop();
   }
@@ -42900,10 +42927,7 @@ async function createRunnerDurableRuntime(config, deps) {
     },
     taskExecutor: {
       run: /* @__PURE__ */ __name(async (task2, input) => {
-        const outputPromise = await deps.taskRunner.run(
-          task2,
-          input
-        );
+        const outputPromise = await deps.taskRunner.run(task2, input);
         if (outputPromise === void 0) {
           throw new Error(
             `Durable task '${task2.id}' completed without a result promise.`
@@ -42931,7 +42955,7 @@ async function createRunnerDurableRuntime(config, deps) {
 __name(createRunnerDurableRuntime, "createRunnerDurableRuntime");
 
 // src/node/durable/core/resource.ts
-var durableResource = r.resource("base.durable").register(durableEventsArray).dependencies({
+var durableResource = r.resource("base.durable").register([durableWorkflowTag, ...durableEventsArray]).dependencies({
   taskRunner: globals.resources.taskRunner,
   eventManager: globals.resources.eventManager,
   runnerStore: globals.resources.store
@@ -44073,7 +44097,7 @@ async function waitUntil(predicate, options) {
 __name(waitUntil, "waitUntil");
 
 // src/node/durable/resources/memoryDurableResource.ts
-var memoryDurableResource = r.resource("base.durable.memory").register(durableEventsArray).dependencies({
+var memoryDurableResource = r.resource("base.durable.memory").register([durableWorkflowTag, ...durableEventsArray]).dependencies({
   taskRunner: globals.resources.taskRunner,
   eventManager: globals.resources.eventManager,
   runnerStore: globals.resources.store
@@ -44132,7 +44156,7 @@ function deriveDurableIsolation(params) {
 __name(deriveDurableIsolation, "deriveDurableIsolation");
 
 // src/node/durable/resources/redisDurableResource.ts
-var redisDurableResource = r.resource("base.durable.redis").register(durableEventsArray).dependencies({
+var redisDurableResource = r.resource("base.durable.redis").register([durableWorkflowTag, ...durableEventsArray]).dependencies({
   taskRunner: globals.resources.taskRunner,
   eventManager: globals.resources.eventManager,
   runnerStore: globals.resources.store
@@ -44179,50 +44203,6 @@ var redisDurableResource = r.resource("base.durable.redis").register(durableEven
   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:
@@ -44510,6 +44490,6 @@ serve-static/index.js:
    *)
 */
 
-export { DependencyProcessor, DurableAuditEntryKind, DurableContext, DurableExecutionError, DurableOperator, DurableResource, DurableService, DurableWorker, errors_exports as Errors, EventManager, ExecutionStatus, LogPrinter, Logger, MemoryEventBus, MemoryQueue, MemoryStore, MiddlewareManager, NodeInputFile, NoopEventBus, PlatformAdapter, Queue, RabbitMQQueue, RedisEventBus, RedisStore, ResourceInitializer, RunResult, ScheduleStatus, ScheduleType, Semaphore, Serializer, StepBuilder, Store, SuspensionSignal, SymbolPolicy, SymbolPolicyErrorMessage, TaskRunner, TimerStatus, TimerType, allFalse, defineAsyncContext as asyncContext, bindProcessErrorHandler, createContext2 as createContext, createDashboardMiddleware, createDefaultUnhandledError, createDurableAuditEntryId, createDurableRunnerAuditEmitter, createDurableStepId, createDurableTestSetup, createExposureFetch, createHttpClient, createHttpMixedClient, createHttpSmartClient, createNodeFile, createRunnerDurableRuntime, createTestResource, debug, debugLevels, defs_exports as definitions, disposeDurableService, durableEvents, durableEventsArray, durableResource, defineEvent as event, getConfig, globals2 as globals, hasExposureContext, defineHook as hook, initDurableService, initDurableWorker, isDurableInternalStepId, journal, levelNormal, levelVerbose, memoryDurableResource, nodeExposure, normalizeError, defineOverride as override, r, readInputFileToBuffer, redisDurableResource, defineResource as resource, defineResourceMiddleware as resourceMiddleware, run2 as run, safeReportUnhandledError, setPlatform, defineTag as tag, defineTask as task, defineTaskMiddleware as taskMiddleware, useExposureContext, waitUntil, writeInputFileToPath };
+export { DurableAuditEntryKind, DurableContext, DurableExecutionError, DurableOperator, DurableResource, DurableService, DurableWorker, ExecutionStatus, MemoryEventBus, MemoryQueue, MemoryStore, NodeInputFile, NoopEventBus, RabbitMQQueue, RedisEventBus, RedisStore, ScheduleStatus, ScheduleType, StepBuilder, SuspensionSignal, TimerStatus, TimerType, createDashboardMiddleware, createDurableAuditEntryId, createDurableRunnerAuditEmitter, createDurableStepId, createDurableTestSetup, createHttpMixedClient, createHttpSmartClient, createNodeFile, createRunnerDurableRuntime, disposeDurableService, durableEvents, durableEventsArray, durableResource, durableWorkflowTag, globals, hasExposureContext, initDurableService, initDurableWorker, isDurableInternalStepId, memoryDurableResource, nodeExposure, readInputFileToBuffer, redisDurableResource, run, useExposureContext, waitUntil, writeInputFileToPath };
 //# sourceMappingURL=node.mjs.map
 //# sourceMappingURL=node.mjs.map