@bluelibs/runner 4.7.0 → 4.8.0

package/dist/node/node.cjs

@@ -3812,8 +3812,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,
@@ -3828,6 +3831,7 @@ __export(defs_exports, {
   symbolTagConfigured: () => symbolTagConfigured,
   symbolTask: () => symbolTask,
   symbolTaskMiddleware: () => symbolTaskMiddleware,
+  symbolTunneledBy: () => symbolTunneledBy,
   symbolTunneledTask: () => symbolTunneledTask
 });
 
@@ -3841,6 +3845,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"
@@ -3854,6 +3859,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(
@@ -3863,6 +3871,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) {
@@ -3873,6 +3884,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) => {
@@ -4017,26 +4036,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');
@@ -4160,7 +4276,7 @@ var BrowserPlatformAdapter = class {
     };
   }
   exit() {
-    throw new PlatformUnsupportedFunction("exit");
+    platformUnsupportedFunctionError.throw({ functionName: "exit" });
   }
   getEnv(key) {
     const g = globalThis;
@@ -4176,10 +4292,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")
     };
   }
@@ -4255,7 +4375,7 @@ var GenericUniversalPlatformAdapter = class {
     };
   }
   exit() {
-    throw new PlatformUnsupportedFunction("exit");
+    platformUnsupportedFunctionError.throw({ functionName: "exit" });
   }
   getEnv(key) {
     const g = globalThis;
@@ -4271,10 +4391,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")
     };
   }
@@ -4471,198 +4595,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");
 
@@ -4687,12 +4703,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 {
@@ -4753,12 +4769,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({
@@ -4794,12 +4810,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({
@@ -4851,8 +4867,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;
@@ -4953,6 +4973,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({
@@ -4967,29 +4995,45 @@ var requireContextTaskMiddleware = defineTaskMiddleware({
     return next(task2?.input);
   }
 });
+var EjsonSerializer = {
+  stringify(value) {
+    return ejson.EJSON.stringify(value);
+  },
+  parse(text) {
+    return ejson.EJSON.parse(text);
+  },
+  addType(name, factory) {
+    ejson.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();
@@ -4997,16 +5041,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
@@ -5221,10 +5288,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) {
@@ -5245,10 +5312,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) {
@@ -5268,17 +5335,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);
@@ -5294,17 +5361,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);
@@ -5330,6 +5397,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) {
@@ -5356,16 +5494,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;
     }
   }
   /**
@@ -5416,7 +5554,7 @@ var MiddlewareManager = class {
    */
   checkLock() {
     if (this.#isLocked) {
-      throw new LockedError("MiddlewareManager");
+      lockedError.throw({ what: "MiddlewareManager" });
     }
   }
   /**
@@ -5534,12 +5672,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;
@@ -5547,8 +5685,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;
@@ -5643,12 +5785,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;
@@ -5674,16 +5816,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) || [];
@@ -5895,7 +6037,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);
@@ -5909,7 +6051,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;
@@ -5952,14 +6094,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(
@@ -6110,13 +6252,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 }
     };
@@ -6130,17 +6272,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) {
@@ -6214,14 +6356,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;
@@ -6397,7 +6539,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, {
@@ -6405,7 +6547,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
@@ -6446,8 +6588,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);
@@ -6455,8 +6603,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 });
     }
   }
   /**
@@ -6472,27 +6630,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);
@@ -6502,12 +6662,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;
   }
 };
 
@@ -6565,12 +6725,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 };
@@ -6626,10 +6786,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]
+            });
           }
         }
       }
@@ -6769,7 +6928,7 @@ var EventManager = class {
    */
   checkLock() {
     if (this.#isLocked) {
-      throw new LockedError("EventManager");
+      lockedError.throw({ what: "EventManager" });
     }
   }
   /**
@@ -6925,25 +7084,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() {
@@ -6951,11 +7116,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
+          });
         }
       });
     }
@@ -6963,11 +7128,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
+          });
         }
       });
     }
@@ -6991,7 +7156,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 });
           }
         }
       }
@@ -7010,6 +7175,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 {
@@ -7021,12 +7188,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)) {
@@ -7036,9 +7207,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);
@@ -7402,7 +7581,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()) {
@@ -7455,6 +7634,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);
       }
@@ -7462,6 +7650,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));
@@ -7549,8 +7738,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;
@@ -7558,6 +7767,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");
@@ -7577,6 +7787,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;
   }
@@ -7679,19 +7895,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);
@@ -7745,68 +7961,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",
@@ -8134,8 +8288,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,
@@ -8147,9 +8301,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 {
     }
   };
@@ -8182,7 +8336,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;
       }
@@ -8197,7 +8351,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;
       }
@@ -8211,7 +8365,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");
@@ -8228,7 +8382,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,
@@ -8284,8 +8438,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();
@@ -8352,11 +8506,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) {
@@ -8366,7 +8522,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);
@@ -8397,7 +8556,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 {
@@ -8408,6 +8567,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",
@@ -8438,6 +8598,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)}`;
@@ -8448,9 +8622,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)}`;
@@ -8461,9 +8645,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;
+      }
     }
   };
 }
@@ -8515,14 +8709,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];
 }
@@ -8606,7 +8800,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,
@@ -8620,50 +8814,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);
@@ -8750,16 +8944,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,
@@ -8773,26 +8967,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() {
@@ -8826,16 +9020,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,
@@ -8849,22 +9043,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) {
@@ -8872,11 +9066,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() {
@@ -8907,25 +9101,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() {
@@ -8950,21 +9144,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) {
@@ -8991,7 +9185,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
@@ -9004,17 +9198,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() {
@@ -9059,7 +9253,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;
@@ -9146,7 +9343,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;
@@ -9220,25 +9420,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
       );
@@ -9269,6 +9469,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) {
@@ -9319,9 +9564,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);
@@ -9422,14 +9667,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
@@ -9452,12 +9701,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) {
@@ -9674,8 +9928,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");
 
@@ -9687,9 +9941,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(
@@ -10098,7 +10352,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();
@@ -10217,9 +10478,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();
 }
@@ -10347,7 +10608,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");
@@ -10401,18 +10671,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,
@@ -10428,7 +10723,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) {
@@ -10461,7 +10756,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") {
@@ -10501,7 +10796,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") {
@@ -10517,8 +10812,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(
@@ -10529,15 +10824,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
       );
     }
@@ -10581,15 +10887,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(
@@ -10600,15 +10930,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
       );
     }
@@ -10844,6 +11185,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(
@@ -10933,6 +11287,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) => {
@@ -10962,6 +11329,19 @@ async function postOctetStream(cfg, url, stream$1) {
     "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) => {
@@ -10972,10 +11352,10 @@ async function postOctetStream(cfg, url, stream$1) {
         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(
         {
@@ -11136,12 +11516,15 @@ exports.Semaphore = Semaphore;
 exports.Store = Store;
 exports.TaskRunner = TaskRunner;
 exports.allFalse = allFalse;
+exports.asyncContext = defineAsyncContext;
 exports.bindProcessErrorHandler = bindProcessErrorHandler;
-exports.createContext = createContext;
+exports.createContext = createContext2;
 exports.createDefaultUnhandledError = createDefaultUnhandledError;
 exports.createHttpSmartClient = createHttpSmartClient;
 exports.createNodeFile = createNodeFile;
 exports.createTestResource = createTestResource;
+exports.debug = debug;
+exports.debugLevels = debugLevels;
 exports.definitions = defs_exports;
 exports.event = defineEvent;
 exports.getConfig = getConfig;