@bluelibs/runner 5.1.0 → 5.2.1

package/dist/edge/index.cjs

@@ -198,88 +198,227 @@ var symbolAsyncContext = Symbol.for(
   "runner.asyncContext"
 );
 
-// src/platform/adapters/node-als.ts
-async function loadAsyncLocalStorageClass() {
-  const mod = __require("async_hooks");
-  return mod.AsyncLocalStorage;
+// src/tools/getCallerFile.ts
+function isNodeInline() {
+  return typeof process !== "undefined" && typeof process?.versions?.node === "string";
 }
-__name(loadAsyncLocalStorageClass, "loadAsyncLocalStorageClass");
-
-// src/platform/adapters/node.ts
-var NodePlatformAdapter = class {
-  constructor() {
-    this.id = "node";
-    this.setTimeout = globalThis.setTimeout;
-    this.clearTimeout = globalThis.clearTimeout;
-  }
-  static {
-    __name(this, "NodePlatformAdapter");
-  }
-  async init() {
-    this.alsClass = await loadAsyncLocalStorageClass();
-  }
-  onUncaughtException(handler) {
-    const h = /* @__PURE__ */ __name((error2) => handler(error2), "h");
-    process.on("uncaughtException", h);
-    return () => process.off("uncaughtException", h);
-  }
-  onUnhandledRejection(handler) {
-    const h = /* @__PURE__ */ __name((reason) => handler(reason), "h");
-    process.on("unhandledRejection", h);
-    return () => process.off("unhandledRejection", h);
-  }
-  onShutdownSignal(handler) {
-    process.on("SIGINT", handler);
-    process.on("SIGTERM", handler);
-    return () => {
-      process.off("SIGINT", handler);
-      process.off("SIGTERM", handler);
-    };
-  }
-  exit(code) {
-    process.exit(code);
-  }
-  getEnv(key) {
-    return process.env[key];
-  }
-  hasAsyncLocalStorage() {
-    return true;
+__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;
   }
-  createAsyncLocalStorage() {
-    let instance;
-    const ensure = /* @__PURE__ */ __name(() => {
-      if (!this.alsClass) {
-        let als;
-        const forceNoop = typeof process !== "undefined" && !!process.env?.RUNNER_FORCE_NOOP_ALS;
-        if (!forceNoop) {
-          try {
-            const mod = __require("async_hooks");
-            als = mod?.AsyncLocalStorage;
-          } catch (_) {
-            als = void 0;
-          }
-        }
-        this.alsClass = als || class NoopAsyncLocalStorage {
-          static {
-            __name(this, "NoopAsyncLocalStorage");
-          }
-          getStore() {
-            return void 0;
-          }
-          run(_store, callback) {
-            return callback();
-          }
-        };
+}
+__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);
       }
-      return instance ??= new this.alsClass();
-    }, "ensure");
-    return {
-      getStore: /* @__PURE__ */ __name(() => ensure().getStore(), "getStore"),
-      run: /* @__PURE__ */ __name((store2, callback) => ensure().run(store2, callback), "run")
-    };
+      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, {
@@ -321,9 +460,10 @@ var RunnerError = class extends Error {
 var _a;
 _a = symbolError;
 var ErrorHelper = class {
-  constructor(definition) {
+  constructor(definition, filePath) {
     this.definition = definition;
     this[_a] = true;
+    this[symbolFilePath] = filePath;
   }
   static {
     __name(this, "ErrorHelper");
@@ -346,11 +486,15 @@ var ErrorHelper = class {
     };
   }
 };
-function defineError(definition) {
+function defineError(definition, filePath) {
   if (!definition.format) {
     definition.format = (data) => `${JSON.stringify(data)}`;
   }
-  return new ErrorHelper(definition);
+  const resolvedFilePath = filePath ?? getCallerFile();
+  return new ErrorHelper(
+    definition,
+    resolvedFilePath
+  );
 }
 __name(defineError, "defineError");
 
@@ -388,14 +532,17 @@ function makeErrorBuilder(state) {
       return makeErrorBuilder(next);
     },
     build() {
-      return defineError({
-        id: state.id,
-        serialize: state.serialize,
-        parse: state.parse,
-        dataSchema: state.dataSchema,
-        format: state.format,
-        meta: state.meta
-      });
+      return defineError(
+        {
+          id: state.id,
+          serialize: state.serialize,
+          parse: state.parse,
+          dataSchema: state.dataSchema,
+          format: state.format,
+          meta: state.meta
+        },
+        state.filePath
+      );
     }
   };
   return builder;
@@ -404,8 +551,10 @@ __name(makeErrorBuilder, "makeErrorBuilder");
 
 // src/definers/builders/error/index.ts
 function errorBuilder(id2) {
+  const filePath = getCallerFile();
   const initial = Object.freeze({
     id: id2,
+    filePath,
     serialize: void 0,
     parse: void 0,
     dataSchema: void 0,
@@ -416,103 +565,87 @@ function errorBuilder(id2) {
 __name(errorBuilder, "errorBuilder");
 var error = errorBuilder;
 
-// 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.`
-).build();
-var dependencyNotFoundError = error("runner.errors.dependencyNotFound").format(
-  ({ key }) => `Dependency ${key.toString()} not found. Did you forget to register it through a resource?`
-).build();
-var unknownItemTypeError = error(
-  "runner.errors.unknownItemType"
-).format(
-  ({ item }) => `Unknown item type: ${String(
-    item
-  )}. Please ensure you are not using different versions of '@bluelibs/runner'`
-).build();
-var contextError = error(
-  "runner.errors.context"
-).format(({ details }) => details ?? "Context error").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"));
-  let guidance = "\n\nTo resolve circular dependencies:";
-  guidance += "\n  \u2022 Consider refactoring to reduce coupling between components";
-  guidance += "\n  \u2022 Extract shared dependencies into separate resources";
-  if (hasMiddleware) {
-    guidance += "\n  \u2022 For middleware: you can filter out tasks/resources using everywhere(fn)";
-    guidance += "\n  \u2022 Consider using events for communication instead of direct dependencies";
-  }
-  return `Circular dependencies detected:
-${cycleDetails}${guidance}`;
-}).build();
-var eventNotFoundError = error(
-  "runner.errors.eventNotFound"
-).format(
-  ({ id: id2 }) => `Event "${id2.toString()}" not found. Did you forget to register it?`
-).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?`
-).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?`
-).build();
-var tagNotFoundError = error(
-  "runner.errors.tagNotFound"
-).format(
-  ({ id: id2 }) => `Tag "${id2}" not registered. Did you forget to register it inside a resource?`
-).build();
-var lockedError = error(
-  "runner.errors.locked"
-).format(
-  ({ what }) => `Cannot modify the ${what.toString()} when it is locked.`
-).build();
-var storeAlreadyInitializedError = error(
-  "runner.errors.storeAlreadyInitialized"
-).format(() => "Store already initialized. Cannot reinitialize.").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}`;
-}).build();
-var eventCycleError = error("runner.errors.eventCycle").format(({ path }) => {
-  const chain = path.map((p) => `${p.id}\u2190${p.source}`).join("  ->  ");
-  return `Event emission cycle detected:
-  ${chain}
-
-Break the cycle by changing hook logic (avoid mutual emits) or gate with conditions/tags.`;
-}).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();
-var platformUnsupportedFunctionError = error("runner.errors.platformUnsupportedFunction").format(
-  ({ functionName }) => `Platform function not supported in this environment: ${functionName}. Detected platform: ${detectEnvironment()}.`
-).build();
-var cancellationError = error(
-  "runner.errors.cancellation"
-).format(({ reason }) => reason || "Operation cancelled").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.`
-).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).`
-).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.`
-).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);
+// src/platform/adapters/node-als.ts
+async function loadAsyncLocalStorageClass() {
+  const mod = __require("async_hooks");
+  return mod.AsyncLocalStorage;
 }
