@mandujs/core 0.54.32 → 0.55.0-beta.1

package/src/kitchen/api/bundle-inspector.ts

@@ -0,0 +1,179 @@
+/**
+ * Plan 18 P2-6 — Bundle inspector.
+ *
+ * Reads `.mandu/manifest.json` and adds disk-byte measurements per
+ * route bundle / island bundle / shared chunk so the Kitchen UI (and
+ * the supervisor context pack downstream) can answer "which island
+ * weighs the most" without each consumer re-stat'ing the same files.
+ *
+ * The manifest itself describes WHAT was emitted; this layer adds HOW
+ * MUCH. Stat failures are not fatal — a missing or torn file just
+ * shows up as 0 bytes so the rest of the report still renders.
+ */
+
+import fs from "fs/promises";
+import path from "path";
+import type { BundleManifest } from "../../bundler/types";
+
+export interface BundleSizeEntry {
+  /** Public path declared by the manifest (e.g. /.mandu/client/home.js). */
+  path: string;
+  /** On-disk size in bytes; 0 when the file is missing or unreadable. */
+  bytes: number;
+}
+
+export interface BundleRouteEntry extends BundleSizeEntry {
+  routeId: string;
+  priority: string;
+  dependencies: string[];
+  css?: string;
+}
+
+export interface BundleIslandEntry extends BundleSizeEntry {
+  islandId: string;
+  route: string;
+  priority: string;
+}
+
+export interface BundleReport {
+  /** False when `.mandu/manifest.json` is missing or malformed. */
+  loaded: boolean;
+  /** Reason the report could not be loaded; absent on success. */
+  reason?: string;
+  manifest?: {
+    version: number;
+    buildTime: string;
+    env: "development" | "production";
+  };
+  shared?: {
+    runtime: BundleSizeEntry;
+    vendor: BundleSizeEntry;
+    router?: BundleSizeEntry;
+  };
+  bundles: BundleRouteEntry[];
+  islands: BundleIslandEntry[];
+  totals: {
+    totalBytes: number;
+    sharedBytes: number;
+    bundleBytes: number;
+    islandBytes: number;
+    bundleCount: number;
+    islandCount: number;
+    largestIsland?: { id: string; route: string; bytes: number };
+    largestBundle?: { routeId: string; bytes: number };
+  };
+}
+
+async function fileBytes(rootDir: string, urlPath: string | undefined): Promise<number> {
+  if (!urlPath) return 0;
+  const rel = urlPath.startsWith("/") ? urlPath.slice(1) : urlPath;
+  try {
+    const stat = await fs.stat(path.join(rootDir, rel));
+    return stat.isFile() ? stat.size : 0;
+  } catch {
+    return 0;
+  }
+}
+
+async function readManifest(rootDir: string): Promise<BundleManifest | null> {
+  const manifestPath = path.join(rootDir, ".mandu", "manifest.json");
+  try {
+    const raw = await fs.readFile(manifestPath, "utf-8");
+    return JSON.parse(raw) as BundleManifest;
+  } catch {
+    return null;
+  }
+}
+
+export async function buildBundleReport(rootDir: string): Promise<BundleReport> {
+  const manifest = await readManifest(rootDir);
+  if (!manifest) {
+    return {
+      loaded: false,
+      reason: ".mandu/manifest.json is missing or malformed. Run `mandu build`.",
+      bundles: [],
+      islands: [],
+      totals: {
+        totalBytes: 0,
+        sharedBytes: 0,
+        bundleBytes: 0,
+        islandBytes: 0,
+        bundleCount: 0,
+        islandCount: 0,
+      },
+    };
+  }
+
+  const sharedRuntime: BundleSizeEntry = {
+    path: manifest.shared?.runtime ?? "",
+    bytes: await fileBytes(rootDir, manifest.shared?.runtime),
+  };
+  const sharedVendor: BundleSizeEntry = {
+    path: manifest.shared?.vendor ?? "",
+    bytes: await fileBytes(rootDir, manifest.shared?.vendor),
+  };
+  const sharedRouter: BundleSizeEntry | undefined = manifest.shared?.router
+    ? { path: manifest.shared.router, bytes: await fileBytes(rootDir, manifest.shared.router) }
+    : undefined;
+
+  const bundleEntries: BundleRouteEntry[] = [];
+  for (const [routeId, entry] of Object.entries(manifest.bundles ?? {})) {
+    bundleEntries.push({
+      routeId,
+      path: entry.js,
+      bytes: await fileBytes(rootDir, entry.js),
+      priority: entry.priority,
+      dependencies: entry.dependencies,
+      css: entry.css,
+    });
+  }
+
+  const islandEntries: BundleIslandEntry[] = [];
+  for (const [islandId, entry] of Object.entries(manifest.islands ?? {})) {
+    islandEntries.push({
+      islandId,
+      path: entry.js,
+      bytes: await fileBytes(rootDir, entry.js),
+      route: entry.route,
+      priority: entry.priority,
+    });
+  }
+
+  // Sort biggest-first — that's what the operator wants to see at the top.
+  bundleEntries.sort((a, b) => b.bytes - a.bytes);
+  islandEntries.sort((a, b) => b.bytes - a.bytes);
+
+  const sharedBytes = sharedRuntime.bytes + sharedVendor.bytes + (sharedRouter?.bytes ?? 0);
+  const bundleBytes = bundleEntries.reduce((sum, b) => sum + b.bytes, 0);
+  const islandBytes = islandEntries.reduce((sum, b) => sum + b.bytes, 0);
+
+  return {
+    loaded: true,
+    manifest: {
+      version: manifest.version,
+      buildTime: manifest.buildTime,
+      env: manifest.env,
+    },
+    shared: {
+      runtime: sharedRuntime,
+      vendor: sharedVendor,
+      router: sharedRouter,
+    },
+    bundles: bundleEntries,
+    islands: islandEntries,
+    totals: {
+      totalBytes: sharedBytes + bundleBytes + islandBytes,
+      sharedBytes,
+      bundleBytes,
+      islandBytes,
+      bundleCount: bundleEntries.length,
+      islandCount: islandEntries.length,
+      largestIsland: islandEntries[0]
+        ? { id: islandEntries[0].islandId, route: islandEntries[0].route, bytes: islandEntries[0].bytes }
+        : undefined,
+      largestBundle: bundleEntries[0]
+        ? { routeId: bundleEntries[0].routeId, bytes: bundleEntries[0].bytes }
+        : undefined,
+    },
+  };
+}

