@bluelibs/runner 4.8.2 → 4.8.4

package/dist/browser/index.mjs

@@ -37,8 +37,7 @@ __export(defs_exports, {
   symbolTagConfigured: () => symbolTagConfigured,
   symbolTask: () => symbolTask,
   symbolTaskMiddleware: () => symbolTaskMiddleware,
-  symbolTunneledBy: () => symbolTunneledBy,
-  symbolTunneledTask: () => symbolTunneledTask
+  symbolTunneledBy: () => symbolTunneledBy
 });
 
 // src/types/symbols.ts
@@ -62,9 +61,6 @@ var symbolResourceMiddleware = Symbol.for(
 var symbolMiddlewareConfigured = Symbol.for(
   "runner.middlewareConfigured"
 );
-var symbolTunneledTask = Symbol.for(
-  "runner.tunneledTask"
-);
 var symbolTunneledBy = Symbol.for(
   "runner.tunneledBy"
 );
@@ -2072,39 +2068,33 @@ var TaskRunner = class {
   }
 };
 
-// src/models/MiddlewareManager.ts
-var MiddlewareManager = class {
-  constructor(store2, eventManager, logger) {
-    this.store = store2;
-    this.eventManager = eventManager;
-    this.logger = logger;
-    // Interceptor storage
-    this.taskMiddlewareInterceptors = [];
-    this.resourceMiddlewareInterceptors = [];
-    // Per-middleware interceptor storage
-    this.perMiddlewareInterceptors = /* @__PURE__ */ new Map();
-    this.perResourceMiddlewareInterceptors = /* @__PURE__ */ new Map();
-    // Locking mechanism to prevent modifications after initialization
+// src/models/middleware/InterceptorRegistry.ts
+var InterceptorRegistry = class {
+  constructor() {
+    this.taskInterceptors = [];
+    this.resourceInterceptors = [];
+    this.perTaskMiddleware = /* @__PURE__ */ new Map();
+    this.perResourceMiddleware = /* @__PURE__ */ new Map();
     this.#isLocked = false;
   }
   static {
-    __name(this, "MiddlewareManager");
+    __name(this, "InterceptorRegistry");
   }
   #isLocked;
   /**
-   * Gets the current lock status of the MiddlewareManager
+   * Gets the current lock status
    */
   get isLocked() {
     return this.#isLocked;
   }
   /**
-   * Locks the MiddlewareManager, preventing any further modifications to interceptors
+   * Locks the registry, preventing any further modifications
    */
   lock() {
     this.#isLocked = true;
   }
   /**
-   * Throws an error if the MiddlewareManager is locked
+   * Throws an error if the registry is locked
    */
   checkLock() {
     if (this.#isLocked) {
@@ -2112,193 +2102,288 @@ var MiddlewareManager = class {
     }
   }
   /**
-   * Adds an interceptor for task or resource middleware execution
-   * Interceptors are executed in the order they are added, with the ability to
-   * modify, log, or prevent middleware execution
-   *
-   * @param kind - The type of middleware to intercept ("task" or "resource")
-   * @param interceptor - The interceptor function to add
+   * Adds a global task interceptor
    */
-  intercept(kind, interceptor) {
+  addGlobalTaskInterceptor(interceptor) {
     this.checkLock();
-    if (kind === "task") {
-      this.taskMiddlewareInterceptors.push(
-        interceptor
-      );
-    } else {
-      this.resourceMiddlewareInterceptors.push(
-        interceptor
-      );
+    this.taskInterceptors.push(interceptor);
+  }
+  /**
+   * Adds a global resource interceptor
+   */
+  addGlobalResourceInterceptor(interceptor) {
+    this.checkLock();
+    this.resourceInterceptors.push(interceptor);
+  }
+  /**
+   * Adds an interceptor for a specific task middleware instance
+   */
+  addTaskMiddlewareInterceptor(middlewareId, interceptor) {
+    this.checkLock();
+    if (!this.perTaskMiddleware.has(middlewareId)) {
+      this.perTaskMiddleware.set(middlewareId, []);
     }
+    this.perTaskMiddleware.get(middlewareId).push(interceptor);
   }
   /**
-   * Adds an interceptor for a specific middleware instance with better type safety
-   * This method automatically determines the type and provides type-safe access
-   *
-   * @param middleware - The middleware instance to intercept
-   * @param interceptor - The interceptor function with proper typing
+   * Adds an interceptor for a specific resource middleware instance
    */
-  interceptMiddleware(middleware, interceptor) {
+  addResourceMiddlewareInterceptor(middlewareId, interceptor) {
     this.checkLock();
-    if (isTaskMiddleware(middleware)) {
-      if (!this.perMiddlewareInterceptors.has(middleware.id)) {
-        this.perMiddlewareInterceptors.set(middleware.id, []);
+    if (!this.perResourceMiddleware.has(middlewareId)) {
+      this.perResourceMiddleware.set(middlewareId, []);
+    }
+    this.perResourceMiddleware.get(middlewareId).push(interceptor);
+  }
+  /**
+   * Gets all global task interceptors
+   */
+  getGlobalTaskInterceptors() {
+    return this.taskInterceptors;
+  }
+  /**
+   * Gets all global resource interceptors
+   */
+  getGlobalResourceInterceptors() {
+    return this.resourceInterceptors;
+  }
+  /**
+   * Gets interceptors for a specific task middleware
+   */
+  getTaskMiddlewareInterceptors(middlewareId) {
+    return this.perTaskMiddleware.get(middlewareId) || [];
+  }
+  /**
+   * Gets interceptors for a specific resource middleware
+   */
+  getResourceMiddlewareInterceptors(middlewareId) {
+    return this.perResourceMiddleware.get(middlewareId) || [];
+  }
+};
+
+// src/models/middleware/MiddlewareResolver.ts
+var MiddlewareResolver = class {
+  constructor(store2) {
+    this.store = store2;
+  }
+  static {
+    __name(this, "MiddlewareResolver");
+  }
+  /**
+   * Gets all applicable middlewares for a task (global + local, deduplicated)
+   */
+  getApplicableTaskMiddlewares(task2) {
+    const local = task2.middleware;
+    const localIds = new Set(local.map((m) => m.id));
+    const global = this.getEverywhereTaskMiddlewares(task2).filter(
+      (m) => !localIds.has(m.id)
+    );
+    return [...global, ...local];
+  }
+  /**
+   * Gets all applicable middlewares for a resource (global + local, deduplicated)
+   */
+  getApplicableResourceMiddlewares(resource2) {
+    const local = resource2.middleware;
+    const localIds = new Set(local.map((m) => m.id));
+    const global = this.getEverywhereResourceMiddlewares(resource2).filter(
+      (m) => !localIds.has(m.id)
+    );
+    return [...global, ...local];
+  }
+  /**
+   * Applies tunnel policy filter to middlewares if task is tunneled
+   * Only allows whitelisted middlewares when tunnel policy is set
+   */
+  applyTunnelPolicyFilter(task2, middlewares) {
+    const tDef = this.store.tasks.get(task2.id).task;
+    const isLocallyTunneled = tDef.isTunneled;
+    if (!isLocallyTunneled || !globalTags.tunnelPolicy.exists(tDef)) {
+      return middlewares;
+    }
+    const cfg = globalTags.tunnelPolicy.extract(task2);
+    const allowList = cfg?.client;
+    if (!Array.isArray(allowList)) {
+      return middlewares;
+    }
+    const toId = /* @__PURE__ */ __name((x) => typeof x === "string" ? x : x?.id, "toId");
+    const allowed = new Set(allowList.map(toId).filter(Boolean));
+    return middlewares.filter((m) => allowed.has(m.id));
+  }
+  /**
+   * Gets all "everywhere" middlewares that apply to the given task
+   */
+  getEverywhereTaskMiddlewares(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(task2);
       }
-      this.perMiddlewareInterceptors.get(middleware.id).push(interceptor);
-    } else if (isResourceMiddleware(middleware)) {
-      if (!this.perResourceMiddlewareInterceptors.has(middleware.id)) {
-        this.perResourceMiddlewareInterceptors.set(middleware.id, []);
+      return true;
+    }).map((x) => x.middleware);
+  }
+  /**
+   * Gets all "everywhere" middlewares that apply to the given resource
+   */
+  getEverywhereResourceMiddlewares(resource2) {
+    return Array.from(this.store.resourceMiddlewares.values()).filter((x) => Boolean(x.middleware.everywhere)).filter((x) => {
+      if (typeof x.middleware.everywhere === "function") {
+        return x.middleware.everywhere(resource2);
       }
-      this.perResourceMiddlewareInterceptors.get(middleware.id).push(interceptor);
-    } else {
-      throw new Error("Unknown middleware type");
+      return true;
+    }).map((x) => x.middleware);
+  }
+};
+
+// src/models/middleware/ValidationHelper.ts
+var ValidationHelper = class {
+  static {
+    __name(this, "ValidationHelper");
+  }
+  /**
+   * Validates input using the provided schema
+   * @throws ValidationError if validation fails
+   */
+  static validateInput(value, schema, id2, type) {
+    if (!schema) return value;
+    try {
+      return schema.parse(value);
+    } catch (error2) {
+      return validationError.throw({
+        subject: `${type} input`,
+        id: id2,
+        originalError: error2 instanceof Error ? error2 : new Error(String(error2))
+      });
     }
   }
   /**
-   * Wrap a middleware with its specific interceptors in onion style
+   * Validates result using the provided schema
+   * @throws ValidationError if validation fails
    */
-  wrapMiddlewareWithInterceptors(middleware, middlewareRunner, interceptors) {
-    if (!interceptors.length) {
-      return middlewareRunner;
+  static validateResult(value, schema, id2, type) {
+    if (!schema) return value;
+    try {
+      return schema.parse(value);
+    } catch (error2) {
+      return validationError.throw({
+        subject: `${type} result`,
+        id: id2,
+        originalError: error2 instanceof Error ? error2 : new Error(String(error2))
+      });
     }
-    const reversedInterceptors = [...interceptors].reverse();
-    let wrapped = middlewareRunner;
-    for (let i = reversedInterceptors.length - 1; i >= 0; i--) {
-      const interceptor = reversedInterceptors[i];
+  }
+};
+
+// src/models/middleware/TaskMiddlewareComposer.ts
+var TaskMiddlewareComposer = class {
+  constructor(store2, interceptorRegistry, middlewareResolver) {
+    this.store = store2;
+    this.interceptorRegistry = interceptorRegistry;
+    this.middlewareResolver = middlewareResolver;
+  }
+  static {
+    __name(this, "TaskMiddlewareComposer");
+  }
+  /**
+   * Composes a complete task runner with all middleware and interceptors applied
+   */
+  compose(task2) {
+    const storeTask = this.store.tasks.get(task2.id);
+    let runner = this.createBaseRunner(task2, storeTask);
+    runner = this.applyLocalInterceptors(runner, storeTask);
+    runner = this.applyGlobalInterceptors(runner, task2);
+    runner = this.applyMiddlewares(runner, task2, storeTask);
+    return runner;
+  }
+  /**
+   * Creates the base task runner with input/result validation
+   */
+  createBaseRunner(task2, storeTask) {
+    return async (input) => {
+      const runnerTask = this.resolveTaskDefinition(task2, storeTask.task);
+      const validatedInput = ValidationHelper.validateInput(
+        input,
+        runnerTask.inputSchema,
+        runnerTask.id,
+        "Task"
+      );
+      const rawResult = await runnerTask.run(
+        validatedInput,
+        storeTask.computedDependencies
+      );
+      return ValidationHelper.validateResult(
+        rawResult,
+        runnerTask.resultSchema,
+        runnerTask.id,
+        "Task"
+      );
+    };
+  }
+  /**
+   * Determines which task definition to use for execution
+   * Prefers store definition when task is tunneled (tunnel overrides apply)
+   */
+  resolveTaskDefinition(task2, storeTask) {
+    const isLocallyTunneled = task2.isTunneled || storeTask.isTunneled;
+    return isLocallyTunneled ? storeTask : task2;
+  }
+  /**
+   * Applies local per-task interceptors (closest to the task)
+   */
+  applyLocalInterceptors(runner, storeTask) {
+    if (!storeTask.interceptors || storeTask.interceptors.length === 0) {
+      return runner;
+    }
+    let wrapped = runner;
+    for (let i = storeTask.interceptors.length - 1; i >= 0; i--) {
+      const interceptor = storeTask.interceptors[i];
       const nextFunction = wrapped;
-      wrapped = /* @__PURE__ */ __name(async (input) => {
-        const executionInput = {
-          task: {
-            definition: null,
-            // Will be filled by middleware.run
-            input
-          },
-          next: nextFunction
-        };
-        const wrappedNext = /* @__PURE__ */ __name((i2) => {
-          return nextFunction(i2.task.input);
-        }, "wrappedNext");
-        return interceptor(wrappedNext, executionInput);
-      }, "wrapped");
+      wrapped = /* @__PURE__ */ __name(async (input) => interceptor(nextFunction, input), "wrapped");
     }
     return wrapped;
   }
   /**
-   * Wrap a resource middleware with its specific interceptors in onion style
+   * Applies global task middleware interceptors
    */
-  wrapResourceMiddlewareWithInterceptors(middleware, middlewareRunner, interceptors) {
-    if (!interceptors.length) {
-      return middlewareRunner;
+  applyGlobalInterceptors(runner, task2) {
+    const interceptors = this.interceptorRegistry.getGlobalTaskInterceptors();
+    if (interceptors.length === 0) {
+      return runner;
     }
     const reversedInterceptors = [...interceptors].reverse();
-    let wrapped = middlewareRunner;
+    const createExecutionInput = /* @__PURE__ */ __name((input, nextFunc) => ({
+      task: {
+        definition: task2,
+        input
+      },
+      next: nextFunc
+    }), "createExecutionInput");
+    let currentNext = runner;
     for (let i = reversedInterceptors.length - 1; i >= 0; i--) {
       const interceptor = reversedInterceptors[i];
-      const nextFunction = wrapped;
-      wrapped = /* @__PURE__ */ __name(async (config) => {
-        const executionInput = {
-          resource: {
-            definition: null,
-            // Will be filled by middleware.run
-            config
-          },
-          next: nextFunction
-        };
-        const wrappedNext = /* @__PURE__ */ __name((input) => {
-          return nextFunction(input.resource.config);
+      const nextFunction = currentNext;
+      currentNext = /* @__PURE__ */ __name(async (input) => {
+        const executionInput = createExecutionInput(input, nextFunction);
+        const wrappedNext = /* @__PURE__ */ __name((i2) => {
+          return nextFunction(i2.task.input);
         }, "wrappedNext");
         return interceptor(wrappedNext, executionInput);
-      }, "wrapped");
+      }, "currentNext");
     }
-    return wrapped;
+    return currentNext;
   }
   /**
-   * 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.
+   * Applies task middleware layers (global first, then local)
    */
-  composeTaskRunner(task2) {
-    const storeTask = this.store.tasks.get(task2.id);
-    const tDef = storeTask.task;
-    let next = /* @__PURE__ */ __name(async (input) => {
-      let rawInput = input;
-      const isLocallyTunneled = task2[symbolTunneledTask] === "client" || tDef[symbolTunneledTask] === "client";
-      const runnerTask = isLocallyTunneled ? tDef : task2;
-      if (runnerTask.inputSchema) {
-        try {
-          rawInput = runnerTask.inputSchema.parse(rawInput);
-        } catch (error2) {
-          validationError.throw({
-            subject: "Task input",
-            id: runnerTask.id,
-            originalError: error2 instanceof Error ? error2 : new Error(String(error2))
-          });
-        }
-      }
-      const deps = storeTask.computedDependencies;
-      const rawResult = await runnerTask.run.call(null, rawInput, deps);
-      if (runnerTask.resultSchema) {
-        try {
-          return runnerTask.resultSchema.parse(rawResult);
-        } catch (error2) {
-          validationError.throw({
-            subject: "Task result",
-            id: runnerTask.id,
-            originalError: error2
-          });
-        }
-      }
-      return rawResult;
-    }, "next");
-    if (storeTask.interceptors && storeTask.interceptors.length > 0) {
-      for (let i = storeTask.interceptors.length - 1; i >= 0; i--) {
-        const interceptor = storeTask.interceptors[i];
-        const nextFunction = next;
-        next = /* @__PURE__ */ __name(async (input) => interceptor(nextFunction, input), "next");
-      }
-    }
-    if (this.taskMiddlewareInterceptors.length > 0) {
-      const reversedInterceptors = [
-        ...this.taskMiddlewareInterceptors
-      ].reverse();
-      const createExecutionInput = /* @__PURE__ */ __name((input, nextFunc) => ({
-        task: {
-          definition: task2,
-          input
-        },
-        next: nextFunc
-      }), "createExecutionInput");
-      let currentNext = next;
-      for (let i = reversedInterceptors.length - 1; i >= 0; i--) {
-        const interceptor = reversedInterceptors[i];
-        const nextFunction = currentNext;
-        currentNext = /* @__PURE__ */ __name(async (input) => {
-          const executionInput = createExecutionInput(input, nextFunction);
-          const wrappedNext = /* @__PURE__ */ __name((i2) => {
-            return nextFunction(i2.task.input);
-          }, "wrappedNext");
-          return interceptor(wrappedNext, executionInput);
-        }, "currentNext");
-      }
-      next = currentNext;
-    }
-    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;
-    }
-    for (let i = createdMiddlewares.length - 1; i >= 0; i--) {
-      const middleware = createdMiddlewares[i];
+  applyMiddlewares(runner, task2, storeTask) {
+    storeTask.task;
+    let middlewares = this.middlewareResolver.getApplicableTaskMiddlewares(task2);
+    middlewares = this.middlewareResolver.applyTunnelPolicyFilter(task2, middlewares);
+    if (middlewares.length === 0) {
+      return runner;
+    }
+    let next = runner;
+    for (let i = middlewares.length - 1; i >= 0; i--) {
+      const middleware = middlewares[i];
       const storeMiddleware = this.store.taskMiddlewares.get(middleware.id);
       const nextFunction = next;
       const baseMiddlewareRunner = /* @__PURE__ */ __name(async (input) => {
@@ -2314,51 +2399,96 @@ var MiddlewareManager = class {
           middleware.config
         );
       }, "baseMiddlewareRunner");
-      const middlewareInterceptors = this.perMiddlewareInterceptors.get(middleware.id) || [];
-      const wrappedMiddleware = this.wrapMiddlewareWithInterceptors(
-        middleware,
+      const middlewareInterceptors = this.interceptorRegistry.getTaskMiddlewareInterceptors(middleware.id);
+      next = this.wrapWithInterceptors(
         baseMiddlewareRunner,
         middlewareInterceptors
       );
-      next = wrappedMiddleware;
     }
     return next;
   }
   /**
-   * Run a resource init wrapped with its applicable middlewares.
+   * Wraps a middleware runner with its specific interceptors in onion style
    */
-  async runResourceInit(resource2, config, dependencies, context) {
-    let next = /* @__PURE__ */ __name(async (cfg) => {
-      if (!resource2.init) return void 0;
-      const rawValue = await resource2.init.call(
-        null,
-        cfg,
-        dependencies,
-        context
-      );
-      if (resource2.resultSchema) {
-        try {
-          return resource2.resultSchema.parse(rawValue);
-        } catch (error2) {
-          validationError.throw({
-            subject: "Resource result",
-            id: resource2.id,
-            originalError: error2
-          });
-        }
+  wrapWithInterceptors(middlewareRunner, interceptors) {
+    if (interceptors.length === 0) {
+      return middlewareRunner;
+    }
+    const reversedInterceptors = [...interceptors].reverse();
+    let wrapped = middlewareRunner;
+    for (let i = reversedInterceptors.length - 1; i >= 0; i--) {
+      const interceptor = reversedInterceptors[i];
+      const nextFunction = wrapped;
+      wrapped = /* @__PURE__ */ __name(async (input) => {
+        const executionInput = {
+          task: {
+            definition: null,
+            input
+          },
+          next: nextFunction
+        };
+        const wrappedNext = /* @__PURE__ */ __name((i2) => {
+          return nextFunction(i2.task.input);
+        }, "wrappedNext");
+        return interceptor(wrappedNext, executionInput);
+      }, "wrapped");
+    }
+    return wrapped;
+  }
+};
+
+// src/models/middleware/ResourceMiddlewareComposer.ts
+var ResourceMiddlewareComposer = class {
+  constructor(store2, interceptorRegistry, middlewareResolver) {
+    this.store = store2;
+    this.interceptorRegistry = interceptorRegistry;
+    this.middlewareResolver = middlewareResolver;
+  }
+  static {
+    __name(this, "ResourceMiddlewareComposer");
+  }
+  /**
+   * Runs resource initialization with all middleware and interceptors applied
+   */
+  async runInit(resource2, config, dependencies, context) {
+    let runner = this.createBaseInitRunner(resource2, dependencies, context);
+    runner = this.applyMiddlewares(runner, resource2);
+    runner = this.applyGlobalInterceptors(runner, resource2);
+    return runner(config);
+  }
+  /**
+   * Creates the base resource init runner with result validation
+   */
+  createBaseInitRunner(resource2, dependencies, context) {
+    return async (config) => {
+      if (!resource2.init) {
+        return void 0;
       }
-      return rawValue;
-    }, "next");
-    const createdMiddlewares = this.getApplicableResourceMiddlewares(resource2);
-    for (let i = createdMiddlewares.length - 1; i >= 0; i--) {
-      const middleware = createdMiddlewares[i];
-      const storeMiddleware = this.store.resourceMiddlewares.get(
-        middleware.id
+      const rawValue = await resource2.init(config, dependencies, context);
+      return ValidationHelper.validateResult(
+        rawValue,
+        resource2.resultSchema,
+        resource2.id,
+        "Resource"
       );
+    };
+  }
+  /**
+   * Applies resource middleware layers
+   */
+  applyMiddlewares(runner, resource2) {
+    const middlewares = this.middlewareResolver.getApplicableResourceMiddlewares(resource2);
+    if (middlewares.length === 0) {
+      return runner;
+    }
+    let next = runner;
+    for (let i = middlewares.length - 1; i >= 0; i--) {
+      const middleware = middlewares[i];
+      const storeMiddleware = this.store.resourceMiddlewares.get(middleware.id);
       const nextFunction = next;
       const baseMiddlewareRunner = /* @__PURE__ */ __name(async (cfg) => {
         try {
-          const result = await storeMiddleware.middleware.run(
+          return await storeMiddleware.middleware.run(
             {
               resource: {
                 definition: resource2,
@@ -2369,7 +2499,6 @@ var MiddlewareManager = class {
             storeMiddleware.computedDependencies,
             middleware.config
           );
-          return result;
         } catch (error2) {
           try {
             await this.store.onUnhandledError({
@@ -2382,79 +2511,192 @@ var MiddlewareManager = class {
           throw error2;
         }
       }, "baseMiddlewareRunner");
-      const middlewareInterceptors = this.perResourceMiddlewareInterceptors.get(middleware.id) || [];
-      const wrappedMiddleware = this.wrapResourceMiddlewareWithInterceptors(
-        middleware,
+      const middlewareInterceptors = this.interceptorRegistry.getResourceMiddlewareInterceptors(middleware.id);
+      next = this.wrapWithInterceptors(
         baseMiddlewareRunner,
         middlewareInterceptors
       );
-      next = wrappedMiddleware;
-    }
-    if (this.resourceMiddlewareInterceptors.length > 0) {
-      const reversedInterceptors = [
-        ...this.resourceMiddlewareInterceptors
-      ].reverse();
-      const createExecutionInput = /* @__PURE__ */ __name((config2, nextFunc) => ({
-        resource: {
-          definition: resource2,
-          config: config2
-        },
-        next: nextFunc
-      }), "createExecutionInput");
-      let currentNext = next;
-      for (let i = reversedInterceptors.length - 1; i >= 0; i--) {
-        const interceptor = reversedInterceptors[i];
-        const nextFunction = currentNext;
-        currentNext = /* @__PURE__ */ __name(async (cfg) => {
-          const executionInput = createExecutionInput(cfg, nextFunction);
-          const wrappedNext = /* @__PURE__ */ __name((input) => {
-            return nextFunction(input.resource.config);
-          }, "wrappedNext");
-          return interceptor(wrappedNext, executionInput);
-        }, "currentNext");
-      }
-      next = currentNext;
     }
-    return next(config);
+    return next;
   }
-  getApplicableTaskMiddlewares(task2) {
-    const existingMiddlewares = task2.middleware;
-    const existingMiddlewareIds = existingMiddlewares.map((x) => x.id);
-    const globalMiddlewares2 = this.getEverywhereMiddlewareForTasks(task2).filter(
-      (x) => !existingMiddlewareIds.includes(x.id)
+  /**
+   * Applies global resource middleware interceptors
+   */
+  applyGlobalInterceptors(runner, resource2) {
+    const interceptors = this.interceptorRegistry.getGlobalResourceInterceptors();
+    if (interceptors.length === 0) {
+      return runner;
+    }
+    const reversedInterceptors = [...interceptors].reverse();
+    const createExecutionInput = /* @__PURE__ */ __name((config, nextFunc) => ({
+      resource: {
+        definition: resource2,
+        config
+      },
+      next: nextFunc
+    }), "createExecutionInput");
+    let currentNext = runner;
+    for (let i = reversedInterceptors.length - 1; i >= 0; i--) {
+      const interceptor = reversedInterceptors[i];
+      const nextFunction = currentNext;
+      currentNext = /* @__PURE__ */ __name(async (cfg) => {
+        const executionInput = createExecutionInput(cfg, nextFunction);
+        const wrappedNext = /* @__PURE__ */ __name((input) => {
+          return nextFunction(input.resource.config);
+        }, "wrappedNext");
+        return interceptor(wrappedNext, executionInput);
+      }, "currentNext");
+    }
+    return currentNext;
+  }
+  /**
+   * Wraps a middleware runner with its specific interceptors in onion style
+   */
+  wrapWithInterceptors(middlewareRunner, interceptors) {
+    if (interceptors.length === 0) {
+      return middlewareRunner;
+    }
+    const reversedInterceptors = [...interceptors].reverse();
+    let wrapped = middlewareRunner;
+    for (let i = reversedInterceptors.length - 1; i >= 0; i--) {
+      const interceptor = reversedInterceptors[i];
+      const nextFunction = wrapped;
+      wrapped = /* @__PURE__ */ __name(async (config) => {
+        const executionInput = {
+          resource: {
+            definition: null,
+            config
+          },
+          next: nextFunction
+        };
+        const wrappedNext = /* @__PURE__ */ __name((input) => {
+          return nextFunction(input.resource.config);
+        }, "wrappedNext");
+        return interceptor(wrappedNext, executionInput);
+      }, "wrapped");
+    }
+    return wrapped;
+  }
+};
+
+// src/models/MiddlewareManager.ts
+var MiddlewareManager = class {
+  constructor(store2, eventManager, logger) {
+    this.store = store2;
+    this.eventManager = eventManager;
+    this.logger = logger;
+    this.interceptorRegistry = new InterceptorRegistry();
+    this.middlewareResolver = new MiddlewareResolver(store2);
+    this.taskComposer = new TaskMiddlewareComposer(
+      store2,
+      this.interceptorRegistry,
+      this.middlewareResolver
+    );
+    this.resourceComposer = new ResourceMiddlewareComposer(
+      store2,
+      this.interceptorRegistry,
+      this.middlewareResolver
     );
-    return [...globalMiddlewares2, ...existingMiddlewares];
   }
-  getApplicableResourceMiddlewares(resource2) {
-    const existingMiddlewares = resource2.middleware;
-    const existingMiddlewareIds = existingMiddlewares.map((x) => x.id);
-    const globalMiddlewares2 = this.getEverywhereMiddlewareForResources(
-      resource2
-    ).filter((x) => !existingMiddlewareIds.includes(x.id));
-    return [...globalMiddlewares2, ...existingMiddlewares];
+  static {
+    __name(this, "MiddlewareManager");
   }
   /**
-   * @param task
-   * @returns
+   * @internal
+   */
+  get taskMiddlewareInterceptors() {
+    return this.interceptorRegistry.getGlobalTaskInterceptors();
+  }
+  /**
+   * @internal
+   */
+  get resourceMiddlewareInterceptors() {
+    return this.interceptorRegistry.getGlobalResourceInterceptors();
+  }
+  /**
+   * Gets the current lock status of the MiddlewareManager
+   */
+  get isLocked() {
+    return this.interceptorRegistry.isLocked;
+  }
+  /**
+   * Locks the MiddlewareManager, preventing any further modifications to interceptors
+   */
+  lock() {
+    this.interceptorRegistry.lock();
+  }
+  /**
+   * Adds an interceptor for task or resource middleware execution
+   * Interceptors are executed in the order they are added, with the ability to
+   * modify, log, or prevent middleware execution
+   *
+   * @param kind - The type of middleware to intercept ("task" or "resource")
+   * @param interceptor - The interceptor function to add
+   */
+  intercept(kind, interceptor) {
+    if (kind === "task") {
+      this.interceptorRegistry.addGlobalTaskInterceptor(
+        interceptor
+      );
+    } else {
+      this.interceptorRegistry.addGlobalResourceInterceptor(
+        interceptor
+      );
+    }
+  }
+  /**
+   * Adds an interceptor for a specific middleware instance with better type safety
+   * This method automatically determines the type and provides type-safe access
+   *
+   * @param middleware - The middleware instance to intercept
+   * @param interceptor - The interceptor function with proper typing
+   */
+  interceptMiddleware(middleware, interceptor) {
+    if (isTaskMiddleware(middleware)) {
+      this.interceptorRegistry.addTaskMiddlewareInterceptor(
+        middleware.id,
+        interceptor
+      );
+    } else if (isResourceMiddleware(middleware)) {
+      this.interceptorRegistry.addResourceMiddlewareInterceptor(
+        middleware.id,
+        interceptor
+      );
+    } else {
+      throw new Error("Unknown middleware type");
+    }
+  }
+  /**
+   * 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(task2) {
+    return this.taskComposer.compose(task2);
+  }
+  /**
+   * Run a resource init wrapped with its applicable middlewares.
+   */
+  async runResourceInit(resource2, config, dependencies, context) {
+    return this.resourceComposer.runInit(
+      resource2,
+      config,
+      dependencies,
+      context
+    );
+  }
+  /**
+   * Gets all "everywhere" middlewares that apply to the given task
+   * @deprecated Internal method exposed for testing - may be removed in future versions
    */
   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(task2);
-      }
-      return true;
-    }).map((x) => x.middleware);
+    return this.middlewareResolver.getEverywhereTaskMiddlewares(task2);
   }
   /**
-   * Returns all global middleware for resource, which do not depend on the target resource.
+   * Gets all "everywhere" middlewares that apply to the given resource
+   * @deprecated Internal method exposed for testing - may be removed in future versions
    */
-  getEverywhereMiddlewareForResources(target) {
-    return Array.from(this.store.resourceMiddlewares.values()).filter((x) => Boolean(x.middleware.everywhere)).filter((x) => {
-      if (typeof x.middleware.everywhere === "function") {
-        return x.middleware.everywhere(target);
-      }
-      return true;
-    }).map((x) => x.middleware);
+  getEverywhereMiddlewareForResources(resource2) {
+    return this.middlewareResolver.getEverywhereResourceMiddlewares(resource2);
   }
 };
 
@@ -4203,7 +4445,7 @@ var tunnelResourceMiddleware = defineResourceMiddleware({
       t.run = (async (input) => {
         return value.run(t, input);
       });
-      t[symbolTunneledTask] = "client";
+      t.isTunneled = true;
       t[symbolTunneledBy] = resourceId;
     }
     if (events.length > 0) {