@bluelibs/runner-dev 5.1.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 = [];
@@ -17,7 +16,18 @@ class Introspector {
     errors = [];
     asyncContexts = [];
     store = null;
+    runtime = null;
     rootId = null;
+    runOptions = null;
+    interceptorOwners = {
+        tasksById: {},
+        middleware: {
+            globalTaskInterceptorOwnerIds: [],
+            globalResourceInterceptorOwnerIds: [],
+            perTaskMiddlewareInterceptorOwnerIds: {},
+            perResourceMiddlewareInterceptorOwnerIds: {},
+        },
+    };
     taskMap = new Map();
     hookMap = new Map();
     resourceMap = new Map();
@@ -28,27 +38,150 @@ class Introspector {
     asyncContextMap = new Map();
     constructor(input) {
         if ("store" in input) {
-            // this.store = input.store;
-            // this.initializeFromStore();
+            this.store = input.store;
+            this.runtime = input.runtime ?? null;
+            this.runOptions = input.runOptions ?? null;
         }
         else {
             this.store = null;
+            this.runtime = null;
             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)
+            : null;
+        this.interceptorOwners = data.interceptorOwners ?? this.interceptorOwners;
         // Maps
         this.taskMap = (0, introspector_tools_1.buildIdMap)(this.tasks);
         this.hookMap = (0, introspector_tools_1.buildIdMap)(this.hooks);
@@ -57,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 = {};
@@ -94,13 +246,146 @@ 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");
     }
+    /**
+     * Returns the effective run options that were used when the application was started.
+     * When a live store is available, options are derived from it; otherwise
+     * 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,
+            debugMode: runOptions.debugMode ?? (debug ? "normal" : "disabled"),
+            logsEnabled: typeof runOptions.logsEnabled === "boolean"
+                ? runOptions.logsEnabled
+                : logsPrintThreshold !== null,
+            logsPrintThreshold,
+            logsPrintStrategy: runOptions.logsPrintStrategy !== undefined
+                ? runOptions.logsPrintStrategy
+                : "pretty",
+            logsBuffer: Boolean(runOptions.logsBuffer),
+            errorBoundary: runOptions.errorBoundary !== undefined
+                ? runOptions.errorBoundary
+                : null,
+            shutdownHooks: runOptions.shutdownHooks !== undefined
+                ? runOptions.shutdownHooks
+                : null,
+            dryRun: Boolean(runOptions.dryRun),
+            lazy: Boolean(runOptions.lazy),
+            lifecycleMode: runOptions.lifecycleMode === "parallel" ? "parallel" : "sequential",
+            dispose,
+            executionContext,
+            hasOnUnhandledError: Boolean(runOptions.hasOnUnhandledError),
+            rootId,
+        };
+    }
+    getRunOptions() {
+        if (this.store) {
+            const rootId = this.store.root?.resource?.id != null
+                ? String(this.store.root.resource.id)
+                : this.rootId ?? "";
+            const hasDebug = this.store.resources.has("runner.debug");
+            const debugResource = this.store.resources.get("runner.debug");
+            const debugConfig = debugResource?.config;
+            const debugMode = !hasDebug
+                ? "disabled"
+                : debugConfig === true
+                    ? "normal"
+                    : typeof debugConfig === "string"
+                        ? debugConfig
+                        : debugConfig && typeof debugConfig === "object"
+                            ? "custom"
+                            : "normal";
+            const loggerResource = this.store.resources.get("runner.logger");
+            const logger = loggerResource?.value;
+            const logsPrintThresholdRaw = logger?.printThreshold;
+            const logsPrintStrategyRaw = logger?.printStrategy;
+            const logsBufferRaw = logger?.bufferLogs;
+            const logsPrintThreshold = logsPrintThresholdRaw == null ? null : String(logsPrintThresholdRaw);
+            const logsPrintStrategy = logsPrintStrategyRaw == null ? null : String(logsPrintStrategyRaw);
+            const logsBuffer = Boolean(logsBufferRaw);
+            const runtimeRunOptions = this.runtime?.runOptions;
+            return this.normalizeRunOptions({
+                mode: this.store.mode ?? "dev",
+                debug: hasDebug,
+                debugMode,
+                logsEnabled: logsPrintThreshold !== null,
+                logsPrintThreshold,
+                logsPrintStrategy,
+                logsBuffer,
+                errorBoundary: typeof runtimeRunOptions?.errorBoundary === "boolean"
+                    ? runtimeRunOptions.errorBoundary
+                    : null,
+                shutdownHooks: typeof runtimeRunOptions?.shutdownHooks === "boolean"
+                    ? runtimeRunOptions.shutdownHooks
+                    : null,
+                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,
+            });
+        }
+        if (this.runOptions)
+            return this.normalizeRunOptions(this.runOptions);
+        return this.normalizeRunOptions({
+            mode: "dev",
+            debug: false,
+            rootId: this.rootId ?? "",
+        });
+    }
     getAll() {
         return [
             ...this.tasks,
@@ -115,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) => {
@@ -180,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,
@@ -213,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)
@@ -247,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);
@@ -264,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) => ({
@@ -277,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) => ({
@@ -292,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 });
                 }
             }
@@ -305,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 });
             }
         }
@@ -324,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
@@ -379,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 [
@@ -421,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 [
@@ -465,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
     /**
@@ -539,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);
@@ -554,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))
@@ -564,6 +853,45 @@ class Introspector {
         return durableDepId ? this.getResource(durableDepId) : null;
     }
     // Serialization API
+    getInterceptorOwnersSnapshot() {
+        return this.interceptorOwners;
+    }
+    getTaskInterceptorOwnerIds(taskId) {
+        const taskInterceptors = this.getTaskInterceptorsFromLiveStore(taskId);
+        if (taskInterceptors != null) {
+            return Array.from(new Set(taskInterceptors
+                .map((record) => record.ownerResourceId)
+                .filter((value) => Boolean(value))));
+        }
+        return this.interceptorOwners.tasksById[taskId] ?? [];
+    }
+    getTaskInterceptorCount(taskId) {
+        const taskInterceptors = this.getTaskInterceptorsFromLiveStore(taskId);
+        if (taskInterceptors != null) {
+            return taskInterceptors.length;
+        }
+        const task = this.taskMap.get(taskId);
+        if (typeof task?.interceptorCount === "number") {
+            return task.interceptorCount;
+        }
+        return (this.interceptorOwners.tasksById[taskId] ?? []).length;
+    }
+    hasTaskInterceptors(taskId) {
+        return this.getTaskInterceptorCount(taskId) > 0;
+    }
+    getMiddlewareInterceptorOwnerIds(middlewareId) {
+        const taskOwners = this.interceptorOwners.middleware.perTaskMiddlewareInterceptorOwnerIds[middlewareId] ?? [];
+        const resourceOwners = this.interceptorOwners.middleware
+            .perResourceMiddlewareInterceptorOwnerIds[middlewareId] ?? [];
+        return Array.from(new Set([...taskOwners, ...resourceOwners]));
+    }
+    getTaskInterceptorsFromLiveStore(taskId) {
+        const taskStoreEntry = this.store?.tasks.get(taskId);
+        if (!taskStoreEntry || !Array.isArray(taskStoreEntry.interceptors)) {
+            return null;
+        }
+        return taskStoreEntry.interceptors;
+    }
     serialize() {
         return {
             tasks: this.tasks,
@@ -584,6 +912,8 @@ class Introspector {
             rootId: this.store?.root?.resource?.id != null
                 ? String(this.store.root.resource.id)
                 : this.rootId,
+            runOptions: this.getRunOptions(),
+            interceptorOwners: this.getInterceptorOwnersSnapshot(),
         };
     }
     static deserialize(data) {