package/src/kitchen/api/errors-grouping.ts

@@ -1,126 +1,126 @@
-/**
- * Plan 18 P1-4 — Error grouping for the Kitchen Errors panel.
- *
- * The Kitchen error ring buffer (`kitchen-handler.ts:storedErrors`) is a
- * flat list. When the same hydration failure or unhandled rejection
- * fires repeatedly on every render, the buffer fills with near-identical
- * rows and the operator has to scroll through them to spot the count.
- *
- * `groupErrors()` collapses runs of "the same error" into one row with
- * count / first-seen / last-seen / affected-sources / a representative
- * sample. The group key is intentionally conservative so that
- * superficially different errors stay separate:
- *
- *   key = sha1(`${type}|${source}|${normalize(message)}`)
- *
- * `normalize` collapses obvious noise (numbers, UUIDs, file:line refs)
- * but leaves stack-shape and message word order intact. This is a
- * smaller hammer than full stack-trace fingerprinting — that lives
- * elsewhere if we ever need it.
- */
-
-import crypto from "node:crypto";
-
-export interface KitchenErrorLike {
-  id?: string;
-  type?: string;
-  severity?: string;
-  message: string;
-  stack?: string;
-  url?: string;
-  source?: string;
-  line?: number;
-  column?: number;
-  timestamp?: number;
-}
-
-export interface GroupedError {
-  /** Stable hash of (type, source, normalized message). */
-  key: string;
-  /** How many raw errors collapsed into this group. */
-  count: number;
-  /** Representative event — the most recent occurrence. */
-  sample: KitchenErrorLike;
-  /** Severity of the sample. Same across the group in practice. */
-  severity: string | undefined;
-  /** Earliest timestamp seen for this signature. */
-  firstSeen: number;
-  /** Latest timestamp seen for this signature. */
-  lastSeen: number;
-  /** Distinct source / file refs across the group, capped for transport. */
-  affectedSources: string[];
-}
-
-const NUM_RE = /\d{1,}/g;
-const UUID_RE = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/gi;
-const HEX_RE = /\b0x[0-9a-f]+\b/gi;
-
-/**
- * Replace noise that varies run-to-run but doesn't change which bug is
- * being reported. Kept intentionally narrow so user-visible message
- * structure stays recognizable for the operator.
- */
-export function normalizeMessage(message: string): string {
-  return message
-    .replace(UUID_RE, "<UUID>")
-    .replace(HEX_RE, "<HEX>")
-    .replace(NUM_RE, "<N>")
-    .trim()
-    .toLowerCase();
-}
-
-export function errorKey(err: KitchenErrorLike): string {
-  const parts = [
-    err.type ?? "runtime",
-    err.source ?? "unknown",
-    normalizeMessage(err.message ?? ""),
-  ].join("|");
-  return crypto.createHash("sha1").update(parts).digest("hex").slice(0, 16);
-}
-
-export interface GroupOptions {
-  /** Cap `affectedSources` length in the response. Default 5. */
-  maxSourcesPerGroup?: number;
-}
-
-/**
- * Collapse a flat error list into `GroupedError[]`, newest-group first.
- * Stable: a single error becomes a group of size 1.
- */
-export function groupErrors(errors: readonly KitchenErrorLike[], options: GroupOptions = {}): GroupedError[] {
-  const maxSources = options.maxSourcesPerGroup ?? 5;
-  const byKey = new Map<string, GroupedError>();
-
-  for (const err of errors) {
-    const key = errorKey(err);
-    const ts = err.timestamp ?? 0;
-    const existing = byKey.get(key);
-    if (!existing) {
-      const sources = err.source ? [err.source] : [];
-      byKey.set(key, {
-        key,
-        count: 1,
-        sample: err,
-        severity: err.severity,
-        firstSeen: ts,
-        lastSeen: ts,
-        affectedSources: sources,
-      });
-      continue;
-    }
-    existing.count += 1;
-    if (ts < existing.firstSeen || existing.firstSeen === 0) existing.firstSeen = ts;
-    if (ts > existing.lastSeen) {
-      existing.lastSeen = ts;
-      existing.sample = err; // newest wins so the operator sees the freshest message
-    }
-    if (err.source && !existing.affectedSources.includes(err.source)) {
-      if (existing.affectedSources.length < maxSources) {
-        existing.affectedSources.push(err.source);
-      }
-    }
-  }
-
-  // Newest groups first — the operator wants the most recent regression up top.
-  return Array.from(byKey.values()).sort((a, b) => b.lastSeen - a.lastSeen);
-}
+/**
+ * Plan 18 P1-4 — Error grouping for the Kitchen Errors panel.
+ *
+ * The Kitchen error ring buffer (`kitchen-handler.ts:storedErrors`) is a
+ * flat list. When the same hydration failure or unhandled rejection
+ * fires repeatedly on every render, the buffer fills with near-identical
+ * rows and the operator has to scroll through them to spot the count.
+ *
+ * `groupErrors()` collapses runs of "the same error" into one row with
+ * count / first-seen / last-seen / affected-sources / a representative
+ * sample. The group key is intentionally conservative so that
+ * superficially different errors stay separate:
+ *
+ *   key = sha1(`${type}|${source}|${normalize(message)}`)
+ *
+ * `normalize` collapses obvious noise (numbers, UUIDs, file:line refs)
+ * but leaves stack-shape and message word order intact. This is a
+ * smaller hammer than full stack-trace fingerprinting — that lives
+ * elsewhere if we ever need it.
+ */
+
+import crypto from "node:crypto";
+
+export interface KitchenErrorLike {
+  id?: string;
+  type?: string;
+  severity?: string;
+  message: string;
+  stack?: string;
+  url?: string;
+  source?: string;
+  line?: number;
+  column?: number;
+  timestamp?: number;
+}
+
+export interface GroupedError {
+  /** Stable hash of (type, source, normalized message). */
+  key: string;
+  /** How many raw errors collapsed into this group. */
+  count: number;
+  /** Representative event — the most recent occurrence. */
+  sample: KitchenErrorLike;
+  /** Severity of the sample. Same across the group in practice. */
+  severity: string | undefined;
+  /** Earliest timestamp seen for this signature. */
+  firstSeen: number;
+  /** Latest timestamp seen for this signature. */
+  lastSeen: number;
+  /** Distinct source / file refs across the group, capped for transport. */
+  affectedSources: string[];
+}
+
+const NUM_RE = /\d{1,}/g;
+const UUID_RE = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/gi;
+const HEX_RE = /\b0x[0-9a-f]+\b/gi;
+
+/**
+ * Replace noise that varies run-to-run but doesn't change which bug is
+ * being reported. Kept intentionally narrow so user-visible message
+ * structure stays recognizable for the operator.
+ */
+export function normalizeMessage(message: string): string {
+  return message
+    .replace(UUID_RE, "<UUID>")
+    .replace(HEX_RE, "<HEX>")
+    .replace(NUM_RE, "<N>")
+    .trim()
+    .toLowerCase();
+}
+
+export function errorKey(err: KitchenErrorLike): string {
+  const parts = [
+    err.type ?? "runtime",
+    err.source ?? "unknown",
+    normalizeMessage(err.message ?? ""),
+  ].join("|");
+  return crypto.createHash("sha1").update(parts).digest("hex").slice(0, 16);
+}
+
+export interface GroupOptions {
+  /** Cap `affectedSources` length in the response. Default 5. */
+  maxSourcesPerGroup?: number;
+}
+
+/**
+ * Collapse a flat error list into `GroupedError[]`, newest-group first.
+ * Stable: a single error becomes a group of size 1.
+ */
+export function groupErrors(errors: readonly KitchenErrorLike[], options: GroupOptions = {}): GroupedError[] {
+  const maxSources = options.maxSourcesPerGroup ?? 5;
+  const byKey = new Map<string, GroupedError>();
+
+  for (const err of errors) {
+    const key = errorKey(err);
+    const ts = err.timestamp ?? 0;
+    const existing = byKey.get(key);
+    if (!existing) {
+      const sources = err.source ? [err.source] : [];
+      byKey.set(key, {
+        key,
+        count: 1,
+        sample: err,
+        severity: err.severity,
+        firstSeen: ts,
+        lastSeen: ts,
+        affectedSources: sources,
+      });
+      continue;
+    }
+    existing.count += 1;
+    if (ts < existing.firstSeen || existing.firstSeen === 0) existing.firstSeen = ts;
+    if (ts > existing.lastSeen) {
+      existing.lastSeen = ts;
+      existing.sample = err; // newest wins so the operator sees the freshest message
+    }
+    if (err.source && !existing.affectedSources.includes(err.source)) {
+      if (existing.affectedSources.length < maxSources) {
+        existing.affectedSources.push(err.source);
+      }
+    }
+  }
+
+  // Newest groups first — the operator wants the most recent regression up top.
+  return Array.from(byKey.values()).sort((a, b) => b.lastSeen - a.lastSeen);
+}

