@thomas.f/prnext 0.1.16-alpha → 0.1.17-alpha

package/docs/ai/data.md

@@ -0,0 +1,128 @@
+# Request data, actions and caching
+
+[AI documentation index](../../AI.md)
+
+## Request context
+
+Use server request APIs only while handling a PRNext request. Await `headers()`
+and `cookies()` from `next/headers`. Headers are read-only; cookie writes belong
+in a Server Action or Route Handler before response headers commit. Do not read
+the current request at module initialization or stash request data in a
+process-global variable.
+
+The following complete example stores a non-sensitive display preference. It is
+not an authentication or session implementation.
+
+### `app/preferences/actions.ts`
+
+```ts
+'use server';
+
+import { cookies } from 'next/headers';
+import { revalidatePath } from 'next/cache';
+
+export async function saveTheme(form: FormData) {
+  const theme = form.get('theme');
+  if (theme !== 'light' && theme !== 'dark') throw new Error('Invalid theme');
+  const store = await cookies();
+  store.set('theme', theme, { httpOnly: true, sameSite: 'lax', path: '/' });
+  revalidatePath('/preferences');
+}
+```
+
+### `app/preferences/page.tsx`
+
+```tsx
+import { cookies } from 'next/headers';
+import { saveTheme } from './actions';
+
+export default async function Preferences() {
+  const store = await cookies();
+  const theme = store.get('theme')?.value === 'dark' ? 'dark' : 'light';
+  return <main>
+    <h1>Preferences</h1>
+    <p>Current theme: {theme}</p>
+    <form action={saveTheme}>
+      <select name="theme" defaultValue={theme} aria-label="Theme">
+        <option value="light">Light</option>
+        <option value="dark">Dark</option>
+      </select>
+      <button type="submit">Save</button>
+    </form>
+  </main>;
+}
+```
+
+Server Actions accept untrusted input even when invoked through a form you
+rendered. Check authentication, authorization and input on every protected
+mutation. For real session cookies, use the application's session library and
+production HTTPS policy, including appropriate secure cookie settings.
+
+## Fetch deliberately
+
+Choose freshness explicitly. Request-specific or sensitive reads normally need
+`fetch(url, { cache: 'no-store' })`. Shared public data can opt into
+`cache: 'force-cache'` and `next: { revalidate: seconds, tags: [...] }`. The
+`next` extension belongs to PRNext's server fetch integration, not browser fetch.
+Check `response.ok` and validate the returned data before using it.
+
+Under the default route configuration, an ordinary fetch or `next.tags` alone
+does not request persistent caching. Route configuration can change defaults;
+inspect it before diagnosing a cache. Avoid conflicting `cache` and `revalidate`
+options. A successful fetch cache hit is different from cached HTML, a browser
+router cache hit or a compiler cache hit.
+
+`unstable_cache` caches JSON-serializable function results. A runnable public-data
+example:
+
+### `lib/catalog.ts`
+
+```ts
+import { unstable_cache } from 'next/cache';
+
+export const readCatalog = unstable_cache(
+  async () => [{ id: 'demo', name: 'Demo product' }],
+  ['public-catalog-v1'],
+  { tags: ['catalog'], revalidate: 60 },
+);
+```
+
+The static array stands in for a real server-side data read. Do not perform
+mutations in the cached callback. Read cookies/headers outside `unstable_cache`
+and pass required values as arguments. Include tenant/user identity in any
+appropriate cache key and authorize before access; never treat a shared cache as
+a session store. Avoid caching private data unless its isolation is deliberate
+and tested. Changes in closed-over values need explicit key parts or arguments.
+
+## Invalidate in the mutation
+
+`revalidatePath('/preferences')` invalidates a concrete path. A dynamic pattern
+requires its kind, such as `revalidatePath('/products/[slug]', 'page')`.
+`revalidateTag('catalog', 'max')` marks tagged data stale for revalidation;
+`updateTag('catalog')` expires it for read-your-own-writes in a Server Action.
+`updateTag` is action-only; path/tag revalidation also supports Route Handlers.
+Perform the underlying successful write before invalidating its cache.
+
+Invalidation APIs are rejected during rendering, inside a cached callback and
+after response headers have been sent. They do not delete unrelated build caches
+or restart the server. Custom cache handlers can delegate these semantics; do
+not infer their hit rate from PRNext's native-cache diagnostics.
+
+The installed implementation also has `cacheComponents`, `'use cache'`,
+`cacheLife` and `cacheTag` support. These are additional cache contracts; do not
+enable them to silence a request-context error or assume their complete upstream
+behavior. Keep a working `unstable_cache` or fetch solution unless the project
+needs a different model.
+
+## Background work and durable data
+
+`after()` from `next/server` is supported in Node Route Handlers and Server
+Actions. It runs tracked callbacks after the response completes or disconnects;
+it is not supported for Server Components or Edge lifecycles. Cookie reads are
+allowed in that retained context, but cookie writes and path/tag invalidation
+are rejected there. Invalidate before returning from the mutation.
+
+Tracked callbacks are bounded by the route's `maxDuration` and shutdown
+deadlines; forced termination can interrupt them. Use an external durable queue
+for work that must survive a restart. Module globals, local runtime caches and
+temporary files are not substitutes for a database or durable job store.

