@bluelibs/runner-dev 6.2.0 → 6.4.0

package/dist/resources/models/initializeFromStore.utils.js

@@ -25,7 +25,7 @@ exports.extractTaskIdsFromDependencies = extractTaskIdsFromDependencies;
 exports.extractErrorIdsFromDependencies = extractErrorIdsFromDependencies;
 const runner_1 = require("@bluelibs/runner");
 const lane_resources_1 = require("../../utils/lane-resources");
-const zod_1 = require("../../utils/zod");
+const schemaFormat_1 = require("../../utils/schemaFormat");
 const path_1 = require("../../utils/path");
 const introspector_tools_1 = require("./introspector.tools");
 function normalizeTags(tags) {
@@ -66,22 +66,169 @@ function findById(collection, id) {
             Object.values(collection).find((x) => (0, introspector_tools_1.readId)(x) === id));
     return undefined;
 }
+const taskMiddlewareScopeMarker = ".middleware.task.";
+const resourceMiddlewareScopeMarker = ".middleware.resource.";
+function getMiddlewareDuplicateKey(id) {
+    const taskScopeIndex = id.lastIndexOf(taskMiddlewareScopeMarker);
+    if (taskScopeIndex >= 0) {
+        return id.slice(taskScopeIndex + taskMiddlewareScopeMarker.length);
+    }
+    const resourceScopeIndex = id.lastIndexOf(resourceMiddlewareScopeMarker);
+    if (resourceScopeIndex >= 0) {
+        return id.slice(resourceScopeIndex + resourceMiddlewareScopeMarker.length);
+    }
+    return id;
+}
+function getTaskOwnerResourceChain(store, taskId) {
+    const chain = [];
+    const visited = new Set();
+    let currentOwnerId = store.getOwnerResourceId(taskId);
+    while (currentOwnerId && !visited.has(currentOwnerId)) {
+        visited.add(currentOwnerId);
+        chain.push(currentOwnerId);
+        currentOwnerId = store.getOwnerResourceId(currentOwnerId);
+    }
+    return chain;
+}
+function normalizeIdentityRequirementSummary(value) {
+    if (!value || typeof value !== "object")
+        return null;
+    const config = value;
+    return {
+        tenant: config.tenant ?? true,
+        user: config.user === true,
+        roles: Array.isArray(config.roles)
+            ? config.roles.map((role) => String(role))
+            : [],
+    };
+}
+function normalizeIdentityRequirementSummaries(value) {
+    const entries = Array.isArray(value)
+        ? value
+        : value && typeof value === "object"
+            ? [value]
+            : [];
+    return entries
+        .map((entry) => normalizeIdentityRequirementSummary(entry))
+        .filter((entry) => Boolean(entry));
+}
+function normalizeIdentityScopeSummary(value) {
+    if (!value || typeof value !== "object")
+        return null;
+    const config = value;
+    return {
+        tenant: config.tenant ?? true,
+        user: config.user === true,
+        required: config.required ?? true,
+    };
+}
+function getSubtreePolicies(resource) {
+    const rawSubtree = resource?.subtree;
+    if (!rawSubtree || typeof rawSubtree !== "object")
+        return [];
+    return Array.isArray(rawSubtree)
+        ? rawSubtree.filter((policy) => Boolean(policy) && typeof policy === "object")
+        : [rawSubtree];
+}
+function readSubtreeMiddlewareEntryId(entry) {
+    if (typeof entry === "string")
+        return entry;
+    if (!entry || typeof entry !== "object")
+        return null;
+    if ("use" in entry) {
+        return readSubtreeMiddlewareEntryId(entry.use ?? null);
+    }
+    const id = (0, introspector_tools_1.readId)(entry);
+    return id ? id : null;
+}
+function resolveTaskSubtreeMiddlewareEntry(entry, task) {
+    if (typeof entry === "string") {
+        return entry;
+    }
+    if (!entry || typeof entry !== "object") {
+        return null;
+    }
+    if ("use" in entry) {
+        const conditionalEntry = entry;
+        if (typeof conditionalEntry.when === "function") {
+            try {
+                if (!conditionalEntry.when(task)) {
+                    return null;
+                }
+            }
+            catch {
+                return null;
+            }
+        }
+        return readSubtreeMiddlewareEntryId(conditionalEntry.use ?? null);
+    }
+    return readSubtreeMiddlewareEntryId(entry);
+}
+function collectSubtreeTaskMiddlewareOwnerIds(store, task) {
+    const ownerIds = new Map();
+    const chainRootToNearest = [
+        ...getTaskOwnerResourceChain(store, task.id),
+    ].reverse();
+    for (const ownerResourceId of chainRootToNearest) {
+        const ownerResource = store.resources.get(ownerResourceId)?.resource;
+        if (!ownerResource)
+            continue;
+        for (const policy of getSubtreePolicies(ownerResource)) {
+            const taskMiddlewares = Array.isArray(policy.tasks?.middleware)
+                ? policy.tasks.middleware
+                : [];
+            for (const entry of taskMiddlewares) {
+                const middlewareId = resolveTaskSubtreeMiddlewareEntry(entry, task);
+                if (!middlewareId)
+                    continue;
+                const duplicateKey = getMiddlewareDuplicateKey(middlewareId);
+                if (!ownerIds.has(duplicateKey)) {
+                    ownerIds.set(duplicateKey, ownerResourceId);
+                }
+            }
+        }
+    }
+    return ownerIds;
+}
+function hasMiddlewareConfig(middleware) {
+    return (Boolean(middleware?.[runner_1.definitions.symbolMiddlewareConfigured]) ||
+        middleware?.config !== undefined);
+}
+function buildEffectiveTaskMiddlewareUsages(store, task) {
+    const resolver = store.getMiddlewareManager()?.middlewareResolver;
+    const effectiveMiddlewares = resolver
+        ? resolver.getApplicableTaskMiddlewares(task)
+        : task.middleware;
+    const subtreeOwnersByKey = collectSubtreeTaskMiddlewareOwnerIds(store, task);
+    return effectiveMiddlewares.map((middleware) => {
+        const duplicateKey = getMiddlewareDuplicateKey(String(middleware.id));
+        const subtreeOwnerId = subtreeOwnersByKey.get(duplicateKey) ?? null;
+        return {
+            id: String(middleware.id),
+            config: hasMiddlewareConfig(middleware)
+                ? (0, introspector_tools_1.stringifyIfObject)(middleware.config)
+                : null,
+            origin: subtreeOwnerId ? "subtree" : "local",
+            subtreeOwnerId,
+        };
+    });
+}
 // Mapping helpers
