@bluelibs/runner 4.6.1 → 4.7.0-alpha

package/dist/browser/index.mjs

@@ -1,7 +1,15 @@
 import { LRUCache } from 'lru-cache';
+import { EJSON } from '@bluelibs/ejson';
+export { EJSON } from '@bluelibs/ejson';
 
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -18,17 +26,22 @@ __export(defs_exports, {
   symbolMiddleware: () => symbolMiddleware,
   symbolMiddlewareConfigured: () => symbolMiddlewareConfigured,
   symbolOptionalDependency: () => symbolOptionalDependency,
+  symbolPhantomTask: () => symbolPhantomTask,
   symbolResource: () => symbolResource,
   symbolResourceMiddleware: () => symbolResourceMiddleware,
   symbolResourceWithConfig: () => symbolResourceWithConfig,
   symbolTag: () => symbolTag,
   symbolTagConfigured: () => symbolTagConfigured,
   symbolTask: () => symbolTask,
-  symbolTaskMiddleware: () => symbolTaskMiddleware
+  symbolTaskMiddleware: () => symbolTaskMiddleware,
+  symbolTunneledTask: () => symbolTunneledTask
 });
 
 // src/types/symbols.ts
 var symbolTask = Symbol.for("runner.task");
+var symbolPhantomTask = Symbol.for(
+  "runner.task.phantom"
+);
 var symbolResource = Symbol.for("runner.resource");
 var symbolResourceWithConfig = Symbol.for(
   "runner.resourceWithConfig"
@@ -44,6 +57,9 @@ var symbolResourceMiddleware = Symbol.for(
 var symbolMiddlewareConfigured = Symbol.for(
   "runner.middlewareConfigured"
 );
+var symbolTunneledTask = Symbol.for(
+  "runner.tunneledTask"
+);
 var symbolHook = Symbol.for("runner.hook");
 var symbolTag = Symbol.for("runner.tag");
 var symbolTagConfigured = Symbol.for(
@@ -99,7 +115,7 @@ var defaultKeyBuilder = /* @__PURE__ */ __name((taskId, input) => `${taskId}-${J
 var cacheMiddleware = defineTaskMiddleware({
   id: "globals.middleware.cache",
   dependencies: { cache: cacheResource },
-  async run({ task, next }, deps, config) {
+  async run({ task: task2, next }, deps, config) {
     const { cache } = deps;
     config = {
       keyBuilder: defaultKeyBuilder,
@@ -110,7 +126,7 @@ var cacheMiddleware = defineTaskMiddleware({
       // Automatically purge expired items
       ...config
     };
-    const taskId = task.definition.id;
+    const taskId = task2.definition.id;
     let cacheHolderForTask = cache.map.get(taskId);
     if (!cacheHolderForTask) {
       const { keyBuilder, ...lruOptions } = config;
@@ -121,12 +137,12 @@ var cacheMiddleware = defineTaskMiddleware({
       cacheHolderForTask = await cache.cacheFactoryTask(cacheOptions);
       cache.map.set(taskId, cacheHolderForTask);
     }
-    const key = config.keyBuilder(taskId, task.input);
+    const key = config.keyBuilder(taskId, task2.input);
     const cachedValue = await cacheHolderForTask.get(key);
     if (cachedValue) {
       return cachedValue;
     }
-    const result = await next(task.input);
+    const result = await next(task2.input);
     await cacheHolderForTask.set(key, result);
     return result;
   }
@@ -176,6 +192,16 @@ function defineTask(taskConfig) {
   };
 }
 __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) {
@@ -197,6 +223,7 @@ __name(defineHook, "defineHook");
 // src/errors.ts
 var errors_exports = {};
 __export(errors_exports, {
+  CancellationError: () => CancellationError,
   CircularDependenciesError: () => CircularDependenciesError,
   ContextError: () => ContextError,
   DependencyNotFoundError: () => DependencyNotFoundError,
@@ -212,7 +239,8 @@ __export(errors_exports, {
   StoreAlreadyInitializedError: () => StoreAlreadyInitializedError,
   TagNotFoundError: () => TagNotFoundError,
   UnknownItemTypeError: () => UnknownItemTypeError,
-  ValidationError: () => ValidationError
+  ValidationError: () => ValidationError,
+  isCancellationError: () => isCancellationError
 });
 
 // src/platform/adapters/node-als.ts
@@ -265,9 +293,27 @@ var NodePlatformAdapter = class {
     let instance;
     const ensure = /* @__PURE__ */ __name(() => {
       if (!this.alsClass) {
-        throw new PlatformUnsupportedFunction(
-          "createAsyncLocalStorage: Platform not initialized"
-        );
+        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 ? als : class NoopAsyncLocalStorage {
+          static {
+            __name(this, "NoopAsyncLocalStorage");
+          }
+          getStore() {
+            return void 0;
+          }
+          run(_store, callback) {
+            return callback();
+          }
+        };
       }
       return instance ??= new this.alsClass();
     }, "ensure");
@@ -454,6 +500,9 @@ function detectEnvironment() {
   if (typeof globalThis.Bun !== "undefined" || typeof process !== "undefined" && process.versions?.bun) {
     return "universal";
   }
+  if (typeof globalThis.importScripts === "function" && typeof window === "undefined") {
+    return "edge";
+  }
   if (typeof globalThis.WorkerGlobalScope !== "undefined" && typeof self !== "undefined" && self instanceof globalThis.WorkerGlobalScope) {
     return "edge";
   }
@@ -569,6 +618,63 @@ function getPlatform() {
   return platformInstance;
 }
 __name(getPlatform, "getPlatform");
+function setPlatform(adapter) {
+  platformInstance = adapter;
+  adapter.id;
+}
+__name(setPlatform, "setPlatform");
+var PlatformAdapter = class {
+  constructor(env) {
+    this.setTimeout = globalThis.setTimeout;
+    this.clearTimeout = globalThis.clearTimeout;
+    const kind = env ?? detectEnvironment();
+    this.env = kind;
+    switch (kind) {
+      case "node":
+        this.inner = new NodePlatformAdapter();
+        break;
+      case "browser":
+        this.inner = new BrowserPlatformAdapter();
+        break;
+      case "edge":
+        this.inner = new EdgePlatformAdapter();
+        break;
+      case "universal":
+        this.inner = new GenericUniversalPlatformAdapter();
+        break;
+      default:
+        this.inner = new UniversalPlatformAdapter();
+    }
+    this.id = this.inner.id;
+  }
+  static {
+    __name(this, "PlatformAdapter");
+  }
+  async init() {
+    return this.inner.init();
+  }
+  onUncaughtException(handler) {
+    return this.inner.onUncaughtException(handler);
+  }
+  onUnhandledRejection(handler) {
+    return this.inner.onUnhandledRejection(handler);
+  }
+  onShutdownSignal(handler) {
+    return this.inner.onShutdownSignal(handler);
+  }
+  exit(code) {
+    return this.inner.exit(code);
+  }
+  getEnv(key) {
+    return this.inner.getEnv(key);
+  }
+  hasAsyncLocalStorage() {
+    return this.inner.hasAsyncLocalStorage();
+  }
+  createAsyncLocalStorage() {
+    return this.inner.createAsyncLocalStorage();
+  }
+};
 
 // src/errors.ts
 var RuntimeError = class extends Error {
@@ -752,6 +858,19 @@ var PlatformUnsupportedFunction = class extends RuntimeError {
     this.name = "PlatformUnsupportedFunction";
   }
 };
+var CancellationError = class extends RuntimeError {
+  static {
+    __name(this, "CancellationError");
+  }
+  constructor(message = "Operation cancelled") {
+    super(message);
+    this.name = "CancellationError";
+  }
+};
+function isCancellationError(err) {
+  return !!err && err.name === "CancellationError";
+}
+__name(isCancellationError, "isCancellationError");
 
 // src/definers/defineResource.ts
 function defineResource(constConfig) {
@@ -1044,14 +1163,14 @@ __name(isOptional, "isOptional");
 // src/globals/middleware/requireContext.middleware.ts
 var requireContextTaskMiddleware = defineTaskMiddleware({
   id: "globals.middleware.requireContext",
-  async run({ task, next }, deps, config) {
+  async run({ task: task2, next }, deps, config) {
     if (!config.context) {
       throw new Error(
         "Context not available. Did you forget to pass 'context' to the middleware?"
       );
     }
     config.context.use();
-    return next(task?.input);
+    return next(task2?.input);
   }
 });
 
@@ -1105,6 +1224,24 @@ var debugTag = defineTag({
   }
 });
 
+// src/globals/resources/tunnel/tunnel.tag.ts
+var tunnelTag = defineTag({
+  id: "globals.tags.tunnel",
+  meta: {
+    title: "Tunnel",
+    description: "Marks a resource that exposes a runner to tunnel selected tasks (override task run() with resource.run(taskId, input))."
+  }
+});
+
+// src/globals/resources/tunnel/tunnel.policy.tag.ts
+var tunnelPolicyTag = defineTag({
+  id: "globals.tags.tunnel.middlewarePolicy",
+  meta: {
+    title: "Tunnel Middleware Policy",
+    description: "Controls which middlewares run on caller vs executor when a task is tunneled (whitelist)."
+  }
+});
+
 // src/globals/globalTags.ts
 var globalTags = {
   system: defineTag({
@@ -1121,7 +1258,9 @@ var globalTags = {
       description: "Marks events that should not be dispatched to global hooks (on: '*')."
     }
   }),
-  debug: debugTag
+  debug: debugTag,
+  tunnel: tunnelTag,
+  tunnelPolicy: tunnelPolicyTag
 };
 
 // src/globals/globalEvents.ts
@@ -1158,7 +1297,7 @@ var Queue = class {
    * Schedule an asynchronous task.
    * @param task – receives an AbortSignal so it can cancel early if desired.
    */
-  run(task) {
+  run(task2) {
     if (this.disposed) {
       return Promise.reject(new Error("Queue has been disposed"));
     }
@@ -1171,7 +1310,7 @@ var Queue = class {
     }
     const { signal } = this.abortController;
     const result = this.tail.then(
-      () => this.hasAsyncLocalStorage ? this.executionContext.run(true, () => task(signal)) : task(signal)
+      () => this.hasAsyncLocalStorage ? this.executionContext.run(true, () => task2(signal)) : task2(signal)
     );
     this.tail = result.catch(() => {
     });
@@ -1203,11 +1342,11 @@ var queueResource = defineResource({
     const map = context.map;
     return {
       map,
-      run: /* @__PURE__ */ __name((id2, task) => {
+      run: /* @__PURE__ */ __name((id2, task2) => {
         if (!map.has(id2)) {
           map.set(id2, new Queue());
         }
-        return map.get(id2).run(task);
+        return map.get(id2).run(task2);
       }, "run")
     };
   }, "init"),
@@ -1265,6 +1404,14 @@ var globalResources = {
     },
     tags: [systemTag2]
   }),
+  serializer: defineResource({
+    id: "globals.resources.serializer",
+    meta: {
+      title: "Serializer",
+      description: "Serializes and deserializes data. Provides EJSON-compatible stringify/parse and custom type registration via addType."
+    },
+    tags: [systemTag2]
+  }),
   cache: cacheResource,
   queue: queueResource
 };
@@ -1272,8 +1419,8 @@ var globalResources = {
 // src/globals/middleware/retry.middleware.ts
 var retryTaskMiddleware = defineTaskMiddleware({
   id: "globals.middleware.retry.task",
-  async run({ task, next }, deps, config) {
-    const input = task?.input;
+  async run({ task: task2, next }, deps, config) {
+    const input = task2?.input;
     let attempts = 0;
     const maxRetries = config.retries ?? 3;
     const shouldStop = config.stopRetryIf ?? (() => false);
@@ -1296,8 +1443,8 @@ var retryTaskMiddleware = defineTaskMiddleware({
 });
 var retryResourceMiddleware = defineResourceMiddleware({
   id: "globals.middleware.retry.resource",
-  async run({ resource, next }, deps, config) {
-    const input = resource?.config;
+  async run({ resource: resource2, next }, deps, config) {
+    const input = resource2?.config;
     let attempts = 0;
     const maxRetries = config.retries ?? 3;
     const shouldStop = config.stopRetryIf ?? (() => false);
@@ -1322,8 +1469,8 @@ var retryResourceMiddleware = defineResourceMiddleware({
 // src/globals/middleware/timeout.middleware.ts
 var timeoutTaskMiddleware = defineTaskMiddleware({
   id: "globals.middleware.timeout.task",
-  async run({ task, next }, _deps, config) {
-    const input = task?.input;
+  async run({ task: task2, next }, _deps, config) {
+    const input = task2?.input;
     const ttl = Math.max(0, config.ttl);
     const message = `Operation timed out after ${ttl}ms`;
     if (ttl === 0) {
@@ -1348,8 +1495,8 @@ var timeoutTaskMiddleware = defineTaskMiddleware({
 });
 var timeoutResourceMiddleware = defineResourceMiddleware({
   id: "globals.middleware.timeout.resource",
-  async run({ resource, next }, _deps, config) {
-    const input = resource?.config;
+  async run({ resource: resource2, next }, _deps, config) {
+    const input = resource2?.config;
     const ttl = Math.max(0, config.ttl);
     const message = `Operation timed out after ${ttl}ms`;
     if (ttl === 0) {
@@ -1407,11 +1554,11 @@ var TaskRunner = class {
    * @param task the task to be run
    * @param input the input to be passed to the task
    */
-  async run(task, input) {
-    let runner = this.runnerStore.get(task.id);
+  async run(task2, input) {
+    let runner = this.runnerStore.get(task2.id);
     if (!runner) {
-      runner = this.createRunnerWithMiddleware(task);
-      this.runnerStore.set(task.id, runner);
+      runner = this.createRunnerWithMiddleware(task2);
+      this.runnerStore.set(task2.id, runner);
     }
     try {
       return await runner(input);
@@ -1420,7 +1567,7 @@ var TaskRunner = class {
         await this.store.onUnhandledError({
           error,
           kind: "task",
-          source: task.id
+          source: task2.id
         });
       } catch (_) {
       }
@@ -1434,8 +1581,8 @@ var TaskRunner = class {
    * @param taskDependencies
    * @returns
    */
-  createRunnerWithMiddleware(task) {
-    return this.middlewareManager.composeTaskRunner(task);
+  createRunnerWithMiddleware(task2) {
+    return this.middlewareManager.composeTaskRunner(task2);
   }
 };
 
@@ -1583,28 +1730,31 @@ var MiddlewareManager = class {
    * Compose a runner for a task with its local interceptors and applicable middlewares.
    * Returns a function that accepts the task input and resolves to the task output.
    */
-  composeTaskRunner(task) {
-    const storeTask = this.store.tasks.get(task.id);
+  composeTaskRunner(task2) {
+    const storeTask = this.store.tasks.get(task2.id);
+    const tDef = storeTask.task;
     let next = /* @__PURE__ */ __name(async (input) => {
       let rawInput = input;
-      if (task.inputSchema) {
+      const isLocallyTunneled = task2[symbolTunneledTask] === "client" || tDef[symbolTunneledTask] === "client";
+      const runnerTask = isLocallyTunneled ? tDef : task2;
+      if (runnerTask.inputSchema) {
         try {
-          rawInput = task.inputSchema.parse(rawInput);
+          rawInput = runnerTask.inputSchema.parse(rawInput);
         } catch (error) {
           throw new ValidationError(
             "Task input",
-            task.id,
+            runnerTask.id,
             error instanceof Error ? error : new Error(String(error))
           );
         }
       }
       const deps = storeTask.computedDependencies;
-      const rawResult = await task.run.call(null, rawInput, deps);
-      if (task.resultSchema) {
+      const rawResult = await runnerTask.run.call(null, rawInput, deps);
+      if (runnerTask.resultSchema) {
         try {
-          return task.resultSchema.parse(rawResult);
+          return runnerTask.resultSchema.parse(rawResult);
         } catch (error) {
-          throw new ValidationError("Task result", task.id, error);
+          throw new ValidationError("Task result", runnerTask.id, error);
         }
       }
       return rawResult;
@@ -1622,7 +1772,7 @@ var MiddlewareManager = class {
       ].reverse();
       const createExecutionInput = /* @__PURE__ */ __name((input, nextFunc) => ({
         task: {
-          definition: task,
+          definition: task2,
           input
         },
         next: nextFunc
@@ -1641,7 +1791,19 @@ var MiddlewareManager = class {
       }
       next = currentNext;
     }
-    const createdMiddlewares = this.getApplicableTaskMiddlewares(task);
+    let createdMiddlewares = this.getApplicableTaskMiddlewares(task2);
+    const isLocallyTunneledPolicy = task2[symbolTunneledTask] === "client" || tDef[symbolTunneledTask] === "client";
+    if (isLocallyTunneledPolicy && globalTags.tunnelPolicy.exists(tDef)) {
+      const cfg = globalTags.tunnelPolicy.extract(task2);
+      const allowList = cfg?.client || void 0;
+      if (Array.isArray(allowList)) {
+        const toId = /* @__PURE__ */ __name((x) => typeof x === "string" ? x : x?.id, "toId");
+        const allowed = new Set(allowList.map(toId).filter(Boolean));
+        createdMiddlewares = createdMiddlewares.filter(
+          (m) => allowed.has(m.id)
+        );
+      }
+    }
     if (createdMiddlewares.length === 0) {
       return next;
     }
@@ -1653,7 +1815,7 @@ var MiddlewareManager = class {
         return storeMiddleware.middleware.run(
           {
             task: {
-              definition: task,
+              definition: task2,
               input
             },
             next: nextFunction
@@ -1675,29 +1837,29 @@ var MiddlewareManager = class {
   /**
    * Run a resource init wrapped with its applicable middlewares.
    */
-  async runResourceInit(resource, config, dependencies, context) {
+  async runResourceInit(resource2, config, dependencies, context) {
     let next = /* @__PURE__ */ __name(async (cfg) => {
-      if (!resource.init) return void 0;
-      const rawValue = await resource.init.call(
+      if (!resource2.init) return void 0;
+      const rawValue = await resource2.init.call(
         null,
         cfg,
         dependencies,
         context
       );
-      if (resource.resultSchema) {
+      if (resource2.resultSchema) {
         try {
-          return resource.resultSchema.parse(rawValue);
+          return resource2.resultSchema.parse(rawValue);
         } catch (error) {
           throw new ValidationError(
             "Resource result",
-            resource.id,
+            resource2.id,
             error
           );
         }
       }
       return rawValue;
     }, "next");
-    const createdMiddlewares = this.getApplicableResourceMiddlewares(resource);
+    const createdMiddlewares = this.getApplicableResourceMiddlewares(resource2);
     for (let i = createdMiddlewares.length - 1; i >= 0; i--) {
       const middleware = createdMiddlewares[i];
       const storeMiddleware = this.store.resourceMiddlewares.get(
@@ -1709,7 +1871,7 @@ var MiddlewareManager = class {
           const result = await storeMiddleware.middleware.run(
             {
               resource: {
-                definition: resource,
+                definition: resource2,
                 config: cfg
               },
               next: nextFunction
@@ -1723,7 +1885,7 @@ var MiddlewareManager = class {
             await this.store.onUnhandledError({
               error,
               kind: "resourceInit",
-              source: resource.id
+              source: resource2.id
             });
           } catch (_) {
           }
@@ -1744,7 +1906,7 @@ var MiddlewareManager = class {
       ].reverse();
       const createExecutionInput = /* @__PURE__ */ __name((config2, nextFunc) => ({
         resource: {
-          definition: resource,
+          definition: resource2,
           config: config2
         },
         next: nextFunc
@@ -1765,19 +1927,19 @@ var MiddlewareManager = class {
     }
     return next(config);
   }
-  getApplicableTaskMiddlewares(task) {
-    const existingMiddlewares = task.middleware;
+  getApplicableTaskMiddlewares(task2) {
+    const existingMiddlewares = task2.middleware;
     const existingMiddlewareIds = existingMiddlewares.map((x) => x.id);
-    const globalMiddlewares2 = this.getEverywhereMiddlewareForTasks(task).filter(
+    const globalMiddlewares2 = this.getEverywhereMiddlewareForTasks(task2).filter(
       (x) => !existingMiddlewareIds.includes(x.id)
     );
     return [...globalMiddlewares2, ...existingMiddlewares];
   }
-  getApplicableResourceMiddlewares(resource) {
-    const existingMiddlewares = resource.middleware;
+  getApplicableResourceMiddlewares(resource2) {
+    const existingMiddlewares = resource2.middleware;
     const existingMiddlewareIds = existingMiddlewares.map((x) => x.id);
     const globalMiddlewares2 = this.getEverywhereMiddlewareForResources(
-      resource
+      resource2
     ).filter((x) => !existingMiddlewareIds.includes(x.id));
     return [...globalMiddlewares2, ...existingMiddlewares];
   }
@@ -1785,10 +1947,10 @@ var MiddlewareManager = class {
    * @param task
    * @returns
    */
-  getEverywhereMiddlewareForTasks(task) {
+  getEverywhereMiddlewareForTasks(task2) {
     return Array.from(this.store.taskMiddlewares.values()).filter((x) => Boolean(x.middleware.everywhere)).filter((x) => {
       if (typeof x.middleware.everywhere === "function") {
-        return x.middleware.everywhere(task);
+        return x.middleware.everywhere(task2);
       }
       return true;
     }).map((x) => x.middleware);
@@ -1825,15 +1987,15 @@ var ResourceInitializer = class {
    * 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.
    * This function can throw only if any of the event listeners or run function throws
    */
-  async initializeResource(resource, config, dependencies) {
-    const context = resource.context?.();
+  async initializeResource(resource2, config, dependencies) {
+    const context = resource2.context?.();
     let value;
-    if (!resource.init) {
-      resource.init = (async () => void 0);
+    if (!resource2.init) {
+      resource2.init = (async () => void 0);
     }
-    if (resource.init) {
+    if (resource2.init) {
       value = await this.initWithMiddleware(
-        resource,
+        resource2,
         config,
         dependencies,
         context
@@ -1842,9 +2004,9 @@ var ResourceInitializer = class {
     return { value, context };
   }
   // Lifecycle emissions removed
-  async initWithMiddleware(resource, config, dependencies, context) {
+  async initWithMiddleware(resource2, config, dependencies, context) {
     return this.middlewareManager.runResourceInit(
-      resource,
+      resource2,
       config,
       dependencies,
       context
@@ -2310,45 +2472,45 @@ var DependencyProcessor = class {
       middleware.computedDependencies = computedDependencies;
       middleware.isInitialized = true;
     }
-    for (const resource of this.store.resources.values()) {
-      await this.processResourceDependencies(resource);
+    for (const resource2 of this.store.resources.values()) {
+      await this.processResourceDependencies(resource2);
     }
-    for (const task of this.store.tasks.values()) {
-      await this.computeTaskDependencies(task);
+    for (const task2 of this.store.tasks.values()) {
+      await this.computeTaskDependencies(task2);
     }
     for (const hookStoreElement of this.store.hooks.values()) {
-      const hook = hookStoreElement.hook;
-      const deps = hook.dependencies;
+      const hook2 = hookStoreElement.hook;
+      const deps = hook2.dependencies;
       hookStoreElement.computedDependencies = await this.extractDependencies(
         deps,
-        hook.id
+        hook2.id
       );
     }
     await this.initializeUninitializedResources();
   }
-  async computeTaskDependencies(task) {
-    const deps = task.task.dependencies;
-    task.computedDependencies = await this.extractDependencies(
+  async computeTaskDependencies(task2) {
+    const deps = task2.task.dependencies;
+    task2.computedDependencies = await this.extractDependencies(
       deps,
-      task.task.id
+      task2.task.id
     );
-    task.isInitialized = true;
+    task2.isInitialized = true;
   }
   // Most likely these are resources that no-one has dependencies towards
   // We need to ensure they work too!
   async initializeUninitializedResources() {
-    for (const resource of this.store.resources.values()) {
-      if (resource.isInitialized === false && // The root is the last one to be initialized and is done in a separate process.
-      resource.resource.id !== this.store.root.resource.id) {
-        await this.processResourceDependencies(resource);
+    for (const resource2 of this.store.resources.values()) {
+      if (resource2.isInitialized === false && // The root is the last one to be initialized and is done in a separate process.
+      resource2.resource.id !== this.store.root.resource.id) {
+        await this.processResourceDependencies(resource2);
         const { value, context } = await this.resourceInitializer.initializeResource(
-          resource.resource,
-          resource.config,
-          resource.computedDependencies
+          resource2.resource,
+          resource2.config,
+          resource2.computedDependencies
         );
-        resource.context = context;
-        resource.value = value;
-        resource.isInitialized = true;
+        resource2.context = context;
+        resource2.value = value;
+        resource2.isInitialized = true;
       }
     }
   }
@@ -2356,13 +2518,13 @@ var DependencyProcessor = class {
    * Processes dependencies and hooks
    * @param resource
    */
-  async processResourceDependencies(resource) {
-    const deps = resource.resource.dependencies || {};
+  async processResourceDependencies(resource2) {
+    const deps = resource2.resource.dependencies || {};
     const extracted = await this.extractDependencies(
       deps,
-      resource.resource.id
+      resource2.resource.id
     );
-    resource.computedDependencies = this.wrapResourceDependencies(
+    resource2.computedDependencies = this.wrapResourceDependencies(
       deps,
       extracted
     );
@@ -2422,20 +2584,20 @@ var DependencyProcessor = class {
    */
   attachListeners() {
     for (const hookStoreElement of this.store.hooks.values()) {
-      const hook = hookStoreElement.hook;
-      if (hook.on) {
-        const eventDefinition = hook.on;
+      const hook2 = hookStoreElement.hook;
+      if (hook2.on) {
+        const eventDefinition = hook2.on;
         const handler = /* @__PURE__ */ __name(async (receivedEvent) => {
-          if (receivedEvent.source === hook.id) {
+          if (receivedEvent.source === hook2.id) {
             return;
           }
           return this.eventManager.executeHookWithInterceptors(
-            hook,
+            hook2,
             receivedEvent,
             hookStoreElement.computedDependencies
           );
         }, "handler");
-        const order = hook.order ?? 0;
+        const order = hook2.order ?? 0;
         if (eventDefinition === "*") {
           this.eventManager.addGlobalListener(handler, { order });
         } else if (Array.isArray(eventDefinition)) {
@@ -2535,14 +2697,14 @@ var DependencyProcessor = class {
     if (storeResource === void 0) {
       throw new DependencyNotFoundError(`Resource ${object.id}`);
     }
-    const { resource, config } = storeResource;
+    const { resource: resource2, config } = storeResource;
     if (!storeResource.isInitialized) {
-      if (resource.init) {
-        const depMap = resource.dependencies || {};
-        const raw = await this.extractDependencies(depMap, resource.id);
+      if (resource2.init) {
+        const depMap = resource2.dependencies || {};
+        const raw = await this.extractDependencies(depMap, resource2.id);
         const wrapped = this.wrapResourceDependencies(depMap, raw);
         const { value, context } = await this.resourceInitializer.initializeResource(
-          resource,
+          resource2,
           config,
           wrapped
         );
@@ -2622,7 +2784,7 @@ var EventManager = class {
       const excludeFromGlobal = globalTags.excludeFromGlobalHooks.exists(eventDefinition);
       const allListeners = excludeFromGlobal ? this.listeners.get(eventDefinition.id) || [] : this.getCachedMergedListeners(eventDefinition.id);
       let propagationStopped = false;
-      const event = {
+      const event2 = {
         id: eventDefinition.id,
         data,
         timestamp: /* @__PURE__ */ new Date(),
@@ -2657,7 +2819,7 @@ var EventManager = class {
         const nextFunction = emitWithInterceptors;
         emitWithInterceptors = /* @__PURE__ */ __name(async (eventToEmit) => interceptor(nextFunction, eventToEmit), "emitWithInterceptors");
       }
-      await emitWithInterceptors(event);
+      await emitWithInterceptors(event2);
     }, "processEmission");
     if (this.runtimeCycleDetection && this.emissionStack && this.currentHookIdContext) {
       const currentStack = this.emissionStack.getStore();
@@ -2691,7 +2853,7 @@ var EventManager = class {
    * @param handler - The callback function to handle the event
    * @param options - Configuration options for the listener
    */
-  addListener(event, handler, options = HandlerOptionsDefaults) {
+  addListener(event2, handler, options = HandlerOptionsDefaults) {
     this.checkLock();
     const newListener = {
       handler,
@@ -2700,10 +2862,10 @@ var EventManager = class {
       id: options.id,
       isGlobal: false
     };
-    if (Array.isArray(event)) {
-      event.forEach((id2) => this.addListener(id2, handler, options));
+    if (Array.isArray(event2)) {
+      event2.forEach((id2) => this.addListener(id2, handler, options));
     } else {
-      const eventId = event.id;
+      const eventId = event2.id;
       const listeners = this.listeners.get(eventId);
       if (listeners) {
         this.insertListener(listeners, newListener);
@@ -2780,7 +2942,7 @@ var EventManager = class {
    * @param computedDependencies - The computed dependencies for the hook
    * @returns Promise resolving to the hook execution result
    */
-  async executeHookWithInterceptors(hook, event, computedDependencies) {
+  async executeHookWithInterceptors(hook2, event2, computedDependencies) {
     const baseExecute = /* @__PURE__ */ __name(async (hookToExecute, eventForHook) => {
       try {
         const result = await hookToExecute.run(
@@ -2800,11 +2962,11 @@ var EventManager = class {
     }
     if (this.runtimeCycleDetection) {
       return await this.currentHookIdContext?.run(
-        hook.id,
-        async () => await executeWithInterceptors(hook, event)
+        hook2.id,
+        async () => await executeWithInterceptors(hook2, event2)
       );
     } else {
-      return await executeWithInterceptors(hook, event);
+      return await executeWithInterceptors(hook2, event2);
     }
   }
   // ==================== PRIVATE METHODS ====================
@@ -2865,8 +3027,8 @@ var EventManager = class {
    * @param event - The event emission to check
    * @returns true if event should exclude global listeners
    */
-  isExcludedFromGlobal(event) {
-    return globalTags.excludeFromGlobalHooks.exists(event);
+  isExcludedFromGlobal(event2) {
+    return globalTags.excludeFromGlobalHooks.exists(event2);
   }
   /**
    * Retrieves cached merged listeners for an event, or creates them if not cached.
@@ -2991,25 +3153,25 @@ var StoreValidator = class {
     }
   }
   runSanityChecks() {
-    for (const task of this.registry.tasks.values()) {
-      const middlewares = task.task.middleware;
+    for (const task2 of this.registry.tasks.values()) {
+      const middlewares = task2.task.middleware;
       middlewares.forEach((middlewareAttachment) => {
         if (!this.registry.taskMiddlewares.has(middlewareAttachment.id)) {
           throw new MiddlewareNotRegisteredError(
             "task",
-            task.task.id,
+            task2.task.id,
             middlewareAttachment.id
           );
         }
       });
     }
-    for (const resource of this.registry.resources.values()) {
-      const middlewares = resource.resource.middleware;
+    for (const resource2 of this.registry.resources.values()) {
+      const middlewares = resource2.resource.middleware;
       middlewares.forEach((middlewareAttachment) => {
         if (!this.registry.resourceMiddlewares.has(middlewareAttachment.id)) {
           throw new MiddlewareNotRegisteredError(
             "resource",
-            resource.resource.id,
+            resource2.resource.id,
             middlewareAttachment.id
           );
         }
@@ -3033,9 +3195,9 @@ var StoreValidator = class {
     for (const taggable of taggables) {
       const tags = taggable.tags;
       if (tags) {
-        for (const tag of tags) {
-          if (!this.registry.tags.has(tag.id)) {
-            throw new TagNotFoundError(tag.id);
+        for (const tag2 of tags) {
+          if (!this.registry.tags.has(tag2.id)) {
+            throw new TagNotFoundError(tag2.id);
           }
         }
       }
@@ -3089,9 +3251,9 @@ var StoreRegistry = class {
   }
   storeHook(item, overrideMode = "normal") {
     overrideMode === "normal" && this.validator.checkIfIDExists(item.id);
-    const hook = this.getFreshValue(item, this.hooks, "hook", overrideMode);
-    this.hooks.set(hook.id, {
-      hook,
+    const hook2 = this.getFreshValue(item, this.hooks, "hook", overrideMode);
+    this.hooks.set(hook2.id, {
+      hook: hook2,
       computedDependencies: {}
     });
   }
@@ -3173,9 +3335,9 @@ var StoreRegistry = class {
   }
   storeTask(item, storingMode = "normal") {
     storingMode === "normal" && this.validator.checkIfIDExists(item.id);
-    const task = this.getFreshValue(item, this.tasks, "task", storingMode);
-    this.tasks.set(task.id, {
-      task,
+    const task2 = this.getFreshValue(item, this.tasks, "task", storingMode);
+    this.tasks.set(task2.id, {
+      task: task2,
       computedDependencies: {},
       isInitialized: false
     });
@@ -3185,11 +3347,11 @@ var StoreRegistry = class {
     const depenedants = [];
     const nodeMap = /* @__PURE__ */ new Map();
     this.setupBlankNodes(nodeMap, depenedants);
-    for (const task of this.tasks.values()) {
-      const node = nodeMap.get(task.task.id);
-      if (task.task.dependencies) {
+    for (const task2 of this.tasks.values()) {
+      const node = nodeMap.get(task2.task.id);
+      if (task2.task.dependencies) {
         for (const [depKey, depItem] of Object.entries(
-          task.task.dependencies
+          task2.task.dependencies
         )) {
           const candidate = isOptional(depItem) ? depItem.inner : depItem;
           const depNode = nodeMap.get(candidate.id);
@@ -3198,7 +3360,7 @@ var StoreRegistry = class {
           }
         }
       }
-      const t = task.task;
+      const t = task2.task;
       for (const middleware of t.middleware) {
         const middlewareNode = nodeMap.get(middleware.id);
         if (middlewareNode) {
@@ -3222,9 +3384,9 @@ var StoreRegistry = class {
       }
       if (middleware.everywhere) {
         const filter = typeof middleware.everywhere === "function" ? middleware.everywhere : () => true;
-        for (const task of this.tasks.values()) {
-          if (filter(task.task)) {
-            const taskNode = nodeMap.get(task.task.id);
+        for (const task2 of this.tasks.values()) {
+          if (filter(task2.task)) {
+            const taskNode = nodeMap.get(task2.task.id);
             taskNode.dependencies[`__middleware.${middleware.id}`] = node;
           }
         }
@@ -3246,19 +3408,19 @@ var StoreRegistry = class {
       }
       if (middleware.everywhere) {
         const filter = typeof middleware.everywhere === "function" ? middleware.everywhere : () => true;
-        for (const resource of this.resources.values()) {
-          if (filter(resource.resource)) {
-            const resourceNode = nodeMap.get(resource.resource.id);
+        for (const resource2 of this.resources.values()) {
+          if (filter(resource2.resource)) {
+            const resourceNode = nodeMap.get(resource2.resource.id);
             resourceNode.dependencies[`__middleware.${middleware.id}`] = node;
           }
         }
       }
     }
-    for (const resource of this.resources.values()) {
-      const node = nodeMap.get(resource.resource.id);
-      if (resource.resource.dependencies) {
+    for (const resource2 of this.resources.values()) {
+      const node = nodeMap.get(resource2.resource.id);
+      if (resource2.resource.dependencies) {
         for (const [depKey, depItem] of Object.entries(
-          resource.resource.dependencies
+          resource2.resource.dependencies
         )) {
           const candidate = isOptional(depItem) ? depItem.inner : depItem;
           const depNode = nodeMap.get(candidate.id);
@@ -3267,18 +3429,18 @@ var StoreRegistry = class {
           }
         }
       }
-      for (const middleware of resource.resource.middleware) {
+      for (const middleware of resource2.resource.middleware) {
         const middlewareNode = nodeMap.get(middleware.id);
         if (middlewareNode) {
           node.dependencies[middleware.id] = middlewareNode;
         }
       }
     }
-    for (const hook of this.hooks.values()) {
-      const node = nodeMap.get(hook.hook.id);
-      if (hook.hook.dependencies) {
+    for (const hook2 of this.hooks.values()) {
+      const node = nodeMap.get(hook2.hook.id);
+      if (hook2.hook.dependencies) {
         for (const [depKey, depItem] of Object.entries(
-          hook.hook.dependencies
+          hook2.hook.dependencies
         )) {
           const candidate = isOptional(depItem) ? depItem.inner : depItem;
           const depNode = nodeMap.get(candidate.id);
@@ -3330,12 +3492,12 @@ var StoreRegistry = class {
     return Array.from(nodes.values());
   }
   setupBlankNodes(nodeMap, depenedants) {
-    for (const task of this.tasks.values()) {
+    for (const task2 of this.tasks.values()) {
       const node = {
-        id: task.task.id,
+        id: task2.task.id,
         dependencies: {}
       };
-      nodeMap.set(task.task.id, node);
+      nodeMap.set(task2.task.id, node);
       depenedants.push(node);
     }
     for (const middleware of this.taskMiddlewares.values()) {
@@ -3354,31 +3516,31 @@ var StoreRegistry = class {
       nodeMap.set(middleware.middleware.id, node);
       depenedants.push(node);
     }
-    for (const resource of this.resources.values()) {
+    for (const resource2 of this.resources.values()) {
       const node = {
-        id: resource.resource.id,
+        id: resource2.resource.id,
         dependencies: {}
       };
-      nodeMap.set(resource.resource.id, node);
+      nodeMap.set(resource2.resource.id, node);
       depenedants.push(node);
     }
-    for (const hook of this.hooks.values()) {
+    for (const hook2 of this.hooks.values()) {
       const node = {
-        id: hook.hook.id,
+        id: hook2.hook.id,
         dependencies: {}
       };
-      nodeMap.set(hook.hook.id, node);
+      nodeMap.set(hook2.hook.id, node);
       depenedants.push(node);
     }
   }
-  getTasksWithTag(tag) {
-    const tagId = typeof tag === "string" ? tag : tag.id;
+  getTasksWithTag(tag2) {
+    const tagId = typeof tag2 === "string" ? tag2 : tag2.id;
     return Array.from(this.tasks.values()).filter((x) => {
       return x.task.tags.some((t) => t.id === tagId);
     }).map((x) => x.task);
   }
-  getResourcesWithTag(tag) {
-    const tagId = typeof tag === "string" ? tag : tag.id;
+  getResourcesWithTag(tag2) {
+    const tagId = typeof tag2 === "string" ? tag2 : tag2.id;
     return Array.from(this.resources.values()).filter((x) => {
       return x.resource.tags.some((t) => t.id === tagId);
     }).map((x) => x.resource);
@@ -3467,7 +3629,132 @@ var OverrideManager = class {
   }
 };
 
-// src/models/Store.ts
+// src/globals/middleware/tunnel.middleware.ts
+var originalRuns = /* @__PURE__ */ new WeakMap();
+var tunnelResourceMiddleware = defineResourceMiddleware({
+  id: "globals.middleware.resource.tunnel",
+  dependencies: {
+    store: globalResources.store,
+    eventManager: globalResources.eventManager
+  },
+  // Only applies to resources tagged with globals.tags.tunnel
+  everywhere: /* @__PURE__ */ __name((resource2) => globalTags.tunnel.exists(resource2), "everywhere"),
+  run: /* @__PURE__ */ __name(async ({ resource: resource2, next }, { store: store2, eventManager }) => {
+    const value = await next(resource2.config);
+    const mode = value.mode || "none";
+    const delivery = value.eventDeliveryMode || "mirror";
+    const tasks = value.tasks ? resolveTasks(store2, value.tasks) : [];
+    const events = value.events ? resolveEvents(store2, value.events) : [];
+    if (mode === "client" || mode === "both") {
+      if (tasks.length > 0 && typeof value.run !== "function") {
+        throw new Error(
+          "Tunnel resource value must implement run(task, input) when tasks[] is configured."
+        );
+      }
+      if (events.length > 0 && typeof value.emit !== "function") {
+        throw new Error(
+          "Tunnel resource value must implement emit(event, payload) when events[] is configured."
+        );
+      }
+    }
+    if (mode === "none" || mode === "server") {
+      return value;
+    }
+    for (const t of tasks) {
+      if (!originalRuns.has(t)) {
+        originalRuns.set(t, t.run);
+      }
+      t.run = (async (input) => {
+        return value.run(t, input);
+      });
+      t[symbolTunneledTask] = "client";
+    }
+    if (events.length > 0) {
+      const selectedEventIds = new Set(events.map((e) => e.id));
+      eventManager.intercept(
+        async (next2, emission) => {
+          if (!selectedEventIds.has(emission.id)) {
+            return next2(emission);
+          }
+          if (delivery === "local-only") {
+            return next2(emission);
+          }
+          if (delivery === "remote-only") {
+            return value.emit(emission);
+          }
+          if (delivery === "remote-first") {
+            try {
+              await value.emit(emission);
+            } catch (_) {
+              return next2(emission);
+            }
+            return;
+          }
+          await next2(emission);
+          return value.emit(emission);
+        }
+      );
+    }
+    return value;
+  }, "run"),
+  tags: [globalTags.system]
+});
+function resolveTasks(store2, selector) {
+  const out = [];
+  if (typeof selector === "function") {
+    for (const t of store2.tasks.values()) {
+      if (selector(t.task)) {
+        out.push(t.task);
+      }
+    }
+    return out;
+  }
+  for (const item of selector) {
+    if (typeof item === "string") {
+      const st = store2.tasks.get(item);
+      if (!st)
+        throw new Error(
+          `Task ${item} not found while trying to resolve tasks for tunnel.`
+        );
+      out.push(st.task);
+    } else if (item && typeof item === "object") {
+      const st = store2.tasks.get(item.id);
+      if (!st)
+        throw new Error(
+          `Task ${item} not found while trying to resolve tasks for tunnel.`
+        );
+      out.push(st.task);
+    }
+  }
+  return out;
+}
+__name(resolveTasks, "resolveTasks");
+function resolveEvents(store2, selector) {
+  const out = [];
+  if (typeof selector === "function") {
+    for (const e of store2.events.values()) {
+      if (selector(e.event)) {
+        out.push(e.event);
+      }
+    }
+    return out;
+  }
+  for (const item of selector) {
+    let st;
+    if (typeof item === "string") {
+      st = store2.events.get(item);
+    } else if (item && typeof item === "object") {
+      st = store2.events.get(item.id);
+    }
+    if (!st)
+      throw new Error(
+        `Event ${item} not found while trying to resolve events for tunnel.`
+      );
+    out.push(st.event);
+  }
+  return out;
+}
+__name(resolveEvents, "resolveEvents");
 var Store = class {
   constructor(eventManager, logger, onUnhandledError) {
     this.eventManager = eventManager;
@@ -3533,24 +3820,25 @@ var Store = class {
     builtInResourcesMap.set(globalResources.eventManager, this.eventManager);
     builtInResourcesMap.set(globalResources.logger, this.logger);
     builtInResourcesMap.set(globalResources.taskRunner, this.taskRunner);
+    builtInResourcesMap.set(globalResources.serializer, EJSON);
     builtInResourcesMap.set(
       globalResources.middlewareManager,
       this.middlewareManager
     );
     this.registry.storeGenericItem(globalResources.queue);
-    for (const [resource, value] of builtInResourcesMap.entries()) {
-      this.registry.storeGenericItem(resource);
-      const entry = this.resources.get(resource.id);
+    for (const [resource2, value] of builtInResourcesMap.entries()) {
+      this.registry.storeGenericItem(resource2);
+      const entry = this.resources.get(resource2.id);
       if (entry) {
         entry.value = value;
         entry.isInitialized = true;
       }
     }
-    Object.values(globalTags).forEach((tag) => {
-      this.registry.storeTag(tag);
+    Object.values(globalTags).forEach((tag2) => {
+      this.registry.storeTag(tag2);
     });
-    globalEventsArray.forEach((event) => {
-      this.registry.storeEvent(event);
+    globalEventsArray.forEach((event2) => {
+      this.registry.storeEvent(event2);
     });
     const builtInTaskMiddlewares = [
       requireContextTaskMiddleware,
@@ -3566,7 +3854,8 @@ var Store = class {
     });
     const builtInResourceMiddlewares = [
       retryResourceMiddleware,
-      timeoutResourceMiddleware
+      timeoutResourceMiddleware,
+      tunnelResourceMiddleware
     ];
     builtInResourceMiddlewares.forEach((middleware) => {
       this.registry.resourceMiddlewares.set(middleware.id, {
@@ -3613,19 +3902,19 @@ var Store = class {
     this.registerGlobalComponents();
     this.setupRootResource(root, config);
     this.validator.runSanityChecks();
-    for (const resource of this.resources.values()) {
-      this.overrideManager.storeOverridesDeeply(resource.resource);
+    for (const resource2 of this.resources.values()) {
+      this.overrideManager.storeOverridesDeeply(resource2.resource);
     }
     this.#isInitialized = true;
   }
   async dispose() {
-    for (const resource of this.resources.values()) {
-      if (resource.isInitialized && resource.resource.dispose) {
-        await resource.resource.dispose(
-          resource.value,
-          resource.config,
-          resource.computedDependencies,
-          resource.context
+    for (const resource2 of this.resources.values()) {
+      if (resource2.isInitialized && resource2.resource.dispose) {
+        await resource2.resource.dispose(
+          resource2.value,
+          resource2.config,
+          resource2.computedDependencies,
+          resource2.context
         );
       }
     }
@@ -3649,16 +3938,16 @@ var Store = class {
    * @param tag - The tag to filter by.
    * @returns The tasks with the given tag.
    */
-  getTasksWithTag(tag) {
-    return this.registry.getTasksWithTag(tag);
+  getTasksWithTag(tag2) {
+    return this.registry.getTasksWithTag(tag2);
   }
   /**
    * Returns all resources with the given tag.
    * @param tag - The tag to filter by.
    * @returns The resources with the given tag.
    */
-  getResourcesWithTag(tag) {
-    return this.registry.getResourcesWithTag(tag);
+  getResourcesWithTag(tag2) {
+    return this.registry.getResourcesWithTag(tag2);
   }
 };
 
@@ -3756,16 +4045,16 @@ var globalEventListener = defineHook({
     logger: globalResources.logger,
     debugConfig
   },
-  run: /* @__PURE__ */ __name(async (event, { logger, debugConfig: debugConfig2 }) => {
-    if (hasSystemTag(event)) {
+  run: /* @__PURE__ */ __name(async (event2, { logger, debugConfig: debugConfig2 }) => {
+    if (hasSystemTag(event2)) {
       return;
     }
-    debugConfig2 = getConfig(debugConfig2, event);
+    debugConfig2 = getConfig(debugConfig2, event2);
     if (debugConfig2.logEventEmissionOnRun) {
-      const message = `Event ${String(event.id)} emitted`;
+      const message = `Event ${String(event2.id)} emitted`;
       await logger.info(message, {
         source: "globals.debug.hooks.onAnyEvent",
-        data: debugConfig2.logEventEmissionInput ? { data: event.data } : void 0
+        data: debugConfig2.logEventEmissionInput ? { data: event2.data } : void 0
       });
     }
   }, "run"),
@@ -3779,26 +4068,26 @@ var globalEventListener = defineHook({
 // src/globals/resources/debug/executionTracker.middleware.ts
 var tasksTrackerMiddleware = defineTaskMiddleware({
   id: "globals.debug.middleware.task.executionTracker",
-  everywhere: /* @__PURE__ */ __name((task) => !globalTags.system.exists(task), "everywhere"),
+  everywhere: /* @__PURE__ */ __name((task2) => !globalTags.system.exists(task2), "everywhere"),
   dependencies: {
     logger: globalResources.logger,
     debugConfig,
     store: globalResources.store
   },
-  run: /* @__PURE__ */ __name(async ({ task, next }, { logger, debugConfig: debugConfig2, store: store2 }) => {
+  run: /* @__PURE__ */ __name(async ({ task: task2, next }, { logger, debugConfig: debugConfig2, store: store2 }) => {
     const start = Date.now();
     logger = logger.with({
       source: tasksTrackerMiddleware.id
     });
-    debugConfig2 = getConfig(debugConfig2, task?.definition);
-    const taskStartMessage = `Task ${task.definition.id} is running...`;
-    const shouldShowData = debugConfig2.logTaskInput && task.input;
+    debugConfig2 = getConfig(debugConfig2, task2?.definition);
+    const taskStartMessage = `Task ${task2.definition.id} is running...`;
+    const shouldShowData = debugConfig2.logTaskInput && task2.input;
     await logger.info(taskStartMessage, {
-      data: shouldShowData ? { input: task.input } : void 0
+      data: shouldShowData ? { input: task2.input } : void 0
     });
-    const result = await next(task.input);
+    const result = await next(task2.input);
     const duration = Date.now() - start;
-    const taskCompleteMessage = `Task ${task.definition.id} completed in ${duration}ms`;
+    const taskCompleteMessage = `Task ${task2.definition.id} completed in ${duration}ms`;
     const shouldShowResult = debugConfig2.logTaskOutput && result;
     await logger.info(taskCompleteMessage, {
       data: shouldShowResult ? { result } : void 0
@@ -3818,23 +4107,23 @@ var resourcesTrackerMiddleware = defineResourceMiddleware({
     debugConfig,
     store: globalResources.store
   },
-  everywhere: /* @__PURE__ */ __name((resource) => !globalTags.system.exists(resource), "everywhere"),
-  run: /* @__PURE__ */ __name(async ({ resource, next }, { logger, debugConfig: debugConfig2, store: store2 }) => {
+  everywhere: /* @__PURE__ */ __name((resource2) => !globalTags.system.exists(resource2), "everywhere"),
+  run: /* @__PURE__ */ __name(async ({ resource: resource2, next }, { logger, debugConfig: debugConfig2, store: store2 }) => {
     const start = Date.now();
     logger = logger.with({
       source: resourcesTrackerMiddleware.id
     });
-    debugConfig2 = getConfig(debugConfig2, resource?.definition);
-    const resourceStartMessage = `Resource ${resource.definition.id} is initializing...`;
-    const isConfigEmpty = Object.keys(resource.config || {}).length === 0;
+    debugConfig2 = getConfig(debugConfig2, resource2?.definition);
+    const resourceStartMessage = `Resource ${resource2.definition.id} is initializing...`;
+    const isConfigEmpty = Object.keys(resource2.config || {}).length === 0;
     const shouldShowConfig = debugConfig2.logResourceConfig && !isConfigEmpty;
     await logger.info(resourceStartMessage, {
-      data: shouldShowConfig ? { config: resource.config } : void 0
+      data: shouldShowConfig ? { config: resource2.config } : void 0
     });
-    const result = await next(resource.config);
+    const result = await next(resource2.config);
     const duration = Date.now() - start;
     const resourceCompleteMessage = `Resource ${String(
-      resource.definition.id
+      resource2.definition.id
     )} initialized in ${duration}ms`;
     const shouldShowResult = debugConfig2.logResourceValue && result !== void 0;
     await logger.info(resourceCompleteMessage, {
@@ -3863,14 +4152,14 @@ var middlewareInterceptorResource = defineResource({
     debugConfig,
     middlewareManager: globalResources.middlewareManager
   },
-  init: /* @__PURE__ */ __name(async (event, deps) => {
+  init: /* @__PURE__ */ __name(async (event2, deps) => {
     const { logger, debugConfig: debugConfig2, middlewareManager } = deps;
     middlewareManager.intercept(
       "task",
       async (next, input) => {
         const taskDef = input.task.definition;
         if (!hasSystemTag(taskDef)) {
-          const cfg = getConfig(debugConfig2, event);
+          const cfg = getConfig(debugConfig2, event2);
           if (cfg.logMiddlewareBeforeRun) {
             const msg = `Middleware triggered for task ${String(taskDef.id)}`;
             await logger.info(msg, {
@@ -3880,7 +4169,7 @@ var middlewareInterceptorResource = defineResource({
         }
         const result = await next(input);
         if (!hasSystemTag(taskDef)) {
-          const cfg = getConfig(debugConfig2, event);
+          const cfg = getConfig(debugConfig2, event2);
           if (cfg.logMiddlewareAfterRun) {
             const msg = `Middleware completed for task ${String(taskDef.id)}`;
             await logger.info(msg, {
@@ -3896,7 +4185,7 @@ var middlewareInterceptorResource = defineResource({
       async (next, input) => {
         const resourceDef = input.resource.definition;
         if (!hasSystemTag(resourceDef)) {
-          const cfg = getConfig(debugConfig2, event);
+          const cfg = getConfig(debugConfig2, event2);
           if (cfg.logMiddlewareBeforeRun) {
             const msg = `Middleware triggered for resource ${String(
               resourceDef.id
@@ -3908,7 +4197,7 @@ var middlewareInterceptorResource = defineResource({
         }
         const result = await next(input);
         if (!hasSystemTag(resourceDef)) {
-          const cfg = getConfig(debugConfig2, event);
+          const cfg = getConfig(debugConfig2, event2);
           if (cfg.logMiddlewareAfterRun) {
             const msg = `Middleware completed for resource ${String(
               resourceDef.id
@@ -3937,23 +4226,23 @@ var hookInterceptorResource = defineResource({
     debugConfig,
     eventManager: globalResources.eventManager
   },
-  init: /* @__PURE__ */ __name(async (event, deps) => {
-    deps.eventManager.interceptHook(async (next, hook, event2) => {
+  init: /* @__PURE__ */ __name(async (event2, deps) => {
+    deps.eventManager.interceptHook(async (next, hook2, event3) => {
       const { logger, debugConfig: debugConfig2 } = deps;
-      if (hasSystemTag(hook)) {
-        return await next(hook, event2);
+      if (hasSystemTag(hook2)) {
+        return await next(hook2, event3);
       }
-      const resolved = getConfig(debugConfig2, event2);
+      const resolved = getConfig(debugConfig2, event3);
       if (resolved.logHookTriggered) {
-        const hookId = hook.id;
+        const hookId = hook2.id;
         let logString = `Hook triggered for ${String(hookId)}`;
         await logger.info(logString, {
           source: "globals.debug.resources.hookInterceptor"
         });
       }
-      await next(hook, event2);
+      await next(hook2, event3);
       if (resolved.logHookCompleted) {
-        const hookId = hook.id;
+        const hookId = hook2.id;
         let logString = `Hook completed for ${String(hookId)}`;
         await logger.info(logString, {
           source: "globals.debug.resources.hookInterceptor"
@@ -4034,13 +4323,7 @@ function installGlobalShutdownHooksOnce() {
         activeDisposers.delete(d);
       }
     } finally {
-      try {
-        platform2.exit(0);
-      } catch (e) {
-        if (!(e instanceof PlatformUnsupportedFunction)) {
-          throw e;
-        }
-      }
+      platform2.exit(0);
     }
   }, "handler");
   platform2.onShutdownSignal(handler);
@@ -4101,38 +4384,38 @@ var RunResult = class {
      * @param args - The arguments to pass to the task.
      * @returns The result of the task.
      */
-    this.runTask = /* @__PURE__ */ __name((task, ...args) => {
-      if (typeof task === "string") {
-        const taskId = task;
+    this.runTask = /* @__PURE__ */ __name((task2, ...args) => {
+      if (typeof task2 === "string") {
+        const taskId = task2;
         if (!this.store.tasks.has(taskId)) {
           throw new RuntimeError(`Task "${taskId}" not found.`);
         }
-        task = this.store.tasks.get(taskId).task;
+        task2 = this.store.tasks.get(taskId).task;
       }
-      return this.taskRunner.run(task, ...args);
+      return this.taskRunner.run(task2, ...args);
     }, "runTask");
     /**
      * Emit an event within the context of the run result.
      * @param event - The event to emit.
      * @param payload - The payload to emit.
      */
-    this.emitEvent = /* @__PURE__ */ __name((event, payload) => {
-      if (typeof event === "string") {
-        const eventId = event;
+    this.emitEvent = /* @__PURE__ */ __name((event2, payload) => {
+      if (typeof event2 === "string") {
+        const eventId = event2;
         if (!this.store.events.has(eventId)) {
           throw new RuntimeError(`Event "${eventId}" not found.`);
         }
-        event = this.store.events.get(eventId).event;
+        event2 = this.store.events.get(eventId).event;
       }
-      return this.eventManager.emit(event, payload, "outside");
+      return this.eventManager.emit(event2, payload, "outside");
     }, "emitEvent");
     /**
      * Get the value of a resource from the run result.
      * @param resource - The resource to get the value of.
      * @returns The value of the resource.
      */
-    this.getResourceValue = /* @__PURE__ */ __name((resource) => {
-      const resourceId = typeof resource === "string" ? resource : resource.id;
+    this.getResourceValue = /* @__PURE__ */ __name((resource2) => {
+      const resourceId = typeof resource2 === "string" ? resource2 : resource2.id;
       if (!this.store.resources.has(resourceId)) {
         throw new ResourceNotFoundError(resourceId);
       }
@@ -4167,7 +4450,7 @@ async function run(resourceOrResourceWithConfig, options) {
   const eventManager = new EventManager({
     runtimeCycleDetection
   });
-  let { resource, config } = extractResourceAndConfig(
+  let { resource: resource2, config } = extractResourceAndConfig(
     resourceOrResourceWithConfig
   );
   const logger = new Logger({
@@ -4210,7 +4493,7 @@ async function run(resourceOrResourceWithConfig, options) {
     if (debug) {
       store2.storeGenericItem(debugResource.with(debug));
     }
-    store2.initializeStore(resource, config);
+    store2.initializeStore(resource2, config);
     await store2.processOverrides();
     store2.validateDependencyGraph();
     store2.validateEventEmissionGraph();
@@ -4257,19 +4540,152 @@ async function run(resourceOrResourceWithConfig, options) {
 }
 __name(run, "run");
 function extractResourceAndConfig(resourceOrResourceWithConfig) {
-  let resource;
+  let resource2;
   let config;
   if (isResourceWithConfig(resourceOrResourceWithConfig)) {
-    resource = resourceOrResourceWithConfig.resource;
+    resource2 = resourceOrResourceWithConfig.resource;
     config = resourceOrResourceWithConfig.config;
   } else {
-    resource = resourceOrResourceWithConfig;
+    resource2 = resourceOrResourceWithConfig;
     config = void 0;
   }
-  return { resource, config };
+  return { resource: resource2, config };
 }
 __name(extractResourceAndConfig, "extractResourceAndConfig");
 
+// src/globals/resources/tunnel/protocol.ts
+var TunnelError = class extends Error {
+  static {
+    __name(this, "TunnelError");
+  }
+  constructor(code, message, details) {
+    super(message);
+    this.name = "TunnelError";
+    this.code = code;
+    this.details = details;
+  }
+};
+function toTunnelError(input, fallbackMessage) {
+  if (input instanceof Error) {
+    return new TunnelError("UNKNOWN", input.message);
+  }
+  if (input && typeof input === "object" && "code" in input && "message" in input && typeof input.message === "string" && typeof input.code === "string") {
+    const pe = input;
+    const msg = pe.message || fallbackMessage || "Tunnel error";
+    return new TunnelError(pe.code, msg, pe.details);
+  }
+  if (input && typeof input === "object" && "message" in input && typeof input.message === "string") {
+    return new TunnelError("UNKNOWN", input.message);
+  }
+  return new TunnelError(
+    "UNKNOWN",
+    typeof input === "string" && input || fallbackMessage || "Tunnel error"
+  );
+}
+__name(toTunnelError, "toTunnelError");
+function assertOkEnvelope(envelope, opts) {
+  if (!envelope || typeof envelope !== "object") {
+    throw new TunnelError(
+      "INVALID_RESPONSE",
+      opts?.fallbackMessage || "Invalid or empty response"
+    );
+  }
+  if (envelope.ok) {
+    return envelope.result;
+  }
+  if (envelope.error) {
+    return (() => {
+      throw toTunnelError(envelope.error, opts?.fallbackMessage);
+    })();
+  }
+  throw new TunnelError("UNKNOWN", opts?.fallbackMessage || "Tunnel error");
+}
+__name(assertOkEnvelope, "assertOkEnvelope");
+
+// src/http-fetch-tunnel.resource.ts
+async function postSerialized(fetchFn, url, body, headers, timeoutMs, serializer, onRequest) {
+  const controller = timeoutMs && timeoutMs > 0 ? new AbortController() : void 0;
+  let timeout;
+  try {
+    if (controller) {
+      timeout = setTimeout(() => controller.abort(), timeoutMs);
+    }
+    const reqHeaders = {
+      "content-type": "application/json; charset=utf-8",
+      ...headers
+    };
+    if (onRequest) await onRequest({ url, headers: reqHeaders });
+    const res = await fetchFn(url, {
+      method: "POST",
+      headers: reqHeaders,
+      body: serializer.stringify(body),
+      signal: controller?.signal
+    });
+    const text = await res.text();
+    const json = text ? serializer.parse(text) : void 0;
+    return json;
+  } finally {
+    if (timeout) clearTimeout(timeout);
+  }
+}
+__name(postSerialized, "postSerialized");
+function createExposureFetch(cfg) {
+  const baseUrl = (cfg?.baseUrl).replace(/\/$/, "");
+  if (!baseUrl) throw new Error("createExposureFetch requires baseUrl");
+  const headerName = (cfg?.auth?.header ?? "x-runner-token").toLowerCase();
+  const buildHeaders = /* @__PURE__ */ __name(() => {
+    const headers = {};
+    if (cfg?.auth?.token) headers[headerName] = cfg.auth.token;
+    return headers;
+  }, "buildHeaders");
+  const fetchImpl = cfg.fetchImpl ?? globalThis.fetch;
+  if (typeof fetchImpl !== "function") {
+    throw new Error(
+      "global fetch is not available; provide fetchImpl in config"
+    );
+  }
+  return {
+    async task(id2, input) {
+      const url = `${baseUrl}/task/${encodeURIComponent(id2)}`;
+      const r2 = await postSerialized(
+        fetchImpl,
+        url,
+        { input },
+        buildHeaders(),
+        cfg?.timeoutMs,
+        cfg.serializer,
+        cfg?.onRequest
+      );
+      return assertOkEnvelope(r2, { fallbackMessage: "Tunnel task error" });
+    },
+    async event(id2, payload) {
+      const url = `${baseUrl}/event/${encodeURIComponent(id2)}`;
+      const r2 = await postSerialized(
+        fetchImpl,
+        url,
+        { payload },
+        buildHeaders(),
+        cfg?.timeoutMs,
+        cfg.serializer,
+        cfg?.onRequest
+      );
+      assertOkEnvelope(r2, { fallbackMessage: "Tunnel event error" });
+    }
+  };
+}
+__name(createExposureFetch, "createExposureFetch");
+
+// src/globals/tunnels/index.ts
+var http = Object.freeze({
+  createClient(cfg) {
+    const { url, ...rest } = cfg;
+    return createExposureFetch({ baseUrl: url, ...rest });
+  }
+});
+var tunnels = Object.freeze({
+  http
+});
+
 // src/testing.ts
 var testResourceCounter = 0;
 function createTestResource(root, options) {
@@ -4292,7 +4708,7 @@ __name(createTestResource, "createTestResource");
 function buildTestFacade(deps) {
   return {
     // Run a task within the fully initialized ecosystem
-    runTask: /* @__PURE__ */ __name((task, ...args) => deps.taskRunner.run(task, ...args), "runTask"),
+    runTask: /* @__PURE__ */ __name((task2, ...args) => deps.taskRunner.run(task2, ...args), "runTask"),
     // Access a resource value by id (string or symbol)
     getResource: /* @__PURE__ */ __name((id2) => deps.store.resources.get(id2)?.value, "getResource"),
     // Expose internals when needed in tests (not recommended for app usage)
@@ -4304,6 +4720,761 @@ function buildTestFacade(deps) {
 }
 __name(buildTestFacade, "buildTestFacade");
 
+// src/definers/builders/resource.ts
+function clone(s, patch) {
+  return Object.freeze({
+    // We reuse the frozen state while widening generics, hence the temporary cast.
+    ...s,
+    ...patch
+  });
+}
+__name(clone, "clone");
+function toRegisterArray(items) {
+  return Array.isArray(items) ? [...items] : [items];
+}
+__name(toRegisterArray, "toRegisterArray");
+function normalizeRegisterFunction(fn) {
+  return (config) => toRegisterArray(fn(config));
+}
+__name(normalizeRegisterFunction, "normalizeRegisterFunction");
+function mergeRegister(existing, addition, override) {
+  const isFunctionAddition = typeof addition === "function";
+  const normalizedAddition = isFunctionAddition ? normalizeRegisterFunction(
+    addition
+  ) : toRegisterArray(addition);
+  if (override || !existing) {
+    return isFunctionAddition ? normalizedAddition : normalizedAddition;
+  }
+  if (typeof existing === "function") {
+    if (isFunctionAddition) {
+      const additionFn = normalizedAddition;
+      return (config) => [...existing(config), ...additionFn(config)];
+    }
+    const additionArray = normalizedAddition;
+    return (config) => [...existing(config), ...additionArray];
+  }
+  const existingArray = existing;
+  if (isFunctionAddition) {
+    const additionFn = normalizedAddition;
+    return (config) => [...existingArray, ...additionFn(config)];
+  }
+  return [
+    ...existingArray,
+    ...normalizedAddition
+  ];
+}
+__name(mergeRegister, "mergeRegister");
+function mergeArray(existing, addition, override) {
+  const toArray = [...addition];
+  if (override || !existing) {
+    return toArray;
+  }
+  return [...existing, ...toArray];
+}
+__name(mergeArray, "mergeArray");
+function mergeDependencies(existing, addition, override) {
+  const isFnExisting = typeof existing === "function";
+  const isFnAddition = typeof addition === "function";
+  if (override || !existing) {
+    return addition;
+  }
+  if (isFnExisting && isFnAddition) {
+    const e2 = existing;
+    const a2 = addition;
+    return ((config) => ({
+      ...e2(config),
+      ...a2(config)
+    }));
+  }
+  if (isFnExisting && !isFnAddition) {
+    const e2 = existing;
+    const a2 = addition;
+    return ((config) => ({
+      ...e2(config),
+      ...a2
+    }));
+  }
+  if (!isFnExisting && isFnAddition) {
+    const e2 = existing;
+    const a2 = addition;
+    return ((config) => ({
+      ...e2,
+      ...a2(config)
+    }));
+  }
+  const e = existing;
+  const a = addition;
+  return { ...e, ...a };
+}
+__name(mergeDependencies, "mergeDependencies");
+function makeResourceBuilder(state) {
+  const builder = {
+    id: state.id,
+    dependencies(deps, options) {
+      const override = options?.override ?? false;
+      const next = clone(state, {
+        dependencies: mergeDependencies(
+          state.dependencies,
+          deps,
+          override
+        )
+      });
+      if (override) {
+        return makeResourceBuilder(next);
+      }
+      return makeResourceBuilder(next);
+    },
+    register(items, options) {
+      const override = options?.override ?? false;
+      const next = clone(state, {
+        register: mergeRegister(state.register, items, override)
+      });
+      return makeResourceBuilder(next);
+    },
+    middleware(mw, options) {
+      const override = options?.override ?? false;
+      const next = clone(state, {
+        middleware: mergeArray(state.middleware, mw, override)
+      });
+      return makeResourceBuilder(next);
+    },
+    tags(tags, options) {
+      const override = options?.override ?? false;
+      const next = clone(state, { tags: mergeArray(state.tags, tags, override) });
+      return makeResourceBuilder(next);
+    },
+    context(factory) {
+      const next = clone(state, { context: factory });
+      return makeResourceBuilder(next);
+    },
+    configSchema(schema) {
+      const next = clone(state, { configSchema: schema });
+      return makeResourceBuilder(next);
+    },
+    resultSchema(schema) {
+      const next = clone(state, { resultSchema: schema });
+      return makeResourceBuilder(next);
+    },
+    init(fn) {
+      const next = clone(state, { init: fn });
+      return makeResourceBuilder(next);
+    },
+    dispose(fn) {
+      const next = clone(state, { dispose: fn });
+      return makeResourceBuilder(next);
+    },
+    meta(m) {
+      const next = clone(state, { meta: m });
+      return makeResourceBuilder(next);
+    },
+    overrides(o, options) {
+      const override = options?.override ?? false;
+      const next = clone(state, {
+        overrides: mergeArray(state.overrides, o, override)
+      });
+      return makeResourceBuilder(next);
+    },
+    build() {
+      const definition = {
+        id: state.id,
+        dependencies: state.dependencies,
+        register: state.register,
+        middleware: state.middleware,
+        tags: state.tags,
+        context: state.context,
+        init: state.init,
+        dispose: state.dispose,
+        configSchema: state.configSchema,
+        resultSchema: state.resultSchema,
+        meta: state.meta,
+        overrides: state.overrides
+      };
+      return defineResource(definition);
+    }
+  };
+  return builder;
+}
+__name(makeResourceBuilder, "makeResourceBuilder");
+function resourceBuilder(id2) {
+  const initial = Object.freeze({
+    id: id2,
+    dependencies: void 0,
+    register: void 0,
+    middleware: [],
+    tags: [],
+    context: void 0,
+    init: void 0,
+    dispose: void 0,
+    configSchema: void 0,
+    resultSchema: void 0,
+    meta: void 0,
+    overrides: void 0
+  });
+  return makeResourceBuilder(initial);
+}
+__name(resourceBuilder, "resourceBuilder");
+var resource = resourceBuilder;
+
+// src/definers/builders/utils.ts
+function cloneState(s, patch) {
+  return Object.freeze({ ...s, ...patch });
+}
+__name(cloneState, "cloneState");
+function mergeArray2(existing, addition, override) {
+  const toArray = [...addition];
+  if (override || !existing) {
+    return toArray;
+  }
+  return [...existing, ...toArray];
+}
+__name(mergeArray2, "mergeArray");
+function mergeDepsNoConfig(existing, addition, override) {
+  const isFnExisting = typeof existing === "function";
+  const isFnAddition = typeof addition === "function";
+  if (override || !existing) {
+    return addition;
+  }
+  if (isFnExisting && isFnAddition) {
+    const e2 = existing;
+    const a2 = addition;
+    return (() => ({ ...e2(), ...a2() }));
+  }
+  if (isFnExisting && !isFnAddition) {
+    const e2 = existing;
+    const a2 = addition;
+    return (() => ({ ...e2(), ...a2 }));
+  }
+  if (!isFnExisting && isFnAddition) {
+    const e2 = existing;
+    const a2 = addition;
+    return (() => ({ ...e2, ...a2() }));
+  }
+  const e = existing;
+  const a = addition;
+  return { ...e, ...a };
+}
+__name(mergeDepsNoConfig, "mergeDepsNoConfig");
+
+// src/definers/builders/task.phantom.ts
+function clone2(s, patch) {
+  return cloneState(s, patch);
+}
+__name(clone2, "clone");
+function makePhantomTaskBuilder(state) {
+  const builder = {
+    id: state.id,
+    dependencies(deps, options) {
+      const override = options?.override ?? false;
+      const next = clone2(state, {
+        dependencies: mergeDepsNoConfig(
+          state.dependencies,
+          deps,
+          override
+        )
+      });
+      if (override) {
+        return makePhantomTaskBuilder(next);
+      }
+      return makePhantomTaskBuilder(next);
+    },
+    middleware(mw, options) {
+      const override = options?.override ?? false;
+      const next = clone2(state, {
+        middleware: mergeArray2(state.middleware, mw, override)
+      });
+      return makePhantomTaskBuilder(next);
+    },
+    tags(t, options) {
+      const override = options?.override ?? false;
+      const next = clone2(state, { tags: mergeArray2(state.tags, t, override) });
+      return makePhantomTaskBuilder(next);
+    },
+    inputSchema(schema) {
+      const next = clone2(state, { inputSchema: schema });
+      return makePhantomTaskBuilder(next);
+    },
+    resultSchema(schema) {
+      const next = clone2(state, { resultSchema: schema });
+      return makePhantomTaskBuilder(next);
+    },
+    meta(m) {
+      const next = clone2(state, { meta: m });
+      return makePhantomTaskBuilder(next);
+    },
+    build() {
+      const built = defineTask.phantom({
+        id: state.id,
+        dependencies: state.dependencies,
+        middleware: state.middleware,
+        inputSchema: state.inputSchema,
+        resultSchema: state.resultSchema,
+        meta: state.meta,
+        tags: state.tags
+      });
+      return built;
+    }
+  };
+  return builder;
+}
+__name(makePhantomTaskBuilder, "makePhantomTaskBuilder");
+function phantomTaskBuilder(id2) {
+  const initial = Object.freeze({
+    id: id2,
+    dependencies: {},
+    middleware: [],
+    meta: {},
+    inputSchema: void 0,
+    resultSchema: void 0,
+    tags: []
+  });
+  return makePhantomTaskBuilder(initial);
+}
+__name(phantomTaskBuilder, "phantomTaskBuilder");
+
+// src/definers/builders/task.ts
+function clone3(s, patch) {
+  return cloneState(s, patch);
+}
+__name(clone3, "clone");
+function makeTaskBuilder(state) {
+  const builder = {
+    id: state.id,
+    dependencies(deps, options) {
+      const override = options?.override ?? false;
+      const next = clone3(state, {
+        dependencies: mergeDepsNoConfig(
+          state.dependencies,
+          deps,
+          override
+        )
+      });
+      if (override) {
+        return makeTaskBuilder(next);
+      }
+      return makeTaskBuilder(next);
+    },
+    middleware(mw, options) {
+      const override = options?.override ?? false;
+      const next = clone3(state, {
+        middleware: mergeArray2(state.middleware, mw, override)
+      });
+      return makeTaskBuilder(next);
+    },
+    tags(t, options) {
+      const override = options?.override ?? false;
+      const next = clone3(state, { tags: mergeArray2(state.tags, t, override) });
+      return makeTaskBuilder(next);
+    },
+    inputSchema(schema) {
+      const next = clone3(state, { inputSchema: schema });
+      return makeTaskBuilder(next);
+    },
+    resultSchema(schema) {
+      const next = clone3(state, { resultSchema: schema });
+      return makeTaskBuilder(next);
+    },
+    run(fn) {
+      const wrapped = /* @__PURE__ */ __name((input, deps) => fn(
+        input,
+        deps
+      ), "wrapped");
+      const next = clone3(state, { run: wrapped });
+      return makeTaskBuilder(next);
+    },
+    meta(m) {
+      const next = clone3(state, { meta: m });
+      return makeTaskBuilder(next);
+    },
+    build() {
+      return defineTask({
+        ...state
+      });
+    }
+  };
+  return builder;
+}
+__name(makeTaskBuilder, "makeTaskBuilder");
+function taskBuilder(id2) {
+  const initial = Object.freeze({
+    id: id2,
+    dependencies: {},
+    middleware: [],
+    meta: {},
+    inputSchema: void 0,
+    resultSchema: void 0,
+    run: void 0,
+    tags: []
+  });
+  return makeTaskBuilder(initial);
+}
+__name(taskBuilder, "taskBuilder");
+var task = Object.assign(taskBuilder, {
+  phantom: phantomTaskBuilder
+});
+
+// src/definers/builders/event.ts
+function clone4(s, patch) {
+  return Object.freeze({ ...s, ...patch });
+}
+__name(clone4, "clone");
+function makeEventBuilder(state) {
+  const b = {
+    id: state.id,
+    payloadSchema(schema) {
+      const next = clone4(state, { payloadSchema: schema });
+      return makeEventBuilder(next);
+    },
+    tags(t, options) {
+      const override = options?.override ?? false;
+      const tags = mergeArray2(state.tags, t, override);
+      const next = clone4(state, { tags });
+      return makeEventBuilder(next);
+    },
+    meta(m) {
+      const next = clone4(state, { meta: m });
+      return makeEventBuilder(next);
+    },
+    build() {
+      return defineEvent({
+        ...state
+      });
+    }
+  };
+  return b;
+}
+__name(makeEventBuilder, "makeEventBuilder");
+function eventBuilder(id2) {
+  const initial = Object.freeze({
+    id: id2,
+    meta: {},
+    payloadSchema: void 0,
+    tags: []
+  });
+  return makeEventBuilder(initial);
+}
+__name(eventBuilder, "eventBuilder");
+var event = eventBuilder;
+
+// src/definers/builders/hook.ts
+function clone5(s, patch) {
+  return Object.freeze({ ...s, ...patch });
+}
+__name(clone5, "clone");
+function makeHookBuilder(state) {
+  const b = {
+    id: state.id,
+    on(on) {
+      const next = clone5(state, { on });
+      return makeHookBuilder(
+        next
+      );
+    },
+    order(order) {
+      const next = clone5(state, { order });
+      return makeHookBuilder(next);
+    },
+    dependencies(deps, options) {
+      const override = options?.override ?? false;
+      const isFnExisting = typeof state.dependencies === "function";
+      const isFnAddition = typeof deps === "function";
+      let merged;
+      if (override || !state.dependencies) {
+        merged = deps;
+      } else if (isFnExisting && isFnAddition) {
+        const e = state.dependencies;
+        const a = deps;
+        merged = /* @__PURE__ */ __name((() => ({ ...e(), ...a() })), "merged");
+      } else if (isFnExisting && !isFnAddition) {
+        const e = state.dependencies;
+        const a = deps;
+        merged = /* @__PURE__ */ __name((() => ({ ...e(), ...a })), "merged");
+      } else if (!isFnExisting && isFnAddition) {
+        const e = state.dependencies;
+        const a = deps;
+        merged = /* @__PURE__ */ __name((() => ({ ...e, ...a() })), "merged");
+      } else {
+        const e = state.dependencies;
+        const a = deps;
+        merged = { ...e, ...a };
+      }
+      const next = clone5(state, { dependencies: merged });
+      if (override) {
+        return makeHookBuilder(
+          next
+        );
+      }
+      return makeHookBuilder(
+        next
+      );
+    },
+    tags(t, options) {
+      const override = options?.override ?? false;
+      const tags = mergeArray2(state.tags, t, override);
+      const next = clone5(state, { tags });
+      return makeHookBuilder(next);
+    },
+    meta(m) {
+      const next = clone5(state, { meta: m });
+      return makeHookBuilder(
+        next
+      );
+    },
+    run(fn) {
+      const next = clone5(state, { run: fn });
+      return makeHookBuilder(next);
+    },
+    build() {
+      return defineHook({
+        ...state
+      });
+    }
+  };
+  return b;
+}
+__name(makeHookBuilder, "makeHookBuilder");
+function hookBuilder(id2) {
+  const initial = Object.freeze({
+    id: id2,
+    dependencies: {},
+    on: "*",
+    order: void 0,
+    meta: {},
+    run: void 0,
+    tags: []
+  });
+  return makeHookBuilder(initial);
+}
+__name(hookBuilder, "hookBuilder");
+var hook = hookBuilder;
+
+// src/definers/builders/middleware.ts
+function cloneTask(s, patch) {
+  return Object.freeze({ ...s, ...patch });
+}
+__name(cloneTask, "cloneTask");
+function makeTaskMiddlewareBuilder(state) {
+  const b = {
+    id: state.id,
+    dependencies(deps, options) {
+      const override = options?.override ?? false;
+      const isFnExisting = typeof state.dependencies === "function";
+      const isFnAddition = typeof deps === "function";
+      let merged;
+      if (override || !state.dependencies) {
+        merged = deps;
+      } else if (isFnExisting && isFnAddition) {
+        const e = state.dependencies;
+        const a = deps;
+        merged = /* @__PURE__ */ __name(((cfg) => ({ ...e(cfg), ...a(cfg) })), "merged");
+      } else if (isFnExisting && !isFnAddition) {
+        const e = state.dependencies;
+        const a = deps;
+        merged = /* @__PURE__ */ __name(((cfg) => ({ ...e(cfg), ...a })), "merged");
+      } else if (!isFnExisting && isFnAddition) {
+        const e = state.dependencies;
+        const a = deps;
+        merged = /* @__PURE__ */ __name(((cfg) => ({ ...e, ...a(cfg) })), "merged");
+      } else {
+        const e = state.dependencies;
+        const a = deps;
+        merged = { ...e, ...a };
+      }
+      const next = cloneTask(state, { dependencies: merged });
+      if (override) {
+        return makeTaskMiddlewareBuilder(
+          next
+        );
+      }
+      return makeTaskMiddlewareBuilder(
+        next
+      );
+    },
+    configSchema(schema) {
+      const next = cloneTask(state, { configSchema: schema });
+      return makeTaskMiddlewareBuilder(
+        next
+      );
+    },
+    run(fn) {
+      const next = cloneTask(state, { run: fn });
+      return makeTaskMiddlewareBuilder(next);
+    },
+    meta(m) {
+      const next = cloneTask(state, { meta: m });
+      return makeTaskMiddlewareBuilder(next);
+    },
+    tags(t, options) {
+      const override = options?.override ?? false;
+      const tags = mergeArray2(state.tags, t, override);
+      const next = cloneTask(state, { tags });
+      return makeTaskMiddlewareBuilder(next);
+    },
+    everywhere(flag) {
+      const next = cloneTask(state, { everywhere: flag });
+      return makeTaskMiddlewareBuilder(next);
+    },
+    build() {
+      return defineTaskMiddleware({
+        ...state
+      });
+    }
+  };
+  return b;
+}
+__name(makeTaskMiddlewareBuilder, "makeTaskMiddlewareBuilder");
+function taskMiddlewareBuilder(id2) {
+  const initial = Object.freeze({
+    id: id2,
+    dependencies: {},
+    configSchema: void 0,
+    run: void 0,
+    meta: {},
+    tags: [],
+    everywhere: void 0
+  });
+  return makeTaskMiddlewareBuilder(initial);
+}
+__name(taskMiddlewareBuilder, "taskMiddlewareBuilder");
+function cloneRes(s, patch) {
+  return Object.freeze({ ...s, ...patch });
+}
+__name(cloneRes, "cloneRes");
+function makeResourceMiddlewareBuilder(state) {
+  const b = {
+    id: state.id,
+    dependencies(deps, options) {
+      const override = options?.override ?? false;
+      const isFnExisting = typeof state.dependencies === "function";
+      const isFnAddition = typeof deps === "function";
+      let merged;
+      if (override || !state.dependencies) {
+        merged = deps;
+      } else if (isFnExisting && isFnAddition) {
+        const e = state.dependencies;
+        const a = deps;
+        merged = /* @__PURE__ */ __name(((cfg) => ({ ...e(cfg), ...a(cfg) })), "merged");
+      } else if (isFnExisting && !isFnAddition) {
+        const e = state.dependencies;
+        const a = deps;
+        merged = /* @__PURE__ */ __name(((cfg) => ({ ...e(cfg), ...a })), "merged");
+      } else if (!isFnExisting && isFnAddition) {
+        const e = state.dependencies;
+        const a = deps;
+        merged = /* @__PURE__ */ __name(((cfg) => ({ ...e, ...a(cfg) })), "merged");
+      } else {
+        const e = state.dependencies;
+        const a = deps;
+        merged = { ...e, ...a };
+      }
+      const next = cloneRes(state, { dependencies: merged });
+      if (override) {
+        return makeResourceMiddlewareBuilder(
+          next
+        );
+      }
+      return makeResourceMiddlewareBuilder(
+        next
+      );
+    },
+    configSchema(schema) {
+      const next = cloneRes(state, { configSchema: schema });
+      return makeResourceMiddlewareBuilder(
+        next
+      );
+    },
+    run(fn) {
+      const next = cloneRes(state, { run: fn });
+      return makeResourceMiddlewareBuilder(next);
+    },
+    meta(m) {
+      const next = cloneRes(state, { meta: m });
+      return makeResourceMiddlewareBuilder(next);
+    },
+    tags(t, options) {
+      const override = options?.override ?? false;
+      const tags = mergeArray2(state.tags, t, override);
+      const next = cloneRes(state, { tags });
+      return makeResourceMiddlewareBuilder(next);
+    },
+    everywhere(flag) {
+      const next = cloneRes(state, { everywhere: flag });
+      return makeResourceMiddlewareBuilder(next);
+    },
+    build() {
+      return defineResourceMiddleware({
+        ...state
+      });
+    }
+  };
+  return b;
+}
+__name(makeResourceMiddlewareBuilder, "makeResourceMiddlewareBuilder");
+function resourceMiddlewareBuilder(id2) {
+  const initial = Object.freeze({
+    id: id2,
+    dependencies: {},
+    configSchema: void 0,
+    run: void 0,
+    meta: {},
+    tags: [],
+    everywhere: void 0
+  });
+  return makeResourceMiddlewareBuilder(initial);
+}
+__name(resourceMiddlewareBuilder, "resourceMiddlewareBuilder");
+var taskMiddleware = taskMiddlewareBuilder;
+var resourceMiddleware = resourceMiddlewareBuilder;
+
+// src/definers/builders/tag.ts
+function clone6(s, patch) {
+  return Object.freeze({ ...s, ...patch });
+}
+__name(clone6, "clone");
+function makeTagBuilder(state) {
+  const b = {
+    id: state.id,
+    meta(m) {
+      const next = clone6(state, { meta: m });
+      return makeTagBuilder(next);
+    },
+    configSchema(schema) {
+      const next = clone6(state, { configSchema: schema });
+      return makeTagBuilder(
+        next
+      );
+    },
+    config(config) {
+      const next = clone6(state, { config });
+      return makeTagBuilder(
+        next
+      );
+    },
+    build() {
+      return defineTag({
+        id: state.id,
+        meta: state.meta,
+        configSchema: state.configSchema,
+        config: state.config
+      });
+    }
+  };
+  return b;
+}
+__name(makeTagBuilder, "makeTagBuilder");
+function tagBuilder(id2) {
+  const initial = Object.freeze(
+    {
+      id: id2,
+      meta: {},
+      configSchema: void 0,
+      config: void 0
+    }
+  );
+  return makeTagBuilder(initial);
+}
+__name(tagBuilder, "tagBuilder");
+var tag = tagBuilder;
+
 // src/models/Semaphore.ts
 var Semaphore = class {
   constructor(maxPermits) {
@@ -4452,15 +5623,25 @@ var Semaphore = class {
     };
   }
 };
-
-// src/index.ts
 var globals = {
   events: globalEvents,
   resources: globalResources,
   middleware: globalMiddlewares,
-  tags: globalTags
+  tags: globalTags,
+  tunnels
 };
+var r = Object.freeze({
+  resource,
+  task,
+  event,
+  hook,
+  tag,
+  middleware: Object.freeze({
+    task: taskMiddleware,
+    resource: resourceMiddleware
+  })
+});
 
-export { DependencyProcessor, errors_exports as Errors, EventManager, Logger, MiddlewareManager, Queue, ResourceInitializer, RunResult, Semaphore, Store, TaskRunner, allFalse, bindProcessErrorHandler, createContext, createDefaultUnhandledError, createTestResource, defs_exports as definitions, defineEvent as event, getConfig, globals, defineHook as hook, levelNormal, levelVerbose, defineOverride as override, defineResource as resource, defineResourceMiddleware as resourceMiddleware, run, safeReportUnhandledError, defineTag as tag, defineTask as task, defineTaskMiddleware as taskMiddleware };
+export { DependencyProcessor, errors_exports as Errors, EventManager, Logger, MiddlewareManager, PlatformAdapter, Queue, ResourceInitializer, RunResult, Semaphore, Store, TaskRunner, allFalse, bindProcessErrorHandler, createContext, createDefaultUnhandledError, createTestResource, defs_exports as definitions, defineEvent as event, getConfig, globals, defineHook as hook, levelNormal, levelVerbose, defineOverride as override, r, defineResource as resource, defineResourceMiddleware as resourceMiddleware, run, safeReportUnhandledError, setPlatform, defineTag as tag, defineTask as task, defineTaskMiddleware as taskMiddleware };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map