@bluelibs/runner 5.0.0 → 5.2.0

package/dist/browser/index.mjs

@@ -164,6 +164,9 @@ var symbolPhantomTask = Symbol.for(
   "runner.task.phantom"
 );
 var symbolResource = Symbol.for("runner.resource");
+var symbolResourceForkedFrom = Symbol.for(
+  "runner.resourceForkedFrom"
+);
 var symbolResourceWithConfig = Symbol.for(
   "runner.resourceWithConfig"
 );
@@ -193,88 +196,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, {
@@ -316,9 +458,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");
@@ -341,11 +484,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");
 
@@ -383,14 +530,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;
@@ -399,8 +549,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,
@@ -411,103 +563,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 {
@@ -800,16 +936,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) {
@@ -829,9 +960,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();
@@ -859,208 +989,285 @@ 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;
+// 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";
   }
-}
-__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,
-  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 || {});
+  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/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");
+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/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}`
-  );
+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(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);
+__name(isCancellationError, "isCancellationError");
+
+// src/definers/resourceFork.ts
+function resolveReId(forkId, options) {
+  const fallback = /* @__PURE__ */ __name((id2) => `${forkId}.${id2}`, "fallback");
+  const reId = options?.reId ?? fallback;
+  return (id2) => {
+    const next = reId(id2);
+    if (typeof next !== "string" || next.length === 0) {
+      throw new Error(`fork(reId) must return a non-empty string for "${id2}"`);
+    }
+    return next;
+  };
+}
+__name(resolveReId, "resolveReId");
+function remapResourceDependenciesInObject(deps, options) {
+  const remapObject = /* @__PURE__ */ __name((deps2) => {
+    const out = { ...deps2 };
+    for (const [key, value] of Object.entries(deps2)) {
+      if (isOptional(value)) {
+        const inner = value.inner;
+        if (isResource(inner)) {
+          const forked = options.getForkedResourceByBaseId(inner.id);
+          if (forked) {
+            out[key] = { ...value, inner: forked };
+          }
+        }
+        continue;
       }
-      id2 = item;
-    } else if (isError(item)) {
-      id2 = item.id;
-      if (typeof id2 !== "string" || id2.trim().length === 0) {
-        throw invalidThrowsEntryError(owner, item);
+      if (isResource(value)) {
+        const forked = options.getForkedResourceByBaseId(value.id);
+        if (forked) {
+          out[key] = forked;
+        }
       }
-    } else {
-      throw invalidThrowsEntryError(owner, item);
     }
-    if (seen.has(id2)) continue;
-    seen.add(id2);
-    ids.push(id2);
-  }
-  return ids;
+    return out;
+  }, "remapObject");
+  return remapObject(deps);
 }
-__name(toErrorIdList, "toErrorIdList");
-function normalizeThrows(owner, throwsList) {
-  if (throwsList === void 0) return void 0;
-  return toErrorIdList(owner, throwsList);
+__name(remapResourceDependenciesInObject, "remapResourceDependenciesInObject");
+function toResourceOnlyRegisterItems(items) {
+  const out = [];
+  for (const item of items) {
+    if (isResourceWithConfig(item)) {
+      out.push({
+        kind: "withConfig",
+        resource: item.resource,
+        config: item.config
+      });
+      continue;
+    }
+    if (isResource(item)) {
+      out.push({ kind: "resource", resource: item });
+      continue;
+    }
+  }
+  return out;
 }
-__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(toResourceOnlyRegisterItems, "toResourceOnlyRegisterItems");
+function createDeepForkContext(forkId, options) {
+  const reId = resolveReId(forkId, options);
+  const forkedResourceByBaseId = /* @__PURE__ */ new Map();
+  const ensureForked = /* @__PURE__ */ __name((base) => {
+    const cached = forkedResourceByBaseId.get(base.id);
+    if (cached) return cached;
+    const forked = base.fork(reId(base.id), { register: "drop" });
+    forkedResourceByBaseId.set(base.id, forked);
+    const baseRegister = base.register;
+    const ensureForkedForRegisterConfig = /* @__PURE__ */ __name((config) => {
+      const items = typeof baseRegister === "function" ? baseRegister(config) : baseRegister;
+      for (const candidate of toResourceOnlyRegisterItems(items)) {
+        ensureForked(candidate.resource);
+      }
+      return items;
+    }, "ensureForkedForRegisterConfig");
+    const mapRegisterItems2 = /* @__PURE__ */ __name((items) => {
+      const resourceItems = toResourceOnlyRegisterItems(items);
+      const out = [];
+      for (const candidate of resourceItems) {
+        if (candidate.kind === "resource") {
+          out.push(ensureForked(candidate.resource));
+          continue;
+        }
+        out.push(ensureForked(candidate.resource).with(candidate.config));
+      }
+      return out;
+    }, "mapRegisterItems");
+    forked.register = typeof baseRegister === "function" ? (config) => {
+      const items = ensureForkedForRegisterConfig(config);
+      return mapRegisterItems2(items);
+    } : (() => {
+      ensureForkedForRegisterConfig(void 0);
+      return mapRegisterItems2(baseRegister);
+    })();
+    const baseDependencies = base.dependencies;
+    const remapDepsObject = /* @__PURE__ */ __name((deps) => remapResourceDependenciesInObject(deps, {
+      getForkedResourceByBaseId: /* @__PURE__ */ __name((id2) => forkedResourceByBaseId.get(id2), "getForkedResourceByBaseId")
+    }), "remapDepsObject");
+    if (!baseDependencies) {
+      forked.dependencies = baseDependencies;
+    } else {
+      forked.dependencies = (config) => {
+        ensureForkedForRegisterConfig(config);
+        const deps = typeof baseDependencies === "function" ? baseDependencies(config) : baseDependencies;
+        return remapDepsObject(deps);
       };
     }
+    return forked;
+  }, "ensureForked");
+  const ensureForkedForRegisterItems = /* @__PURE__ */ __name((items) => {
+    for (const candidate of toResourceOnlyRegisterItems(items)) {
+      ensureForked(candidate.resource);
+    }
+  }, "ensureForkedForRegisterItems");
+  const mapRegisterItems = /* @__PURE__ */ __name((items) => {
+    ensureForkedForRegisterItems(items);
+    const resourceItems = toResourceOnlyRegisterItems(items);
+    const out = [];
+    for (const candidate of resourceItems) {
+      if (candidate.kind === "resource") {
+        out.push(ensureForked(candidate.resource));
+        continue;
+      }
+      out.push(ensureForked(candidate.resource).with(candidate.config));
+    }
+    return out;
+  }, "mapRegisterItems");
+  const remapDependencies = /* @__PURE__ */ __name((dependencies) => {
+    if (!dependencies) return dependencies;
+    const remapObj = /* @__PURE__ */ __name((deps) => remapResourceDependenciesInObject(deps, {
+      getForkedResourceByBaseId: /* @__PURE__ */ __name((id2) => forkedResourceByBaseId.get(id2), "getForkedResourceByBaseId")
+    }), "remapObj");
+    if (typeof dependencies === "function") {
+      return (config) => remapObj(dependencies(config));
+    }
+    return remapObj(dependencies);
+  }, "remapDependencies");
+  return {
+    reId,
+    ensureForkedForRegisterItems,
+    mapRegisterItems,
+    remapDependencies,
+    getForkedResourceByBaseId: /* @__PURE__ */ __name((id2) => forkedResourceByBaseId.get(id2), "getForkedResourceByBaseId")
   };
 }
-__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();
+__name(createDeepForkContext, "createDeepForkContext");
+function resolveForkedRegisterAndDependencies(params) {
+  const { register, dependencies, forkId, options } = params;
+  const mode = options?.register ?? "keep";
+  if (mode === "drop") {
+    return { register: [], dependencies };
+  }
+  if (mode !== "deep") {
+    return { register, dependencies };
+  }
+  if (!register) {
+    return { register, dependencies };
+  }
+  const ctx = createDeepForkContext(forkId, options);
+  if (typeof register === "function") {
+    return {
+      register: /* @__PURE__ */ __name((config) => {
+        const baseItems = register(config);
+        return ctx.mapRegisterItems(baseItems);
+      }, "register"),
+      dependencies: dependencies ? (config) => {
+        const baseItems = register(config);
+        ctx.ensureForkedForRegisterItems(baseItems);
+        const baseDeps = typeof dependencies === "function" ? dependencies(config) : dependencies;
+        return remapResourceDependenciesInObject(baseDeps, {
+          getForkedResourceByBaseId: ctx.getForkedResourceByBaseId
+        });
+      } : dependencies
+    };
+  }
+  ctx.ensureForkedForRegisterItems(register);
   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 || []
+    register: ctx.mapRegisterItems(register),
+    dependencies: ctx.remapDependencies(dependencies)
   };
 }
-__name(defineHook, "defineHook");
+__name(resolveForkedRegisterAndDependencies, "resolveForkedRegisterAndDependencies");
 
 // src/definers/defineResource.ts
 function defineResource(constConfig) {
@@ -1107,12 +1314,25 @@ function defineResource(constConfig) {
         [symbolOptionalDependency]: true
       };
     },
-    fork(newId) {
-      return defineResource({
+    fork(newId, options) {
+      const forkedParts = resolveForkedRegisterAndDependencies({
+        register: constConfig.register,
+        dependencies: constConfig.dependencies,
+        forkId: newId,
+        options
+      });
+      const forked = defineResource({
         ...constConfig,
         id: newId,
+        register: forkedParts.register,
+        dependencies: forkedParts.dependencies,
         [symbolFilePath]: filePath
       });
+      forked[symbolResourceForkedFrom] = {
+        fromId: id2,
+        forkedAtFilePath: getCallerFile()
+      };
+      return forked;
     }
   };
 }
@@ -1240,7 +1460,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;
@@ -1360,6 +1580,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(() => ({
@@ -1565,7 +2088,9 @@ var builtInTypes = [
   UndefinedType,
   NonFiniteNumberType,
   BigIntType,
-  SymbolType
+  SymbolType,
+  ...errorAndUrlBuiltInTypes,
+  ...binaryBuiltInTypes
 ];
 
 // src/serializer/type-registry.ts
@@ -2056,7 +2581,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)) {
@@ -2137,7 +2662,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)) {
@@ -2182,7 +2707,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)) {
@@ -2254,7 +2779,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)) {
@@ -2287,7 +2812,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)) {
@@ -2298,6 +2823,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;
@@ -2333,10 +2878,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({
@@ -2471,13 +3017,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();
@@ -2485,13 +3024,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)) {
@@ -2508,10 +3048,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) {
@@ -3163,12 +3704,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) {
@@ -3194,10 +3735,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;
@@ -3308,21 +3853,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.
@@ -4840,7 +5388,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
@@ -4869,8 +5417,6 @@ var TaskRunner = class {
   /**
    * Creates the function with the chain of middleware.
    * @param task
-   * @param input
-   * @param taskDependencies
    * @returns
    */
   createRunnerWithMiddleware(task2) {
@@ -4890,7 +5436,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) {
@@ -5380,23 +5926,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,
@@ -5528,6 +6079,9 @@ var DependencyProcessor = class {
           if (receivedEvent.source === hook2.id) {
             return;
           }
+          if (hookStoreElement.dependencyState !== "ready" /* Ready */) {
+            return;
+          }
           return this.eventManager.executeHookWithInterceptors(
             hook2,
             receivedEvent,
@@ -5644,7 +6198,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
@@ -5670,14 +6224,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;
   }
@@ -5880,7 +6439,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") {
@@ -5935,7 +6495,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);
@@ -6473,25 +7036,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]);
   }
 };
 
@@ -6970,10 +7535,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(
@@ -7014,14 +7577,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(
@@ -7033,13 +7588,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(
@@ -7178,12 +7726,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
@@ -7243,8 +7796,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: {},
@@ -7797,6 +8353,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");
@@ -8977,7 +9545,7 @@ function makeAsyncContextBuilder(state) {
         configSchema: state.configSchema,
         meta: state.meta
       };
-      return defineAsyncContext(def);
+      return defineAsyncContext(def, state.filePath);
     }
   };
   return builder;
@@ -8986,8 +9554,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,
@@ -9460,7 +10030,7 @@ function override(base) {
 }
 __name(override, "override");
 
-// src/index.ts
+// src/public.ts
 var globals = {
   events: globalEvents,
   resources: globalResources,
@@ -9485,6 +10055,6 @@ var r = Object.freeze({
   })
 });
 
-export { DependencyProcessor, errors_exports as Errors, EventManager, Logger, MiddlewareManager, PlatformAdapter, Queue, ResourceInitializer, RunResult, Semaphore, Serializer, Store, TaskRunner, allFalse, defineAsyncContext as asyncContext, bindProcessErrorHandler, createContext2 as createContext, createDefaultUnhandledError, createExposureFetch, createHttpClient, createTestResource, debug, debugLevels, defs_exports as definitions, defineEvent as event, getConfig, getDefaultSerializer, 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, 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 };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map