-function mapStoreTaskToTaskModel(task, taskStoreElement) {
+function mapStoreTaskToTaskModel(task, store, taskStoreElement) {
     const depsObj = normalizeDependencies(task?.dependencies);
     const eventIdsFromDeps = extractEventIdsFromDependencies(depsObj);
     const resourceIdsFromDeps = extractResourceIdsFromDependencies(depsObj);
     const taskIdsFromDeps = extractTaskIdsFromDependencies(depsObj);
     const errorIdsFromDeps = extractErrorIdsFromDependencies(depsObj);
     const tagIdsFromDeps = extractTagIdsFromDependencies(depsObj);
-    const middlewareDetailed = (task.middleware || []).map((m) => ({
-        id: String(m.id),
-        // In some @bluelibs/runner versions the configured flag may be missing; fall back to presence of config
-        config: (m && m[runner_1.definitions.symbolMiddlewareConfigured]) ||
-            m?.config !== undefined
-            ? (0, introspector_tools_1.stringifyIfObject)(m.config)
-            : null,
-    }));
+    const middlewareDetailed = store
+        ? buildEffectiveTaskMiddlewareUsages(store, task)
+        : (task.middleware || []).map((m) => ({
+            id: String(m.id),
+            config: hasMiddlewareConfig(m) ? (0, introspector_tools_1.stringifyIfObject)(m.config) : null,
+            origin: "local",
+            subtreeOwnerId: null,
+        }));
     const { ids: tagIds, detailed: tagsDetailed } = normalizeTags(task?.tags);
     const interceptorOwnerIds = Array.from(new Set(taskStoreElement?.interceptors
         ?.map((record) => record.ownerResourceId)
@@ -101,7 +248,7 @@ function mapStoreTaskToTaskModel(task, taskStoreElement) {
             ...errorIdsFromDeps,
             ...tagIdsFromDeps,
         ],
-        middleware: task.middleware.map((m) => m.id.toString()),
+        middleware: middlewareDetailed.map((m) => m.id),
         middlewareDetailed,
         registeredBy: null,
         kind: "TASK",
@@ -109,8 +256,8 @@ function mapStoreTaskToTaskModel(task, taskStoreElement) {
         visibilityReason: null,
         // Emits any events present in its dependencies
         emits: eventIdsFromDeps,
-        inputSchema: (0, zod_1.formatSchemaIfZod)(task.inputSchema),
-        resultSchema: (0, zod_1.formatSchemaIfZod)(task.resultSchema),
+        inputSchema: (0, schemaFormat_1.formatSchemaIfZod)(task.inputSchema),
+        resultSchema: (0, schemaFormat_1.formatSchemaIfZod)(task.resultSchema),
         rpcLane: extractRpcLaneSummary(tagsDetailed),
         interceptorCount: taskStoreElement?.interceptors?.length ?? 0,
         hasInterceptors: (taskStoreElement?.interceptors?.length ?? 0) > 0,
@@ -120,7 +267,7 @@ function mapStoreTaskToTaskModel(task, taskStoreElement) {
 function mapStoreTaskToHookModel(_task) {
     throw new Error("deprecated");
 }
-function mapStoreHookToHookModel(hkStoreElement) {
+function mapStoreHookToHookModel(hkStoreElement, store) {
     const hk = hkStoreElement.hook;
     const depsObj = normalizeDependencies(hk?.dependencies);
     const eventIdsFromDeps = extractEventIdsFromDependencies(depsObj);
@@ -129,9 +276,7 @@ function mapStoreHookToHookModel(hkStoreElement) {
     const errorIdsFromDeps = extractErrorIdsFromDependencies(depsObj);
     const tagIdsFromDeps = extractTagIdsFromDependencies(depsObj);
     const { ids: tagIds, detailed: tagsDetailed } = normalizeTags(hk.tags);
-    const eventIds = Array.isArray(hk.on)
-        ? hk.on.map((e) => String(e.id))
-        : [String(hk.on?.id ?? "*")];
+    const eventIds = resolveHookEventIds(hk, store);
     return (0, introspector_tools_1.stampElementKind)({
         id: String(hk?.id),
         meta: buildMetaWithNormalizedTags(hk?.meta, hk),
@@ -188,6 +333,8 @@ function mapStoreResourceToResourceModel(resource, resourceConfig) {
     const { ids: tagIds, detailed: tagsDetailed } = normalizeTags(resource?.tags);
     const isolation = normalizeIsolation(resource);
     const subtree = normalizeSubtreePolicy(resource);
+    const hasInit = typeof resource?.init === "function";
+    const hasDispose = typeof resource?.dispose === "function";
     const hasCooldown = typeof resource?.cooldown === "function";
     const hasReady = typeof resource?.ready === "function";
     const hasHealthCheck = typeof resource?.health === "function";
@@ -215,12 +362,14 @@ function mapStoreResourceToResourceModel(resource, resourceConfig) {
         registers: register.map((r) => r.id.toString()),
         isolation,
         subtree,
+        hasInit,
+        hasDispose,
         hasCooldown,
         hasReady,
         hasHealthCheck,
         context: (0, introspector_tools_1.stringifyIfObject)(resource.context),
         registeredBy: null,
-        configSchema: (0, zod_1.formatSchemaIfZod)(resource.configSchema),
+        configSchema: (0, schemaFormat_1.formatSchemaIfZod)(resource.configSchema),
         isPrivate: false,
         visibilityReason: null,
     }, "RESOURCE");
@@ -238,25 +387,22 @@ function normalizeResourceConfig(config) {
 function buildEvents(store) {
     const eventsCollection = Array.from(store.events.values()).map((e) => e.event);
     const allEventIds = eventsCollection.map((e) => e.id.toString());
-    const hooks = Array.from(store.hooks.values()).map((h) => h.hook);
+    const hookEntries = Array.from(store.hooks.values());
+    const hookTargetEventIdsByHookId = new Map();
+    const eventLaneByEventId = buildEventLaneSummaryByEventId(store);
+    for (const hookEntry of hookEntries) {
+        hookTargetEventIdsByHookId.set(hookEntry.hook.id, resolveHookEventIds(hookEntry.hook, store));
+    }
     return allEventIds.map((eventId) => {
         const e = findById(eventsCollection, eventId);
         const { ids: tagIds, detailed: tagsDetailed } = normalizeTags(e.tags);
-        // Keep wildcard hooks in listenedToBy per design, but match specific listeners robustly
-        const hooksListeningToEvent = hooks
-            .filter((h) => {
-            const on = h?.on;
-            if (on === "*")
+        const hooksListeningToEvent = hookEntries
+            .filter(({ hook }) => {
+            if (hook.on === "*")
                 return true;
-            if (typeof on === "string")
-                return on === eventId;
-            if (on && typeof on === "object" && !Array.isArray(on))
-                return String(on.id) === eventId;
-            if (Array.isArray(on))
-                return on.some((v) => typeof v === "string" ? v === eventId : String(v?.id) === eventId);
-            return false;
+            return (hookTargetEventIdsByHookId.get(hook.id)?.includes(eventId) ?? false);
         })
-            .map((h) => h.id);
+            .map(({ hook }) => hook.id);
         return (0, introspector_tools_1.stampElementKind)({
             id: eventId,
             meta: buildMetaWithNormalizedTags(e?.meta ?? null, e),
@@ -264,17 +410,175 @@ function buildEvents(store) {
             tagsDetailed,
             transactional: Boolean(e?.transactional),
             parallel: Boolean(e?.parallel),
-            eventLane: extractEventLaneSummary(tagsDetailed),
+            eventLane: eventLaneByEventId.get(eventId) ?? null,
             rpcLane: extractRpcLaneSummary(tagsDetailed),
             filePath: (0, path_1.sanitizePath)((e && e[runner_1.definitions.symbolFilePath]) ?? e?.filePath ?? null),
             listenedToBy: hooksListeningToEvent,
             registeredBy: null,
-            payloadSchema: (0, zod_1.formatSchemaIfZod)(e.payloadSchema),
+            payloadSchema: (0, schemaFormat_1.formatSchemaIfZod)(e.payloadSchema),
             isPrivate: false,
             visibilityReason: null,
         }, "EVENT");
     });
 }
+function resolveHookEventIds(hook, store) {
+    if (hook.on === "*") {
+        return ["*"];
+    }
+    if (store && hook.on) {
+        return store.resolveHookTargets(hook).map((entry) => entry.event.id);
+    }
+    if (Array.isArray(hook.on)) {
+        return hook.on.map((entry) => typeof entry === "string" ? entry : String(entry?.id));
+    }
+    return [String(hook.on?.id ?? "*")];
+}
+function buildEventLaneSummaryByEventId(store) {
+    const laneByEventId = new Map();
+    const buildLaneApplyTargetKey = (target) => {
+        if (typeof target === "string") {
+            return `id:${target}`;
+        }
+        const targetId = (0, lane_resources_1.extractLaneId)(target);
+        if (targetId) {
+            return `id:${targetId}`;
+        }
+        const serializedTarget = (0, introspector_tools_1.stringifyIfObject)(target);
+        if (serializedTarget) {
+            return `json:${serializedTarget}`;
+        }
+        return `raw:${String(target)}`;
+    };
+    const mergeLaneApplyTo = (existingApplyTo, incomingApplyTo) => {
+        if (incomingApplyTo === undefined) {
+            return existingApplyTo;
+        }
+        if (existingApplyTo === undefined) {
+            return incomingApplyTo;
+        }
+        if (Array.isArray(existingApplyTo) && Array.isArray(incomingApplyTo)) {
+            const mergedTargets = new Map();
+            for (const target of [...existingApplyTo, ...incomingApplyTo]) {
+                mergedTargets.set(buildLaneApplyTargetKey(target), target);
+            }
+            return Array.from(mergedTargets.values());
+        }
+        return incomingApplyTo;
+    };
+    const mergeTopologyLaneEntry = (existingEntry, incomingEntry) => {
+        if (!existingEntry) {
+            return incomingEntry;
+        }
+        return {
+            id: incomingEntry.id,
+            applyTo: mergeLaneApplyTo(existingEntry.applyTo, incomingEntry.applyTo),
+            orderingKey: incomingEntry.orderingKey ?? existingEntry.orderingKey,
+            metadata: incomingEntry.metadata ?? existingEntry.metadata,
+        };
+    };
+    const upsertTopologyLaneEntry = (entry) => {
+        topologyLanesById.set(entry.id, mergeTopologyLaneEntry(topologyLanesById.get(entry.id), entry));
+    };
+    const topologyLanesById = new Map();
+    for (const resourceEntry of store.resources.values()) {
+        const resource = resourceEntry.resource;
+        const normalizedTags = normalizeTags(resource?.tags).ids;
+        if (!(0, lane_resources_1.isEventLanesResource)({
+            id: String(resource.id),
+            tags: normalizedTags,
+        })) {
+            continue;
+        }
+        const topology = resourceEntry
+            .config?.topology;
+        if (Array.isArray(topology?.bindings)) {
+            for (const binding of topology.bindings) {
+                const laneId = (0, lane_resources_1.extractLaneId)(binding?.lane);
+                if (!laneId || !binding?.lane)
+                    continue;
+                upsertTopologyLaneEntry({
+                    id: laneId,
+                    applyTo: normalizeEventLaneApplyTo(binding.lane.applyTo),
+                    orderingKey: typeof binding.lane.orderingKey === "string"
+                        ? binding.lane.orderingKey
+                        : null,
+                    metadata: (0, introspector_tools_1.stringifyIfObject)(binding.lane.metadata),
+                });
+            }
+        }
+        if (topology?.profiles && typeof topology.profiles === "object") {
+            for (const profile of Object.values(topology.profiles)) {
+                if (!Array.isArray(profile?.consume))
+                    continue;
+                for (const entry of profile.consume) {
+                    const laneId = (0, lane_resources_1.extractLaneId)(entry?.lane);
+                    if (!laneId || !entry?.lane)
+                        continue;
+                    upsertTopologyLaneEntry({
+                        id: laneId,
+                        applyTo: normalizeEventLaneApplyTo(entry.lane.applyTo),
+                        orderingKey: typeof entry.lane.orderingKey === "string"
+                            ? entry.lane.orderingKey
+                            : null,
+                        metadata: (0, introspector_tools_1.stringifyIfObject)(entry.lane.metadata),
+                    });
+                }
+            }
+        }
+    }
+    const registeredEvents = Array.from(store.events.values()).map((eventEntry) => eventEntry.event);
+    for (const lane of topologyLanesById.values()) {
+        if (typeof lane.applyTo === "function") {
+            for (const event of registeredEvents) {
+                if (laneByEventId.has(event.id))
+                    continue;
+                let matchesEvent = false;
+                try {
+                    matchesEvent = lane.applyTo(event);
+                }
+                catch {
+                    matchesEvent = false;
+                }
+                if (!matchesEvent)
+                    continue;
+                laneByEventId.set(event.id, {
+                    laneId: lane.id,
+                    orderingKey: lane.orderingKey,
+                    metadata: lane.metadata,
+                });
+            }
+            continue;
+        }
+        if (!Array.isArray(lane.applyTo)) {
+            continue;
+        }
+        for (const target of lane.applyTo) {
+            const targetId = typeof target === "string"
+                ? target
+                : store.findIdByDefinition(target) ?? (0, lane_resources_1.extractLaneId)(target);
+            if (!targetId)
+                continue;
+            const event = store.events.get(targetId)?.event;
+            if (!event || laneByEventId.has(event.id))
+                continue;
+            laneByEventId.set(event.id, {
+                laneId: lane.id,
+                orderingKey: lane.orderingKey,
+                metadata: lane.metadata,
+            });
+        }
+    }
+    return laneByEventId;
+}
+function normalizeEventLaneApplyTo(applyTo) {
+    if (Array.isArray(applyTo)) {
+        return applyTo;
+    }
+    if (typeof applyTo === "function") {
+        return applyTo;
+    }
+    return undefined;
+}
 function buildMiddlewaresGeneric(middlewaresCollection, tasks, resources, kind) {
     const matchesMiddlewareId = (candidateIds, middlewareId) => (candidateIds ?? []).some((candidateId) => candidateId === middlewareId ||
         candidateId.endsWith(`.${middlewareId}`) ||
@@ -318,7 +622,7 @@ function buildMiddlewaresGeneric(middlewaresCollection, tasks, resources, kind)
             usedByResources,
             overriddenBy: mw?.overriddenBy ?? null,
             registeredBy: null,
-            configSchema: (0, zod_1.formatSchemaIfZod)(mw.configSchema),
+            configSchema: (0, schemaFormat_1.formatSchemaIfZod)(mw.configSchema),
             type: kind,
             isPrivate: false,
             visibilityReason: null,
@@ -332,6 +636,20 @@ function buildResourceMiddlewares(middlewaresCollection, tasks, resources) {
     return buildMiddlewaresGeneric(middlewaresCollection, tasks, resources, "resource");
 }
 function attachRegisteredBy(resources, tasks, hooks, middlewares, events) {
+    const matchesRegisteredElement = (candidateId, referenceId) => candidateId === referenceId ||
+        candidateId.endsWith(`.${referenceId}`) ||
+        referenceId.endsWith(`.${candidateId}`);
+    const resolveRegisteredElement = (map, referenceId) => {
+        const direct = map.get(referenceId);
+        if (direct)
+            return direct;
+        for (const element of map.values()) {
+            if (matchesRegisteredElement(element.id, referenceId)) {
+                return element;
+            }
+        }
+        return null;
+    };
     const taskMap = (0, introspector_tools_1.buildIdMap)(tasks);
     const hookMap = (0, introspector_tools_1.buildIdMap)(hooks);
     const resourceMap = (0, introspector_tools_1.buildIdMap)(resources);
@@ -339,16 +657,30 @@ function attachRegisteredBy(resources, tasks, hooks, middlewares, events) {
     const eventMap = (0, introspector_tools_1.buildIdMap)(events);
     for (const r of resources) {
         for (const id of r.registers ?? []) {
-            if (taskMap.has(id))
-                taskMap.get(id).registeredBy = r.id;
-            else if (hookMap.has(id))
-                hookMap.get(id).registeredBy = r.id;
-            else if (resourceMap.has(id))
-                resourceMap.get(id).registeredBy = r.id;
-            else if (middlewareMap.has(id))
-                middlewareMap.get(id).registeredBy = r.id;
-            else if (eventMap.has(id))
-                eventMap.get(id).registeredBy = r.id;
+            const task = resolveRegisteredElement(taskMap, id);
+            if (task) {
+                task.registeredBy = r.id;
+                continue;
+            }
+            const hook = resolveRegisteredElement(hookMap, id);
+            if (hook) {
+                hook.registeredBy = r.id;
+                continue;
+            }
+            const resource = resolveRegisteredElement(resourceMap, id);
+            if (resource) {
+                resource.registeredBy = r.id;
+                continue;
+            }
+            const middleware = resolveRegisteredElement(middlewareMap, id);
+            if (middleware) {
+                middleware.registeredBy = r.id;
+                continue;
+            }
+            const event = resolveRegisteredElement(eventMap, id);
+            if (event) {
+                event.registeredBy = r.id;
+            }
         }
     }
 }
@@ -592,8 +924,8 @@ function toSubtreeMiddlewareIds(entries) {
     if (!Array.isArray(entries))
         return [];
     const ids = entries
-        .map((entry) => (typeof entry === "string" ? entry : (0, introspector_tools_1.readId)(entry)))
-        .filter(Boolean);
+        .map((entry) => typeof entry === "string" ? entry : readSubtreeMiddlewareEntryId(entry))
+        .filter((id) => Boolean(id));
     return Array.from(new Set(ids));
 }
 function appendSubtreeMiddlewareIds(target, entries) {
@@ -602,16 +934,12 @@ function appendSubtreeMiddlewareIds(target, entries) {
     }
 }
 function normalizeSubtreePolicy(resource) {
-    const rawSubtree = resource?.subtree;
-    if (!rawSubtree || typeof rawSubtree !== "object")
-        return null;
-    const subtreePolicies = Array.isArray(rawSubtree)
-        ? rawSubtree.filter((policy) => Boolean(policy) && typeof policy === "object")
-        : [rawSubtree];
+    const subtreePolicies = getSubtreePolicies(resource);
     if (subtreePolicies.length === 0)
         return null;
     const taskMiddlewareIds = new Set();
     const resourceMiddlewareIds = new Set();
+    const taskIdentityRequirements = [];
     let tasksValidatorCount = 0;
     let resourcesValidatorCount = 0;
     let hooksValidatorCount = 0;
@@ -619,11 +947,16 @@ function normalizeSubtreePolicy(resource) {
     let resourceMiddlewareValidatorCount = 0;
     let eventsValidatorCount = 0;
     let tagsValidatorCount = 0;
+    let subtreeMiddlewareIdentityScope = null;
     for (const subtree of subtreePolicies) {
         if (subtree.tasks) {
             appendSubtreeMiddlewareIds(taskMiddlewareIds, subtree.tasks.middleware);
+            taskIdentityRequirements.push(...normalizeIdentityRequirementSummaries(subtree.tasks.identity));
             tasksValidatorCount += normalizeSubtreeValidatorCount(subtree.tasks.validate);
         }
+        if (subtree.middleware && "identityScope" in subtree.middleware) {
+            subtreeMiddlewareIdentityScope = normalizeIdentityScopeSummary(subtree.middleware.identityScope);
+        }
         if (subtree.resources) {
             appendSubtreeMiddlewareIds(resourceMiddlewareIds, subtree.resources.middleware);
             resourcesValidatorCount += normalizeSubtreeValidatorCount(subtree.resources.validate);
@@ -644,10 +977,20 @@ function normalizeSubtreePolicy(resource) {
             tagsValidatorCount += normalizeSubtreeValidatorCount(subtree.tags.validate);
         }
     }
-    const tasks = taskMiddlewareIds.size > 0 || tasksValidatorCount > 0
+    const tasks = taskMiddlewareIds.size > 0 ||
+        tasksValidatorCount > 0 ||
+        taskIdentityRequirements.length > 0
         ? {
             middleware: Array.from(taskMiddlewareIds),
             validatorCount: tasksValidatorCount,
+            ...(taskIdentityRequirements.length > 0
+                ? { identity: taskIdentityRequirements }
+                : {}),
+        }
+        : null;
+    const middleware = subtreeMiddlewareIdentityScope !== null
+        ? {
+            identityScope: subtreeMiddlewareIdentityScope,
         }
         : null;
     const resources = resourceMiddlewareIds.size > 0 || resourcesValidatorCount > 0
@@ -682,6 +1025,7 @@ function normalizeSubtreePolicy(resource) {
         }
         : null;
     if (!tasks &&
+        !middleware &&
         !resources &&
         !hooks &&
         !taskMiddleware &&
@@ -692,6 +1036,7 @@ function normalizeSubtreePolicy(resource) {
     }
     return {
         tasks,
+        middleware,
         resources,
         hooks,
         taskMiddleware,
@@ -710,20 +1055,6 @@ function parseTagConfigJson(config) {
         return null;
     }
 }
-function extractEventLaneSummary(tagsDetailed) {
-    const laneTag = tagsDetailed.find((tag) => matchesTagId(tag.id, lane_resources_1.EVENT_LANE_TAG_ID));
-    if (!laneTag)
-        return null;
-    const parsed = parseTagConfigJson(laneTag.config);
-    const laneId = (0, lane_resources_1.extractLaneId)(parsed?.lane);
-    if (!laneId)
-        return null;
-    return {
-        laneId,
-        orderingKey: parsed?.orderingKey != null ? String(parsed.orderingKey) : null,
-        metadata: parsed?.metadata != null ? (0, introspector_tools_1.stringifyIfObject)(parsed.metadata) : null,
-    };
-}
 function extractRpcLaneSummary(tagsDetailed) {
     const laneTag = tagsDetailed.find((tag) => matchesTagId(tag.id, lane_resources_1.RPC_LANE_TAG_ID));
     if (!laneTag)