@bluelibs/runner 5.0.0 → 5.2.0

package/dist/node/node.mjs

@@ -2639,10 +2639,10 @@ var require_bom_handling = __commonJS({
 // node_modules/raw-body/node_modules/iconv-lite/lib/helpers/merge-exports.js
 var require_merge_exports = __commonJS({
   "node_modules/raw-body/node_modules/iconv-lite/lib/helpers/merge-exports.js"(exports, module) {
-    var hasOwn2 = typeof Object.hasOwn === "undefined" ? Function.call.bind(Object.prototype.hasOwnProperty) : Object.hasOwn;
+    var hasOwn3 = typeof Object.hasOwn === "undefined" ? Function.call.bind(Object.prototype.hasOwnProperty) : Object.hasOwn;
     function mergeModules(target, module2) {
       for (var key in module2) {
-        if (hasOwn2(module2, key)) {
+        if (hasOwn3(module2, key)) {
           target[key] = module2[key];
         }
       }
@@ -6613,10 +6613,10 @@ var require_bom_handling2 = __commonJS({
 // node_modules/body-parser/node_modules/iconv-lite/lib/helpers/merge-exports.js
 var require_merge_exports2 = __commonJS({
   "node_modules/body-parser/node_modules/iconv-lite/lib/helpers/merge-exports.js"(exports, module) {
-    var hasOwn2 = typeof Object.hasOwn === "undefined" ? Function.call.bind(Object.prototype.hasOwnProperty) : Object.hasOwn;
+    var hasOwn3 = typeof Object.hasOwn === "undefined" ? Function.call.bind(Object.prototype.hasOwnProperty) : Object.hasOwn;
     function mergeModules(target, module2) {
       for (var key in module2) {
-        if (hasOwn2(module2, key)) {
+        if (hasOwn3(module2, key)) {
           target[key] = module2[key];
         }
       }
@@ -20940,11 +20940,11 @@ var require_object_inspect = __commonJS({
       return false;
     }
     __name(isBigInt, "isBigInt");
-    var hasOwn2 = Object.prototype.hasOwnProperty || function(key) {
+    var hasOwn3 = Object.prototype.hasOwnProperty || function(key) {
       return key in this;
     };
     function has(obj, key) {
-      return hasOwn2.call(obj, key);
+      return hasOwn3.call(obj, key);
     }
     __name(has, "has");
     function toStr(obj) {
@@ -21927,7 +21927,7 @@ var require_get_intrinsic = __commonJS({
       "%WeakSetPrototype%": ["WeakSet", "prototype"]
     };
     var bind = require_function_bind();
-    var hasOwn2 = require_hasown();
+    var hasOwn3 = require_hasown();
     var $concat = bind.call($call, Array.prototype.concat);
     var $spliceApply = bind.call($apply, Array.prototype.splice);
     var $replace = bind.call($call, String.prototype.replace);
@@ -21952,11 +21952,11 @@ var require_get_intrinsic = __commonJS({
     var getBaseIntrinsic = /* @__PURE__ */ __name(function getBaseIntrinsic2(name, allowMissing) {
       var intrinsicName = name;
       var alias;
-      if (hasOwn2(LEGACY_ALIASES, intrinsicName)) {
+      if (hasOwn3(LEGACY_ALIASES, intrinsicName)) {
         alias = LEGACY_ALIASES[intrinsicName];
         intrinsicName = "%" + alias[0] + "%";
       }
-      if (hasOwn2(INTRINSICS, intrinsicName)) {
+      if (hasOwn3(INTRINSICS, intrinsicName)) {
         var value = INTRINSICS[intrinsicName];
         if (value === needsEval) {
           value = doEval(intrinsicName);
@@ -22005,7 +22005,7 @@ var require_get_intrinsic = __commonJS({
         }
         intrinsicBaseName += "." + part;
         intrinsicRealName = "%" + intrinsicBaseName + "%";
-        if (hasOwn2(INTRINSICS, intrinsicRealName)) {
+        if (hasOwn3(INTRINSICS, intrinsicRealName)) {
           value = INTRINSICS[intrinsicRealName];
         } else if (value != null) {
           if (!(part in value)) {
@@ -22023,7 +22023,7 @@ var require_get_intrinsic = __commonJS({
               value = value[part];
             }
           } else {
-            isOwn = hasOwn2(value, part);
+            isOwn = hasOwn3(value, part);
             value = value[part];
           }
           if (isOwn && !skipFurtherCaching) {
@@ -28588,6 +28588,9 @@ var symbolPhantomTask = Symbol.for(
   "runner.task.phantom"
 );
 var symbolResource = Symbol.for("runner.resource");
+var symbolResourceForkedFrom = Symbol.for(
+  "runner.resourceForkedFrom"
+);
 var symbolResourceWithConfig = Symbol.for(
   "runner.resourceWithConfig"
 );
@@ -28617,88 +28620,227 @@ var symbolAsyncContext = Symbol.for(
   "runner.asyncContext"
 );
 
-// src/platform/adapters/node-als.ts
-async function loadAsyncLocalStorageClass() {
-  const mod = __require("async_hooks");
-  return mod.AsyncLocalStorage;
+// src/tools/getCallerFile.ts
+function isNodeInline() {
+  return typeof process !== "undefined" && typeof process?.versions?.node === "string";
 }
-__name(loadAsyncLocalStorageClass, "loadAsyncLocalStorageClass");
-
-// src/platform/adapters/node.ts
-var NodePlatformAdapter = class {
-  constructor() {
-    this.id = "node";
-    this.setTimeout = globalThis.setTimeout;
-    this.clearTimeout = globalThis.clearTimeout;
-  }
-  static {
-    __name(this, "NodePlatformAdapter");
-  }
-  async init() {
-    this.alsClass = await loadAsyncLocalStorageClass();
-  }
-  onUncaughtException(handler) {
-    const h = /* @__PURE__ */ __name((error2) => handler(error2), "h");
-    process.on("uncaughtException", h);
-    return () => process.off("uncaughtException", h);
-  }
-  onUnhandledRejection(handler) {
-    const h = /* @__PURE__ */ __name((reason) => handler(reason), "h");
-    process.on("unhandledRejection", h);
-    return () => process.off("unhandledRejection", h);
-  }
-  onShutdownSignal(handler) {
-    process.on("SIGINT", handler);
-    process.on("SIGTERM", handler);
-    return () => {
-      process.off("SIGINT", handler);
-      process.off("SIGTERM", handler);
-    };
-  }
-  exit(code) {
-    process.exit(code);
-  }
-  getEnv(key) {
-    return process.env[key];
-  }
-  hasAsyncLocalStorage() {
-    return true;
+__name(isNodeInline, "isNodeInline");
+function getCallerFile() {
+  const originalPrepare = Error.prepareStackTrace;
+  try {
+    if (isNodeInline()) {
+      const err = new Error();
+      Error.prepareStackTrace = (_err, stack2) => stack2;
+      const stack = err.stack;
+      stack.shift();
+      stack.shift();
+      const candidate = stack.shift();
+      const file = candidate?.getFileName?.();
+      return file;
+    }
+    return "unknown";
+  } finally {
+    Error.prepareStackTrace = originalPrepare;
   }
-  createAsyncLocalStorage() {
-    let instance;
-    const ensure = /* @__PURE__ */ __name(() => {
-      if (!this.alsClass) {
-        let als;
-        const forceNoop = typeof process !== "undefined" && !!process.env?.RUNNER_FORCE_NOOP_ALS;
-        if (!forceNoop) {
-          try {
-            const mod = __require("async_hooks");
-            als = mod?.AsyncLocalStorage;
-          } catch (_) {
-            als = void 0;
-          }
-        }
-        this.alsClass = als || class NoopAsyncLocalStorage {
-          static {
-            __name(this, "NoopAsyncLocalStorage");
-          }
-          getStore() {
-            return void 0;
-          }
-          run(_store, callback) {
-            return callback();
-          }
-        };
+}
+__name(getCallerFile, "getCallerFile");
+
+// src/defs.ts
+var defs_exports = {};
+__export(defs_exports, {
+  CONTRACT: () => CONTRACT,
+  HookDependencyState: () => HookDependencyState,
+  RunnerMode: () => RunnerMode,
+  isOneOf: () => isOneOf,
+  onAnyOf: () => onAnyOf,
+  symbolAsyncContext: () => symbolAsyncContext,
+  symbolError: () => symbolError,
+  symbolEvent: () => symbolEvent,
+  symbolFilePath: () => symbolFilePath,
+  symbolHook: () => symbolHook,
+  symbolMiddleware: () => symbolMiddleware,
+  symbolMiddlewareConfigured: () => symbolMiddlewareConfigured,
+  symbolOptionalDependency: () => symbolOptionalDependency,
+  symbolPhantomTask: () => symbolPhantomTask,
+  symbolResource: () => symbolResource,
+  symbolResourceForkedFrom: () => symbolResourceForkedFrom,
+  symbolResourceMiddleware: () => symbolResourceMiddleware,
+  symbolResourceWithConfig: () => symbolResourceWithConfig,
+  symbolTag: () => symbolTag,
+  symbolTagConfigured: () => symbolTagConfigured,
+  symbolTask: () => symbolTask,
+  symbolTaskMiddleware: () => symbolTaskMiddleware,
+  symbolTunneledBy: () => symbolTunneledBy
+});
+
+// src/types/event.ts
+function onAnyOf(...defs) {
+  return defs;
+}
+__name(onAnyOf, "onAnyOf");
+function isOneOf(emission, defs) {
+  return defs.some((d) => d.id === emission.id);
+}
+__name(isOneOf, "isOneOf");
+
+// src/types/runner.ts
+var RunnerMode = /* @__PURE__ */ ((RunnerMode2) => {
+  RunnerMode2["TEST"] = "test";
+  RunnerMode2["DEV"] = "dev";
+  RunnerMode2["PROD"] = "prod";
+  return RunnerMode2;
+})(RunnerMode || {});
+
+// src/types/contracts.ts
+var CONTRACT = Symbol.for("runner.contract");
+
+// src/types/storeTypes.ts
+var HookDependencyState = /* @__PURE__ */ ((HookDependencyState2) => {
+  HookDependencyState2["Pending"] = "pending";
+  HookDependencyState2["Computing"] = "computing";
+  HookDependencyState2["Ready"] = "ready";
+  return HookDependencyState2;
+})(HookDependencyState || {});
+
+// src/definers/tools.ts
+function isTask(definition) {
+  return definition && definition[symbolTask];
+}
+__name(isTask, "isTask");
+function isResource(definition) {
+  return definition && definition[symbolResource];
+}
+__name(isResource, "isResource");
+function isResourceWithConfig(definition) {
+  return definition && definition[symbolResourceWithConfig];
+}
+__name(isResourceWithConfig, "isResourceWithConfig");
+function isEvent(definition) {
+  return definition && definition[symbolEvent];
+}
+__name(isEvent, "isEvent");
+function isHook(definition) {
+  return definition && definition[symbolHook];
+}
+__name(isHook, "isHook");
+function isTaskMiddleware(definition) {
+  return definition && definition[symbolTaskMiddleware];
+}
+__name(isTaskMiddleware, "isTaskMiddleware");
+function isResourceMiddleware(definition) {
+  return definition && definition[symbolResourceMiddleware];
+}
+__name(isResourceMiddleware, "isResourceMiddleware");
+function isTag(definition) {
+  return definition && definition[symbolTag];
+}
+__name(isTag, "isTag");
+function isOptional(definition) {
+  return definition && definition[symbolOptionalDependency];
+}
+__name(isOptional, "isOptional");
+function isError(definition) {
+  return Boolean(definition && definition[symbolError]);
+}
+__name(isError, "isError");
+function isAsyncContext(definition) {
+  return Boolean(definition && definition[symbolAsyncContext]);
+}
+__name(isAsyncContext, "isAsyncContext");
+
+// src/tools/throws.ts
+function invalidThrowsEntryError(owner, item) {
+  const got = item === null ? "null" : Array.isArray(item) ? "array" : typeof item === "object" ? "object" : typeof item;
+  return new Error(
+    `Invalid throws entry for ${owner.kind} ${owner.id}: expected error id string or Error helper, got ${got}`
+  );
+}
+__name(invalidThrowsEntryError, "invalidThrowsEntryError");
+function toErrorIdList(owner, list) {
+  const ids = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const item of list) {
+    let id2;
+    if (typeof item === "string") {
+      if (item.trim().length === 0) {
+        throw invalidThrowsEntryError(owner, item);
       }
-      return instance ??= new this.alsClass();
-    }, "ensure");
-    return {
-      getStore: /* @__PURE__ */ __name(() => ensure().getStore(), "getStore"),
-      run: /* @__PURE__ */ __name((store2, callback) => ensure().run(store2, callback), "run")
-    };
+      id2 = item;
+    } else if (isError(item)) {
+      id2 = item.id;
+      if (typeof id2 !== "string" || id2.trim().length === 0) {
+        throw invalidThrowsEntryError(owner, item);
+      }
+    } else {
+      throw invalidThrowsEntryError(owner, item);
+    }
+    if (seen.has(id2)) continue;
+    seen.add(id2);
+    ids.push(id2);
   }
+  return ids;
+}
+__name(toErrorIdList, "toErrorIdList");
+function normalizeThrows(owner, throwsList) {
+  if (throwsList === void 0) return void 0;
+  return toErrorIdList(owner, throwsList);
+}
+__name(normalizeThrows, "normalizeThrows");
+
+// src/definers/defineTask.ts
+function defineTask(taskConfig) {
+  const filePath = getCallerFile();
+  const id2 = taskConfig.id;
+  return {
+    [symbolTask]: true,
+    [symbolFilePath]: filePath,
+    id: id2,
+    dependencies: taskConfig.dependencies || {},
+    middleware: taskConfig.middleware || [],
+    run: taskConfig.run,
+    inputSchema: taskConfig.inputSchema,
+    resultSchema: taskConfig.resultSchema,
+    meta: taskConfig.meta || {},
+    tags: taskConfig.tags || [],
+    throws: normalizeThrows({ kind: "task", id: id2 }, taskConfig.throws),
+    // autorun,
+    optional() {
+      return {
+        inner: this,
+        [symbolOptionalDependency]: true
+      };
+    }
+  };
+}
+__name(defineTask, "defineTask");
+defineTask.phantom = (taskConfig) => {
+  const taskDef = defineTask({
+    ...taskConfig,
+    run: /* @__PURE__ */ __name(async (_input) => {
+      return void 0;
+    }, "run")
+  });
+  taskDef[symbolPhantomTask] = true;
+  return taskDef;
 };
 
+// src/definers/defineHook.ts
+function defineHook(hookDef) {
+  const filePath = getCallerFile();
+  return {
+    [symbolHook]: true,
+    [symbolFilePath]: filePath,
+    id: hookDef.id,
+    dependencies: hookDef.dependencies || {},
+    on: hookDef.on,
+    order: hookDef.order,
+    run: hookDef.run,
+    meta: hookDef.meta || {},
+    tags: hookDef.tags || []
+  };
+}
+__name(defineHook, "defineHook");
+
 // src/errors.ts
 var errors_exports = {};
 __export(errors_exports, {
@@ -28740,9 +28882,10 @@ var RunnerError = class extends Error {
 var _a;
 _a = symbolError;
 var ErrorHelper = class {
-  constructor(definition) {
+  constructor(definition, filePath) {
     this.definition = definition;
     this[_a] = true;
+    this[symbolFilePath] = filePath;
   }
   static {
     __name(this, "ErrorHelper");
@@ -28765,11 +28908,15 @@ var ErrorHelper = class {
     };
   }
 };
-function defineError(definition) {
+function defineError(definition, filePath) {
   if (!definition.format) {
     definition.format = (data) => `${JSON.stringify(data)}`;
   }
-  return new ErrorHelper(definition);
+  const resolvedFilePath = filePath ?? getCallerFile();
+  return new ErrorHelper(
+    definition,
+    resolvedFilePath
+  );
 }
 __name(defineError, "defineError");
 
@@ -28807,14 +28954,17 @@ function makeErrorBuilder(state) {
       return makeErrorBuilder(next);
     },
     build() {
-      return defineError({
-        id: state.id,
-        serialize: state.serialize,
-        parse: state.parse,
-        dataSchema: state.dataSchema,
-        format: state.format,
-        meta: state.meta
-      });
+      return defineError(
+        {
+          id: state.id,
+          serialize: state.serialize,
+          parse: state.parse,
+          dataSchema: state.dataSchema,
+          format: state.format,
+          meta: state.meta
+        },
+        state.filePath
+      );
     }
   };
   return builder;
@@ -28823,8 +28973,10 @@ __name(makeErrorBuilder, "makeErrorBuilder");
 
 // src/definers/builders/error/index.ts
 function errorBuilder(id2) {
+  const filePath = getCallerFile();
   const initial = Object.freeze({
     id: id2,
+    filePath,
     serialize: void 0,
     parse: void 0,
     dataSchema: void 0,
@@ -28835,103 +28987,87 @@ function errorBuilder(id2) {
 __name(errorBuilder, "errorBuilder");
 var error = errorBuilder;
 
-// src/errors.ts
-var duplicateRegistrationError = error("runner.errors.duplicateRegistration").format(
-  ({ type, id: id2 }) => `${type} "${id2.toString()}" already registered. You might have used the same 'id' in two different components or you may have registered the same element twice.`
-).build();
-var dependencyNotFoundError = error("runner.errors.dependencyNotFound").format(
-  ({ key }) => `Dependency ${key.toString()} not found. Did you forget to register it through a resource?`
-).build();
-var unknownItemTypeError = error(
-  "runner.errors.unknownItemType"
-).format(
-  ({ item }) => `Unknown item type: ${String(
-    item
-  )}. Please ensure you are not using different versions of '@bluelibs/runner'`
-).build();
-var contextError = error(
-  "runner.errors.context"
-).format(({ details }) => details ?? "Context error").build();
-var circularDependenciesError = error("runner.errors.circularDependencies").format(({ cycles }) => {
-  const cycleDetails = cycles.map((cycle) => `  \u2022 ${cycle}`).join("\n");
-  const hasMiddleware = cycles.some((cycle) => cycle.includes("middleware"));
-  let guidance = "\n\nTo resolve circular dependencies:";
-  guidance += "\n  \u2022 Consider refactoring to reduce coupling between components";
-  guidance += "\n  \u2022 Extract shared dependencies into separate resources";
-  if (hasMiddleware) {
-    guidance += "\n  \u2022 For middleware: you can filter out tasks/resources using everywhere(fn)";
-    guidance += "\n  \u2022 Consider using events for communication instead of direct dependencies";
-  }
-  return `Circular dependencies detected:
-${cycleDetails}${guidance}`;
-}).build();
-var eventNotFoundError = error(
-  "runner.errors.eventNotFound"
-).format(
-  ({ id: id2 }) => `Event "${id2.toString()}" not found. Did you forget to register it?`
-).build();
-var resourceNotFoundError = error(
-  "runner.errors.resourceNotFound"
-).format(
-  ({ id: id2 }) => `Resource "${id2.toString()}" not found. Did you forget to register it or are you using the correct id?`
-).build();
-var middlewareNotRegisteredError = error("runner.errors.middlewareNotRegistered").format(
-  ({ type, source, middlewareId }) => `Middleware inside ${type} "${source}" depends on "${middlewareId}" but it's not registered. Did you forget to register it?`
-).build();
-var tagNotFoundError = error(
-  "runner.errors.tagNotFound"
-).format(
-  ({ id: id2 }) => `Tag "${id2}" not registered. Did you forget to register it inside a resource?`
-).build();
-var lockedError = error(
-  "runner.errors.locked"
-).format(
-  ({ what }) => `Cannot modify the ${what.toString()} when it is locked.`
-).build();
-var storeAlreadyInitializedError = error(
-  "runner.errors.storeAlreadyInitialized"
-).format(() => "Store already initialized. Cannot reinitialize.").build();
-var validationError = error("runner.errors.validation").format(({ subject, id: id2, originalError }) => {
-  const 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: path4 }) => {
-  const chain = path4.map((p) => `${p.id}\u2190${p.source}`).join("  ->  ");
-  return `Event emission cycle detected:
-  ${chain}
-
-Break the cycle by changing hook logic (avoid mutual emits) or gate with conditions/tags.`;
-}).build();
-var eventEmissionCycleError = error("runner.errors.eventEmissionCycle").format(({ cycles }) => {
-  const list = cycles.map((c) => `  \u2022 ${c}`).join("\n");
-  return `Event emission cycles detected between hooks and events:
-${list}
-
-This was detected at compile time (dry-run). Break the cycle by avoiding mutual emits between hooks or scoping hooks using tags.`;
-}).build();
-var platformUnsupportedFunctionError = error("runner.errors.platformUnsupportedFunction").format(
-  ({ functionName }) => `Platform function not supported in this environment: ${functionName}. Detected platform: ${detectEnvironment()}.`
-).build();
-var cancellationError = error(
-  "runner.errors.cancellation"
-).format(({ reason }) => reason || "Operation cancelled").build();
-var tunnelOwnershipConflictError = error("runner.errors.tunnelOwnershipConflict").format(
-  ({ taskId, currentOwnerId, attemptedOwnerId }) => `Task "${taskId}" is already tunneled by resource "${currentOwnerId}". Resource "${attemptedOwnerId}" cannot tunnel it again. Ensure each task is owned by a single tunnel client.`
-).build();
-var phantomTaskNotRoutedError = error("runner.errors.phantomTaskNotRouted").format(
-  ({ taskId }) => `Phantom task "${taskId}" is not routed through any tunnel. Ensure a tunnel client selects this task id (or avoid calling the phantom task directly).`
-).build();
-var taskNotRegisteredError = error("runner.errors.taskNotRegistered").format(
-  ({ taskId }) => `Task "${taskId}" is not registered in the Store. This is an internal error\u2014ensure the task is registered before execution.`
-).build();
-var builderIncompleteError = error("runner.errors.builderIncomplete").format(({ type, builderId, missingFields }) => {
-  const typeLabel = type === "hook" ? "Hook" : type === "task-middleware" ? "Task middleware" : "Resource middleware";
-  return `${typeLabel} "${builderId}" is incomplete. Missing required: ${missingFields.join(", ")}. Call ${missingFields.map((f) => `.${f}()`).join(" and ")} before .build().`;
-}).build();
-function isCancellationError(err) {
-  return cancellationError.is(err);
+// src/platform/adapters/node-als.ts
+async function loadAsyncLocalStorageClass() {
+  const mod = __require("async_hooks");
+  return mod.AsyncLocalStorage;
 }
-__name(isCancellationError, "isCancellationError");
+__name(loadAsyncLocalStorageClass, "loadAsyncLocalStorageClass");
+
+// src/platform/adapters/node.ts
+var NodePlatformAdapter = class {
+  constructor() {
+    this.id = "node";
+    this.setTimeout = globalThis.setTimeout;
+    this.clearTimeout = globalThis.clearTimeout;
+  }
+  static {
+    __name(this, "NodePlatformAdapter");
+  }
+  async init() {
+    this.alsClass = await loadAsyncLocalStorageClass();
+  }
+  onUncaughtException(handler) {
+    const h = /* @__PURE__ */ __name((error2) => handler(error2), "h");
+    process.on("uncaughtException", h);
+    return () => process.off("uncaughtException", h);
+  }
+  onUnhandledRejection(handler) {
+    const h = /* @__PURE__ */ __name((reason) => handler(reason), "h");
+    process.on("unhandledRejection", h);
+    return () => process.off("unhandledRejection", h);
+  }
+  onShutdownSignal(handler) {
+    process.on("SIGINT", handler);
+    process.on("SIGTERM", handler);
+    return () => {
+      process.off("SIGINT", handler);
+      process.off("SIGTERM", handler);
+    };
+  }
+  exit(code) {
+    process.exit(code);
+  }
+  getEnv(key) {
+    return process.env[key];
+  }
+  hasAsyncLocalStorage() {
+    return true;
+  }
+  createAsyncLocalStorage() {
+    let instance;
+    const ensure = /* @__PURE__ */ __name(() => {
+      if (!this.alsClass) {
+        let als;
+        const forceNoop = typeof process !== "undefined" && !!process.env?.RUNNER_FORCE_NOOP_ALS;
+        if (!forceNoop) {
+          try {
+            const mod = __require("async_hooks");
+            als = mod?.AsyncLocalStorage;
+          } catch (_) {
+            als = void 0;
+          }
+        }
+        this.alsClass = als || class NoopAsyncLocalStorage {
+          static {
+            __name(this, "NoopAsyncLocalStorage");
+          }
+          getStore() {
+            return void 0;
+          }
+          run(_store, callback) {
+            return callback();
+          }
+        };
+      }
+      return instance ??= new this.alsClass();
+    }, "ensure");
+    return {
+      getStore: /* @__PURE__ */ __name(() => ensure().getStore(), "getStore"),
+      run: /* @__PURE__ */ __name((store2, callback) => ensure().run(store2, callback), "run")
+    };
+  }
+};
 
 // src/platform/adapters/browser.ts
 var BrowserPlatformAdapter = class {
@@ -29224,16 +29360,11 @@ function setPlatform(adapter) {
   adapter.id;
 }
 __name(setPlatform, "setPlatform");
-function isNode() {
-  {
-    return true;
-  }
-}
-__name(isNode, "isNode");
 var PlatformAdapter = class {
+  static {
+    __name(this, "PlatformAdapter");
+  }
   constructor(env) {
-    this.setTimeout = globalThis.setTimeout;
-    this.clearTimeout = globalThis.clearTimeout;
     const kind = env ?? detectEnvironment();
     this.env = kind;
     switch (kind) {
@@ -29253,9 +29384,8 @@ var PlatformAdapter = class {
         this.inner = new UniversalPlatformAdapter();
     }
     this.id = this.inner.id;
-  }
-  static {
-    __name(this, "PlatformAdapter");
+    this.setTimeout = this.inner.setTimeout;
+    this.clearTimeout = this.inner.clearTimeout;
   }
   async init() {
     return this.inner.init();
@@ -29283,208 +29413,285 @@ var PlatformAdapter = class {
   }
 };
 
-// src/tools/getCallerFile.ts
-function getCallerFile() {
-  const originalPrepare = Error.prepareStackTrace;
-  try {
-    if (isNode()) {
-      const err = new Error();
-      Error.prepareStackTrace = (_err, stack2) => stack2;
-      const stack = err.stack;
-      stack.shift();
-      stack.shift();
-      const candidate = stack.shift();
-      const file = candidate?.getFileName?.();
-      return file;
-    }
-    return "unknown";
-  } finally {
-    Error.prepareStackTrace = originalPrepare;
+// src/errors.ts
+var duplicateRegistrationError = error("runner.errors.duplicateRegistration").format(
+  ({ type, id: id2 }) => `${type} "${id2.toString()}" already registered. You might have used the same 'id' in two different components or you may have registered the same element twice.`
+).build();
+var dependencyNotFoundError = error("runner.errors.dependencyNotFound").format(
+  ({ key }) => `Dependency ${key.toString()} not found. Did you forget to register it through a resource?`
+).build();
+var unknownItemTypeError = error(
+  "runner.errors.unknownItemType"
+).format(
+  ({ item }) => `Unknown item type: ${String(
+    item
+  )}. Please ensure you are not using different versions of '@bluelibs/runner'`
+).build();
+var contextError = error(
+  "runner.errors.context"
+).format(({ details }) => details ?? "Context error").build();
+var circularDependenciesError = error("runner.errors.circularDependencies").format(({ cycles }) => {
+  const cycleDetails = cycles.map((cycle) => `  \u2022 ${cycle}`).join("\n");
+  const hasMiddleware = cycles.some((cycle) => cycle.includes("middleware"));
+  let guidance = "\n\nTo resolve circular dependencies:";
+  guidance += "\n  \u2022 Consider refactoring to reduce coupling between components";
+  guidance += "\n  \u2022 Extract shared dependencies into separate resources";
+  if (hasMiddleware) {
+    guidance += "\n  \u2022 For middleware: you can filter out tasks/resources using everywhere(fn)";
+    guidance += "\n  \u2022 Consider using events for communication instead of direct dependencies";
   }
-}
-__name(getCallerFile, "getCallerFile");
-
-// src/defs.ts
-var defs_exports = {};
-__export(defs_exports, {
-  RunnerMode: () => RunnerMode,
-  isOneOf: () => isOneOf,
-  onAnyOf: () => onAnyOf,
-  symbolAsyncContext: () => symbolAsyncContext,
-  symbolError: () => symbolError,
-  symbolEvent: () => symbolEvent,
-  symbolFilePath: () => symbolFilePath,
-  symbolHook: () => symbolHook,
-  symbolMiddleware: () => symbolMiddleware,
-  symbolMiddlewareConfigured: () => symbolMiddlewareConfigured,
-  symbolOptionalDependency: () => symbolOptionalDependency,
-  symbolPhantomTask: () => symbolPhantomTask,
-  symbolResource: () => symbolResource,
-  symbolResourceMiddleware: () => symbolResourceMiddleware,
-  symbolResourceWithConfig: () => symbolResourceWithConfig,
-  symbolTag: () => symbolTag,
-  symbolTagConfigured: () => symbolTagConfigured,
-  symbolTask: () => symbolTask,
-  symbolTaskMiddleware: () => symbolTaskMiddleware,
-  symbolTunneledBy: () => symbolTunneledBy
-});
-
-// src/types/event.ts
-function onAnyOf(...defs) {
-  return defs;
-}
-__name(onAnyOf, "onAnyOf");
-function isOneOf(emission, defs) {
-  return defs.some((d) => d.id === emission.id);
-}
-__name(isOneOf, "isOneOf");
+  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: path4 }) => {
+  const chain = path4.map((p) => `${p.id}\u2190${p.source}`).join("  ->  ");
+  return `Event emission cycle detected:
+  ${chain}
 
-// src/types/runner.ts
-var RunnerMode = /* @__PURE__ */ ((RunnerMode2) => {
-  RunnerMode2["TEST"] = "test";
-  RunnerMode2["DEV"] = "dev";
-  RunnerMode2["PROD"] = "prod";
-  return RunnerMode2;
-})(RunnerMode || {});
+Break the cycle by changing hook logic (avoid mutual emits) or gate with conditions/tags.`;
+}).build();
+var eventEmissionCycleError = error("runner.errors.eventEmissionCycle").format(({ cycles }) => {
+  const list = cycles.map((c) => `  \u2022 ${c}`).join("\n");
+  return `Event emission cycles detected between hooks and events:
+${list}
 
-// src/definers/tools.ts
-function isTask(definition) {
-  return definition && definition[symbolTask];
-}
-__name(isTask, "isTask");
-function isResource(definition) {
-  return definition && definition[symbolResource];
-}
-__name(isResource, "isResource");
-function isResourceWithConfig(definition) {
-  return definition && definition[symbolResourceWithConfig];
-}
-__name(isResourceWithConfig, "isResourceWithConfig");
-function isEvent(definition) {
-  return definition && definition[symbolEvent];
-}
-__name(isEvent, "isEvent");
-function isHook(definition) {
-  return definition && definition[symbolHook];
-}
-__name(isHook, "isHook");
-function isTaskMiddleware(definition) {
-  return definition && definition[symbolTaskMiddleware];
-}
-__name(isTaskMiddleware, "isTaskMiddleware");
-function isResourceMiddleware(definition) {
-  return definition && definition[symbolResourceMiddleware];
-}
-__name(isResourceMiddleware, "isResourceMiddleware");
-function isTag(definition) {
-  return definition && definition[symbolTag];
-}
-__name(isTag, "isTag");
-function isOptional(definition) {
-  return definition && definition[symbolOptionalDependency];
-}
-__name(isOptional, "isOptional");
-function isError(definition) {
-  return Boolean(definition && definition[symbolError]);
-}
-__name(isError, "isError");
-function isAsyncContext(definition) {
-  return Boolean(definition && definition[symbolAsyncContext]);
+This was detected at compile time (dry-run). Break the cycle by avoiding mutual emits between hooks or scoping hooks using tags.`;
+}).build();
+var platformUnsupportedFunctionError = error("runner.errors.platformUnsupportedFunction").format(
+  ({ functionName }) => `Platform function not supported in this environment: ${functionName}. Detected platform: ${detectEnvironment()}.`
+).build();
+var cancellationError = error(
+  "runner.errors.cancellation"
+).format(({ reason }) => reason || "Operation cancelled").build();
+var tunnelOwnershipConflictError = error("runner.errors.tunnelOwnershipConflict").format(
+  ({ taskId, currentOwnerId, attemptedOwnerId }) => `Task "${taskId}" is already tunneled by resource "${currentOwnerId}". Resource "${attemptedOwnerId}" cannot tunnel it again. Ensure each task is owned by a single tunnel client.`
+).build();
+var phantomTaskNotRoutedError = error("runner.errors.phantomTaskNotRouted").format(
+  ({ taskId }) => `Phantom task "${taskId}" is not routed through any tunnel. Ensure a tunnel client selects this task id (or avoid calling the phantom task directly).`
+).build();
+var taskNotRegisteredError = error("runner.errors.taskNotRegistered").format(
+  ({ taskId }) => `Task "${taskId}" is not registered in the Store. This is an internal error\u2014ensure the task is registered before execution.`
+).build();
+var builderIncompleteError = error("runner.errors.builderIncomplete").format(({ type, builderId, missingFields }) => {
+  const typeLabel = type === "hook" ? "Hook" : type === "task-middleware" ? "Task middleware" : "Resource middleware";
+  return `${typeLabel} "${builderId}" is incomplete. Missing required: ${missingFields.join(", ")}. Call ${missingFields.map((f) => `.${f}()`).join(" and ")} before .build().`;
+}).build();
+function isCancellationError(err) {
+  return cancellationError.is(err);
 }
-__name(isAsyncContext, "isAsyncContext");
+__name(isCancellationError, "isCancellationError");
 
-// src/tools/throws.ts
-function invalidThrowsEntryError(owner, item) {
-  const got = item === null ? "null" : Array.isArray(item) ? "array" : typeof item === "object" ? "object" : typeof item;
-  return new Error(
-    `Invalid throws entry for ${owner.kind} ${owner.id}: expected error id string or Error helper, got ${got}`
-  );
+// src/definers/resourceFork.ts
+function resolveReId(forkId, options) {
+  const fallback = /* @__PURE__ */ __name((id2) => `${forkId}.${id2}`, "fallback");
+  const reId = options?.reId ?? fallback;
+  return (id2) => {
+    const next = reId(id2);
+    if (typeof next !== "string" || next.length === 0) {
+      throw new Error(`fork(reId) must return a non-empty string for "${id2}"`);
+    }
+    return next;
+  };
 }
-__name(invalidThrowsEntryError, "invalidThrowsEntryError");
-function toErrorIdList(owner, list) {
-  const ids = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const item of list) {
-    let id2;
-    if (typeof item === "string") {
-      if (item.trim().length === 0) {
-        throw invalidThrowsEntryError(owner, item);
+__name(resolveReId, "resolveReId");
+function remapResourceDependenciesInObject(deps, options) {
+  const remapObject = /* @__PURE__ */ __name((deps2) => {
+    const out = { ...deps2 };
+    for (const [key, value] of Object.entries(deps2)) {
+      if (isOptional(value)) {
+        const inner = value.inner;
+        if (isResource(inner)) {
+          const forked = options.getForkedResourceByBaseId(inner.id);
+          if (forked) {
+            out[key] = { ...value, inner: forked };
+          }
+        }
+        continue;
       }
-      id2 = item;
-    } else if (isError(item)) {
-      id2 = item.id;
-      if (typeof id2 !== "string" || id2.trim().length === 0) {
-        throw invalidThrowsEntryError(owner, item);
+      if (isResource(value)) {
+        const forked = options.getForkedResourceByBaseId(value.id);
+        if (forked) {
+          out[key] = forked;
+        }
       }
-    } else {
-      throw invalidThrowsEntryError(owner, item);
     }
-    if (seen.has(id2)) continue;
-    seen.add(id2);
-    ids.push(id2);
-  }
-  return ids;
+    return out;
+  }, "remapObject");
+  return remapObject(deps);
 }
-__name(toErrorIdList, "toErrorIdList");
-function normalizeThrows(owner, throwsList) {
-  if (throwsList === void 0) return void 0;
-  return toErrorIdList(owner, throwsList);
+__name(remapResourceDependenciesInObject, "remapResourceDependenciesInObject");
+function toResourceOnlyRegisterItems(items) {
+  const out = [];
+  for (const item of items) {
+    if (isResourceWithConfig(item)) {
+      out.push({
+        kind: "withConfig",
+        resource: item.resource,
+        config: item.config
+      });
+      continue;
+    }
+    if (isResource(item)) {
+      out.push({ kind: "resource", resource: item });
+      continue;
+    }
+  }
+  return out;
 }
-__name(normalizeThrows, "normalizeThrows");
-
-// src/definers/defineTask.ts
-function defineTask(taskConfig) {
-  const filePath = getCallerFile();
-  const id2 = taskConfig.id;
-  return {
-    [symbolTask]: true,
-    [symbolFilePath]: filePath,
-    id: id2,
-    dependencies: taskConfig.dependencies || {},
-    middleware: taskConfig.middleware || [],
-    run: taskConfig.run,
-    inputSchema: taskConfig.inputSchema,
-    resultSchema: taskConfig.resultSchema,
-    meta: taskConfig.meta || {},
-    tags: taskConfig.tags || [],
-    throws: normalizeThrows({ kind: "task", id: id2 }, taskConfig.throws),
-    // autorun,
-    optional() {
-      return {
-        inner: this,
-        [symbolOptionalDependency]: true
+__name(toResourceOnlyRegisterItems, "toResourceOnlyRegisterItems");
+function createDeepForkContext(forkId, options) {
+  const reId = resolveReId(forkId, options);
+  const forkedResourceByBaseId = /* @__PURE__ */ new Map();
+  const ensureForked = /* @__PURE__ */ __name((base) => {
+    const cached = forkedResourceByBaseId.get(base.id);
+    if (cached) return cached;
+    const forked = base.fork(reId(base.id), { register: "drop" });
+    forkedResourceByBaseId.set(base.id, forked);
+    const baseRegister = base.register;
+    const ensureForkedForRegisterConfig = /* @__PURE__ */ __name((config) => {
+      const items = typeof baseRegister === "function" ? baseRegister(config) : baseRegister;
+      for (const candidate of toResourceOnlyRegisterItems(items)) {
+        ensureForked(candidate.resource);
+      }
+      return items;
+    }, "ensureForkedForRegisterConfig");
+    const mapRegisterItems2 = /* @__PURE__ */ __name((items) => {
+      const resourceItems = toResourceOnlyRegisterItems(items);
+      const out = [];
+      for (const candidate of resourceItems) {
+        if (candidate.kind === "resource") {
+          out.push(ensureForked(candidate.resource));
+          continue;
+        }
+        out.push(ensureForked(candidate.resource).with(candidate.config));
+      }
+      return out;
+    }, "mapRegisterItems");
+    forked.register = typeof baseRegister === "function" ? (config) => {
+      const items = ensureForkedForRegisterConfig(config);
+      return mapRegisterItems2(items);
+    } : (() => {
+      ensureForkedForRegisterConfig(void 0);
+      return mapRegisterItems2(baseRegister);
+    })();
+    const baseDependencies = base.dependencies;
+    const remapDepsObject = /* @__PURE__ */ __name((deps) => remapResourceDependenciesInObject(deps, {
+      getForkedResourceByBaseId: /* @__PURE__ */ __name((id2) => forkedResourceByBaseId.get(id2), "getForkedResourceByBaseId")
+    }), "remapDepsObject");
+    if (!baseDependencies) {
+      forked.dependencies = baseDependencies;
+    } else {
+      forked.dependencies = (config) => {
+        ensureForkedForRegisterConfig(config);
+        const deps = typeof baseDependencies === "function" ? baseDependencies(config) : baseDependencies;
+        return remapDepsObject(deps);
       };
     }
+    return forked;
+  }, "ensureForked");
+  const ensureForkedForRegisterItems = /* @__PURE__ */ __name((items) => {
+    for (const candidate of toResourceOnlyRegisterItems(items)) {
+      ensureForked(candidate.resource);
+    }
+  }, "ensureForkedForRegisterItems");
+  const mapRegisterItems = /* @__PURE__ */ __name((items) => {
+    ensureForkedForRegisterItems(items);
+    const resourceItems = toResourceOnlyRegisterItems(items);
+    const out = [];
+    for (const candidate of resourceItems) {
+      if (candidate.kind === "resource") {
+        out.push(ensureForked(candidate.resource));
+        continue;
+      }
+      out.push(ensureForked(candidate.resource).with(candidate.config));
+    }
+    return out;
+  }, "mapRegisterItems");
+  const remapDependencies = /* @__PURE__ */ __name((dependencies) => {
+    if (!dependencies) return dependencies;
+    const remapObj = /* @__PURE__ */ __name((deps) => remapResourceDependenciesInObject(deps, {
+      getForkedResourceByBaseId: /* @__PURE__ */ __name((id2) => forkedResourceByBaseId.get(id2), "getForkedResourceByBaseId")
+    }), "remapObj");
+    if (typeof dependencies === "function") {
+      return (config) => remapObj(dependencies(config));
+    }
+    return remapObj(dependencies);
+  }, "remapDependencies");
+  return {
+    reId,
+    ensureForkedForRegisterItems,
+    mapRegisterItems,
+    remapDependencies,
+    getForkedResourceByBaseId: /* @__PURE__ */ __name((id2) => forkedResourceByBaseId.get(id2), "getForkedResourceByBaseId")
   };
 }
-__name(defineTask, "defineTask");
-defineTask.phantom = (taskConfig) => {
-  const taskDef = defineTask({
-    ...taskConfig,
-    run: /* @__PURE__ */ __name(async (_input) => {
-      return void 0;
-    }, "run")
-  });
-  taskDef[symbolPhantomTask] = true;
-  return taskDef;
-};
-
-// src/definers/defineHook.ts
-function defineHook(hookDef) {
-  const filePath = getCallerFile();
+__name(createDeepForkContext, "createDeepForkContext");
+function resolveForkedRegisterAndDependencies(params) {
+  const { register, dependencies, forkId, options } = params;
+  const mode = options?.register ?? "keep";
+  if (mode === "drop") {
+    return { register: [], dependencies };
+  }
+  if (mode !== "deep") {
+    return { register, dependencies };
+  }
+  if (!register) {
+    return { register, dependencies };
+  }
+  const ctx = createDeepForkContext(forkId, options);
+  if (typeof register === "function") {
+    return {
+      register: /* @__PURE__ */ __name((config) => {
+        const baseItems = register(config);
+        return ctx.mapRegisterItems(baseItems);
+      }, "register"),
+      dependencies: dependencies ? (config) => {
+        const baseItems = register(config);
+        ctx.ensureForkedForRegisterItems(baseItems);
+        const baseDeps = typeof dependencies === "function" ? dependencies(config) : dependencies;
+        return remapResourceDependenciesInObject(baseDeps, {
+          getForkedResourceByBaseId: ctx.getForkedResourceByBaseId
+        });
+      } : dependencies
+    };
+  }
+  ctx.ensureForkedForRegisterItems(register);
   return {
-    [symbolHook]: true,
-    [symbolFilePath]: filePath,
-    id: hookDef.id,
-    dependencies: hookDef.dependencies || {},
-    on: hookDef.on,
-    order: hookDef.order,
-    run: hookDef.run,
-    meta: hookDef.meta || {},
-    tags: hookDef.tags || []
+    register: ctx.mapRegisterItems(register),
+    dependencies: ctx.remapDependencies(dependencies)
   };
 }
-__name(defineHook, "defineHook");
+__name(resolveForkedRegisterAndDependencies, "resolveForkedRegisterAndDependencies");
 
 // src/definers/defineResource.ts
 function defineResource(constConfig) {
@@ -29531,12 +29738,25 @@ function defineResource(constConfig) {
         [symbolOptionalDependency]: true
       };
     },
-    fork(newId) {
-      return defineResource({
+    fork(newId, options) {
+      const forkedParts = resolveForkedRegisterAndDependencies({
+        register: constConfig.register,
+        dependencies: constConfig.dependencies,
+        forkId: newId,
+        options
+      });
+      const forked = defineResource({
         ...constConfig,
         id: newId,
+        register: forkedParts.register,
+        dependencies: forkedParts.dependencies,
         [symbolFilePath]: filePath
       });
+      forked[symbolResourceForkedFrom] = {
+        fromId: id2,
+        forkedAtFilePath: getCallerFile()
+      };
+      return forked;
     }
   };
 }
@@ -29664,7 +29884,7 @@ function defineOverride(base, patch) {
     ...patch,
     id: base.id
   };
-  if (base.on !== void 0) {
+  if ("on" in base && base.on !== void 0) {
     overridden.on = base.on;
   }
   return overridden;
@@ -29784,6 +30004,309 @@ var SymbolPolicy = /* @__PURE__ */ ((SymbolPolicy2) => {
   SymbolPolicy2["Disabled"] = "Disabled";
   return SymbolPolicy2;
 })(SymbolPolicy || {});
+var SymbolPolicyErrorMessage = /* @__PURE__ */ ((SymbolPolicyErrorMessage2) => {
+  SymbolPolicyErrorMessage2["GlobalSymbolsNotAllowed"] = "Global symbols are not allowed";
+  SymbolPolicyErrorMessage2["SymbolsNotAllowed"] = "Symbols are not allowed";
+  SymbolPolicyErrorMessage2["UnsupportedSymbolPolicy"] = "Unsupported symbol policy";
+  return SymbolPolicyErrorMessage2;
+})(SymbolPolicyErrorMessage || {});
+
+// src/serializer/binary-builtins.ts
+var INVALID_PAYLOAD_MESSAGE_PREFIX = "Invalid";
+var typedArrayTypeIds = [
+  "Int8Array",
+  "Uint8Array",
+  "Uint8ClampedArray",
+  "Int16Array",
+  "Uint16Array",
+  "Int32Array",
+  "Uint32Array",
+  "Float32Array",
+  "Float64Array",
+  "BigInt64Array",
+  "BigUint64Array"
+];
+var getTypedArrayConstructor = /* @__PURE__ */ __name((typeId) => {
+  const value = globalThis[typeId];
+  if (typeof value !== "function") {
+    return null;
+  }
+  return value;
+}, "getTypedArrayConstructor");
+var getRuntimeBufferConstructor = /* @__PURE__ */ __name(() => {
+  const value = globalThis.Buffer;
+  if (typeof value !== "function") {
+    return null;
+  }
+  const valueRecord = value;
+  if (typeof valueRecord.from !== "function" || typeof valueRecord.isBuffer !== "function") {
+    return null;
+  }
+  return value;
+}, "getRuntimeBufferConstructor");
+var isNodeBuffer = /* @__PURE__ */ __name((value) => {
+  const runtimeBufferConstructor = getRuntimeBufferConstructor();
+  if (!runtimeBufferConstructor) {
+    return false;
+  }
+  return runtimeBufferConstructor.isBuffer(value);
+}, "isNodeBuffer");
+var assertBytePayload = /* @__PURE__ */ __name((payload, typeId) => {
+  if (!Array.isArray(payload)) {
+    throw new Error(`${INVALID_PAYLOAD_MESSAGE_PREFIX} ${typeId} payload`);
+  }
+  const bytes = new Array(payload.length);
+  for (let index = 0; index < payload.length; index += 1) {
+    const byteValue = payload[index];
+    if (typeof byteValue !== "number" || !Number.isInteger(byteValue) || byteValue < 0 || byteValue > 255) {
+      throw new Error(`${INVALID_PAYLOAD_MESSAGE_PREFIX} ${typeId} payload`);
+    }
+    bytes[index] = byteValue;
+  }
+  return bytes;
+}, "assertBytePayload");
+var toBytePayload = /* @__PURE__ */ __name((value) => Array.from(new Uint8Array(value.buffer, value.byteOffset, value.byteLength)), "toBytePayload");
+var bytesToArrayBuffer = /* @__PURE__ */ __name((payload, typeId) => {
+  const bytes = assertBytePayload(payload, typeId);
+  return Uint8Array.from(bytes).buffer;
+}, "bytesToArrayBuffer");
+var deserializeTypedArray = /* @__PURE__ */ __name((typeId, payload) => {
+  const typedArrayConstructor = getTypedArrayConstructor(typeId);
+  if (!typedArrayConstructor) {
+    throw new Error(`${typeId} is not available in this runtime`);
+  }
+  const bytes = assertBytePayload(payload, typeId);
+  const bytesPerElement = typedArrayConstructor.BYTES_PER_ELEMENT;
+  if (bytes.length % bytesPerElement !== 0) {
+    throw new Error(`${INVALID_PAYLOAD_MESSAGE_PREFIX} ${typeId} payload`);
+  }
+  const arrayBuffer = Uint8Array.from(bytes).buffer;
+  return new typedArrayConstructor(arrayBuffer);
+}, "deserializeTypedArray");
+var createTypedArrayType = /* @__PURE__ */ __name((typeId) => ({
+  id: typeId,
+  is: /* @__PURE__ */ __name((value) => {
+    const typedArrayConstructor = getTypedArrayConstructor(typeId);
+    if (!typedArrayConstructor) {
+      return false;
+    }
+    if (!(value instanceof typedArrayConstructor)) {
+      return false;
+    }
+    if (typeId === "Uint8Array" && isNodeBuffer(value)) {
+      return false;
+    }
+    return true;
+  }, "is"),
+  serialize: /* @__PURE__ */ __name((value) => toBytePayload(value), "serialize"),
+  deserialize: /* @__PURE__ */ __name((payload) => deserializeTypedArray(typeId, payload), "deserialize"),
+  strategy: "value"
+}), "createTypedArrayType");
+var ArrayBufferType = {
+  id: "ArrayBuffer",
+  is: /* @__PURE__ */ __name((value) => value instanceof ArrayBuffer, "is"),
+  serialize: /* @__PURE__ */ __name((value) => Array.from(new Uint8Array(value)), "serialize"),
+  deserialize: /* @__PURE__ */ __name((payload) => bytesToArrayBuffer(payload, "ArrayBuffer"), "deserialize"),
+  strategy: "value"
+};
+var DataViewType = {
+  id: "DataView",
+  is: /* @__PURE__ */ __name((value) => value instanceof DataView, "is"),
+  serialize: /* @__PURE__ */ __name((value) => toBytePayload(value), "serialize"),
+  deserialize: /* @__PURE__ */ __name((payload) => new DataView(bytesToArrayBuffer(payload, "DataView")), "deserialize"),
+  strategy: "value"
+};
+var BufferType = {
+  id: "Buffer",
+  is: /* @__PURE__ */ __name((value) => isNodeBuffer(value), "is"),
+  serialize: /* @__PURE__ */ __name((value) => toBytePayload(value), "serialize"),
+  deserialize: /* @__PURE__ */ __name((payload) => {
+    const bytes = assertBytePayload(payload, "Buffer");
+    const runtimeBufferConstructor = getRuntimeBufferConstructor();
+    if (runtimeBufferConstructor) {
+      return runtimeBufferConstructor.from(bytes);
+    }
+    return Uint8Array.from(bytes);
+  }, "deserialize"),
+  strategy: "value"
+};
+var typedArrayTypes = typedArrayTypeIds.map(
+  (typeId) => createTypedArrayType(typeId)
+);
+var binaryBuiltInTypes = [
+  ArrayBufferType,
+  DataViewType,
+  BufferType,
+  ...typedArrayTypes
+];
+
+// src/serializer/error-url-builtins.ts
+var hasOwn = Object.prototype.hasOwnProperty;
+var errorReservedPropertyNames = /* @__PURE__ */ new Set([
+  "name",
+  "message",
+  "stack",
+  "cause"
+]);
+var isRecord = /* @__PURE__ */ __name((value) => typeof value === "object" && value !== null && !Array.isArray(value), "isRecord");
+var isUnsafePropertyName = /* @__PURE__ */ __name((propertyName) => propertyName === "__proto__" || propertyName === "constructor" || propertyName === "prototype", "isUnsafePropertyName");
+var collectErrorCustomFields = /* @__PURE__ */ __name((error2) => {
+  const customFields = {};
+  for (const propertyName of Object.getOwnPropertyNames(error2)) {
+    if (errorReservedPropertyNames.has(propertyName)) {
+      continue;
+    }
+    if (isUnsafePropertyName(propertyName)) {
+      continue;
+    }
+    const descriptor = Object.getOwnPropertyDescriptor(error2, propertyName);
+    if (!descriptor || !("value" in descriptor)) {
+      continue;
+    }
+    customFields[propertyName] = descriptor.value;
+  }
+  return customFields;
+}, "collectErrorCustomFields");
+var assertSerializedErrorPayload = /* @__PURE__ */ __name((value) => {
+  if (!isRecord(value)) {
+    throw new Error("Invalid Error payload");
+  }
+  const { name, message, stack, customFields } = value;
+  if (typeof name !== "string" || typeof message !== "string") {
+    throw new Error("Invalid Error payload");
+  }
+  if (stack !== void 0 && typeof stack !== "string") {
+    throw new Error("Invalid Error payload");
+  }
+  if (customFields !== void 0 && !isRecord(customFields)) {
+    throw new Error("Invalid Error payload");
+  }
+  const normalizedCustomFields = {};
+  const customFieldEntries = Object.entries(customFields ?? {});
+  for (const [propertyName, propertyValue] of customFieldEntries) {
+    if (isUnsafePropertyName(propertyName)) {
+      continue;
+    }
+    normalizedCustomFields[propertyName] = propertyValue;
+  }
+  return {
+    name,
+    message,
+    stack,
+    hasCause: hasOwn.call(value, "cause"),
+    cause: value.cause,
+    customFields: normalizedCustomFields
+  };
+}, "assertSerializedErrorPayload");
+var getUrlConstructor = /* @__PURE__ */ __name(() => {
+  const value = globalThis.URL;
+  if (typeof value !== "function") {
+    return null;
+  }
+  return value;
+}, "getUrlConstructor");
+var getUrlSearchParamsConstructor = /* @__PURE__ */ __name(() => {
+  const value = globalThis.URLSearchParams;
+  if (typeof value !== "function") {
+    return null;
+  }
+  return value;
+}, "getUrlSearchParamsConstructor");
+var ErrorType = {
+  id: "Error",
+  is: /* @__PURE__ */ __name((value) => value instanceof Error, "is"),
+  serialize: /* @__PURE__ */ __name((error2) => {
+    const serializedErrorPayload = {
+      name: error2.name,
+      message: error2.message,
+      customFields: collectErrorCustomFields(error2)
+    };
+    if (typeof error2.stack === "string") {
+      serializedErrorPayload.stack = error2.stack;
+    }
+    if (hasOwn.call(error2, "cause")) {
+      serializedErrorPayload.cause = error2.cause;
+    }
+    return serializedErrorPayload;
+  }, "serialize"),
+  deserialize: /* @__PURE__ */ __name((payload) => {
+    const { name, message, stack, hasCause, cause, customFields } = assertSerializedErrorPayload(payload);
+    const restoredError = new Error(message);
+    restoredError.name = name;
+    if (stack !== void 0) {
+      Object.defineProperty(restoredError, "stack", {
+        value: stack,
+        writable: true,
+        configurable: true,
+        enumerable: false
+      });
+    }
+    if (hasCause) {
+      Object.defineProperty(restoredError, "cause", {
+        value: cause,
+        writable: true,
+        configurable: true,
+        enumerable: false
+      });
+    }
+    for (const [propertyName, propertyValue] of Object.entries(customFields)) {
+      if (errorReservedPropertyNames.has(propertyName)) {
+        continue;
+      }
+      restoredError[propertyName] = propertyValue;
+    }
+    return restoredError;
+  }, "deserialize")
+};
+var URLType = {
+  id: "URL",
+  is: /* @__PURE__ */ __name((value) => {
+    const runtimeUrlConstructor = getUrlConstructor();
+    if (!runtimeUrlConstructor) {
+      return false;
+    }
+    return value instanceof runtimeUrlConstructor;
+  }, "is"),
+  serialize: /* @__PURE__ */ __name((value) => value.href, "serialize"),
+  deserialize: /* @__PURE__ */ __name((payload) => {
+    if (typeof payload !== "string") {
+      throw new Error("Invalid URL payload");
+    }
+    const runtimeUrlConstructor = getUrlConstructor();
+    if (!runtimeUrlConstructor) {
+      throw new Error("URL is not available in this runtime");
+    }
+    return new runtimeUrlConstructor(payload);
+  }, "deserialize"),
+  strategy: "value"
+};
+var URLSearchParamsType = {
+  id: "URLSearchParams",
+  is: /* @__PURE__ */ __name((value) => {
+    const runtimeUrlSearchParamsConstructor = getUrlSearchParamsConstructor();
+    if (!runtimeUrlSearchParamsConstructor) {
+      return false;
+    }
+    return value instanceof runtimeUrlSearchParamsConstructor;
+  }, "is"),
+  serialize: /* @__PURE__ */ __name((value) => value.toString(), "serialize"),
+  deserialize: /* @__PURE__ */ __name((payload) => {
+    if (typeof payload !== "string") {
+      throw new Error("Invalid URLSearchParams payload");
+    }
+    const runtimeUrlSearchParamsConstructor = getUrlSearchParamsConstructor();
+    if (!runtimeUrlSearchParamsConstructor) {
+      throw new Error("URLSearchParams is not available in this runtime");
+    }
+    return new runtimeUrlSearchParamsConstructor(payload);
+  }, "deserialize"),
+  strategy: "value"
+};
+var errorAndUrlBuiltInTypes = [
+  ErrorType,
+  URLType,
+  URLSearchParamsType
+];
 
 // src/serializer/special-values.ts
 var serializeUndefined = /* @__PURE__ */ __name(() => ({
@@ -29989,7 +30512,9 @@ var builtInTypes = [
   UndefinedType,
   NonFiniteNumberType,
   BigIntType,
-  SymbolType
+  SymbolType,
+  ...errorAndUrlBuiltInTypes,
+  ...binaryBuiltInTypes
 ];
 
 // src/serializer/type-registry.ts
@@ -30480,7 +31005,7 @@ var serializeTreeValue = /* @__PURE__ */ __name((value, context, depth, options)
 }, "serializeTreeValue");
 
 // src/serializer/deserializer.ts
-var hasOwn = Object.prototype.hasOwnProperty;
+var hasOwn2 = Object.prototype.hasOwnProperty;
 var copyOwnProperties = /* @__PURE__ */ __name((target, source, unsafeKeys) => {
   const descriptors = Object.getOwnPropertyDescriptors(source);
   for (const key of Object.keys(descriptors)) {
@@ -30561,7 +31086,7 @@ var deserializeValue = /* @__PURE__ */ __name((value, context, depth, options) =
   const obj = {};
   const source = value;
   for (const key in source) {
-    if (!hasOwn.call(source, key)) {
+    if (!hasOwn2.call(source, key)) {
       continue;
     }
     if (isUnsafeKey(key, options.unsafeKeys)) {
@@ -30606,7 +31131,7 @@ var resolveReference = /* @__PURE__ */ __name((id2, context, depth, options) =>
       context.resolved.set(id2, target);
       const source = node.value;
       for (const key in source) {
-        if (!hasOwn.call(source, key)) {
+        if (!hasOwn2.call(source, key)) {
           continue;
         }
         if (isUnsafeKey(key, options.unsafeKeys)) {
@@ -30678,7 +31203,7 @@ var mergePlaceholder = /* @__PURE__ */ __name((placeholder, result, unsafeKeys)
     const target = placeholder;
     const source = result;
     for (const key in source) {
-      if (!hasOwn.call(source, key)) {
+      if (!hasOwn2.call(source, key)) {
         continue;
       }
       if (isUnsafeKey(key, unsafeKeys)) {
@@ -30711,7 +31236,7 @@ var deserializeLegacy = /* @__PURE__ */ __name((value, depth, options) => {
   const obj = {};
   const source = value;
   for (const key in source) {
-    if (!hasOwn.call(source, key)) {
+    if (!hasOwn2.call(source, key)) {
       continue;
     }
     if (isUnsafeKey(key, options.unsafeKeys)) {
@@ -30722,6 +31247,26 @@ var deserializeLegacy = /* @__PURE__ */ __name((value, depth, options) => {
   return obj;
 }, "deserializeLegacy");
 
+// src/serializer/option-normalizers.ts
+var normalizeMaxDepth = /* @__PURE__ */ __name((value, fallback) => {
+  if (value === Number.POSITIVE_INFINITY) {
+    return Number.POSITIVE_INFINITY;
+  }
+  if (typeof value === "number" && Number.isFinite(value) && value >= 0) {
+    return Math.floor(value);
+  }
+  return fallback;
+}, "normalizeMaxDepth");
+var normalizeMaxRegExpPatternLength = /* @__PURE__ */ __name((value, fallback) => {
+  if (value === Number.POSITIVE_INFINITY) {
+    return Number.POSITIVE_INFINITY;
+  }
+  if (typeof value === "number" && Number.isFinite(value) && value > 0) {
+    return Math.floor(value);
+  }
+  return fallback;
+}, "normalizeMaxRegExpPatternLength");
+
 // src/serializer/Serializer.ts
 var GRAPH_VERSION = 1;
 var DEFAULT_MAX_DEPTH = 1e3;
@@ -30757,10 +31302,11 @@ var Serializer = class {
       return check(pattern, index);
     }, "isBoundedQuantifier");
     this.indent = options.pretty ? 2 : void 0;
-    const maxDepth = options.maxDepth;
-    this.maxDepth = typeof maxDepth === "number" && Number.isFinite(maxDepth) && maxDepth >= 0 ? Math.floor(maxDepth) : DEFAULT_MAX_DEPTH;
-    const maxPatternLength = options.maxRegExpPatternLength;
-    this.maxRegExpPatternLength = maxPatternLength === Number.POSITIVE_INFINITY ? Number.POSITIVE_INFINITY : typeof maxPatternLength === "number" && Number.isFinite(maxPatternLength) && maxPatternLength > 0 ? Math.floor(maxPatternLength) : DEFAULT_MAX_REGEXP_PATTERN_LENGTH;
+    this.maxDepth = normalizeMaxDepth(options.maxDepth, DEFAULT_MAX_DEPTH);
+    this.maxRegExpPatternLength = normalizeMaxRegExpPatternLength(
+      options.maxRegExpPatternLength,
+      DEFAULT_MAX_REGEXP_PATTERN_LENGTH
+    );
     this.allowUnsafeRegExp = options.allowUnsafeRegExp ?? false;
     this.unsafeKeys = DEFAULT_UNSAFE_KEYS;
     this.typeRegistry = new TypeRegistry({
@@ -30895,13 +31441,6 @@ var Serializer = class {
   }
 };
 
-// src/serializer/index.ts
-var defaultSerializer = new Serializer();
-function getDefaultSerializer() {
-  return defaultSerializer;
-}
-__name(getDefaultSerializer, "getDefaultSerializer");
-
 // src/definers/defineAsyncContext.ts
 var platform = getPlatform();
 var storage = platform.createAsyncLocalStorage();
@@ -30909,13 +31448,14 @@ function getCurrentStore() {
   return storage.getStore();
 }
 __name(getCurrentStore, "getCurrentStore");
-function defineAsyncContext(def) {
+function defineAsyncContext(def, filePath) {
   if (!platform.hasAsyncLocalStorage()) {
     platformUnsupportedFunctionError.throw({
       functionName: `createAsyncLocalStorage: Cannot create context ${def.id}: no async storage available in this environment`
     });
   }
   const ctxId = def.id;
+  const resolvedFilePath = filePath ?? getCallerFile();
   const use = /* @__PURE__ */ __name(() => {
     const store2 = getCurrentStore();
     if (!store2 || !store2.has(ctxId)) {
@@ -30932,10 +31472,11 @@ function defineAsyncContext(def) {
     map.set(ctxId, value);
     return storage.run(map, fn);
   }, "provide");
-  const serializer3 = getDefaultSerializer();
+  const serializer3 = new Serializer();
   const api = {
     id: ctxId,
     [symbolAsyncContext]: true,
+    [symbolFilePath]: resolvedFilePath,
     use,
     /* istanbul ignore next */
     provide(value, fn) {
@@ -31587,12 +32128,12 @@ var EventManager = class {
         data,
         timestamp: /* @__PURE__ */ new Date(),
         source,
-        meta: eventDefinition.meta || {},
+        meta: { ...eventDefinition.meta || {} },
         stopPropagation: /* @__PURE__ */ __name(() => {
           propagationStopped = true;
         }, "stopPropagation"),
         isPropagationStopped: /* @__PURE__ */ __name(() => propagationStopped, "isPropagationStopped"),
-        tags: eventDefinition.tags
+        tags: [...eventDefinition.tags]
       };
       const baseEmit = /* @__PURE__ */ __name(async (eventToEmit) => {
         if (allListeners.length === 0) {
@@ -31618,10 +32159,14 @@ var EventManager = class {
         if (!interceptor) {
           return baseEmit(eventToEmit);
         }
-        return interceptor(
-          (nextEvent) => runInterceptor(index + 1, nextEvent),
-          eventToEmit
-        );
+        return interceptor((nextEvent) => {
+          this.assertPropagationMethodsUnchanged(
+            eventDefinition.id,
+            eventToEmit,
+            nextEvent
+          );
+          return runInterceptor(index + 1, nextEvent);
+        }, eventToEmit);
       }, "runInterceptor");
       await runInterceptor(0, event2);
       return deepestEvent;
@@ -31732,21 +32277,24 @@ var EventManager = class {
       lockedError.throw({ what: "EventManager" });
     }
   }
-  /**
-   * Clears all listeners and interceptors.
-   * Call this to release references and free memory.
-   */
-  clear() {
-    this.registry.clear();
-    this.emissionInterceptors.length = 0;
-    this.hookInterceptors.length = 0;
+  assertPropagationMethodsUnchanged(eventId, currentEvent, nextEvent) {
+    if (nextEvent.stopPropagation !== currentEvent.stopPropagation || nextEvent.isPropagationStopped !== currentEvent.isPropagationStopped) {
+      validationError.throw({
+        subject: "Event interceptor",
+        id: eventId,
+        originalError: new Error(
+          "Interceptors cannot override stopPropagation/isPropagationStopped"
+        )
+      });
+    }
   }
   /**
    * Disposes the EventManager, releasing all listeners and interceptors.
-   * Alias for clear() following the IResource disposal pattern.
    */
   dispose() {
-    this.clear();
+    this.registry.clear();
+    this.emissionInterceptors.length = 0;
+    this.hookInterceptors.length = 0;
   }
   /**
    * Retrieves cached merged listeners for an event, or creates them if not cached.
@@ -33053,7 +33601,7 @@ var TaskRunner = class {
     __name(this, "TaskRunner");
   }
   /**
-   * Begins the execution of an task. These are registered tasks and all sanity checks have been performed at this stage to ensure consistency of the object.
+   * Begins the execution of a task. These are registered tasks and all sanity checks have been performed at this stage to ensure consistency of the object.
    * This function can throw only if any of the event listeners or run function throws
    * @param task the task to be run
    * @param input the input to be passed to the task
@@ -33082,8 +33630,6 @@ var TaskRunner = class {
   /**
    * Creates the function with the chain of middleware.
    * @param task
-   * @param input
-   * @param taskDependencies
    * @returns
    */
   createRunnerWithMiddleware(task2) {
@@ -33103,7 +33649,7 @@ var ResourceInitializer = class {
     __name(this, "ResourceInitializer");
   }
   /**
-   * Begins the execution of an task. These are registered tasks and all sanity checks have been performed at this stage to ensure consistency of the object.
+   * Begins the execution of a task. These are registered tasks and all sanity checks have been performed at this stage to ensure consistency of the object.
    * This function can throw only if any of the event listeners or run function throws
    */
   async initializeResource(resource2, config, dependencies) {
@@ -33593,23 +34139,28 @@ var DependencyProcessor = class {
       middleware.computedDependencies = computedDependencies;
       middleware.isInitialized = true;
     }
-    for (const resource2 of this.store.resources.values()) {
-      await this.processResourceDependencies(resource2);
-    }
-    for (const task2 of this.store.tasks.values()) {
-      await this.computeTaskDependencies(task2);
-    }
     for (const hookStoreElement of this.store.hooks.values()) {
       const hook2 = hookStoreElement.hook;
       const deps = hook2.dependencies;
+      hookStoreElement.dependencyState = "computing" /* Computing */;
       hookStoreElement.computedDependencies = await this.extractDependencies(
         deps,
         hook2.id
       );
+      hookStoreElement.dependencyState = "ready" /* Ready */;
+    }
+    for (const resource2 of this.store.resources.values()) {
+      await this.processResourceDependencies(resource2);
+    }
+    for (const task2 of this.store.tasks.values()) {
+      await this.computeTaskDependencies(task2);
     }
     await this.initializeUninitializedResources();
   }
   async computeTaskDependencies(task2) {
+    if (task2.isInitialized) {
+      return;
+    }
     const deps = task2.task.dependencies;
     task2.computedDependencies = await this.extractDependencies(
       deps,
@@ -33741,6 +34292,9 @@ var DependencyProcessor = class {
           if (receivedEvent.source === hook2.id) {
             return;
           }
+          if (hookStoreElement.dependencyState !== "ready" /* Ready */) {
+            return;
+          }
           return this.eventManager.executeHookWithInterceptors(
             hook2,
             receivedEvent,
@@ -33857,7 +34411,7 @@ var DependencyProcessor = class {
     }
     const st = storeTask;
     if (!st.isInitialized) {
-      const dependencies = object.dependencies;
+      const dependencies = st.task.dependencies;
       st.computedDependencies = await this.extractDependencies(
         dependencies,
         st.task.id
@@ -33883,14 +34437,19 @@ var DependencyProcessor = class {
         wrapped = this.wrapResourceDependencies(depMap, raw);
         sr.computedDependencies = wrapped;
       }
-      const { value, context } = await this.resourceInitializer.initializeResource(
-        resource2,
-        config,
-        wrapped
-      );
-      sr.context = context;
-      sr.value = value;
-      sr.isInitialized = true;
+      try {
+        const { value, context } = await this.resourceInitializer.initializeResource(
+          resource2,
+          config,
+          wrapped
+        );
+        sr.context = context;
+        sr.value = value;
+        sr.isInitialized = true;
+        this.store.recordResourceInitialized(resource2.id);
+      } catch (error2) {
+        this.rethrowResourceInitError(resource2.id, error2);
+      }
     }
     return sr.value;
   }
@@ -34093,7 +34652,8 @@ var StoreRegistry = class {
     const hook2 = this.getFreshValue(item, this.hooks, "hook", overrideMode);
     this.hooks.set(hook2.id, {
       hook: hook2,
-      computedDependencies: {}
+      computedDependencies: {},
+      dependencyState: "pending" /* Pending */
     });
   }
   storeTaskMiddleware(item, storingMode = "normal") {
@@ -34148,7 +34708,10 @@ var StoreRegistry = class {
     return prepared;
   }
   computeRegistrationDeeply(element, config) {
-    const items = typeof element.register === "function" ? element.register(config) : element.register;
+    let items = typeof element.register === "function" ? element.register(config) : element.register;
+    if (!items) {
+      items = [];
+    }
     element.register = items;
     for (const item of items) {
       this.storeGenericItem(item);
@@ -34686,25 +35249,27 @@ var InterceptorRegistry = class {
    * Gets all global task interceptors
    */
   getGlobalTaskInterceptors() {
-    return this.taskInterceptors;
+    return Object.freeze([...this.taskInterceptors]);
   }
   /**
    * Gets all global resource interceptors
    */
   getGlobalResourceInterceptors() {
-    return this.resourceInterceptors;
+    return Object.freeze([...this.resourceInterceptors]);
   }
   /**
    * Gets interceptors for a specific task middleware
    */
   getTaskMiddlewareInterceptors(middlewareId) {
-    return this.perTaskMiddleware.get(middlewareId) || [];
+    const interceptors = this.perTaskMiddleware.get(middlewareId) ?? [];
+    return Object.freeze([...interceptors]);
   }
   /**
    * Gets interceptors for a specific resource middleware
    */
   getResourceMiddlewareInterceptors(middlewareId) {
-    return this.perResourceMiddleware.get(middlewareId) || [];
+    const interceptors = this.perResourceMiddleware.get(middlewareId) ?? [];
+    return Object.freeze([...interceptors]);
   }
 };
 
@@ -35183,10 +35748,8 @@ var ResourceMiddlewareComposer = class {
 
 // src/models/MiddlewareManager.ts
 var MiddlewareManager = class {
-  constructor(store2, eventManager, logger) {
+  constructor(store2, _eventManager, _logger) {
     this.store = store2;
-    this.eventManager = eventManager;
-    this.logger = logger;
     this.interceptorRegistry = new InterceptorRegistry();
     this.middlewareResolver = new MiddlewareResolver(store2);
     this.taskComposer = new TaskMiddlewareComposer(
@@ -35227,14 +35790,6 @@ var MiddlewareManager = class {
   lock() {
     this.interceptorRegistry.lock();
   }
-  /**
-   * Adds an interceptor for task or resource middleware execution
-   * Interceptors are executed in the order they are added, with the ability to
-   * modify, log, or prevent middleware execution
-   *
-   * @param kind - The type of middleware to intercept ("task" or "resource")
-   * @param interceptor - The interceptor function to add
-   */
   intercept(kind, interceptor) {
     if (kind === "task") {
       this.interceptorRegistry.addGlobalTaskInterceptor(
@@ -35246,13 +35801,6 @@ var MiddlewareManager = class {
       );
     }
   }
-  /**
-   * Adds an interceptor for a specific middleware instance with better type safety
-   * This method automatically determines the type and provides type-safe access
-   *
-   * @param middleware - The middleware instance to intercept
-   * @param interceptor - The interceptor function with proper typing
-   */
   interceptMiddleware(middleware, interceptor) {
     if (isTaskMiddleware(middleware)) {
       this.interceptorRegistry.addTaskMiddlewareInterceptor(
@@ -35391,12 +35939,17 @@ var Store = class {
     }
   }
   registerGlobalComponents() {
+    if (!this.taskRunner) {
+      throw new Error(
+        "TaskRunner is not set. Call store.setTaskRunner() before initializeStore()."
+      );
+    }
     const builtInResourcesMap = /* @__PURE__ */ new Map();
     builtInResourcesMap.set(globalResources.store, this);
     builtInResourcesMap.set(globalResources.eventManager, this.eventManager);
     builtInResourcesMap.set(globalResources.logger, this.logger);
     builtInResourcesMap.set(globalResources.taskRunner, this.taskRunner);
-    builtInResourcesMap.set(globalResources.serializer, getDefaultSerializer());
+    builtInResourcesMap.set(globalResources.serializer, new Serializer());
     builtInResourcesMap.set(
       globalResources.middlewareManager,
       this.middlewareManager
@@ -35456,8 +36009,11 @@ var Store = class {
   setTaskRunner(taskRunner) {
     this.taskRunner = taskRunner;
   }
-  setupRootResource(root, config) {
-    root.dependencies = typeof root.dependencies === "function" ? root.dependencies(config) : root.dependencies;
+  setupRootResource(rootDefinition, config) {
+    const root = {
+      ...rootDefinition,
+      dependencies: typeof rootDefinition.dependencies === "function" ? rootDefinition.dependencies(config) : rootDefinition.dependencies
+    };
     this.root = {
       resource: root,
       computedDependencies: {},
@@ -36010,6 +36566,18 @@ var RunResult = class {
       }
       return this.store.resources.get(resourceId).value;
     }, "getResourceValue");
+    /**
+     * Get the config of a resource from the run result.
+     * @param resource - The resource to get the config of.
+     * @returns The config passed for the resource.
+     */
+    this.getResourceConfig = /* @__PURE__ */ __name((resource2) => {
+      const resourceId = typeof resource2 === "string" ? resource2 : resource2.id;
+      if (!this.store.resources.has(resourceId)) {
+        throw new Error(`Resource "${resourceId}" not found.`);
+      }
+      return this.store.resources.get(resourceId).config;
+    }, "getResourceConfig");
     this.dispose = /* @__PURE__ */ __name(() => {
       return this.disposeFn();
     }, "dispose");
@@ -37191,7 +37759,7 @@ function makeAsyncContextBuilder(state) {
         configSchema: state.configSchema,
         meta: state.meta
       };
-      return defineAsyncContext(def);
+      return defineAsyncContext(def, state.filePath);
     }
   };
   return builder;
@@ -37200,8 +37768,10 @@ __name(makeAsyncContextBuilder, "makeAsyncContextBuilder");
 
 // src/definers/builders/asyncContext/index.ts
 function asyncContextBuilder(id2) {
+  const filePath = getCallerFile();
   const initial = Object.freeze({
     id: id2,
+    filePath,
     serialize: void 0,
     parse: void 0,
     configSchema: void 0,
@@ -37674,7 +38244,7 @@ function override(base) {
 }
 __name(override, "override");
 
-// src/index.ts
+// src/public.ts
 init_http_fetch_tunnel_resource();
 var globals = {
   events: globalEvents,
@@ -38818,15 +39388,15 @@ var UNSAFE_ERROR_FIELDS = /* @__PURE__ */ new Set([
   "cause" /* Cause */,
   "sql" /* Sql */
 ]);
-var isRecord = /* @__PURE__ */ __name((value) => !!value && typeof value === "object", "isRecord");
-var isJsonBody = /* @__PURE__ */ __name((value) => isRecord(value) && typeof value.ok === "boolean", "isJsonBody");
-var toErrorRecord = /* @__PURE__ */ __name((value) => isRecord(value) ? value : void 0, "toErrorRecord");
+var isRecord2 = /* @__PURE__ */ __name((value) => !!value && typeof value === "object", "isRecord");
+var isJsonBody = /* @__PURE__ */ __name((value) => isRecord2(value) && typeof value.ok === "boolean", "isJsonBody");
+var toErrorRecord = /* @__PURE__ */ __name((value) => isRecord2(value) ? value : void 0, "toErrorRecord");
 var sanitizeErrorResponse = /* @__PURE__ */ __name((response) => {
-  const asRecord = isRecord(response) ? response : void 0;
+  const asRecord = isRecord2(response) ? response : void 0;
   const statusRaw = asRecord?.status ?? asRecord?.statusCode;
   const status = typeof statusRaw === "number" && Number.isFinite(statusRaw) ? statusRaw : 500;
   const bodyRaw = asRecord?.body;
-  const body = isRecord(bodyRaw) ? bodyRaw : void 0;
+  const body = isRecord2(bodyRaw) ? bodyRaw : void 0;
   const errorRaw = (body ? toErrorRecord(body.error) : void 0) ?? toErrorRecord(asRecord?.error);
   const normalizedBody = (() => {
     if (isJsonBody(bodyRaw)) {
@@ -38883,7 +39453,7 @@ var resolveAppErrorExtra = /* @__PURE__ */ __name((store2, error2) => {
   try {
     for (const helper of store2.errors.values()) {
       if (helper.is(error2)) {
-        if (!isRecord(error2)) return { id: void 0, data: void 0 };
+        if (!isRecord2(error2)) return { id: void 0, data: void 0 };
         const name = error2["name" /* Name */];
         const id2 = typeof name === "string" ? name : void 0;
         const data = error2["data" /* Data */];
@@ -39599,10 +40169,10 @@ function createDurableStepId(id2) {
   return { id: id2 };
 }
 __name(createDurableStepId, "createDurableStepId");
-function isRecord2(value) {
+function isRecord3(value) {
   return typeof value === "object" && value !== null;
 }
-__name(isRecord2, "isRecord");
+__name(isRecord3, "isRecord");
 function sleepMs(ms) {
   return new Promise((resolve) => {
     const timer = setTimeout$1(resolve, ms);
@@ -39632,7 +40202,7 @@ function createExecutionId() {
 }
 __name(createExecutionId, "createExecutionId");
 function parseSignalState(value) {
-  if (!isRecord2(value)) return null;
+  if (!isRecord3(value)) return null;
   const state = value.state;
   if (state === "waiting") {
     const timerId = value.timerId;
@@ -39674,6 +40244,7 @@ var DurableAuditEntryKind = {
   SignalDelivered: "signal_delivered",
   SignalTimedOut: "signal_timed_out",
   EmitPublished: "emit_published",
+  SwitchEvaluated: "switch_evaluated",
   Note: "note"
 };
 function isDurableInternalStepId(stepId) {
@@ -39697,15 +40268,194 @@ var SuspensionSignal = class extends Error {
   }
 };
 
+// src/node/durable/core/DurableOperator.ts
+var DurableOperator = class {
+  constructor(store2) {
+    this.store = store2;
+  }
+  static {
+    __name(this, "DurableOperator");
+  }
+  async listExecutions(options) {
+    if (this.store.listExecutions) {
+      return await this.store.listExecutions(options);
+    }
+    return await this.store.listIncompleteExecutions();
+  }
+  async getExecutionDetail(executionId) {
+    const execution = await this.store.getExecution(executionId);
+    const steps = this.store.listStepResults ? await this.store.listStepResults(executionId) : [];
+    const audit = this.store.listAuditEntries ? await this.store.listAuditEntries(executionId) : [];
+    return { execution, steps, audit };
+  }
+  /**
+   * Resets an execution from `compensation_failed` (or other states) to `pending`.
+   * This effectively retries the workflow from the last memoized step.
+   */
+  async retryRollback(executionId) {
+    if (!this.store.retryRollback) {
+      throw new Error("Store does not support retryRollback");
+    }
+    await this.store.retryRollback(executionId);
+  }
+  /**
+   * Manually marks a step as completed with a specific result.
+   * Useful for skipping broken steps or providing a manual fix.
+   */
+  async skipStep(executionId, stepId) {
+    if (!this.store.skipStep) {
+      throw new Error("Store does not support skipStep");
+    }
+    await this.store.skipStep(executionId, stepId);
+  }
+  /**
+   * Forces an execution to the `failed` state.
+   */
+  async forceFail(executionId, reason) {
+    if (!this.store.forceFail) {
+      throw new Error("Store does not support forceFail");
+    }
+    await this.store.forceFail(executionId, { message: reason });
+  }
+  /**
+   * Manually patches the result of a step.
+   * Useful when a step failed to save its result but the side effect occurred.
+   */
+  async editState(executionId, stepId, newState) {
+    if (!this.store.editStepResult) {
+      throw new Error("Store does not support editStepResult");
+    }
+    await this.store.editStepResult(executionId, stepId, newState);
+  }
+  /**
+   * Lists all executions that require manual intervention.
+   */
+  async listStuckExecutions() {
+    if (!this.store.listStuckExecutions) {
+      throw new Error("Store does not support listStuckExecutions");
+    }
+    return await this.store.listStuckExecutions();
+  }
+};
+
+// src/node/durable/core/flowShape.ts
+var FlowRecorder = class {
+  constructor() {
+    this.nodes = [];
+    this.executionId = "__flow_record__";
+    this.attempt = 0;
+  }
+  static {
+    __name(this, "FlowRecorder");
+  }
+  resolveStepId(stepId) {
+    return typeof stepId === "string" ? stepId : stepId.id;
+  }
+  step(stepId, optionsOrFn, _fn) {
+    const id2 = this.resolveStepId(stepId);
+    if (optionsOrFn === void 0) {
+      return new FlowStepRecorder(this, id2);
+    }
+    this.nodes.push({ kind: "step", stepId: id2, hasCompensation: false });
+    return Promise.resolve(void 0);
+  }
+  async sleep(durationMs, options) {
+    this.nodes.push({
+      kind: "sleep",
+      durationMs,
+      stepId: options?.stepId
+    });
+  }
+  async waitForSignal(signal, options) {
+    this.nodes.push({
+      kind: "waitForSignal",
+      signalId: signal.id,
+      timeoutMs: options?.timeoutMs,
+      stepId: options?.stepId
+    });
+    return void 0;
+  }
+  async emit(_event, _payload, options) {
+    this.nodes.push({
+      kind: "emit",
+      eventId: _event.id,
+      stepId: options?.stepId
+    });
+  }
+  async switch(stepId, _value, branches, defaultBranch) {
+    this.nodes.push({
+      kind: "switch",
+      stepId,
+      branchIds: branches.map((b) => b.id),
+      hasDefault: defaultBranch !== void 0
+    });
+    return void 0;
+  }
+  async note(message, _meta) {
+    this.nodes.push({ kind: "note", message });
+  }
+  async rollback() {
+  }
+};
+var FlowStepRecorder = class {
+  constructor(recorder, stepId) {
+    this.recorder = recorder;
+    this.stepId = stepId;
+    this.hasDown = false;
+  }
+  static {
+    __name(this, "FlowStepRecorder");
+  }
+  up(_fn) {
+    return this;
+  }
+  down(_fn) {
+    this.hasDown = true;
+    return this;
+  }
+  then(onfulfilled, onrejected) {
+    this.recorder.nodes.push({
+      kind: "step",
+      stepId: this.stepId,
+      hasCompensation: this.hasDown
+    });
+    const result = Promise.resolve(void 0);
+    return result.then(
+      onfulfilled ?? ((v) => v),
+      onrejected
+    );
+  }
+};
+async function recordFlowShape(descriptor) {
+  const recorder = new FlowRecorder();
+  await descriptor(recorder);
+  return { nodes: recorder.nodes };
+}
+__name(recordFlowShape, "recordFlowShape");
+
 // src/node/durable/core/DurableResource.ts
-var DurableResource = class {
-  constructor(service, contextStorage) {
+var DurableResource = class _DurableResource {
+  constructor(service, contextStorage, store2, runnerStore) {
     this.service = service;
     this.contextStorage = contextStorage;
+    this.store = store2;
+    this.runnerStore = runnerStore;
+    this.operatorInstance = null;
   }
   static {
     __name(this, "DurableResource");
   }
+  get operator() {
+    if (!this.store) {
+      throw new Error(
+        "Durable operator API is not available: store was not provided to DurableResource. Use a Runner durable resource (durableResource/memoryDurableResource/redisDurableResource) or construct a DurableOperator(store) directly."
+      );
+    }
+    if (!this.operatorInstance) {
+      this.operatorInstance = new DurableOperator(this.store);
+    }
+    return this.operatorInstance;
+  }
   use() {
     const ctx = this.contextStorage.getStore();
     if (!ctx) {
@@ -39715,6 +40465,47 @@ var DurableResource = class {
     }
     return ctx;
   }
+  async describe(task2, input) {
+    if (!this.runnerStore) {
+      throw new Error(
+        "Durable describe API is not available: runner store was not provided to DurableResource. Use a Runner durable resource (durableResource/memoryDurableResource/redisDurableResource) instead of manually constructing DurableResource."
+      );
+    }
+    const storeTask = this.runnerStore.tasks.get(task2.id);
+    if (!storeTask) {
+      throw new Error(
+        `Cannot describe task "${task2.id}": task is not registered in the runtime store.`
+      );
+    }
+    const effectiveTask = storeTask.task;
+    if (!storeTask.computedDependencies) {
+      throw new Error(
+        `Cannot describe task "${task2.id}": task dependencies are not available in the runtime store.`
+      );
+    }
+    const deps = storeTask.computedDependencies;
+    return await recordFlowShape(async (ctx) => {
+      const depsWithRecorder = this.injectRecorderIntoDurableDeps(deps, ctx);
+      await effectiveTask.run(input, depsWithRecorder);
+    });
+  }
+  injectRecorderIntoDurableDeps(deps, ctx) {
+    const next = { ...deps };
+    for (const [key, value] of Object.entries(deps)) {
+      if (!(value instanceof _DurableResource)) {
+        continue;
+      }
+      next[key] = new Proxy(value, {
+        get(target, prop, receiver) {
+          if (prop === "use") {
+            return () => ctx;
+          }
+          return Reflect.get(target, prop, receiver);
+        }
+      });
+    }
+    return next;
+  }
   startExecution(task2, input, options) {
     return this.service.startExecution(task2, input, options);
   }
@@ -40410,7 +41201,7 @@ var ScheduleManager = class {
 // src/node/durable/core/managers/SignalHandler.ts
 var isWaitingSignalStep = /* @__PURE__ */ __name((step) => {
   const result = step.result;
-  if (!isRecord2(result)) return false;
+  if (!isRecord3(result)) return false;
   const waitResult = result;
   if (waitResult.state !== "waiting") return false;
   if (typeof waitResult.signalId !== "string") return false;
@@ -40887,7 +41678,7 @@ function getSignalId(signal) {
 }
 __name(getSignalId, "getSignalId");
 function parseSignalStepState(value) {
-  if (!isRecord2(value)) return null;
+  if (!isRecord3(value)) return null;
   const state = value.state;
   if (state === "waiting") {
     const signalId = value.signalId;
@@ -41083,6 +41874,58 @@ async function waitForSignalDurably(params) {
 }
 __name(waitForSignalDurably, "waitForSignalDurably");
 
+// src/node/durable/core/durable-context/DurableContext.switch.ts
+async function switchDurably(params) {
+  await params.assertNotCancelled();
+  params.assertUniqueStepId(params.stepId);
+  const cached = await params.store.getStepResult(
+    params.executionId,
+    params.stepId
+  );
+  if (cached) {
+    const persisted = cached.result;
+    return persisted.result;
+  }
+  const startedAt = Date.now();
+  let matchedBranch = null;
+  for (const branch of params.branches) {
+    if (branch.match(params.value)) {
+      matchedBranch = { id: branch.id, run: branch.run };
+      break;
+    }
+  }
+  if (!matchedBranch && params.defaultBranch) {
+    matchedBranch = {
+      id: params.defaultBranch.id,
+      run: params.defaultBranch.run
+    };
+  }
+  if (!matchedBranch) {
+    throw new Error(
+      `Durable switch '${params.stepId}': no branch matched and no default provided`
+    );
+  }
+  const result = await matchedBranch.run(params.value);
+  const durationMs = Date.now() - startedAt;
+  await params.store.saveStepResult({
+    executionId: params.executionId,
+    stepId: params.stepId,
+    result: {
+      branchId: matchedBranch.id,
+      result
+    },
+    completedAt: /* @__PURE__ */ new Date()
+  });
+  await params.appendAuditEntry({
+    kind: DurableAuditEntryKind.SwitchEvaluated,
+    stepId: params.stepId,
+    branchId: matchedBranch.id,
+    durationMs
+  });
+  return result;
+}
+__name(switchDurably, "switchDurably");
+
 // src/node/durable/core/DurableContext.ts
 var DurableContext = class {
   constructor(store2, bus, executionId, attempt, options = {}) {
@@ -41203,6 +42046,20 @@ var DurableContext = class {
       options
     });
   }
+  async switch(stepId, value, branches, defaultBranch) {
+    this.determinism.assertUserStepId(stepId);
+    return await switchDurably({
+      store: this.store,
+      executionId: this.executionId,
+      assertNotCancelled: this.assertNotCancelled.bind(this),
+      appendAuditEntry: this.audit.append,
+      assertUniqueStepId: this.determinism.assertUniqueStepId,
+      stepId,
+      value,
+      branches,
+      defaultBranch
+    });
+  }
   async note(message, meta) {
     if (!this.audit.isEnabled()) return;
     const stepId = `__note:${this.noteIndex}`;
@@ -42016,13 +42873,11 @@ async function initDurableWorker(service, queue) {
 }
 __name(initDurableWorker, "initDurableWorker");
 
-// src/node/durable/core/resource.ts
-var durableResource = r.resource("base.durable").register(durableEventsArray).dependencies({
-  taskRunner: globals.resources.taskRunner,
-  eventManager: globals.resources.eventManager,
-  runnerStore: globals.resources.store
-}).init(async (config, { taskRunner, eventManager, runnerStore }) => {
-  const runnerEmitter = createDurableRunnerAuditEmitter({ eventManager });
+// src/node/durable/core/createRunnerDurableRuntime.ts
+async function createRunnerDurableRuntime(config, deps) {
+  const runnerEmitter = createDurableRunnerAuditEmitter({
+    eventManager: deps.eventManager
+  });
   const userEmitter = config.audit?.emitter;
   const auditEmitter = userEmitter ? {
     emit: /* @__PURE__ */ __name(async (entry) => {
@@ -42045,7 +42900,10 @@ var durableResource = r.resource("base.durable").register(durableEventsArray).de
     },
     taskExecutor: {
       run: /* @__PURE__ */ __name(async (task2, input) => {
-        const outputPromise = await taskRunner.run(task2, input);
+        const outputPromise = await deps.taskRunner.run(
+          task2,
+          input
+        );
         if (outputPromise === void 0) {
           throw new Error(
             `Durable task '${task2.id}' completed without a result promise.`
@@ -42055,7 +42913,7 @@ var durableResource = r.resource("base.durable").register(durableEventsArray).de
       }, "run")
     },
     taskResolver: /* @__PURE__ */ __name((taskId) => {
-      const storeTask = runnerStore.tasks.get(taskId);
+      const storeTask = deps.runnerStore.tasks.get(taskId);
       return storeTask?.task;
     }, "taskResolver"),
     contextProvider: /* @__PURE__ */ __name((ctx, fn) => contextStorage.run(ctx, fn), "contextProvider")
@@ -42063,81 +42921,30 @@ var durableResource = r.resource("base.durable").register(durableEventsArray).de
   if (config.worker === true && config.queue) {
     await initDurableWorker(service, config.queue);
   }
-  return new DurableResource(service, contextStorage);
+  return new DurableResource(
+    service,
+    contextStorage,
+    config.store,
+    deps.runnerStore
+  );
+}
+__name(createRunnerDurableRuntime, "createRunnerDurableRuntime");
+
+// src/node/durable/core/resource.ts
+var durableResource = r.resource("base.durable").register(durableEventsArray).dependencies({
+  taskRunner: globals.resources.taskRunner,
+  eventManager: globals.resources.eventManager,
+  runnerStore: globals.resources.store
+}).init(async (config, { taskRunner, eventManager, runnerStore }) => {
+  return await createRunnerDurableRuntime(config, {
+    taskRunner,
+    eventManager,
+    runnerStore
+  });
 }).dispose(
   async (durable, config) => disposeDurableService(durable.service, config)
 ).build();
 
-// src/node/durable/core/DurableOperator.ts
-var DurableOperator = class {
-  constructor(store2) {
-    this.store = store2;
-  }
-  static {
-    __name(this, "DurableOperator");
-  }
-  async listExecutions(options) {
-    if (this.store.listExecutions) {
-      return await this.store.listExecutions(options);
-    }
-    return await this.store.listIncompleteExecutions();
-  }
-  async getExecutionDetail(executionId) {
-    const execution = await this.store.getExecution(executionId);
-    const steps = this.store.listStepResults ? await this.store.listStepResults(executionId) : [];
-    const audit = this.store.listAuditEntries ? await this.store.listAuditEntries(executionId) : [];
-    return { execution, steps, audit };
-  }
-  /**
-   * Resets an execution from `compensation_failed` (or other states) to `pending`.
-   * This effectively retries the workflow from the last memoized step.
-   */
-  async retryRollback(executionId) {
-    if (!this.store.retryRollback) {
-      throw new Error("Store does not support retryRollback");
-    }
-    await this.store.retryRollback(executionId);
-  }
-  /**
-   * Manually marks a step as completed with a specific result.
-   * Useful for skipping broken steps or providing a manual fix.
-   */
-  async skipStep(executionId, stepId) {
-    if (!this.store.skipStep) {
-      throw new Error("Store does not support skipStep");
-    }
-    await this.store.skipStep(executionId, stepId);
-  }
-  /**
-   * Forces an execution to the `failed` state.
-   */
-  async forceFail(executionId, reason) {
-    if (!this.store.forceFail) {
-      throw new Error("Store does not support forceFail");
-    }
-    await this.store.forceFail(executionId, { message: reason });
-  }
-  /**
-   * Manually patches the result of a step.
-   * Useful when a step failed to save its result but the side effect occurred.
-   */
-  async editState(executionId, stepId, newState) {
-    if (!this.store.editStepResult) {
-      throw new Error("Store does not support editStepResult");
-    }
-    await this.store.editStepResult(executionId, stepId, newState);
-  }
-  /**
-   * Lists all executions that require manual intervention.
-   */
-  async listStuckExecutions() {
-    if (!this.store.listStuckExecutions) {
-      throw new Error("Store does not support listStuckExecutions");
-    }
-    return await this.store.listStuckExecutions();
-  }
-};
-
 // src/node/durable/dashboard/server.ts
 var express = __toESM(require_express2());
 function findUp(startDir, filename) {
@@ -42521,7 +43328,7 @@ function createIORedisClient(url) {
 __name(createIORedisClient, "createIORedisClient");
 
 // src/node/durable/store/RedisStore.ts
-var serializer2 = getDefaultSerializer();
+var serializer2 = new Serializer();
 var RedisStore = class {
   static {
     __name(this, "RedisStore");
@@ -43265,6 +44072,114 @@ async function waitUntil(predicate, options) {
 }
 __name(waitUntil, "waitUntil");
 
+// src/node/durable/resources/memoryDurableResource.ts
+var memoryDurableResource = r.resource("base.durable.memory").register(durableEventsArray).dependencies({
+  taskRunner: globals.resources.taskRunner,
+  eventManager: globals.resources.eventManager,
+  runnerStore: globals.resources.store
+}).context(() => ({ runtimeConfig: null })).init(async function(config, { taskRunner, eventManager, runnerStore }, ctx) {
+  config.namespace ?? this.id;
+  const shouldCreateQueue = config.queue?.enabled ?? config.worker === true;
+  const queue = shouldCreateQueue ? new MemoryQueue() : void 0;
+  const worker = config.worker ?? Boolean(queue);
+  const runtimeConfig = {
+    ...config,
+    worker,
+    store: new MemoryStore(),
+    eventBus: new MemoryEventBus(),
+    queue
+  };
+  ctx.runtimeConfig = runtimeConfig;
+  return await createRunnerDurableRuntime(runtimeConfig, {
+    taskRunner,
+    eventManager,
+    runnerStore
+  });
+}).dispose(async (durable, _config, _deps, ctx) => {
+  if (!ctx.runtimeConfig) return;
+  await disposeDurableService(durable.service, ctx.runtimeConfig);
+}).build();
+
+// src/node/durable/resources/isolation.ts
+function normalizePrefix(prefix) {
+  return prefix.endsWith(":") ? prefix : `${prefix}:`;
+}
+__name(normalizePrefix, "normalizePrefix");
+function deriveDurableIsolation(params) {
+  if (params.namespace.trim().length === 0) {
+    validationError.throw({
+      subject: "Durable isolation namespace",
+      id: "params.namespace",
+      originalError: "must be a non-empty string"
+    });
+  }
+  const encodedNamespace = encodeURIComponent(params.namespace);
+  const storePrefix = normalizePrefix(
+    params.storePrefix ?? `durable:${encodedNamespace}:`
+  );
+  const busPrefix = normalizePrefix(
+    params.busPrefix ?? `durable:bus:${encodedNamespace}:`
+  );
+  return {
+    namespace: params.namespace,
+    encodedNamespace,
+    storePrefix,
+    busPrefix,
+    queueName: params.queueName ?? `durable_executions:${encodedNamespace}`,
+    deadLetterQueueName: params.deadLetterQueueName ?? `durable_executions:dlq:${encodedNamespace}`
+  };
+}
+__name(deriveDurableIsolation, "deriveDurableIsolation");
+
+// src/node/durable/resources/redisDurableResource.ts
+var redisDurableResource = r.resource("base.durable.redis").register(durableEventsArray).dependencies({
+  taskRunner: globals.resources.taskRunner,
+  eventManager: globals.resources.eventManager,
+  runnerStore: globals.resources.store
+}).context(() => ({ runtimeConfig: null })).init(async function(config, { taskRunner, eventManager, runnerStore }, ctx) {
+  const namespace = config.namespace ?? this.id;
+  const isolation = deriveDurableIsolation({
+    namespace,
+    storePrefix: config.store?.prefix,
+    busPrefix: config.eventBus?.prefix,
+    queueName: config.queue?.name,
+    deadLetterQueueName: config.queue?.deadLetter
+  });
+  const queue = config.queue ? new RabbitMQQueue({
+    url: config.queue.url,
+    prefetch: config.queue.prefetch,
+    queue: {
+      name: isolation.queueName,
+      quorum: config.queue.quorum,
+      deadLetter: isolation.deadLetterQueueName,
+      messageTtl: config.queue.messageTtl
+    }
+  }) : void 0;
+  const worker = config.worker ?? Boolean(queue);
+  const runtimeConfig = {
+    ...config,
+    worker,
+    store: new RedisStore({
+      redis: config.redis.url,
+      prefix: isolation.storePrefix
+    }),
+    eventBus: new RedisEventBus({
+      redis: config.redis.url,
+      prefix: isolation.busPrefix
+    }),
+    queue
+  };
+  ctx.runtimeConfig = runtimeConfig;
+  return await createRunnerDurableRuntime(runtimeConfig, {
+    taskRunner,
+    eventManager,
+    runnerStore
+  });
+}).dispose(async (durable, _config, _deps, ctx) => {
+  if (!ctx.runtimeConfig) return;
+  await disposeDurableService(durable.service, ctx.runtimeConfig);
+}).build();
+
 // src/node/node.ts
 var globals2 = {
   ...globals,
@@ -43595,6 +44510,6 @@ serve-static/index.js:
    *)
 */
 
-export { DependencyProcessor, DurableAuditEntryKind, DurableContext, DurableExecutionError, DurableOperator, DurableResource, DurableService, DurableWorker, errors_exports as Errors, EventManager, ExecutionStatus, Logger, MemoryEventBus, MemoryQueue, MemoryStore, MiddlewareManager, NoopEventBus, PlatformAdapter, Queue, RabbitMQQueue, RedisEventBus, RedisStore, ResourceInitializer, RunResult, ScheduleStatus, ScheduleType, Semaphore, Serializer, StepBuilder, Store, SuspensionSignal, TaskRunner, TimerStatus, TimerType, allFalse, defineAsyncContext as asyncContext, bindProcessErrorHandler, createContext2 as createContext, createDashboardMiddleware, createDefaultUnhandledError, createDurableAuditEntryId, createDurableRunnerAuditEmitter, createDurableStepId, createDurableTestSetup, createExposureFetch, createHttpClient, createHttpMixedClient, createHttpSmartClient, createNodeFile, createTestResource, debug, debugLevels, defs_exports as definitions, disposeDurableService, durableEvents, durableEventsArray, durableResource, defineEvent as event, getConfig, getDefaultSerializer, globals2 as globals, hasExposureContext, defineHook as hook, initDurableService, initDurableWorker, isDurableInternalStepId, journal, levelNormal, levelVerbose, nodeExposure, normalizeError, defineOverride as override, r, readInputFileToBuffer, defineResource as resource, defineResourceMiddleware as resourceMiddleware, run2 as run, safeReportUnhandledError, setPlatform, defineTag as tag, defineTask as task, defineTaskMiddleware as taskMiddleware, useExposureContext, waitUntil, writeInputFileToPath };
+export { DependencyProcessor, DurableAuditEntryKind, DurableContext, DurableExecutionError, DurableOperator, DurableResource, DurableService, DurableWorker, errors_exports as Errors, EventManager, ExecutionStatus, LogPrinter, Logger, MemoryEventBus, MemoryQueue, MemoryStore, MiddlewareManager, NoopEventBus, PlatformAdapter, Queue, RabbitMQQueue, RedisEventBus, RedisStore, ResourceInitializer, RunResult, ScheduleStatus, ScheduleType, Semaphore, Serializer, StepBuilder, Store, SuspensionSignal, SymbolPolicy, SymbolPolicyErrorMessage, TaskRunner, TimerStatus, TimerType, allFalse, defineAsyncContext as asyncContext, bindProcessErrorHandler, createContext2 as createContext, createDashboardMiddleware, createDefaultUnhandledError, createDurableAuditEntryId, createDurableRunnerAuditEmitter, createDurableStepId, createDurableTestSetup, createExposureFetch, createHttpClient, createHttpMixedClient, createHttpSmartClient, createNodeFile, createRunnerDurableRuntime, createTestResource, debug, debugLevels, defs_exports as definitions, disposeDurableService, durableEvents, durableEventsArray, durableResource, defineEvent as event, getConfig, globals2 as globals, hasExposureContext, defineHook as hook, initDurableService, initDurableWorker, isDurableInternalStepId, journal, levelNormal, levelVerbose, memoryDurableResource, nodeExposure, normalizeError, defineOverride as override, r, readInputFileToBuffer, redisDurableResource, defineResource as resource, defineResourceMiddleware as resourceMiddleware, run2 as run, safeReportUnhandledError, setPlatform, defineTag as tag, defineTask as task, defineTaskMiddleware as taskMiddleware, useExposureContext, waitUntil, writeInputFileToPath };
 //# sourceMappingURL=node.mjs.map
 //# sourceMappingURL=node.mjs.map