package/src/kitchen/api/file-api.ts

@@ -229,17 +229,17 @@ export class FileAPI {
     for (const line of stdout.split("\n")) {
       if (!line.trim()) continue;
 
-      const statusCode = line.substring(0, 2);
-      const gitFilePath = line.substring(3).trim();
-      const filePath = this.getProjectRelativePath(gitFilePath, gitRoot);
-      if (!filePath || filePath === ".") {
-        continue;
-      }
-
-      changes.push({
-        filePath,
-        status: parseGitStatus(statusCode),
-      });
+      const statusCode = line.substring(0, 2);
+      const gitFilePath = line.substring(3).trim();
+      const filePath = this.getProjectRelativePath(gitFilePath, gitRoot);
+      if (!filePath || filePath === ".") {
+        continue;
+      }
+
+      changes.push({
+        filePath,
+        status: parseGitStatus(statusCode),
+      });
     }
 
     return changes;

package/src/kitchen/kitchen-handler.ts

@@ -16,6 +16,7 @@ import { GuardDecisionManager } from "./api/guard-decisions";
 import { ContractPlaygroundAPI } from "./api/contract-api";
 import { handleAgentContextRequest } from "./api/agent-devtools-api";
 import { groupErrors } from "./api/errors-grouping";
+import { buildBundleReport } from "./api/bundle-inspector";
 import type { BundleManifest } from "../bundler/types";
 import type { DiagnoseReport } from "../diagnose/types";
 import { runExtendedDiagnose } from "../diagnose/run";
@@ -575,6 +576,41 @@ export class KitchenHandler {
       return Response.json({ errors: storedErrors, count: storedErrors.length });
     }
 
+    // Plan 18 P2-6 — Bundle inspector. Reads .mandu/manifest.json and
+    // adds byte sizes from disk so the operator can see at a glance
+    // which island is largest, which routes have CSS chunks, and how
+    // big the shared runtime / vendor / router bundles are.
+    if (sub === "/api/bundle" && req.method === "GET") {
+      const report = await buildBundleReport(this.options.rootDir);
+      return Response.json(report);
+    }
+
+    // Plan 18 P2-5 — Diagnose panel data. Runs `runExtendedDiagnose`
+    // and returns the structured report so the Kitchen UI can render
+    // every rule (manifest_freshness / nested_internal_core /
+    // package_export_gaps / a11y_hints / ...) on one screen with the
+    // suggestion line attached. Same source as P0-2's signal collector
+    // but always fresh (no caching) so the operator's "Refresh" press
+    // reflects the latest state.
+    if (sub === "/api/diagnose" && req.method === "GET") {
+      const report = await runDiagnoseSignal(this.options.rootDir);
+      if (!report) {
+        return Response.json({
+          healthy: false,
+          errorCount: 1,
+          warningCount: 0,
+          checks: [{
+            ok: false,
+            rule: "diagnose_runner",
+            severity: "error",
+            message: "Diagnose runner failed to execute. See dev server logs.",
+          }],
+          summary: { total: 1, passed: 0, failed: 1 },
+        });
+      }
+      return Response.json(report);
+    }
+
     // Plan 18 P1-4 — Errors panel grouped view. Collapses identical
     // signatures into one row with count/firstSeen/lastSeen/affected
     // sources. The operator no longer scrolls past five copies of the