-__name(isCancellationError, "isCancellationError");
+__name(loadAsyncLocalStorageClass, "loadAsyncLocalStorageClass");
+
+// src/platform/adapters/node.ts
+var NodePlatformAdapter = class {
+  constructor() {
+    this.id = "node";
+    this.setTimeout = globalThis.setTimeout;
+    this.clearTimeout = globalThis.clearTimeout;
+  }
+  static {
+    __name(this, "NodePlatformAdapter");
+  }
+  async init() {
+    this.alsClass = await loadAsyncLocalStorageClass();
+  }
+  onUncaughtException(handler) {
+    const h = /* @__PURE__ */ __name((error2) => handler(error2), "h");
+    process.on("uncaughtException", h);
+    return () => process.off("uncaughtException", h);
+  }
+  onUnhandledRejection(handler) {
+    const h = /* @__PURE__ */ __name((reason) => handler(reason), "h");
+    process.on("unhandledRejection", h);
+    return () => process.off("unhandledRejection", h);
+  }
+  onShutdownSignal(handler) {
+    process.on("SIGINT", handler);
+    process.on("SIGTERM", handler);
+    return () => {
+      process.off("SIGINT", handler);
+      process.off("SIGTERM", handler);
+    };
+  }
+  exit(code) {
+    process.exit(code);
+  }
+  getEnv(key) {
+    return process.env[key];
+  }
+  hasAsyncLocalStorage() {
+    return true;
+  }
+  createAsyncLocalStorage() {
+    let instance;
+    const ensure = /* @__PURE__ */ __name(() => {
+      if (!this.alsClass) {
+        let als;
+        const forceNoop = typeof process !== "undefined" && !!process.env?.RUNNER_FORCE_NOOP_ALS;
+        if (!forceNoop) {
+          try {
+            const mod = __require("async_hooks");
+            als = mod?.AsyncLocalStorage;
+          } catch (_) {
+            als = void 0;
+          }
+        }
+        this.alsClass = als || class NoopAsyncLocalStorage {
+          static {
+            __name(this, "NoopAsyncLocalStorage");
+          }
+          getStore() {
+            return void 0;
+          }
+          run(_store, callback) {
+            return callback();
+          }
+        };
+      }
+      return instance ??= new this.alsClass();
+    }, "ensure");
+    return {
+      getStore: /* @__PURE__ */ __name(() => ensure().getStore(), "getStore"),
+      run: /* @__PURE__ */ __name((store2, callback) => ensure().run(store2, callback), "run")
+    };
+  }
+};
 
 // src/platform/adapters/browser.ts
 var BrowserPlatformAdapter = class {
@@ -805,16 +938,11 @@ function setPlatform(adapter) {
   adapter.id;
 }
 __name(setPlatform, "setPlatform");
-function isNode() {
-  {
-    return false;
-  }
-}
-__name(isNode, "isNode");
 var PlatformAdapter = class {
+  static {
+    __name(this, "PlatformAdapter");
+  }
   constructor(env) {
-    this.setTimeout = globalThis.setTimeout;
-    this.clearTimeout = globalThis.clearTimeout;
     const kind = env ?? detectEnvironment();
     this.env = kind;
     switch (kind) {
@@ -834,9 +962,8 @@ var PlatformAdapter = class {
         this.inner = new UniversalPlatformAdapter();
     }
     this.id = this.inner.id;
-  }
-  static {
-    __name(this, "PlatformAdapter");
+    this.setTimeout = this.inner.setTimeout;
+    this.clearTimeout = this.inner.clearTimeout;
   }
   async init() {
     return this.inner.init();
@@ -864,209 +991,103 @@ var PlatformAdapter = class {
   }
 };
 
-// src/tools/getCallerFile.ts
-function getCallerFile() {
-  const originalPrepare = Error.prepareStackTrace;
-  try {
-    if (isNode()) {
-      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, {
-  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/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);
+// 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.`
+).build();
+var dependencyNotFoundError = error("runner.errors.dependencyNotFound").format(
+  ({ key }) => `Dependency ${key.toString()} not found. Did you forget to register it through a resource?`
+).build();
+var unknownItemTypeError = error(
+  "runner.errors.unknownItemType"
+).format(
+  ({ item }) => `Unknown item type: ${String(
+    item
+  )}. Please ensure you are not using different versions of '@bluelibs/runner'`
+).build();
+var contextError = error(
+  "runner.errors.context"
+).format(({ details }) => details ?? "Context error").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"));
+  let guidance = "\n\nTo resolve circular dependencies:";
+  guidance += "\n  \u2022 Consider refactoring to reduce coupling between components";
+  guidance += "\n  \u2022 Extract shared dependencies into separate resources";
+  if (hasMiddleware) {
+    guidance += "\n  \u2022 For middleware: you can filter out tasks/resources using everywhere(fn)";
+    guidance += "\n  \u2022 Consider using events for communication instead of direct dependencies";
   }
-  return ids;
-}
-__name(toErrorIdList, "toErrorIdList");
-function normalizeThrows(owner, throwsList) {
-  if (throwsList === void 0) return void 0;
-  return toErrorIdList(owner, throwsList);
-}
-__name(normalizeThrows, "normalizeThrows");
+  return `Circular dependencies detected:
+${cycleDetails}${guidance}`;
+}).build();
+var eventNotFoundError = error(
+  "runner.errors.eventNotFound"
+).format(
+  ({ id: id2 }) => `Event "${id2.toString()}" not found. Did you forget to register it?`
+).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?`
+).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?`
+).build();
+var tagNotFoundError = error(
+  "runner.errors.tagNotFound"
+).format(
+  ({ id: id2 }) => `Tag "${id2}" not registered. Did you forget to register it inside a resource?`
+).build();
+var lockedError = error(
+  "runner.errors.locked"
+).format(
+  ({ what }) => `Cannot modify the ${what.toString()} when it is locked.`
+).build();
+var storeAlreadyInitializedError = error(
+  "runner.errors.storeAlreadyInitialized"
+).format(() => "Store already initialized. Cannot reinitialize.").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}`;
+}).build();
+var eventCycleError = error("runner.errors.eventCycle").format(({ path }) => {
+  const chain = path.map((p) => `${p.id}\u2190${p.source}`).join("  ->  ");
+  return `Event emission cycle detected:
+  ${chain}
 
