@bluelibs/runner 5.2.1 → 5.4.0

package/dist/edge/index.cjs

@@ -3,9 +3,6 @@
 var lruCache = require('lru-cache');
 
 var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
   get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
@@ -13,152 +10,10 @@ 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 __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))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-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/types/symbols.ts
 var symbolTask = Symbol.for("runner.task");
@@ -166,9 +21,7 @@ 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"
 );
@@ -198,227 +51,6 @@ var symbolAsyncContext = Symbol.for(
   "runner.asyncContext"
 );
 
-// src/tools/getCallerFile.ts
-function isNodeInline() {
-  return typeof process !== "undefined" && typeof process?.versions?.node === "string";
-}
-__name(isNodeInline, "isNodeInline");
-function getCallerFile() {
-  const originalPrepare = Error.prepareStackTrace;
-  try {
-    if (isNodeInline()) {
-      const err = new Error();
-      Error.prepareStackTrace = (_err, stack2) => stack2;
-      const stack = err.stack;
-      stack.shift();
-      stack.shift();
-      const candidate = stack.shift();
-      const file = candidate?.getFileName?.();
-      return file;
-    }
-    return "unknown";
-  } finally {
-    Error.prepareStackTrace = originalPrepare;
-  }
-}
-__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, {
@@ -431,7 +63,6 @@ __export(errors_exports, {
   eventCycleError: () => eventCycleError,
   eventEmissionCycleError: () => eventEmissionCycleError,
   eventNotFoundError: () => eventNotFoundError,
-  isCancellationError: () => isCancellationError,
   lockedError: () => lockedError,
   middlewareNotRegisteredError: () => middlewareNotRegisteredError,
   phantomTaskNotRoutedError: () => phantomTaskNotRoutedError,
@@ -445,13 +76,52 @@ __export(errors_exports, {
   validationError: () => validationError
 });
 
+// src/tools/getCallerFile.ts
+function isNodeInline() {
+  return typeof process !== "undefined" && typeof process?.versions?.node === "string";
+}
+__name(isNodeInline, "isNodeInline");
+function getCallerFile() {
+  const originalPrepare = Error.prepareStackTrace;
+  try {
+    if (isNodeInline()) {
+      const err = new Error();
+      Error.prepareStackTrace = (_err, stack2) => stack2;
+      const stack = err.stack;
+      stack.shift();
+      stack.shift();
+      const candidate = stack.shift();
+      const file = candidate?.getFileName?.();
+      return file;
+    }
+    return "unknown";
+  } finally {
+    Error.prepareStackTrace = originalPrepare;
+  }
+}
+__name(getCallerFile, "getCallerFile");
+
 // 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");
@@ -471,10 +141,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;
@@ -487,6 +167,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)}`;
   }
@@ -508,9 +191,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);
@@ -527,6 +223,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);
@@ -535,10 +235,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
@@ -555,6 +257,7 @@ function errorBuilder(id2) {
   const initial = Object.freeze({
     id: id2,
     filePath,
+    httpCode: void 0,
     serialize: void 0,
     parse: void 0,
     dataSchema: void 0,
@@ -563,7 +266,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() {
@@ -729,20 +438,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;
   }
@@ -751,6 +507,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) {
@@ -805,9 +578,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({
@@ -865,6 +643,10 @@ var UniversalPlatformAdapter = class {
     if (this.inner) return;
     const kind = detectEnvironment();
     const global = globalThis;
+    if (typeof global.Deno !== "undefined") {
+      this.inner = new GenericUniversalPlatformAdapter();
+      return;
+    }
     if (typeof global.document !== "undefined" || typeof global.addEventListener === "function") {
       this.inner = new BrowserPlatformAdapter();
     } else {
@@ -994,9 +776,13 @@ var PlatformAdapter = class {
 // 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"
@@ -1004,10 +790,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"));
@@ -1020,36 +810,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(
   "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 errorMessage = originalError instanceof Error ? originalError.message : String(originalError);
   return `${subject} validation failed for ${id2.toString()}: ${errorMessage}`;
+}).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 }) => {
   const chain = path.map((p) => `${p.id}\u2190${p.source}`).join("  ->  ");
@@ -1057,37 +865,245 @@ var eventCycleError = error("runner.errors.eventCycle").format(({ path }) => {
   ${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/defs.ts
+var defs_exports = {};
+__export(defs_exports, {
+  CONTRACT: () => CONTRACT,
+  HookDependencyState: () => HookDependencyState,
+  RunnerMode: () => RunnerMode,
+  isOneOf: () => isOneOf,
+  onAnyOf: () => onAnyOf,
+  symbolAsyncContext: () => symbolAsyncContext,
+  symbolError: () => symbolError,
+  symbolEvent: () => symbolEvent,
+  symbolFilePath: () => symbolFilePath,
+  symbolForkedFrom: () => symbolForkedFrom,
+  symbolHook: () => symbolHook,
+  symbolMiddleware: () => symbolMiddleware,
+  symbolMiddlewareConfigured: () => symbolMiddlewareConfigured,
+  symbolOptionalDependency: () => symbolOptionalDependency,
+  symbolPhantomTask: () => symbolPhantomTask,
+  symbolResource: () => symbolResource,
+  symbolResourceMiddleware: () => symbolResourceMiddleware,
+  symbolResourceWithConfig: () => symbolResourceWithConfig,
+  symbolTag: () => symbolTag,
+  symbolTagConfigured: () => symbolTagConfigured,
+  symbolTask: () => symbolTask,
+  symbolTaskMiddleware: () => symbolTaskMiddleware,
+  symbolTunneledBy: () => symbolTunneledBy
+});
+
+// src/types/event.ts
+function onAnyOf(...defs) {
+  return defs;
+}
+__name(onAnyOf, "onAnyOf");
+function isOneOf(emission, defs) {
+  return defs.some((d) => d.id === emission.id);
+}
+__name(isOneOf, "isOneOf");
+
+// src/types/runner.ts
+var RunnerMode = /* @__PURE__ */ ((RunnerMode2) => {
+  RunnerMode2["TEST"] = "test";
+  RunnerMode2["DEV"] = "dev";
+  RunnerMode2["PROD"] = "prod";
+  return RunnerMode2;
+})(RunnerMode || {});
+
+// src/types/contracts.ts
+var CONTRACT = Symbol.for("runner.contract");
+
+// src/types/storeTypes.ts
+var HookDependencyState = /* @__PURE__ */ ((HookDependencyState2) => {
+  HookDependencyState2["Pending"] = "pending";
+  HookDependencyState2["Computing"] = "computing";
+  HookDependencyState2["Ready"] = "ready";
+  return HookDependencyState2;
+})(HookDependencyState || {});
+
+// src/definers/tools.ts
+function isTask(definition) {
+  return definition && definition[symbolTask];
+}
+__name(isTask, "isTask");
+function isResource(definition) {
+  return definition && definition[symbolResource];
+}
+__name(isResource, "isResource");
+function isResourceWithConfig(definition) {
+  return definition && definition[symbolResourceWithConfig];
+}
+__name(isResourceWithConfig, "isResourceWithConfig");
+function isEvent(definition) {
+  return definition && definition[symbolEvent];
+}
+__name(isEvent, "isEvent");
+function isHook(definition) {
+  return definition && definition[symbolHook];
+}
+__name(isHook, "isHook");
+function isTaskMiddleware(definition) {
+  return definition && definition[symbolTaskMiddleware];
+}
+__name(isTaskMiddleware, "isTaskMiddleware");
+function isResourceMiddleware(definition) {
+  return definition && definition[symbolResourceMiddleware];
+}
+__name(isResourceMiddleware, "isResourceMiddleware");
+function isTag(definition) {
+  return definition && definition[symbolTag];
+}
+__name(isTag, "isTag");
+function isOptional(definition) {
+  return definition && definition[symbolOptionalDependency];
+}
+__name(isOptional, "isOptional");
+function isError(definition) {
+  return Boolean(definition && definition[symbolError]);
 }
-__name(isCancellationError, "isCancellationError");
+__name(isError, "isError");
+function isAsyncContext(definition) {
+  return Boolean(definition && definition[symbolAsyncContext]);
+}
+__name(isAsyncContext, "isAsyncContext");
+
+// src/tools/throws.ts
+function invalidThrowsEntryError(owner, item) {
+  const got = item === null ? "null" : Array.isArray(item) ? "array" : typeof item === "object" ? "object" : typeof item;
+  return new Error(
+    `Invalid throws entry for ${owner.kind} ${owner.id}: expected error id string or Error helper, got ${got}`
+  );
+}
+__name(invalidThrowsEntryError, "invalidThrowsEntryError");
+function toErrorIdList(owner, list) {
+  const ids = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const item of list) {
+    let id2;
+    if (typeof item === "string") {
+      if (item.trim().length === 0) {
+        throw invalidThrowsEntryError(owner, item);
+      }
+      id2 = item;
+    } else if (isError(item)) {
+      id2 = item.id;
+      if (typeof id2 !== "string" || id2.trim().length === 0) {
+        throw invalidThrowsEntryError(owner, item);
+      }
+    } else {
+      throw invalidThrowsEntryError(owner, item);
+    }
+    if (seen.has(id2)) continue;
+    seen.add(id2);
+    ids.push(id2);
+  }
+  return ids;
+}
+__name(toErrorIdList, "toErrorIdList");
+function normalizeThrows(owner, throwsList) {
+  if (throwsList === void 0) return void 0;
+  return toErrorIdList(owner, throwsList);
+}
+__name(normalizeThrows, "normalizeThrows");
+
+// src/definers/defineTask.ts
+function defineTask(taskConfig) {
+  const filePath = getCallerFile();
+  const id2 = taskConfig.id;
+  return {
+    [symbolTask]: true,
+    [symbolFilePath]: filePath,
+    id: id2,
+    dependencies: taskConfig.dependencies || {},
+    middleware: taskConfig.middleware || [],
+    run: taskConfig.run,
+    inputSchema: taskConfig.inputSchema,
+    resultSchema: taskConfig.resultSchema,
+    meta: taskConfig.meta || {},
+    tags: taskConfig.tags || [],
+    throws: normalizeThrows({ kind: "task", id: id2 }, taskConfig.throws),
+    // autorun,
+    optional() {
+      return {
+        inner: this,
+        [symbolOptionalDependency]: true
+      };
+    }
+  };
+}
+__name(defineTask, "defineTask");
+defineTask.phantom = (taskConfig) => {
+  const taskDef = defineTask({
+    ...taskConfig,
+    run: /* @__PURE__ */ __name(async (_input) => {
+      phantomTaskNotRoutedError.throw({ taskId: taskConfig.id });
+    }, "run")
+  });
+  taskDef[symbolPhantomTask] = true;
+  return taskDef;
+};
+
+// src/definers/defineHook.ts
+function defineHook(hookDef) {
+  const filePath = getCallerFile();
+  return {
+    [symbolHook]: true,
+    [symbolFilePath]: filePath,
+    id: hookDef.id,
+    dependencies: hookDef.dependencies || {},
+    on: hookDef.on,
+    order: hookDef.order,
+    run: hookDef.run,
+    meta: hookDef.meta || {},
+    tags: hookDef.tags || []
+  };
+}
+__name(defineHook, "defineHook");
 
 // src/definers/resourceFork.ts
 function resolveReId(forkId, options) {
@@ -1317,6 +1333,7 @@ function defineResource(constConfig) {
       };
     },
     fork(newId, options) {
+      const forkCallerFilePath = getCallerFile();
       const forkedParts = resolveForkedRegisterAndDependencies({
         register: constConfig.register,
         dependencies: constConfig.dependencies,
@@ -1328,11 +1345,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;
     }
@@ -1563,7 +1579,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(
@@ -2095,8 +2111,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();
@@ -2855,29 +2987,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);
@@ -3207,7 +3335,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",
@@ -3237,7 +3365,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;
@@ -3288,11 +3416,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({
@@ -3305,7 +3433,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;
@@ -3885,12 +4013,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) {
@@ -4163,7 +4291,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;
@@ -4242,14 +4370,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",
@@ -4261,7 +4391,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) {
@@ -4309,7 +4439,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;
@@ -4346,7 +4476,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;
@@ -4418,12 +4548,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() {
@@ -4582,6 +4712,7 @@ var TunnelError = class extends Error {
     this.name = "TunnelError";
     this.code = code;
     this.details = details;
+    this.httpCode = extras?.httpCode;
     this.id = extras?.id;
     this.data = extras?.data;
   }
@@ -4596,6 +4727,7 @@ function toTunnelError(input, fallbackMessage) {
       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
       });
@@ -4787,7 +4919,7 @@ function createExposureFetch(cfg) {
 }
 __name(createExposureFetch, "createExposureFetch");
 
-// src/tunnels/buildUniversalManifest.ts
+// src/tools/buildUniversalManifest.ts
 function buildUniversalManifest(input) {
   const nodeFiles = [];
   const webFiles = [];
@@ -4844,6 +4976,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");
@@ -4910,12 +5051,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) {
@@ -4926,24 +5062,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) {
@@ -4955,12 +5081,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);
       }
     }
   };
@@ -5243,13 +5364,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
   },
@@ -5892,6 +6015,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) {
@@ -5999,7 +6150,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).
@@ -6142,46 +6302,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
@@ -6378,19 +6527,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 {
@@ -6399,6 +6775,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);
@@ -6535,195 +6923,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;
@@ -7657,6 +7864,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) {
@@ -7721,6 +7985,7 @@ var Store = class {
   }
   lock() {
     this.#isLocked = true;
+    this.registry.lockAll();
   }
   checkLock() {
     if (this.#isLocked) {
@@ -7862,58 +8127,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.
@@ -7929,21 +8143,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);
   }
 };
 
@@ -8206,7 +8410,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;
@@ -8544,6 +8748,16 @@ function buildTestFacade(deps) {
 }
 __name(buildTestFacade, "buildTestFacade");
 
+// src/definers/builders/shared/mergeUtils.ts
+function mergeArray(existing, addition, override2) {
+  const toArray = [...addition];
+  if (override2 || !existing) {
+    return toArray;
+  }
+  return [...existing, ...toArray];
+}
+__name(mergeArray, "mergeArray");
+
 // src/definers/builders/resource/utils.ts
 function clone2(s, patch) {
   return Object.freeze({
@@ -8588,14 +8802,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";
@@ -8759,14 +8965,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";
@@ -8822,14 +9020,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);
     },
@@ -8905,14 +9103,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
@@ -9001,14 +9199,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) {
@@ -9023,7 +9213,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);
     },
@@ -9071,14 +9261,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";
@@ -9152,7 +9334,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);
     },
@@ -9229,14 +9411,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";
@@ -9317,7 +9491,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);
     },
@@ -9389,7 +9563,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);
     },
@@ -9600,7 +9774,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);
     },
@@ -9805,7 +9979,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);
     },
@@ -9865,14 +10039,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);
     },
@@ -9981,7 +10155,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);
     },
@@ -10060,6 +10234,7 @@ var r = Object.freeze({
 exports.DependencyProcessor = DependencyProcessor;
 exports.Errors = errors_exports;
 exports.EventManager = EventManager;
+exports.LockableMap = LockableMap;
 exports.LogPrinter = LogPrinter;
 exports.Logger = Logger;
 exports.MiddlewareManager = MiddlewareManager;
@@ -10067,6 +10242,7 @@ exports.PlatformAdapter = PlatformAdapter;
 exports.Queue = Queue;
 exports.ResourceInitializer = ResourceInitializer;
 exports.RunResult = RunResult;
+exports.RunnerError = RunnerError;
 exports.Semaphore = Semaphore;
 exports.Serializer = Serializer;
 exports.Store = Store;
@@ -10076,6 +10252,7 @@ exports.TaskRunner = TaskRunner;
 exports.allFalse = allFalse;
 exports.asyncContext = defineAsyncContext;
 exports.bindProcessErrorHandler = bindProcessErrorHandler;
+exports.cancellationError = cancellationError;
 exports.createContext = createContext2;
 exports.createDefaultUnhandledError = createDefaultUnhandledError;
 exports.createExposureFetch = createExposureFetch;