@bluelibs/runner 4.7.0 → 4.8.0

package/dist/node/node.mjs

@@ -3787,8 +3787,11 @@ var require_lib = __commonJS({
 // 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,
@@ -3803,6 +3806,7 @@ __export(defs_exports, {
   symbolTagConfigured: () => symbolTagConfigured,
   symbolTask: () => symbolTask,
   symbolTaskMiddleware: () => symbolTaskMiddleware,
+  symbolTunneledBy: () => symbolTunneledBy,
   symbolTunneledTask: () => symbolTunneledTask
 });
 
@@ -3816,6 +3820,7 @@ var symbolResourceWithConfig = Symbol.for(
   "runner.resourceWithConfig"
 );
 var symbolEvent = Symbol.for("runner.event");
+var symbolError = Symbol.for("runner.error");
 var symbolMiddleware = Symbol.for("runner.middleware");
 var symbolTaskMiddleware = Symbol.for(
   "runner.taskMiddleware"
@@ -3829,6 +3834,9 @@ var symbolMiddlewareConfigured = Symbol.for(
 var symbolTunneledTask = Symbol.for(
   "runner.tunneledTask"
 );
+var symbolTunneledBy = Symbol.for(
+  "runner.tunneledBy"
+);
 var symbolHook = Symbol.for("runner.hook");
 var symbolTag = Symbol.for("runner.tag");
 var symbolTagConfigured = Symbol.for(
@@ -3838,6 +3846,9 @@ var symbolOptionalDependency = Symbol.for(
   "runner.optionalDependency"
 );
 var symbolFilePath = Symbol.for("runner.filePath");
+var symbolAsyncContext = Symbol.for(
+  "runner.asyncContext"
+);
 
 // src/types/event.ts
 function onAnyOf(...defs) {
@@ -3848,6 +3859,14 @@ 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 || {});
 var cacheFactoryTask = defineTask({
   id: "globals.tasks.cacheFactory",
   run: /* @__PURE__ */ __name(async (options) => {
@@ -3992,26 +4011,123 @@ __name(defineHook, "defineHook");
 // src/errors.ts
 var errors_exports = {};
 __export(errors_exports, {
-  CancellationError: () => CancellationError,
-  CircularDependenciesError: () => CircularDependenciesError,
-  ContextError: () => ContextError,
-  DependencyNotFoundError: () => DependencyNotFoundError,
-  DuplicateRegistrationError: () => DuplicateRegistrationError,
-  EventCycleError: () => EventCycleError,
-  EventEmissionCycleError: () => EventEmissionCycleError,
-  EventNotFoundError: () => EventNotFoundError,
-  LockedError: () => LockedError,
-  MiddlewareNotRegisteredError: () => MiddlewareNotRegisteredError,
-  PlatformUnsupportedFunction: () => PlatformUnsupportedFunction,
-  ResourceNotFoundError: () => ResourceNotFoundError,
-  RuntimeError: () => RuntimeError,
-  StoreAlreadyInitializedError: () => StoreAlreadyInitializedError,
-  TagNotFoundError: () => TagNotFoundError,
-  UnknownItemTypeError: () => UnknownItemTypeError,
-  ValidationError: () => ValidationError,
-  isCancellationError: () => isCancellationError
+  cancellationError: () => cancellationError,
+  circularDependenciesError: () => circularDependenciesError,
+  contextError: () => contextError,
+  dependencyNotFoundError: () => dependencyNotFoundError,
+  duplicateRegistrationError: () => duplicateRegistrationError,
+  eventCycleError: () => eventCycleError,
+  eventEmissionCycleError: () => eventEmissionCycleError,
+  eventNotFoundError: () => eventNotFoundError,
+  isCancellationError: () => isCancellationError,
+  lockedError: () => lockedError,
+  middlewareNotRegisteredError: () => middlewareNotRegisteredError,
+  platformUnsupportedFunctionError: () => platformUnsupportedFunctionError,
+  resourceNotFoundError: () => resourceNotFoundError,
+  storeAlreadyInitializedError: () => storeAlreadyInitializedError,
+  tagNotFoundError: () => tagNotFoundError,
+  tunnelOwnershipConflictError: () => tunnelOwnershipConflictError,
+  unknownItemTypeError: () => unknownItemTypeError,
+  validationError: () => validationError
 });
 
+// src/definers/defineError.ts
+var RunnerError = class extends Error {
+  constructor(id2, message, data) {
+    super(message);
+    this.id = id2;
+    this.data = data;
+    this.name = id2;
+  }
+  static {
+    __name(this, "RunnerError");
+  }
+};
+var _a;
+_a = symbolError;
+var ErrorHelper = class {
+  constructor(definition) {
+    this.definition = definition;
+    this[_a] = true;
+  }
+  static {
+    __name(this, "ErrorHelper");
+  }
+  get id() {
+    return this.definition.id;
+  }
+  throw(data) {
+    const parsed = this.definition.dataSchema ? this.definition.dataSchema.parse(data) : data;
+    const message = this.definition.format(parsed);
+    throw new RunnerError(this.definition.id, message, parsed);
+  }
+  is(error2) {
+    return error2 instanceof RunnerError && error2.name === this.definition.id;
+  }
+  optional() {
+    return {
+      inner: this,
+      [symbolOptionalDependency]: true
+    };
+  }
+};
+function defineError(definition) {
+  if (!definition.format) {
+    definition.format = (data) => `${JSON.stringify(data)}`;
+  }
+  return new ErrorHelper(definition);
+}
+__name(defineError, "defineError");
+
+// src/definers/builders/error.ts
+function clone(s, patch) {
+  return Object.freeze({ ...s, ...patch });
+}
+__name(clone, "clone");
+function makeErrorBuilder(state) {
+  const b = {
+    id: state.id,
+    serialize(fn) {
+      const next = clone(state, { serialize: fn });
+      return makeErrorBuilder(next);
+    },
+    parse(fn) {
+      const next = clone(state, { parse: fn });
+      return makeErrorBuilder(next);
+    },
+    dataSchema(schema) {
+      const next = clone(state, { dataSchema: schema });
+      return makeErrorBuilder(next);
+    },
+    format(fn) {
+      const next = clone(state, { format: fn });
+      return makeErrorBuilder(next);
+    },
+    build() {
+      return defineError({
+        id: state.id,
+        serialize: state.serialize,
+        parse: state.parse,
+        dataSchema: state.dataSchema,
+        format: state.format
+      });
+    }
+  };
+  return b;
+}
+__name(makeErrorBuilder, "makeErrorBuilder");
+function errorBuilder(id2) {
+  const initial = Object.freeze({
+    id: id2,
+    serialize: void 0,
+    parse: void 0,
+    dataSchema: void 0
+  });
+  return makeErrorBuilder(initial);
+}
+__name(errorBuilder, "errorBuilder");
+var error = errorBuilder;
+
 // src/platform/adapters/node-als.ts
 async function loadAsyncLocalStorageClass() {
   const mod = await import('async_hooks');
@@ -4135,7 +4251,7 @@ var BrowserPlatformAdapter = class {
     };
   }
   exit() {
-    throw new PlatformUnsupportedFunction("exit");
+    platformUnsupportedFunctionError.throw({ functionName: "exit" });
   }
   getEnv(key) {
     const g = globalThis;
@@ -4151,10 +4267,14 @@ var BrowserPlatformAdapter = class {
   createAsyncLocalStorage() {
     return {
       getStore: /* @__PURE__ */ __name(() => {
-        throw new PlatformUnsupportedFunction("createAsyncLocalStorage");
+        platformUnsupportedFunctionError.throw({
+          functionName: "createAsyncLocalStorage"
+        });
       }, "getStore"),
-      run: /* @__PURE__ */ __name(() => {
-        throw new PlatformUnsupportedFunction("createAsyncLocalStorage");
+      run: /* @__PURE__ */ __name((_store, _callback) => {
+        platformUnsupportedFunctionError.throw({
+          functionName: "createAsyncLocalStorage"
+        });
       }, "run")
     };
   }
@@ -4230,7 +4350,7 @@ var GenericUniversalPlatformAdapter = class {
     };
   }
   exit() {
-    throw new PlatformUnsupportedFunction("exit");
+    platformUnsupportedFunctionError.throw({ functionName: "exit" });
   }
   getEnv(key) {
     const g = globalThis;
@@ -4246,10 +4366,14 @@ var GenericUniversalPlatformAdapter = class {
   createAsyncLocalStorage() {
     return {
       getStore: /* @__PURE__ */ __name(() => {
-        throw new PlatformUnsupportedFunction("createAsyncLocalStorage");
+        platformUnsupportedFunctionError.throw({
+          functionName: "createAsyncLocalStorage"
+        });
       }, "getStore"),
-      run: /* @__PURE__ */ __name(() => {
-        throw new PlatformUnsupportedFunction("createAsyncLocalStorage");
+      run: /* @__PURE__ */ __name((_store, _callback) => {
+        platformUnsupportedFunctionError.throw({
+          functionName: "createAsyncLocalStorage"
+        });
       }, "run")
     };
   }
@@ -4446,198 +4570,90 @@ var PlatformAdapter = class {
 };
 
 // src/errors.ts
-var RuntimeError = class extends Error {
-  static {
-    __name(this, "RuntimeError");
-  }
-  constructor(message) {
-    super(message);
-    this.name = "RuntimeError";
-  }
-};
-var DuplicateRegistrationError = class extends RuntimeError {
-  static {
-    __name(this, "DuplicateRegistrationError");
-  }
-  constructor(type, id2) {
-    super(
-      `${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.`
-    );
-    this.name = "DuplicateRegistrationError";
-  }
-};
-var DependencyNotFoundError = class extends RuntimeError {
-  static {
-    __name(this, "DependencyNotFoundError");
-  }
-  constructor(key) {
-    super(
-      `Dependency ${key.toString()} not found. Did you forget to register it through a resource?`
-    );
-    this.name = "DependencyNotFoundError";
-  }
-};
-var UnknownItemTypeError = class extends RuntimeError {
-  static {
-    __name(this, "UnknownItemTypeError");
-  }
-  constructor(item) {
-    super(
-      `Unknown item type: ${item}. Please ensure you are not using different versions of '@bluelibs/runner'`
-    );
-    this.name = "UnknownItemTypeError";
-  }
-};
-var ContextError = class extends Error {
-  static {
-    __name(this, "ContextError");
-  }
-  constructor(message) {
-    super(message);
-    this.name = "ContextError";
-  }
-};
-var CircularDependenciesError = class extends RuntimeError {
-  static {
-    __name(this, "CircularDependenciesError");
-  }
-  constructor(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";
-    }
-    super(`Circular dependencies detected:
-${cycleDetails}${guidance}`);
-    this.name = "CircularDependenciesError";
-  }
-};
-var EventNotFoundError = class extends RuntimeError {
-  static {
-    __name(this, "EventNotFoundError");
-  }
-  constructor(id2) {
-    super(`Event "${id2.toString()}" not found. Did you forget to register it?`);
-    this.name = "EventNotFoundError";
-  }
-};
-var ResourceNotFoundError = class extends RuntimeError {
-  static {
-    __name(this, "ResourceNotFoundError");
-  }
-  constructor(id2) {
-    super(
-      `Resource "${id2.toString()}" not found. Did you forget to register it or are you using the correct id?`
-    );
-    this.name = "ResourceNotFoundError";
-  }
-};
-var MiddlewareNotRegisteredError = class extends RuntimeError {
-  static {
-    __name(this, "MiddlewareNotRegisteredError");
-  }
-  constructor(type, source, middlewareId) {
-    super(
-      `Middleware inside ${type} "${source}" depends on "${middlewareId}" but it's not registered. Did you forget to register it?`
-    );
-    this.name = `MiddlewareNotRegisteredError: ${type} ${source} ${middlewareId}`;
-  }
-};
-var TagNotFoundError = class extends RuntimeError {
-  static {
-    __name(this, "TagNotFoundError");
-  }
-  constructor(id2) {
-    super(
-      `Tag "${id2}" not registered. Did you forget to register it inside a resource?`
-    );
-    this.name = "TagNotRegisteredError";
-  }
-};
-var LockedError = class extends RuntimeError {
-  static {
-    __name(this, "LockedError");
-  }
-  constructor(what) {
-    super(`Cannot modify the ${what.toString()} when it is locked.`);
-    this.name = "LockedError";
-  }
-};
-var StoreAlreadyInitializedError = class extends RuntimeError {
-  static {
-    __name(this, "StoreAlreadyInitializedError");
-  }
-  constructor() {
-    super("Store already initialized. Cannot reinitialize.");
-    this.name = "StoreAlreadyInitializedError";
-  }
-};
-var ValidationError = class extends RuntimeError {
-  static {
-    __name(this, "ValidationError");
-  }
-  constructor(type, id2, originalError) {
-    const errorMessage2 = originalError instanceof Error ? originalError.message : String(originalError);
-    super(`${type} validation failed for ${id2.toString()}: ${errorMessage2}`);
-    this.name = "ValidationError";
-  }
-};
-var EventCycleError = class extends RuntimeError {
-  static {
-    __name(this, "EventCycleError");
-  }
-  constructor(path3) {
-    const chain = path3.map((p) => `${p.id}\u2190${p.source}`).join("  ->  ");
-    super(
-      `Event emission cycle detected:
+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 errorMessage2 = originalError instanceof Error ? originalError.message : String(originalError);
+  return `${subject} validation failed for ${id2.toString()}: ${errorMessage2}`;
+}).build();
+var eventCycleError = error("runner.errors.eventCycle").format(({ path: path3 }) => {
+  const chain = path3.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.`
-    );
-    this.name = "EventCycleError";
-  }
-};
-var EventEmissionCycleError = class extends RuntimeError {
-  static {
-    __name(this, "EventEmissionCycleError");
-  }
-  constructor(cycles) {
-    const list = cycles.map((c) => `  \u2022 ${c}`).join("\n");
-    super(
-      `Event emission cycles detected between hooks and events:
+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.`
-    );
-    this.name = "EventEmissionCycleError";
-  }
-};
-var PlatformUnsupportedFunction = class extends RuntimeError {
-  static {
-    __name(this, "PlatformUnsupportedFunction");
-  }
-  constructor(functionName) {
-    super(
-      `Platform function not supported in this environment: ${functionName}. Detected platform: ${detectEnvironment()}.`
-    );
-    this.name = "PlatformUnsupportedFunction";
-  }
-};
-var CancellationError = class extends RuntimeError {
-  static {
-    __name(this, "CancellationError");
-  }
-  constructor(message = "Operation cancelled") {
-    super(message);
-    this.name = "CancellationError";
-  }
-};
+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();
 function isCancellationError(err) {
-  return !!err && err.name === "CancellationError";
+  return cancellationError.is(err);
 }
 __name(isCancellationError, "isCancellationError");
 
@@ -4662,12 +4678,12 @@ function defineResource(constConfig) {
       if (constConfig.configSchema) {
         try {
           config = constConfig.configSchema.parse(config);
-        } catch (error) {
-          throw new ValidationError(
-            "Resource config",
-            id2,
-            error instanceof Error ? error : new Error(String(error))
-          );
+        } catch (error2) {
+          validationError.throw({
+            subject: "Resource config",
+            id: id2,
+            originalError: error2 instanceof Error ? error2 : new Error(String(error2))
+          });
         }
       }
       return {
@@ -4728,12 +4744,12 @@ function defineTaskMiddleware(middlewareDef) {
         if (obj.configSchema) {
           try {
             config = obj.configSchema.parse(config);
-          } catch (error) {
-            throw new ValidationError(
-              "Middleware config",
-              obj.id,
-              error instanceof Error ? error : new Error(String(error))
-            );
+          } catch (error2) {
+            validationError.throw({
+              subject: "Middleware config",
+              id: obj.id,
+              originalError: error2 instanceof Error ? error2 : new Error(String(error2))
+            });
           }
         }
         return wrap({
@@ -4769,12 +4785,12 @@ function defineResourceMiddleware(middlewareDef) {
         if (obj.configSchema) {
           try {
             config = obj.configSchema.parse(config);
-          } catch (error) {
-            throw new ValidationError(
-              "Middleware config",
-              obj.id,
-              error
-            );
+          } catch (error2) {
+            validationError.throw({
+              subject: "Middleware config",
+              id: obj.id,
+              originalError: error2
+            });
           }
         }
         return wrap({
@@ -4826,8 +4842,12 @@ function defineTag(definition) {
       if (definition.configSchema) {
         try {
           tagConfig = definition.configSchema.parse(tagConfig);
-        } catch (error) {
-          throw new ValidationError("Tag config", this.id, error);
+        } catch (error2) {
+          validationError.throw({
+            subject: "Tag config",
+            id: this.id,
+            originalError: error2
+          });
         }
       }
       let config;
@@ -4928,6 +4948,14 @@ 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/globals/middleware/requireContext.middleware.ts
 var requireContextTaskMiddleware = defineTaskMiddleware({
@@ -4942,29 +4970,45 @@ var requireContextTaskMiddleware = defineTaskMiddleware({
     return next(task2?.input);
   }
 });
+var EjsonSerializer = {
+  stringify(value) {
+    return EJSON.stringify(value);
+  },
+  parse(text) {
+    return EJSON.parse(text);
+  },
+  addType(name, factory) {
+    EJSON.addType(name, factory);
+  }
+};
+function getDefaultSerializer() {
+  return EjsonSerializer;
+}
+__name(getDefaultSerializer, "getDefaultSerializer");
 
-// src/context.ts
+// src/definers/defineAsyncContext.ts
 var platform = getPlatform();
 var storage = platform.createAsyncLocalStorage();
 function getCurrentStore() {
   return storage.getStore();
 }
 __name(getCurrentStore, "getCurrentStore");
-function createContext(name = "runner.context") {
+function defineAsyncContext(def) {
   if (!platform.hasAsyncLocalStorage()) {
-    throw new PlatformUnsupportedFunction(
-      `createAsyncLocalStorage: Cannot create context ${name}: no async storage available in this environment`
-    );
+    platformUnsupportedFunctionError.throw({
+      functionName: `createAsyncLocalStorage: Cannot create context ${def.id}: no async storage available in this environment`
+    });
   }
-  const ctxId = Symbol(name);
+  const ctxId = def.id;
   const use = /* @__PURE__ */ __name(() => {
     const store2 = getCurrentStore();
     if (!store2 || !store2.has(ctxId)) {
-      throw new ContextError(
-        `Context not available for symbol ${ctxId.toString()}`
-      );
+      contextError.throw({
+        details: `Context not available for symbol ${ctxId.toString()}`
+      });
     }
-    return store2.get(ctxId);
+    const s = store2;
+    return s.get(ctxId);
   }, "use");
   const provide = /* @__PURE__ */ __name((value, fn) => {
     const currentStore = getCurrentStore();
@@ -4972,16 +5016,39 @@ function createContext(name = "runner.context") {
     map.set(ctxId, value);
     return storage.run(map, fn);
   }, "provide");
+  const serializer = getDefaultSerializer();
   const api = {
     id: ctxId,
+    [symbolAsyncContext]: true,
     use,
-    provide,
+    /* istanbul ignore next */
+    provide(value, fn) {
+      const validated = def.configSchema ? def.configSchema.parse(value) : value;
+      return provide(validated, fn);
+    },
     require() {
-      return requireContextTaskMiddleware.with({ context: api });
+      return requireContextTaskMiddleware.with({
+        context: api
+      });
+    },
+    /* istanbul ignore next */
+    serialize: def.serialize || ((data) => serializer.stringify(data)),
+    /* istanbul ignore next */
+    parse: def.parse || ((data) => serializer.parse(data)),
+    optional() {
+      return {
+        inner: api,
+        [symbolOptionalDependency]: true
+      };
     }
   };
   return api;
 }
+__name(defineAsyncContext, "defineAsyncContext");
+function createContext(name) {
+  const id2 = name ?? `context.${Math.random().toString(36).slice(2)}.${Date.now()}`;
+  return defineAsyncContext({ id: id2 });
+}
 __name(createContext, "createContext");
 
 // src/globals/resources/debug/debug.tag.ts
@@ -5196,10 +5263,10 @@ var retryTaskMiddleware = defineTaskMiddleware({
     while (true) {
       try {
         return await next(input);
-      } catch (error) {
-        const err = error;
+      } catch (error2) {
+        const err = error2;
         if (shouldStop(err) || attempts >= maxRetries) {
-          throw error;
+          throw error2;
         }
         const delay = config.delayStrategy ? config.delayStrategy(attempts, err) : 100 * Math.pow(2, attempts);
         if (delay > 0) {
@@ -5220,10 +5287,10 @@ var retryResourceMiddleware = defineResourceMiddleware({
     while (true) {
       try {
         return await next(input);
-      } catch (error) {
-        const err = error;
+      } catch (error2) {
+        const err = error2;
         if (shouldStop(err) || attempts >= maxRetries) {
-          throw error;
+          throw error2;
         }
         const delay = config.delayStrategy ? config.delayStrategy(attempts, err) : 100 * Math.pow(2, attempts);
         if (delay > 0) {
@@ -5243,17 +5310,17 @@ var timeoutTaskMiddleware = defineTaskMiddleware({
     const ttl = Math.max(0, config.ttl);
     const message = `Operation timed out after ${ttl}ms`;
     if (ttl === 0) {
-      const error = new Error(message);
-      error.name = "TimeoutError";
-      throw error;
+      const error2 = new Error(message);
+      error2.name = "TimeoutError";
+      throw error2;
     }
     const controller = new AbortController();
     const timeoutPromise = new Promise((_, reject) => {
       const timeoutId = setTimeout(() => {
         controller.abort();
-        const error = new Error(message);
-        error.name = "TimeoutError";
-        reject(error);
+        const error2 = new Error(message);
+        error2.name = "TimeoutError";
+        reject(error2);
       }, ttl);
       controller.signal.addEventListener("abort", () => {
         clearTimeout(timeoutId);
@@ -5269,17 +5336,17 @@ var timeoutResourceMiddleware = defineResourceMiddleware({
     const ttl = Math.max(0, config.ttl);
     const message = `Operation timed out after ${ttl}ms`;
     if (ttl === 0) {
-      const error = new Error(message);
-      error.name = "TimeoutError";
-      throw error;
+      const error2 = new Error(message);
+      error2.name = "TimeoutError";
+      throw error2;
     }
     const controller = new AbortController();
     const timeoutPromise = new Promise((_, reject) => {
       const timeoutId = setTimeout(() => {
         controller.abort();
-        const error = new Error(message);
-        error.name = "TimeoutError";
-        reject(error);
+        const error2 = new Error(message);
+        error2.name = "TimeoutError";
+        reject(error2);
       }, ttl);
       controller.signal.addEventListener("abort", () => {
         clearTimeout(timeoutId);
@@ -5305,6 +5372,77 @@ var globalMiddlewares = {
   }
 };
 
+// src/globals/resources/debug/types.ts
+var allFalse = Object.freeze({
+  logResourceBeforeRun: false,
+  logResourceAfterRun: false,
+  logMiddlewareBeforeRun: false,
+  logMiddlewareAfterRun: false,
+  logTaskBeforeRun: false,
+  logTaskAfterRun: false,
+  logTaskInput: false,
+  logTaskOutput: false,
+  logResourceConfig: false,
+  logResourceValue: false,
+  logHookTriggered: false,
+  logHookCompleted: false,
+  logEventEmissionOnRun: false,
+  logEventEmissionInput: false
+});
+var levelNormal = Object.freeze({
+  ...allFalse,
+  logTaskAfterRun: true,
+  logTaskBeforeRun: true,
+  logResourceBeforeRun: true,
+  logResourceAfterRun: true,
+  logMiddlewareBeforeRun: true,
+  logMiddlewareAfterRun: true,
+  logHookTriggered: true,
+  logHookCompleted: true,
+  logEventEmissionOnRun: true
+});
+Object.freeze(levelNormal);
+var levelVerbose = Object.freeze({
+  ...levelNormal,
+  logTaskInput: true,
+  logTaskOutput: true,
+  logResourceConfig: true,
+  logResourceValue: true,
+  logHookTriggered: true,
+  logHookCompleted: true
+});
+Object.freeze(levelVerbose);
+function formatConfig(config) {
+  if (config === "normal") {
+    return { ...levelNormal };
+  }
+  if (config === "verbose") {
+    return { ...levelVerbose };
+  }
+  return { ...allFalse, ...config };
+}
+__name(formatConfig, "formatConfig");
+var getConfig = /* @__PURE__ */ __name((config, taggable) => {
+  if (!taggable) {
+    return formatConfig(config);
+  }
+  const debugTagConfig = debugTag.extract(taggable);
+  if (debugTagConfig) {
+    const debugTagConfigFormatted = formatConfig(debugTagConfig);
+    return { ...formatConfig(config), ...debugTagConfigFormatted };
+  }
+  return formatConfig(config);
+}, "getConfig");
+
+// src/globals/debug.ts
+var debugLevels = {
+  normal: levelNormal,
+  verbose: levelVerbose
+};
+var debug = {
+  levels: debugLevels
+};
+
 // src/models/TaskRunner.ts
 var TaskRunner = class {
   constructor(store2, eventManager, logger) {
@@ -5331,16 +5469,16 @@ var TaskRunner = class {
     }
     try {
       return await runner(input);
-    } catch (error) {
+    } catch (error2) {
       try {
         await this.store.onUnhandledError({
-          error,
+          error: error2,
           kind: "task",
           source: task2.id
         });
       } catch (_) {
       }
-      throw error;
+      throw error2;
     }
   }
   /**
@@ -5391,7 +5529,7 @@ var MiddlewareManager = class {
    */
   checkLock() {
     if (this.#isLocked) {
-      throw new LockedError("MiddlewareManager");
+      lockedError.throw({ what: "MiddlewareManager" });
     }
   }
   /**
@@ -5509,12 +5647,12 @@ var MiddlewareManager = class {
       if (runnerTask.inputSchema) {
         try {
           rawInput = runnerTask.inputSchema.parse(rawInput);
-        } catch (error) {
-          throw new ValidationError(
-            "Task input",
-            runnerTask.id,
-            error instanceof Error ? error : new Error(String(error))
-          );
+        } catch (error2) {
+          validationError.throw({
+            subject: "Task input",
+            id: runnerTask.id,
+            originalError: error2 instanceof Error ? error2 : new Error(String(error2))
+          });
         }
       }
       const deps = storeTask.computedDependencies;
@@ -5522,8 +5660,12 @@ var MiddlewareManager = class {
       if (runnerTask.resultSchema) {
         try {
           return runnerTask.resultSchema.parse(rawResult);
-        } catch (error) {
-          throw new ValidationError("Task result", runnerTask.id, error);
+        } catch (error2) {
+          validationError.throw({
+            subject: "Task result",
+            id: runnerTask.id,
+            originalError: error2
+          });
         }
       }
       return rawResult;
@@ -5618,12 +5760,12 @@ var MiddlewareManager = class {
       if (resource2.resultSchema) {
         try {
           return resource2.resultSchema.parse(rawValue);
-        } catch (error) {
-          throw new ValidationError(
-            "Resource result",
-            resource2.id,
-            error
-          );
+        } catch (error2) {
+          validationError.throw({
+            subject: "Resource result",
+            id: resource2.id,
+            originalError: error2
+          });
         }
       }
       return rawValue;
@@ -5649,16 +5791,16 @@ var MiddlewareManager = class {
             middleware.config
           );
           return result;
-        } catch (error) {
+        } catch (error2) {
           try {
             await this.store.onUnhandledError({
-              error,
+              error: error2,
               kind: "resourceInit",
               source: resource2.id
             });
           } catch (_) {
           }
-          throw error;
+          throw error2;
         }
       }, "baseMiddlewareRunner");
       const middlewareInterceptors = this.perResourceMiddlewareInterceptors.get(middleware.id) || [];
@@ -5870,7 +6012,7 @@ var LogPrinter = class _LogPrinter {
       _LogPrinter.writers.log(safeStringify(this.normalizeForJson(log), 2));
       return;
     }
-    const { level, source, message, timestamp, error, data, context } = log;
+    const { level, source, message, timestamp, error: error2, data, context } = log;
     const timePart = this.formatTime(timestamp);
     const levelPart = this.formatLevel(level);
     const sourcePart = this.formatSource(source);
@@ -5884,7 +6026,7 @@ var LogPrinter = class _LogPrinter {
     if (message) {
       output.push(...messageLines.map((line) => `${indentation}${line}`));
     }
-    const errorLines = this.formatError(error);
+    const errorLines = this.formatError(error2);
     const dataLines = this.formatData(data);
     const contextLines = this.formatContext(context);
     const detailsExist = errorLines.length > 0 || dataLines.length > 0 || contextLines.length > 0;
@@ -5927,14 +6069,14 @@ var LogPrinter = class _LogPrinter {
     }
     return String(message);
   }
-  formatError(error, indentation = "  ") {
-    if (!error) return [];
+  formatError(error2, indentation = "  ") {
+    if (!error2) return [];
     const lines = [];
     lines.push(
-      `${indentation}${this.colors.gray}\u2570\u2500${this.colors.reset} ${this.colors.error}Error: ${error.name}: ${error.message}${this.colors.reset}`
+      `${indentation}${this.colors.gray}\u2570\u2500${this.colors.reset} ${this.colors.error}Error: ${error2.name}: ${error2.message}${this.colors.reset}`
     );
-    if (error.stack) {
-      const frames = error.stack.split("\n").slice(1);
+    if (error2.stack) {
+      const frames = error2.stack.split("\n").slice(1);
       frames.forEach((frame) => {
         const cleaned = frame.trim().replace(/^at /, "");
         lines.push(
@@ -6085,13 +6227,13 @@ var Logger = class _Logger {
    * Core logging method with structured LogInfo
    */
   async log(level, message, logInfo = {}) {
-    const { source, error, data, ...context } = logInfo;
+    const { source, error: error2, data, ...context } = logInfo;
     const log = {
       level,
       message,
       source: source || this.source,
       timestamp: /* @__PURE__ */ new Date(),
-      error: error ? this.extractErrorInfo(error) : void 0,
+      error: error2 ? this.extractErrorInfo(error2) : void 0,
       data: data || void 0,
       context: { ...this.boundContext, ...context }
     };
@@ -6105,17 +6247,17 @@ var Logger = class _Logger {
       root.printer.print(log);
     }
   }
-  extractErrorInfo(error) {
-    if (error instanceof Error) {
+  extractErrorInfo(error2) {
+    if (error2 instanceof Error) {
       return {
-        name: error.name,
-        message: error.message,
-        stack: error.stack
+        name: error2.name,
+        message: error2.message,
+        stack: error2.stack
       };
     }
     return {
       name: "UnknownError",
-      message: String(error)
+      message: String(error2)
     };
   }
   async info(message, logInfo) {
@@ -6189,14 +6331,14 @@ var Logger = class _Logger {
     for (const listener of this.localListeners) {
       try {
         await listener(log);
-      } catch (error) {
+      } catch (error2) {
         this.print({
           level: "error",
           message: "Error in log listener",
           timestamp: /* @__PURE__ */ new Date(),
           error: {
             name: "ListenerError",
-            message: error instanceof Error ? error.message : String(error)
+            message: error2 instanceof Error ? error2.message : String(error2)
           }
         });
         continue;
@@ -6372,7 +6514,7 @@ var DependencyProcessor = class {
         } else if (Array.isArray(eventDefinition)) {
           for (const ed of eventDefinition) {
             if (this.store.events.get(ed.id) === void 0) {
-              throw new EventNotFoundError(ed.id);
+              eventNotFoundError.throw({ id: ed.id });
             }
           }
           this.eventManager.addListener(eventDefinition, handler, {
@@ -6380,7 +6522,7 @@ var DependencyProcessor = class {
           });
         } else {
           if (this.store.events.get(eventDefinition.id) === void 0) {
-            throw new EventNotFoundError(eventDefinition.id);
+            eventNotFoundError.throw({ id: eventDefinition.id });
           }
           this.eventManager.addListener(eventDefinition, handler, {
             order
@@ -6421,8 +6563,14 @@ var DependencyProcessor = class {
       } else if (isEvent(inner)) {
         const exists = this.store.events.get(inner.id) !== void 0;
         return exists ? this.extractEventDependency(inner, source) : void 0;
+      } else if (isError(inner)) {
+        const exists = this.store.errors.get(inner.id) !== void 0;
+        return exists ? inner : void 0;
+      } else if (isAsyncContext(inner)) {
+        const exists = this.store.asyncContexts.get(inner.id) !== void 0;
+        return exists ? inner : void 0;
       }
-      throw new UnknownItemTypeError(inner);
+      unknownItemTypeError.throw({ item: inner });
     }
     if (isResource(object)) {
       return this.extractResourceDependency(object);
@@ -6430,8 +6578,18 @@ var DependencyProcessor = class {
       return this.extractTaskDependency(object);
     } else if (isEvent(object)) {
       return this.extractEventDependency(object, source);
+    } else if (isError(object)) {
+      if (this.store.errors.get(object.id) === void 0) {
+        dependencyNotFoundError.throw({ key: `Error ${object.id}` });
+      }
+      return object;
+    } else if (isAsyncContext(object)) {
+      if (this.store.asyncContexts.get(object.id) === void 0) {
+        dependencyNotFoundError.throw({ key: `AsyncContext ${object.id}` });
+      }
+      return object;
     } else {
-      throw new UnknownItemTypeError(object);
+      unknownItemTypeError.throw({ item: object });
     }
   }
   /**
@@ -6447,27 +6605,29 @@ var DependencyProcessor = class {
   async extractTaskDependency(object) {
     const storeTask = this.store.tasks.get(object.id);
     if (storeTask === void 0) {
-      throw new DependencyNotFoundError(`Task ${object.id}`);
+      dependencyNotFoundError.throw({ key: `Task ${object.id}` });
     }
-    if (!storeTask.isInitialized) {
+    const st = storeTask;
+    if (!st.isInitialized) {
       const dependencies = object.dependencies;
-      storeTask.computedDependencies = await this.extractDependencies(
+      st.computedDependencies = await this.extractDependencies(
         dependencies,
-        storeTask.task.id
+        st.task.id
       );
-      storeTask.isInitialized = true;
+      st.isInitialized = true;
     }
     return (input) => {
-      return this.taskRunner.run(storeTask.task, input);
+      return this.taskRunner.run(st.task, input);
     };
   }
   async extractResourceDependency(object) {
     const storeResource = this.store.resources.get(object.id);
     if (storeResource === void 0) {
-      throw new DependencyNotFoundError(`Resource ${object.id}`);
+      dependencyNotFoundError.throw({ key: `Resource ${object.id}` });
     }
-    const { resource: resource2, config } = storeResource;
-    if (!storeResource.isInitialized) {
+    const sr = storeResource;
+    const { resource: resource2, config } = sr;
+    if (!sr.isInitialized) {
       if (resource2.init) {
         const depMap = resource2.dependencies || {};
         const raw = await this.extractDependencies(depMap, resource2.id);
@@ -6477,12 +6637,12 @@ var DependencyProcessor = class {
           config,
           wrapped
         );
-        storeResource.context = context;
-        storeResource.value = value;
+        sr.context = context;
+        sr.value = value;
       }
-      storeResource.isInitialized = true;
+      sr.isInitialized = true;
     }
-    return storeResource.value;
+    return sr.value;
   }
 };
 
@@ -6540,12 +6700,12 @@ var EventManager = class {
     if (eventDefinition.payloadSchema) {
       try {
         data = eventDefinition.payloadSchema.parse(data);
-      } catch (error) {
-        throw new ValidationError(
-          "Event payload",
-          eventDefinition.id,
-          error instanceof Error ? error : new Error(String(error))
-        );
+      } catch (error2) {
+        validationError.throw({
+          subject: "Event payload",
+          id: eventDefinition.id,
+          originalError: error2 instanceof Error ? error2 : new Error(String(error2))
+        });
       }
     }
     const frame = { id: eventDefinition.id, source };
@@ -6601,10 +6761,9 @@ var EventManager = class {
           const currentHookId = this.currentHookIdContext.getStore();
           const safeReEmitBySameHook = top.id === frame.id && currentHookId && currentHookId === source;
           if (!safeReEmitBySameHook) {
-            throw new EventCycleError([
-              ...currentStack.slice(cycleStart),
-              frame
-            ]);
+            eventCycleError.throw({
+              path: [...currentStack.slice(cycleStart), frame]
+            });
           }
         }
       }
@@ -6744,7 +6903,7 @@ var EventManager = class {
    */
   checkLock() {
     if (this.#isLocked) {
-      throw new LockedError("EventManager");
+      lockedError.throw({ what: "EventManager" });
     }
   }
   /**
@@ -6900,25 +7059,31 @@ var StoreValidator = class {
   }
   checkIfIDExists(id2) {
     if (this.registry.tasks.has(id2)) {
-      throw new DuplicateRegistrationError("Task", id2);
+      duplicateRegistrationError.throw({ type: "Task", id: id2 });
     }
     if (this.registry.resources.has(id2)) {
-      throw new DuplicateRegistrationError("Resource", id2);
+      duplicateRegistrationError.throw({ type: "Resource", id: id2 });
     }
     if (this.registry.events.has(id2)) {
-      throw new DuplicateRegistrationError("Event", id2);
+      duplicateRegistrationError.throw({ type: "Event", id: id2 });
+    }
+    if (this.registry.errors.has(id2)) {
+      duplicateRegistrationError.throw({ type: "Error", id: id2 });
+    }
+    if (this.registry.asyncContexts.has(id2)) {
+      duplicateRegistrationError.throw({ type: "AsyncContext", id: id2 });
     }
     if (this.registry.taskMiddlewares.has(id2)) {
-      throw new DuplicateRegistrationError("Middleware", id2);
+      duplicateRegistrationError.throw({ type: "Middleware", id: id2 });
     }
     if (this.registry.resourceMiddlewares.has(id2)) {
-      throw new DuplicateRegistrationError("Middleware", id2);
+      duplicateRegistrationError.throw({ type: "Middleware", id: id2 });
     }
     if (this.registry.tags.has(id2)) {
-      throw new DuplicateRegistrationError("Tag", id2);
+      duplicateRegistrationError.throw({ type: "Tag", id: id2 });
     }
     if (this.registry.hooks.has(id2)) {
-      throw new DuplicateRegistrationError("Hook", id2);
+      duplicateRegistrationError.throw({ type: "Hook", id: id2 });
     }
   }
   runSanityChecks() {
@@ -6926,11 +7091,11 @@ var StoreValidator = class {
       const middlewares = task2.task.middleware;
       middlewares.forEach((middlewareAttachment) => {
         if (!this.registry.taskMiddlewares.has(middlewareAttachment.id)) {
-          throw new MiddlewareNotRegisteredError(
-            "task",
-            task2.task.id,
-            middlewareAttachment.id
-          );
+          middlewareNotRegisteredError.throw({
+            type: "task",
+            source: task2.task.id,
+            middlewareId: middlewareAttachment.id
+          });
         }
       });
     }
@@ -6938,11 +7103,11 @@ var StoreValidator = class {
       const middlewares = resource2.resource.middleware;
       middlewares.forEach((middlewareAttachment) => {
         if (!this.registry.resourceMiddlewares.has(middlewareAttachment.id)) {
-          throw new MiddlewareNotRegisteredError(
-            "resource",
-            resource2.resource.id,
-            middlewareAttachment.id
-          );
+          middlewareNotRegisteredError.throw({
+            type: "resource",
+            source: resource2.resource.id,
+            middlewareId: middlewareAttachment.id
+          });
         }
       });
     }
@@ -6966,7 +7131,7 @@ var StoreValidator = class {
       if (tags) {
         for (const tag2 of tags) {
           if (!this.registry.tags.has(tag2.id)) {
-            throw new TagNotFoundError(tag2.id);
+            tagNotFoundError.throw({ id: tag2.id });
           }
         }
       }
@@ -6985,6 +7150,8 @@ var StoreRegistry = class {
     this.resourceMiddlewares = /* @__PURE__ */ new Map();
     this.hooks = /* @__PURE__ */ new Map();
     this.tags = /* @__PURE__ */ new Map();
+    this.asyncContexts = /* @__PURE__ */ new Map();
+    this.errors = /* @__PURE__ */ new Map();
     this.validator = new StoreValidator(this);
   }
   static {
@@ -6996,12 +7163,16 @@ var StoreRegistry = class {
   storeGenericItem(item) {
     if (isTask(item)) {
       this.storeTask(item);
+    } else if (isError(item)) {
+      this.storeError(item);
     } else if (isHook && isHook(item)) {
       this.storeHook(item);
     } else if (isResource(item)) {
       this.storeResource(item);
     } else if (isEvent(item)) {
       this.storeEvent(item);
+    } else if (isAsyncContext(item)) {
+      this.storeAsyncContext(item);
     } else if (isTaskMiddleware(item)) {
       this.storeTaskMiddleware(item);
     } else if (isResourceMiddleware(item)) {
@@ -7011,9 +7182,17 @@ var StoreRegistry = class {
     } else if (isTag(item)) {
       this.storeTag(item);
     } else {
-      throw new UnknownItemTypeError(item);
+      unknownItemTypeError.throw({ item });
     }
   }
+  storeError(item) {
+    this.validator.checkIfIDExists(item.id);
+    this.errors.set(item.id, item);
+  }
+  storeAsyncContext(item) {
+    this.validator.checkIfIDExists(item.id);
+    this.asyncContexts.set(item.id, item);
+  }
   storeTag(item) {
     this.validator.checkIfIDExists(item.id);
     this.tags.set(item.id, item);
@@ -7377,7 +7556,7 @@ var OverrideManager = class {
       }
       if (!hasAnyItem) {
         const id2 = isResourceWithConfig(override) ? override.resource.id : override.id;
-        throw new DependencyNotFoundError(id2);
+        dependencyNotFoundError.throw({ key: id2 });
       }
     }
     for (const override of this.overrides.values()) {
@@ -7430,6 +7609,15 @@ var tunnelResourceMiddleware = defineResourceMiddleware({
       return value;
     }
     for (const t of tasks) {
+      const currentOwner = t[symbolTunneledBy];
+      const resourceId = resource2.definition.id;
+      if (currentOwner && currentOwner !== resourceId) {
+        tunnelOwnershipConflictError.throw({
+          taskId: t.id,
+          currentOwnerId: currentOwner,
+          attemptedOwnerId: resourceId
+        });
+      }
       if (!originalRuns.has(t)) {
         originalRuns.set(t, t.run);
       }
@@ -7437,6 +7625,7 @@ var tunnelResourceMiddleware = defineResourceMiddleware({
         return value.run(t, input);
       });
       t[symbolTunneledTask] = "client";
+      t[symbolTunneledBy] = resourceId;
     }
     if (events.length > 0) {
       const selectedEventIds = new Set(events.map((e) => e.id));
@@ -7524,8 +7713,28 @@ function resolveEvents(store2, selector) {
   return out;
 }
 __name(resolveEvents, "resolveEvents");
+
+// src/utils/detectRunnerMode.ts
+function detectRunnerMode(explicitMode) {
+  if (explicitMode !== void 0) {
+    return explicitMode;
+  }
+  const env = getPlatform().getEnv("NODE_ENV");
+  switch (env) {
+    case "test":
+      return "test" /* TEST */;
+    case "production":
+      return "prod" /* PROD */;
+    case "development":
+    default:
+      return "dev" /* DEV */;
+  }
+}
+__name(detectRunnerMode, "detectRunnerMode");
+
+// src/models/Store.ts
 var Store = class {
-  constructor(eventManager, logger, onUnhandledError) {
+  constructor(eventManager, logger, onUnhandledError, mode) {
     this.eventManager = eventManager;
     this.logger = logger;
     this.onUnhandledError = onUnhandledError;
@@ -7533,6 +7742,7 @@ var Store = class {
     this.validator = this.registry.getValidator();
     this.overrideManager = new OverrideManager(this.registry);
     this.middlewareManager = new MiddlewareManager(this, eventManager, logger);
+    this.mode = detectRunnerMode(mode);
   }
   static {
     __name(this, "Store");
@@ -7552,6 +7762,12 @@ var Store = class {
   get events() {
     return this.registry.events;
   }
+  get errors() {
+    return this.registry.errors;
+  }
+  get asyncContexts() {
+    return this.registry.asyncContexts;
+  }
   get taskMiddlewares() {
     return this.registry.taskMiddlewares;
   }
@@ -7654,19 +7870,19 @@ var Store = class {
     const dependentNodes = this.registry.getDependentNodes();
     const circularDependencies = findCircularDependencies(dependentNodes);
     if (circularDependencies.cycles.length > 0) {
-      throw new CircularDependenciesError(circularDependencies.cycles);
+      circularDependenciesError.throw({ cycles: circularDependencies.cycles });
     }
   }
   validateEventEmissionGraph() {
     const eventNodes = this.registry.buildEventEmissionGraph();
     const circular = findCircularDependencies(eventNodes);
     if (circular.cycles.length > 0) {
-      throw new EventEmissionCycleError(circular.cycles);
+      eventEmissionCycleError.throw({ cycles: circular.cycles });
     }
   }
   initializeStore(root, config) {
     if (this.#isInitialized) {
-      throw new StoreAlreadyInitializedError();
+      storeAlreadyInitializedError.throw({});
     }
     this.registerGlobalComponents();
     this.setupRootResource(root, config);
@@ -7720,68 +7936,6 @@ var Store = class {
   }
 };
 
-// src/globals/resources/debug/types.ts
-var allFalse = Object.freeze({
-  logResourceBeforeRun: false,
-  logResourceAfterRun: false,
-  logMiddlewareBeforeRun: false,
-  logMiddlewareAfterRun: false,
-  logTaskBeforeRun: false,
-  logTaskAfterRun: false,
-  logTaskInput: false,
-  logTaskOutput: false,
-  logResourceConfig: false,
-  logResourceValue: false,
-  logHookTriggered: false,
-  logHookCompleted: false,
-  logEventEmissionOnRun: false,
-  logEventEmissionInput: false
-});
-var levelNormal = Object.freeze({
-  ...allFalse,
-  logTaskAfterRun: true,
-  logTaskBeforeRun: true,
-  logResourceBeforeRun: true,
-  logResourceAfterRun: true,
-  logMiddlewareBeforeRun: true,
-  logMiddlewareAfterRun: true,
-  logHookTriggered: true,
-  logHookCompleted: true,
-  logEventEmissionOnRun: true
-});
-Object.freeze(levelNormal);
-var levelVerbose = Object.freeze({
-  ...levelNormal,
-  logTaskInput: true,
-  logTaskOutput: true,
-  logResourceConfig: true,
-  logResourceValue: true,
-  logHookTriggered: true,
-  logHookCompleted: true
-});
-Object.freeze(levelVerbose);
-function formatConfig(config) {
-  if (config === "normal") {
-    return { ...levelNormal };
-  }
-  if (config === "verbose") {
-    return { ...levelVerbose };
-  }
-  return { ...allFalse, ...config };
-}
-__name(formatConfig, "formatConfig");
-var getConfig = /* @__PURE__ */ __name((config, taggable) => {
-  if (!taggable) {
-    return formatConfig(config);
-  }
-  const debugTagConfig = debugTag.extract(taggable);
-  if (debugTagConfig) {
-    const debugTagConfigFormatted = formatConfig(debugTagConfig);
-    return { ...formatConfig(config), ...debugTagConfigFormatted };
-  }
-  return formatConfig(config);
-}, "getConfig");
-
 // src/globals/resources/debug/debugConfig.resource.ts
 var debugConfig = defineResource({
   id: "globals.debug.resources.config",
@@ -8109,8 +8263,8 @@ __name(registerShutdownHook, "registerShutdownHook");
 
 // src/models/UnhandledError.ts
 function createDefaultUnhandledError(logger) {
-  return async ({ error, kind, source }) => {
-    const normalizedError = error instanceof Error ? error : new Error(String(error));
+  return async ({ error: error2, kind, source }) => {
+    const normalizedError = error2 instanceof Error ? error2 : new Error(String(error2));
     await logger.error(`${normalizedError.toString()}`, {
       source,
       error: normalizedError,
@@ -8122,9 +8276,9 @@ function createDefaultUnhandledError(logger) {
 }
 __name(createDefaultUnhandledError, "createDefaultUnhandledError");
 function bindProcessErrorHandler(handler) {
-  return async (error, source) => {
+  return async (error2, source) => {
     try {
-      await handler({ error, kind: "process", source });
+      await handler({ error: error2, kind: "process", source });
     } catch {
     }
   };
@@ -8157,7 +8311,7 @@ var RunResult = class {
       if (typeof task2 === "string") {
         const taskId = task2;
         if (!this.store.tasks.has(taskId)) {
-          throw new RuntimeError(`Task "${taskId}" not found.`);
+          throw new Error(`Task "${taskId}" not found.`);
         }
         task2 = this.store.tasks.get(taskId).task;
       }
@@ -8172,7 +8326,7 @@ var RunResult = class {
       if (typeof event2 === "string") {
         const eventId = event2;
         if (!this.store.events.has(eventId)) {
-          throw new RuntimeError(`Event "${eventId}" not found.`);
+          throw new Error(`Event "${eventId}" not found.`);
         }
         event2 = this.store.events.get(eventId).event;
       }
@@ -8186,7 +8340,7 @@ var RunResult = class {
     this.getResourceValue = /* @__PURE__ */ __name((resource2) => {
       const resourceId = typeof resource2 === "string" ? resource2 : resource2.id;
       if (!this.store.resources.has(resourceId)) {
-        throw new ResourceNotFoundError(resourceId);
+        throw new Error(`Resource "${resourceId}" not found.`);
       }
       return this.store.resources.get(resourceId).value;
     }, "getResourceValue");
@@ -8203,7 +8357,7 @@ var RunResult = class {
 async function run(resourceOrResourceWithConfig, options) {
   await getPlatform().init();
   const {
-    debug = void 0,
+    debug: debug2 = void 0,
     logs = {},
     errorBoundary = true,
     shutdownHooks = true,
@@ -8259,8 +8413,8 @@ async function run(resourceOrResourceWithConfig, options) {
     }
   }, "disposeAll");
   try {
-    if (debug) {
-      store2.storeGenericItem(debugResource.with(debug));
+    if (debug2) {
+      store2.storeGenericItem(debugResource.with(debug2));
     }
     store2.initializeStore(resource2, config);
     await store2.processOverrides();
@@ -8327,11 +8481,13 @@ var TunnelError = class extends Error {
   static {
     __name(this, "TunnelError");
   }
-  constructor(code, message, details) {
+  constructor(code, message, details, extras) {
     super(message);
     this.name = "TunnelError";
     this.code = code;
     this.details = details;
+    this.id = extras?.id;
+    this.data = extras?.data;
   }
 };
 function toTunnelError(input, fallbackMessage) {
@@ -8341,7 +8497,10 @@ function toTunnelError(input, fallbackMessage) {
   if (input && typeof input === "object" && "code" in input && "message" in input && typeof input.message === "string" && typeof input.code === "string") {
     const pe = input;
     const msg = pe.message || fallbackMessage || "Tunnel error";
-    return new TunnelError(pe.code, msg, pe.details);
+    return new TunnelError(pe.code, msg, pe.details, {
+      id: pe.id,
+      data: pe.data
+    });
   }
   if (input && typeof input === "object" && "message" in input && typeof input.message === "string") {
     return new TunnelError("UNKNOWN", input.message);
@@ -8372,7 +8531,7 @@ function assertOkEnvelope(envelope, opts) {
 __name(assertOkEnvelope, "assertOkEnvelope");
 
 // src/http-fetch-tunnel.resource.ts
-async function postSerialized(fetchFn, url, body, headers, timeoutMs, serializer, onRequest) {
+async function postSerialized(fetchFn, url, body, headers, timeoutMs, serializer, onRequest, contextHeaderText) {
   const controller = timeoutMs && timeoutMs > 0 ? new AbortController() : void 0;
   let timeout;
   try {
@@ -8383,6 +8542,7 @@ async function postSerialized(fetchFn, url, body, headers, timeoutMs, serializer
       "content-type": "application/json; charset=utf-8",
       ...headers
     };
+    if (contextHeaderText) reqHeaders["x-runner-context"] = contextHeaderText;
     if (onRequest) await onRequest({ url, headers: reqHeaders });
     const res = await fetchFn(url, {
       method: "POST",
@@ -8413,6 +8573,20 @@ function createExposureFetch(cfg) {
       "global fetch is not available; provide fetchImpl in config"
     );
   }
+  const buildContextHeader = /* @__PURE__ */ __name(() => {
+    if (!cfg.contexts || cfg.contexts.length === 0) return void 0;
+    const map = {};
+    for (const ctx of cfg.contexts) {
+      try {
+        const v = ctx.use();
+        map[ctx.id] = ctx.serialize(v);
+      } catch {
+      }
+    }
+    const keys = Object.keys(map);
+    if (keys.length === 0) return void 0;
+    return cfg.serializer.stringify(map);
+  }, "buildContextHeader");
   return {
     async task(id2, input) {
       const url = `${baseUrl}/task/${encodeURIComponent(id2)}`;
@@ -8423,9 +8597,19 @@ function createExposureFetch(cfg) {
         buildHeaders(),
         cfg?.timeoutMs,
         cfg.serializer,
-        cfg?.onRequest
+        cfg?.onRequest,
+        buildContextHeader()
       );
-      return assertOkEnvelope(r2, { fallbackMessage: "Tunnel task error" });
+      try {
+        return assertOkEnvelope(r2, { fallbackMessage: "Tunnel task error" });
+      } catch (e) {
+        const te = e;
+        if (te && cfg.errorRegistry && te.id && te.data) {
+          const helper = cfg.errorRegistry.get(String(te.id));
+          if (helper) helper.throw(te.data);
+        }
+        throw e;
+      }
     },
     async event(id2, payload) {
       const url = `${baseUrl}/event/${encodeURIComponent(id2)}`;
@@ -8436,9 +8620,19 @@ function createExposureFetch(cfg) {
         buildHeaders(),
         cfg?.timeoutMs,
         cfg.serializer,
-        cfg?.onRequest
+        cfg?.onRequest,
+        buildContextHeader()
       );
-      assertOkEnvelope(r2, { fallbackMessage: "Tunnel event error" });
+      try {
+        assertOkEnvelope(r2, { fallbackMessage: "Tunnel event error" });
+      } catch (e) {
+        const te = e;
+        if (te && cfg.errorRegistry && te.id && te.data) {
+          const helper = cfg.errorRegistry.get(String(te.id));
+          if (helper) helper.throw(te.data);
+        }
+        throw e;
+      }
     }
   };
 }
@@ -8490,14 +8684,14 @@ function buildTestFacade(deps) {
 __name(buildTestFacade, "buildTestFacade");
 
 // src/definers/builders/resource.ts
-function clone(s, patch) {
+function clone2(s, patch) {
   return Object.freeze({
     // We reuse the frozen state while widening generics, hence the temporary cast.
     ...s,
     ...patch
   });
 }
-__name(clone, "clone");
+__name(clone2, "clone");
 function toRegisterArray(items) {
   return Array.isArray(items) ? [...items] : [items];
 }
@@ -8581,7 +8775,7 @@ function makeResourceBuilder(state) {
     id: state.id,
     dependencies(deps, options) {
       const override = options?.override ?? false;
-      const next = clone(state, {
+      const next = clone2(state, {
         dependencies: mergeDependencies(
           state.dependencies,
           deps,
@@ -8595,50 +8789,50 @@ function makeResourceBuilder(state) {
     },
     register(items, options) {
       const override = options?.override ?? false;
-      const next = clone(state, {
+      const next = clone2(state, {
         register: mergeRegister(state.register, items, override)
       });
       return makeResourceBuilder(next);
     },
     middleware(mw, options) {
       const override = options?.override ?? false;
-      const next = clone(state, {
+      const next = clone2(state, {
         middleware: mergeArray(state.middleware, mw, override)
       });
       return makeResourceBuilder(next);
     },
     tags(tags, options) {
       const override = options?.override ?? false;
-      const next = clone(state, { tags: mergeArray(state.tags, tags, override) });
+      const next = clone2(state, { tags: mergeArray(state.tags, tags, override) });
       return makeResourceBuilder(next);
     },
     context(factory) {
-      const next = clone(state, { context: factory });
+      const next = clone2(state, { context: factory });
       return makeResourceBuilder(next);
     },
     configSchema(schema) {
-      const next = clone(state, { configSchema: schema });
+      const next = clone2(state, { configSchema: schema });
       return makeResourceBuilder(next);
     },
     resultSchema(schema) {
-      const next = clone(state, { resultSchema: schema });
+      const next = clone2(state, { resultSchema: schema });
       return makeResourceBuilder(next);
     },
     init(fn) {
-      const next = clone(state, { init: fn });
+      const next = clone2(state, { init: fn });
       return makeResourceBuilder(next);
     },
     dispose(fn) {
-      const next = clone(state, { dispose: fn });
+      const next = clone2(state, { dispose: fn });
       return makeResourceBuilder(next);
     },
     meta(m) {
-      const next = clone(state, { meta: m });
+      const next = clone2(state, { meta: m });
       return makeResourceBuilder(next);
     },
     overrides(o, options) {
       const override = options?.override ?? false;
-      const next = clone(state, {
+      const next = clone2(state, {
         overrides: mergeArray(state.overrides, o, override)
       });
       return makeResourceBuilder(next);
@@ -8725,16 +8919,16 @@ function mergeDepsNoConfig(existing, addition, override) {
 __name(mergeDepsNoConfig, "mergeDepsNoConfig");
 
 // src/definers/builders/task.phantom.ts
-function clone2(s, patch) {
+function clone3(s, patch) {
   return cloneState(s, patch);
 }
-__name(clone2, "clone");
+__name(clone3, "clone");
 function makePhantomTaskBuilder(state) {
   const builder = {
     id: state.id,
     dependencies(deps, options) {
       const override = options?.override ?? false;
-      const next = clone2(state, {
+      const next = clone3(state, {
         dependencies: mergeDepsNoConfig(
           state.dependencies,
           deps,
@@ -8748,26 +8942,26 @@ function makePhantomTaskBuilder(state) {
     },
     middleware(mw, options) {
       const override = options?.override ?? false;
-      const next = clone2(state, {
+      const next = clone3(state, {
         middleware: mergeArray2(state.middleware, mw, override)
       });
       return makePhantomTaskBuilder(next);
     },
     tags(t, options) {
       const override = options?.override ?? false;
-      const next = clone2(state, { tags: mergeArray2(state.tags, t, override) });
+      const next = clone3(state, { tags: mergeArray2(state.tags, t, override) });
       return makePhantomTaskBuilder(next);
     },
     inputSchema(schema) {
-      const next = clone2(state, { inputSchema: schema });
+      const next = clone3(state, { inputSchema: schema });
       return makePhantomTaskBuilder(next);
     },
     resultSchema(schema) {
-      const next = clone2(state, { resultSchema: schema });
+      const next = clone3(state, { resultSchema: schema });
       return makePhantomTaskBuilder(next);
     },
     meta(m) {
-      const next = clone2(state, { meta: m });
+      const next = clone3(state, { meta: m });
       return makePhantomTaskBuilder(next);
     },
     build() {
@@ -8801,16 +8995,16 @@ function phantomTaskBuilder(id2) {
 __name(phantomTaskBuilder, "phantomTaskBuilder");
 
 // src/definers/builders/task.ts
-function clone3(s, patch) {
+function clone4(s, patch) {
   return cloneState(s, patch);
 }
-__name(clone3, "clone");
+__name(clone4, "clone");
 function makeTaskBuilder(state) {
   const builder = {
     id: state.id,
     dependencies(deps, options) {
       const override = options?.override ?? false;
-      const next = clone3(state, {
+      const next = clone4(state, {
         dependencies: mergeDepsNoConfig(
           state.dependencies,
           deps,
@@ -8824,22 +9018,22 @@ function makeTaskBuilder(state) {
     },
     middleware(mw, options) {
       const override = options?.override ?? false;
-      const next = clone3(state, {
+      const next = clone4(state, {
         middleware: mergeArray2(state.middleware, mw, override)
       });
       return makeTaskBuilder(next);
     },
     tags(t, options) {
       const override = options?.override ?? false;
-      const next = clone3(state, { tags: mergeArray2(state.tags, t, override) });
+      const next = clone4(state, { tags: mergeArray2(state.tags, t, override) });
       return makeTaskBuilder(next);
     },
     inputSchema(schema) {
-      const next = clone3(state, { inputSchema: schema });
+      const next = clone4(state, { inputSchema: schema });
       return makeTaskBuilder(next);
     },
     resultSchema(schema) {
-      const next = clone3(state, { resultSchema: schema });
+      const next = clone4(state, { resultSchema: schema });
       return makeTaskBuilder(next);
     },
     run(fn) {
@@ -8847,11 +9041,11 @@ function makeTaskBuilder(state) {
         input,
         deps
       ), "wrapped");
-      const next = clone3(state, { run: wrapped });
+      const next = clone4(state, { run: wrapped });
       return makeTaskBuilder(next);
     },
     meta(m) {
-      const next = clone3(state, { meta: m });
+      const next = clone4(state, { meta: m });
       return makeTaskBuilder(next);
     },
     build() {
@@ -8882,25 +9076,25 @@ var task = Object.assign(taskBuilder, {
 });
 
 // src/definers/builders/event.ts
-function clone4(s, patch) {
+function clone5(s, patch) {
   return Object.freeze({ ...s, ...patch });
 }
-__name(clone4, "clone");
+__name(clone5, "clone");
 function makeEventBuilder(state) {
   const b = {
     id: state.id,
     payloadSchema(schema) {
-      const next = clone4(state, { payloadSchema: schema });
+      const next = clone5(state, { payloadSchema: schema });
       return makeEventBuilder(next);
     },
     tags(t, options) {
       const override = options?.override ?? false;
       const tags = mergeArray2(state.tags, t, override);
-      const next = clone4(state, { tags });
+      const next = clone5(state, { tags });
       return makeEventBuilder(next);
     },
     meta(m) {
-      const next = clone4(state, { meta: m });
+      const next = clone5(state, { meta: m });
       return makeEventBuilder(next);
     },
     build() {
@@ -8925,21 +9119,21 @@ __name(eventBuilder, "eventBuilder");
 var event = eventBuilder;
 
 // src/definers/builders/hook.ts
-function clone5(s, patch) {
+function clone6(s, patch) {
   return Object.freeze({ ...s, ...patch });
 }
-__name(clone5, "clone");
+__name(clone6, "clone");
 function makeHookBuilder(state) {
   const b = {
     id: state.id,
     on(on) {
-      const next = clone5(state, { on });
+      const next = clone6(state, { on });
       return makeHookBuilder(
         next
       );
     },
     order(order) {
-      const next = clone5(state, { order });
+      const next = clone6(state, { order });
       return makeHookBuilder(next);
     },
     dependencies(deps, options) {
@@ -8966,7 +9160,7 @@ function makeHookBuilder(state) {
         const a = deps;
         merged = { ...e, ...a };
       }
-      const next = clone5(state, { dependencies: merged });
+      const next = clone6(state, { dependencies: merged });
       if (override) {
         return makeHookBuilder(
           next
@@ -8979,17 +9173,17 @@ function makeHookBuilder(state) {
     tags(t, options) {
       const override = options?.override ?? false;
       const tags = mergeArray2(state.tags, t, override);
-      const next = clone5(state, { tags });
+      const next = clone6(state, { tags });
       return makeHookBuilder(next);
     },
     meta(m) {
-      const next = clone5(state, { meta: m });
+      const next = clone6(state, { meta: m });
       return makeHookBuilder(
         next
       );
     },
     run(fn) {
-      const next = clone5(state, { run: fn });
+      const next = clone6(state, { run: fn });
       return makeHookBuilder(next);
     },
     build() {
@@ -9034,7 +9228,10 @@ function makeTaskMiddlewareBuilder(state) {
       } else if (isFnExisting && isFnAddition) {
         const e = state.dependencies;
         const a = deps;
-        merged = /* @__PURE__ */ __name(((cfg) => ({ ...e(cfg), ...a(cfg) })), "merged");
+        merged = /* @__PURE__ */ __name(((cfg) => ({
+          ...e(cfg),
+          ...a(cfg)
+        })), "merged");
       } else if (isFnExisting && !isFnAddition) {
         const e = state.dependencies;
         const a = deps;
@@ -9121,7 +9318,10 @@ function makeResourceMiddlewareBuilder(state) {
       } else if (isFnExisting && isFnAddition) {
         const e = state.dependencies;
         const a = deps;
-        merged = /* @__PURE__ */ __name(((cfg) => ({ ...e(cfg), ...a(cfg) })), "merged");
+        merged = /* @__PURE__ */ __name(((cfg) => ({
+          ...e(cfg),
+          ...a(cfg)
+        })), "merged");
       } else if (isFnExisting && !isFnAddition) {
         const e = state.dependencies;
         const a = deps;
@@ -9195,25 +9395,25 @@ var taskMiddleware = taskMiddlewareBuilder;
 var resourceMiddleware = resourceMiddlewareBuilder;
 
 // src/definers/builders/tag.ts
-function clone6(s, patch) {
+function clone7(s, patch) {
   return Object.freeze({ ...s, ...patch });
 }
-__name(clone6, "clone");
+__name(clone7, "clone");
 function makeTagBuilder(state) {
   const b = {
     id: state.id,
     meta(m) {
-      const next = clone6(state, { meta: m });
+      const next = clone7(state, { meta: m });
       return makeTagBuilder(next);
     },
     configSchema(schema) {
-      const next = clone6(state, { configSchema: schema });
+      const next = clone7(state, { configSchema: schema });
       return makeTagBuilder(
         next
       );
     },
     config(config) {
-      const next = clone6(state, { config });
+      const next = clone7(state, { config });
       return makeTagBuilder(
         next
       );
@@ -9244,6 +9444,51 @@ function tagBuilder(id2) {
 __name(tagBuilder, "tagBuilder");
 var tag = tagBuilder;
 
+// src/definers/builders/asyncContext.ts
+function clone8(s, patch) {
+  return Object.freeze({ ...s, ...patch });
+}
+__name(clone8, "clone");
+function makeAsyncContextBuilder(state) {
+  const b = {
+    id: state.id,
+    serialize(fn) {
+      const next = clone8(state, { serialize: fn });
+      return makeAsyncContextBuilder(next);
+    },
+    parse(fn) {
+      const next = clone8(state, { parse: fn });
+      return makeAsyncContextBuilder(next);
+    },
+    configSchema(schema) {
+      const next = clone8(state, { configSchema: schema });
+      return makeAsyncContextBuilder(next);
+    },
+    build() {
+      const def = {
+        id: state.id,
+        serialize: state.serialize,
+        parse: state.parse,
+        configSchema: state.configSchema
+      };
+      return defineAsyncContext(def);
+    }
+  };
+  return b;
+}
+__name(makeAsyncContextBuilder, "makeAsyncContextBuilder");
+function asyncContextBuilder(id2) {
+  const initial = Object.freeze({
+    id: id2,
+    serialize: void 0,
+    parse: void 0,
+    configSchema: void 0
+  });
+  return makeAsyncContextBuilder(initial);
+}
+__name(asyncContextBuilder, "asyncContextBuilder");
+var asyncContext = asyncContextBuilder;
+
 // src/models/Semaphore.ts
 var Semaphore = class {
   constructor(maxPermits) {
@@ -9294,9 +9539,9 @@ var Semaphore = class {
           options.signal.removeEventListener("abort", abortHandler);
           originalResolve();
         };
-        operation.reject = (error) => {
+        operation.reject = (error2) => {
           options.signal.removeEventListener("abort", abortHandler);
-          originalReject(error);
+          originalReject(error2);
         };
       }
       this.waitingQueue.push(operation);
@@ -9397,14 +9642,18 @@ var globals = {
   resources: globalResources,
   middleware: globalMiddlewares,
   tags: globalTags,
-  tunnels
+  tunnels,
+  debug
 };
+var createContext2 = createContext;
 var r = Object.freeze({
   resource,
   task,
   event,
   hook,
   tag,
+  asyncContext,
+  error,
   middleware: Object.freeze({
     task: taskMiddleware,
     resource: resourceMiddleware
@@ -9427,12 +9676,17 @@ function jsonOkResponse(data = {}) {
   return { status: 200, body: { ok: true, ...data } };
 }
 __name(jsonOkResponse, "jsonOkResponse");
-function jsonErrorResponse(status, message, code) {
-  const error = { message };
+function jsonErrorResponse(status, message, code, extra) {
+  const error2 = { message };
   if (code) {
-    error.code = code;
+    error2.code = code;
+  }
+  if (extra && typeof extra === "object") {
+    for (const [k, v] of Object.entries(extra)) {
+      error2[k] = v;
+    }
   }
-  return { status, body: { ok: false, error } };
+  return { status, body: { ok: false, error: error2 } };
 }
 __name(jsonErrorResponse, "jsonErrorResponse");
 function respondJson(res, response, serializer) {
@@ -9649,8 +9903,8 @@ function safeLogInfo(logger, message, data) {
   }
 }
 __name(safeLogInfo, "safeLogInfo");
-function errorMessage(error) {
-  return error instanceof Error ? error.message : String(error);
+function errorMessage(error2) {
+  return error2 instanceof Error ? error2.message : String(error2);
 }
 __name(errorMessage, "errorMessage");
 
@@ -9662,9 +9916,9 @@ function makeRequestListener(options) {
       if (!handled && respondOnMiss && !res.writableEnded) {
         respondJson(res, NOT_FOUND_RESPONSE);
       }
-    }).catch((error) => {
+    }).catch((error2) => {
       safeLogError(logger, "exposure.http.unhandled", {
-        error: errorMessage(error)
+        error: errorMessage(error2)
       });
       if (!res.writableEnded) {
         respondJson(
@@ -10073,7 +10327,14 @@ async function readRequestBody(req, signal) {
       if (aborted) return;
       aborted = true;
       cleanup();
-      reject(new CancellationError("Request aborted"));
+      const err = (() => {
+        try {
+          cancellationError.throw({ reason: "Request aborted" });
+        } catch (e) {
+          return e;
+        }
+      })();
+      reject(err);
     }, "onAbort");
     const onError = /* @__PURE__ */ __name((err) => {
       cleanup();
@@ -10192,9 +10453,9 @@ function trimTrailingSlash(path3) {
 __name(trimTrailingSlash, "trimTrailingSlash");
 
 // src/node/exposure/requestContext.ts
-var ExposureRequestContext = createContext(
-  "platform.node.exposure.request"
-);
+var ExposureRequestContext = defineAsyncContext({
+  id: "platform.node.exposure.request"
+});
 function useExposureContext() {
   return ExposureRequestContext.use();
 }
@@ -10322,7 +10583,16 @@ function createAbortControllerForRequest(req, res) {
   const controller = new AbortController();
   const onAbort = /* @__PURE__ */ __name(() => {
     try {
-      controller.abort(new CancellationError("Client Closed Request"));
+      controller.abort(
+        // pass a typed error instance
+        (() => {
+          try {
+            cancellationError.throw({ reason: "Client Closed Request" });
+          } catch (e) {
+            return e;
+          }
+        })()
+      );
     } catch {
     }
   }, "onAbort");
@@ -10376,18 +10646,43 @@ function createRequestHandlers(deps) {
     try {
       const contentType = getContentType(req.headers);
       const url = requestUrl(req);
-      const provide = /* @__PURE__ */ __name((fn) => ExposureRequestContext.provide(
-        {
-          req,
-          res,
-          url,
-          basePath: router.basePath,
-          headers: req.headers,
-          method: req.method,
-          signal: controller.signal
-        },
-        fn
-      ), "provide");
+      const buildProvider = /* @__PURE__ */ __name((fn) => {
+        const rawHeader = req.headers["x-runner-context"];
+        let headerText;
+        if (Array.isArray(rawHeader)) headerText = rawHeader[0];
+        else if (typeof rawHeader === "string") headerText = rawHeader;
+        let userWrapped = fn;
+        if (headerText) {
+          try {
+            const map = serializer.parse(headerText);
+            for (const [id2, ctx] of store2.asyncContexts.entries()) {
+              const raw = map[id2];
+              if (typeof raw === "string") {
+                try {
+                  const value = ctx.parse(raw);
+                  const prev = userWrapped;
+                  userWrapped = /* @__PURE__ */ __name(async () => await ctx.provide(value, prev), "userWrapped");
+                } catch {
+                }
+              }
+            }
+          } catch {
+          }
+        }
+        const run2 = /* @__PURE__ */ __name(() => ExposureRequestContext.provide(
+          {
+            req,
+            res,
+            url,
+            basePath: router.basePath,
+            headers: req.headers,
+            method: req.method,
+            signal: controller.signal
+          },
+          userWrapped
+        ), "run");
+        return run2();
+      }, "buildProvider");
       if (isMultipart(contentType)) {
         const multipart = await parseMultipartInput(
           req,
@@ -10403,7 +10698,7 @@ function createRequestHandlers(deps) {
         let taskError = void 0;
         let taskResult;
         try {
-          taskResult = await provide(
+          taskResult = await buildProvider(
             () => taskRunner.run(storeTask.task, multipart.value)
           );
         } catch (err) {
@@ -10436,7 +10731,7 @@ function createRequestHandlers(deps) {
         return;
       }
       if (/^application\/octet-stream(?:;|$)/i.test(contentType)) {
-        const result2 = await provide(
+        const result2 = await buildProvider(
           () => taskRunner.run(storeTask.task, void 0)
         );
         if (!res.writableEnded && result2 && typeof result2.pipe === "function") {
@@ -10476,7 +10771,7 @@ function createRequestHandlers(deps) {
         }
         return body.value;
       })();
-      const result = await provide(
+      const result = await buildProvider(
         () => taskRunner.run(storeTask.task, payload)
       );
       if (!res.writableEnded && result && typeof result.pipe === "function") {
@@ -10492,8 +10787,8 @@ function createRequestHandlers(deps) {
       if (res.writableEnded || res.headersSent) return;
       applyCorsActual(req, res, cors);
       respondJson(res, jsonOkResponse({ result }), serializer);
-    } catch (error) {
-      if (isCancellationError(error)) {
+    } catch (error2) {
+      if (isCancellationError(error2)) {
         if (!res.writableEnded && !res.headersSent) {
           applyCorsActual(req, res, cors);
           respondJson(
@@ -10504,15 +10799,26 @@ function createRequestHandlers(deps) {
         }
         return;
       }
-      const logMessage = errorMessage(error);
-      const displayMessage = error instanceof Error && error.message ? error.message : "Internal Error";
+      let appErrorExtra;
+      try {
+        for (const helper of store2.errors.values()) {
+          if (helper.is(error2)) {
+            const errAny = error2;
+            appErrorExtra = { id: errAny?.name, data: errAny?.data };
+            break;
+          }
+        }
+      } catch {
+      }
+      const logMessage = errorMessage(error2);
+      const displayMessage = error2 instanceof Error && error2.message ? error2.message : "Internal Error";
       safeLogError(logger, "exposure.task.error", {
         error: logMessage
       });
       applyCorsActual(req, res, cors);
       respondJson(
         res,
-        jsonErrorResponse(500, displayMessage, "INTERNAL_ERROR"),
+        jsonErrorResponse(500, displayMessage, "INTERNAL_ERROR", appErrorExtra),
         serializer
       );
     }
@@ -10556,15 +10862,39 @@ function createRequestHandlers(deps) {
         respondJson(res, body.response, serializer);
         return;
       }
-      await eventManager.emit(
-        storeEvent.event,
-        body.value?.payload,
-        "exposure:http"
-      );
+      const rawHeader = req.headers["x-runner-context"];
+      let headerText;
+      if (Array.isArray(rawHeader)) headerText = rawHeader[0];
+      else if (typeof rawHeader === "string") headerText = rawHeader;
+      let runEmit = /* @__PURE__ */ __name(async () => {
+        await eventManager.emit(
+          storeEvent.event,
+          body.value?.payload,
+          "exposure:http"
+        );
+      }, "runEmit");
+      if (headerText) {
+        try {
+          const map = serializer.parse(headerText);
+          for (const [id2, ctx] of store2.asyncContexts.entries()) {
+            const raw = map[id2];
+            if (typeof raw === "string") {
+              try {
+                const value = ctx.parse(raw);
+                const prev = runEmit;
+                runEmit = /* @__PURE__ */ __name(async () => await ctx.provide(value, prev), "runEmit");
+              } catch {
+              }
+            }
+          }
+        } catch {
+        }
+      }
+      await runEmit();
       applyCorsActual(req, res, cors);
       respondJson(res, jsonOkResponse(), serializer);
-    } catch (error) {
-      if (isCancellationError(error)) {
+    } catch (error2) {
+      if (isCancellationError(error2)) {
         if (!res.writableEnded && !res.headersSent) {
           applyCorsActual(req, res, cors);
           respondJson(
@@ -10575,15 +10905,26 @@ function createRequestHandlers(deps) {
         }
         return;
       }
-      const logMessage = errorMessage(error);
-      const displayMessage = error instanceof Error && error.message ? error.message : "Internal Error";
+      let appErrorExtra;
+      try {
+        for (const helper of store2.errors.values()) {
+          if (helper.is(error2)) {
+            const errAny = error2;
+            appErrorExtra = { id: errAny?.name, data: errAny?.data };
+            break;
+          }
+        }
+      } catch {
+      }
+      const logMessage = errorMessage(error2);
+      const displayMessage = error2 instanceof Error && error2.message ? error2.message : "Internal Error";
       safeLogError(logger, "exposure.event.error", {
         error: logMessage
       });
       applyCorsActual(req, res, cors);
       respondJson(
         res,
-        jsonErrorResponse(500, displayMessage, "INTERNAL_ERROR"),
+        jsonErrorResponse(500, displayMessage, "INTERNAL_ERROR", appErrorExtra),
         serializer
       );
     }
@@ -10819,6 +11160,19 @@ async function postJson(cfg, url, body) {
     "content-type": "application/json; charset=utf-8",
     ...toHeaders(cfg.auth)
   };
+  if (cfg.contexts && cfg.contexts.length > 0) {
+    const map = {};
+    for (const ctx of cfg.contexts) {
+      try {
+        const v = ctx.use();
+        map[ctx.id] = ctx.serialize(v);
+      } catch {
+      }
+    }
+    if (Object.keys(map).length > 0) {
+      headers["x-runner-context"] = cfg.serializer.stringify(map);
+    }
+  }
   if (cfg.onRequest) await cfg.onRequest({ url, headers });
   return await new Promise((resolve, reject) => {
     const req = lib.request(
@@ -10908,6 +11262,19 @@ async function postMultipart(cfg, url, manifestText, files) {
     "content-type": `multipart/form-data; boundary=${boundary}`,
     ...toHeaders(cfg.auth)
   };
+  if (cfg.contexts && cfg.contexts.length > 0) {
+    const map = {};
+    for (const ctx of cfg.contexts) {
+      try {
+        const v = ctx.use();
+        map[ctx.id] = ctx.serialize(v);
+      } catch {
+      }
+    }
+    if (Object.keys(map).length > 0) {
+      headers["x-runner-context"] = cfg.serializer.stringify(map);
+    }
+  }
   if (cfg.onRequest) await cfg.onRequest({ url, headers });
   return await new Promise(
     (resolve, reject) => {
@@ -10937,6 +11304,19 @@ async function postOctetStream(cfg, url, stream) {
     "content-type": "application/octet-stream",
     ...toHeaders(cfg.auth)
   };
+  if (cfg.contexts && cfg.contexts.length > 0) {
+    const map = {};
+    for (const ctx of cfg.contexts) {
+      try {
+        const v = ctx.use();
+        map[ctx.id] = ctx.serialize(v);
+      } catch {
+      }
+    }
+    if (Object.keys(map).length > 0) {
+      headers["x-runner-context"] = cfg.serializer.stringify(map);
+    }
+  }
   if (cfg.onRequest) await cfg.onRequest({ url, headers });
   return await new Promise(
     (resolve, reject) => {
@@ -10947,10 +11327,10 @@ async function postOctetStream(cfg, url, stream) {
         cleanup.forEach((fn) => fn());
         resolve(value);
       }, "resolveOnce");
-      const rejectOnce = /* @__PURE__ */ __name((error) => {
+      const rejectOnce = /* @__PURE__ */ __name((error2) => {
         settled = true;
         cleanup.forEach((fn) => fn());
-        reject(error);
+        reject(error2);
       }, "rejectOnce");
       const req = lib.request(
         {
@@ -11094,6 +11474,6 @@ async function writeInputFileToPath(file, targetPath) {
 }
 __name(writeInputFileToPath, "writeInputFileToPath");
 
-export { DependencyProcessor, errors_exports as Errors, EventManager, Logger, MiddlewareManager, PlatformAdapter, Queue, ResourceInitializer, RunResult, Semaphore, Store, TaskRunner, allFalse, bindProcessErrorHandler, createContext, createDefaultUnhandledError, createHttpSmartClient, createNodeFile, createTestResource, defs_exports as definitions, defineEvent as event, getConfig, globals, hasExposureContext, defineHook as hook, levelNormal, levelVerbose, nodeExposure, defineOverride as override, r, readInputFileToBuffer, defineResource as resource, defineResourceMiddleware as resourceMiddleware, run, safeReportUnhandledError, setPlatform, defineTag as tag, defineTask as task, defineTaskMiddleware as taskMiddleware, useExposureContext, writeInputFileToPath };
+export { DependencyProcessor, errors_exports as Errors, EventManager, Logger, MiddlewareManager, PlatformAdapter, Queue, ResourceInitializer, RunResult, Semaphore, Store, TaskRunner, allFalse, defineAsyncContext as asyncContext, bindProcessErrorHandler, createContext2 as createContext, createDefaultUnhandledError, createHttpSmartClient, createNodeFile, createTestResource, debug, debugLevels, defs_exports as definitions, defineEvent as event, getConfig, globals, hasExposureContext, defineHook as hook, levelNormal, levelVerbose, nodeExposure, defineOverride as override, r, readInputFileToBuffer, defineResource as resource, defineResourceMiddleware as resourceMiddleware, run, safeReportUnhandledError, setPlatform, defineTag as tag, defineTask as task, defineTaskMiddleware as taskMiddleware, useExposureContext, writeInputFileToPath };
 //# sourceMappingURL=node.mjs.map
 //# sourceMappingURL=node.mjs.map