@bluelibs/runner 5.0.0 → 5.2.0

package/dist/node/node.cjs

@@ -2666,10 +2666,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];
         }
       }
@@ -6640,10 +6640,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];
         }
       }
@@ -20967,11 +20967,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) {
@@ -21954,7 +21954,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);
@@ -21979,11 +21979,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);
@@ -22032,7 +22032,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)) {
@@ -22050,7 +22050,7 @@ var require_get_intrinsic = __commonJS({
               value = value[part];
             }
           } else {
-            isOwn = hasOwn2(value, part);
+            isOwn = hasOwn3(value, part);
             value = value[part];
           }
           if (isOwn && !skipFurtherCaching) {
@@ -28615,6 +28615,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"
 );
@@ -28644,88 +28647,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, {
@@ -28767,9 +28909,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");
@@ -28792,11 +28935,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");
 
@@ -28834,14 +28981,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;
@@ -28850,8 +29000,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,
@@ -28862,103 +29014,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 {
@@ -29251,16 +29387,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) {
@@ -29280,9 +29411,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();
@@ -29310,208 +29440,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) {
@@ -29558,12 +29765,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;
     }
   };
 }
@@ -29691,7 +29911,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;
@@ -29811,6 +30031,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(() => ({
@@ -30016,7 +30539,9 @@ var builtInTypes = [
   UndefinedType,
   NonFiniteNumberType,
   BigIntType,
-  SymbolType
+  SymbolType,
+  ...errorAndUrlBuiltInTypes,
+  ...binaryBuiltInTypes
 ];
 
 // src/serializer/type-registry.ts
@@ -30507,7 +31032,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)) {
@@ -30588,7 +31113,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)) {
@@ -30633,7 +31158,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)) {
@@ -30705,7 +31230,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)) {
@@ -30738,7 +31263,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)) {
@@ -30749,6 +31274,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;
@@ -30784,10 +31329,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({
@@ -30922,13 +31468,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();
@@ -30936,13 +31475,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)) {
@@ -30959,10 +31499,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) {
@@ -31614,12 +32155,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) {
@@ -31645,10 +32186,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;
@@ -31759,21 +32304,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.
@@ -33080,7 +33628,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
@@ -33109,8 +33657,6 @@ var TaskRunner = class {
   /**
    * Creates the function with the chain of middleware.
    * @param task
-   * @param input
-   * @param taskDependencies
    * @returns
    */
   createRunnerWithMiddleware(task2) {
@@ -33130,7 +33676,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) {
@@ -33620,23 +34166,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,
@@ -33768,6 +34319,9 @@ var DependencyProcessor = class {
           if (receivedEvent.source === hook2.id) {
             return;
           }
+          if (hookStoreElement.dependencyState !== "ready" /* Ready */) {
+            return;
+          }
           return this.eventManager.executeHookWithInterceptors(
             hook2,
             receivedEvent,
@@ -33884,7 +34438,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
@@ -33910,14 +34464,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;
   }
@@ -34120,7 +34679,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") {
@@ -34175,7 +34735,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);
@@ -34713,25 +35276,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]);
   }
 };
 
@@ -35210,10 +35775,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(
@@ -35254,14 +35817,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(
@@ -35273,13 +35828,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(
@@ -35418,12 +35966,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
@@ -35483,8 +36036,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: {},
@@ -36037,6 +36593,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");
@@ -37218,7 +37786,7 @@ function makeAsyncContextBuilder(state) {
         configSchema: state.configSchema,
         meta: state.meta
       };
-      return defineAsyncContext(def);
+      return defineAsyncContext(def, state.filePath);
     }
   };
   return builder;
@@ -37227,8 +37795,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,
@@ -37701,7 +38271,7 @@ function override(base) {
 }
 __name(override, "override");
 
-// src/index.ts
+// src/public.ts
 init_http_fetch_tunnel_resource();
 var globals = {
   events: globalEvents,
@@ -38845,15 +39415,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)) {
@@ -38910,7 +39480,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 */];
@@ -39626,10 +40196,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 = timers.setTimeout(resolve, ms);
@@ -39659,7 +40229,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;
@@ -39701,6 +40271,7 @@ var DurableAuditEntryKind = {
   SignalDelivered: "signal_delivered",
   SignalTimedOut: "signal_timed_out",
   EmitPublished: "emit_published",
+  SwitchEvaluated: "switch_evaluated",
   Note: "note"
 };
 function isDurableInternalStepId(stepId) {
@@ -39724,15 +40295,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) {
@@ -39742,6 +40492,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);
   }
@@ -40437,7 +41228,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;
@@ -40914,7 +41705,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;
@@ -41110,6 +41901,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 = {}) {
@@ -41230,6 +42073,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}`;
@@ -42043,13 +42900,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) => {
@@ -42072,7 +42927,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.`
@@ -42082,7 +42940,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")
@@ -42090,81 +42948,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) {
@@ -42548,7 +43355,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");
@@ -43292,6 +44099,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,
@@ -43633,6 +44548,7 @@ exports.DurableWorker = DurableWorker;
 exports.Errors = errors_exports;
 exports.EventManager = EventManager;
 exports.ExecutionStatus = ExecutionStatus;
+exports.LogPrinter = LogPrinter;
 exports.Logger = Logger;
 exports.MemoryEventBus = MemoryEventBus;
 exports.MemoryQueue = MemoryQueue;
@@ -43653,6 +44569,8 @@ exports.Serializer = Serializer;
 exports.StepBuilder = StepBuilder;
 exports.Store = Store;
 exports.SuspensionSignal = SuspensionSignal;
+exports.SymbolPolicy = SymbolPolicy;
+exports.SymbolPolicyErrorMessage = SymbolPolicyErrorMessage;
 exports.TaskRunner = TaskRunner;
 exports.TimerStatus = TimerStatus;
 exports.TimerType = TimerType;
@@ -43671,6 +44589,7 @@ exports.createHttpClient = createHttpClient;
 exports.createHttpMixedClient = createHttpMixedClient;
 exports.createHttpSmartClient = createHttpSmartClient;
 exports.createNodeFile = createNodeFile;
+exports.createRunnerDurableRuntime = createRunnerDurableRuntime;
 exports.createTestResource = createTestResource;
 exports.debug = debug;
 exports.debugLevels = debugLevels;
@@ -43681,7 +44600,6 @@ exports.durableEventsArray = durableEventsArray;
 exports.durableResource = durableResource;
 exports.event = defineEvent;
 exports.getConfig = getConfig;
-exports.getDefaultSerializer = getDefaultSerializer;
 exports.globals = globals2;
 exports.hasExposureContext = hasExposureContext;
 exports.hook = defineHook;
@@ -43691,11 +44609,13 @@ exports.isDurableInternalStepId = isDurableInternalStepId;
 exports.journal = journal;
 exports.levelNormal = levelNormal;
 exports.levelVerbose = levelVerbose;
+exports.memoryDurableResource = memoryDurableResource;
 exports.nodeExposure = nodeExposure;
 exports.normalizeError = normalizeError;
 exports.override = defineOverride;
 exports.r = r;
 exports.readInputFileToBuffer = readInputFileToBuffer;
+exports.redisDurableResource = redisDurableResource;
 exports.resource = defineResource;
 exports.resourceMiddleware = defineResourceMiddleware;
 exports.run = run2;