@usefragments/core 1.11.0 → 2.0.1

package/src/identity/usage.test.ts

@@ -0,0 +1,64 @@
+import { describe, expect, it } from "vitest";
+import {
+  FactIndex,
+  asComponentId,
+  makeComponentDefinitionFact,
+  makeUsageComponentFact,
+  makeUsageNodeFact,
+} from "../index.js";
+import { indexComponentIdentityUsage } from "./usage.js";
+
+describe("component identity usage joins", () => {
+  const key = "src/Button.tsx#Button";
+  const catalogId = asComponentId("cloud:source#source::src/Button.tsx::Button");
+
+  it("preserves fact identity and counts a node once with exact definition evidence", () => {
+    const ix = new FactIndex();
+    const node = makeUsageNodeFact({
+      file: "src/App.tsx",
+      nodePath: "0:0",
+      element: "Button",
+      location: { file: "src/App.tsx", line: 1, column: 0 },
+    });
+    const original = makeUsageComponentFact({ nodeId: node.id, componentId: catalogId });
+    const resolved = makeUsageComponentFact({
+      nodeId: node.id,
+      componentId: catalogId,
+      definitionKey: key,
+    });
+    expect(resolved.id).toBe(original.id);
+    ix.addMany([
+      node,
+      resolved,
+      makeUsageComponentFact({ nodeId: node.id, componentId: asComponentId(key) }),
+      makeComponentDefinitionFact({
+        file: "src/Button.tsx",
+        exportName: "Button",
+        componentKey: key,
+        propSurface: [],
+        renderRoot: { resolution: "intrinsic", tag: "button" },
+      }),
+    ]);
+    expect(indexComponentIdentityUsage(ix).get(key)).toMatchObject({
+      usageCount: 1,
+      blastRadius: 1,
+    });
+    expect(indexComponentIdentityUsage(ix).has(catalogId)).toBe(false);
+  });
+
+  it("does not synthesize a definition from catalog evidence", () => {
+    const ix = new FactIndex();
+    const node = makeUsageNodeFact({
+      file: "src/App.tsx",
+      nodePath: "0:0",
+      element: "Button",
+      location: { file: "src/App.tsx", line: 1, column: 0 },
+    });
+    ix.addMany([
+      node,
+      makeUsageComponentFact({ nodeId: node.id, componentId: catalogId, definitionKey: key }),
+    ]);
+    expect(indexComponentIdentityUsage(ix).has(key)).toBe(false);
+    expect(indexComponentIdentityUsage(ix).get(catalogId)?.usageCount).toBe(1);
+  });
+});

package/src/identity/usage.ts

