@sntlr/registry-shell 1.1.3 → 2.0.0

package/src/cli/build.ts

@@ -1,15 +1,17 @@
 /**
- * `registry-shell build` — run `next build` against the user's project.
+ * `registry-shell build` — produces a Next.js static export tree in
+ * `<user-project>/out/`.
  *
- * Strategy: `next build` writes to its default `<next-project>/.next`
- * location (inside our node_modules). After a successful build, MOVE that
- * directory to `<user-project>/<paths.buildOutput ?? ".next">`.
- *
- * Why not use Next's `distDir` config? Next silently ignores absolute
- * paths that point outside the Next project dir (the output ends up back
- * in the default location). The env-var approach we tried first worked
- * locally on Windows but failed on Vercel. A post-build move is
- * platform-independent.
+ * Pipeline:
+ *   1. Overlay user's public/ onto the shell's bundled public/ (so Next
+ *      sees user's registry manifests at /r/*.json, /a11y/*.json, etc.).
+ *   2. Run build-time generators that write derived JSON into the merged
+ *      public/ — currently just `api/search-index.json`.
+ *   3. Run `next build` with `output: "export"` (set in next.config.ts).
+ *      Next writes static HTML/JS/CSS to `<shell>/out/`.
+ *   4. Copy `<shell>/out/` → `<user-project>/out/`.
+ *   5. Restore shell's public/ to its pristine state (remove anything we
+ *      added in step 1/2) so repeated builds are idempotent.
  */
 import fs from "node:fs"
 import path from "node:path"
@@ -22,53 +24,112 @@ import {
   nextAppDir,
   writeUserSourcesCss,
 } from "./shared.js"