-// 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;
-};
+Break the cycle by changing hook logic (avoid mutual emits) or gate with conditions/tags.`;
+}).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}
 
-// 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 || []
-  };
+This was detected at compile time (dry-run). Break the cycle by avoiding mutual emits between hooks or scoping hooks using tags.`;
+}).build();
+var platformUnsupportedFunctionError = error("runner.errors.platformUnsupportedFunction").format(
+  ({ functionName }) => `Platform function not supported in this environment: ${functionName}. Detected platform: ${detectEnvironment()}.`
+).build();
+var cancellationError = error(
+  "runner.errors.cancellation"
+).format(({ reason }) => reason || "Operation cancelled").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.`
+).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).`
+).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.`
+).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);
 }
-__name(defineHook, "defineHook");
+__name(isCancellationError, "isCancellationError");
 
 // src/definers/resourceFork.ts
 function resolveReId(forkId, options) {
@@ -1441,7 +1462,7 @@ function defineOverride(base, patch) {
     ...patch,
     id: base.id
   };
-  if (base.on !== void 0) {
+  if ("on" in base && base.on !== void 0) {
     overridden.on = base.on;
   }
   return overridden;
@@ -1561,6 +1582,309 @@ var SymbolPolicy = /* @__PURE__ */ ((SymbolPolicy2) => {
   SymbolPolicy2["Disabled"] = "Disabled";
   return SymbolPolicy2;
 })(SymbolPolicy || {});
+var SymbolPolicyErrorMessage = /* @__PURE__ */ ((SymbolPolicyErrorMessage2) => {
+  SymbolPolicyErrorMessage2["GlobalSymbolsNotAllowed"] = "Global symbols are not allowed";
+  SymbolPolicyErrorMessage2["SymbolsNotAllowed"] = "Symbols are not allowed";
+  SymbolPolicyErrorMessage2["UnsupportedSymbolPolicy"] = "Unsupported symbol policy";
+  return SymbolPolicyErrorMessage2;
+})(SymbolPolicyErrorMessage || {});
+
+// src/serializer/binary-builtins.ts
+var INVALID_PAYLOAD_MESSAGE_PREFIX = "Invalid";
+var typedArrayTypeIds = [
+  "Int8Array",
+  "Uint8Array",
+  "Uint8ClampedArray",
+  "Int16Array",
+  "Uint16Array",
+  "Int32Array",
+  "Uint32Array",
+  "Float32Array",
+  "Float64Array",
+  "BigInt64Array",
+  "BigUint64Array"
+];
+var getTypedArrayConstructor = /* @__PURE__ */ __name((typeId) => {
+  const value = globalThis[typeId];
+  if (typeof value !== "function") {
+    return null;
+  }
+  return value;
+}, "getTypedArrayConstructor");
+var getRuntimeBufferConstructor = /* @__PURE__ */ __name(() => {
+  const value = globalThis.Buffer;
+  if (typeof value !== "function") {
+    return null;
+  }
+  const valueRecord = value;
+  if (typeof valueRecord.from !== "function" || typeof valueRecord.isBuffer !== "function") {
+    return null;
+  }
+  return value;
+}, "getRuntimeBufferConstructor");
+var isNodeBuffer = /* @__PURE__ */ __name((value) => {
+  const runtimeBufferConstructor = getRuntimeBufferConstructor();
+  if (!runtimeBufferConstructor) {
+    return false;
+  }
+  return runtimeBufferConstructor.isBuffer(value);
+}, "isNodeBuffer");
+var assertBytePayload = /* @__PURE__ */ __name((payload, typeId) => {
+  if (!Array.isArray(payload)) {
+    throw new Error(`${INVALID_PAYLOAD_MESSAGE_PREFIX} ${typeId} payload`);
+  }
+  const bytes = new Array(payload.length);
+  for (let index = 0; index < payload.length; index += 1) {
+    const byteValue = payload[index];
+    if (typeof byteValue !== "number" || !Number.isInteger(byteValue) || byteValue < 0 || byteValue > 255) {
+      throw new Error(`${INVALID_PAYLOAD_MESSAGE_PREFIX} ${typeId} payload`);
+    }
+    bytes[index] = byteValue;
+  }
+  return bytes;
+}, "assertBytePayload");
+var toBytePayload = /* @__PURE__ */ __name((value) => Array.from(new Uint8Array(value.buffer, value.byteOffset, value.byteLength)), "toBytePayload");
+var bytesToArrayBuffer = /* @__PURE__ */ __name((payload, typeId) => {
+  const bytes = assertBytePayload(payload, typeId);
+  return Uint8Array.from(bytes).buffer;
+}, "bytesToArrayBuffer");
+var deserializeTypedArray = /* @__PURE__ */ __name((typeId, payload) => {
+  const typedArrayConstructor = getTypedArrayConstructor(typeId);
+  if (!typedArrayConstructor) {
+    throw new Error(`${typeId} is not available in this runtime`);
+  }
+  const bytes = assertBytePayload(payload, typeId);
+  const bytesPerElement = typedArrayConstructor.BYTES_PER_ELEMENT;
+  if (bytes.length % bytesPerElement !== 0) {
+    throw new Error(`${INVALID_PAYLOAD_MESSAGE_PREFIX} ${typeId} payload`);
+  }
+  const arrayBuffer = Uint8Array.from(bytes).buffer;
+  return new typedArrayConstructor(arrayBuffer);
+}, "deserializeTypedArray");
+var createTypedArrayType = /* @__PURE__ */ __name((typeId) => ({
+  id: typeId,
+  is: /* @__PURE__ */ __name((value) => {
+    const typedArrayConstructor = getTypedArrayConstructor(typeId);
+    if (!typedArrayConstructor) {
+      return false;
+    }
+    if (!(value instanceof typedArrayConstructor)) {
+      return false;
+    }
+    if (typeId === "Uint8Array" && isNodeBuffer(value)) {
+      return false;
+    }
+    return true;
+  }, "is"),
+  serialize: /* @__PURE__ */ __name((value) => toBytePayload(value), "serialize"),
+  deserialize: /* @__PURE__ */ __name((payload) => deserializeTypedArray(typeId, payload), "deserialize"),
+  strategy: "value"
+}), "createTypedArrayType");
+var ArrayBufferType = {
+  id: "ArrayBuffer",
+  is: /* @__PURE__ */ __name((value) => value instanceof ArrayBuffer, "is"),
+  serialize: /* @__PURE__ */ __name((value) => Array.from(new Uint8Array(value)), "serialize"),
+  deserialize: /* @__PURE__ */ __name((payload) => bytesToArrayBuffer(payload, "ArrayBuffer"), "deserialize"),
+  strategy: "value"
+};
+var DataViewType = {
+  id: "DataView",
+  is: /* @__PURE__ */ __name((value) => value instanceof DataView, "is"),
+  serialize: /* @__PURE__ */ __name((value) => toBytePayload(value), "serialize"),
+  deserialize: /* @__PURE__ */ __name((payload) => new DataView(bytesToArrayBuffer(payload, "DataView")), "deserialize"),
+  strategy: "value"
+};
+var BufferType = {
+  id: "Buffer",
+  is: /* @__PURE__ */ __name((value) => isNodeBuffer(value), "is"),
+  serialize: /* @__PURE__ */ __name((value) => toBytePayload(value), "serialize"),
+  deserialize: /* @__PURE__ */ __name((payload) => {
+    const bytes = assertBytePayload(payload, "Buffer");
+    const runtimeBufferConstructor = getRuntimeBufferConstructor();
+    if (runtimeBufferConstructor) {
+      return runtimeBufferConstructor.from(bytes);
+    }
+    return Uint8Array.from(bytes);
+  }, "deserialize"),
+  strategy: "value"
+};
+var typedArrayTypes = typedArrayTypeIds.map(
+  (typeId) => createTypedArrayType(typeId)
+);
+var binaryBuiltInTypes = [
+  ArrayBufferType,
+  DataViewType,
+  BufferType,
+  ...typedArrayTypes
+];
+
+// src/serializer/error-url-builtins.ts
+var hasOwn = Object.prototype.hasOwnProperty;
+var errorReservedPropertyNames = /* @__PURE__ */ new Set([
+  "name",
+  "message",
+  "stack",
+  "cause"
+]);
+var isRecord = /* @__PURE__ */ __name((value) => typeof value === "object" && value !== null && !Array.isArray(value), "isRecord");
+var isUnsafePropertyName = /* @__PURE__ */ __name((propertyName) => propertyName === "__proto__" || propertyName === "constructor" || propertyName === "prototype", "isUnsafePropertyName");
+var collectErrorCustomFields = /* @__PURE__ */ __name((error2) => {
+  const customFields = {};
+  for (const propertyName of Object.getOwnPropertyNames(error2)) {
+    if (errorReservedPropertyNames.has(propertyName)) {
+      continue;
+    }
+    if (isUnsafePropertyName(propertyName)) {
+      continue;
+    }
+    const descriptor = Object.getOwnPropertyDescriptor(error2, propertyName);
+    if (!descriptor || !("value" in descriptor)) {
+      continue;
+    }
+    customFields[propertyName] = descriptor.value;
+  }
+  return customFields;
+}, "collectErrorCustomFields");
+var assertSerializedErrorPayload = /* @__PURE__ */ __name((value) => {
+  if (!isRecord(value)) {
+    throw new Error("Invalid Error payload");
+  }
+  const { name, message, stack, customFields } = value;
+  if (typeof name !== "string" || typeof message !== "string") {
+    throw new Error("Invalid Error payload");
+  }
+  if (stack !== void 0 && typeof stack !== "string") {
+    throw new Error("Invalid Error payload");
+  }
+  if (customFields !== void 0 && !isRecord(customFields)) {
+    throw new Error("Invalid Error payload");
+  }
+  const normalizedCustomFields = {};
+  const customFieldEntries = Object.entries(customFields ?? {});
+  for (const [propertyName, propertyValue] of customFieldEntries) {
+    if (isUnsafePropertyName(propertyName)) {
+      continue;
+    }
+    normalizedCustomFields[propertyName] = propertyValue;
+  }
+  return {
+    name,
+    message,
+    stack,
+    hasCause: hasOwn.call(value, "cause"),
+    cause: value.cause,
+    customFields: normalizedCustomFields
+  };
+}, "assertSerializedErrorPayload");
+var getUrlConstructor = /* @__PURE__ */ __name(() => {
+  const value = globalThis.URL;
+  if (typeof value !== "function") {
+    return null;
+  }
+  return value;
+}, "getUrlConstructor");
+var getUrlSearchParamsConstructor = /* @__PURE__ */ __name(() => {
+  const value = globalThis.URLSearchParams;
+  if (typeof value !== "function") {
+    return null;
+  }
+  return value;
+}, "getUrlSearchParamsConstructor");
+var ErrorType = {
+  id: "Error",
+  is: /* @__PURE__ */ __name((value) => value instanceof Error, "is"),
+  serialize: /* @__PURE__ */ __name((error2) => {
+    const serializedErrorPayload = {
+      name: error2.name,
+      message: error2.message,
+      customFields: collectErrorCustomFields(error2)
+    };
+    if (typeof error2.stack === "string") {
+      serializedErrorPayload.stack = error2.stack;
+    }
+    if (hasOwn.call(error2, "cause")) {
+      serializedErrorPayload.cause = error2.cause;
+    }
+    return serializedErrorPayload;
+  }, "serialize"),
+  deserialize: /* @__PURE__ */ __name((payload) => {
+    const { name, message, stack, hasCause, cause, customFields } = assertSerializedErrorPayload(payload);
+    const restoredError = new Error(message);
+    restoredError.name = name;
+    if (stack !== void 0) {
+      Object.defineProperty(restoredError, "stack", {
+        value: stack,
+        writable: true,
+        configurable: true,
+        enumerable: false
+      });
+    }
+    if (hasCause) {
+      Object.defineProperty(restoredError, "cause", {
+        value: cause,
+        writable: true,
+        configurable: true,
+        enumerable: false
+      });
+    }
+    for (const [propertyName, propertyValue] of Object.entries(customFields)) {
+      if (errorReservedPropertyNames.has(propertyName)) {
+        continue;
+      }
+      restoredError[propertyName] = propertyValue;
+    }
+    return restoredError;
+  }, "deserialize")
+};
+var URLType = {
+  id: "URL",
+  is: /* @__PURE__ */ __name((value) => {
+    const runtimeUrlConstructor = getUrlConstructor();
+    if (!runtimeUrlConstructor) {
+      return false;
+    }
+    return value instanceof runtimeUrlConstructor;
+  }, "is"),
+  serialize: /* @__PURE__ */ __name((value) => value.href, "serialize"),
+  deserialize: /* @__PURE__ */ __name((payload) => {
+    if (typeof payload !== "string") {
+      throw new Error("Invalid URL payload");
+    }
+    const runtimeUrlConstructor = getUrlConstructor();
+    if (!runtimeUrlConstructor) {
+      throw new Error("URL is not available in this runtime");
+    }
+    return new runtimeUrlConstructor(payload);
+  }, "deserialize"),
+  strategy: "value"
+};
+var URLSearchParamsType = {
+  id: "URLSearchParams",
+  is: /* @__PURE__ */ __name((value) => {
+    const runtimeUrlSearchParamsConstructor = getUrlSearchParamsConstructor();
+    if (!runtimeUrlSearchParamsConstructor) {
+      return false;
+    }
+    return value instanceof runtimeUrlSearchParamsConstructor;
+  }, "is"),
+  serialize: /* @__PURE__ */ __name((value) => value.toString(), "serialize"),
+  deserialize: /* @__PURE__ */ __name((payload) => {
+    if (typeof payload !== "string") {
+      throw new Error("Invalid URLSearchParams payload");
+    }
+    const runtimeUrlSearchParamsConstructor = getUrlSearchParamsConstructor();
+    if (!runtimeUrlSearchParamsConstructor) {
+      throw new Error("URLSearchParams is not available in this runtime");
+    }
+    return new runtimeUrlSearchParamsConstructor(payload);
+  }, "deserialize"),
+  strategy: "value"
+};
+var errorAndUrlBuiltInTypes = [
+  ErrorType,
+  URLType,
+  URLSearchParamsType
+];
 
 // src/serializer/special-values.ts
 var serializeUndefined = /* @__PURE__ */ __name(() => ({
@@ -1766,7 +2090,9 @@ var builtInTypes = [
   UndefinedType,
   NonFiniteNumberType,
   BigIntType,
-  SymbolType
+  SymbolType,
+  ...errorAndUrlBuiltInTypes,
+  ...binaryBuiltInTypes
 ];
 
 // src/serializer/type-registry.ts
@@ -2257,7 +2583,7 @@ var serializeTreeValue = /* @__PURE__ */ __name((value, context, depth, options)
 }, "serializeTreeValue");
 
 // src/serializer/deserializer.ts
-var hasOwn = Object.prototype.hasOwnProperty;
+var hasOwn2 = Object.prototype.hasOwnProperty;
 var copyOwnProperties = /* @__PURE__ */ __name((target, source, unsafeKeys) => {
   const descriptors = Object.getOwnPropertyDescriptors(source);
   for (const key of Object.keys(descriptors)) {
@@ -2338,7 +2664,7 @@ var deserializeValue = /* @__PURE__ */ __name((value, context, depth, options) =
   const obj = {};
   const source = value;
   for (const key in source) {
-    if (!hasOwn.call(source, key)) {
+    if (!hasOwn2.call(source, key)) {
       continue;
     }
     if (isUnsafeKey(key, options.unsafeKeys)) {
@@ -2383,7 +2709,7 @@ var resolveReference = /* @__PURE__ */ __name((id2, context, depth, options) =>
       context.resolved.set(id2, target);
       const source = node.value;
       for (const key in source) {
-        if (!hasOwn.call(source, key)) {
+        if (!hasOwn2.call(source, key)) {
           continue;
         }
         if (isUnsafeKey(key, options.unsafeKeys)) {
@@ -2455,7 +2781,7 @@ var mergePlaceholder = /* @__PURE__ */ __name((placeholder, result, unsafeKeys)
     const target = placeholder;
     const source = result;
     for (const key in source) {
-      if (!hasOwn.call(source, key)) {
+      if (!hasOwn2.call(source, key)) {
         continue;
       }
       if (isUnsafeKey(key, unsafeKeys)) {
@@ -2488,7 +2814,7 @@ var deserializeLegacy = /* @__PURE__ */ __name((value, depth, options) => {
   const obj = {};
   const source = value;
   for (const key in source) {
-    if (!hasOwn.call(source, key)) {
+    if (!hasOwn2.call(source, key)) {
       continue;
     }
     if (isUnsafeKey(key, options.unsafeKeys)) {
@@ -2499,6 +2825,26 @@ var deserializeLegacy = /* @__PURE__ */ __name((value, depth, options) => {
   return obj;
 }, "deserializeLegacy");
 
+// src/serializer/option-normalizers.ts
+var normalizeMaxDepth = /* @__PURE__ */ __name((value, fallback) => {
+  if (value === Number.POSITIVE_INFINITY) {
+    return Number.POSITIVE_INFINITY;
+  }
+  if (typeof value === "number" && Number.isFinite(value) && value >= 0) {
+    return Math.floor(value);
+  }
+  return fallback;
+}, "normalizeMaxDepth");
+var normalizeMaxRegExpPatternLength = /* @__PURE__ */ __name((value, fallback) => {
+  if (value === Number.POSITIVE_INFINITY) {
+    return Number.POSITIVE_INFINITY;
+  }
+  if (typeof value === "number" && Number.isFinite(value) && value > 0) {
+    return Math.floor(value);
+  }
+  return fallback;
+}, "normalizeMaxRegExpPatternLength");
+
 // src/serializer/Serializer.ts
 var GRAPH_VERSION = 1;
 var DEFAULT_MAX_DEPTH = 1e3;
@@ -2534,10 +2880,11 @@ var Serializer = class {
       return check(pattern, index);
     }, "isBoundedQuantifier");
     this.indent = options.pretty ? 2 : void 0;
-    const maxDepth = options.maxDepth;
-    this.maxDepth = typeof maxDepth === "number" && Number.isFinite(maxDepth) && maxDepth >= 0 ? Math.floor(maxDepth) : DEFAULT_MAX_DEPTH;
-    const maxPatternLength = options.maxRegExpPatternLength;
-    this.maxRegExpPatternLength = maxPatternLength === Number.POSITIVE_INFINITY ? Number.POSITIVE_INFINITY : typeof maxPatternLength === "number" && Number.isFinite(maxPatternLength) && maxPatternLength > 0 ? Math.floor(maxPatternLength) : DEFAULT_MAX_REGEXP_PATTERN_LENGTH;
+    this.maxDepth = normalizeMaxDepth(options.maxDepth, DEFAULT_MAX_DEPTH);
+    this.maxRegExpPatternLength = normalizeMaxRegExpPatternLength(
+      options.maxRegExpPatternLength,
+      DEFAULT_MAX_REGEXP_PATTERN_LENGTH
+    );
     this.allowUnsafeRegExp = options.allowUnsafeRegExp ?? false;
     this.unsafeKeys = DEFAULT_UNSAFE_KEYS;
     this.typeRegistry = new TypeRegistry({
@@ -2672,13 +3019,6 @@ var Serializer = class {
   }
 };
 
-// src/serializer/index.ts
-var defaultSerializer = new Serializer();
-function getDefaultSerializer() {
-  return defaultSerializer;
-}
-__name(getDefaultSerializer, "getDefaultSerializer");
-
 // src/definers/defineAsyncContext.ts
 var platform = getPlatform();
 var storage = platform.createAsyncLocalStorage();
@@ -2686,13 +3026,14 @@ function getCurrentStore() {
   return storage.getStore();
 }
 __name(getCurrentStore, "getCurrentStore");
-function defineAsyncContext(def) {
+function defineAsyncContext(def, filePath) {
   if (!platform.hasAsyncLocalStorage()) {
     platformUnsupportedFunctionError.throw({
       functionName: `createAsyncLocalStorage: Cannot create context ${def.id}: no async storage available in this environment`
     });
   }
   const ctxId = def.id;
+  const resolvedFilePath = filePath ?? getCallerFile();
   const use = /* @__PURE__ */ __name(() => {
     const store2 = getCurrentStore();
     if (!store2 || !store2.has(ctxId)) {
@@ -2709,10 +3050,11 @@ function defineAsyncContext(def) {
     map.set(ctxId, value);
     return storage.run(map, fn);
   }, "provide");
-  const serializer2 = getDefaultSerializer();
+  const serializer2 = new Serializer();
   const api = {
     id: ctxId,
     [symbolAsyncContext]: true,
+    [symbolFilePath]: resolvedFilePath,
     use,
     /* istanbul ignore next */
     provide(value, fn) {
@@ -3364,12 +3706,12 @@ var EventManager = class {
         data,
         timestamp: /* @__PURE__ */ new Date(),
         source,
-        meta: eventDefinition.meta || {},
+        meta: { ...eventDefinition.meta || {} },
         stopPropagation: /* @__PURE__ */ __name(() => {
           propagationStopped = true;
         }, "stopPropagation"),
         isPropagationStopped: /* @__PURE__ */ __name(() => propagationStopped, "isPropagationStopped"),
-        tags: eventDefinition.tags
+        tags: [...eventDefinition.tags]
       };
       const baseEmit = /* @__PURE__ */ __name(async (eventToEmit) => {
         if (allListeners.length === 0) {
@@ -3395,10 +3737,14 @@ var EventManager = class {
         if (!interceptor) {
           return baseEmit(eventToEmit);
         }
-        return interceptor(
-          (nextEvent) => runInterceptor(index + 1, nextEvent),
-          eventToEmit
-        );
+        return interceptor((nextEvent) => {
+          this.assertPropagationMethodsUnchanged(
+            eventDefinition.id,
+            eventToEmit,
+            nextEvent
+          );
+          return runInterceptor(index + 1, nextEvent);
+        }, eventToEmit);
       }, "runInterceptor");
       await runInterceptor(0, event2);
       return deepestEvent;
@@ -3509,21 +3855,24 @@ var EventManager = class {
       lockedError.throw({ what: "EventManager" });
     }
   }
-  /**
-   * Clears all listeners and interceptors.
-   * Call this to release references and free memory.
-   */
-  clear() {
-    this.registry.clear();
-    this.emissionInterceptors.length = 0;
-    this.hookInterceptors.length = 0;
+  assertPropagationMethodsUnchanged(eventId, currentEvent, nextEvent) {
+    if (nextEvent.stopPropagation !== currentEvent.stopPropagation || nextEvent.isPropagationStopped !== currentEvent.isPropagationStopped) {
+      validationError.throw({
+        subject: "Event interceptor",
+        id: eventId,
+        originalError: new Error(
+          "Interceptors cannot override stopPropagation/isPropagationStopped"
+        )
+      });
+    }
   }
   /**
    * Disposes the EventManager, releasing all listeners and interceptors.
-   * Alias for clear() following the IResource disposal pattern.
    */
   dispose() {
-    this.clear();
+    this.registry.clear();
+    this.emissionInterceptors.length = 0;
+    this.hookInterceptors.length = 0;
   }
   /**
    * Retrieves cached merged listeners for an event, or creates them if not cached.
@@ -5041,7 +5390,7 @@ var TaskRunner = class {
     __name(this, "TaskRunner");
   }
   /**
-   * Begins the execution of an task. These are registered tasks and all sanity checks have been performed at this stage to ensure consistency of the object.
+   * Begins the execution of a task. These are registered tasks and all sanity checks have been performed at this stage to ensure consistency of the object.
    * This function can throw only if any of the event listeners or run function throws
    * @param task the task to be run
    * @param input the input to be passed to the task
@@ -5070,8 +5419,6 @@ var TaskRunner = class {
   /**
    * Creates the function with the chain of middleware.
    * @param task
-   * @param input
-   * @param taskDependencies
    * @returns
    */
   createRunnerWithMiddleware(task2) {
@@ -5091,7 +5438,7 @@ var ResourceInitializer = class {
     __name(this, "ResourceInitializer");
   }
   /**
-   * Begins the execution of an task. These are registered tasks and all sanity checks have been performed at this stage to ensure consistency of the object.
+   * Begins the execution of a task. These are registered tasks and all sanity checks have been performed at this stage to ensure consistency of the object.
    * This function can throw only if any of the event listeners or run function throws
    */
   async initializeResource(resource2, config, dependencies) {
@@ -5581,23 +5928,28 @@ var DependencyProcessor = class {
       middleware.computedDependencies = computedDependencies;
       middleware.isInitialized = true;
     }
-    for (const resource2 of this.store.resources.values()) {
-      await this.processResourceDependencies(resource2);
-    }
-    for (const task2 of this.store.tasks.values()) {
-      await this.computeTaskDependencies(task2);
-    }
     for (const hookStoreElement of this.store.hooks.values()) {
       const hook2 = hookStoreElement.hook;
       const deps = hook2.dependencies;
+      hookStoreElement.dependencyState = "computing" /* Computing */;
       hookStoreElement.computedDependencies = await this.extractDependencies(
         deps,
         hook2.id
       );
+      hookStoreElement.dependencyState = "ready" /* Ready */;
+    }
+    for (const resource2 of this.store.resources.values()) {
+      await this.processResourceDependencies(resource2);
+    }
+    for (const task2 of this.store.tasks.values()) {
+      await this.computeTaskDependencies(task2);
     }
     await this.initializeUninitializedResources();
   }
   async computeTaskDependencies(task2) {
+    if (task2.isInitialized) {
+      return;
+    }
     const deps = task2.task.dependencies;
     task2.computedDependencies = await this.extractDependencies(
       deps,
@@ -5729,6 +6081,9 @@ var DependencyProcessor = class {
           if (receivedEvent.source === hook2.id) {
             return;
           }
+          if (hookStoreElement.dependencyState !== "ready" /* Ready */) {
+            return;
+          }
           return this.eventManager.executeHookWithInterceptors(
             hook2,
             receivedEvent,
@@ -5845,7 +6200,7 @@ var DependencyProcessor = class {
     }
     const st = storeTask;
     if (!st.isInitialized) {
-      const dependencies = object.dependencies;
+      const dependencies = st.task.dependencies;
       st.computedDependencies = await this.extractDependencies(
         dependencies,
         st.task.id
@@ -5871,14 +6226,19 @@ var DependencyProcessor = class {
         wrapped = this.wrapResourceDependencies(depMap, raw);
         sr.computedDependencies = wrapped;
       }
-      const { value, context } = await this.resourceInitializer.initializeResource(
-        resource2,
-        config,
-        wrapped
-      );
-      sr.context = context;
-      sr.value = value;
-      sr.isInitialized = true;
+      try {
+        const { value, context } = await this.resourceInitializer.initializeResource(
+          resource2,
+          config,
+          wrapped
+        );
+        sr.context = context;
+        sr.value = value;
+        sr.isInitialized = true;
+        this.store.recordResourceInitialized(resource2.id);
+      } catch (error2) {
+        this.rethrowResourceInitError(resource2.id, error2);
+      }
     }
     return sr.value;
   }
@@ -6081,7 +6441,8 @@ var StoreRegistry = class {
     const hook2 = this.getFreshValue(item, this.hooks, "hook", overrideMode);
     this.hooks.set(hook2.id, {
       hook: hook2,
-      computedDependencies: {}
+      computedDependencies: {},
+      dependencyState: "pending" /* Pending */
     });
   }
   storeTaskMiddleware(item, storingMode = "normal") {
@@ -6136,7 +6497,10 @@ var StoreRegistry = class {
     return prepared;
   }
   computeRegistrationDeeply(element, config) {
-    const items = typeof element.register === "function" ? element.register(config) : element.register;
+    let items = typeof element.register === "function" ? element.register(config) : element.register;
+    if (!items) {
+      items = [];
+    }
     element.register = items;
     for (const item of items) {
       this.storeGenericItem(item);
@@ -6674,25 +7038,27 @@ var InterceptorRegistry = class {
    * Gets all global task interceptors
    */
   getGlobalTaskInterceptors() {
-    return this.taskInterceptors;
+    return Object.freeze([...this.taskInterceptors]);
   }
   /**
    * Gets all global resource interceptors
    */
   getGlobalResourceInterceptors() {
-    return this.resourceInterceptors;
+    return Object.freeze([...this.resourceInterceptors]);
   }
   /**
    * Gets interceptors for a specific task middleware
    */
   getTaskMiddlewareInterceptors(middlewareId) {
-    return this.perTaskMiddleware.get(middlewareId) || [];
+    const interceptors = this.perTaskMiddleware.get(middlewareId) ?? [];
+    return Object.freeze([...interceptors]);
   }
   /**
    * Gets interceptors for a specific resource middleware
    */
   getResourceMiddlewareInterceptors(middlewareId) {
-    return this.perResourceMiddleware.get(middlewareId) || [];
+    const interceptors = this.perResourceMiddleware.get(middlewareId) ?? [];
+    return Object.freeze([...interceptors]);
   }
 };
 
@@ -7171,10 +7537,8 @@ var ResourceMiddlewareComposer = class {
 
 // src/models/MiddlewareManager.ts
 var MiddlewareManager = class {
-  constructor(store2, eventManager, logger) {
+  constructor(store2, _eventManager, _logger) {
     this.store = store2;
-    this.eventManager = eventManager;
-    this.logger = logger;
     this.interceptorRegistry = new InterceptorRegistry();
     this.middlewareResolver = new MiddlewareResolver(store2);
     this.taskComposer = new TaskMiddlewareComposer(
@@ -7215,14 +7579,6 @@ var MiddlewareManager = class {
   lock() {
     this.interceptorRegistry.lock();
   }
-  /**
-   * Adds an interceptor for task or resource middleware execution
-   * Interceptors are executed in the order they are added, with the ability to
-   * modify, log, or prevent middleware execution
-   *
-   * @param kind - The type of middleware to intercept ("task" or "resource")
-   * @param interceptor - The interceptor function to add
-   */
   intercept(kind, interceptor) {
     if (kind === "task") {
       this.interceptorRegistry.addGlobalTaskInterceptor(
@@ -7234,13 +7590,6 @@ var MiddlewareManager = class {
       );
     }
   }
-  /**
-   * Adds an interceptor for a specific middleware instance with better type safety
-   * This method automatically determines the type and provides type-safe access
-   *
-   * @param middleware - The middleware instance to intercept
-   * @param interceptor - The interceptor function with proper typing
-   */
   interceptMiddleware(middleware, interceptor) {
     if (isTaskMiddleware(middleware)) {
       this.interceptorRegistry.addTaskMiddlewareInterceptor(
@@ -7379,12 +7728,17 @@ var Store = class {
     }
   }
   registerGlobalComponents() {
+    if (!this.taskRunner) {
+      throw new Error(
+        "TaskRunner is not set. Call store.setTaskRunner() before initializeStore()."
+      );
+    }
     const builtInResourcesMap = /* @__PURE__ */ new Map();
     builtInResourcesMap.set(globalResources.store, this);
     builtInResourcesMap.set(globalResources.eventManager, this.eventManager);
     builtInResourcesMap.set(globalResources.logger, this.logger);
     builtInResourcesMap.set(globalResources.taskRunner, this.taskRunner);
-    builtInResourcesMap.set(globalResources.serializer, getDefaultSerializer());
+    builtInResourcesMap.set(globalResources.serializer, new Serializer());
     builtInResourcesMap.set(
       globalResources.middlewareManager,
       this.middlewareManager
@@ -7444,8 +7798,11 @@ var Store = class {
   setTaskRunner(taskRunner) {
     this.taskRunner = taskRunner;
   }
-  setupRootResource(root, config) {
-    root.dependencies = typeof root.dependencies === "function" ? root.dependencies(config) : root.dependencies;
+  setupRootResource(rootDefinition, config) {
+    const root = {
+      ...rootDefinition,
+      dependencies: typeof rootDefinition.dependencies === "function" ? rootDefinition.dependencies(config) : rootDefinition.dependencies
+    };
     this.root = {
       resource: root,
       computedDependencies: {},
@@ -7998,6 +8355,18 @@ var RunResult = class {
       }
       return this.store.resources.get(resourceId).value;
     }, "getResourceValue");
+    /**
+     * Get the config of a resource from the run result.
+     * @param resource - The resource to get the config of.
+     * @returns The config passed for the resource.
+     */
+    this.getResourceConfig = /* @__PURE__ */ __name((resource2) => {
+      const resourceId = typeof resource2 === "string" ? resource2 : resource2.id;
+      if (!this.store.resources.has(resourceId)) {
+        throw new Error(`Resource "${resourceId}" not found.`);
+      }
+      return this.store.resources.get(resourceId).config;
+    }, "getResourceConfig");
     this.dispose = /* @__PURE__ */ __name(() => {
       return this.disposeFn();
     }, "dispose");
@@ -9178,7 +9547,7 @@ function makeAsyncContextBuilder(state) {
         configSchema: state.configSchema,
         meta: state.meta
       };
-      return defineAsyncContext(def);
+      return defineAsyncContext(def, state.filePath);
     }
   };
   return builder;
@@ -9187,8 +9556,10 @@ __name(makeAsyncContextBuilder, "makeAsyncContextBuilder");
 
 // src/definers/builders/asyncContext/index.ts
 function asyncContextBuilder(id2) {
+  const filePath = getCallerFile();
   const initial = Object.freeze({
     id: id2,
+    filePath,
     serialize: void 0,
     parse: void 0,
     configSchema: void 0,
@@ -9661,7 +10032,7 @@ function override(base) {
 }
 __name(override, "override");
 
-// src/index.ts
+// src/public.ts
 var globals = {
   events: globalEvents,
   resources: globalResources,
@@ -9689,6 +10060,7 @@ var r = Object.freeze({
 exports.DependencyProcessor = DependencyProcessor;
 exports.Errors = errors_exports;
 exports.EventManager = EventManager;
+exports.LogPrinter = LogPrinter;
 exports.Logger = Logger;
 exports.MiddlewareManager = MiddlewareManager;
 exports.PlatformAdapter = PlatformAdapter;
@@ -9698,6 +10070,8 @@ exports.RunResult = RunResult;
 exports.Semaphore = Semaphore;
 exports.Serializer = Serializer;
 exports.Store = Store;
+exports.SymbolPolicy = SymbolPolicy;
+exports.SymbolPolicyErrorMessage = SymbolPolicyErrorMessage;
 exports.TaskRunner = TaskRunner;
 exports.allFalse = allFalse;
 exports.asyncContext = defineAsyncContext;
@@ -9712,7 +10086,6 @@ exports.debugLevels = debugLevels;
 exports.definitions = defs_exports;
 exports.event = defineEvent;
 exports.getConfig = getConfig;
-exports.getDefaultSerializer = getDefaultSerializer;
 exports.globals = globals;
 exports.hook = defineHook;
 exports.journal = journal;