@@ -12,12 +12,18 @@ export function indexComponentIdentityUsage(
   ix: FactIndex
 ): ReadonlyMap<string, ComponentIdentityUsage> {
   const nodesById = new Map(ix.byKind("usage_node").map((node) => [node.id, node]));
+  const definitions = new Set(
+    ix.byKind("component_definition").map((definition) => definition.componentKey)
+  );
   const nodesByComponent = new Map<string, Map<string, UsageNodeFact>>();
 
   for (const usage of ix.byKind("usage_component")) {
     const node = nodesById.get(usage.nodeId);
     if (!node) continue;
-    const componentKey = String(usage.componentId);
+    const componentKey =
+      usage.definitionKey && definitions.has(usage.definitionKey)
+        ? usage.definitionKey
+        : String(usage.componentId);
     const nodes = nodesByComponent.get(componentKey) ?? new Map<string, UsageNodeFact>();
     nodes.set(node.id, node);
     nodesByComponent.set(componentKey, nodes);

package/src/index.ts

@@ -508,6 +508,7 @@ export type { InferProps } from "./defineFragment.js";
 export {
   componentGovernanceRecordSchema,
   componentGovernanceRecordsSchema,
+  parseComponentGovernancePolicyJson,
   canonicalBridgeV1Schema,
   g,
   globalGovernanceRecordSchema,
@@ -683,6 +684,11 @@ export {
   type RuleConfigView,
 } from "./rules/rule-config.js";
 export { indexComponentIdentityUsage, type ComponentIdentityUsage } from "./identity/usage.js";
+export {
+  isCanonicalSourceDefinition,
+  canonicalSourceContainsFile,
+  canonicalSourceIncludesExport,
+} from "./canonical-source.js";
 export { nearestSignedScaleValue } from "./rules/utils.js";
 export {
   buildSpacingTokenLookup,
@@ -1060,25 +1066,11 @@ export {
   mintEvaluationReceiptId,
   evaluationReceiptIdSchema,
   evaluationReceiptIdStringSchema,
-  featurePlanIdFromEntropy,
-  featurePlanIdSchema,
-  featurePlanIdStringSchema,
-  featureRevisionIdFromDigest,
-  featureRevisionIdSchema,
-  featureRevisionIdStringSchema,
   parseAnalysisPlanId,
   parseDigestHex,
   parseEvaluationReceiptId,
-  parseFeaturePlanId,
-  parseFeatureRevisionId,
-} from "./domain-ids.js";
-export type {
-  AnalysisPlanId,
-  DigestHex,
-  EvaluationReceiptId,
-  FeaturePlanId,
-  FeatureRevisionId,
 } from "./domain-ids.js";
+export type { AnalysisPlanId, DigestHex, EvaluationReceiptId } from "./domain-ids.js";
 export {
   PROVIDER_ID_MAX_BYTES_V1,
   REPOSITORY_BINDING_ID_MAX_BYTES_V1,
@@ -1118,70 +1110,6 @@ export type {
   CoverageSummaryV1,
 } from "./analysis-plan/index.js";
 
-export {
-  AGENT_FEATURE_CONTEXT_MAX_BYTES_V1,
-  FEATURE_PLAN_MAX_ACCEPTANCE_ITEMS_V1,
-  FEATURE_PLAN_MAX_DECISIONS_V1,
-  FEATURE_PLAN_MAX_EVIDENCE_REFS_V1,
-  FEATURE_PLAN_MAX_GAPS_V1,
-  FEATURE_PLAN_MAX_SCENARIOS_V1,
-  FEATURE_PLAN_MAX_TEXT_BYTES_V1,
-  FEATURE_PLAN_MAX_USES_PER_KIND_V1,
-  agentFeatureContextV1Schema,
-  approvedFeatureManifestInputV1Schema,
-  approvedFeatureManifestRevisionDigestV1,
-  approvedFeatureManifestV1Schema,
-  buildApprovedFeatureManifestV1,
-  buildFeatureProposalV1,
-  capabilityGapV1Schema,
-  componentUseDecisionV1Schema,
-  decisionRequestV1Schema,
-  decisionResolutionV1Schema,
-  evidenceRefV1Schema,
-  featureAcceptanceItemV1Schema,
-  featurePinsV1Schema,
-  featureProposalInputV1Schema,
-  featureProposalRevisionDigestV1,
-  featureProposalV1Schema,
-  gapDispositionV1Schema,
-  layoutConcernV1Schema,
-  layoutOwnershipV1Schema,
-  normalizeApprovedFeatureManifestInputV1,
-  normalizeFeatureProposalInputV1,
-  parseAgentFeatureContextV1,
-  parseApprovedFeatureManifestV1,
-  parseFeatureProposalV1,
-  patternStatusV1Schema,
-  patternUseDecisionV1Schema,
-  placementDecisionV1Schema,
-  responsiveDecisionV1Schema,
-  scenarioRequirementV1Schema,
-  tokenUseDecisionV1Schema,
-} from "./feature-plan/index.js";
-export type {
-  AgentFeatureContextV1,
-  ApprovedFeatureManifestInputV1,
-  ApprovedFeatureManifestV1,
-  CapabilityGapV1,
-  ComponentUseDecisionV1,
-  DecisionRequestV1,
-  DecisionResolutionV1,
-  EvidenceRefV1,
-  FeatureAcceptanceItemV1,
-  FeaturePinsV1,
-  FeatureProposalInputV1,
-  FeatureProposalV1,
-  GapDispositionV1,
-  LayoutConcernV1,
-  LayoutOwnershipV1,
-  PatternStatusV1,
-  PatternUseDecisionV1,
-  PlacementDecisionV1,
-  ResponsiveDecisionV1,
-  ScenarioRequirementV1,
-  TokenUseDecisionV1,
-} from "./feature-plan/index.js";
-
 // Topology — map file paths to product areas (area-scoped governance).
 // Also available at the `@usefragments/core/topology` subpath.
 export { resolveArea } from "./topology/index.js";
@@ -1203,6 +1131,8 @@ export {
   EVALUATOR_VERSION_V2,
   effectiveEvaluationWaiverV2Schema,
   evaluate,
+  evaluationInputDigestV2,
+  evaluationResultDigestV2,
   evaluationInputV2Schema,
   evaluationReceiptDigestV1,
   evaluationReceiptMintInputV1Schema,
@@ -1245,3 +1175,9 @@ export type {
   ProviderProofSemanticV1,
   ProviderProofV1,
 } from "./evaluation/index.js";
+
+export {
+  APPROVED_CONTRACT_TOKEN_MAX_NAMES,
+  APPROVED_CONTRACT_TOKEN_MAX_NAME_LENGTH,
+  isApprovedContractTokenNames,
+} from "./approved-contract-tokens.js";

package/src/rules/components-prefer-library.ts

@@ -2,6 +2,8 @@ import type { CanonicalSource, GovernanceSeverity } from "../governance.js";
 import type {
   FactId,
   FactIndex,
+  ComponentDefinitionFact,
+  FactLocation,
   UsageImportFact,
   UsageNodeFact,
   UsagePropResolvedFact,
@@ -15,6 +17,8 @@ import {
   type RawHtmlPrecisionTier,
 } from "../raw-html-canonical.js";
 import { ownedImportMatchesRoot, ownedImportsEqual } from "../package-identity-match.js";
+import { indexComponentIdentityUsage } from "../identity/usage.js";
+import { canonicalSourceContainsFile, canonicalSourceIncludesExport } from "../canonical-source.js";
 import {
   canonicalDirectionConflictsTarget,
   projectCanonicalDirectionConflicts,
@@ -262,6 +266,13 @@ export function ruleComponentsPreferLibrary(ix: FactIndex): Finding[] {
   const configuredSources = canonicalSourcesFromPolicy(policy.options?.canonicalSources);
   const conflicts = projectCanonicalDirectionConflicts(ix, configuredSources);
   const sources = configuredSources.map((source) => suppressConflictedExports(source, conflicts));
+  const approvedLocalDefinitionKeys = Array.isArray(policy.options?.approvedLocalDefinitionKeys)
+    ? new Set(
+        policy.options.approvedLocalDefinitionKeys.filter(
+          (key): key is string => typeof key === "string"
+        )
+      )
+    : undefined;
   const mappings = canonicalMappingsFromPolicy(policy.options?.canonicalMappings).filter(
     (mapping) => !canonicalDirectionConflictsTarget(conflicts, mapping.importPath, mapping.name)
   );
@@ -278,16 +289,41 @@ export function ruleComponentsPreferLibrary(ix: FactIndex): Finding[] {
   // canonical primitives imported by a relative/`@/` path; a browser-safe string
   // comparison of the raw specifier could never recognize them, so the resolved
   // fact is the identity of record. Never flag them as import impostors.
-  const canonicalDirectoryResolvedNodes = indexCanonicalDirectoryResolvedNodes(ix, sources);
+  const canonicalDirectoryResolvedNodes = indexCanonicalDirectoryResolvedNodes(
+    ix,
+    sources,
+    approvedLocalDefinitionKeys
+  );
   const shadowRenderRootNodeIds =
     ix.policy.ruleConfig("components/shadow-component")?.enabled === true
       ? indexShadowRenderRootNodeIds(ix)
       : new Set<FactId>();
   const findings: Finding[] = [];
   const seenImportFixes = new Set<string>();
+  const canonicalIdentities = new Map(
+    ix
+      .byKind("component_identity")
+      .map((identity) => [identity.componentKey, identity.state === "canonical"])
+  );
+  const definitionsByFile = new Map<string, ComponentDefinitionFact[]>();
+  for (const definition of ix.byKind("component_definition")) {
+    const file = normalizePath(definition.file);
+    const definitions = definitionsByFile.get(file) ?? [];
+    definitions.push(definition);
+    definitionsByFile.set(file, definitions);
+  }
 
   for (const node of ix.byKind("usage_node")) {
-    if (isCanonicalSourceImplementationFile(node.file, sources)) continue;
+    if (
+      isCanonicalSourceImplementation(
+        node,
+        sources,
+        definitionsByFile,
+        canonicalIdentities,
+        approvedLocalDefinitionKeys
+      )
+    )
+      continue;
     if (node.element.includes(".")) continue;
     if (canonicalDirectoryResolvedNodes.has(node.id)) continue;
     if (shadowRenderRootNodeIds.has(node.id)) continue;
@@ -299,7 +335,17 @@ export function ruleComponentsPreferLibrary(ix: FactIndex): Finding[] {
       node.element === "input" ? readStaticStringProp(props, "type") : undefined;
     const mapped = findMapping(node, nodeInputType, mappings);
     if (mapped && imported && isMappedCanonicalImport(imported, mapped)) continue;
-    if (imported && isCanonicalImport(imported, node.element, sources)) continue;
+    if (
+      imported &&
+      isCanonicalImport(
+        imported,
+        node.element,
+        approvedLocalDefinitionKeys === undefined
+          ? sources
+          : sources.filter((source) => source.kind !== "directory")
+      )
+    )
+      continue;
 
     if (mapped) {
       if (!shouldSuggestMapped(node, nodeInputType, imported, mapped)) continue;
@@ -1154,22 +1200,34 @@ function canonicalImportPath(source: CanonicalSource): string | undefined {
  */
 function indexCanonicalDirectoryResolvedNodes(
   ix: FactIndex,
-  sources: readonly CanonicalSource[]
+  sources: readonly CanonicalSource[],
+  approvedLocalDefinitionKeys?: ReadonlySet<string>
 ): Set<FactId> {
   const out = new Set<FactId>();
-  const directoryPaths = sources
-    .filter(
-      (source): source is Extract<CanonicalSource, { kind: "directory" }> =>
-        source.kind === "directory"
-    )
-    .map((source) => normalizePath(source.path));
-  if (directoryPaths.length === 0) return out;
-  for (const fact of ix.byKind("usage_component")) {
-    const module = componentIdModule(fact.componentId);
+  const directorySources = sources.filter(
+    (source): source is Extract<CanonicalSource, { kind: "directory" }> =>
+      source.kind === "directory"
+  );
+  if (directorySources.length === 0) return out;
+  const identities = new Map(
+    ix.byKind("component_identity").map((identity) => [identity.componentKey, identity])
+  );
+  for (const [componentKey, usage] of indexComponentIdentityUsage(ix)) {
+    if (approvedLocalDefinitionKeys !== undefined && !approvedLocalDefinitionKeys.has(componentKey))
+      continue;
+    const identity = identities.get(componentKey);
+    if (identity && identity.state !== "canonical") continue;
+    const module = componentIdModule(componentKey);
     if (module === undefined) continue;
-    const normalizedModule = normalizePath(module);
-    if (directoryPaths.some((path) => isPathInSource(normalizedModule, path))) {
-      out.add(fact.nodeId);
+    const exportName = componentKey.slice(componentKey.indexOf("#") + 1);
+    if (
+      directorySources.some(
+        (source) =>
+          canonicalSourceContainsFile(source, module) &&
+          canonicalSourceIncludesExport(source, exportName)
+      )
+    ) {
+      for (const node of usage.nodes) out.add(node.id);
     }
   }
   return out;
@@ -1181,28 +1239,47 @@ function componentIdModule(componentId: string): string | undefined {
   return hash > 0 ? componentId.slice(0, hash) : undefined;
 }
 
-function isCanonicalSourceImplementationFile(
-  file: string,
-  sources: readonly CanonicalSource[]
+function isCanonicalSourceImplementation(
+  node: UsageNodeFact,
+  sources: readonly CanonicalSource[],
+  definitionsByFile: ReadonlyMap<string, readonly ComponentDefinitionFact[]>,
+  canonicalIdentities: ReadonlyMap<string, boolean>,
+  approvedLocalDefinitionKeys?: ReadonlySet<string>
 ): boolean {
-  const normalizedFile = normalizePath(file);
+  const definitions = definitionsByFile.get(normalizePath(node.file)) ?? [];
   return sources.some((source) => {
-    if (source.kind === "npm" && source.implementationPath) {
-      return isPathInSource(normalizedFile, source.implementationPath);
-    }
-    if (source.kind === "directory") {
-      return isPathInSource(normalizedFile, source.path);
-    }
-    if (source.kind === "registry") {
-      return isPathInSource(normalizedFile, source.installPath);
-    }
-    return false;
+    if (!canonicalSourceContainsFile(source, node.file)) return false;
+    // Legacy package/registry implementation roots declare file ownership;
+    // their export filters describe the public API. A frozen local inventory
+    // always narrows that ownership to exact approved definition regions.
+    if (
+      approvedLocalDefinitionKeys === undefined &&
+      (source.kind !== "directory" || (source.include === undefined && !source.exclude?.length))
+    )
+      return true;
+    const owners = definitions.filter(
+      (definition) => definition.location && locationContains(definition.location, node.location)
+    );
+    // Unlocated/ambiguous source cannot exempt arbitrary application code.
+    return (
+      owners.length > 0 &&
+      owners.every(
+        (definition) =>
+          (approvedLocalDefinitionKeys === undefined ||
+            approvedLocalDefinitionKeys.has(definition.componentKey)) &&
+          canonicalIdentities.get(definition.componentKey) !== false &&
+          canonicalSourceIncludesExport(source, definition.exportName)
+      )
+    );
   });
 }
 
-function isPathInSource(file: string, sourcePath: string): boolean {
-  const normalizedSource = normalizePath(sourcePath).replace(/\/$/, "");
-  return file === normalizedSource || file.startsWith(`${normalizedSource}/`);
+function locationContains(region: FactLocation, node: FactLocation): boolean {
+  if (region.endLine === undefined || region.endColumn === undefined) return false;
+  return (
+    (node.line > region.line || (node.line === region.line && node.column >= region.column)) &&
+    (node.line < region.endLine || (node.line === region.endLine && node.column < region.endColumn))
+  );
 }
 
 function normalizePath(path: string): string {

package/src/topology/resolve-area.ts

@@ -6,7 +6,7 @@
  * preview, cross-repo reconciliation) import it; none reimplements glob/area
  * logic. Pure and browser-safe — no Node, no parser deps.
  *
- * See `apps/cloud/docs/topology/01-architecture.md §1`.
+ * See `docs/fragments-v1/ARCHITECTURE.md §1`.
  */
 
 export type AreaCriticality = "low" | "medium" | "high" | "revenue" | "regulated";

package/src/types.ts

@@ -922,9 +922,6 @@ export interface ThemeSeeds {
   /** Neutral palette name */
   neutral?: "stone" | "ice" | "earth" | "sand" | "fire" | "fragments";
 
-  /** Spacing density scale */
-  density?: "compact" | "default" | "relaxed";
-
   /** Border radius style */
   radiusStyle?: "sharp" | "subtle" | "default" | "rounded" | "pill";
 

package/dist/chunk-3LLRNCPX.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/topology/resolve-area.ts"],"sourcesContent":["/**\n * Topology — map a repo-relative file path to its product area.\n *\n * This is the DRY keystone of the topology layer: the ONLY area-matching\n * implementation in the monorepo. Consumers (CLI scan, Cloud managed-editor\n * preview, cross-repo reconciliation) import it; none reimplements glob/area\n * logic. Pure and browser-safe — no Node, no parser deps.\n *\n * See `apps/cloud/docs/topology/01-architecture.md §1`.\n */\n\nexport type AreaCriticality = \"low\" | \"medium\" | \"high\" | \"revenue\" | \"regulated\";\n\nexport interface Area {\n  id: string;\n  name: string;\n  criticality: AreaCriticality;\n  owners: string[];\n  /** Globs matched against repo-relative file paths in v0. */\n  files: string[];\n  /** Stored for later route-topology adapters; NOT matched in v0. */\n  routes?: string[];\n  /** Tie-break: higher wins. Defaults to declaration order. */\n  priority?: number;\n}\n\nexport interface Topology {\n  /** Bump signals \"re-tag\" to consumers that cache. */\n  version: number;\n  /** Whether area file globs are matched relative to app.path or repo root. Defaults to \"app\". */\n  base?: \"app\" | \"repo\";\n  /** Array (not a keyed record) so precedence is deterministic. */\n  areas: Area[];\n}\n\nexport interface AreaMatch {\n  areaId: string;\n  areaName: string;\n  criticality: AreaCriticality;\n  owners: string[];\n  /** The winning pattern — surfaced in reports for transparency. */\n  matchedGlob: string;\n}\n\n/**\n * Compile a minimal glob to an anchored RegExp. We intentionally do NOT depend\n * on picomatch: core stays lean, the surface we need is small, and we want\n * exact control over Next.js route-group parens (`(marketing)` is a literal\n * path segment here, not an extglob group).\n *\n * Semantics:\n *   - `/**` at a segment boundary (end-of-glob or before `/`) → \"this directory\n *     and everything under it\": the leading slash is optional, so\n *     `src/app/checkout/**` matches `src/app/checkout` AND any descendant.\n *   - a bare/leading `**` → matches across path separators (`.*`). Note a\n *     leading globstar-then-slash does NOT match the root (use a lone `**`\n *     for \"everything\").\n *   - `*`   → matches within a single segment (`[^/]*`)\n *   - `?`   → a single non-separator char\n *   - `{a,b}` → alternation `(?:a|b)`\n *   - every other regex-significant char (`.`, `(`, `)`, `+`, …) is literal\n *\n * Throws on a malformed pattern (e.g. an unbalanced `{`). Callers compile via\n * `compile()`, which catches the throw so a config typo degrades one glob to a\n * non-match instead of aborting the whole scan.\n */\nfunction globToRegExp(glob: string): RegExp {\n  let out = \"\";\n  let braceDepth = 0;\n  let i = 0;\n  while (i < glob.length) {\n    const ch = glob[i];\n\n    // `/**` at a segment boundary → optional slash + anything-below. Matches\n    // the directory itself (`a/**` ⇒ `a`) and every descendant.\n    if (\n      ch === \"/\" &&\n      glob[i + 1] === \"*\" &&\n      glob[i + 2] === \"*\" &&\n      (glob[i + 3] === undefined || glob[i + 3] === \"/\")\n    ) {\n      out += \"(?:/.*)?\";\n      i += 3; // consume `/**`; a trailing `/` (in `a/**/b`) is handled next pass\n      continue;\n    }\n\n    // Bare/leading globstar — crosses path separators.\n    if (ch === \"*\" && glob[i + 1] === \"*\") {\n      out += \".*\";\n      i += 2;\n      continue;\n    }\n\n    switch (ch) {\n      case \"*\":\n        out += \"[^/]*\"; // single segment\n        break;\n      case \"?\":\n        out += \"[^/]\";\n        break;\n      case \"{\":\n        braceDepth += 1;\n        out += \"(?:\";\n        break;\n      case \"}\":\n        if (braceDepth > 0) {\n          braceDepth -= 1;\n          out += \")\";\n        } else {\n          out += \"\\\\}\";\n        }\n        break;\n      case \",\":\n        out += braceDepth > 0 ? \"|\" : \",\";\n        break;\n      // Regex-significant chars kept literal (parens cover route groups).\n      case \".\":\n      case \"(\":\n      case \")\":\n      case \"+\":\n      case \"^\":\n      case \"$\":\n      case \"|\":\n      case \"[\":\n      case \"]\":\n      case \"\\\\\":\n        out += `\\\\${ch}`;\n        break;\n      default:\n        out += ch;\n    }\n    i += 1;\n  }\n  return new RegExp(`^${out}$`);\n}\n\ninterface CompiledArea {\n  area: Area;\n  matchers: { glob: string; re: RegExp }[];\n}\n\n/**\n * Cache compiled matchers per topology object. Consumers pass the same\n * `topology` for every finding in a run, so this turns N×globs recompiles into\n * one. A reloaded config is a new object → fresh entry, so `version` bumps need\n * no manual invalidation.\n */\nconst compiledCache = new WeakMap<Topology, CompiledArea[]>();\n\nfunction compile(topology: Topology): CompiledArea[] {\n  const cached = compiledCache.get(topology);\n  if (cached) return cached;\n\n  // Order by (priority desc, declaration order). Decorate-sort-undecorate keeps\n  // the sort stable across engines.\n  const ordered = topology.areas\n    .map((area, index) => ({ area, index }))\n    .sort((a, b) => {\n      const pa = a.area.priority ?? 0;\n      const pb = b.area.priority ?? 0;\n      if (pa !== pb) return pb - pa;\n      return a.index - b.index;\n    })\n    .map(({ area }) => ({\n      area,\n      matchers: area.files.flatMap((glob) => {\n        try {\n          return [{ glob, re: globToRegExp(glob) }];\n        } catch {\n          // A malformed glob (e.g. unbalanced `{`) compiles to an invalid\n          // RegExp. Skip it rather than aborting the entire scan — topology\n          // config is user-authored, so one typo must not take down\n          // `fragments check`. Its files simply fall through to \"Unassigned\".\n          if (typeof console !== \"undefined\") {\n            console.warn(\n              `[topology] ignoring invalid glob in area \"${area.id}\": ${JSON.stringify(glob)}`\n            );\n          }\n          return [];\n        }\n      }),\n    }));\n\n  compiledCache.set(topology, ordered);\n  return ordered;\n}\n\n/** Normalize to a POSIX, repo-relative path before matching. */\nfunction normalizePath(repoRelPath: string): string {\n  return repoRelPath.replace(/\\\\/g, \"/\").replace(/^\\.\\//, \"\").replace(/^\\/+/, \"\");\n}\n\n/**\n * Resolve the product area for a repo-relative path. First match by\n * `(priority desc, declaration order)`. Returns `null` when nothing matches —\n * the caller buckets that as the explicit \"Unassigned\" area (never dropped;\n * dropping unmatched evidence would make coverage lie).\n */\nexport function resolveArea(repoRelPath: string, topology: Topology): AreaMatch | null {\n  const path = normalizePath(repoRelPath);\n  for (const { area, matchers } of compile(topology)) {\n    for (const { glob, re } of matchers) {\n      if (re.test(path)) {\n        return {\n          areaId: area.id,\n          areaName: area.name,\n          criticality: area.criticality,\n          owners: area.owners,\n          matchedGlob: glob,\n        };\n      }\n    }\n  }\n  return null;\n}\n"],"mappings":"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","names":[]}