@bluelibs/runner 5.2.1 → 5.4.0

package/dist/edge/index.mjs

@@ -1,9 +1,6 @@
 import { LRUCache } from '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]
@@ -11,152 +8,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");
@@ -164,9 +19,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"
 );
@@ -196,227 +49,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, {
@@ -429,7 +61,6 @@ __export(errors_exports, {
   eventCycleError: () => eventCycleError,
   eventEmissionCycleError: () => eventEmissionCycleError,
   eventNotFoundError: () => eventNotFoundError,
-  isCancellationError: () => isCancellationError,
   lockedError: () => lockedError,
   middlewareNotRegisteredError: () => middlewareNotRegisteredError,
   phantomTaskNotRoutedError: () => phantomTaskNotRoutedError,
@@ -443,13 +74,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");
@@ -469,10 +139,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;
@@ -485,6 +165,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)}`;
   }
@@ -506,9 +189,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);
@@ -525,6 +221,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);
@@ -533,10 +233,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
@@ -553,6 +255,7 @@ function errorBuilder(id2) {
   const initial = Object.freeze({
     id: id2,
     filePath,
+    httpCode: void 0,
     serialize: void 0,
     parse: void 0,
     dataSchema: void 0,
@@ -561,7 +264,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() {
@@ -727,20 +436,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;
   }
@@ -749,6 +505,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) {
@@ -803,9 +576,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({
@@ -863,6 +641,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 {
@@ -992,9 +774,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"
@@ -1002,10 +788,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"));
@@ -1018,36 +808,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("  ->  ");
@@ -1055,37 +863,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) {
@@ -1315,6 +1331,7 @@ function defineResource(constConfig) {
       };
     },
     fork(newId, options) {
+      const forkCallerFilePath = getCallerFile();
       const forkedParts = resolveForkedRegisterAndDependencies({
         register: constConfig.register,
         dependencies: constConfig.dependencies,
@@ -1326,11 +1343,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;
     }
@@ -1561,7 +1577,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(
@@ -2093,8 +2109,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();
@@ -2853,29 +2985,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);
@@ -3205,7 +3333,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",
@@ -3235,7 +3363,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;
@@ -3286,11 +3414,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({
@@ -3303,7 +3431,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;
@@ -3883,12 +4011,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) {
@@ -4161,7 +4289,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;
@@ -4240,14 +4368,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",
@@ -4259,7 +4389,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) {
@@ -4307,7 +4437,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;
@@ -4344,7 +4474,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;
@@ -4416,12 +4546,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() {
@@ -4580,6 +4710,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;
   }
@@ -4594,6 +4725,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
       });
@@ -4785,7 +4917,7 @@ function createExposureFetch(cfg) {
 }
 __name(createExposureFetch, "createExposureFetch");
 
-// src/tunnels/buildUniversalManifest.ts
+// src/tools/buildUniversalManifest.ts
 function buildUniversalManifest(input) {
   const nodeFiles = [];
   const webFiles = [];
@@ -4842,6 +4974,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");
@@ -4908,12 +5049,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) {
@@ -4924,24 +5060,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) {
@@ -4953,12 +5079,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);
       }
     }
   };
@@ -5241,13 +5362,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
   },
@@ -5890,6 +6013,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) {
@@ -5997,7 +6148,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).
@@ -6140,46 +6300,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
@@ -6376,19 +6525,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 {
@@ -6397,6 +6773,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);
@@ -6533,195 +6921,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;
@@ -7655,6 +7862,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) {
@@ -7719,6 +7983,7 @@ var Store = class {
   }
   lock() {
     this.#isLocked = true;
+    this.registry.lockAll();
   }
   checkLock() {
     if (this.#isLocked) {
@@ -7860,58 +8125,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.
@@ -7927,21 +8141,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);
   }
 };
 
@@ -8204,7 +8408,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;
@@ -8542,6 +8746,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({
@@ -8586,14 +8800,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";
@@ -8757,14 +8963,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";
@@ -8820,14 +9018,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);
     },
@@ -8903,14 +9101,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
@@ -8999,14 +9197,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) {
@@ -9021,7 +9211,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);
     },
@@ -9069,14 +9259,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";
@@ -9150,7 +9332,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);
     },
@@ -9227,14 +9409,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";
@@ -9315,7 +9489,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);
     },
@@ -9387,7 +9561,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);
     },
@@ -9598,7 +9772,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);
     },
@@ -9803,7 +9977,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);
     },
@@ -9863,14 +10037,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);
     },
@@ -9979,7 +10153,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);
     },
@@ -10055,6 +10229,6 @@ var r = Object.freeze({
   })
 });
 
-export { DependencyProcessor, errors_exports as Errors, EventManager, LogPrinter, Logger, MiddlewareManager, PlatformAdapter, Queue, ResourceInitializer, RunResult, Semaphore, Serializer, Store, SymbolPolicy, SymbolPolicyErrorMessage, TaskRunner, allFalse, defineAsyncContext as asyncContext, bindProcessErrorHandler, createContext2 as createContext, createDefaultUnhandledError, createExposureFetch, createHttpClient, createTestResource, debug, debugLevels, defs_exports as definitions, defineEvent as event, getConfig, globals, defineHook as hook, journal, levelNormal, levelVerbose, normalizeError, defineOverride as override, r, defineResource as resource, defineResourceMiddleware as resourceMiddleware, run, safeReportUnhandledError, setPlatform, defineTag as tag, defineTask as task, defineTaskMiddleware as taskMiddleware };
+export { DependencyProcessor, errors_exports as Errors, EventManager, LockableMap, LogPrinter, Logger, MiddlewareManager, PlatformAdapter, Queue, ResourceInitializer, RunResult, RunnerError, Semaphore, Serializer, Store, SymbolPolicy, SymbolPolicyErrorMessage, TaskRunner, allFalse, defineAsyncContext as asyncContext, bindProcessErrorHandler, cancellationError, createContext2 as createContext, createDefaultUnhandledError, createExposureFetch, createHttpClient, createTestResource, debug, debugLevels, defs_exports as definitions, defineEvent as event, getConfig, globals, defineHook as hook, journal, levelNormal, levelVerbose, normalizeError, defineOverride as override, r, defineResource as resource, defineResourceMiddleware as resourceMiddleware, run, safeReportUnhandledError, setPlatform, defineTag as tag, defineTask as task, defineTaskMiddleware as taskMiddleware };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map