@open-mercato/cli 0.6.7-develop.6795.1.8a3f27921c → 0.6.7-develop.6814.1.0627c7e9f1

package/dist/lib/generators/module-extension-facts.js

@@ -493,7 +493,7 @@ function factRefHost(options) {
     ...options.scopeContract ? { scopeContract: options.scopeContract } : {},
     bound: true,
     stability: "stable",
-    source: { kind: "fact-ref", factSection: options.factSection, factKey: options.id }
+    source: { kind: "fact-ref", factSection: options.factSection, factKey: options.factKey ?? options.id }
   };
 }
 function sourceFilesBelow(directory) {
@@ -527,6 +527,7 @@ function apiExtensionHostIds(moduleId, moduleRoot) {
   const cached = activeExtractionCache?.apiExtensionHostIds.get(cacheKey);
   if (cached) return cached;
   const entityIds = /* @__PURE__ */ new Set();
+  const entitySourceFiles = {};
   const commandIds = /* @__PURE__ */ new Set();
   const routeIds = /* @__PURE__ */ new Set();
   for (const filePath of sourceFilesBelow(path.join(moduleRoot, "api"))) {
@@ -545,13 +546,19 @@ function apiExtensionHostIds(moduleId, moduleRoot) {
         if (name === "enrichers") {
           const config = staticValue(node.initializer, context);
           const entityId = isStaticObject(config) ? stringValue(config.entityId) : void 0;
-          if (entityId) entityIds.add(entityId);
+          if (entityId) {
+            entityIds.add(entityId);
+            if (!entitySourceFiles[entityId]) entitySourceFiles[entityId] = filePath;
+          }
         }
       }
       if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === "validateCrudMutationGuard") {
         const input = node.arguments[1] ? staticValue(node.arguments[1], context) : void 0;
         const entityId = isStaticObject(input) ? stringValue(input.resourceKind) : void 0;
-        if (entityId) entityIds.add(entityId);
+        if (entityId) {
+          entityIds.add(entityId);
+          if (!entitySourceFiles[entityId]) entitySourceFiles[entityId] = filePath;
+        }
       }
       node.forEachChild(visit);
     };
@@ -559,6 +566,7 @@ function apiExtensionHostIds(moduleId, moduleRoot) {
   }
   const result = {
     entityIds: [...entityIds].sort((left, right) => left.localeCompare(right)),
+    entitySourceFiles,
     commandIds: [...commandIds].sort((left, right) => left.localeCompare(right)),
     routeIds: [...routeIds].sort((left, right) => left.localeCompare(right))
   };
@@ -580,6 +588,104 @@ function extractKnownCommandIds(moduleId, moduleRoot) {
   const apiHosts = apiExtensionHostIds(moduleId, moduleRoot);
   return moduleCommandIds(moduleRoot, apiHosts.commandIds);
 }
+const HTTP_METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE"];
+const API_INTERCEPTOR_BRIDGE_CALLS = {
+  runApiInterceptorsBefore: "before",
+  runApiInterceptorsAfter: "after"
+};
+function isHttpMethodName(value) {
+  return HTTP_METHODS.includes(value);
+}
+function exportedHttpMethods(file) {
+  const methods = /* @__PURE__ */ new Set();
+  const consider = (name) => {
+    if (name && isHttpMethodName(name)) methods.add(name);
+  };
+  const considerBindingName = (name) => {
+    if (ts.isIdentifier(name)) {
+      consider(name.text);
+      return;
+    }
+    for (const element of name.elements) {
+      if (ts.isBindingElement(element)) considerBindingName(element.name);
+    }
+  };
+  const visit = (node) => {
+    if (ts.isVariableStatement(node) && node.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword)) {
+      for (const declaration of node.declarationList.declarations) {
+        considerBindingName(declaration.name);
+      }
+    }
+    if (ts.isFunctionDeclaration(node) && node.name && node.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword)) {
+      consider(node.name.text);
+    }
+    if (ts.isExportDeclaration(node) && node.exportClause && ts.isNamedExports(node.exportClause)) {
+      for (const element of node.exportClause.elements) consider(element.name.text);
+    }
+    node.forEachChild(visit);
+  };
+  file.forEachChild(visit);
+  return [...methods].sort((left, right) => left.localeCompare(right));
+}
+function extractApiRouteInterceptorBridges(file, context) {
+  const exportedMethods = exportedHttpMethods(file);
+  const phasesByMethod = /* @__PURE__ */ new Map();
+  const addPhase = (method, phase) => {
+    const phases = phasesByMethod.get(method) ?? /* @__PURE__ */ new Set();
+    phases.add(phase);
+    phasesByMethod.set(method, phases);
+  };
+  const visit = (node) => {
+    if (ts.isCallExpression(node) && ts.isIdentifier(node.expression)) {
+      const calleeName = node.expression.text;
+      if (calleeName === "makeCrudRoute") {
+        for (const method of exportedMethods) {
+          addPhase(method, "before");
+          addPhase(method, "after");
+        }
+      }
+      const phase = API_INTERCEPTOR_BRIDGE_CALLS[calleeName];
+      if (phase) {
+        const callOptions = node.arguments[0] ? staticValue(node.arguments[0], context) : void 0;
+        const declaredMethod = isStaticObject(callOptions) ? stringValue(callOptions.method) : void 0;
+        const methods = declaredMethod && isHttpMethodName(declaredMethod) ? [declaredMethod] : exportedMethods;
+        for (const method of methods) addPhase(method, phase);
+      }
+    }
+    node.forEachChild(visit);
+  };
+  file.forEachChild(visit);
+  return [...phasesByMethod.entries()].map(([method, phases]) => ({
+    method,
+    phases: [...phases].sort((left, right) => left.localeCompare(right))
+  })).sort((left, right) => left.method.localeCompare(right.method));
+}
+function extractActivationTargetOwners(options) {
+  const apiRoutes = [];
+  for (const filePath of sourceFilesBelow(path.join(options.moduleRoot, "api"))) {
+    const routeId = apiRouteId(options.moduleId, options.moduleRoot, filePath);
+    if (!routeId) continue;
+    const file = sourceFile(filePath);
+    const bridges = file ? extractApiRouteInterceptorBridges(file, buildStaticContext(file)) : [];
+    apiRoutes.push({
+      id: routeId,
+      source: { sourcePath: portablePath(options.moduleRoot, options.sourceRoot, filePath) },
+      bridges
+    });
+  }
+  const commands = [];
+  const seenCommands = /* @__PURE__ */ new Set();
+  for (const filePath of sourceFilesBelow(path.join(options.moduleRoot, "commands"))) {
+    if (path.basename(filePath).replace(/\.(?:ts|tsx)$/, "") === "interceptors") continue;
+    const source = { sourcePath: portablePath(options.moduleRoot, options.sourceRoot, filePath) };
+    for (const id of extractCommandIdsFromSource(filePath)) {
+      if (seenCommands.has(id)) continue;
+      seenCommands.add(id);
+      commands.push({ id, source });
+    }
+  }
+  return { apiRoutes, commands };
+}
 function extractFactRefHosts(options) {
   const hosts = [];
   for (const entity of options.entities) {
@@ -631,6 +737,7 @@ function extractFactRefHosts(options) {
         family: "query-lifecycle",
         capabilities: ["sync-subscriber"],
         factSection: "searchEntities",
+        factKey: entityId,
         phases: phase === "querying" ? ["block", "query-transform"] : ["result-transform", "scope-reapply"],
         activation: "caller-opt-in",
         scopeContract: "tenant-and-organization-reapplied-after-result"
@@ -639,7 +746,8 @@ function extractFactRefHosts(options) {
   }
   const apiHosts = apiExtensionHostIds(options.moduleId, options.moduleRoot);
   for (const entityId of apiHosts.entityIds) {
-    hosts.push(factRefHost({
+    const declaringFile = apiHosts.entitySourceFiles[entityId];
+    const host = factRefHost({
       key: `api-entity.${entityId}`,
       id: entityId,
       moduleId: options.moduleId,
@@ -648,7 +756,15 @@ function extractFactRefHosts(options) {
       factSection: "apiRoutes",
       activation: "host-opt-in",
       scopeContract: "tenant-and-organization"
-    }));
+    });
+    hosts.push(declaringFile ? {
+      ...host,
+      source: {
+        kind: "declaration",
+        path: portablePath(options.moduleRoot, options.sourceRoot, declaringFile),
+        symbol: entityId
+      }
+    } : host);
   }
   return sortHosts([...new Map(hosts.map((host) => [`${host.family}:${host.id}`, host])).values()]);
 }
@@ -738,7 +854,8 @@ function extractEnrichers(options) {
       const targetEntity = stringValue(entry.targetEntity);
       if (!targetEntity) return null;
       const timeoutMs = numberValue(entry.timeout) ?? 2e3;
-      const queryEngine = isStaticObject(entry.queryEngine) ? entry.queryEngine : null;
+      const queryEngineConfig = isStaticObject(entry.queryEngine) ? entry.queryEngine : null;
+      const queryEngine = queryEngineConfig && booleanValue(queryEngineConfig.enabled) === true ? queryEngineConfig : null;
       const surfaces = [entry.enrichMany === true ? "list" : null, entry.enrichOne === true ? "detail" : null].filter((value) => value !== null);
       const base = contributionBase(id, sourcePath, id);
       return {
@@ -879,14 +996,13 @@ function extractSubscribers(options) {
   const directory = path.join(options.moduleRoot, "subscribers");
   if (!fs.existsSync(directory)) return [];
   const facts = [];
-  for (const entry of fs.readdirSync(directory, { withFileTypes: true }).sort((left, right) => left.name.localeCompare(right.name))) {
-    if (!entry.isFile() || !/\.(?:ts|tsx)$/.test(entry.name) || /\.(?:test|spec)\./.test(entry.name)) continue;
-    const filePath = path.join(directory, entry.name);
+  for (const filePath of sourceFilesBelow(directory)) {
     const metadata = readRootObject(filePath, "metadata");
     if (!metadata) continue;
     const event = stringValue(metadata.event);
     if (!event) continue;
-    const subscriberId = stringValue(metadata.id) ?? `${options.moduleId}:${entry.name.replace(/\.tsx?$/, "")}`;
+    const relativeStem = path.relative(directory, filePath).replace(/\.tsx?$/, "").split(path.sep).join("/");
+    const subscriberId = stringValue(metadata.id) ?? `${options.moduleId}:${relativeStem}`;
     const persistent = booleanValue(metadata.persistent) ?? false;
     const sync = booleanValue(metadata.sync) ?? !persistent;
     const contribution = contributionBase(subscriberId, portablePath(options.moduleRoot, options.sourceRoot, filePath), "metadata");
@@ -931,7 +1047,8 @@ function extractNotificationReactions(options) {
     build(entry, sourcePath, index) {
       const notificationType = stringValue(entry.notificationType);
       if (!notificationType) return null;
-      const id = stringValue(entry.id) ?? `${options.moduleId}.notification-handler.${index}`;
+      const declaredId = stringValue(entry.id);
+      const id = declaredId ?? `${options.moduleId}.notification-handler.${index}`;
       const contribution = contributionBase(id, sourcePath, "notificationHandlers");
       return {
         ...contribution,
@@ -942,7 +1059,8 @@ function extractNotificationReactions(options) {
         details: {
           transports: ["notification-effect"],
           hooks: ["useNotificationEffect"],
-          audienceScopeContract: "tenant-organization-user-role-and-customer"
+          audienceScopeContract: "tenant-organization-user-role-and-customer",
+          ...declaredId ? { overrideKey: declaredId } : {}
         }
       };
     }
@@ -1007,16 +1125,32 @@ function extractSpecializedRegistries(options) {
   }
   const integrationPath = conventionPath(options.moduleRoot, "integration.ts");
   if (integrationPath) {
-    const integration = readRootObject(integrationPath, "integration");
     const sourcePath = portablePath(options.moduleRoot, options.sourceRoot, integrationPath);
-    const integrationId = integration ? stringValue(integration.id) : void 0;
-    if (integrationId) add(integrationId, "integration", sourcePath, "integrations", "integration");
-    const providerKey = integration ? stringValue(integration.providerKey) : void 0;
-    const category = integration ? stringValue(integration.category) : void 0;
-    const categoryRegistry = category === "payment" ? "payment" : category === "shipping" ? "shipping" : category === "currency" ? "currency" : null;
-    if (providerKey && categoryRegistry) {
-      const specialistRoute = categoryRegistry === "payment" ? "paymentGateways" : categoryRegistry === "shipping" ? "shippingCarriers" : "currencies";
-      add(providerKey, categoryRegistry, sourcePath, specialistRoute, "integration.providerKey");
+    const addIntegration = (integration, symbol, bundleId) => {
+      const integrationId = stringValue(integration.id);
+      if (integrationId) {
+        add(integrationId, "integration", sourcePath, "integrations", bundleId ? `${symbol}[${bundleId}]` : symbol);
+      }
+      const providerKey = stringValue(integration.providerKey);
+      const category = stringValue(integration.category);
+      const categoryRegistry = category === "payment" ? "payment" : category === "shipping" ? "shipping" : category === "currency" ? "currency" : null;
+      if (providerKey && categoryRegistry) {
+        const specialistRoute = categoryRegistry === "payment" ? "paymentGateways" : categoryRegistry === "shipping" ? "shippingCarriers" : "currencies";
+        add(providerKey, categoryRegistry, sourcePath, specialistRoute, `${symbol}.providerKey`);
+      }
+    };
+    const singular = readRootObject(integrationPath, "integration");
+    if (singular) addIntegration(singular, "integration");
+    for (const integration of readConventionObjectArray(integrationPath, "integrations")) {
+      addIntegration(integration, "integrations");
+    }
+    const bundle = readRootObject(integrationPath, "integrationBundle") ?? readRootObject(integrationPath, "bundle");
+    if (bundle) {
+      const bundleId = stringValue(bundle.id) ?? "bundle";
+      const members = Array.isArray(bundle.integrations) ? bundle.integrations : [];
+      for (const member of members) {
+        if (isStaticObject(member)) addIntegration(member, "integrationBundle", bundleId);
+      }
     }
   }
   const workflowsPath = conventionPath(options.moduleRoot, "workflows.ts");
@@ -1071,6 +1205,147 @@ function extractSpecializedRegistries(options) {
   }
   return facts;
 }
+const ACTIVATION_ADAPTERS = {
+  "crud-response-enricher": { contributionKinds: ["response-enricher"], mode: "call-site-object" },
+  "query-enricher": { contributionKinds: ["response-enricher"], mode: "call-site-object" },
+  "mutation-guard": { contributionKinds: ["mutation-guard"], mode: "call-site-object" },
+  "api-interceptor-bridge": { contributionKinds: ["api-interceptor"], mode: "host-reference" },
+  "command-interceptor-bridge": { contributionKinds: ["command-interceptor"], mode: "owner-reference" },
+  "widget-injection-consumer": { contributionKinds: ["widget", "data-table", "crud-form"], mode: "host-reference" },
+  "component-extension-consumer": { contributionKinds: ["component-override"], mode: "host-reference" },
+  "dashboard-host-consumer": { contributionKinds: ["widget"], mode: "host-reference" }
+};
+const CONTRIBUTION_ACTIVATION_CLASSIFICATION = {
+  "response-enricher": ["crud-response-enricher", "query-enricher"],
+  "mutation-guard": ["mutation-guard"],
+  "api-interceptor": ["api-interceptor-bridge"],
+  "command-interceptor": ["command-interceptor-bridge"],
+  "widget": ["widget-injection-consumer", "dashboard-host-consumer"],
+  "data-table": ["widget-injection-consumer"],
+  "crud-form": ["widget-injection-consumer"],
+  "component-override": ["component-extension-consumer"],
+  "entity-extension": "capability-only",
+  "subscriber": "capability-only",
+  "browser-reaction": "capability-only",
+  "specialized-registry": "capability-only",
+  "module-override": "capability-only"
+};
+const ALL_ACTIVATION_KINDS = Object.keys(ACTIVATION_ADAPTERS);
+const ALL_CONTRIBUTION_KINDS = Object.keys(CONTRIBUTION_ACTIVATION_CLASSIFICATION);
+const MUTATION_GUARD_BRIDGE_ADAPTERS = {
+  runRouteMutationGuards: { resourceArgument: "input-property" },
+  validateCrudMutationGuard: { resourceArgument: "any-argument" },
+  runMutationGuards: { resourceArgument: "any-argument" }
+};
+const MUTATION_GUARD_SOURCE_DIRECTORIES = ["api", "lib"];
+const MUTATION_GUARD_OPERATIONS = /* @__PURE__ */ new Set(["create", "update", "delete", "custom"]);
+function toRegistryGuardOperation(operation) {
+  return operation === "custom" ? "update" : operation;
+}
+function readMutationGuardBridge(node, context) {
+  const callee = node.expression;
+  const calleeName = ts.isIdentifier(callee) ? callee.text : ts.isPropertyAccessExpression(callee) ? callee.name.text : null;
+  const adapter = calleeName ? MUTATION_GUARD_BRIDGE_ADAPTERS[calleeName] : void 0;
+  if (!adapter) return null;
+  const argumentObjects = node.arguments.map((argument) => staticValue(argument, context)).filter(isStaticObject);
+  const resourceObjects = adapter.resourceArgument === "input-property" ? argumentObjects.flatMap((argumentObject) => isStaticObject(argumentObject.input) ? [argumentObject.input] : []) : argumentObjects;
+  for (const resourceObject of resourceObjects) {
+    const entityId = stringValue(resourceObject.resourceKind) ?? stringValue(resourceObject.entityId);
+    if (!entityId) continue;
+    const declaredOperation = stringValue(resourceObject.operation);
+    const operations = declaredOperation && MUTATION_GUARD_OPERATIONS.has(declaredOperation) ? [toRegistryGuardOperation(declaredOperation)] : [];
+    return { entityId, operations };
+  }
+  return null;
+}
+function nodeLine(file, node) {
+  return file.getLineAndCharacterOfPosition(node.getStart(file)).line + 1;
+}
+function activationId(host, kind) {
+  const method = host.method ? `:${host.method}` : "";
+  return `${host.kind}:${host.id}${method}:${kind}`;
+}
+function sortActivations(activations) {
+  return [...activations].sort((left, right) => left.id.localeCompare(right.id));
+}
+function isQueryWithExtensionsCall(node, context) {
+  if (!ts.isCallExpression(node)) return false;
+  const callee = node.expression;
+  const calleeName = ts.isPropertyAccessExpression(callee) ? callee.name.text : ts.isIdentifier(callee) ? callee.text : null;
+  if (calleeName !== "query") return false;
+  const queryOptions = node.arguments[1] ? staticValue(node.arguments[1], context) : void 0;
+  return isStaticObject(queryOptions) && queryOptions.extensions !== void 0;
+}
+function extractCallSiteActivations(options) {
+  const activations = [];
+  const byId = /* @__PURE__ */ new Map();
+  const push = (activation) => {
+    const existing = byId.get(activation.id);
+    if (existing) {
+      if (!existing.operations || !activation.operations) {
+        delete existing.operations;
+      } else {
+        existing.operations = [.../* @__PURE__ */ new Set([...existing.operations, ...activation.operations])].sort((left, right) => left.localeCompare(right));
+      }
+      return;
+    }
+    byId.set(activation.id, activation);
+    activations.push(activation);
+  };
+  const scannedFiles = MUTATION_GUARD_SOURCE_DIRECTORIES.flatMap((directory) => sourceFilesBelow(path.join(options.moduleRoot, directory)));
+  for (const filePath of scannedFiles) {
+    const file = sourceFile(filePath);
+    if (!file) continue;
+    const context = buildStaticContext(file);
+    const sourcePath = portablePath(options.moduleRoot, options.sourceRoot, filePath);
+    const visit = (node) => {
+      if (ts.isPropertyAssignment(node) && propertyName(node.name) === "enrichers") {
+        const config = staticValue(node.initializer, context);
+        const entityId = isStaticObject(config) ? stringValue(config.entityId) : void 0;
+        if (entityId) {
+          const host = { kind: "entity", id: entityId, moduleId: options.moduleId };
+          push({
+            id: activationId(host, "crud-response-enricher"),
+            kind: "crud-response-enricher",
+            host,
+            contributionKinds: ["response-enricher"],
+            source: { sourcePath, line: nodeLine(file, node) }
+          });
+        }
+      }
+      if (isQueryWithExtensionsCall(node, context)) {
+        const entityId = stringValue(staticValue(node.arguments[0], context));
+        if (entityId) {
+          const host = { kind: "entity", id: entityId, moduleId: options.moduleId };
+          push({
+            id: activationId(host, "query-enricher"),
+            kind: "query-enricher",
+            host,
+            contributionKinds: ["response-enricher"],
+            source: { sourcePath, line: nodeLine(file, node) }
+          });
+        }
+      }
+      if (ts.isCallExpression(node)) {
+        const bridge = readMutationGuardBridge(node, context);
+        if (bridge) {
+          const host = { kind: "entity", id: bridge.entityId, moduleId: options.moduleId };
+          push({
+            id: activationId(host, "mutation-guard"),
+            kind: "mutation-guard",
+            host,
+            contributionKinds: ["mutation-guard"],
+            ...bridge.operations.length > 0 ? { operations: bridge.operations } : {},
+            source: { sourcePath, line: nodeLine(file, node) }
+          });
+        }
+      }
+      node.forEachChild(visit);
+    };
+    file.forEachChild(visit);
+  }
+  return sortActivations(activations);
+}
 function extractModuleExtensionFacts(options) {
   const declared = extractDeclaredHosts(options);
   const hosts = sortHosts([...declared.hosts, ...extractFactRefHosts(options)]);
@@ -1087,7 +1362,12 @@ function extractModuleExtensionFacts(options) {
     ...extractComponentOverrides(options),
     ...extractSpecializedRegistries(options)
   ]);
-  return { hosts, contributions, unresolved: declared.unresolved };
+  return {
+    hosts,
+    contributions,
+    unresolved: declared.unresolved,
+    activations: extractCallSiteActivations(options)
+  };
 }
 function patternMatches(pattern, targetId) {
   const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\\\{[^}]+\\\}/g, "[^:]+").replace(/\*/g, ".*");
@@ -1128,7 +1408,7 @@ function correlateExtensionTarget(targetFact, options) {
     return { id: targetFact.id, resolution: "fact-ref", factRef: { factSection: "events", factKey: targetFact.id } };
   }
   if (options.commandIds?.has(targetFact.id)) {
-    return factTarget(targetFact.id, "commands");
+    return factTarget(targetFact.id, "ownedContracts.command");
   }
   const route = [...options.apiRoutes].find((apiRoute) => apiRoute === targetFact.id || apiRoute.endsWith(`/${targetFact.id}`));
   if (route) return { id: targetFact.id, resolution: "fact-ref", factRef: { factSection: "apiRoutes", factKey: route } };
@@ -1164,11 +1444,343 @@ function correlateModuleExtensionFacts(options) {
     result[moduleId] = {
       hosts: sortHosts([...surface.hosts]),
       contributions: sortContributions(contributions),
-      unresolved: unresolved.sort((left, right) => left.key.localeCompare(right.key))
+      unresolved: unresolved.sort((left, right) => left.key.localeCompare(right.key)),
+      activations: sortActivations([...surface.activations ?? []])
+    };
+  }
+  return result;
+}
+function normalizeRouteId(routeId) {
+  return routeId.replace(/^\//, "");
+}
+const FRAMEWORK_HOST_OWNER = "framework";
+const FRAMEWORK_HOST_FAMILIES_BY_ACTIVATION = {
+  "dashboard-host-consumer": ["dashboard"],
+  "widget-injection-consumer": ["menu", "generic", "crud-form", "data-table", "notification", "integration"],
+  "component-extension-consumer": ["component-handle"]
+};
+function findFrameworkHost(targetId, activationKind) {
+  const families = FRAMEWORK_HOST_FAMILIES_BY_ACTIVATION[activationKind];
+  if (!families) return null;
+  const candidates = FRAMEWORK_HOSTS.filter((host) => families.includes(host.family));
+  const exact = candidates.find((host) => host.id === targetId);
+  if (exact) return exact;
+  return candidates.find((host) => host.resolution === "pattern" && patternMatches(host.id, targetId)) ?? null;
+}
+function operationsIntersect(activationOperations, contributionOperations) {
+  if (!activationOperations || activationOperations.length === 0) return true;
+  if (!contributionOperations || contributionOperations.length === 0) return true;
+  return contributionOperations.some((operation) => activationOperations.includes(operation));
+}
+function contributionSourceRef(contribution) {
+  return {
+    sourcePath: contribution.source.path,
+    ...contribution.source.symbol ? { exportName: contribution.source.symbol } : {}
+  };
+}
+function targetRefKindFor(contribution, targetId) {
+  if (targetId === "*" || targetId.includes("*") || targetId.includes("{")) return "wildcard";
+  switch (contribution.kind) {
+    case "response-enricher":
+    case "mutation-guard":
+    case "entity-extension":
+      return "entity";
+    case "api-interceptor":
+      return "api-route";
+    case "command-interceptor":
+      return "command";
+    case "component-override":
+      return "component";
+    case "subscriber":
+      return "event";
+    case "browser-reaction":
+      return contribution.details.transports.includes("notification-effect") ? "notification" : "event";
+    case "widget":
+    case "data-table":
+    case "crud-form":
+      return "widget-spot";
+    case "specialized-registry":
+    case "module-override":
+      return "module";
+    default:
+      return "module";
+  }
+}
+function correlateIncomingExtensions(options) {
+  const moduleIds = Object.keys(options.surfacesByModule).sort((left, right) => left.localeCompare(right));
+  const apiRouteOwners = options.apiRouteOwners ?? /* @__PURE__ */ new Map();
+  const commandOwners = options.commandOwners ?? /* @__PURE__ */ new Map();
+  const activationIndex = /* @__PURE__ */ new Map();
+  const activationKey = (kind, hostKind, id) => {
+    const normId = hostKind === "api-route" ? normalizeRouteId(id) : id;
+    return JSON.stringify([kind, hostKind, normId]);
+  };
+  const boundHostIndex = /* @__PURE__ */ new Map();
+  for (const moduleId of moduleIds) {
+    const surface = options.surfacesByModule[moduleId];
+    for (const activation of surface.activations ?? []) {
+      const key = activationKey(activation.kind, activation.host.kind, activation.host.id);
+      const bucket = activationIndex.get(key);
+      if (bucket) bucket.push({ moduleId, activation });
+      else activationIndex.set(key, [{ moduleId, activation }]);
+    }
+    for (const host of surface.hosts) {
+      if (!host.bound) continue;
+      if (!boundHostIndex.has(host.id)) boundHostIndex.set(host.id, { moduleId, host });
+    }
+  }
+  const incomingByModule = {};
+  const resolutionsByModule = {};
+  const syntheticActivations = {};
+  for (const moduleId of moduleIds) {
+    incomingByModule[moduleId] = [];
+    resolutionsByModule[moduleId] = [];
+    syntheticActivations[moduleId] = [];
+  }
+  const registerSyntheticActivation = (ownerModule, activation) => {
+    if (!syntheticActivations[ownerModule]) syntheticActivations[ownerModule] = [];
+    if (!syntheticActivations[ownerModule].some((entry) => entry.id === activation.id)) {
+      syntheticActivations[ownerModule].push(activation);
+    }
+  };
+  const findCallSiteActivations = (contributionKind, activationKinds, targetRef, contributionOperations) => {
+    const matches = [];
+    for (const kind of activationKinds) {
+      if (ACTIVATION_ADAPTERS[kind].mode !== "call-site-object") continue;
+      const bucket = activationIndex.get(activationKey(kind, targetRef.kind, targetRef.id)) ?? [];
+      for (const entry of bucket) {
+        if (!entry.activation.contributionKinds.includes(contributionKind)) continue;
+        if (!operationsIntersect(entry.activation.operations, contributionOperations)) continue;
+        matches.push(entry);
+      }
+    }
+    return matches.sort((left, right) => left.activation.id.localeCompare(right.activation.id));
+  };
+  for (const contributorModuleId of moduleIds) {
+    const surface = options.surfacesByModule[contributorModuleId];
+    for (const contribution of surface.contributions) {
+      const classification = CONTRIBUTION_ACTIVATION_CLASSIFICATION[contribution.kind];
+      for (const resolvedTarget of contribution.targets) {
+        const targetKind = targetRefKindFor(contribution, resolvedTarget.id);
+        const baseTarget = { kind: targetKind, id: resolvedTarget.id };
+        let resolution;
+        let ownerModule = null;
+        let boundActivationIds = [];
+        if (targetKind === "wildcard" || resolvedTarget.resolution === "pattern") {
+          resolution = "wildcard";
+        } else if (resolvedTarget.resolution === "optional-external") {
+          resolution = "optional-target-missing";
+        } else if (resolvedTarget.resolution === "unresolved") {
+          resolution = "unresolved";
+        } else {
+          const activationKinds = classification === "capability-only" ? [] : classification;
+          const callSiteMatches = findCallSiteActivations(
+            contribution.kind,
+            activationKinds,
+            baseTarget,
+            contribution.operations
+          );
+          if (callSiteMatches.length > 0) {
+            resolution = "bound";
+            ownerModule = callSiteMatches[0].moduleId;
+            boundActivationIds = callSiteMatches.map((entry) => entry.activation.id);
+          } else {
+            const referenceBinding = resolveReferenceBinding({
+              contribution,
+              activationKinds,
+              targetRef: baseTarget,
+              boundHostIndex,
+              apiRouteOwners,
+              commandOwners
+            });
+            if (referenceBinding) {
+              resolution = "bound";
+              const isFrameworkHost = referenceBinding.ownerModule === FRAMEWORK_HOST_OWNER;
+              ownerModule = isFrameworkHost ? null : referenceBinding.ownerModule;
+              const activationOwner = isFrameworkHost ? contributorModuleId : referenceBinding.ownerModule;
+              for (const activation of referenceBinding.activations) {
+                registerSyntheticActivation(activationOwner, activation);
+              }
+              boundActivationIds = referenceBinding.activations.map((activation) => activation.id);
+            } else {
+              const hostOwner = boundHostIndex.get(resolvedTarget.id);
+              if (hostOwner) {
+                resolution = "capability-only";
+                ownerModule = hostOwner.moduleId;
+              } else {
+                resolution = "capability-only";
+                ownerModule = null;
+              }
+            }
+          }
+        }
+        const resolutionTarget = ownerModule ? { ...baseTarget, moduleId: ownerModule } : baseTarget;
+        resolutionsByModule[contributorModuleId].push({
+          contributionId: contribution.id,
+          target: resolutionTarget,
+          resolution,
+          activationIds: [...boundActivationIds].sort((left, right) => left.localeCompare(right))
+        });
+        if (ownerModule && ownerModule !== contributorModuleId && (resolution === "bound" || resolution === "capability-only")) {
+          const source = contributionSourceRef(contribution);
+          const incomingTarget = { ...baseTarget, moduleId: ownerModule };
+          if (resolution === "bound" && boundActivationIds.length > 0) {
+            for (const activationRefId of boundActivationIds) {
+              incomingByModule[ownerModule].push({
+                contributionId: contribution.id,
+                contributionKind: contribution.kind,
+                contributorModuleId,
+                target: incomingTarget,
+                activationId: activationRefId,
+                resolution: "bound",
+                source
+              });
+            }
+          } else {
+            incomingByModule[ownerModule].push({
+              contributionId: contribution.id,
+              contributionKind: contribution.kind,
+              contributorModuleId,
+              target: incomingTarget,
+              resolution,
+              source
+            });
+          }
+        }
+      }
+    }
+  }
+  const result = {};
+  for (const moduleId of moduleIds) {
+    const surface = options.surfacesByModule[moduleId];
+    result[moduleId] = {
+      ...surface,
+      activations: sortActivations([...surface.activations ?? [], ...syntheticActivations[moduleId]]),
+      incoming: dedupeIncoming(incomingByModule[moduleId]),
+      contributionResolutions: sortResolutions(resolutionsByModule[moduleId])
     };
   }
   return result;
 }
+function matchApiInterceptorBridges(contribution, owner) {
+  if (contribution.kind !== "api-interceptor") return [];
+  const bridges = owner.bridges ?? [];
+  const declaredMethods = contribution.details.methods ?? [];
+  const declaredPhases = contribution.phases ?? [];
+  const matched = [];
+  for (const bridge of bridges) {
+    if (declaredMethods.length > 0 && !declaredMethods.includes(bridge.method)) continue;
+    const phases = declaredPhases.length > 0 ? bridge.phases.filter((phase) => declaredPhases.includes(phase)) : bridge.phases;
+    if (phases.length === 0) continue;
+    matched.push({ method: bridge.method, phases });
+  }
+  return matched;
+}
+function resolveReferenceBinding(input) {
+  for (const kind of input.activationKinds) {
+    const adapter = ACTIVATION_ADAPTERS[kind];
+    if (adapter.mode === "call-site-object") continue;
+    if (!adapter.contributionKinds.includes(input.contribution.kind)) continue;
+    if (adapter.mode === "host-reference" && kind === "api-interceptor-bridge") {
+      const routeId = normalizeRouteId(input.targetRef.id);
+      const owner = input.apiRouteOwners.get(routeId);
+      if (!owner) continue;
+      const matchedBridges = matchApiInterceptorBridges(input.contribution, owner);
+      if (matchedBridges.length === 0) continue;
+      return {
+        ownerModule: owner.moduleId,
+        activations: matchedBridges.map((bridge) => {
+          const host = {
+            kind: "api-route",
+            id: routeId,
+            moduleId: owner.moduleId,
+            method: bridge.method
+          };
+          return {
+            id: activationId(host, kind),
+            kind,
+            host,
+            contributionKinds: ["api-interceptor"],
+            phases: bridge.phases,
+            source: owner.source,
+            bridge: { factSection: "apiRoutes", factKey: `/${routeId}` }
+          };
+        })
+      };
+    }
+    if (adapter.mode === "owner-reference" && kind === "command-interceptor-bridge") {
+      const owner = input.commandOwners.get(input.targetRef.id);
+      if (!owner) continue;
+      const host = { kind: "command", id: input.targetRef.id, moduleId: owner.moduleId };
+      return {
+        ownerModule: owner.moduleId,
+        activations: [{
+          id: activationId(host, kind),
+          kind,
+          host,
+          contributionKinds: ["command-interceptor"],
+          source: owner.source,
+          bridge: { factSection: "ownedContracts.command", factKey: input.targetRef.id }
+        }]
+      };
+    }
+    if (adapter.mode === "host-reference" && (kind === "widget-injection-consumer" || kind === "component-extension-consumer" || kind === "dashboard-host-consumer")) {
+      const frameworkHostFact = input.boundHostIndex.has(input.targetRef.id) ? null : findFrameworkHost(input.targetRef.id, kind);
+      const hostEntry = input.boundHostIndex.get(input.targetRef.id) ?? (frameworkHostFact ? { moduleId: FRAMEWORK_HOST_OWNER, host: frameworkHostFact } : void 0);
+      if (!hostEntry) continue;
+      const hostSource = hostReferenceSource(hostEntry.host);
+      if (!hostSource) continue;
+      const host = { ...input.targetRef, moduleId: hostEntry.moduleId };
+      return {
+        ownerModule: hostEntry.moduleId,
+        activations: [{
+          id: activationId(host, kind),
+          kind,
+          host,
+          contributionKinds: adapter.contributionKinds,
+          source: hostSource,
+          bridge: { factSection: "hosts", factKey: hostEntry.host.key }
+        }]
+      };
+    }
+  }
+  return null;
+}
+function hostReferenceSource(host) {
+  if (host.source.kind === "declaration" || host.source.kind === "framework") {
+    return { sourcePath: host.source.path, exportName: host.source.symbol };
+  }
+  return null;
+}
+function incomingIdentity(entry) {
+  const target2 = JSON.stringify([entry.target.kind, entry.target.id]);
+  return JSON.stringify([entry.contributorModuleId, entry.contributionId, target2, entry.activationId ?? entry.resolution]);
+}
+function dedupeIncoming(entries) {
+  const seen = /* @__PURE__ */ new Set();
+  const unique = [];
+  for (const entry of entries) {
+    const identity = incomingIdentity(entry);
+    if (seen.has(identity)) continue;
+    seen.add(identity);
+    unique.push(entry);
+  }
+  return unique.sort((left, right) => incomingIdentity(left).localeCompare(incomingIdentity(right)));
+}
+function resolutionIdentity(entry) {
+  return JSON.stringify([entry.contributionId, entry.target.kind, entry.target.id, entry.resolution]);
+}
+function sortResolutions(entries) {
+  const seen = /* @__PURE__ */ new Set();
+  const unique = [];
+  for (const entry of entries) {
+    const identity = resolutionIdentity(entry);
+    if (seen.has(identity)) continue;
+    seen.add(identity);
+    unique.push(entry);
+  }
+  return unique.sort((left, right) => resolutionIdentity(left).localeCompare(resolutionIdentity(right)));
+}
 function assertNoUnresolvedExtensionTargets(surfacesByModule) {
   const unresolved = Object.entries(surfacesByModule).flatMap(
     ([moduleId, surface]) => surface.unresolved.filter((entry) => entry.reason === "unresolved-first-party-target").map((entry) => `${moduleId}:${entry.key}`)
@@ -1177,6 +1789,15 @@ function assertNoUnresolvedExtensionTargets(surfacesByModule) {
     throw new Error(`[module-facts] unresolved first-party extension targets: ${unresolved.join(", ")}`);
   }
 }
+function getFrameworkOverrideModes() {
+  const modes = {};
+  for (const host of FRAMEWORK_OVERRIDE_HOSTS) {
+    const dotted = host.key.replace(/^framework\.module-override\./, "");
+    const mode = host.operations?.[0];
+    if (mode === "disable-replace" || mode === "replace" || mode === "additive") modes[dotted] = mode;
+  }
+  return modes;
+}
 function getFrameworkExtensionHosts() {
   return sortHosts(allFrameworkHosts().map((host) => ({
     ...host,
@@ -1198,13 +1819,20 @@ function renderFrameworkExtensionPointsMarkdown() {
   ].join("\n");
 }
 export {
+  ACTIVATION_ADAPTERS,
+  ALL_ACTIVATION_KINDS,
+  ALL_CONTRIBUTION_KINDS,
+  CONTRIBUTION_ACTIVATION_CLASSIFICATION,
   assertNoUnresolvedExtensionTargets,
   correlateExtensionTarget,
+  correlateIncomingExtensions,
   correlateModuleExtensionFacts,
+  extractActivationTargetOwners,
   extractKnownApiRouteIds,
   extractKnownCommandIds,
   extractModuleExtensionFacts,
   getFrameworkExtensionHosts,
+  getFrameworkOverrideModes,
   readConventionObjectArray,
   renderFrameworkExtensionPointsMarkdown,
   withModuleExtensionFactExtractionCache