@foxlight/core 0.1.0

package/dist/index.js

@@ -0,0 +1,1484 @@
+// src/registry.ts
+var ComponentRegistry = class {
+  components = /* @__PURE__ */ new Map();
+  imports = [];
+  bundleInfo = /* @__PURE__ */ new Map();
+  health = /* @__PURE__ */ new Map();
+  // -----------------------------------------------------------
+  // Component CRUD
+  // -----------------------------------------------------------
+  /** Register a discovered component. */
+  addComponent(component) {
+    this.components.set(component.id, component);
+  }
+  /** Register multiple components at once. */
+  addComponents(components) {
+    for (const c of components) {
+      this.addComponent(c);
+    }
+  }
+  /** Get a component by ID. */
+  getComponent(id) {
+    return this.components.get(id);
+  }
+  /** Get all registered components. */
+  getAllComponents() {
+    return Array.from(this.components.values());
+  }
+  /** Check if a component exists in the registry. */
+  hasComponent(id) {
+    return this.components.has(id);
+  }
+  /** Remove a component from the registry. */
+  removeComponent(id) {
+    return this.components.delete(id);
+  }
+  /** Total number of registered components. */
+  get size() {
+    return this.components.size;
+  }
+  // -----------------------------------------------------------
+  // Import graph
+  // -----------------------------------------------------------
+  /** Add an import edge to the graph. */
+  addImport(edge) {
+    this.imports.push(edge);
+  }
+  /** Add multiple import edges. */
+  addImports(edges) {
+    this.imports.push(...edges);
+  }
+  /** Get all imports originating from a file. */
+  getImportsFrom(filePath) {
+    return this.imports.filter((e) => e.source === filePath);
+  }
+  /** Get all imports targeting a file or package. */
+  getImportsTo(target) {
+    return this.imports.filter((e) => e.target === target);
+  }
+  /** Get the full import graph. */
+  getAllImports() {
+    return [...this.imports];
+  }
+  // -----------------------------------------------------------
+  // Bundle info
+  // -----------------------------------------------------------
+  /** Set bundle size info for a component. */
+  setBundleInfo(info) {
+    this.bundleInfo.set(info.componentId, info);
+  }
+  /** Get bundle info for a component. */
+  getBundleInfo(id) {
+    return this.bundleInfo.get(id);
+  }
+  /** Get all bundle info entries. */
+  getAllBundleInfo() {
+    return Array.from(this.bundleInfo.values());
+  }
+  // -----------------------------------------------------------
+  // Health scores
+  // -----------------------------------------------------------
+  /** Set health score for a component. */
+  setHealth(h) {
+    this.health.set(h.componentId, h);
+  }
+  /** Get health score for a component. */
+  getHealth(id) {
+    return this.health.get(id);
+  }
+  /** Get all health scores. */
+  getAllHealth() {
+    return Array.from(this.health.values());
+  }
+  // -----------------------------------------------------------
+  // Relationship queries
+  // -----------------------------------------------------------
+  /** Find components that use the given component (parents). */
+  getConsumers(id) {
+    const component = this.components.get(id);
+    if (!component) return [];
+    return component.usedBy.map((parentId) => this.components.get(parentId)).filter((c) => c !== void 0);
+  }
+  /** Find components that the given component renders (children). */
+  getDependents(id) {
+    const component = this.components.get(id);
+    if (!component) return [];
+    return component.children.map((childId) => this.components.get(childId)).filter((c) => c !== void 0);
+  }
+  /** Get components that have no parents (top-level / page components). */
+  getRootComponents() {
+    return this.getAllComponents().filter((c) => c.usedBy.length === 0);
+  }
+  /** Get components that have no children (leaf / primitive components). */
+  getLeafComponents() {
+    return this.getAllComponents().filter((c) => c.children.length === 0);
+  }
+  /**
+   * Find all components reachable from the given component (full subtree).
+   * Uses BFS to avoid stack overflow on deep trees.
+   */
+  getSubtree(id) {
+    const visited = /* @__PURE__ */ new Set();
+    const queue = [id];
+    const result = [];
+    while (queue.length > 0) {
+      const currentId = queue.shift();
+      if (visited.has(currentId)) continue;
+      visited.add(currentId);
+      const component = this.components.get(currentId);
+      if (!component) continue;
+      result.push(component);
+      for (const childId of component.children) {
+        if (!visited.has(childId)) {
+          queue.push(childId);
+        }
+      }
+    }
+    return result;
+  }
+  // -----------------------------------------------------------
+  // Snapshot & diff
+  // -----------------------------------------------------------
+  /** Create a point-in-time snapshot of the registry. */
+  createSnapshot(commitSha, branch) {
+    return {
+      id: `snap_${Date.now()}_${commitSha.slice(0, 8)}`,
+      commitSha,
+      branch,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      components: this.getAllComponents(),
+      imports: this.getAllImports(),
+      bundleInfo: this.getAllBundleInfo(),
+      health: this.getAllHealth()
+    };
+  }
+  /** Load a snapshot into the registry, replacing current state. */
+  loadSnapshot(snapshot) {
+    this.clear();
+    this.addComponents(snapshot.components);
+    this.addImports(snapshot.imports);
+    for (const bi of snapshot.bundleInfo) {
+      this.setBundleInfo(bi);
+    }
+    for (const h of snapshot.health) {
+      this.setHealth(h);
+    }
+  }
+  /** Compute the diff between two snapshots. */
+  static diff(base, head) {
+    const baseIds = new Set(base.components.map((c) => c.id));
+    const headIds = new Set(head.components.map((c) => c.id));
+    const added = head.components.filter((c) => !baseIds.has(c.id));
+    const removed = base.components.filter((c) => !headIds.has(c.id));
+    const modified = [];
+    for (const headComp of head.components) {
+      if (!baseIds.has(headComp.id)) continue;
+      const baseComp = base.components.find((c) => c.id === headComp.id);
+      if (!baseComp) continue;
+      const mod = diffComponent(baseComp, headComp);
+      if (mod) {
+        modified.push(mod);
+      }
+    }
+    const bundleDiff = [];
+    const headBundleMap = new Map(head.bundleInfo.map((b) => [b.componentId, b]));
+    for (const baseBi of base.bundleInfo) {
+      const headBi = headBundleMap.get(baseBi.componentId);
+      if (!headBi) continue;
+      bundleDiff.push({
+        componentId: baseBi.componentId,
+        before: baseBi.selfSize,
+        after: headBi.selfSize,
+        delta: {
+          raw: headBi.selfSize.raw - baseBi.selfSize.raw,
+          gzip: headBi.selfSize.gzip - baseBi.selfSize.gzip
+        }
+      });
+    }
+    const healthDiff = [];
+    const headHealthMap = new Map(head.health.map((h) => [h.componentId, h]));
+    for (const baseH of base.health) {
+      const headH = headHealthMap.get(baseH.componentId);
+      if (!headH) continue;
+      healthDiff.push({
+        componentId: baseH.componentId,
+        beforeScore: baseH.score,
+        afterScore: headH.score,
+        delta: headH.score - baseH.score
+      });
+    }
+    return {
+      base: { id: base.id, commitSha: base.commitSha },
+      head: { id: head.id, commitSha: head.commitSha },
+      components: { added, removed, modified },
+      bundleDiff,
+      healthDiff
+    };
+  }
+  // -----------------------------------------------------------
+  // Utility
+  // -----------------------------------------------------------
+  /** Clear all data from the registry. */
+  clear() {
+    this.components.clear();
+    this.imports = [];
+    this.bundleInfo.clear();
+    this.health.clear();
+  }
+};
+function diffComponent(base, head) {
+  const changes = [];
+  const baseProps = new Set(base.props.map((p) => p.name));
+  const headProps = new Set(head.props.map((p) => p.name));
+  const propsAdded = head.props.filter((p) => !baseProps.has(p.name)).map((p) => p.name);
+  const propsRemoved = base.props.filter((p) => !headProps.has(p.name)).map((p) => p.name);
+  const propsModified = [];
+  for (const headProp of head.props) {
+    if (!baseProps.has(headProp.name)) continue;
+    const baseProp = base.props.find((p) => p.name === headProp.name);
+    if (!baseProp) continue;
+    if (baseProp.type !== headProp.type || baseProp.required !== headProp.required) {
+      propsModified.push(headProp.name);
+    }
+  }
+  if (base.children.length !== head.children.length) {
+    changes.push("children changed");
+  }
+  if (base.dependencies.length !== head.dependencies.length) {
+    changes.push("dependencies changed");
+  }
+  if (base.framework !== head.framework) {
+    changes.push(`framework changed: ${base.framework} \u2192 ${head.framework}`);
+  }
+  const hasChanges = propsAdded.length > 0 || propsRemoved.length > 0 || propsModified.length > 0 || changes.length > 0;
+  if (!hasChanges) return null;
+  return {
+    componentId: head.id,
+    changes,
+    propsAdded,
+    propsRemoved,
+    propsModified
+  };
+}
+
+// src/dependency-graph.ts
+var DependencyGraph = class _DependencyGraph {
+  nodes = /* @__PURE__ */ new Map();
+  /** Build the graph from a list of import edges. */
+  static fromImports(edges) {
+    const graph = new _DependencyGraph();
+    for (const edge of edges) {
+      graph.addEdge(edge.source, edge.target);
+    }
+    return graph;
+  }
+  /** Add a directed edge from source to target. */
+  addEdge(source, target) {
+    this.ensureNode(source);
+    this.ensureNode(target);
+    this.nodes.get(source).outgoing.add(target);
+    this.nodes.get(target).incoming.add(source);
+  }
+  /** Get all direct dependencies of a module. */
+  getDependencies(id) {
+    const node = this.nodes.get(id);
+    return node ? Array.from(node.outgoing) : [];
+  }
+  /** Get all modules that directly depend on a module. */
+  getDependents(id) {
+    const node = this.nodes.get(id);
+    return node ? Array.from(node.incoming) : [];
+  }
+  /**
+   * Get all modules transitively affected if the given module changes.
+   * Walks the "incoming" edges (dependents) recursively.
+   */
+  getImpactedModules(id) {
+    const visited = /* @__PURE__ */ new Set();
+    const queue = [id];
+    while (queue.length > 0) {
+      const current = queue.shift();
+      if (visited.has(current)) continue;
+      visited.add(current);
+      const node = this.nodes.get(current);
+      if (!node) continue;
+      for (const dep of node.incoming) {
+        if (!visited.has(dep)) {
+          queue.push(dep);
+        }
+      }
+    }
+    visited.delete(id);
+    return Array.from(visited);
+  }
+  /**
+   * Get all transitive dependencies of a module.
+   * Walks "outgoing" edges recursively.
+   */
+  getTransitiveDependencies(id) {
+    const visited = /* @__PURE__ */ new Set();
+    const queue = [id];
+    while (queue.length > 0) {
+      const current = queue.shift();
+      if (visited.has(current)) continue;
+      visited.add(current);
+      const node = this.nodes.get(current);
+      if (!node) continue;
+      for (const dep of node.outgoing) {
+        if (!visited.has(dep)) {
+          queue.push(dep);
+        }
+      }
+    }
+    visited.delete(id);
+    return Array.from(visited);
+  }
+  /**
+   * Detect cycles in the graph.
+   * Returns an array of cycles, where each cycle is an array of module IDs.
+   */
+  detectCycles() {
+    const cycles = [];
+    const visited = /* @__PURE__ */ new Set();
+    const inStack = /* @__PURE__ */ new Set();
+    const stack = [];
+    const dfs = (nodeId) => {
+      if (inStack.has(nodeId)) {
+        const cycleStart = stack.indexOf(nodeId);
+        if (cycleStart !== -1) {
+          cycles.push([...stack.slice(cycleStart), nodeId]);
+        }
+        return;
+      }
+      if (visited.has(nodeId)) return;
+      visited.add(nodeId);
+      inStack.add(nodeId);
+      stack.push(nodeId);
+      const node = this.nodes.get(nodeId);
+      if (node) {
+        for (const dep of node.outgoing) {
+          dfs(dep);
+        }
+      }
+      stack.pop();
+      inStack.delete(nodeId);
+    };
+    for (const nodeId of this.nodes.keys()) {
+      if (!visited.has(nodeId)) {
+        dfs(nodeId);
+      }
+    }
+    return cycles;
+  }
+  /**
+   * Topological sort of the graph.
+   * Returns null if the graph has cycles.
+   */
+  topologicalSort() {
+    const inDegree = /* @__PURE__ */ new Map();
+    for (const [id, node] of this.nodes) {
+      inDegree.set(id, node.incoming.size);
+    }
+    const queue = [];
+    for (const [id, degree] of inDegree) {
+      if (degree === 0) queue.push(id);
+    }
+    const result = [];
+    while (queue.length > 0) {
+      const current = queue.shift();
+      result.push(current);
+      const node = this.nodes.get(current);
+      if (!node) continue;
+      for (const dep of node.outgoing) {
+        const newDegree = (inDegree.get(dep) ?? 1) - 1;
+        inDegree.set(dep, newDegree);
+        if (newDegree === 0) {
+          queue.push(dep);
+        }
+      }
+    }
+    return result.length === this.nodes.size ? result : null;
+  }
+  /**
+   * Find shared dependencies between two modules.
+   * Useful for understanding which code is shared vs. unique.
+   */
+  getSharedDependencies(idA, idB) {
+    const depsA = new Set(this.getTransitiveDependencies(idA));
+    const depsB = new Set(this.getTransitiveDependencies(idB));
+    return Array.from(depsA).filter((d) => depsB.has(d));
+  }
+  /**
+   * Find dependencies unique to a module (not shared with any other top-level module).
+   * Used for calculating "exclusive" bundle size.
+   */
+  getExclusiveDependencies(id, allTopLevel) {
+    const myDeps = new Set(this.getTransitiveDependencies(id));
+    const otherDeps = /* @__PURE__ */ new Set();
+    for (const otherId of allTopLevel) {
+      if (otherId === id) continue;
+      for (const dep of this.getTransitiveDependencies(otherId)) {
+        otherDeps.add(dep);
+      }
+    }
+    return Array.from(myDeps).filter((d) => !otherDeps.has(d));
+  }
+  /** Get all node IDs in the graph. */
+  getAllNodes() {
+    return Array.from(this.nodes.keys());
+  }
+  /** Get the total number of nodes. */
+  get nodeCount() {
+    return this.nodes.size;
+  }
+  /** Get the total number of edges. */
+  get edgeCount() {
+    let count = 0;
+    for (const node of this.nodes.values()) {
+      count += node.outgoing.size;
+    }
+    return count;
+  }
+  ensureNode(id) {
+    if (!this.nodes.has(id)) {
+      this.nodes.set(id, { id, outgoing: /* @__PURE__ */ new Set(), incoming: /* @__PURE__ */ new Set() });
+    }
+  }
+};
+
+// src/config.ts
+import { existsSync } from "fs";
+import { readFile } from "fs/promises";
+import { resolve, join } from "path";
+var CONFIG_FILENAMES = [
+  "foxlight.config.ts",
+  "foxlight.config.js",
+  "foxlight.config.mjs",
+  "foxlight.config.json"
+];
+var DEFAULT_INCLUDE = [
+  "src/**/*.{tsx,jsx,vue,svelte}",
+  "components/**/*.{tsx,jsx,vue,svelte}",
+  "app/**/*.{tsx,jsx,vue,svelte}",
+  "pages/**/*.{tsx,jsx,vue,svelte}"
+];
+var DEFAULT_EXCLUDE = [
+  "**/node_modules/**",
+  "**/dist/**",
+  "**/build/**",
+  "**/.next/**",
+  "**/.nuxt/**",
+  "**/*.test.*",
+  "**/*.spec.*",
+  "**/*.stories.*"
+];
+async function loadConfig(rootDir) {
+  const resolvedRoot = resolve(rootDir);
+  for (const filename of CONFIG_FILENAMES) {
+    const configPath = join(resolvedRoot, filename);
+    if (existsSync(configPath)) {
+      const config = await loadConfigFile(configPath);
+      return mergeWithDefaults(resolvedRoot, config);
+    }
+  }
+  const framework = await detectFramework(resolvedRoot);
+  return mergeWithDefaults(resolvedRoot, { framework });
+}
+function createDefaultConfig(rootDir) {
+  return {
+    rootDir: resolve(rootDir),
+    include: DEFAULT_INCLUDE,
+    exclude: DEFAULT_EXCLUDE
+  };
+}
+async function detectFramework(rootDir) {
+  const pkgPath = join(rootDir, "package.json");
+  if (!existsSync(pkgPath)) return "unknown";
+  try {
+    const raw = await readFile(pkgPath, "utf-8");
+    const pkg = JSON.parse(raw);
+    const allDeps = {
+      ...pkg["dependencies"],
+      ...pkg["devDependencies"]
+    };
+    if ("react" in allDeps) return "react";
+    if ("vue" in allDeps) return "vue";
+    if ("svelte" in allDeps) return "svelte";
+    if ("@angular/core" in allDeps) return "angular";
+    if ("lit" in allDeps || "lit-element" in allDeps) return "web-component";
+  } catch {
+  }
+  return "unknown";
+}
+async function loadConfigFile(configPath) {
+  if (configPath.endsWith(".json")) {
+    const raw = await readFile(configPath, "utf-8");
+    return JSON.parse(raw);
+  }
+  try {
+    const mod = await import(configPath);
+    return mod.default ?? {};
+  } catch {
+    return {};
+  }
+}
+function mergeWithDefaults(rootDir, partial) {
+  return {
+    rootDir,
+    include: partial.include ?? DEFAULT_INCLUDE,
+    exclude: partial.exclude ?? DEFAULT_EXCLUDE,
+    framework: partial.framework,
+    storybook: partial.storybook,
+    costModel: partial.costModel,
+    baselines: partial.baselines,
+    plugins: partial.plugins
+  };
+}
+
+// src/health-scorer.ts
+var DEFAULT_WEIGHTS = {
+  bundleSize: 0.25,
+  testCoverage: 0.2,
+  accessibility: 0.15,
+  freshness: 0.15,
+  performance: 0.15,
+  reliability: 0.1
+};
+var BUNDLE_THRESHOLDS = {
+  good: 10240,
+  // ≤10 KB
+  warning: 50240
+  // ≤50 KB
+};
+var COVERAGE_THRESHOLDS = {
+  good: 80,
+  warning: 50
+};
+var FRESHNESS_THRESHOLDS = {
+  good: 90,
+  // Modified within 90 days
+  warning: 365
+  // Modified within a year
+};
+function computeComponentHealth(input, weights = DEFAULT_WEIGHTS) {
+  const metrics = computeMetrics(input);
+  const score = computeOverallScore(metrics, weights);
+  return {
+    componentId: input.component.id,
+    score,
+    metrics,
+    computedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function computeAllHealth(inputs, weights = DEFAULT_WEIGHTS) {
+  return inputs.map((input) => computeComponentHealth(input, weights));
+}
+function computeMetrics(input) {
+  return {
+    bundleSize: scoreBundleSize(input.bundleInfo),
+    testCoverage: scoreTestCoverage(input.testCoverage),
+    accessibility: scoreAccessibility(input.accessibilityScore),
+    freshness: scoreFreshness(input.daysSinceModified),
+    performance: scorePerformance(input.renderTimeMs),
+    reliability: scoreReliability(input.errorRate)
+  };
+}
+function computeOverallScore(metrics, weights) {
+  const weighted = metrics.bundleSize.score * weights.bundleSize + metrics.testCoverage.score * weights.testCoverage + metrics.accessibility.score * weights.accessibility + metrics.freshness.score * weights.freshness + metrics.performance.score * weights.performance + metrics.reliability.score * weights.reliability;
+  return Math.round(weighted);
+}
+function scoreBundleSize(bundleInfo) {
+  if (!bundleInfo) {
+    return {
+      score: 50,
+      value: "unknown",
+      label: "Bundle size not measured",
+      level: "warning"
+    };
+  }
+  const gzipBytes = bundleInfo.selfSize.gzip;
+  const score = gzipBytes <= BUNDLE_THRESHOLDS.good ? 100 : gzipBytes <= BUNDLE_THRESHOLDS.warning ? Math.round(
+    100 - (gzipBytes - BUNDLE_THRESHOLDS.good) / (BUNDLE_THRESHOLDS.warning - BUNDLE_THRESHOLDS.good) * 50
+  ) : Math.max(
+    0,
+    Math.round(
+      50 - (gzipBytes - BUNDLE_THRESHOLDS.warning) / BUNDLE_THRESHOLDS.warning * 50
+    )
+  );
+  return {
+    score,
+    value: formatBytesCompact(gzipBytes),
+    label: "Gzip size",
+    level: levelFromScore(score)
+  };
+}
+function scoreTestCoverage(coverage) {
+  if (coverage === void 0) {
+    return {
+      score: 0,
+      value: "no data",
+      label: "Test coverage not available",
+      level: "critical"
+    };
+  }
+  const clamped = Math.max(0, Math.min(100, coverage));
+  return {
+    score: Math.round(clamped),
+    value: `${clamped.toFixed(0)}%`,
+    label: "Test coverage",
+    level: clamped >= COVERAGE_THRESHOLDS.good ? "good" : clamped >= COVERAGE_THRESHOLDS.warning ? "warning" : "critical"
+  };
+}
+function scoreAccessibility(a11yScore) {
+  if (a11yScore === void 0) {
+    return {
+      score: 50,
+      value: "not scanned",
+      label: "Accessibility not measured",
+      level: "warning"
+    };
+  }
+  const clamped = Math.max(0, Math.min(100, a11yScore));
+  return {
+    score: Math.round(clamped),
+    value: `${clamped.toFixed(0)}/100`,
+    label: "Accessibility score",
+    level: levelFromScore(Math.round(clamped))
+  };
+}
+function scoreFreshness(daysSinceModified) {
+  if (daysSinceModified === void 0) {
+    return {
+      score: 50,
+      value: "unknown",
+      label: "Last modification date unknown",
+      level: "warning"
+    };
+  }
+  const score = daysSinceModified <= FRESHNESS_THRESHOLDS.good ? 100 : daysSinceModified <= FRESHNESS_THRESHOLDS.warning ? Math.round(
+    100 - (daysSinceModified - FRESHNESS_THRESHOLDS.good) / (FRESHNESS_THRESHOLDS.warning - FRESHNESS_THRESHOLDS.good) * 50
+  ) : Math.max(
+    0,
+    Math.round(
+      50 - (daysSinceModified - FRESHNESS_THRESHOLDS.warning) / FRESHNESS_THRESHOLDS.warning * 50
+    )
+  );
+  return {
+    score,
+    value: daysSinceModified <= 1 ? "today" : `${daysSinceModified}d ago`,
+    label: "Last modified",
+    level: levelFromScore(score)
+  };
+}
+function scorePerformance(renderTimeMs) {
+  if (renderTimeMs === void 0) {
+    return {
+      score: 50,
+      value: "not profiled",
+      label: "Render performance not measured",
+      level: "warning"
+    };
+  }
+  const score = renderTimeMs <= 16 ? 100 : renderTimeMs <= 50 ? Math.round(100 - (renderTimeMs - 16) / 34 * 20) : renderTimeMs <= 200 ? Math.round(80 - (renderTimeMs - 50) / 150 * 50) : Math.max(0, Math.round(30 - (renderTimeMs - 200) / 500 * 30));
+  return {
+    score,
+    value: `${renderTimeMs.toFixed(0)}ms`,
+    label: "Render time",
+    level: levelFromScore(score)
+  };
+}
+function scoreReliability(errorRate) {
+  if (errorRate === void 0) {
+    return {
+      score: 50,
+      value: "no data",
+      label: "Error rate not tracked",
+      level: "warning"
+    };
+  }
+  const pct = errorRate * 100;
+  const score = pct <= 0 ? 100 : pct <= 1 ? Math.round(100 - pct * 20) : pct <= 5 ? Math.round(80 - (pct - 1) / 4 * 50) : Math.max(0, Math.round(30 - (pct - 5) / 10 * 30));
+  return {
+    score,
+    value: `${pct.toFixed(2)}%`,
+    label: "Error rate",
+    level: levelFromScore(score)
+  };
+}
+function levelFromScore(score) {
+  if (score >= 80) return "good";
+  if (score >= 50) return "warning";
+  return "critical";
+}
+function formatBytesCompact(bytes) {
+  if (bytes === 0) return "0 B";
+  const units = ["B", "KB", "MB", "GB"];
+  const i = Math.floor(Math.log(Math.abs(bytes)) / Math.log(1024));
+  const value = bytes / Math.pow(1024, i);
+  return `${value.toFixed(value >= 100 ? 0 : value >= 10 ? 1 : 2)} ${units[i]}`;
+}
+
+// src/cost-estimator.ts
+var COST_MODELS = {
+  vercel: {
+    provider: "vercel",
+    invocationCostPer1M: 0.6,
+    bandwidthCostPerGB: 0.15,
+    storageCostPerGB: 0.023,
+    edgeCostPer1M: 2,
+    baseCost: 0
+  },
+  netlify: {
+    provider: "netlify",
+    invocationCostPer1M: 2,
+    bandwidthCostPerGB: 0.2,
+    storageCostPerGB: 0.025,
+    baseCost: 0
+  },
+  aws: {
+    provider: "aws",
+    invocationCostPer1M: 0.2,
+    bandwidthCostPerGB: 0.09,
+    storageCostPerGB: 0.023,
+    edgeCostPer1M: 0.6,
+    baseCost: 0
+  },
+  cloudflare: {
+    provider: "cloudflare",
+    invocationCostPer1M: 0.5,
+    bandwidthCostPerGB: 0,
+    // Free egress
+    storageCostPerGB: 0.015,
+    edgeCostPer1M: 0.5,
+    baseCost: 5
+  }
+};
+var DEFAULT_TRAFFIC = {
+  monthlyPageViews: 1e5,
+  invocationsPerPageView: 1.5,
+  edgeRatio: 0.3
+};
+function estimateCostImpact(currentBundleInfo, updatedBundleInfo, costModel, traffic = DEFAULT_TRAFFIC) {
+  const currentTotalSize = aggregateTotalSize(currentBundleInfo);
+  const updatedTotalSize = aggregateTotalSize(updatedBundleInfo);
+  const currentCosts = computeMonthlyCosts(currentTotalSize, costModel, traffic);
+  const updatedCosts = computeMonthlyCosts(updatedTotalSize, costModel, traffic);
+  const breakdown = [
+    {
+      category: "bandwidth",
+      description: `Bandwidth cost for serving ${formatGB(updatedTotalSize.gzip * traffic.monthlyPageViews)} per month`,
+      currentCost: currentCosts.bandwidth,
+      projectedCost: updatedCosts.bandwidth,
+      delta: updatedCosts.bandwidth - currentCosts.bandwidth
+    },
+    {
+      category: "invocations",
+      description: `${formatNumber(traffic.monthlyPageViews * traffic.invocationsPerPageView)} monthly function invocations`,
+      currentCost: currentCosts.invocations,
+      projectedCost: updatedCosts.invocations,
+      delta: updatedCosts.invocations - currentCosts.invocations
+    },
+    {
+      category: "storage",
+      description: "CDN/hosting asset storage",
+      currentCost: currentCosts.storage,
+      projectedCost: updatedCosts.storage,
+      delta: updatedCosts.storage - currentCosts.storage
+    },
+    {
+      category: "edge",
+      description: `Edge function invocations (${(traffic.edgeRatio * 100).toFixed(0)}% of traffic)`,
+      currentCost: currentCosts.edge,
+      projectedCost: updatedCosts.edge,
+      delta: updatedCosts.edge - currentCosts.edge
+    },
+    {
+      category: "base",
+      description: "Base platform cost",
+      currentCost: costModel.baseCost,
+      projectedCost: costModel.baseCost,
+      delta: 0
+    }
+  ];
+  const currentMonthlyCost = Object.values(currentCosts).reduce((a, b) => a + b, 0) + costModel.baseCost;
+  const projectedMonthlyCost = Object.values(updatedCosts).reduce((a, b) => a + b, 0) + costModel.baseCost;
+  return {
+    monthlyDelta: projectedMonthlyCost - currentMonthlyCost,
+    breakdown,
+    currentMonthlyCost,
+    projectedMonthlyCost
+  };
+}
+function estimateMonthlyCost(bundleInfo, costModel, traffic = DEFAULT_TRAFFIC) {
+  const totalSize = aggregateTotalSize(bundleInfo);
+  const costs = computeMonthlyCosts(totalSize, costModel, traffic);
+  return Object.values(costs).reduce((a, b) => a + b, 0) + costModel.baseCost;
+}
+function computeMonthlyCosts(totalSize, model, traffic) {
+  const monthlyBandwidthGB = totalSize.gzip * traffic.monthlyPageViews / (1024 * 1024 * 1024);
+  const bandwidth = monthlyBandwidthGB * model.bandwidthCostPerGB;
+  const totalInvocations = traffic.monthlyPageViews * traffic.invocationsPerPageView;
+  const invocations = totalInvocations / 1e6 * model.invocationCostPer1M;
+  const storageGB = totalSize.raw / (1024 * 1024 * 1024);
+  const storage = storageGB * model.storageCostPerGB;
+  const edgeInvocations = totalInvocations * traffic.edgeRatio;
+  const edge = model.edgeCostPer1M ? edgeInvocations / 1e6 * model.edgeCostPer1M : 0;
+  return { bandwidth, invocations, storage, edge };
+}
+function aggregateTotalSize(bundleInfo) {
+  let raw = 0;
+  let gzip = 0;
+  for (const info of bundleInfo) {
+    raw += info.selfSize.raw;
+    gzip += info.selfSize.gzip;
+  }
+  return { raw, gzip };
+}
+function formatGB(bytes) {
+  const gb = bytes / (1024 * 1024 * 1024);
+  if (gb >= 1) return `${gb.toFixed(2)} GB`;
+  const mb = bytes / (1024 * 1024);
+  if (mb >= 1) return `${mb.toFixed(1)} MB`;
+  const kb = bytes / 1024;
+  return `${kb.toFixed(0)} KB`;
+}
+function formatNumber(n) {
+  if (n >= 1e6) return `${(n / 1e6).toFixed(1)}M`;
+  if (n >= 1e3) return `${(n / 1e3).toFixed(0)}K`;
+  return String(Math.round(n));
+}
+
+// src/upgrade-analyzer.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+import { readFile as readFile2 } from "fs/promises";
+import { join as join2 } from "path";
+var execFileAsync = promisify(execFile);
+async function analyzeUpgrade(options) {
+  const { rootDir, packageName, affectedComponents = [] } = options;
+  const currentVersion = await getCurrentVersion(rootDir, packageName);
+  const targetVersion = options.targetVersion ?? await getLatestVersion(packageName);
+  const checks = [];
+  checks.push(checkSemverRisk(currentVersion, targetVersion));
+  checks.push(checkComponentImpact(packageName, affectedComponents));
+  checks.push(await checkPeerDependencies(rootDir, packageName, targetVersion));
+  checks.push(await checkDeprecation(packageName, targetVersion));
+  const risk = computeOverallRisk(checks);
+  return {
+    packageName,
+    fromVersion: currentVersion,
+    toVersion: targetVersion,
+    risk,
+    checks
+  };
+}
+async function analyzeUpgrades(rootDir, packages, allComponents) {
+  const results = [];
+  for (const pkg of packages) {
+    const affectedComponents = allComponents?.filter((c) => c.dependencies.includes(pkg.name));
+    const preview = await analyzeUpgrade({
+      rootDir,
+      packageName: pkg.name,
+      targetVersion: pkg.targetVersion,
+      affectedComponents
+    });
+    results.push(preview);
+  }
+  return results;
+}
+function checkSemverRisk(currentVersion, targetVersion) {
+  const current = parseSemver(currentVersion);
+  const target = parseSemver(targetVersion);
+  if (!current || !target) {
+    return {
+      name: "Semver Analysis",
+      status: "warn",
+      summary: `Could not parse versions: ${currentVersion} \u2192 ${targetVersion}`
+    };
+  }
+  if (target.major > current.major) {
+    return {
+      name: "Semver Analysis",
+      status: "fail",
+      summary: `Major version bump (${currentVersion} \u2192 ${targetVersion}). Likely contains breaking changes.`,
+      details: "Major version bumps often require code changes. Review the changelog carefully."
+    };
+  }
+  if (target.minor > current.minor) {
+    return {
+      name: "Semver Analysis",
+      status: "warn",
+      summary: `Minor version bump (${currentVersion} \u2192 ${targetVersion}). May contain new features and deprecations.`
+    };
+  }
+  return {
+    name: "Semver Analysis",
+    status: "pass",
+    summary: `Patch version bump (${currentVersion} \u2192 ${targetVersion}). Bug fixes only.`
+  };
+}
+function checkComponentImpact(packageName, affectedComponents) {
+  if (affectedComponents.length === 0) {
+    return {
+      name: "Component Impact",
+      status: "pass",
+      summary: `No components directly import ${packageName}.`
+    };
+  }
+  const names = affectedComponents.map((c) => c.name).slice(0, 10);
+  const more = affectedComponents.length > 10 ? ` and ${affectedComponents.length - 10} more` : "";
+  const status = affectedComponents.length > 20 ? "fail" : affectedComponents.length > 5 ? "warn" : "pass";
+  return {
+    name: "Component Impact",
+    status,
+    summary: `${affectedComponents.length} component(s) directly import ${packageName}.`,
+    details: `Affected: ${names.join(", ")}${more}`
+  };
+}
+async function checkPeerDependencies(rootDir, packageName, targetVersion) {
+  try {
+    const { stdout } = await execFileAsync(
+      "npm",
+      ["view", `${packageName}@${targetVersion}`, "peerDependencies", "--json"],
+      { cwd: rootDir, timeout: 1e4 }
+    );
+    if (!stdout.trim()) {
+      return {
+        name: "Peer Dependencies",
+        status: "pass",
+        summary: "No peer dependency requirements."
+      };
+    }
+    const peerDeps = JSON.parse(stdout);
+    const peerList = Object.entries(peerDeps).map(([name, range]) => `${name}@${range}`).join(", ");
+    return {
+      name: "Peer Dependencies",
+      status: "warn",
+      summary: `Requires peer dependencies: ${peerList}`,
+      details: "Verify that your installed versions satisfy these peer dependency ranges."
+    };
+  } catch {
+    return {
+      name: "Peer Dependencies",
+      status: "warn",
+      summary: "Could not check peer dependencies (npm view failed)."
+    };
+  }
+}
+async function checkDeprecation(packageName, targetVersion) {
+  try {
+    const { stdout } = await execFileAsync(
+      "npm",
+      ["view", `${packageName}@${targetVersion}`, "deprecated", "--json"],
+      { timeout: 1e4 }
+    );
+    if (stdout.trim() && stdout.trim() !== "undefined") {
+      return {
+        name: "Deprecation",
+        status: "fail",
+        summary: `Version ${targetVersion} is deprecated.`,
+        details: stdout.trim().replace(/^"|"$/g, "")
+      };
+    }
+    return {
+      name: "Deprecation",
+      status: "pass",
+      summary: "Target version is not deprecated."
+    };
+  } catch {
+    return {
+      name: "Deprecation",
+      status: "pass",
+      summary: "No deprecation notice found."
+    };
+  }
+}
+async function getCurrentVersion(rootDir, packageName) {
+  try {
+    const pkgPath = join2(rootDir, "package.json");
+    const raw = await readFile2(pkgPath, "utf-8");
+    const pkg = JSON.parse(raw);
+    const allDeps = {
+      ...pkg["dependencies"],
+      ...pkg["devDependencies"]
+    };
+    const version = allDeps[packageName];
+    return version?.replace(/^[\^~>=<]+/, "") ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+async function getLatestVersion(packageName) {
+  try {
+    const { stdout } = await execFileAsync("npm", ["view", packageName, "version"], {
+      timeout: 1e4
+    });
+    return stdout.trim();
+  } catch {
+    return "0.0.0";
+  }
+}
+function parseSemver(version) {
+  const cleaned = version.replace(/^[\^~>=<]+/, "");
+  const match = cleaned.match(/^(\d+)\.(\d+)\.(\d+)/);
+  if (!match) return null;
+  return {
+    major: parseInt(match[1], 10),
+    minor: parseInt(match[2], 10),
+    patch: parseInt(match[3], 10)
+  };
+}
+function computeOverallRisk(checks) {
+  const hasFail = checks.some((c) => c.status === "fail");
+  const warnCount = checks.filter((c) => c.status === "warn").length;
+  if (hasFail) return "high";
+  if (warnCount >= 2) return "medium";
+  return "low";
+}
+
+// src/import-parser.ts
+function extractImportsFromScript(script, filePath) {
+  const imports = [];
+  const importRegex = /import\s+(?:(?:type\s+)?(?:(\{[^}]+\})|(\w+)(?:\s*,\s*(\{[^}]+\}))?|(\*\s+as\s+\w+)))\s+from\s+['"]([^'"]+)['"]/g;
+  let match;
+  while ((match = importRegex.exec(script)) !== null) {
+    const target = match[5];
+    const specifiers = [];
+    if (match[2]) {
+      specifiers.push({ imported: "default", local: match[2] });
+    }
+    const namedBlock = match[1] ?? match[3];
+    if (namedBlock) {
+      const names = namedBlock.replace(/[{}]/g, "").split(",").map((s) => s.trim()).filter(Boolean);
+      for (const name of names) {
+        const parts = name.split(/\s+as\s+/);
+        specifiers.push({
+          imported: parts[0].replace(/^type\s+/, "").trim(),
+          local: (parts[1] ?? parts[0]).trim()
+        });
+      }
+    }
+    if (match[4]) {
+      const nsName = match[4].replace("* as ", "").trim();
+      specifiers.push({ imported: "*", local: nsName });
+    }
+    imports.push({
+      source: filePath,
+      target,
+      specifiers,
+      typeOnly: /import\s+type\s/.test(match[0])
+    });
+  }
+  return imports;
+}
+
+// src/coverage-analyzer.ts
+import { readFile as readFile3 } from "fs/promises";
+import { existsSync as existsSync2 } from "fs";
+import { join as join3 } from "path";
+async function loadCoverageData(projectRoot, customCoveragePath) {
+  const coveragePath = customCoveragePath || join3(projectRoot, "coverage", "coverage-final.json");
+  if (!existsSync2(coveragePath)) {
+    return {};
+  }
+  try {
+    const raw = await readFile3(coveragePath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+function calculateFileCoverage(coverage) {
+  const statementsCovered = Object.values(coverage.s).filter((count) => count > 0).length;
+  const statementsTotal = Object.keys(coverage.s).length;
+  const functionsCovered = Object.values(coverage.f).filter((count) => count > 0).length;
+  const functionsTotal = Object.keys(coverage.f).length;
+  const totalCoveration = statementsTotal + functionsTotal;
+  const coveredCount = statementsCovered + functionsCovered;
+  const percentage = totalCoveration > 0 ? Math.round(coveredCount / totalCoveration * 100) : 0;
+  return {
+    statements: { covered: statementsCovered, total: statementsTotal },
+    functions: { covered: functionsCovered, total: functionsTotal },
+    percentage
+  };
+}
+function mapCoverageToComponents(coverageData, componentFilePaths) {
+  const components = /* @__PURE__ */ new Map();
+  let totalStatementsCovered = 0;
+  let totalStatementsTotal = 0;
+  for (const [filePath, coverage] of Object.entries(coverageData)) {
+    if (!componentFilePaths.has(filePath) && !componentFilePaths.has(`./${filePath}`)) {
+      continue;
+    }
+    const { statements, functions, percentage } = calculateFileCoverage(coverage);
+    const componentId = filePath;
+    const componentCoverage = {
+      componentId,
+      filePath,
+      statementsCovered: statements.covered,
+      statementsTotal: statements.total,
+      functionsCovered: functions.covered,
+      functionsTotal: functions.total,
+      percentage,
+      isCovered: percentage > 0
+    };
+    components.set(filePath, componentCoverage);
+    totalStatementsCovered += statements.covered;
+    totalStatementsTotal += statements.total;
+  }
+  const overallPercentage = totalStatementsTotal > 0 ? Math.round(totalStatementsCovered / totalStatementsTotal * 100) : 0;
+  return {
+    components,
+    totalStatementsCovered,
+    totalStatementsTotal,
+    overallPercentage
+  };
+}
+function getComponentCoverage(componentFilePath, coverage) {
+  const componentCoverage = coverage.components.get(componentFilePath);
+  return componentCoverage?.percentage ?? 0;
+}
+function findUncoveredComponents(coverage) {
+  return Array.from(coverage.components.values()).filter((c) => c.percentage === 0);
+}
+function findLowCoverageComponents(coverage, threshold = 50) {
+  return Array.from(coverage.components.values()).filter(
+    (c) => c.percentage > 0 && c.percentage < threshold
+  );
+}
+function summarizeCoverage(coverage) {
+  const uncovered = findUncoveredComponents(coverage);
+  const lowCoverage = findLowCoverageComponents(coverage, 50);
+  return [
+    `Overall Coverage: ${coverage.overallPercentage}%`,
+    `Statements: ${coverage.totalStatementsCovered}/${coverage.totalStatementsTotal}`,
+    `Components with 0% coverage: ${uncovered.length}`,
+    `Components with <50% coverage: ${lowCoverage.length}`
+  ].join("\n");
+}
+
+// src/dead-code-detector.ts
+function detectDeadCode(registry) {
+  const allComponents = registry.getAllComponents();
+  const allImports = registry.getAllImports();
+  const unusedComponents = [];
+  const orphanedComponents = [];
+  const unusedExports = [];
+  const importedIds = /* @__PURE__ */ new Set();
+  for (const imp of allImports) {
+    importedIds.add(imp.target);
+  }
+  for (const component of allComponents) {
+    const isImported = importedIds.has(component.filePath) || importedIds.has(component.id);
+    if (component.exportKind === "re-export" && !isImported) {
+      unusedExports.push({
+        filePath: component.filePath,
+        exportName: component.name,
+        reason: "re_exported_unused"
+      });
+    }
+    const hasConsumers = component.usedBy && component.usedBy.length > 0;
+    if (!isImported && !hasConsumers) {
+      if (component.exportKind === "default") {
+        unusedComponents.push({
+          id: component.id,
+          name: component.name,
+          filePath: component.filePath,
+          reason: "never_imported"
+        });
+      } else if (component.exportKind === "named") {
+        unusedComponents.push({
+          id: component.id,
+          name: component.name,
+          filePath: component.filePath,
+          reason: "unused_export"
+        });
+        unusedExports.push({
+          filePath: component.filePath,
+          exportName: component.name,
+          reason: "exported_but_unused"
+        });
+      }
+    }
+    if (!isImported && hasConsumers) {
+      const allConsumersAreUnused = component.usedBy.every((consumerId) => {
+        const consumer = registry.getComponent(consumerId);
+        return consumer && !isComponentUsed(consumer, registry);
+      });
+      if (allConsumersAreUnused) {
+        orphanedComponents.push({
+          id: component.id,
+          name: component.name,
+          filePath: component.filePath,
+          reason: "orphaned"
+        });
+      }
+    }
+  }
+  let totalPotentialBytes = 0;
+  for (const unused of unusedComponents) {
+    const bundleInfo = registry.getBundleInfo(unused.id);
+    if (bundleInfo) {
+      totalPotentialBytes += bundleInfo.exclusiveSize.gzip;
+    }
+  }
+  return {
+    unusedComponents,
+    orphanedComponents,
+    unusedExports,
+    totalPotentialBytes
+  };
+}
+function isComponentUsed(component, registry) {
+  if (!component.usedBy || component.usedBy.length === 0) {
+    return false;
+  }
+  for (const consumerId of component.usedBy) {
+    const consumer = registry.getComponent(consumerId);
+    if (consumer && isComponentUsed(consumer, registry)) {
+      return true;
+    }
+  }
+  return false;
+}
+function findSafeRemovalCandidates(report) {
+  return report.unusedComponents.filter((c) => c.reason !== "orphaned");
+}
+function formatDeadCodeReport(report) {
+  const lines = [];
+  if (report.unusedComponents.length > 0) {
+    lines.push(`
+\u274C Unused Components (${report.unusedComponents.length}):`);
+    for (const comp of report.unusedComponents.slice(0, 10)) {
+      lines.push(`  - ${comp.name} (${comp.filePath})`);
+    }
+    if (report.unusedComponents.length > 10) {
+      lines.push(`  ... and ${report.unusedComponents.length - 10} more`);
+    }
+  }
+  if (report.orphanedComponents.length > 0) {
+    lines.push(`
+\u{1F517} Orphaned Components (${report.orphanedComponents.length}):`);
+    for (const comp of report.orphanedComponents.slice(0, 5)) {
+      lines.push(`  - ${comp.name} (${comp.filePath})`);
+    }
+    if (report.orphanedComponents.length > 5) {
+      lines.push(`  ... and ${report.orphanedComponents.length - 5} more`);
+    }
+  }
+  if (report.unusedExports.length > 0) {
+    lines.push(`
+\u26A0\uFE0F  Unused Exports (${report.unusedExports.length}):`);
+    for (const exp of report.unusedExports.slice(0, 10)) {
+      lines.push(`  - ${exp.exportName} from ${exp.filePath}`);
+    }
+  }
+  if (report.totalPotentialBytes > 0) {
+    const kb = (report.totalPotentialBytes / 1024).toFixed(1);
+    lines.push(`
+\u{1F4BE} Potential Savings: ~${kb} KB`);
+  }
+  return lines.join("\n");
+}
+
+// src/api-snapshot.ts
+function createAPISnapshot(components, hash) {
+  const components_map = /* @__PURE__ */ new Map();
+  for (const comp of components) {
+    components_map.set(comp.id, {
+      componentId: comp.id,
+      name: comp.name,
+      filePath: comp.filePath,
+      exportKind: comp.exportKind,
+      props: comp.props,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  return {
+    components: components_map,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    hash
+  };
+}
+function snapshotToJSON(snapshot) {
+  const data = {
+    timestamp: snapshot.timestamp,
+    hash: snapshot.hash,
+    components: Array.from(snapshot.components.values())
+  };
+  return JSON.stringify(data, null, 2);
+}
+function snapshotFromJSON(json) {
+  const data = JSON.parse(json);
+  const components = new Map(data.components.map((c) => [c.componentId, c]));
+  return {
+    components,
+    timestamp: data.timestamp,
+    hash: data.hash
+  };
+}
+function compareSnapshots(oldSnapshot, newSnapshot) {
+  const addedComponents = [];
+  const removedComponents = [];
+  const modifiedComponents = [];
+  const breakingChanges = [];
+  const nonBreakingChanges = [];
+  for (const [id, oldComponent] of oldSnapshot.components) {
+    if (!newSnapshot.components.has(id)) {
+      removedComponents.push(oldComponent);
+      breakingChanges.push({
+        componentId: id,
+        componentName: oldComponent.name,
+        changeType: "export_removed",
+        description: `${oldComponent.name} export was removed`,
+        affectedItems: [oldComponent.filePath],
+        severity: "critical"
+      });
+    }
+  }
+  for (const [id, newComponent] of newSnapshot.components) {
+    const oldComponent = oldSnapshot.components.get(id);
+    if (!oldComponent) {
+      addedComponents.push(newComponent);
+    } else {
+      const changes = detectComponentChanges(oldComponent, newComponent);
+      if (changes.length > 0) {
+        modifiedComponents.push({
+          component: newComponent,
+          changes
+        });
+        for (const change of changes) {
+          if (change.type === "removed" || change.type === "modified" && change.field === "export_kind") {
+            breakingChanges.push({
+              componentId: id,
+              componentName: newComponent.name,
+              changeType: change.field === "export_kind" ? "export_kind_changed" : "prop_removed",
+              description: `${newComponent.name}: ${change.field} changed`,
+              affectedItems: [newComponent.filePath],
+              severity: change.field === "export_kind" ? "high" : "medium"
+            });
+          } else {
+            nonBreakingChanges.push(change);
+          }
+        }
+      }
+    }
+  }
+  return {
+    addedComponents,
+    removedComponents,
+    modifiedComponents,
+    breaking: breakingChanges,
+    nonBreaking: nonBreakingChanges
+  };
+}
+function detectComponentChanges(oldComponent, newComponent) {
+  const changes = [];
+  if (oldComponent.exportKind !== newComponent.exportKind) {
+    changes.push({
+      type: "modified",
+      field: "export_kind",
+      oldValue: oldComponent.exportKind,
+      newValue: newComponent.exportKind
+    });
+  }
+  const oldPropNames = new Set(oldComponent.props.map((p) => p.name));
+  const newPropNames = new Set(newComponent.props.map((p) => p.name));
+  for (const propName of oldPropNames) {
+    if (!newPropNames.has(propName)) {
+      changes.push({
+        type: "removed",
+        field: "prop",
+        oldValue: propName
+      });
+    }
+  }
+  for (const propName of newPropNames) {
+    if (!oldPropNames.has(propName)) {
+      const newProp = newComponent.props.find((p) => p.name === propName);
+      if (newProp?.required) {
+        changes.push({
+          type: "added",
+          field: "prop",
+          newValue: `${propName} (required)`
+        });
+      } else {
+        changes.push({
+          type: "added",
+          field: "prop",
+          newValue: propName
+        });
+      }
+    }
+  }
+  return changes;
+}
+function formatAPIChangeSummary(summary) {
+  const lines = [];
+  if (summary.addedComponents.length > 0) {
+    lines.push(`
+\u2728 Added Components (${summary.addedComponents.length}):`);
+    for (const comp of summary.addedComponents.slice(0, 5)) {
+      lines.push(`  + ${comp.name}`);
+    }
+  }
+  if (summary.removedComponents.length > 0) {
+    lines.push(`
+\u{1F5D1}\uFE0F  Removed Components (${summary.removedComponents.length}):`);
+    for (const comp of summary.removedComponents.slice(0, 5)) {
+      lines.push(`  - ${comp.name}`);
+    }
+  }
+  if (summary.breaking.length > 0) {
+    lines.push(`
+\u26A0\uFE0F  BREAKING CHANGES (${summary.breaking.length}):`);
+    for (const change of summary.breaking.slice(0, 10)) {
+      const icon = change.severity === "critical" ? "\u{1F6A8}" : "\u26A0\uFE0F ";
+      lines.push(
+        `  ${icon} [${change.severity.toUpperCase()}] ${change.componentName}: ${change.description}`
+      );
+    }
+    if (summary.breaking.length > 10) {
+      lines.push(`  ... and ${summary.breaking.length - 10} more`);
+    }
+  }
+  if (summary.modifiedComponents.length > 0 && summary.breaking.length === 0) {
+    lines.push(`
+\u{1F504} Modified Components (${summary.modifiedComponents.length}):`);
+    for (const mod of summary.modifiedComponents.slice(0, 5)) {
+      lines.push(`  ~ ${mod.component.name}`);
+    }
+  }
+  return lines.length > 0 ? lines.join("\n") : "No API changes detected.";
+}
+export {
+  COST_MODELS,
+  ComponentRegistry,
+  DEFAULT_TRAFFIC,
+  DEFAULT_WEIGHTS,
+  DependencyGraph,
+  analyzeUpgrade,
+  analyzeUpgrades,
+  compareSnapshots,
+  computeAllHealth,
+  computeComponentHealth,
+  createAPISnapshot,
+  createDefaultConfig,
+  detectDeadCode,
+  detectFramework,
+  estimateCostImpact,
+  estimateMonthlyCost,
+  extractImportsFromScript,
+  findLowCoverageComponents,
+  findSafeRemovalCandidates,
+  findUncoveredComponents,
+  formatAPIChangeSummary,
+  formatDeadCodeReport,
+  getComponentCoverage,
+  loadConfig,
+  loadCoverageData,
+  mapCoverageToComponents,
+  snapshotFromJSON,
+  snapshotToJSON,
+  summarizeCoverage
+};