@bluelibs/runner-dev 5.3.0 → 6.0.0

package/dist/resources/models/Introspector.js

@@ -3,8 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Introspector = void 0;
 const introspector_tools_1 = require("./introspector.tools");
 const durable_tools_1 = require("./durable.tools");
-const extractTunnelInfo_1 = require("./extractTunnelInfo");
-const tunnel_tools_1 = require("./tunnel.tools");
+const lane_resources_1 = require("../../utils/lane-resources");
 class Introspector {
     tasks = [];
     hooks = [];
@@ -49,18 +48,135 @@ class Introspector {
             this.initializeFromData(input.data);
         }
     }
+    idsMatch(candidateId, referenceId) {
+        return (candidateId === referenceId || candidateId.endsWith(`.${referenceId}`));
+    }
+    resolveCanonicalId(referenceId, candidateIds) {
+        const direct = candidateIds.find((candidateId) => candidateId === referenceId);
+        if (direct)
+            return direct;
+        const suffixMatch = candidateIds.find((candidateId) => this.idsMatch(candidateId, referenceId));
+        return suffixMatch ?? referenceId;
+    }
+    canonicalizeReferenceArray(ids, candidateIds) {
+        return (0, introspector_tools_1.ensureStringArray)(ids).map((referenceId) => this.resolveCanonicalId(referenceId, candidateIds));
+    }
+    findByIdLike(collection, id) {
+        return collection.find((entry) => this.idsMatch(entry.id, id)) ?? null;
+    }
+    idsContainLike(ids, candidateId) {
+        return (0, introspector_tools_1.ensureStringArray)(ids).some((id) => this.idsMatch(candidateId, id));
+    }
+    normalizeMetaTags(node, tagIds) {
+        const meta = node.meta;
+        if (!meta)
+            return;
+        const normalizedDetailed = Array.isArray(meta.tagsDetailed)
+            ? meta.tagsDetailed.map((entry) => ({
+                ...entry,
+                id: this.resolveCanonicalId(entry.id, tagIds),
+            }))
+            : meta.tagsDetailed;
+        node.meta = {
+            ...meta,
+            tags: this.canonicalizeReferenceArray(meta.tags, tagIds),
+            tagsDetailed: normalizedDetailed,
+        };
+    }
+    normalizeRelationIds() {
+        const taskIds = this.tasks.map((entry) => entry.id);
+        const hookIds = this.hooks.map((entry) => entry.id);
+        const resourceIds = this.resources.map((entry) => entry.id);
+        const eventIds = this.events.map((entry) => entry.id);
+        const middlewareIds = this.middlewares.map((entry) => entry.id);
+        const tagIds = this.tags.map((entry) => entry.id);
+        const errorIds = this.errors.map((entry) => entry.id);
+        const asyncContextIds = this.asyncContexts.map((entry) => entry.id);
+        const allDependencyIds = [
+            ...taskIds,
+            ...hookIds,
+            ...resourceIds,
+            ...eventIds,
+            ...middlewareIds,
+            ...tagIds,
+            ...errorIds,
+            ...asyncContextIds,
+        ];
+        const taskLikeIds = [...taskIds, ...hookIds];
+        const taskHookResourceMiddlewareIds = [
+            ...taskIds,
+            ...hookIds,
+            ...resourceIds,
+            ...middlewareIds,
+        ];
+        for (const task of this.tasks) {
+            task.dependsOn = this.canonicalizeReferenceArray(task.dependsOn, allDependencyIds);
+            task.tags = this.canonicalizeReferenceArray(task.tags, tagIds);
+            task.emits = this.canonicalizeReferenceArray(task.emits, eventIds);
+            task.middleware = this.canonicalizeReferenceArray(task.middleware, middlewareIds);
+            this.normalizeMetaTags(task, tagIds);
+        }
+        for (const hook of this.hooks) {
+            hook.dependsOn = this.canonicalizeReferenceArray(hook.dependsOn, allDependencyIds);
+            hook.tags = this.canonicalizeReferenceArray(hook.tags, tagIds);
+            hook.emits = this.canonicalizeReferenceArray(hook.emits, eventIds);
+            hook.events = this.canonicalizeReferenceArray(hook.events, eventIds);
+            const hookWithMiddleware = hook;
+            hookWithMiddleware.middleware = this.canonicalizeReferenceArray(hookWithMiddleware.middleware, middlewareIds);
+            this.normalizeMetaTags(hook, tagIds);
+        }
+        for (const resource of this.resources) {
+            resource.dependsOn = this.canonicalizeReferenceArray(resource.dependsOn, allDependencyIds);
+            resource.tags = this.canonicalizeReferenceArray(resource.tags, tagIds);
+            resource.emits = this.canonicalizeReferenceArray(resource.emits, eventIds);
+            resource.middleware = this.canonicalizeReferenceArray(resource.middleware, middlewareIds);
+            resource.overrides = this.canonicalizeReferenceArray(resource.overrides, taskHookResourceMiddlewareIds);
+            resource.registers = this.canonicalizeReferenceArray(resource.registers, taskHookResourceMiddlewareIds);
+            this.normalizeMetaTags(resource, tagIds);
+        }
+        for (const middleware of this.middlewares) {
+            middleware.tags = this.canonicalizeReferenceArray(middleware.tags, tagIds);
+            const middlewareWithEmits = middleware;
+            middlewareWithEmits.emits = this.canonicalizeReferenceArray(middlewareWithEmits.emits, eventIds);
+            middleware.usedByTasks = this.canonicalizeReferenceArray(middleware.usedByTasks, taskLikeIds);
+            middleware.usedByResources = this.canonicalizeReferenceArray(middleware.usedByResources, resourceIds);
+            this.normalizeMetaTags(middleware, tagIds);
+        }
+        for (const event of this.events) {
+            event.tags = this.canonicalizeReferenceArray(event.tags, tagIds);
+            event.listenedToBy = this.canonicalizeReferenceArray(event.listenedToBy, hookIds);
+            this.normalizeMetaTags(event, tagIds);
+        }
+        for (const error of this.errors) {
+            error.tags = this.canonicalizeReferenceArray(error.tags, tagIds);
+            error.thrownBy = this.canonicalizeReferenceArray(error.thrownBy, taskHookResourceMiddlewareIds);
+            this.normalizeMetaTags(error, tagIds);
+        }
+        for (const asyncContext of this.asyncContexts) {
+            asyncContext.usedBy = this.canonicalizeReferenceArray(asyncContext.usedBy, taskHookResourceMiddlewareIds);
+            asyncContext.requiredBy = this.canonicalizeReferenceArray(asyncContext.requiredBy, taskIds);
+            asyncContext.providedBy = this.canonicalizeReferenceArray(asyncContext.providedBy, resourceIds);
+            this.normalizeMetaTags(asyncContext, tagIds);
+        }
+    }
+    finalizeDerivedState() {
+        this.normalizeRelationIds();
+        this.populateErrorThrownBy();
+    }
     initializeFromData(data) {
         this.tasks = Array.isArray(data.tasks) ? data.tasks : [];
         this.hooks = Array.isArray(data.hooks) ? data.hooks : [];
         this.resources = Array.isArray(data.resources) ? data.resources : [];
         this.events = Array.isArray(data.events) ? data.events : [];
-        this.taskMiddlewares = [];
-        this.resourceMiddlewares = [];
         this.middlewares = Array.isArray(data.middlewares) ? data.middlewares : [];
+        const splitMiddlewares = this.splitMiddlewaresByType(this.middlewares);
+        this.taskMiddlewares = splitMiddlewares.taskMiddlewares;
+        this.resourceMiddlewares = splitMiddlewares.resourceMiddlewares;
         this.errors = Array.isArray(data.errors) ? data.errors : [];
         this.asyncContexts = Array.isArray(data.asyncContexts)
             ? data.asyncContexts
             : [];
+        this.tags = Array.isArray(data.tags) ? data.tags : [];
         this.rootId = data.rootId ?? null;
         this.runOptions = data.runOptions
             ? this.normalizeRunOptions(data.runOptions)
@@ -74,20 +190,39 @@ class Introspector {
         this.middlewareMap = (0, introspector_tools_1.buildIdMap)(this.middlewares);
         this.errorMap = (0, introspector_tools_1.buildIdMap)(this.errors);
         this.asyncContextMap = (0, introspector_tools_1.buildIdMap)(this.asyncContexts);
-        // Populate thrownBy for errors based on dependencies (after maps are built)
-        this.populateErrorThrownBy();
-        // Tags
-        const _getTasksWithTag = (tagId) => this.tasks.filter((t) => (0, introspector_tools_1.ensureStringArray)(t.tags).includes(tagId));
-        const _getHooksWithTag = (tagId) => this.hooks.filter((h) => (0, introspector_tools_1.ensureStringArray)(h.tags).includes(tagId));
-        const _getResourcesWithTag = (tagId) => this.resources.filter((r) => (0, introspector_tools_1.ensureStringArray)(r.tags).includes(tagId));
-        const _getMiddlewaresWithTag = (tagId) => this.middlewares.filter((m) => (0, introspector_tools_1.ensureStringArray)(m.tags).includes(tagId));
-        const _getEventsWithTag = (tagId) => this.events.filter((e) => (0, introspector_tools_1.ensureStringArray)(e.tags).includes(tagId));
-        this.tags = data.tags;
+        this.finalizeDerivedState();
         this.tagMap = new Map();
         for (const tag of this.tags) {
             this.tagMap.set(tag.id, tag);
         }
     }
+    splitMiddlewaresByType(middlewares) {
+        const taskMiddlewares = [];
+        const resourceMiddlewares = [];
+        for (const middleware of middlewares) {
+            if (middleware.type === "task") {
+                taskMiddlewares.push(middleware);
+                continue;
+            }
+            if (middleware.type === "resource") {
+                resourceMiddlewares.push(middleware);
+                continue;
+            }
+            const usedByTasksLength = Array.isArray(middleware.usedByTasks)
+                ? middleware.usedByTasks.length
+                : 0;
+            const usedByResourcesLength = Array.isArray(middleware.usedByResources)
+                ? middleware.usedByResources.length
+                : 0;
+            if (usedByTasksLength > 0 || usedByResourcesLength === 0) {
+                taskMiddlewares.push(middleware);
+            }
+            else {
+                resourceMiddlewares.push(middleware);
+            }
+        }
+        return { taskMiddlewares, resourceMiddlewares };
+    }
     // Helper function for building runs options
     buildRunsOptions(nodeId, args) {
         const opts = {};
@@ -111,9 +246,8 @@ class Introspector {
     }
     // API Methods
     getRoot() {
-        const s = this.store;
-        const idFromStore = s?.root?.resource?.id
-            ? String(s.root.resource.id)
+        const idFromStore = this.store?.root?.resource?.id
+            ? String(this.store.root.resource.id)
             : null;
         const id = idFromStore ?? this.rootId ?? this.resources[0]?.id;
         return (0, introspector_tools_1.stampElementKind)(this.resourceMap.get(String(id)), "RESOURCE");
@@ -124,12 +258,30 @@ class Introspector {
      * the previously serialized snapshot is used.
      */
     normalizeRunOptions(runOptions) {
+        const legacyRunOptions = runOptions;
         const mode = runOptions.mode ?? "dev";
         const debug = Boolean(runOptions.debug);
         const rootId = runOptions.rootId ?? this.rootId ?? "";
         const logsPrintThreshold = runOptions.logsPrintThreshold !== undefined
             ? runOptions.logsPrintThreshold
             : "info";
+        const dispose = runOptions.dispose ??
+            {
+                totalBudgetMs: typeof legacyRunOptions.disposeBudgetMs === "number"
+                    ? legacyRunOptions.disposeBudgetMs
+                    : null,
+                drainingBudgetMs: typeof legacyRunOptions.disposeDrainBudgetMs === "number"
+                    ? legacyRunOptions.disposeDrainBudgetMs
+                    : null,
+                cooldownWindowMs: null,
+            };
+        const executionContext = runOptions.executionContext ??
+            {
+                enabled: false,
+                cycleDetection: typeof legacyRunOptions.runtimeEventCycleDetection === "boolean"
+                    ? legacyRunOptions.runtimeEventCycleDetection
+                    : null,
+            };
         return {
             mode,
             debug,
@@ -150,22 +302,20 @@ class Introspector {
                 : null,
             dryRun: Boolean(runOptions.dryRun),
             lazy: Boolean(runOptions.lazy),
-            initMode: runOptions.initMode === "parallel" ? "parallel" : "sequential",
-            runtimeEventCycleDetection: runOptions.runtimeEventCycleDetection !== undefined
-                ? runOptions.runtimeEventCycleDetection
-                : null,
+            lifecycleMode: runOptions.lifecycleMode === "parallel" ? "parallel" : "sequential",
+            dispose,
+            executionContext,
             hasOnUnhandledError: Boolean(runOptions.hasOnUnhandledError),
             rootId,
         };
     }
     getRunOptions() {
         if (this.store) {
-            const sAny = this.store;
-            const rootId = sAny.root?.resource?.id != null
-                ? String(sAny.root.resource.id)
+            const rootId = this.store.root?.resource?.id != null
+                ? String(this.store.root.resource.id)
                 : this.rootId ?? "";
-            const hasDebug = !!sAny.resources?.has?.("globals.resources.debug");
-            const debugResource = sAny.resources?.get?.("globals.resources.debug");
+            const hasDebug = this.store.resources.has("runner.debug");
+            const debugResource = this.store.resources.get("runner.debug");
             const debugConfig = debugResource?.config;
             const debugMode = !hasDebug
                 ? "disabled"
@@ -176,7 +326,7 @@ class Introspector {
                         : debugConfig && typeof debugConfig === "object"
                             ? "custom"
                             : "normal";
-            const loggerResource = sAny.resources?.get?.("globals.resources.logger");
+            const loggerResource = this.store.resources.get("runner.logger");
             const logger = loggerResource?.value;
             const logsPrintThresholdRaw = logger?.printThreshold;
             const logsPrintStrategyRaw = logger?.printStrategy;
@@ -184,31 +334,50 @@ class Introspector {
             const logsPrintThreshold = logsPrintThresholdRaw == null ? null : String(logsPrintThresholdRaw);
             const logsPrintStrategy = logsPrintStrategyRaw == null ? null : String(logsPrintStrategyRaw);
             const logsBuffer = Boolean(logsBufferRaw);
-            const initMode = sAny.preferInitOrderDisposal ? "sequential" : "parallel";
-            const runtimeAny = this.runtime;
-            const lazy = Boolean(runtimeAny?.lazyOptions?.lazyMode);
-            const runtimeEventCycleDetection = runtimeAny?.eventManager?.runtimeEventCycleDetection;
-            return {
-                mode: sAny.mode ?? "dev",
+            const runtimeRunOptions = this.runtime?.runOptions;
+            return this.normalizeRunOptions({
+                mode: this.store.mode ?? "dev",
                 debug: hasDebug,
                 debugMode,
                 logsEnabled: logsPrintThreshold !== null,
                 logsPrintThreshold,
                 logsPrintStrategy,
                 logsBuffer,
-                errorBoundary: null,
-                shutdownHooks: null,
-                dryRun: Boolean(this.runOptions?.dryRun),
-                lazy,
-                initMode,
-                runtimeEventCycleDetection: typeof runtimeEventCycleDetection === "boolean"
-                    ? runtimeEventCycleDetection
+                errorBoundary: typeof runtimeRunOptions?.errorBoundary === "boolean"
+                    ? runtimeRunOptions.errorBoundary
+                    : null,
+                shutdownHooks: typeof runtimeRunOptions?.shutdownHooks === "boolean"
+                    ? runtimeRunOptions.shutdownHooks
                     : null,
-                hasOnUnhandledError: typeof sAny.onUnhandledError === "function",
+                dryRun: Boolean(runtimeRunOptions?.dryRun),
+                lazy: Boolean(runtimeRunOptions?.lazy),
+                lifecycleMode: runtimeRunOptions?.lifecycleMode === "parallel"
+                    ? "parallel"
+                    : "sequential",
+                dispose: {
+                    totalBudgetMs: typeof runtimeRunOptions?.dispose?.totalBudgetMs === "number"
+                        ? runtimeRunOptions.dispose.totalBudgetMs
+                        : null,
+                    drainingBudgetMs: typeof runtimeRunOptions?.dispose?.drainingBudgetMs === "number"
+                        ? runtimeRunOptions.dispose.drainingBudgetMs
+                        : null,
+                    cooldownWindowMs: typeof runtimeRunOptions?.dispose?.cooldownWindowMs === "number"
+                        ? runtimeRunOptions.dispose.cooldownWindowMs
+                        : null,
+                },
+                executionContext: {
+                    enabled: runtimeRunOptions?.executionContext != null,
+                    cycleDetection: runtimeRunOptions?.executionContext == null
+                        ? null
+                        : typeof runtimeRunOptions.executionContext.cycleDetection ===
+                            "boolean"
+                            ? runtimeRunOptions.executionContext.cycleDetection
+                            : runtimeRunOptions.executionContext.cycleDetection != null,
+                },
+                hasOnUnhandledError: typeof this.store.onUnhandledError === "function",
                 rootId,
-            };
+            });
         }
-        // Fallback to serialized data
         if (this.runOptions)
             return this.normalizeRunOptions(this.runOptions);
         return this.normalizeRunOptions({
@@ -231,9 +400,9 @@ class Introspector {
     populateErrorThrownBy() {
         // Create error ID map for quick lookup
         const errorIds = new Set(this.errors.map((e) => e.id));
-        // Clear existing thrownBy arrays
+        // Preserve preloaded producer data and only append derived dependencies.
         this.errors.forEach((error) => {
-            error.thrownBy = [];
+            error.thrownBy = (0, introspector_tools_1.ensureStringArray)(error.thrownBy);
         });
         // Check tasks
         this.tasks.forEach((task) => {
@@ -296,29 +465,28 @@ class Introspector {
         return this.resources;
     }
     getEvent(id) {
-        return this.eventMap.get(id) ?? null;
+        return this.eventMap.get(id) ?? this.findByIdLike(this.events, id);
     }
     getTask(id) {
-        return this.taskMap.get(id) ?? null;
+        return this.taskMap.get(id) ?? this.findByIdLike(this.tasks, id);
     }
     getHook(id) {
-        return this.hookMap.get(id) ?? null;
+        return this.hookMap.get(id) ?? this.findByIdLike(this.hooks, id);
     }
     getMiddleware(id) {
-        return this.middlewareMap.get(id) ?? null;
+        return (this.middlewareMap.get(id) ?? this.findByIdLike(this.middlewares, id));
     }
     getResource(id) {
-        return this.resourceMap.get(id) ?? null;
+        return this.resourceMap.get(id) ?? this.findByIdLike(this.resources, id);
     }
     getDependencies(node) {
         const depends = (0, introspector_tools_1.ensureStringArray)(node.dependsOn);
-        const tasksDeps = this.tasks.filter((t) => depends.includes(t.id));
-        const hooksDeps = this.hooks.filter((l) => depends.includes(l.id));
-        const resourcesDeps = this.resources.filter((r) => depends.includes(r.id));
-        const errorDeps = this.errors.filter((e) => depends.includes(e.id));
-        // Only Task and Hook have emits, Resource doesn't
+        const tasksDeps = this.tasks.filter((t) => this.idsContainLike(depends, t.id));
+        const hooksDeps = this.hooks.filter((l) => this.idsContainLike(depends, l.id));
+        const resourcesDeps = this.resources.filter((r) => this.idsContainLike(depends, r.id));
+        const errorDeps = this.errors.filter((e) => this.idsContainLike(depends, e.id));
         const emitIds = (0, introspector_tools_1.ensureStringArray)(node.emits);
-        const emitEvents = this.events.filter((e) => emitIds.includes(e.id));
+        const emitEvents = this.events.filter((e) => this.idsContainLike(emitIds, e.id));
         return {
             tasks: tasksDeps,
             hooks: hooksDeps,
@@ -329,33 +497,28 @@ class Introspector {
     }
     getEmittedEvents(node) {
         const emits = (0, introspector_tools_1.ensureStringArray)(node.emits);
-        return this.events.filter((e) => emits.includes(e.id));
+        return this.events.filter((e) => this.idsContainLike(emits, e.id));
     }
     getMiddlewaresByIds(ids) {
-        const set = new Set((0, introspector_tools_1.ensureStringArray)(ids));
-        return this.middlewares.filter((m) => set.has(m.id));
+        return this.middlewares.filter((m) => this.idsContainLike(ids, m.id));
     }
     getResourcesByIds(ids) {
-        const set = new Set((0, introspector_tools_1.ensureStringArray)(ids));
-        return this.resources.filter((r) => set.has(r.id));
+        return this.resources.filter((r) => this.idsContainLike(ids, r.id));
     }
     getTasksByIds(ids) {
-        const set = new Set((0, introspector_tools_1.ensureStringArray)(ids));
-        return this.tasks.filter((t) => set.has(t.id));
+        return this.tasks.filter((t) => this.idsContainLike(ids, t.id));
     }
     getHooksByIds(ids) {
-        const set = new Set((0, introspector_tools_1.ensureStringArray)(ids));
-        return this.hooks.filter((l) => set.has(l.id));
+        return this.hooks.filter((l) => this.idsContainLike(ids, l.id));
     }
     getEventsByIds(ids) {
-        const set = new Set((0, introspector_tools_1.ensureStringArray)(ids));
-        return this.events.filter((e) => set.has(e.id));
+        return this.events.filter((e) => this.idsContainLike(ids, e.id));
     }
     getTasksUsingResource(resourceId) {
-        return [...this.tasks, ...this.hooks].filter((t) => (0, introspector_tools_1.ensureStringArray)(t.dependsOn).includes(resourceId));
+        return [...this.tasks, ...this.hooks].filter((t) => this.idsContainLike(t.dependsOn, resourceId));
     }
     getTasksUsingMiddleware(middlewareId) {
-        return this.tasks.filter((t) => (0, introspector_tools_1.ensureStringArray)(t.middleware).includes(middlewareId));
+        return this.tasks.filter((t) => this.idsContainLike(t.middleware, middlewareId));
     }
     // Backward-compat for schema fields expecting this name
     // Returns only task-like nodes (tasks and hooks)
@@ -363,10 +526,10 @@ class Introspector {
         return this.getTasksUsingMiddleware(middlewareId);
     }
     getEmittersOfEvent(eventId) {
-        return [...this.tasks, ...this.hooks, ...this.resources].filter((t) => (0, introspector_tools_1.ensureStringArray)(t.emits).includes(eventId));
+        return [...this.tasks, ...this.hooks, ...this.resources].filter((t) => this.idsContainLike(t.emits, eventId));
     }
     getHooksOfEvent(eventId) {
-        return this.hooks.filter((l) => l.events.includes(eventId));
+        return this.hooks.filter((l) => this.idsContainLike(l.events, eventId));
     }
     getMiddlewareEmittedEvents(middlewareId) {
         const taskLikes = this.getTasksUsingMiddleware(middlewareId);
@@ -380,8 +543,12 @@ class Introspector {
     }
     getMiddlewareUsagesForTask(taskId) {
         const task = this.taskMap.get(taskId);
-        if (!task)
-            return [];
+        if (!task) {
+            const resolvedTask = this.getTask(taskId);
+            if (!resolvedTask)
+                return [];
+            return this.getMiddlewareUsagesForTask(resolvedTask.id);
+        }
         const detailed = task.middlewareDetailed ?? [];
         return detailed
             .map((d) => ({
@@ -393,8 +560,12 @@ class Introspector {
     }
     getMiddlewareUsagesForResource(resourceId) {
         const res = this.resourceMap.get(resourceId);
-        if (!res)
-            return [];
+        if (!res) {
+            const resolvedResource = this.getResource(resourceId);
+            if (!resolvedResource)
+                return [];
+            return this.getMiddlewareUsagesForResource(resolvedResource.id);
+        }
         const detailed = res.middlewareDetailed ?? [];
         return detailed
             .map((d) => ({
@@ -408,9 +579,8 @@ class Introspector {
         const result = [];
         const addFrom = (arr) => {
             for (const tl of arr) {
-                if ((tl.middleware || []).includes(middlewareId)) {
-                    const conf = (tl.middlewareDetailed || []).find((m) => m.id === middlewareId)
-                        ?.config ?? null;
+                if (this.idsContainLike(tl.middleware, middlewareId)) {
+                    const conf = (tl.middlewareDetailed || []).find((m) => this.idsMatch(this.resolveCanonicalId(m.id, this.middlewares.map((entry) => entry.id)), middlewareId))?.config ?? null;
                     result.push({ id: tl.id, config: conf ?? null, node: tl });
                 }
             }
@@ -421,9 +591,8 @@ class Introspector {
     getResourcesUsingMiddlewareDetailed(middlewareId) {
         const result = [];
         for (const r of this.resources) {
-            if ((r.middleware || []).includes(middlewareId)) {
-                const conf = (r.middlewareDetailed || []).find((m) => m.id === middlewareId)
-                    ?.config ?? null;
+            if (this.idsContainLike(r.middleware, middlewareId)) {
+                const conf = (r.middlewareDetailed || []).find((m) => this.idsMatch(this.resolveCanonicalId(m.id, this.middlewares.map((entry) => entry.id)), middlewareId))?.config ?? null;
                 result.push({ id: r.id, config: conf ?? null, node: r });
             }
         }
@@ -440,25 +609,44 @@ class Introspector {
     }
     // Tags API
     getTasksWithTag(tagId) {
-        return this.tasks.filter((t) => (0, introspector_tools_1.ensureStringArray)(t.tags).includes(tagId));
+        return this.tasks.filter((t) => this.idsContainLike(t.tags, tagId));
     }
     getHooksWithTag(tagId) {
-        return this.hooks.filter((h) => (0, introspector_tools_1.ensureStringArray)(h.tags).includes(tagId));
+        return this.hooks.filter((h) => this.idsContainLike(h.tags, tagId));
     }
     getResourcesWithTag(tagId) {
-        return this.resources.filter((r) => (0, introspector_tools_1.ensureStringArray)(r.tags).includes(tagId));
+        return this.resources.filter((r) => this.idsContainLike(r.tags, tagId));
     }
     getMiddlewaresWithTag(tagId) {
-        return this.middlewares.filter((m) => (0, introspector_tools_1.ensureStringArray)(m.tags).includes(tagId));
+        return this.middlewares.filter((m) => this.idsContainLike(m.tags, tagId));
+    }
+    getTaskMiddlewaresWithTag(tagId) {
+        return this.taskMiddlewares.filter((m) => this.idsContainLike(m.tags, tagId));
+    }
+    getResourceMiddlewaresWithTag(tagId) {
+        return this.resourceMiddlewares.filter((m) => this.idsContainLike(m.tags, tagId));
     }
     getEventsWithTag(tagId) {
-        return this.events.filter((e) => (0, introspector_tools_1.ensureStringArray)(e.tags).includes(tagId));
+        return this.events.filter((e) => this.idsContainLike(e.tags, tagId));
+    }
+    getErrorsWithTag(tagId) {
+        return this.errors
+            .filter((e) => this.idsContainLike(e.tags, tagId))
+            .map((error) => (0, introspector_tools_1.stampElementKind)(error, "ERROR"));
+    }
+    getTagHandlers(tagId) {
+        const dependsOnTag = (item) => this.idsContainLike(item.dependsOn, tagId);
+        return {
+            tasks: this.tasks.filter(dependsOnTag),
+            hooks: this.hooks.filter(dependsOnTag),
+            resources: this.resources.filter(dependsOnTag),
+        };
     }
     getAllTags() {
         return this.tags;
     }
     getTag(id) {
-        return this.tagMap.get(id) ?? null;
+        return this.tagMap.get(id) ?? this.findByIdLike(this.tags, id);
     }
     getTagsByIds(ids) {
         return ids
@@ -495,34 +683,35 @@ class Introspector {
     }
     // Error-related methods
     getErrors() {
-        return this.errors;
+        return this.errors.map((error) => (0, introspector_tools_1.stampElementKind)(error, "ERROR"));
     }
     getError(id) {
-        return this.errorMap.get(id) ?? null;
+        const error = this.errorMap.get(id) ?? this.findByIdLike(this.errors, id);
+        return error ? (0, introspector_tools_1.stampElementKind)(error, "ERROR") : null;
     }
     getTasksUsingError(errorId) {
-        const error = this.errorMap.get(errorId);
+        const error = this.getError(errorId);
         if (!error?.thrownBy)
             return [];
-        return this.tasks.filter((task) => error.thrownBy.includes(task.id));
+        return this.tasks.filter((task) => this.idsContainLike(error.thrownBy, task.id));
     }
     getResourcesUsingError(errorId) {
-        const error = this.errorMap.get(errorId);
+        const error = this.getError(errorId);
         if (!error?.thrownBy)
             return [];
-        return this.resources.filter((resource) => error.thrownBy.includes(resource.id));
+        return this.resources.filter((resource) => this.idsContainLike(error.thrownBy, resource.id));
     }
     getHooksUsingError(errorId) {
-        const error = this.errorMap.get(errorId);
+        const error = this.getError(errorId);
         if (!error?.thrownBy)
             return [];
-        return this.hooks.filter((hook) => error.thrownBy.includes(hook.id));
+        return this.hooks.filter((hook) => this.idsContainLike(error.thrownBy, hook.id));
     }
     getMiddlewaresUsingError(errorId) {
-        const error = this.errorMap.get(errorId);
+        const error = this.getError(errorId);
         if (!error?.thrownBy)
             return [];
-        return this.middlewares.filter((middleware) => error.thrownBy.includes(middleware.id));
+        return this.middlewares.filter((middleware) => this.idsContainLike(error.thrownBy, middleware.id));
     }
     getAllUsingError(errorId) {
         return [
@@ -537,37 +726,37 @@ class Introspector {
         return this.asyncContexts;
     }
     getAsyncContext(id) {
-        return this.asyncContextMap.get(id) ?? null;
+        return (this.asyncContextMap.get(id) ?? this.findByIdLike(this.asyncContexts, id));
     }
     getTasksUsingContext(contextId) {
-        const context = this.asyncContextMap.get(contextId);
+        const context = this.getAsyncContext(contextId);
         if (!context?.usedBy)
             return [];
-        return this.tasks.filter((task) => context.usedBy.includes(task.id));
+        return this.tasks.filter((task) => this.idsContainLike(context.usedBy, task.id));
     }
     getResourcesUsingContext(contextId) {
-        const context = this.asyncContextMap.get(contextId);
+        const context = this.getAsyncContext(contextId);
         if (!context?.usedBy)
             return [];
-        return this.resources.filter((resource) => context.usedBy.includes(resource.id));
+        return this.resources.filter((resource) => this.idsContainLike(context.usedBy, resource.id));
     }
     getResourcesProvidingContext(contextId) {
-        const context = this.asyncContextMap.get(contextId);
+        const context = this.getAsyncContext(contextId);
         if (!context?.providedBy)
             return [];
-        return this.resources.filter((resource) => context.providedBy.includes(resource.id));
+        return this.resources.filter((resource) => this.idsContainLike(context.providedBy, resource.id));
     }
     getHooksUsingContext(contextId) {
-        const context = this.asyncContextMap.get(contextId);
+        const context = this.getAsyncContext(contextId);
         if (!context?.usedBy)
             return [];
-        return this.hooks.filter((hook) => context.usedBy.includes(hook.id));
+        return this.hooks.filter((hook) => this.idsContainLike(context.usedBy, hook.id));
     }
     getMiddlewaresUsingContext(contextId) {
-        const context = this.asyncContextMap.get(contextId);
+        const context = this.getAsyncContext(contextId);
         if (!context?.usedBy)
             return [];
-        return this.middlewares.filter((middleware) => context.usedBy.includes(middleware.id));
+        return this.middlewares.filter((middleware) => this.idsContainLike(context.usedBy, middleware.id));
     }
     getAllUsingContext(contextId) {
         return [
@@ -581,73 +770,57 @@ class Introspector {
      * Returns tasks that use `.require()` for a given async context.
      */
     getTasksRequiringContext(contextId) {
-        const context = this.asyncContextMap.get(contextId);
+        const context = this.getAsyncContext(contextId);
         if (!context?.requiredBy)
             return [];
-        return this.tasks.filter((task) => context.requiredBy.includes(task.id));
+        return this.tasks.filter((task) => this.idsContainLike(context.requiredBy, task.id));
     }
     /**
      * Checks whether a given element uses `.require()` for a specific async context.
      */
     isContextRequiredBy(contextId, elementId) {
-        const context = this.asyncContextMap.get(contextId);
-        return context?.requiredBy?.includes(elementId) ?? false;
+        const context = this.getAsyncContext(contextId);
+        return this.idsContainLike(context?.requiredBy, elementId);
     }
-    // Tunnel-related methods (enhance existing methods)
-    getTunnelResources() {
-        // Resources with populated tunnelInfo (set during store initialization)
-        return this.resources.filter((resource) => resource.tunnelInfo != null);
+    // RPC lane-related methods
+    getRpcLanesResources() {
+        return this.resources.filter((resource) => (0, lane_resources_1.isRpcLanesResource)(resource));
     }
-    getTunneledTasks(tunnelResourceId) {
-        const tunnel = this.getResource(tunnelResourceId);
-        if (!tunnel?.tunnelInfo?.tasks)
-            return [];
-        return this.getTasksByIds(tunnel.tunnelInfo.tasks);
+    getTasksByRpcLane(rpcLaneId) {
+        return this.tasks.filter((task) => task.rpcLane?.laneId === rpcLaneId);
     }
-    getTunneledEvents(tunnelResourceId) {
-        const tunnel = this.getResource(tunnelResourceId);
-        if (!tunnel?.tunnelInfo?.events)
-            return [];
-        return this.getEventsByIds(tunnel.tunnelInfo.events);
+    getEventsByRpcLane(rpcLaneId) {
+        return this.events.filter((event) => event.rpcLane?.laneId === rpcLaneId);
     }
-    getTunnelForTask(taskId) {
-        const task = this.getTask(taskId);
-        if (!task)
+    getRpcLaneForTask(taskId) {
+        return this.getTask(taskId)?.rpcLane?.laneId ?? null;
+    }
+    getRpcLaneForEvent(eventId) {
+        return this.getEvent(eventId)?.rpcLane?.laneId ?? null;
+    }
+    getRpcLaneResourceForTask(taskId) {
+        const laneId = this.getRpcLaneForTask(taskId);
+        if (!laneId)
             return null;
-        // Find tunnel resource that owns this task
-        return (this.getTunnelResources().find((tunnel) => tunnel.tunnelInfo?.tasks?.includes(taskId)) ?? null);
+        return this.findRpcLanesResourceByLaneId(laneId);
     }
-    getTunnelForEvent(eventId) {
-        // Find tunnel resource that tunnels this event
-        return (this.getTunnelResources().find((tunnel) => tunnel.tunnelInfo?.events?.includes(eventId)) ?? null);
+    getRpcLaneResourceForEvent(eventId) {
+        const laneId = this.getRpcLaneForEvent(eventId);
+        if (!laneId)
+            return null;
+        return this.findRpcLanesResourceByLaneId(laneId);
     }
-    /**
-     * Populates tunnelInfo for resources with the tunnel tag.
-     * Call this method after all resources have been initialized to ensure
-     * tunnel resource values are available.
-     */
-    populateTunnelInfo() {
-        const s = this.store;
-        if (!s?.resources)
-            return;
-        const allTaskIds = this.tasks.map((t) => t.id);
-        const allEventIds = this.events.map((e) => e.id);
-        for (const storeEntry of s.resources.values()) {
-            const resourceDef = storeEntry.resource;
-            const resourceValue = storeEntry.value;
-            const resourceId = String(resourceDef.id);
-            // Find the corresponding model resource
-            const modelResource = this.resources.find((r) => r.id === resourceId);
-            if (!modelResource)
-                continue;
-            // Check if resource has tunnel tag using the already-normalized tags
-            if ((0, tunnel_tools_1.hasTunnelTag)(modelResource.tags) && resourceValue) {
-                const tunnelInfo = (0, extractTunnelInfo_1.extractTunnelInfo)(resourceValue, allTaskIds, allEventIds);
-                if (tunnelInfo) {
-                    modelResource.tunnelInfo = tunnelInfo;
-                }
-            }
+    findRpcLanesResourceByLaneId(laneId) {
+        const rpcLanesResources = this.getRpcLanesResources();
+        if (rpcLanesResources.length === 0)
+            return null;
+        for (const resource of rpcLanesResources) {
+            const laneIds = (0, lane_resources_1.collectRpcLaneIdsFromResourceConfig)(resource.config);
+            if (laneIds.has(laneId))
+                return resource;
         }
+        // Fallback: if exactly one rpcLanes resource exists, prefer it.
+        return rpcLanesResources.length === 1 ? rpcLanesResources[0] : null;
     }
     // Durable workflow-related methods
     /**
@@ -655,7 +828,7 @@ class Introspector {
      * A task is durable if it has the durable workflow tag (current: `globals.tags.durableWorkflow`, legacy: `durable.workflow`).
      */
     isDurableTask(taskId) {
-        const task = this.taskMap.get(taskId);
+        const task = this.getTask(taskId);
         if (!task)
             return false;
         return (0, durable_tools_1.hasDurableWorkflowTag)(task.tags);
@@ -670,7 +843,7 @@ class Introspector {
      * Returns the durable resource a task depends on, if any.
      */
     getDurableResourceForTask(taskId) {
-        const task = this.taskMap.get(taskId);
+        const task = this.getTask(taskId);
         if (!task)
             return null;
         if (!this.isDurableTask(taskId))