@aphrody/m3-showcase 3.3.4

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@aphrody/m3-showcase",
+  "version": "3.3.4",
+  "description": "Adaptive Aphrody M3 web showcase with mobile, desktop and TV layouts, a Bun UI/API executable and a prepared canonical Tauri desktop shell.",
+  "license": "Apache-2.0",
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "inventory": "bun scripts/inventory.ts",
+    "dev": "bun scripts/inventory.ts && m3-bun dev",
+    "build": "bun scripts/inventory.ts && m3-bun build",
+    "serve": "m3-bun serve",
+    "compile": "bun scripts/inventory.ts && m3-bun compile",
+    "package": "m3-bun package",
+    "deploy": "m3-bun deploy all",
+    "smoke": "m3-bun smoke",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "bun test ./test && bun run test:dom",
+    "icons": "bun scripts/icons.ts",
+    "tauri": "bun scripts/tauri.ts",
+    "test:dom": "bun test --preload @aphrody/m3-config/test/dom ./test-dom"
+  },
+  "dependencies": {
+    "@aphrody/ag-ui": "1.0.1",
+    "@aphrody/assets": "0.1.0",
+    "@aphrody/canvas": "1.0.9-aphrody.3",
+    "@aphrody/eslint-plugin-m3": "3.3.3",
+    "@aphrody/identity": "0.1.0",
+    "@aphrody/m3": "3.3.4",
+    "@aphrody/m3-ai": "3.3.4",
+    "@aphrody/m3-baseui": "3.3.4",
+    "@aphrody/m3-bun": "3.3.4",
+    "@aphrody/m3-codemods": "3.3.4",
+    "@aphrody/m3-design": "3.3.4",
+    "@aphrody/m3-explorer": "3.3.4",
+    "@aphrody/m3-fonts": "3.3.4",
+    "@aphrody/m3-forms": "3.3.4",
+    "@aphrody/m3-front": "3.3.4",
+    "@aphrody/m3-icons": "3.3.4",
+    "@aphrody/m3-mcp": "3.3.4",
+    "@aphrody/m3-motion": "3.3.4",
+    "@aphrody/m3-next": "3.3.4",
+    "@aphrody/m3-os-themes": "3.3.4",
+    "@aphrody/m3-primitives": "3.3.4",
+    "@aphrody/m3-react": "3.3.4",
+    "@aphrody/m3-reader": "3.3.4",
+    "@aphrody/m3-tailwind": "3.3.4",
+    "@aphrody/m3-theme": "3.3.4",
+    "@aphrody/m3-tokens": "3.3.4",
+    "@aphrody/material-design-icons": "1.0.0",
+    "@aphrody/scaffold": "1.0.0-canary",
+    "@modelcontextprotocol/sdk": "^1.31.0",
+    "react-hook-form": "^7.89.0"
+  },
+  "engines": {
+    "bun": ">=1.4.2"
+  }
+}

package/scripts/browser-contract.ts