+import { generateSearchIndex } from "./generate-search-index.js"
 
 export async function run(args: string[]): Promise<void> {
   const loaded = loadUserConfig()
+  if (!loaded) {
+    console.error(
+      "[registry-shell] No registry-shell.config.ts found — `build` requires a registry.",
+    )
+    process.exit(1)
+  }
+
   clearStaleNextCacheIfModeChanged(loaded)
   writeUserSourcesCss(loaded)
 
   const shellNextApp = nextAppDir()
+  const shellPublic = path.join(shellNextApp, "public")
+  const userPublic = path.join(loaded.root, "public")
+
+  // Step 1: Snapshot shell's public/ before overlay so we can restore it.
+  const shellOwnEntries: Set<string> = new Set(
+    fs.existsSync(shellPublic) ? fs.readdirSync(shellPublic) : [],
+  )
+
+  // Step 2: Overlay user's public/ onto shell's public/ (user files win).
+  const overlaidEntries: string[] = []
+  if (fs.existsSync(userPublic)) {
+    for (const entry of fs.readdirSync(userPublic)) {
+      const src = path.join(userPublic, entry)
+      const dest = path.join(shellPublic, entry)
+      fs.cpSync(src, dest, { recursive: true, force: true })
+      overlaidEntries.push(entry)
+    }
+  }
+
+  // Apply the shell env vars to THIS process so build-time generators can
+  // call `loadResolvedConfig()` (which reads USER_REGISTRY_ROOT etc.).
+  // The same env is also forwarded to the spawn child below.
   const env = { ...process.env, ...buildEnvVars(loaded) }
-  const child = spawn(
+  Object.assign(process.env, buildEnvVars(loaded))
+
+  // Step 3: Pre-build generators (writes into shell's public/ so Next picks up).
+  try {
+    await generateSearchIndex(loaded, shellPublic)
+  } catch (err) {
+    console.warn(
+      `[registry-shell] search-index generation failed: ${(err as Error).message}`,
+    )
+  }
+
+  // Step 4: next build (static export — writes to <shellNextApp>/out/).
+  const buildChild = spawn(
     process.execPath,
     [NEXT_BIN, "build", shellNextApp, ...args],
     { stdio: "inherit", env },
   )
 
-  child.on("exit", (code) => {
+  buildChild.on("exit", (code) => {
     if (code !== 0) {
+      restoreShellPublic(shellPublic, shellOwnEntries, overlaidEntries)
       process.exit(code ?? 1)
     }
-    if (loaded) relocateBuildOutput(shellNextApp, loaded.root, loaded.config.paths?.buildOutput)
+
+    // Step 5: Copy out/ to user project root.
+    const src = path.join(shellNextApp, "out")
+    const dest = path.resolve(loaded.root, "out")
+    if (fs.existsSync(src)) {
+      if (fs.existsSync(dest)) {
+        fs.rmSync(dest, { recursive: true, force: true, maxRetries: 5, retryDelay: 200 })
+      }
+      fs.cpSync(src, dest, { recursive: true })
+      // Remove the build output from inside node_modules so it doesn't
+      // accumulate stale copies across releases.
+      fs.rmSync(src, { recursive: true, force: true, maxRetries: 5, retryDelay: 200 })
+      console.log(`[registry-shell] Static build ready at ${dest}`)
+    }
+
+    // Step 6: Restore shell's public/ (remove overlay).
+    restoreShellPublic(shellPublic, shellOwnEntries, overlaidEntries)
     process.exit(0)
   })
 }
 
 /**
- * Moves `<shellNextApp>/.next` → `<userRoot>/<outputName ?? ".next">`.
- * Idempotent: removes stale destination first. Noop if source is missing
- * (e.g. Next's distDir *did* happen to work) or source and dest are the
- * same path.
+ * Removes anything from `shellPublic` that wasn't there before the overlay.
+ * Keeps shell's bundled favicons + anything else that was part of the
+ * shipped package. Runs on both success and failure paths.
  */
-function relocateBuildOutput(
-  shellNextApp: string,
-  userRoot: string,
-  outputName: string | undefined,
+function restoreShellPublic(
+  shellPublic: string,
+  shellOwnEntries: Set<string>,
+  overlaidEntries: string[],
 ): void {
-  const src = path.join(shellNextApp, ".next")
-  const dest = path.resolve(userRoot, outputName ?? ".next")
-  if (src === dest) return
-  if (!fs.existsSync(src)) return
-
-  if (fs.existsSync(dest)) {
-    fs.rmSync(dest, {
-      recursive: true,
-      force: true,
-      maxRetries: 5,
-      retryDelay: 200,
-    })
+  if (!fs.existsSync(shellPublic)) return
+  for (const entry of overlaidEntries) {
+    if (!shellOwnEntries.has(entry)) {
+      // Entry didn't exist before overlay — remove cleanly.
+      fs.rmSync(path.join(shellPublic, entry), {
+        recursive: true,
+        force: true,
+        maxRetries: 5,
+        retryDelay: 200,
+      })
+    }
+    // Entry existed in shell's own public/ — we overwrote it, can't
+    // cleanly restore without reinstalling. Leave it; on next build the
+    // user's version replaces it again. Mostly affects favicon.* files
+    // the user might customize.
   }
-  fs.renameSync(src, dest)
-  console.log(`[registry-shell] Build output moved to ${dest}`)
 }

package/src/cli/dev.ts

@@ -1,6 +1,19 @@
 /**
  * `registry-shell dev` — run `next dev` against the user's project.
+ *
+ * Dev mode runs Next in its normal dynamic-rendering mode (so hot reload
+ * / live MDX / interactive previews all work). The `output: "export"`
+ * config only affects `next build`, so dev behaves identically to pre-v2.
+ *
+ * We still overlay the user's `public/` onto the shell's bundled `public/`
+ * before starting Next, so dynamic registry assets (`/r/*.json`,
+ * `/a11y/*.json`, `/props/*.json`, `/tests/*.json`, `/api/search-index.json`,
+ * plus any user-custom static files) are served the same way they will be
+ * in a production build. Note: changes to the user's `public/` during a
+ * dev session require a restart to refresh the overlay.
  */
+import fs from "node:fs"
+import path from "node:path"
 import { spawn } from "node:child_process"
 import {
   NEXT_BIN,
@@ -10,6 +23,7 @@ import {
   nextAppDir,
   writeUserSourcesCss,
 } from "./shared.js"
+import { generateSearchIndex } from "./generate-search-index.js"
 
 export async function run(args: string[]): Promise<void> {
   const loaded = loadUserConfig()
@@ -21,6 +35,22 @@ export async function run(args: string[]): Promise<void> {
 
   clearStaleNextCacheIfModeChanged(loaded)
   writeUserSourcesCss(loaded)
+
+  const shellNextApp = nextAppDir()
+
+  // Overlay user's public/ onto shell's public/ so dev-mode URLs match
+  // what production will serve statically. Skipped in shell-only mode.
+  if (loaded) {
+    overlayUserPublic(loaded.root, shellNextApp)
+    try {
+      await generateSearchIndex(loaded, path.join(shellNextApp, "public"))
+    } catch (err) {
+      console.warn(
+        `[registry-shell] search-index generation failed: ${(err as Error).message}`,
+      )
+    }
+  }
+
   const env = { ...process.env, ...buildEnvVars(loaded) }
   const portArgs = loaded?.config.port ? ["-p", String(loaded.config.port)] : []
   // Webpack by default. Turbopack currently can't compile files reached via
@@ -30,9 +60,20 @@ export async function run(args: string[]): Promise<void> {
   const turbopackArgs = process.env.UI_SHELL_TURBOPACK ? ["--turbopack"] : []
   const child = spawn(
     process.execPath,
-    [NEXT_BIN, "dev", nextAppDir(), ...turbopackArgs, ...portArgs, ...args],
+    [NEXT_BIN, "dev", shellNextApp, ...turbopackArgs, ...portArgs, ...args],
     { stdio: "inherit", env },
   )
 
   child.on("exit", (code) => process.exit(code ?? 0))
 }
+
+function overlayUserPublic(userRoot: string, shellNextApp: string): void {
+  const userPublic = path.join(userRoot, "public")
+  const shellPublic = path.join(shellNextApp, "public")
+  if (!fs.existsSync(userPublic)) return
+  for (const entry of fs.readdirSync(userPublic)) {
+    const src = path.join(userPublic, entry)
+    const dest = path.join(shellPublic, entry)
+    fs.cpSync(src, dest, { recursive: true, force: true })
+  }
+}

package/src/cli/generate-search-index.ts

@@ -0,0 +1,82 @@
+/**
+ * Pre-build generator: writes `public/api/search-index.json` into the
+ * user's public tree. Replaces the former `/api/search-index` route
+ * handler — the shell's static-export mode can't serve dynamic route
+ * handlers, so we bake the search index at build time instead.
+ *
+ * The generator runs in a child `tsx` process so the shell's own build
+ * pipeline (which ships as compiled `.js`) can invoke user-registry-side
+ * .ts files (docs loaders, adapters) without the user's `node_modules/`
+ * needing to be on our resolution path.
+ */
+import fs from "node:fs"
+import path from "node:path"
+import { createJiti } from "jiti"
+import type { LoadedConfig } from "./shared.js"
+import type { ResolvedShellConfig } from "../config-loader.js"
+
+interface SearchItem {
+  label: string
+  href: string
+  group: string
+}
+
+/**
+ * Writes the search index JSON into `targetPublicDir/api/search-index.json`.
+ * `targetPublicDir` is expected to be the shell's bundled `public/` dir
+ * (inside node_modules). The build pipeline overlays the user's public/
+ * onto this dir so the merged tree is what `next build` sees.
+ */
+export async function generateSearchIndex(
+  loaded: LoadedConfig,
+  targetPublicDir: string,
+): Promise<void> {
+  const { config } = loaded
+  void config
+
+  // Load the shell's registry-adapter + config-loader via jiti so we can
+  // evaluate the same filesystem-walking logic the server used to do at
+  // request time.
+  const jiti = createJiti(import.meta.url, { interopDefault: true })
+  const resolved: ResolvedShellConfig | null = (
+    jiti("../config-loader.js") as {
+      loadResolvedConfig: () => ResolvedShellConfig | null
+    }
+  ).loadResolvedConfig()
+
+  if (!resolved) {
+    console.warn("[registry-shell] generate-search-index: no resolved config, skipping")
+    return
+  }
+
+  const { createDefaultAdapter } = jiti("../adapter/default.js") as {
+    createDefaultAdapter: (r: ResolvedShellConfig) => {
+      getAllComponents: () => { name: string; label: string }[]
+      getAllDocs: () => { slug: string; title: string }[]
+    }
+  }
+  const adapter = createDefaultAdapter(resolved)
+
+  const docs: SearchItem[] = adapter.getAllDocs().map((doc) => ({
+    label: doc.title,
+    href: `/docs/${doc.slug}/`,
+    group: "Documentation",
+  }))
+
+  const components: SearchItem[] = adapter.getAllComponents().map((comp) => ({
+    label: comp.label,
+    href: `/components/${comp.name}/`,
+    group: "Components",
+  }))
+
+  const items = [...docs, ...components]
+
+  const outDir = path.join(targetPublicDir, "api")
+  fs.mkdirSync(outDir, { recursive: true })
+  const outPath = path.join(outDir, "search-index.json")
+  fs.writeFileSync(outPath, JSON.stringify(items), "utf-8")
+
+  console.log(
+    `[registry-shell] Wrote search index (${items.length} items) → ${outPath}`,
+  )
+}

package/src/cli/index.ts

@@ -3,10 +3,13 @@
  * @sntlr/registry-shell CLI entry.
  *
  * Commands:
- *   init    Scaffold registry-shell.config.ts and add a script to package.json.
- *   dev     Run `next dev` pointed at the user's current directory.
- *   build   Run `next build` pointed at the user's current directory.
- *   start   Run `next start` for a built shell.
+ *   init    Scaffold registry-shell.config.ts and add scripts to package.json.
+ *   dev     Run `next dev` for local iteration on the registry.
+ *   build   Produce a static export in `<user-project>/out/` (Storybook-style).
+ *
+ * `start` was removed in v2.0.0 — `next build` now produces a static site,
+ * so there's no server to "start". Serve `out/` with any static host
+ * (`npx serve out`, Vercel, Netlify, S3, etc.).
  */
 
 const USAGE = `Usage: registry-shell <command> [args]
@@ -14,8 +17,7 @@ const USAGE = `Usage: registry-shell <command> [args]
 Commands:
   init            Scaffold registry-shell.config.ts in the current project.
   dev             Start the shell in dev mode on http://localhost:3000.
-  build           Build the shell for production.
-  start           Start the production server against a prior build.
+  build           Produce a static export in ./out (deploy anywhere).
 `
 
 async function main() {
@@ -37,8 +39,10 @@ async function main() {
       await (await import("./build.js")).run(args)
       break
     case "start":
-      await (await import("./start.js")).run(args)
-      break
+      console.error(
+        "[registry-shell] `start` was removed in v2.0.0. `build` now produces a static site — serve `./out` with any static host (e.g. `npx serve out`).",
+      )
+      process.exit(1)
     default:
       console.error(`Unknown command: ${cmd}\n`)
       console.log(USAGE)

package/src/config-loader.ts

@@ -3,11 +3,15 @@
  * the user doesn't need a build step or TS tooling of their own — the shell
  * parses TS on the fly.
  *
- * Called once at Next.js server startup (see src/next-app/registry.config.ts).
+ * Called from two places:
+ *   • Next.js server startup (src/next-app/registry.config.ts) — runtime.
+ *   • The shell CLI's build pipeline (src/cli/generate-search-index.ts) —
+ *     pre-build. The CLI runs in plain Node, not inside Next, so we don't
+ *     use Next's `server-only` guard here.
+ *
  * The returned `ResolvedShellConfig` contains absolute paths and defaults
  * applied.
  */
-import "server-only"
 import path from "node:path"
 import fs from "node:fs"
 import { createJiti } from "jiti"

package/src/next-app/components/search.tsx

@@ -24,7 +24,7 @@ let fetchPromise: Promise<void> | null = null
 
 function preloadSearchIndex() {
   if (cachedItems || fetchPromise) return
-  fetchPromise = fetch("/api/search-index")
+  fetchPromise = fetch("/api/search-index.json")
     .then((r) => r.json())
     .then((data) => { cachedItems = data })
     .catch(() => {})

package/src/next-app/next.config.ts

@@ -46,15 +46,20 @@ function resolveUserModule(relativePath: string, fallback: string): string {
 const USER_PREVIEWS = resolveUserModule("components/previews", "fallback/previews.ts")
 
 const nextConfig: NextConfig = {
-  output: process.env.BUILD_STANDALONE === "true" ? "standalone" : undefined,
+  // Static export (Storybook model) — the shell produces a pure static
+  // HTML/JS/CSS tree under `out/`, deployable to any static host (Vercel,
+  // Netlify, S3, GitHub Pages). No serverless functions, no runtime file
+  // tracing, no pnpm symlink hazards. Dev mode (`next dev`) still runs
+  // normally; export only affects `next build`.
+  output: "export",
 
-  // Next's file tracer figures out which node_modules files each
-  // serverless function needs. With pnpm (and our setup, where Next
-  // runs from inside node_modules), the tracer can't walk pnpm's
-  // virtual store without knowing the real project root. Point it at
-  // the user's project — that's the dir that contains `node_modules/.pnpm`
-  // on Vercel and any other pnpm-installed host.
-  ...(USER_ROOT ? { outputFileTracingRoot: toPosix(USER_ROOT) } : {}),
+  // `next/image` runtime optimization requires a server. Disable for
+  // static export — images are served as-is from `public/`.
+  images: { unoptimized: true },
+
+  // URLs end with `/` (e.g. `/components/button/`). Makes static hosts
+  // serve `components/button/index.html` correctly.
+  trailingSlash: true,
 
   // When installed as an external package (link:../registry-shell, npm, etc.),
   // the shell's TSX lives under the user's node_modules and Next won't

package/dist/cli/start.d.ts

@@ -1 +0,0 @@
-export declare function run(args: string[]): Promise<void>;

package/dist/cli/start.js

@@ -1,47 +0,0 @@
-/**
- * `registry-shell start` — run `next start` for a prior `registry-shell build`.
- *
- * Build writes `.next/` to the user's project root (so Vercel / Netlify /
- * generic Next hosts find it). `next start` expects it at its default
- * location inside the Next project dir. Move it back before starting.
- * Safe to run even if the move has already happened on a prior start.
- */
-import fs from "node:fs";
-import path from "node:path";
-import { spawn } from "node:child_process";
-import { NEXT_BIN, buildEnvVars, loadUserConfig, nextAppDir } from "./shared.js";
-export async function run(args) {
-    const loaded = loadUserConfig();
-    const env = { ...process.env, ...buildEnvVars(loaded) };
-    const portArgs = loaded?.config.port ? ["-p", String(loaded.config.port)] : [];
-    const shellNextApp = nextAppDir();
-    if (loaded) {
-        restoreBuildOutput(shellNextApp, loaded.root, loaded.config.paths?.buildOutput);
-    }
-    const child = spawn(process.execPath, [NEXT_BIN, "start", shellNextApp, ...portArgs, ...args], { stdio: "inherit", env });
-    child.on("exit", (code) => process.exit(code ?? 0));
-}
-/**
- * Inverse of build.ts's relocation: moves `<userRoot>/<buildOutput>` back
- * to `<shellNextApp>/.next` so `next start` can find it. Noop when the
- * user-side `.next` is missing — we assume they ran `registry-shell start`
- * against a shell-side build or are otherwise in a good state.
- */
-function restoreBuildOutput(shellNextApp, userRoot, outputName) {
-    const dest = path.join(shellNextApp, ".next");
-    const src = path.resolve(userRoot, outputName ?? ".next");
-    if (src === dest)
-        return;
-    if (!fs.existsSync(src))
-        return;
-    if (fs.existsSync(dest)) {
-        fs.rmSync(dest, {
-            recursive: true,
-            force: true,
-            maxRetries: 5,
-            retryDelay: 200,
-        });
-    }
-    fs.renameSync(src, dest);
-}
-//# sourceMappingURL=start.js.map

package/dist/cli/start.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"start.js","sourceRoot":"","sources":["../../src/cli/start.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,EAAE,MAAM,SAAS,CAAA;AACxB,OAAO,IAAI,MAAM,WAAW,CAAA;AAC5B,OAAO,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAA;AAC1C,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAEhF,MAAM,CAAC,KAAK,UAAU,GAAG,CAAC,IAAc;IACtC,MAAM,MAAM,GAAG,cAAc,EAAE,CAAA;IAC/B,MAAM,GAAG,GAAG,EAAE,GAAG,OAAO,CAAC,GAAG,EAAE,GAAG,YAAY,CAAC,MAAM,CAAC,EAAE,CAAA;IACvD,MAAM,QAAQ,GAAG,MAAM,EAAE,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAA;IAC9E,MAAM,YAAY,GAAG,UAAU,EAAE,CAAA;IAEjC,IAAI,MAAM,EAAE,CAAC;QACX,kBAAkB,CAAC,YAAY,EAAE,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,WAAW,CAAC,CAAA;IACjF,CAAC;IAED,MAAM,KAAK,GAAG,KAAK,CACjB,OAAO,CAAC,QAAQ,EAChB,CAAC,QAAQ,EAAE,OAAO,EAAE,YAAY,EAAE,GAAG,QAAQ,EAAE,GAAG,IAAI,CAAC,EACvD,EAAE,KAAK,EAAE,SAAS,EAAE,GAAG,EAAE,CAC1B,CAAA;IACD,KAAK,CAAC,EAAE,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,CAAC,CAAC,CAAA;AACrD,CAAC;AAED;;;;;GAKG;AACH,SAAS,kBAAkB,CACzB,YAAoB,EACpB,QAAgB,EAChB,UAA8B;IAE9B,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,OAAO,CAAC,CAAA;IAC7C,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE,UAAU,IAAI,OAAO,CAAC,CAAA;IACzD,IAAI,GAAG,KAAK,IAAI;QAAE,OAAM;IACxB,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,GAAG,CAAC;QAAE,OAAM;IAE/B,IAAI,EAAE,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE,CAAC;QACxB,EAAE,CAAC,MAAM,CAAC,IAAI,EAAE;YACd,SAAS,EAAE,IAAI;YACf,KAAK,EAAE,IAAI;YACX,UAAU,EAAE,CAAC;YACb,UAAU,EAAE,GAAG;SAChB,CAAC,CAAA;IACJ,CAAC;IACD,EAAE,CAAC,UAAU,CAAC,GAAG,EAAE,IAAI,CAAC,CAAA;AAC1B,CAAC"}

package/src/cli/start.ts

@@ -1,57 +0,0 @@
-/**
- * `registry-shell start` — run `next start` for a prior `registry-shell build`.
- *
- * Build writes `.next/` to the user's project root (so Vercel / Netlify /
- * generic Next hosts find it). `next start` expects it at its default
- * location inside the Next project dir. Move it back before starting.
- * Safe to run even if the move has already happened on a prior start.
- */
-import fs from "node:fs"
-import path from "node:path"
-import { spawn } from "node:child_process"
-import { NEXT_BIN, buildEnvVars, loadUserConfig, nextAppDir } from "./shared.js"
-
-export async function run(args: string[]): Promise<void> {
-  const loaded = loadUserConfig()
-  const env = { ...process.env, ...buildEnvVars(loaded) }
-  const portArgs = loaded?.config.port ? ["-p", String(loaded.config.port)] : []
-  const shellNextApp = nextAppDir()
-
-  if (loaded) {
-    restoreBuildOutput(shellNextApp, loaded.root, loaded.config.paths?.buildOutput)
-  }
-
-  const child = spawn(
-    process.execPath,
-    [NEXT_BIN, "start", shellNextApp, ...portArgs, ...args],
-    { stdio: "inherit", env },
-  )
-  child.on("exit", (code) => process.exit(code ?? 0))
-}
-
-/**
- * Inverse of build.ts's relocation: moves `<userRoot>/<buildOutput>` back
- * to `<shellNextApp>/.next` so `next start` can find it. Noop when the
- * user-side `.next` is missing — we assume they ran `registry-shell start`
- * against a shell-side build or are otherwise in a good state.
- */
-function restoreBuildOutput(
-  shellNextApp: string,
-  userRoot: string,
-  outputName: string | undefined,
-): void {
-  const dest = path.join(shellNextApp, ".next")
-  const src = path.resolve(userRoot, outputName ?? ".next")
-  if (src === dest) return
-  if (!fs.existsSync(src)) return
-
-  if (fs.existsSync(dest)) {
-    fs.rmSync(dest, {
-      recursive: true,
-      force: true,
-      maxRetries: 5,
-      retryDelay: 200,
-    })
-  }
-  fs.renameSync(src, dest)
-}

package/src/next-app/app/[...asset]/route.ts

@@ -1,81 +0,0 @@
-/**
- * Catch-all route that serves arbitrary files from the user registry's
- * `public/` directory. Fires only when no other app route matches, so it
- * doesn't interfere with static routes like `/`, `/docs/...`, `/r/...`,
- * etc. The shell's own `public/` assets are served first by Next.js's
- * built-in static handler; this route handles the user's project's assets
- * since Next only serves the bundled package's `public/`.
- *
- * Examples of what this enables:
- *   - `![foo](./my-image.png)` inside user MDX resolving to
- *     `{userRoot}/public/my-image.png`
- *   - Custom favicons referenced in `branding.faviconDark` that live under
- *     `{userRoot}/public/`
- */
-import "server-only"
-import fs from "node:fs"
-import path from "node:path"
-import { NextRequest } from "next/server"
-
-const MIME: Record<string, string> = {
-  ".png": "image/png",
-  ".jpg": "image/jpeg",
-  ".jpeg": "image/jpeg",
-  ".gif": "image/gif",
-  ".webp": "image/webp",
-  ".avif": "image/avif",
-  ".svg": "image/svg+xml",
-  ".ico": "image/x-icon",
-  ".woff": "font/woff",
-  ".woff2": "font/woff2",
-  ".ttf": "font/ttf",
-  ".otf": "font/otf",
-  ".json": "application/json",
-  ".txt": "text/plain; charset=utf-8",
-  ".xml": "application/xml",
-  ".pdf": "application/pdf",
-  ".mp4": "video/mp4",
-  ".webm": "video/webm",
-}
-
-export async function GET(
-  _request: NextRequest,
-  { params }: { params: Promise<{ asset: string[] }> },
-) {
-  const { asset } = await params
-  const userRoot = process.env.USER_REGISTRY_ROOT
-  if (!userRoot || asset.length === 0) {
-    return new Response("Not found", { status: 404 })
-  }
-
-  // Reject traversal.
-  if (asset.some((seg) => seg.includes("..") || seg.includes("\0"))) {
-    return new Response("Forbidden", { status: 403 })
-  }
-
-  const publicDir = path.join(userRoot, "public")
-  const filePath = path.join(publicDir, ...asset)
-
-  // Defense-in-depth: make sure the resolved path is still under public/.
-  const resolved = path.resolve(filePath)
-  if (!resolved.startsWith(path.resolve(publicDir) + path.sep)) {
-    return new Response("Forbidden", { status: 403 })
-  }
-
-  try {
-    const stat = await fs.promises.stat(resolved)
-    if (!stat.isFile()) return new Response("Not found", { status: 404 })
-    const body = await fs.promises.readFile(resolved)
-    const type = MIME[path.extname(resolved).toLowerCase()] ?? "application/octet-stream"
-    return new Response(new Uint8Array(body), {
-      status: 200,
-      headers: {
-        "Content-Type": type,
-        "Content-Length": String(stat.size),
-        "Cache-Control": "public, max-age=0, must-revalidate",
-      },
-    })
-  } catch {
-    return new Response("Not found", { status: 404 })
-  }
-}

package/src/next-app/app/a11y/[name]/route.ts

@@ -1,19 +0,0 @@
-import { NextRequest, NextResponse } from "next/server"
-import { registry } from "@shell/registry.config"
-
-/**
- * Serves the user registry's `public/a11y/{name}.json` files. The shell's
- * own `public/` doesn't hold these (they live in the user's project), so a
- * route handler proxies the read through the adapter.
- */
-export async function GET(
-  _request: NextRequest,
-  { params }: { params: Promise<{ name: string }> },
-) {
-  const { name } = await params
-  const data = registry?.getA11yData ? await registry.getA11yData(name) : null
-  if (!data) {
-    return NextResponse.json({ error: "A11y data not found" }, { status: 404 })
-  }
-  return NextResponse.json(data)
-}

package/src/next-app/app/api/search-index/route.ts

@@ -1,19 +0,0 @@
-import { NextResponse } from "next/server"
-import { getAllDocs } from "@shell/lib/docs"
-import { getAllComponents } from "@shell/lib/components-nav"
-
-export function GET() {
-  const docs = getAllDocs().map((doc) => ({
-    label: doc.title,
-    href: `/docs/${doc.slug}`,
-    group: "Documentation",
-  }))
-
-  const components = getAllComponents().map((comp) => ({
-    label: comp.label,
-    href: `/components/${comp.name}`,
-    group: "Components",
-  }))
-
-  return NextResponse.json([...docs, ...components])
-}