@open-mercato/cli 0.6.7 → 0.6.8-canary.319.1.5b4be4bc52

package/dist/lib/generators/module-override-targets.js

@@ -0,0 +1,688 @@
+import crypto from "node:crypto";
+import { buildFactSourceLookup } from "./module-fact-sources.js";
+import { getFrameworkOverrideModes } from "./module-extension-facts.js";
+const OVERRIDE_MODES = getFrameworkOverrideModes();
+function modesFor(dottedHost) {
+  const mode = OVERRIDE_MODES[dottedHost];
+  return mode ? [mode] : null;
+}
+function moduleIdOf(facts) {
+  const segments = facts.sourceRoot.split("/").filter(Boolean);
+  return segments[segments.length - 1] ?? "";
+}
+function computeOverrideTargetId(moduleId, domain, path) {
+  return crypto.createHash("sha1").update(JSON.stringify([moduleId, domain, path])).digest("hex").slice(0, 16);
+}
+function compareSourceRefs(left, right) {
+  return left.sourcePath.localeCompare(right.sourcePath) || (left.line ?? 0) - (right.line ?? 0) || (left.exportName ?? "").localeCompare(right.exportName ?? "");
+}
+function comparePaths(left, right) {
+  const length = Math.max(left.length, right.length);
+  for (let index = 0; index < length; index += 1) {
+    const leftSegment = left[index];
+    const rightSegment = right[index];
+    if (leftSegment === void 0) return -1;
+    if (rightSegment === void 0) return 1;
+    const compared = leftSegment.localeCompare(rightSegment);
+    if (compared !== 0) return compared;
+  }
+  return 0;
+}
+function makeTarget(input) {
+  const modes = modesFor(input.dottedHost);
+  if (!modes) return null;
+  const target = {
+    id: computeOverrideTargetId(input.moduleId, input.domain, input.path),
+    domain: input.domain,
+    ...input.key !== void 0 ? { key: input.key } : {},
+    path: input.path,
+    modes,
+    factRef: input.factRef,
+    source: input.source,
+    ...input.notes && input.notes.length > 0 ? { notes: input.notes } : {}
+  };
+  return target;
+}
+function pushTarget(targets, diagnostics, input) {
+  const target = makeTarget(input);
+  if (target) {
+    targets.push(target);
+    return;
+  }
+  diagnostics.push({
+    code: "unknown-framework-domain",
+    moduleId: input.moduleId,
+    domain: input.domain,
+    candidatePath: input.path,
+    source: input.source
+  });
+}
+function contributionSource(contribution) {
+  return {
+    sourcePath: contribution.source.path,
+    ...contribution.source.symbol ? { exportName: contribution.source.symbol } : {}
+  };
+}
+function ownedSource(fact) {
+  return {
+    sourcePath: fact.source.sourcePath,
+    ...fact.source.line ? { line: fact.source.line } : {}
+  };
+}
+function contributionsOfKind(facts, kind) {
+  const contributions = facts.extensionSurfaces?.contributions ?? [];
+  return contributions.filter(
+    (contribution) => contribution.kind === kind
+  );
+}
+function indexedFactSourcePath(resolveFactSource, kind, id) {
+  return resolveFactSource(kind, id)?.sourcePath ?? null;
+}
+const VALID_HTTP_METHODS = /* @__PURE__ */ new Set(["GET", "POST", "PUT", "PATCH", "DELETE"]);
+function apiRouteOverrideKey(method, routePath) {
+  const upper = method.trim().toUpperCase();
+  if (!VALID_HTTP_METHODS.has(upper)) return null;
+  const withLead = routePath.startsWith("/") ? routePath : `/${routePath}`;
+  const publicPath = withLead.startsWith("/api/") || withLead === "/api" ? withLead : `/api${withLead}`;
+  const normalized = publicPath.replace(/\/+$/, "") || "/";
+  return `${upper} ${normalized}`;
+}
+function pageRouteOverrideKey(routePath) {
+  const trimmed = routePath.trim();
+  if (!trimmed) return null;
+  if (trimmed.startsWith("backend:") || trimmed.startsWith("frontend:")) return trimmed;
+  const withLead = trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
+  const stripped = withLead.replace(/\/+$/, "") || "/";
+  if (stripped === "/frontend") return "frontend:/";
+  if (stripped.startsWith("/frontend/")) return `frontend:/${stripped.slice("/frontend/".length)}`;
+  if (stripped === "/backend" || stripped.startsWith("/backend/")) return `backend:${stripped}`;
+  return `frontend:${stripped}`;
+}
+const aiAdapter = {
+  domain: "ai",
+  run(facts) {
+    const moduleId = moduleIdOf(facts);
+    const targets = [];
+    const diagnostics = [];
+    for (const agent of facts.aiAgents) {
+      if (!agent.sourcePath) {
+        diagnostics.push({ code: "missing-source", moduleId, domain: "ai", candidatePath: ["ai", "agents", agent.id] });
+        continue;
+      }
+      const path = ["ai", "agents", agent.id];
+      pushTarget(targets, diagnostics, {
+        moduleId,
+        domain: "ai",
+        path,
+        key: agent.id,
+        dottedHost: "ai.agents",
+        factRef: { factSection: "aiAgents", factKey: agent.id },
+        source: { sourcePath: agent.sourcePath }
+      });
+    }
+    for (const tool of facts.aiTools) {
+      if (!tool.sourcePath) {
+        diagnostics.push({ code: "missing-source", moduleId, domain: "ai", candidatePath: ["ai", "tools", tool.name] });
+        continue;
+      }
+      const path = ["ai", "tools", tool.name];
+      pushTarget(targets, diagnostics, {
+        moduleId,
+        domain: "ai",
+        path,
+        key: tool.name,
+        dottedHost: "ai.tools",
+        factRef: { factSection: "aiTools", factKey: tool.name },
+        source: { sourcePath: tool.sourcePath }
+      });
+    }
+    const aiFileContracts = facts.ownedContracts?.["ai-extension"] ?? [];
+    const additiveExtensions = [];
+    for (const fact of aiFileContracts) {
+      const metadata = fact.metadata ?? {};
+      if (metadata.mode !== "override") {
+        additiveExtensions.push(fact);
+        continue;
+      }
+      const overrideKey = typeof metadata.overrideKey === "string" ? metadata.overrideKey : null;
+      const target = metadata.target === "agent" ? "agents" : metadata.target === "tool" ? "tools" : null;
+      if (!overrideKey || !target) {
+        diagnostics.push({
+          code: "unsupported-dynamic-key",
+          moduleId,
+          domain: "ai",
+          candidatePath: ["ai", target ?? "extensions"],
+          source: ownedSource(fact)
+        });
+        continue;
+      }
+      const path = ["ai", target, overrideKey];
+      pushTarget(targets, diagnostics, {
+        moduleId,
+        domain: "ai",
+        path,
+        key: overrideKey,
+        dottedHost: `ai.${target}`,
+        factRef: { factSection: "ownedContracts.ai-extension", factKey: fact.id },
+        source: ownedSource(fact)
+      });
+    }
+    if (additiveExtensions.length > 0) {
+      const anchor = [...additiveExtensions].sort((left, right) => left.id.localeCompare(right.id))[0];
+      pushTarget(targets, diagnostics, {
+        moduleId,
+        domain: "ai",
+        path: ["ai", "extensions"],
+        dottedHost: "ai.extensions",
+        factRef: { factSection: "ownedContracts.ai-extension", factKey: anchor.id },
+        source: ownedSource(anchor)
+      });
+    }
+    return { targets, diagnostics };
+  }
+};
+const routesAdapter = {
+  domain: "routes",
+  run(facts) {
+    const moduleId = moduleIdOf(facts);
+    const targets = [];
+    const diagnostics = [];
+    for (const route of facts.apiRoutes) {
+      for (const method of route.methods) {
+        const key = apiRouteOverrideKey(method, route.path);
+        if (!key) {
+          diagnostics.push({ code: "unsupported-dynamic-key", moduleId, domain: "routes", candidatePath: ["routes", "api", `${method} ${route.path}`] });
+          continue;
+        }
+        if (!route.sourcePath) {
+          diagnostics.push({ code: "missing-source", moduleId, domain: "routes", candidatePath: ["routes", "api", key] });
+          continue;
+        }
+        const path = ["routes", "api", key];
+        pushTarget(targets, diagnostics, {
+          moduleId,
+          domain: "routes",
+          path,
+          key,
+          dottedHost: "routes.api",
+          factRef: { factSection: "apiRoutes", factKey: route.path },
+          source: { sourcePath: route.sourcePath }
+        });
+      }
+    }
+    const emitPage = (page, section) => {
+      const key = pageRouteOverrideKey(page.path);
+      if (!key) {
+        diagnostics.push({ code: "unsupported-dynamic-key", moduleId, domain: "routes", candidatePath: ["routes", "pages", page.path] });
+        return;
+      }
+      if (!page.sourcePath) {
+        diagnostics.push({ code: "missing-source", moduleId, domain: "routes", candidatePath: ["routes", "pages", key] });
+        return;
+      }
+      const path = ["routes", "pages", key];
+      pushTarget(targets, diagnostics, {
+        moduleId,
+        domain: "routes",
+        path,
+        key,
+        dottedHost: "routes.pages",
+        factRef: { factSection: section, factKey: page.path },
+        source: { sourcePath: page.sourcePath }
+      });
+    };
+    for (const page of facts.backendPages) emitPage(page, "backendPages");
+    for (const page of facts.frontendPages) emitPage(page, "frontendPages");
+    return { targets, diagnostics };
+  }
+};
+const eventsAdapter = {
+  domain: "events",
+  run(facts) {
+    const moduleId = moduleIdOf(facts);
+    const targets = [];
+    const diagnostics = [];
+    for (const contribution of contributionsOfKind(facts, "subscriber")) {
+      const subscriberId = contribution.details.subscriberId || contribution.id;
+      const path = ["events", "subscribers", subscriberId];
+      if (!contribution.source.path) {
+        diagnostics.push({ code: "missing-source", moduleId, domain: "events", candidatePath: path });
+        continue;
+      }
+      pushTarget(targets, diagnostics, {
+        moduleId,
+        domain: "events",
+        path,
+        key: subscriberId,
+        dottedHost: "events.subscribers",
+        factRef: { factSection: "extensionSurfaces.contributions", factKey: contribution.id },
+        source: contributionSource(contribution)
+      });
+    }
+    return { targets, diagnostics };
+  }
+};
+const workersAdapter = {
+  domain: "workers",
+  run(facts) {
+    const moduleId = moduleIdOf(facts);
+    const targets = [];
+    const diagnostics = [];
+    for (const fact of facts.ownedContracts?.worker ?? []) {
+      const path = ["workers", fact.id];
+      if (!fact.source.sourcePath) {
+        diagnostics.push({ code: "missing-source", moduleId, domain: "workers", candidatePath: path });
+        continue;
+      }
+      pushTarget(targets, diagnostics, {
+        moduleId,
+        domain: "workers",
+        path,
+        key: fact.id,
+        dottedHost: "workers",
+        factRef: { factSection: "ownedContracts.worker", factKey: fact.id },
+        source: ownedSource(fact)
+      });
+    }
+    return { targets, diagnostics };
+  }
+};
+const widgetsAdapter = {
+  domain: "widgets",
+  run(facts) {
+    const moduleId = moduleIdOf(facts);
+    const targets = [];
+    const diagnostics = [];
+    const emitInjection = (registryKey, contribution) => {
+      const path = ["widgets", "injection", registryKey];
+      pushTarget(targets, diagnostics, {
+        moduleId,
+        domain: "widgets",
+        path,
+        key: registryKey,
+        dottedHost: "widgets.injection",
+        factRef: { factSection: "extensionSurfaces.contributions", factKey: contribution.id },
+        source: contributionSource(contribution)
+      });
+    };
+    for (const contribution of contributionsOfKind(facts, "widget")) {
+      const registryKey = contribution.details.registryKey;
+      if (!registryKey) {
+        diagnostics.push({ code: "unsupported-dynamic-key", moduleId, domain: "widgets", candidatePath: ["widgets", "injection", contribution.id] });
+        continue;
+      }
+      if (contribution.details.payload === "dashboard") {
+        const path = ["widgets", "dashboard", registryKey];
+        pushTarget(targets, diagnostics, {
+          moduleId,
+          domain: "widgets",
+          path,
+          key: registryKey,
+          dottedHost: "widgets.dashboard",
+          factRef: { factSection: "extensionSurfaces.contributions", factKey: contribution.id },
+          source: contributionSource(contribution)
+        });
+      } else {
+        emitInjection(registryKey, contribution);
+      }
+    }
+    for (const contribution of [
+      ...contributionsOfKind(facts, "data-table"),
+      ...contributionsOfKind(facts, "crud-form")
+    ]) {
+      const registryKey = contribution.id.split("@")[0];
+      if (!registryKey || registryKey === contribution.id) {
+        diagnostics.push({ code: "unsupported-dynamic-key", moduleId, domain: "widgets", candidatePath: ["widgets", "injection", contribution.id] });
+        continue;
+      }
+      emitInjection(registryKey, contribution);
+    }
+    for (const contribution of contributionsOfKind(facts, "component-override")) {
+      const componentId = contribution.details.handle;
+      const path = ["widgets", "components", componentId];
+      pushTarget(targets, diagnostics, {
+        moduleId,
+        domain: "widgets",
+        path,
+        key: componentId,
+        dottedHost: "widgets.components",
+        factRef: { factSection: "extensionSurfaces.contributions", factKey: contribution.id },
+        source: contributionSource(contribution)
+      });
+    }
+    return { targets, diagnostics };
+  }
+};
+const notificationsAdapter = {
+  domain: "notifications",
+  run(facts, resolveFactSource) {
+    const moduleId = moduleIdOf(facts);
+    const targets = [];
+    const diagnostics = [];
+    const registrySources = /* @__PURE__ */ new Map();
+    for (const contribution of contributionsOfKind(facts, "specialized-registry")) {
+      if (contribution.details.registry !== "notification") continue;
+      registrySources.set(contribution.details.registryId, contributionSource(contribution));
+    }
+    for (const type of facts.notifications) {
+      const path = ["notifications", "types", type];
+      const indexedPath = indexedFactSourcePath(resolveFactSource, "notification", type);
+      const source = registrySources.get(type) ?? (indexedPath ? { sourcePath: indexedPath } : null);
+      if (!source) {
+        diagnostics.push({ code: "missing-source", moduleId, domain: "notifications", candidatePath: path });
+        continue;
+      }
+      pushTarget(targets, diagnostics, {
+        moduleId,
+        domain: "notifications",
+        path,
+        key: type,
+        dottedHost: "notifications.types",
+        factRef: { factSection: "notifications", factKey: type },
+        source
+      });
+    }
+    for (const contribution of contributionsOfKind(facts, "browser-reaction")) {
+      if (!contribution.details.transports.includes("notification-effect")) continue;
+      const overrideKey = contribution.details.overrideKey;
+      if (!overrideKey) {
+        diagnostics.push({
+          code: "unsupported-dynamic-key",
+          moduleId,
+          domain: "notifications",
+          candidatePath: ["notifications", "handlers"],
+          source: contributionSource(contribution)
+        });
+        continue;
+      }
+      pushTarget(targets, diagnostics, {
+        moduleId,
+        domain: "notifications",
+        path: ["notifications", "handlers", overrideKey],
+        key: overrideKey,
+        dottedHost: "notifications.handlers",
+        factRef: { factSection: "extensionSurfaces.contributions", factKey: contribution.id },
+        source: contributionSource(contribution)
+      });
+    }
+    return { targets, diagnostics };
+  }
+};
+function contributionIdAdapter(domain, kind, dottedHost) {
+  return {
+    domain,
+    run(facts) {
+      const moduleId = moduleIdOf(facts);
+      const targets = [];
+      const diagnostics = [];
+      for (const contribution of contributionsOfKind(facts, kind)) {
+        const path = [domain, contribution.id];
+        if (!contribution.source.path) {
+          diagnostics.push({ code: "missing-source", moduleId, domain, candidatePath: path });
+          continue;
+        }
+        pushTarget(targets, diagnostics, {
+          moduleId,
+          domain,
+          path,
+          key: contribution.id,
+          dottedHost,
+          factRef: { factSection: "extensionSurfaces.contributions", factKey: contribution.id },
+          source: contributionSource(contribution)
+        });
+      }
+      return { targets, diagnostics };
+    }
+  };
+}
+const interceptorsAdapter = contributionIdAdapter("interceptors", "api-interceptor", "interceptors");
+const commandInterceptorsAdapter = contributionIdAdapter("commandInterceptors", "command-interceptor", "commandInterceptors");
+const enrichersAdapter = contributionIdAdapter("enrichers", "response-enricher", "enrichers");
+const guardsAdapter = {
+  domain: "guards",
+  run(facts) {
+    const moduleId = moduleIdOf(facts);
+    const targets = [];
+    const diagnostics = [];
+    for (const fact of facts.ownedContracts?.["page-middleware"] ?? []) {
+      const path = ["guards", fact.id];
+      if (!fact.source.sourcePath) {
+        diagnostics.push({ code: "missing-source", moduleId, domain: "guards", candidatePath: path });
+        continue;
+      }
+      pushTarget(targets, diagnostics, {
+        moduleId,
+        domain: "guards",
+        path,
+        key: fact.id,
+        dottedHost: "guards",
+        factRef: { factSection: "ownedContracts.page-middleware", factKey: fact.id },
+        source: ownedSource(fact),
+        notes: ["page-middleware-not-mutation-guard"]
+      });
+    }
+    return { targets, diagnostics };
+  }
+};
+const cliAdapter = {
+  domain: "cli",
+  run(facts) {
+    const moduleId = moduleIdOf(facts);
+    const targets = [];
+    const diagnostics = [];
+    for (const command of facts.cliCommands) {
+      const path = ["cli", command.command];
+      if (!command.sourcePath) {
+        diagnostics.push({ code: "missing-source", moduleId, domain: "cli", candidatePath: path });
+        continue;
+      }
+      pushTarget(targets, diagnostics, {
+        moduleId,
+        domain: "cli",
+        path,
+        key: command.command,
+        dottedHost: "cli",
+        factRef: { factSection: "cliCommands", factKey: command.command },
+        source: { sourcePath: command.sourcePath }
+      });
+    }
+    return { targets, diagnostics };
+  }
+};
+const SUPPORTED_SETUP_HOOKS = /* @__PURE__ */ new Set(["seedDefaults", "seedExamples", "onTenantCreated"]);
+const setupAdapter = {
+  domain: "setup",
+  run(facts) {
+    const moduleId = moduleIdOf(facts);
+    const targets = [];
+    const diagnostics = [];
+    const setupFacts = facts.ownedContracts?.setup ?? [];
+    for (const fact of setupFacts) {
+      if (!fact.source.sourcePath) {
+        diagnostics.push({ code: "missing-source", moduleId, domain: "setup", candidatePath: ["setup"] });
+        continue;
+      }
+      const source = ownedSource(fact);
+      const properties = [];
+      const hooks = fact.metadata?.hooks;
+      if (Array.isArray(hooks)) {
+        for (const hook of hooks) {
+          if (typeof hook === "string" && SUPPORTED_SETUP_HOOKS.has(hook)) properties.push(hook);
+        }
+      }
+      const roles = fact.metadata?.roles;
+      if (Array.isArray(roles) && roles.length > 0) properties.push("defaultRoleFeatures");
+      const customerRoles = fact.metadata?.customerRoles;
+      if (Array.isArray(customerRoles) && customerRoles.length > 0) properties.push("defaultCustomerRoleFeatures");
+      for (const property of properties) {
+        const path = ["setup", property];
+        pushTarget(targets, diagnostics, {
+          moduleId,
+          domain: "setup",
+          path,
+          dottedHost: "setup",
+          factRef: { factSection: "ownedContracts.setup", factKey: fact.id },
+          source
+        });
+      }
+    }
+    return { targets, diagnostics };
+  }
+};
+const aclAdapter = {
+  domain: "acl",
+  run(facts, resolveFactSource) {
+    const moduleId = moduleIdOf(facts);
+    const targets = [];
+    const diagnostics = [];
+    for (const feature of facts.aclFeatures) {
+      const path = ["acl", "features", feature];
+      const sourcePath = indexedFactSourcePath(resolveFactSource, "acl-feature", feature);
+      if (!sourcePath) {
+        diagnostics.push({ code: "missing-source", moduleId, domain: "acl", candidatePath: path });
+        continue;
+      }
+      pushTarget(targets, diagnostics, {
+        moduleId,
+        domain: "acl",
+        path,
+        key: feature,
+        dottedHost: "acl.features",
+        factRef: { factSection: "aclFeatures", factKey: feature },
+        source: { sourcePath }
+      });
+    }
+    return { targets, diagnostics };
+  }
+};
+const diAdapter = {
+  domain: "di",
+  run(facts) {
+    const moduleId = moduleIdOf(facts);
+    const targets = [];
+    const diagnostics = [];
+    for (const fact of facts.ownedContracts?.["di-registration"] ?? []) {
+      const path = ["di", fact.id];
+      if (!fact.source.sourcePath) {
+        diagnostics.push({ code: "missing-source", moduleId, domain: "di", candidatePath: path });
+        continue;
+      }
+      pushTarget(targets, diagnostics, {
+        moduleId,
+        domain: "di",
+        path,
+        key: fact.id,
+        dottedHost: "di",
+        factRef: { factSection: "ownedContracts.di-registration", factKey: fact.id },
+        source: ownedSource(fact),
+        notes: ["safe-metadata-only"]
+      });
+    }
+    return { targets, diagnostics };
+  }
+};
+const encryptionAdapter = {
+  domain: "encryption",
+  run(facts) {
+    const moduleId = moduleIdOf(facts);
+    const targets = [];
+    const diagnostics = [];
+    for (const fact of facts.ownedContracts?.encryption ?? []) {
+      const path = ["encryption", "maps", fact.id];
+      if (!fact.source.sourcePath) {
+        diagnostics.push({ code: "missing-source", moduleId, domain: "encryption", candidatePath: path });
+        continue;
+      }
+      pushTarget(targets, diagnostics, {
+        moduleId,
+        domain: "encryption",
+        path,
+        key: fact.id,
+        dottedHost: "encryption.maps",
+        factRef: { factSection: "ownedContracts.encryption", factKey: fact.id },
+        source: ownedSource(fact)
+      });
+    }
+    return { targets, diagnostics };
+  }
+};
+const navAdapter = {
+  domain: "nav",
+  frameworkOnly: true,
+  run() {
+    return { targets: [], diagnostics: [] };
+  }
+};
+const INTERNAL_ADAPTERS = [
+  aiAdapter,
+  routesAdapter,
+  eventsAdapter,
+  workersAdapter,
+  widgetsAdapter,
+  notificationsAdapter,
+  interceptorsAdapter,
+  commandInterceptorsAdapter,
+  enrichersAdapter,
+  guardsAdapter,
+  cliAdapter,
+  setupAdapter,
+  aclAdapter,
+  diAdapter,
+  encryptionAdapter,
+  navAdapter
+];
+const OVERRIDE_DOMAIN_PRESENCE = {
+  ai: true,
+  routes: true,
+  events: true,
+  workers: true,
+  widgets: true,
+  notifications: true,
+  interceptors: true,
+  commandInterceptors: true,
+  enrichers: true,
+  guards: true,
+  cli: true,
+  setup: true,
+  acl: true,
+  di: true,
+  encryption: true,
+  nav: true
+};
+const ALL_OVERRIDE_DOMAINS = Object.keys(OVERRIDE_DOMAIN_PRESENCE);
+const MODULE_OVERRIDE_TARGET_ADAPTERS = INTERNAL_ADAPTERS.map((adapter) => ({
+  domain: adapter.domain,
+  ...adapter.frameworkOnly ? { frameworkOnly: true } : {},
+  collect: (moduleFacts) => adapter.run(moduleFacts, buildFactSourceLookup(moduleFacts)).targets,
+  diagnose: (moduleFacts) => adapter.run(moduleFacts, buildFactSourceLookup(moduleFacts)).diagnostics
+}));
+function collectModuleOverrideTargets(facts, resolveFactSource = buildFactSourceLookup(facts)) {
+  const collected = [];
+  const diagnostics = [];
+  for (const adapter of INTERNAL_ADAPTERS) {
+    if (adapter.frameworkOnly) continue;
+    const result = adapter.run(facts, resolveFactSource);
+    collected.push(...result.targets);
+    diagnostics.push(...result.diagnostics);
+  }
+  const byPath = /* @__PURE__ */ new Map();
+  for (const target of collected) {
+    const pathKey = `${target.domain} ${JSON.stringify(target.path)}`;
+    const existing = byPath.get(pathKey);
+    if (!existing || compareSourceRefs(target.source, existing.source) < 0) byPath.set(pathKey, target);
+  }
+  const overrideTargets = [...byPath.values()].sort(
+    (left, right) => left.domain.localeCompare(right.domain) || comparePaths(left.path, right.path) || compareSourceRefs(left.source, right.source)
+  );
+  const overrideTargetDiagnostics = diagnostics.sort(
+    (left, right) => left.moduleId.localeCompare(right.moduleId) || left.domain.localeCompare(right.domain) || left.code.localeCompare(right.code) || comparePaths(left.candidatePath ?? [], right.candidatePath ?? []) || compareSourceRefs(left.source ?? { sourcePath: "" }, right.source ?? { sourcePath: "" })
+  );
+  return { overrideTargets, overrideTargetDiagnostics };
+}
+export {
+  ALL_OVERRIDE_DOMAINS,
+  MODULE_OVERRIDE_TARGET_ADAPTERS,
+  collectModuleOverrideTargets,
+  computeOverrideTargetId
+};
+//# sourceMappingURL=module-override-targets.js.map