@@ -0,0 +1,400 @@
+#!/usr/bin/env bun
+// SPDX-License-Identifier: Apache-2.0
+// Chromium interaction checks against an existing local production server; no snapshots or installations.
+import assert from "node:assert/strict";
+import { mkdir } from "node:fs/promises";
+import { dirname, isAbsolute, relative, resolve, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+import { chromium, type Page } from "playwright-core";
+import { PAGES } from "../src/pages/index.ts";
+import { CHROMIUM_ARGS } from "./shots.ts";
+
+const RUNS = fileURLToPath(new URL("../../../../.coord/runs/m3-prod/", import.meta.url));
+interface Check {
+  name: string;
+  passed: boolean;
+  durationMs: number;
+  error?: string;
+}
+export interface BrowserContractReport {
+  url: string;
+  timestamp: string;
+  browser: string;
+  checks: Check[];
+  navigation: { route: string; tag: string; href: string | null }[];
+  inputUndefined?: { type: string; attribute: string | null };
+  consoleErrors: string[];
+  httpFailures: string[];
+  externalRequests: string[];
+}
+
+/** Artifacts are restricted to the integrating agent's existing qualification directory. */
+export function outputPath(value = resolve(RUNS, "browser-contract.json")): string {
+  const target = resolve(value);
+  const within = relative(RUNS, target);
+  if (
+    !within ||
+    within === ".." ||
+    within.startsWith(".." + sep) ||
+    isAbsolute(within) ||
+    !target.endsWith(".json")
+  )
+    throw new TypeError("Output must be a JSON file under " + RUNS);
+  return target;
+}
+function localUrl(value: string): string {
+  const url = new URL(value);
+  if (
+    !["http:", "https:"].includes(url.protocol) ||
+    !["localhost", "127.0.0.1", "[::1]"].includes(url.hostname) ||
+    url.username ||
+    url.password
+  )
+    throw new TypeError("Use a local HTTP server URL.");
+  return url.origin;
+}
+async function ready(page: Page, route: string): Promise<void> {
+  await page.waitForFunction(
+    (id) => document.querySelector('[data-testid="main"]')?.getAttribute("data-route") === id,
+    route,
+  );
+  await page.locator("main h1").waitFor();
+  assert.equal(await page.locator("h1").count(), 1, "Each page must have one document heading");
+  assert.doesNotMatch(await page.locator("main h1").innerText(), /Unable to load/i);
+}
+async function destination(page: Page, route: string): Promise<void> {
+  await page.getByTestId("nav-" + route).click();
+  await ready(page, route);
+  assert.equal(new URL(page.url()).hash, "#/" + route);
+}
+async function containsText(page: Page, selector: string, text: string): Promise<void> {
+  await page.waitForFunction(
+    ({ selector: query, text: expectedText }) =>
+      document.querySelector(query)?.textContent?.includes(expectedText),
+    { selector, text },
+  );
+}
+async function scheme(page: Page, expected: "light" | "dark"): Promise<void> {
+  await page.waitForFunction(
+    (value) => getComputedStyle(document.documentElement).colorScheme === value,
+    expected,
+  );
+}
+async function layout(page: Page, expected: string): Promise<void> {
+  await page.waitForFunction(
+    (value) =>
+      document.querySelector('[data-testid="shell"]')?.getAttribute("data-layout") === value,
+    expected,
+  );
+}
+
+export async function browserContract(baseUrl: string): Promise<BrowserContractReport> {
+  const url = localUrl(baseUrl);
+  const browser = await chromium.launch({ headless: true, args: CHROMIUM_ARGS });
+  const report: BrowserContractReport = {
+    url,
+    timestamp: new Date().toISOString(),
+    browser: browser.version(),
+    checks: [],
+    navigation: [],
+    consoleErrors: [],
+    httpFailures: [],
+    externalRequests: [],
+  };
+  const context = await browser.newContext({
+    viewport: { width: 1280, height: 800 },
+    colorScheme: "light",
+    reducedMotion: "reduce",
+    locale: "en-US",
+    timezoneId: "UTC",
+  });
+  const page = await context.newPage();
+  page.setDefaultTimeout(8_000);
+  page.setDefaultNavigationTimeout(20_000);
+  async function check(name: string, action: () => Promise<void>): Promise<void> {
+    const start = performance.now();
+    try {
+      await action();
+      report.checks.push({ name, passed: true, durationMs: Math.round(performance.now() - start) });
+      console.log("PASS " + name);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      report.checks.push({
+        name,
+        passed: false,
+        durationMs: Math.round(performance.now() - start),
+        error: message.slice(0, 4000),
+      });
+      console.error("FAIL " + name + ": " + message.split("\n")[0]);
+    }
+  }
+  page.on("console", (message) => {
+    if (message.type() === "error") report.consoleErrors.push(message.text());
+  });
+  page.on("pageerror", (error) => report.consoleErrors.push(error.message));
+  page.on("response", (response) => {
+    if (response.status() >= 400)
+      report.httpFailures.push(response.status() + " " + response.url());
+  });
+  await context.route("**/*", async (route) => {
+    const requestUrl = new URL(route.request().url());
+    if (requestUrl.origin === url || ["data:", "blob:"].includes(requestUrl.protocol))
+      await route.continue();
+    else {
+      report.externalRequests.push(requestUrl.origin);
+      await route.abort();
+    }
+  });
+  try {
+    await page.goto(url + "/#/overview", { waitUntil: "networkidle" });
+    await ready(page, "overview");
+    await check("Chromium input type fallback", async () => {
+      report.inputUndefined = await page.evaluate(() => {
+        const input = document.createElement("input");
+        input.type = undefined as unknown as string;
+        return { type: input.type, attribute: input.getAttribute("type") };
+      });
+      assert.deepEqual(report.inputUndefined, { type: "text", attribute: "undefined" });
+    });
+    for (const route of Object.keys(PAGES)) {
+      // eslint-disable-next-line no-await-in-loop -- Navigation runs sequentially in one real browser history.
+      await check("Navigate and announce " + route, async () => {
+        const control = page.getByTestId("nav-" + route);
+        report.navigation.push({
+          route,
+          tag: await control.evaluate((element) => element.tagName),
+          href: await control.getAttribute("href"),
+        });
+        await destination(page, route);
+        assert.equal(await control.getAttribute("aria-current"), "page");
+        if (route !== "overview") assert.match(await page.title(), new RegExp(route, "i"));
+      });
+    }
+    await check("Destinations expose native deep links", async () => {
+      assert.equal(report.navigation.length, 15);
+      for (const control of report.navigation) {
+        assert.equal(control.tag, "A", control.route + " must be a navigation link");
+        assert.equal(control.href, "#/" + control.route);
+      }
+    });
+    await check("Skip link focuses content and preserves the route", async () => {
+      const before = page.url();
+      await page.getByRole("link", { name: "Skip to content", exact: true }).focus();
+      await page.keyboard.press("Enter");
+      assert.equal(page.url(), before);
+      assert.equal(await page.evaluate(() => document.activeElement?.id), "main");
+    });
+    await check("Light and dark choices persist across reload", async () => {
+      await destination(page, "theme");
+      await page.evaluate(() => localStorage.clear());
+      await page.reload({ waitUntil: "networkidle" });
+      await ready(page, "theme");
+      await page.getByRole("combobox", { name: "Colour mode", exact: true }).selectOption("dark");
+      await scheme(page, "dark");
+      await page.reload({ waitUntil: "networkidle" });
+      await ready(page, "theme");
+      await scheme(page, "dark");
+      assert.equal(
+        await page.getByRole("combobox", { name: "Colour mode", exact: true }).inputValue(),
+        "dark",
+      );
+      await page.getByRole("combobox", { name: "Colour mode", exact: true }).selectOption("light");
+      await scheme(page, "light");
+      await page.reload({ waitUntil: "networkidle" });
+      await ready(page, "theme");
+      await scheme(page, "light");
+      assert.equal(
+        await page.getByRole("combobox", { name: "Colour mode", exact: true }).inputValue(),
+        "light",
+      );
+    });
+    await check("Live layout overrides persist and auto follows the viewport", async () => {
+      await destination(page, "adaptive");
+      await page.getByTestId("layout-mobile").click();
+      await layout(page, "mobile");
+      assert.equal(await page.getByTestId("bottom-bar").count(), 1);
+      await page.getByTestId("layout-tv").click();
+      await layout(page, "tv");
+      await page.reload({ waitUntil: "networkidle" });
+      await ready(page, "adaptive");
+      await layout(page, "tv");
+      assert.equal(await page.getByTestId("drawer").count(), 1);
+      await page.getByTestId("layout-auto").click();
+      await layout(page, "desktop");
+      await page.setViewportSize({ width: 390, height: 844 });
+      await layout(page, "mobile");
+      await page.setViewportSize({ width: 1280, height: 800 });
+      await layout(page, "desktop");
+    });
+    await check("TV arrows move spatial focus and Enter activates a tile", async () => {
+      await destination(page, "adaptive");
+      await page.getByTestId("layout-tv").click();
+      await layout(page, "tv");
+      await page.locator('[data-tile="tile 1"]').focus();
+      await page.keyboard.press("ArrowRight");
+      assert.equal(
+        await page.evaluate(() => document.activeElement?.getAttribute("data-tile")),
+        "tile 2",
+      );
+      await page.keyboard.press("Enter");
+      await containsText(page, '[data-testid="dpad-focus"]', "tile 2 (activated)");
+      await page.keyboard.press("ArrowDown");
+      assert.equal(
+        await page.evaluate(() => document.activeElement?.getAttribute("data-tile")),
+        "tile 8",
+      );
+      await page.getByTestId("layout-auto").click();
+      await layout(page, "desktop");
+    });
+    await check("TV Back returns to the previous destination", async () => {
+      await destination(page, "overview");
+      await destination(page, "adaptive");
+      await page.getByTestId("layout-tv").click();
+      await layout(page, "tv");
+      await page.getByTestId("nav-adaptive").focus();
+      await page.keyboard.press("Escape");
+      await ready(page, "overview");
+      await destination(page, "adaptive");
+      await page.getByTestId("layout-auto").click();
+      await layout(page, "desktop");
+    });
+    await check("Forms validate, preview valid values and reset", async () => {
+      await destination(page, "forms");
+      await page.getByRole("button", { name: "Preview profile", exact: true }).click();
+      await page.getByText("Enter a name with at least two characters.", { exact: true }).waitFor();
+      await page.getByRole("textbox", { name: /Display name/ }).fill("Ada");
+      await page.getByRole("textbox", { name: /Email address/ }).fill("ada@example.invalid");
+      await page.getByLabel("These are local sample values").check();
+      await page.getByRole("button", { name: "Preview profile", exact: true }).click();
+      await containsText(page, "main [role=status]", "Valid preview ready.");
+      assert.match(await page.locator("aside").innerText(), /Ada/);
+      await page.getByRole("button", { name: "Reset form", exact: true }).click();
+      assert.equal(await page.getByRole("textbox", { name: /Display name/ }).inputValue(), "");
+      assert.equal(await page.getByLabel("These are local sample values").isChecked(), false);
+      await containsText(page, "main [role=status]", "No profile has been saved.");
+    });
+    await check(
+      "Explorer selects and opens with keyboard, changes star, filters and grids",
+      async () => {
+        await destination(page, "explorer");
+        const row = page.getByRole("row").filter({ hasText: "Material notes.md" });
+        await row.focus();
+        await page.keyboard.press("Space");
+        await containsText(page, "main [role=status]", "Selected Material notes.md");
+        assert.equal(await row.getAttribute("aria-selected"), "true");
+        await page.keyboard.press("Enter");
+        await containsText(page, "main [role=status]", "Opened local preview: Material notes.md");
+        await row.getByRole("button", { name: "Unstar", exact: true }).click();
+        assert.equal(await row.getByRole("button", { name: "Star", exact: true }).count(), 1);
+        const explorer = page.getByRole("region", { name: "Google Drive File List", exact: true });
+        await explorer.getByRole("button", { name: /^People/ }).click();
+        assert.equal(await explorer.locator("tbody tr").count(), 2);
+        await explorer.getByRole("button", { name: "Grid view", exact: true }).click();
+        assert.equal(await explorer.locator("table").count(), 0);
+        assert.equal(
+          await explorer.getByRole("button", { name: "Design studies", exact: true }).count(),
+          1,
+        );
+        assert.equal(
+          await explorer.getByRole("button", { name: "Colour palette.json", exact: true }).count(),
+          1,
+        );
+      },
+    );
+    await check("Reader changes page and reading mode with local artwork", async () => {
+      await destination(page, "reader");
+      await containsText(page, "main [role=status]", "Illustration page: 1");
+      await page.getByRole("button", { name: "Page suivante", exact: true }).click();
+      await containsText(page, "main [role=status]", "Illustration page: 2");
+      await page.getByRole("button", { name: "Page précédente", exact: true }).click();
+      await containsText(page, "main [role=status]", "Illustration page: 1");
+      await page
+        .getByRole("button", { name: "Mode de lecture vertical (webtoon)", exact: true })
+        .click();
+      const vertical = page.locator('main [aria-label$="lecture verticale"]');
+      await vertical.waitFor();
+      assert.equal(await vertical.getAttribute("tabindex"), "0");
+      await page.getByRole("button", { name: "Annotated pages", exact: true }).click();
+      assert.equal(
+        await page
+          .getByRole("button", { name: "Annotated pages", exact: true })
+          .getAttribute("aria-pressed"),
+        "true",
+      );
+      await page.getByText("Local demonstration page 1.", { exact: false }).first().waitFor();
+      assert.equal((await page.locator('main img[src^="data:image/svg+xml"]').count()) > 0, true);
+    });
+    await check("Design generates inspectable CSS, tokens and React source", async () => {
+      await destination(page, "design");
+      await page
+        .getByRole("textbox", { name: "Describe the interface", exact: true })
+        .fill("A minimal dashboard for developers, with a list-detail layout.");
+      await page.getByRole("button", { name: "Generate design", exact: true }).click();
+      await containsText(page, "main [role=status]", "Design generated locally.");
+      const files = page.getByRole("combobox", { name: "File", exact: true });
+      assert.equal(await files.locator("option").count(), 3);
+      assert.match(await page.locator("main").innerText(), /--md-sys-color-primary/);
+      await files.selectOption("src/index.tsx");
+      assert.match(await page.locator("main").innerText(), /@aphrody[/]/);
+    });
+    await check("AI fixture renders events and Stop restores the composer", async () => {
+      await destination(page, "ai");
+      await page
+        .getByRole("textbox", { name: "Draft for the local protocol fixture", exact: true })
+        .fill("Inspect the package inventory.");
+      await page.getByRole("button", { name: "Send", exact: true }).click();
+      await page
+        .getByText(/Local protocol fixture: your draft contains/)
+        .first()
+        .waitFor();
+      await page
+        .getByRole("status")
+        .filter({ hasText: /^Ready$/ })
+        .waitFor();
+      await page.getByRole("button", { name: "Send", exact: true }).click();
+      await page.getByRole("button", { name: "Stop", exact: true }).click();
+      await containsText(page, "main [role=status]", "Stream stopped.");
+      await page.getByRole("button", { name: "Stop", exact: true }).waitFor({ state: "detached" });
+      assert.equal(await page.getByRole("button", { name: "Stop", exact: true }).count(), 0);
+      assert.equal(await page.getByRole("button", { name: "Send", exact: true }).isEnabled(), true);
+    });
+    await check(
+      "Local rendering has no console errors, HTTP failures or external requests",
+      async () => {
+        assert.deepEqual(report.consoleErrors, []);
+        assert.deepEqual(report.httpFailures, []);
+        assert.deepEqual(report.externalRequests, []);
+      },
+    );
+  } finally {
+    await context.close();
+    await browser.close();
+  }
+  return report;
+}
+
+if (import.meta.main) {
+  const args = process.argv.slice(2);
+  if (args.includes("--help")) {
+    console.log(
+      "bun apps/showcase/scripts/browser-contract.ts [--url http://127.0.0.1:3312] [--out " +
+        resolve(RUNS, "browser-contract.json") +
+        "]",
+    );
+  } else {
+    const value = (flag: string) => {
+      const index = args.indexOf(flag);
+      if (index < 0) return undefined;
+      const next = args[index + 1];
+      if (!next || next.startsWith("--")) throw new TypeError("Missing value for " + flag);
+      return next;
+    };
+    const out = outputPath(value("--out"));
+    const report = await browserContract(value("--url") ?? "http://127.0.0.1:3312");
+    await mkdir(dirname(out), { recursive: true });
+    await Bun.write(out, JSON.stringify(report, null, 2) + "\n");
+    const failures = report.checks.filter((check) => !check.passed);
+    console.log(report.checks.length + " checks, " + failures.length + " failures; " + out);
+    if (failures.length) process.exitCode = 1;
+  }
+}

package/scripts/icons.ts

@@ -0,0 +1,56 @@
+// SPDX-License-Identifier: Apache-2.0
+import { resolve } from "node:path";
+
+export const SHOWCASE_ROOT = resolve(import.meta.dir, "..");
+export const APHRODY_ROOT = resolve(SHOWCASE_ROOT, "../../..");
+export const TAURI_ROOT = resolve(APHRODY_ROOT, "crates/ui/m3-showcase");
+/** Canonical Aphrody artwork stays in its protected identity owner; generated icons are ignored. */
+export const ICON_SOURCE = resolve(
+  SHOWCASE_ROOT,
+  "../../../crates/ui/identity/assets/brand/icon.svg",
+);
+
+export function iconCommand(root = TAURI_ROOT, executable = Bun.which("tauri")): string[] {
+  if (!executable)
+    throw new Error(
+      "The installed Tauri CLI is missing. Qualify the declared Aphrody/Yolo toolchain before generating icons.",
+    );
+  return [
+    executable,
+    "icon",
+    ICON_SOURCE,
+    "--output",
+    resolve(root, "icons"),
+    "--ios-color",
+    "#6750a4",
+  ];
+}
+
+export async function generateIcons(args: string[] = [], root = TAURI_ROOT): Promise<void> {
+  if (!(await Bun.file(ICON_SOURCE).exists()))
+    throw new Error(`Canonical Aphrody icon is missing: ${ICON_SOURCE}`);
+  const command = iconCommand(root);
+  if (args.includes("--plan")) {
+    console.log(
+      JSON.stringify({ command, source: ICON_SOURCE, output: resolve(root, "icons") }, null, 2),
+    );
+    return;
+  }
+  const process = Bun.spawn(command, {
+    cwd: root,
+    stdin: "inherit",
+    stdout: "inherit",
+    stderr: "inherit",
+  });
+  const code = await process.exited;
+  if (code !== 0) throw new Error(`Tauri icon generation failed with exit ${code}`);
+}
+
+if (import.meta.main) {
+  try {
+    await generateIcons(Bun.argv.slice(2));
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : error);
+    process.exitCode = 1;
+  }
+}