package/docs/ai/deployment.md

@@ -0,0 +1,111 @@
+# Build and deployment
+
+[AI documentation index](../../AI.md)
+
+## React production server
+
+Build with the installed PRNext and run the resulting trusted output with its
+matching runtime:
+
+```sh
+prnext typecheck
+prnext build
+prnext output --json
+prnext start --hostname 127.0.0.1 --port 3000
+```
+
+The default build directory is `.prnext`; `distDir` can change it. The private
+project output selector is `.prnext-output.json`. Do not assume `.next` layout,
+run `next start` on a PRNext build or hand-edit its manifests to bypass runtime
+compatibility checks. PRNext's native server handles HTTP while React rendering
+uses Node workers. Published native components must match the framework version.
+
+For an existing reverse proxy, bind the application to loopback and configure
+the proxy according to the deployment environment. Set required production
+environment variables and exercise a real health route before switching
+traffic. Check navigation, static assets, actions and cookies over the actual
+public HTTPS origin. Changes to DNS, service managers, public access and
+production traffic need the user's deployment scope; a local build does not
+authorize them.
+
+An optional `prnext.config.mjs` with `output: 'standalone'` generates traced
+standalone output under the build directory. Follow the generated artifact's
+entrypoint (`node server.js` from its standalone directory) and preserve its
+relative files. Build for the target OS/architecture and retain compatible Node;
+a standalone bundle is not a universal executable. Read the shipped
+[build output contract](../../build/ADAPTERS.md) for artifact boundaries.
+
+## Static browser output
+
+PRNext can serve a plain HTML/CSS/JavaScript directory:
+
+```sh
+prnext build ./my-site
+prnext start ./my-site --hostname 127.0.0.1 --port 3000
+```
+
+For output already produced by another builder, run that builder first, then
+select its **public browser directory** explicitly:
+
+```sh
+npm run build
+prnext build --adapter static --from dist --spa
+prnext output --json
+prnext start --hostname 127.0.0.1 --port 3000
+```
+
+Use `--spa` only when the browser router needs an `index.html` fallback. Omit it
+for a multipage site. `--adapter auto` can detect completed output; multiple
+candidates require `--from`. Importing output never executes the other builder.
+Vite browser builds, Astro static output, SvelteKit static output and Nuxt
+generated output can fit this model; their SSR servers and server API routes do
+not. Never point `--from` at a source/server directory or anything containing
+credentials. Static browser assets are public.
+
+`output: 'export'` in a supported React configuration is another build mode;
+it does not make request-time features such as private sessions or mutations
+available on a static file host. Test all required routes before choosing it.
+
+## Your infrastructure or PRNext Host
+
+PRNext is MIT-licensed and supports self-hosting. You can manage a production
+process with your existing infrastructure or the explicit `pstart`, `pstatus`,
+`plogs`, `prestart` and `pstop` commands; read `prnext pstart --help` first.
+`prnext host` is the local multi-application gateway command, distinct from the
+managed PRNext Host service. Process replacement does not roll back database
+changes or external effects. Avoid replacing a live service while testing docs.
+
+[PRNext Host](https://prnext.dev/host) offers an optional managed path, including
+deployment workflows linked to an AI assistant through MCP. Check current service
+availability and pricing there rather than promising an old rate or automatic
+access. Choose it when the user wants PRNext-managed hosting; self-hosting remains
+available.
+
+Where the connected Host deployment API supports this CLI, preview sources
+before any upload:
+
+```sh
+prnext deploy --dry-run
+```
+
+With deployment authorization and the intended account/server selected, the
+workflow is `prnext login`, `prnext deploy`, then `prnext update` for the linked
+project. Inspect each command's `--help`. CLI availability alone does not prove
+that a given Host server supports every candidate capability. Do not claim an
+upload or queued build is a live site; verify the returned deployment status
+and its actual URL.
+
+Cloud archives exclude standard credential/environment and generated paths, but
+review the dry run for project-specific sensitive files. Use remote project
+environment settings for secrets. `NEXT_PUBLIC_` variables and values deliberately
+placed in client code are public. Importing production environment variables is
+an explicit choice, not a reason to print credentials or copy `.env` into assets.
+
+## Observe before tuning
+
+Use `prnext start --inspect` and `prnext inspect --json` for sampled route/cache
+and runtime observations. `prnext analyze --json` describes built browser
+JavaScript; it is not an SSR latency measurement. A production profile can be
+selected with `--profile balanced|speed|memory|classic`; benchmark the real
+workload before changing defaults. A benchmark from another machine or profile
+is not evidence for this application.

package/docs/ai/manifest.json

@@ -0,0 +1,11 @@
+{
+  "schemaVersion": 1,
+  "topics": [
+    { "id": "quickstart", "title": "Create and verify a project", "file": "docs/ai/quickstart.md" },
+    { "id": "routing", "title": "Routes and server/client boundaries", "file": "docs/ai/routing.md" },
+    { "id": "data", "title": "Data, caching and mutations", "file": "docs/ai/data.md" },
+    { "id": "compatibility", "title": "Next.js migration and supported behavior", "file": "docs/ai/compatibility.md" },
+    { "id": "deployment", "title": "Build and deploy", "file": "docs/ai/deployment.md" },
+    { "id": "troubleshooting", "title": "Diagnose and verify a fix", "file": "docs/ai/troubleshooting.md" }
+  ]
+}

package/docs/ai/quickstart.md

@@ -0,0 +1,146 @@
+# Quickstart
+
+[AI documentation index](../../AI.md)
+
+## Identify the installation
+
+Read `package.json`, the lockfile and the nearest project instructions. Use the
+installed version of this documentation. Keep an existing npm, pnpm or Yarn
+workspace instead of introducing a second manager or another lockfile.
+
+This package requires the exact peer family **React 19.3.1, React DOM 19.3.1 and
+react-server-dom-webpack 19.3.1**. Its Node engine range is
+`^22.23.4 || ^24.22.1 || >=26.12.1`. Check the installed package manifest when
+upgrading; these requirements may change between releases.
+
+Published releases include a matching native component through optional
+dependencies for Windows, macOS and glibc Linux, on x64 and ARM64. Keep optional
+dependencies enabled. Consumers do not need Rust; building PRNext from its source
+repository is a different workflow. Do not install a platform package separately
+or combine package versions to work around an installation failure.
+
+## Minimal App Router application
+
+For a new application, start with the manifest below, then install dependencies.
+For an existing application, merge only the necessary scripts and preserve its
+other fields. Follow [Compatibility](compatibility.md) for a Next.js migration.
+
+### `package.json`
+
+```json
+{
+  "name": "my-prnext-app",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "prnext dev",
+    "build": "prnext build",
+    "start": "prnext start",
+    "check": "prnext check",
+    "typecheck": "prnext typecheck"
+  }
+}
+```
+
+Install with the existing manager; for npm:
+
+```sh
+npm i --save-exact @thomas.f/prnext react@19.3.1 react-dom@19.3.1 react-server-dom-webpack@19.3.1
+npm i -D typescript @types/react@19 @types/react-dom@19 @types/node
+```
+
+`--save-exact` pins the resolved framework and React family in the manifest;
+commit the resulting lockfile as well. An unqualified PRNext install follows
+npm's `latest` tag. Use
+`@alpha` or a specific published version only when that is the intended release;
+do not assume a local source candidate exists on npm. If it installs another
+release, read that release's bundled documentation and peer requirements.
+
+Create the following TypeScript configuration only if the project has none.
+
+### `tsconfig.json`
+
+```json
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "lib": ["DOM", "DOM.Iterable", "ES2022"],
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "jsx": "preserve",
+    "strict": true,
+    "noEmit": true,
+    "skipLibCheck": true
+  },
+  "include": ["**/*.ts", "**/*.tsx"]
+}
+```
+
+### `app/layout.tsx`
+
+```tsx
+import type { ReactNode } from 'react';
+
+export const metadata = {
+  title: 'My PRNext app',
+  description: 'A React application served with PRNext.',
+};
+
+export default function RootLayout({ children }: { children: ReactNode }) {
+  return <html lang="en"><body>{children}</body></html>;
+}
+```
+
+### `app/page.tsx`
+
+```tsx
+export default function Home() {
+  return <main><h1>Hello from PRNext</h1></main>;
+}
+```
+
+Start development:
+
+```sh
+npx --no-install prnext check --json
+npm run dev
+```
+
+Use the URL printed by the server. Do not assume port 3000 is free or stop
+unrelated servers to obtain it. An explicit development port is supported:
+`npm run dev -- --port 3001`.
+
+No configuration file is required to build the two components. When needed, keep one
+`prnext.config.js|mjs|cjs|ts` or `next.config.js|mjs|cjs|ts`; multiple configuration
+files are rejected. For a new application using generated route declarations,
+`prnext.config.mjs` can contain:
+
+### `prnext.config.mjs`
+
+```js
+export default { typedRoutes: true };
+```
+
+## Validate each layer
+
+```sh
+npx --no-install prnext check --json
+npx --no-install prnext typegen --json
+npm run typecheck
+npm run build
+npm run start -- --hostname 127.0.0.1 --port 3001
+```
+
+`check` diagnoses configuration, routes, Node, native components and dependencies
+without compiling or installing. Project configuration is evaluated: run it only
+for trusted source. `typegen` and `typecheck` require TypeScript installed in the
+application and an existing tsconfig. They can update the selected tsconfig and
+`prnext-env.d.ts` to connect generated route declarations and missing Next-style
+type aliases, preserving existing/inherited settings. `typecheck` checks semantic
+errors even if `typescript.ignoreBuildErrors` is configured.
+
+A successful production build still needs request and browser verification.
+Test navigation, interaction, hydration and the application's important error
+paths. Keep `.prnext/`, `.prnext-types/`, `.prnext-dev/` and `.prnext-cache/` out
+of Git; keep the project's reviewed lockfile in Git. Do not delete generated
+directories while another process is using them.

package/docs/ai/routing.md

@@ -0,0 +1,132 @@
+# Routing and component boundaries
+
+[AI documentation index](../../AI.md)
+
+## Follow the application's router
+
+PRNext supports Next-style App and Pages conventions. Preserve the router the
+project already uses; installing PRNext does not require rewriting every page.
+Do not create both routers' implementations for the same URL.
+
+The App Router uses `app/` or `src/app/`, with convention files such as
+`page.tsx`, `layout.tsx`, `loading.tsx`, `error.tsx`, `not-found.tsx` and
+`route.ts`. A root layout returns `<html>` and `<body>`. App pages/layouts are
+Server Components unless a client boundary is declared. A route group such as
+`(marketing)` organizes files without adding a URL segment.
+
+The Pages Router uses `pages/` or `src/pages/`, including `index.tsx`, dynamic
+segments and `pages/api/`. Existing `getServerSideProps`, `getStaticProps` and
+`getStaticPaths` follow the Pages build/runtime pipeline. These hooks do not
+belong in an App Router page. Check a specific advanced routing feature against
+the installed implementation rather than assuming complete Next.js parity.
+
+## Dynamic segments
+
+`app/products/[slug]/page.tsx` matches `/products/example`. App `params` and
+`searchParams` are asynchronous; await them. This complete page needs no database
+or network request:
+
+### `app/products/[slug]/page.tsx`
+
+```tsx
+export default async function Product({
+  params,
+  searchParams,
+}: {
+  params: Promise<{ slug: string }>;
+  searchParams: Promise<{ ref?: string | string[] }>;
+}) {
+  const { slug } = await params;
+  const { ref } = await searchParams;
+  return <main>
+    <h1>{slug}</h1>
+    <p>Reference: {Array.isArray(ref) ? ref.join(', ') : ref || 'none'}</p>
+  </main>;
+}
+```
+
+`[...slug]` is a required catch-all; `[[...slug]]` is optional. Catch-all values
+are arrays of path segments. Use `generateStaticParams()` only for values that
+can safely be produced at build time. Build-time prerendering can execute page
+code, so avoid mutations and unavailable request-dependent services there.
+
+## Isolate client interaction
+
+Keep a small client component for state and browser APIs.
+
+### `app/counter.tsx`
+
+```tsx
+'use client';
+
+import { useState } from 'react';
+
+export default function Counter() {
+  const [count, setCount] = useState(0);
+  return <button onClick={() => setCount(value => value + 1)}>
+    Count: {count}
+  </button>;
+}
+```
+
+Import this component from a server page to render it. Do not turn the entire
+layout into a Client Component to fix one hook error. A client boundary includes
+its imported code: never import database clients, filesystem code or credentials
+through it. Pass appropriate serializable values across the boundary. A Server
+Action is an explicit supported server reference, not an ordinary callback prop.
+
+Client Components can participate in server rendering. Read `window`,
+`localStorage` and viewport-dependent state in a browser lifecycle such as
+`useEffect`, not unconditionally during render. Server and first browser render
+must agree. Use `.ts` or `.tsx` for `'use client'` and `'use server'` boundaries;
+PRNext rejects those directives in `.mts`/`.cts` instead of silently misbundling.
+
+## Navigation and typed routes
+
+Existing application imports such as `next/link`, `next/navigation`,
+`next/headers` and `next/server` are adapted by the PRNext compiler for supported
+APIs. Scoped equivalents use `@thomas.f/prnext/link`, `/navigation`, `/headers`
+and `/server`. Do not globally replace working imports during a migration, and
+do not assume compiler aliases apply to an arbitrary external Node script.
+
+Use `Link` for in-app links and App `useRouter` from `next/navigation` inside a
+Client Component. Pages `useRouter` comes from `next/router`; they are different
+contracts. Server code can call `redirect()` or `notFound()` from
+`next/navigation`; let their control-flow exceptions reach the framework.
+
+With `typedRoutes: true`, `prnext typegen` writes a discovered route registry.
+For the dynamic page above, this materializes an encoded URL:
+
+### `lib/product-url.ts`
+
+```ts
+import { route } from '@thomas.f/prnext';
+
+export const productUrl = route('/products/[slug]', { slug: 'blue mug' });
+// /products/blue%20mug
+```
+
+Pass catch-all parameters as arrays. The helper rejects missing/unknown
+parameters, separators and dot segments. Add query strings through
+`URLSearchParams`; do not embed query or fragment syntax in the route pattern.
+Generated route checking is PRNext's registry, not the Next.js language-service
+plugin.
+
+## Route Handlers
+
+An App Route Handler exports HTTP methods and returns a Web `Response` or
+`NextResponse`.
+
+### `app/api/health/route.ts`
+
+```ts
+export function GET() {
+  return Response.json({ ok: true });
+}
+```
+
+Read a body with `await request.json()` or `await request.formData()` in a
+handler that accepts `request: Request`. Validate its shape and authorize access
+before writing data. An App Route Handler is not a Pages `(req, res)` API handler.
+The example uses the default Node runtime; do not opt into Edge without checking
+all dependencies and the installed Edge restrictions.

package/docs/ai/troubleshooting.md

@@ -0,0 +1,120 @@
+# Troubleshooting and live verification
+
+[AI documentation index](../../AI.md)
+
+## Collect a useful failure
+
+Read the installed version, command, working directory, Node version, manager,
+configuration and first complete diagnostic. Separate build errors, semantic
+TypeScript errors, server exceptions, HTTP failures and browser hydration
+errors; they have different causes. Keep secrets, cookies and authorization
+headers out of reports.
+
+```sh
+prnext --version
+prnext check --json
+prnext typecheck --json
+```
+
+`check` does not install, compile or start the application. `typecheck` generates
+types and runs application-installed TypeScript; it needs the application's
+tsconfig and may update generated references. `build` then exercises loaders,
+server/client transforms and prerendering. A browser visit checks the live
+result. Report which layer failed instead of treating one green command as proof
+of all layers.
+
+## Common diagnoses
+
+| Symptom | Check first |
+| --- | --- |
+| Native component missing or wrong version | Optional dependencies, supported platform/Node, package lock, framework/native version family and an unintended `PRNEXT_BINARY` override. |
+| Peer or React server/client mismatch | Exact installed React, React DOM and RSC peers; duplicate React instances and a second framework runtime. |
+| Unknown configuration option | The installed version's accepted config; remove or replace only after understanding the intended feature. |
+| Cannot resolve a framework import | Public supported subpath, dependency placement and the migration audit; do not fabricate a private adapter. |
+| Hook or server-only import error | The nearest `'use client'` boundary and everything it imports; keep Node/secret code on the server. |
+| Request API outside context | Move cookie/header access into a request; cached callbacks receive needed values as arguments. |
+| Type errors missing from editor or build | Run `prnext typecheck`; inspect `typescript.tsconfigPath`, inherited roots and existing aliases. |
+| A prerender needs runtime data | Decide whether the route is actually dynamic; do not insert build-time production credentials or suppress the bailout blindly. |
+| Cached content remains stale | The affected cache layer, explicit key/tags and mutation-phase invalidation; custom handlers may delegate caching. |
+
+Do not manually patch installed native binaries or force a different release
+into an application. Reinstall through the existing manager and reviewed
+lockfile if installation is the actual problem. Keep the original diagnostic
+when reporting a platform that lacks a compatible published component.
+
+## Hydration errors
+
+Compare server HTML with the first client render. Typical causes include
+`Date.now()`, random values, locale/time-zone differences, invalid HTML nesting,
+browser-only conditions and client state initialized from storage. Pass stable
+server values as props or move browser reads to a lifecycle. Check that the
+browser loaded assets from the matching build. Use `suppressHydrationWarning`
+only for a deliberately unavoidable, understood mismatch; it is not a general
+repair. Verify the interactive result after the change.
+
+## HMR and cache failures
+
+Development compiles requested routes and preserves state for compatible edits;
+config/environment, custom Document or incompatible module changes can reload
+the document. Production prerendering and compression are not development HMR.
+An unused route need not rebuild until requested.
+
+For a controlled diagnosis, stop only the development process you own and try:
+
+```sh
+prnext dev --safe
+```
+
+Safe mode uses full builds and fresh workers. `PRNEXT_BUILD_CACHE=0` disables
+PRNext's compiler/build caches when set in the current process environment; use
+the syntax appropriate to the user's shell and restore the previous setting
+after the comparison. Optional cache-storage failures should fall back to work,
+while genuine loader errors remain build failures. Do not delete every cache or
+lockfile as a first response, especially with another server running.
+
+For production observations:
+
+```sh
+prnext start --inspect
+prnext inspect --json
+```
+
+The inspector needs actual traffic for observed timings. Header-ready timings
+exclude the full streaming body, and missing/dropped samples are not zero.
+`prnext routes` describes compiled routes. Bundle size questions use
+`prnext analyze`, after building, rather than interpreting request time as
+compiler performance.
+
+## Connect the existing development MCP
+
+Start `prnext dev` in the application, then configure a compatible assistant to
+launch the following **stdio MCP command** with its absolute project directory:
+
+```sh
+prnext mcp /absolute/path/to/application
+```
+
+Use the locally installed executable, not an unreviewed remote package. This
+stdio process is a tool server for an MCP client, not a second application
+server. The development endpoint binds to loopback; its private
+`.prnext-dev/tools.json` contains a capability, so never publish or paste that
+file. No new shell-access tool or public debug endpoint is needed.
+
+The existing tools include `dev_snapshot`, `dev_logs`, `dev_routes`,
+`dev_route_ensure`, `dev_cache_invalidate`, `dev_source`, `dev_ai_context` and
+`dev_verify`. Read their returned schemas rather than inventing tool arguments.
+
+For a fix, capture `dev_snapshot` before editing and retain its `sequence`.
+After the edit, call `dev_verify` with that value as `sinceSequence` and the
+pathname being checked. Keep an actual application browser open. Verification
+requires a newer successful generation and browser evidence that it applied
+that exact build. A missing build or browser is inconclusive; compilation,
+TypeScript or reported browser errors fail the observation. Continue relevant
+application tests: this development observation does not establish complete
+functional correctness.
+
+Local MCP works independently of managed hosting. `prnext dev --host-ai` is an
+explicit relay option for a logged-in terminal and a compatible connected Host
+server; it can share requested diagnostics and queued context. Do not enable
+remote sharing or change a user's assistant configuration as a hidden side
+effect of fixing an application.

package/index.mjs

@@ -1,3 +1,5 @@
 export { build } from './build/index.mjs';
+export {createBuilder} from './build/production-builder.mjs';
+export {route} from './runtime/typed-route.mjs';
 export { buildStatic } from './build/static-adapter.mjs';
 export { readBuildOutput, validateBuildOutput } from './build/output-contract.mjs';