@bluelibs/runner 4.6.0 → 4.7.0-alpha

package/dist/universal/index.cjs

@@ -1,9 +1,16 @@
 'use strict';
 
 var lruCache = require('lru-cache');
+var ejson = require('@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 });
@@ -20,17 +27,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"
@@ -46,6 +58,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(
@@ -101,7 +116,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,
@@ -112,7 +127,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;
@@ -123,12 +138,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;
   }
@@ -178,6 +193,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) {
@@ -199,6 +224,7 @@ __name(defineHook, "defineHook");
 // src/errors.ts
 var errors_exports = {};
 __export(errors_exports, {
+  CancellationError: () => CancellationError,
   CircularDependenciesError: () => CircularDependenciesError,
   ContextError: () => ContextError,
   DependencyNotFoundError: () => DependencyNotFoundError,
@@ -214,7 +240,8 @@ __export(errors_exports, {
   StoreAlreadyInitializedError: () => StoreAlreadyInitializedError,
   TagNotFoundError: () => TagNotFoundError,
   UnknownItemTypeError: () => UnknownItemTypeError,
-  ValidationError: () => ValidationError
+  ValidationError: () => ValidationError,
+  isCancellationError: () => isCancellationError
 });
 
 // src/platform/adapters/node-als.ts
@@ -267,9 +294,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");
@@ -456,6 +501,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";
   }
@@ -571,6 +619,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 {
@@ -754,6 +859,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) {
@@ -1046,14 +1164,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);
   }
 });
 
@@ -1107,6 +1225,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({
@@ -1123,7 +1259,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
@@ -1160,7 +1298,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"));
     }
@@ -1173,7 +1311,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(() => {
     });
@@ -1205,11 +1343,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"),
@@ -1267,6 +1405,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
 };
@@ -1274,8 +1420,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);
@@ -1298,8 +1444,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);
@@ -1324,8 +1470,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) {
@@ -1350,8 +1496,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) {
@@ -1409,11 +1555,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);
@@ -1422,7 +1568,7 @@ var TaskRunner = class {
         await this.store.onUnhandledError({
           error,
           kind: "task",
-          source: task.id
+          source: task2.id
         });
       } catch (_) {
       }
@@ -1436,8 +1582,8 @@ var TaskRunner = class {
    * @param taskDependencies
    * @returns
    */
-  createRunnerWithMiddleware(task) {
-    return this.middlewareManager.composeTaskRunner(task);
+  createRunnerWithMiddleware(task2) {
+    return this.middlewareManager.composeTaskRunner(task2);
   }
 };
 
@@ -1585,28 +1731,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;
@@ -1624,7 +1773,7 @@ var MiddlewareManager = class {
       ].reverse();
       const createExecutionInput = /* @__PURE__ */ __name((input, nextFunc) => ({
         task: {
-          definition: task,
+          definition: task2,
           input
         },
         next: nextFunc
@@ -1643,7 +1792,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;
     }
@@ -1655,7 +1816,7 @@ var MiddlewareManager = class {
         return storeMiddleware.middleware.run(
           {
             task: {
-              definition: task,
+              definition: task2,
               input
             },
             next: nextFunction
@@ -1677,29 +1838,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(
@@ -1711,7 +1872,7 @@ var MiddlewareManager = class {
           const result = await storeMiddleware.middleware.run(
             {
               resource: {
-                definition: resource,
+                definition: resource2,
                 config: cfg
               },
               next: nextFunction
@@ -1725,7 +1886,7 @@ var MiddlewareManager = class {
             await this.store.onUnhandledError({
               error,
               kind: "resourceInit",
-              source: resource.id
+              source: resource2.id
             });
           } catch (_) {
           }
@@ -1746,7 +1907,7 @@ var MiddlewareManager = class {
       ].reverse();
       const createExecutionInput = /* @__PURE__ */ __name((config2, nextFunc) => ({
         resource: {
-          definition: resource,
+          definition: resource2,
           config: config2
         },
         next: nextFunc
@@ -1767,19 +1928,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];
   }
@@ -1787,10 +1948,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);
@@ -1827,15 +1988,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
@@ -1844,9 +2005,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
@@ -2312,45 +2473,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;
       }
     }
   }
@@ -2358,13 +2519,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
     );
@@ -2424,20 +2585,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)) {
@@ -2537,14 +2698,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
         );
@@ -2624,7 +2785,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(),
@@ -2659,7 +2820,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();
@@ -2693,7 +2854,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,
@@ -2702,10 +2863,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);
@@ -2782,7 +2943,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(
@@ -2802,11 +2963,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 ====================
@@ -2867,8 +3028,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.
@@ -2993,25 +3154,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
           );
         }
@@ -3035,9 +3196,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);
           }
         }
       }
@@ -3091,9 +3252,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: {}
     });
   }
@@ -3175,9 +3336,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
     });
@@ -3187,11 +3348,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);
@@ -3200,7 +3361,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) {
@@ -3224,9 +3385,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;
           }
         }
@@ -3248,19 +3409,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);
@@ -3269,18 +3430,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);
@@ -3332,12 +3493,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()) {
@@ -3356,31 +3517,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);
@@ -3469,7 +3630,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;
@@ -3535,24 +3821,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.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,
@@ -3568,7 +3855,8 @@ var Store = class {
     });
     const builtInResourceMiddlewares = [
       retryResourceMiddleware,
-      timeoutResourceMiddleware
+      timeoutResourceMiddleware,
+      tunnelResourceMiddleware
     ];
     builtInResourceMiddlewares.forEach((middleware) => {
       this.registry.resourceMiddlewares.set(middleware.id, {
@@ -3615,19 +3903,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
         );
       }
     }
@@ -3651,16 +3939,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);
   }
 };
 
@@ -3758,16 +4046,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"),
@@ -3781,26 +4069,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
@@ -3820,23 +4108,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, {
@@ -3865,14 +4153,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, {
@@ -3882,7 +4170,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, {
@@ -3898,7 +4186,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
@@ -3910,7 +4198,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
@@ -3939,23 +4227,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"
@@ -4036,13 +4324,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);
@@ -4103,38 +4385,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);
       }
@@ -4169,7 +4451,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({
@@ -4212,7 +4494,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();
@@ -4259,19 +4541,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) {
@@ -4294,7 +4709,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)
@@ -4306,6 +4721,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) {
@@ -4454,20 +5624,35 @@ 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
+  })
+});
 
+Object.defineProperty(exports, "EJSON", {
+  enumerable: true,
+  get: function () { return ejson.EJSON; }
+});
 exports.DependencyProcessor = DependencyProcessor;
 exports.Errors = errors_exports;
 exports.EventManager = EventManager;
 exports.Logger = Logger;
 exports.MiddlewareManager = MiddlewareManager;
+exports.PlatformAdapter = PlatformAdapter;
 exports.Queue = Queue;
 exports.ResourceInitializer = ResourceInitializer;
 exports.RunResult = RunResult;
@@ -4487,10 +5672,12 @@ exports.hook = defineHook;
 exports.levelNormal = levelNormal;
 exports.levelVerbose = levelVerbose;
 exports.override = defineOverride;
+exports.r = r;
 exports.resource = defineResource;
 exports.resourceMiddleware = defineResourceMiddleware;
 exports.run = run;
 exports.safeReportUnhandledError = safeReportUnhandledError;
+exports.setPlatform = setPlatform;
 exports.tag = defineTag;
 exports.task = defineTask;
 exports.taskMiddleware = defineTaskMiddleware;