package/scripts/inventory.ts

@@ -0,0 +1,86 @@
+#!/usr/bin/env bun
+// SPDX-License-Identifier: Apache-2.0
+// Writes src/generated/inventory.json: every package and app of the monorepo (name, version, description, entry
+// points, location, whether it is in the Bun workspace). The showcase serves it from its own API (`/api/packages`)
+// and its pages read the same data. A test checks the committed file is current: run `bun run inventory` after a
+// version or description change.
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+
+const here = dirname(import.meta.path);
+export const ROOT = resolve(here, "../../..");
+export const OUT = join(here, "../src/generated/inventory.json");
+
+export interface InventoryEntry {
+  name: string;
+  version: string;
+  description: string;
+  /** Path relative to the repository. */
+  dir: string;
+  kind: "package" | "app";
+  /** In the Bun workspace (installed and linked) or a host-bound member outside it. */
+  workspace: boolean;
+  private: boolean;
+  /** Number of `exports` entries (0 when the package declares `main` only). */
+  exports: number;
+  bin: string[];
+}
+
+function workspaceExclusions(root: string): Set<string> {
+  const manifest = JSON.parse(readFileSync(join(root, "package.json"), "utf8")) as {
+    workspaces?: { packages?: string[] };
+  };
+  return new Set(
+    (manifest.workspaces?.packages ?? []).filter((g) => g.startsWith("!")).map((g) => g.slice(1)),
+  );
+}
+
+/** The inventory, sorted by name. */
+export function collect(root: string = ROOT): InventoryEntry[] {
+  const excluded = workspaceExclusions(root);
+  const entries: InventoryEntry[] = [];
+  for (const [kind, base] of [
+    ["package", "packages"],
+    ["app", "apps"],
+  ] as const) {
+    const dir = join(root, base);
+    if (!existsSync(dir)) continue;
+    for (const name of readdirSync(dir).toSorted()) {
+      const file = join(dir, name, "package.json");
+      if (!existsSync(file)) continue;
+      const manifest = JSON.parse(readFileSync(file, "utf8")) as {
+        name: string;
+        version?: string;
+        description?: string;
+        private?: boolean;
+        exports?: Record<string, unknown> | string;
+        bin?: string | Record<string, string>;
+      };
+      const rel = `${base}/${name}`;
+      const exported = manifest.exports;
+      entries.push({
+        name: manifest.name,
+        version: manifest.version ?? "0.0.0",
+        description: (manifest.description ?? "").replace(/\s+/g, " ").trim().slice(0, 220),
+        dir: rel,
+        kind,
+        workspace: !excluded.has(rel),
+        private: manifest.private === true,
+        exports:
+          typeof exported === "object" && exported
+            ? Object.keys(exported).length
+            : exported
+              ? 1
+              : 0,
+        bin: typeof manifest.bin === "string" ? [manifest.name] : Object.keys(manifest.bin ?? {}),
+      });
+    }
+  }
+  return entries.toSorted((a, b) => a.name.localeCompare(b.name));
+}
+
+if (import.meta.main) {
+  const entries = collect();
+  await Bun.write(OUT, `${JSON.stringify(entries, null, 2)}\n`);
+  console.log(`inventory: ${entries.length} packages and apps -> ${OUT}`);
+}