npm - @ultimat3/render - Versions diffs - 8.0.0 → 10.0.0 - Mend

@ultimat3/render 8.0.0 → 10.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (11) hide show

package/CLAUDE.md CHANGED Viewed

@@ -4,6 +4,20 @@ Owns: the `route` primitive, the four render modes, the route table, the surface
 islands + budgets, hydration directives, `<head>` merge, **the server JSX runtime and the two Bun
 loaders that make an app's `.tsx` and `.scss` runnable**.
+**Two entry points, disjoint, split 2026-08-22** — the same `"."` / `"./server"` shape
+`@ultimat3/realtime` took, for the same reason. `"."` (`index.ts`) is the CLIENT half and BUNDLES
+for the browser; `"./server"` (`server.ts`) is the build-time half — `css-modules`,
+`module-loader`, `render-html`, `render-isr`, `render-ssr`, `render-static`, `render-stream` — and
+does not. `css-modules.ts` imports `fileURLToPath`/`pathToFileURL` from `node:url`, which Bun's
+browser polyfill exports NEITHER of, so the single barrel was not a fat bundle, it was a
+`bun build --target=browser` that FAILED at link time on any app entry that reached this package.
+Measured: no `sideEffects` value repairs it (`false`, `[]`, an array naming only `errors.ts` — all
+fail identically), which is where this split differs from realtime's, where the array alone was
+enough. Only not importing the module does. Never re-export a name from both barrels: disjointness
+is what makes "which half does this live in" a mechanical fact, and `index.test.ts` asserts both
+the empty name intersection AND that `index.ts`'s transitive runtime import graph reaches none of
+the seven modules above. `scripts/browser-barrel.test.ts` holds the end property, both directions.
 `island()` is a **factory over the route's own `hydrate`**, not a ninth primitive and not a
 second render mode — the same rule `llm()` and `backfill()` follow. It adds no key to
 `defineRoute`.
@@ -34,7 +48,7 @@ for the mirror-image reason, keeping `render → pwa` refused. Never `cli` (upwa
 | Island node shape | a **branded array** (`IslandNode extends Array<never>`), and every walker tests `isIslandNode` BEFORE `Array.isArray`. An app types JSX with `jsxImportSource: solid-js`, whose `JSX.Element` is a type ALIAS — unaugmentable — and whose only object-shaped member is `ArrayElement`; a plain object was TS2786 at every `<Island />`, so the feature only worked through `h(Island, …)`, which is what render's own tests used. The array stays empty; the shell is `props.children`. Never satisfy this by importing solid's union. |
 | Island declaration order | `island()` above `defineRoute`, drained by it (`drainDeclaredIslands`). Package-internal — reachable from `./island`, never re-exported by `src/index.ts`: an app calling the drain between its `island()` and its `defineRoute` would silently un-declare the islands the route derives everything from, and a public export is semver-locked the moment it ships. Ambient, and NOT the thing the collector refuses to be: that one is per RENDER, where two requests would bill each other; this one is per MODULE, evaluated once, before any request — and `src` is resolved relative to the route file, so an `island()` call is route-module-local by construction. |
 | Derived budget | `registry.ts`, not `defineRoute`: a ceiling is only meaningful against a surface baseline, and the surface is a fact of the file path the route table already reads. `site/` → `20kb`, `app/` → `34kb` (`DEFAULT_ISLAND_JS_BYTES` above `jsBaselineBytes`). **Calibrated on a Solid island** `As of 2026-08`: it was `4kb`, sized from `contact-sales.island.tsx`, which imports no `solid-js` at all — and `render(() => <p>hello</p>, el)` measures 12,588 B, so the default sat a factor of three below the floor of every island that uses the JSX runtime, on every surface. A declared `budget.js` wins; a `'never'` route gets none, so the contradiction stays visible. |
-| `RouteEntry.islands` | filled from `config.islands` at registration, and from nothing else — `RegisterRouteInput` has no `islands` key. It was `input.islands ?? []`, undocumented and passed by nothing, so `routeJsBytes`'s "what registration declared" half read `[]` on every route in the framework's history; keeping it as a fallback would be a second answer to one question that can only ever weaken it, since a caller passing `[]` un-weighs a declared island. |
+| `RouteEntry.islands` | filled from `config.islands` at registration, and from nothing else — `RegisterRouteInput` has no `islands` key. It was `input.islands ?? []`, undocumented and passed by nothing, so the now-deleted `routeJsBytes`'s "what registration declared" half read `[]` on every route in the framework's history; keeping it as a fallback would be a second answer to one question that can only ever weaken it, since a caller passing `[]` un-declares an island. The field survives its one former reader: it is the only record a build has of an island a page declared but did not render on a given pass. |
 | Island props | declared, JSON-safe, under `ISLAND_PROPS_MAX_BYTES` — `island-props.ts` is the one gate. A structural walk, never a `JSON.stringify` round trip: stringify drops a function and an `undefined` silently, which is the footgun rather than the check. |
 | A prop lands via `Object.defineProperty` | never `out[key] = v`. For exactly one name — `__proto__`, which `JSON.parse` mints as a real OWN key off any request body — the assignment runs `Object.prototype`'s setter: the prop was DROPPED from the browser payload (the footgun the walk exists to prevent), the record handed back as `IslandProps` carried a prototype built from request data, so a later `bag.row.isAdmin` on the SERVER read attacker-chosen values, and `ISLAND_PROPS_MAX_BYTES` under-counted because `JSON.stringify` could not see it. Same shape `@ultimat3/mcp`'s `validate-args.ts` uses for the same class. |
 | An attribute alias is a `Map` | never a record — an object lookup walks the prototype chain, so `<div {...row} />` with a column named `toString` resolved the alias to a FUNCTION and `attribute.toLowerCase()` threw a bare `TypeError`: no code, no fix, the whole page 500s off a `load()` result. Same reason `MODE_SPECS[config.render]` in `modes.ts` is guarded by `Object.hasOwn`, where `render: 'constructor'` returned a frozen descriptor for a mode nothing implements. |
@@ -42,10 +56,11 @@ for the mirror-image reason, keeping `render → pwa` refused. Never `cli` (upwa
 | Which attributes take a URL | `URL_BEARING_ATTRIBUTES` in `html.ts` — core's four (`href`, `src`, `action`, `formaction`) plus `data`, `poster`, `ping` and `xlink:href`, each of which a browser FOLLOWS. `srcdoc` is refused outright: its value is entity-decoded and THEN parsed as HTML, so `escapeAttribute`'s `&lt;script&gt;` becomes a live `<script>` on this origin — escaping cannot make markup inert, so the attribute is never emitted, the same way `innerHTML` stays the one explicit escape hatch. |
 | Island collection | per render, passed as `renderToHtml(tree, { islands })`. Never module-global and never on an ambient context — two concurrent requests would bill one page for the other's JS, and `assertNoPerRequestState` refuses a live context under `static` anyway. |
 | A byte count in a message | `formatBytes` from `@ultimat3/core`, never a local one. This package's copy stopped at `kb`, so a 5 MB route read `5120kb` in `X_BUDGET_EXCEEDED` while `@ultimat3/pwa`'s own copy said `5mb` for the same bytes — two halves of one build disagreeing about the size of one artifact. Still on this barrel, because `@ultimat3/cli`'s budget reporter reads it beside the route table. |
-| Island bytes | `routeJsBytes` unions `entry.islands` with the rendered directives' `moduleId`s. Reading either alone is a budget that counts the runtime and not the chunk. |
+| Island bytes | **not this package's**, `As of 2026-08-23`. `routeJsBytes`, `graphFor`, `checkBudget`, `checkBudgets`, `assertBudget` and the `Island` / `BundleGraph` / `RouteBytes` / `BudgetReport` types were exported from the barrel and called by NOTHING outside this package's own tests — the near-miss is `@ultimat3/cli`'s own `checkBudgets` in `packages/cli/src/budgets.ts`, which measures the EMITTED document and is the gate that runs. Deleted rather than wired, because two answers to "what does this route weigh" — one of them never asked — is axiom 1, and a build error nothing calls is not a build error. What survives here is the budget GRAMMAR (`parseByteBudget`, which the CLI does import) and `defaultIslandBudget`, which `registerRoute` reaches. **Breaking**: the six functions and five types are gone from the public API. |
 | Island markup | the props `<script>` is emitted INSIDE the wrapper by `render-html.ts`, so a document assembler has exactly one thing left to remember: `hydrateRuntime(directives)`. |
 | Island boot | `el.__x` holds the boot PROMISE, never a boolean. As a flag, a second interaction while the chunk was still loading got a resolved promise back and the replay queue flushed into an island that had not mounted — the events went nowhere and the listeners were already removed. |
-| Island mount markers | `data-x-mounted=""` when `mount()` RESOLVED, `data-x-failed="<message>"` when it rejected — set by the runtime, never by `emitIslandAttributes`, because the server does not know the answer. `el.__x` alone cannot carry this: it is assigned when `import()` is CALLED, so a chunk still downloading and one whose `mount()` threw were the same observable, and telling those apart is what `x shot` gates on. Two attributes rather than two values of one, so `[data-x-mounted]` never counts a failure as a success. The rejection handler RETHROWS — swallowing it resolves `el.__x` and the interaction runtime flushes its replay queue into an island that never mounted, which is the row above reintroduced one layer out. Costs 129 B of shared prelude: `idle` 744, `visible` 816, `interaction` 1,010 (`As of 2026-08-21`, the numbers `DEFAULT_ISLAND_JS_BYTES` is derived from). |
+| Island mount markers | `data-x-mounted=""` when `mount()` RESOLVED, `data-x-failed="<message>"` when it rejected — set by the runtime, never by `emitIslandAttributes`, because the server does not know the answer. `el.__x` alone cannot carry this: it is assigned when `import()` is CALLED, so a chunk still downloading and one whose `mount()` threw were the same observable, and telling those apart is what `x shot` gates on. Two attributes rather than two values of one, so `[data-x-mounted]` never counts a failure as a success. The rejection handler RETHROWS — swallowing it resolves `el.__x` and the interaction runtime flushes its replay queue into an island that never mounted, which is the row above reintroduced one layer out. Costs 129 B of shared prelude: `idle` 774, `visible` 846, `interaction` 1,067 (`As of 2026-08-23`, the numbers `DEFAULT_ISLAND_JS_BYTES` is derived from). |
+| A runtime that calls `boot` | TERMINATES the chain, because `boot` rethrows. `idle` and `visible` end in `.catch(hush)`; `interaction` passes `off` as the rejection arm of its `then`. A bare `boot(el)` produced a fresh rejected promise per call — one unhandled rejection per user event on an island whose `mount()` threw — and, on `interaction`, left `done` false, the listeners attached and the queue growing by one retained `Event` (each with a live `target`) per click, for an island that will never mount. Nothing is lost by swallowing here: the DOM already carries the failure as `data-x-failed`, which is the row above and the documented observable. `hydrate-runtime.test.ts` runs all three against a real module; Bun's runner fails a test on an unhandled rejection, so the omission reds the suite by itself. |
 | `idle`'s deadline | `IDLE_HYDRATE_TIMEOUT_MS`, interpolated INTO the runtime string. Exported because a second reader has to agree — `x shot` waits before it photographs, and a settle shorter than this deadline reports an unhydrated page for one that hydrates perfectly. A constant the emitted string restates instead of reading is worse than no constant. |
 | Route truth | `registry.ts`. Never keep a second route list anywhere, and never a second *matcher*: this package's `matchRoute` was deleted in 2026-08 with zero consumers, because `@ultimat3/http`'s trie (`stages.ts`) is the one that serves requests and two matchers with different precedence rules is two answers to "which route is this?". `routeFor` is an exact-path `Map` lookup, not a pattern matcher. |
 | Route filename | `page.tsx` under `site/`/`app/`, `route.ts` under `api/` — `ROUTE_FILENAME`, one per surface. The URL is the directory path. Anything else is `X_ROUTE_FILE_INVALID`; never widen the table to accept a second spelling. |
@@ -68,7 +83,7 @@ for the mirror-image reason, keeping `render → pwa` refused. Never `cli` (upwa
 | Responses | return `RenderResult`. `@ultimat3/http` builds the `Response`. |
 | Solid | no `solid-js` import anywhere in this package — `type-pins.tsx` satisfies its `JSX.Element` structurally, through `jsxImportSource`, and never names it. The JSX factory in `jsx.ts` builds inert nodes — it is not a Solid renderer and must never become one. The client half runs in an island chunk, which `@ultimat3/cli`'s `solid-loader.ts` compiles with `babel-preset-solid`: Solid's reactivity is a COMPILE-time contract, so nothing this package could inject would substitute for it. `router-client.ts` was the one file built on that premise ("inject primitives") and it never had a caller. |
 | Root element | `ROOT_ELEMENT_ID` (`render-html.ts`), the id every document's body wraps its component in. It was `SPA_ROOT_ID` in `render-spa.ts`, naming a mode that never used it and that no longer exists. |
-| The loaders | `module-loader.ts` installs them at `index.ts` module scope, once. A plugin only affects modules loaded after it, so a second install point is a page that renders in one entry point and not another. |
+| The loaders | `module-loader.ts` installs them at **`server.ts`** module scope, once — `index.ts` until the barrel split, and it cannot be there again: the client barrel would carry `sass` and `node:url`. A plugin only affects modules loaded after it, so a second install point is a page that renders in one entry point and not another. Anything that loads an app's `.tsx` reaches `@ultimat3/render/server` first, which is why `packages/cli/src/app-load.ts` imports it for the side effect and nothing else. |
 | `<head>` baseline | `documentBaseline()` in `head.ts` — charset, viewport, `color-scheme` — merged FIRST so a route can still override any of them. Absent until `As of 2026-08`, and the missing `viewport` is why every deployed app rendered zoomed-out on a phone whatever its CSS said. |
 | Escaping | `html.ts` only, and that now includes `render-stream.ts` (`holeMarker`'s attribute, and `revealChunk`'s `$X(...)` argument via `JSON.stringify` — an id containing `")` closed the call and ran the rest) and `head.ts`'s `themeScript` (`storageKey`/`attribute` as JS string LITERALS). All author-controlled today — the identical status `emitIslandAttributes` had before the last sweep. `render-spa.ts` was the third entry here and went with the mode. A second escaper is how one of them ends up missing a character, and a missing character in an attribute is an injection. `escapeAttribute` itself is `@ultimat3/seo`'s (tier 1), re-exported by `html.ts` rather than reimplemented — the copy that lived here was the second escaper this row forbids, and `pwa/CLAUDE.md` already named seo's as the one. `head.ts` and `hydrate.ts` each had a private copy; both now import — `escapeAttribute` for every attribute value (`emitIslandAttributes` interpolated all five of its own raw until 2026-08, while this row already claimed otherwise) and `escapeJsonContent` for a JSON script body. |
 | Script and style CONTENT | never emitted raw. Three rules, one choice: HTML text (`escapeText`), raw text for code (`escapeRawTextContent`: `</` → `<\/`, `<!--` → `<\!--`), and the total JSON rule for a `type` ending in `json` (`escapeJsonContent`: `<`, `>`, `&`, U+2028/9 → `\uXXXX`, still valid JSON). `meta.ld` is built from route data, and it was emitted VERBATIM until `As of 2026-08` — a title could close the element. Never HTML-escape a script body: a character reference is not decoded there, so `&lt;` corrupts the code AND leaves the hole. |

package/README.md CHANGED Viewed

@@ -280,18 +280,22 @@ are never serialized.
 const collector = createIslandCollector({ file, hydrate: config.hydrate, resolve });
 const html = await renderToHtml(page, { islands: collector });
 document.body += hydrateRuntime(collector.directives);   // the one thing left to remember
-assertBudget(entry, measuredIslands, collector.directives);
 ```
-`routeJsBytes` reads **both** sources — what registration declared in `entry.islands` and what the
-render actually pulled in. Reading only the first is how a page could be charged for the hydration
-runtime and not for the chunk it boots: a budget that counts the wrapper and not the code.
+Declaring an island is what puts a `budget.js` on the route — `defaultIslandBudget(surface)`,
+applied by `registerRoute`, so a page that declares one is charged without saying so. **Weighing it
+is `x verify`'s `budgets` step**, which measures the emitted document against the manifest's
+per-route budget and fails with `X_BUDGET_EXCEEDED`.
+**Removed `As of 2026-08-23`** (breaking): `routeJsBytes`, `graphFor`, `checkBudget`, `checkBudgets`, `assertBudget` and
+the `Island` / `BundleGraph` / `RouteBytes` / `BudgetReport` types. They were a second, graph-based
+answer to the same question that nothing in the framework ever asked — the gate has always been the
+CLI's. `parseByteBudget` (the `'40kb'` grammar) and `defaultIslandBudget` stay.
 `entry.islands` is filled from `config.islands` at registration and from nothing else, so a declared
-island is weighed even on a route no render has touched. It was `input.islands ?? []` and nothing
-ever passed `islands`, which left that half of the union reading nothing at all; `RegisterRouteInput`
-no longer carries the key, because the only thing a caller could do with it was un-weigh a
-declaration.
+island is on the record even on a route no render has touched. It was `input.islands ?? []` and
+nothing ever passed `islands`; `RegisterRouteInput` no longer carries the key, because the only
+thing a caller could do with it was un-declare an island.
 An island on a route that resolves to `hydrate: 'never'`, or rendered with no collector, is
 `X_ISLAND_NOT_HYDRATED` — inert markup either way. With `hydrate` derived it means one of exactly
@@ -321,8 +325,32 @@ never flushed into an island that did not mount. `ISLAND_MOUNTED_ATTRIBUTE` and
 from, exported for the same reason: anything waiting for hydration has to wait at least this long,
 and a second copy of the number is a settle that shoots early and calls a healthy page broken.
+## Two entry points
+**Split 2026-08-22, and every claim in this section holds `As of 2026-08`.**
+`@ultimat3/render` is the **client** half — the `route` primitive, the JSX factory, islands,
+hydration, `<head>`, the route table. It bundles for the browser, and
+`scripts/browser-barrel.test.ts` builds it that way and asserts it.
+`@ultimat3/render/server` is the **build-time** half — the `.tsx`/`.scss` Bun loaders and the
+render pipeline. It imports `sass` and `node:url`, so it never reaches a browser bundle.
+The two are **disjoint**: no name is on both, and a file needing both imports both. That is the
+price of the split and it is the point of it — a single barrel could not be bundled for the
+browser at all, because `node:url`'s browser polyfill exports neither `fileURLToPath` nor
+`pathToFileURL` and the build fails at link time. No `sideEffects` value fixes that (measured:
+`false`, `[]` and an array naming only `errors.ts` all fail identically) — only not importing it
+does.
+**Importing `@ultimat3/render/server` installs the `.tsx`/`.scss` loaders**, once, as a module
+side effect. Anything that loads an app's source — `x dev`, `x build`, `server.ts`, a test that
+`await import()`s a `page.tsx` — reaches it before the module it loads.
 ## Public API
+`†` marks a name on `@ultimat3/render/server`.
 | Export | Owns |
 |---|---|
 | `defineRoute` | the `route` primitive |
@@ -330,12 +358,14 @@ and a second copy of the number is a settle that shoots early and calls a health
 | `MODE_SPECS`, `assertModeShape`, `assertModeInvariants` | the mode invariant table |
 | `registerRoute`, `describeRoutes`, `routeFor`, `routePathFromFile` | the route table |
 | `checkSurfaceBoundary`, `assertSurfaceBoundary`, `surfaceOf` | the hard boundary |
-| `renderStatic`, `enumeratePrerender` | build-time render, content hashing |
-| `createIsrController`, `invalidateAndRevalidate` | SWR + single-flight + tag triggers |
-| `renderSsr`, `streamResult` | the per-request modes |
+| `renderStatic`†, `enumeratePrerender`† | build-time render, content hashing |
+| `createIsrController`†, `invalidateAndRevalidate`† | SWR + single-flight + tag triggers |
+| `renderSsr`†, `streamResult`† | the per-request modes |
+| `renderToHtml`†, `renderComponent`†, `stylesFor`† | the server JSX writer and the surface's css |
+| `installRenderLoader`†, `compileStylesheet`† | the `.tsx`/`.scss` loaders, installed on import |
 | `emitIslandAttributes`, `hydrateRuntime` | the four hydration strategies |
 | `ISLAND_MOUNTED_ATTRIBUTE`, `ISLAND_FAILED_ATTRIBUTE`, `IDLE_HYDRATE_TIMEOUT_MS` | what hydration looks like from outside the page |
-| `graphFor`, `checkBudget`, `assertBudget` | two bundle graphs, per-route budgets |
+| `parseByteBudget`, `defaultIslandBudget` | the `'40kb'` budget grammar, and the ceiling a declared island earns |
 | `mergeHead`, `renderHead`, `themeScript` | `<head>` merge + the one inlined script |
 ## Notes

package/package.json CHANGED Viewed

@@ -1,12 +1,12 @@
 {
   "name": "@ultimat3/render",
-  "version": "8.0.0",
+  "version": "10.0.0",
   "description": "The route primitive and the five render modes: static, isr, ssr, stream, spa.",
   "license": "MIT",
   "type": "module",
   "sideEffects": [
     "./src/errors.ts",
-    "./src/index.ts"
+    "./src/server.ts"
   ],
   "repository": {
     "type": "git",
@@ -18,7 +18,8 @@
     "provenance": true
   },
   "exports": {
-    ".": "./src/index.ts"
+    ".": "./src/index.ts",
+    "./server": "./src/server.ts"
   },
   "files": [
     "src",
@@ -35,10 +36,10 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@ultimat3/cache": "8.0.0",
-    "@ultimat3/core": "8.0.0",
-    "@ultimat3/i18n": "8.0.0",
-    "@ultimat3/seo": "8.0.0",
+    "@ultimat3/cache": "10.0.0",
+    "@ultimat3/core": "10.0.0",
+    "@ultimat3/i18n": "10.0.0",
+    "@ultimat3/seo": "10.0.0",
     "sass": "1.102.0"
   }
 }

package/src/errors.ts CHANGED Viewed

@@ -54,7 +54,12 @@ registerErrorCodes(
   Object.fromEntries(Object.entries(RENDER_ERROR_TITLES).map(([code, title]) => [code, { title }])),
 );
-const docsFor = (code: RenderErrorCode): string => `https://ultimate.dev/errors/${code}`;
+// No `docs:` on the subclasses below. `UltimateError` fills it from `describeErrorCode(code).docs`,
+// which is `@ultimat3/core`'s `ERROR_DOCS_URL` — one page for every code, never one per code, because
+// `wiki/` is the framework's only public documentation surface and a code lives there in a TABLE ROW,
+// which has no anchor. The `https://ultimate.dev/errors/<code>` links this file built until 9.x
+// answered 404, host included, on every error it has ever thrown; restating the replacement here
+// would be the same constant in eight places waiting to drift again.
 /** A render mode's invariant was violated at registration (see `modes.ts`). */
 export class RouteModeInvalidError extends UltimateError {
@@ -64,7 +69,6 @@ export class RouteModeInvalidError extends UltimateError {
       code: RouteModeInvalidError.code,
       cause,
       fix,
-      docs: docsFor(RouteModeInvalidError.code),
     });
   }
 }
@@ -77,7 +81,6 @@ export class RouteOfflineMissingError extends UltimateError {
       code: RouteOfflineMissingError.code,
       cause,
       fix,
-      docs: docsFor(RouteOfflineMissingError.code),
     });
   }
 }
@@ -90,7 +93,6 @@ export class RouteMetaMissingError extends UltimateError {
       code: RouteMetaMissingError.code,
       cause,
       fix,
-      docs: docsFor(RouteMetaMissingError.code),
     });
   }
 }
@@ -107,7 +109,6 @@ export class RouteUnnormalizedError extends UltimateError {
       code: RouteUnnormalizedError.code,
       cause,
       fix,
-      docs: docsFor(RouteUnnormalizedError.code),
     });
   }
 }
@@ -120,7 +121,6 @@ export class RouteDuplicateError extends UltimateError {
       code: RouteDuplicateError.code,
       cause,
       fix,
-      docs: docsFor(RouteDuplicateError.code),
     });
   }
 }
@@ -138,7 +138,6 @@ export class RouteFileInvalidError extends UltimateError {
       code: RouteFileInvalidError.code,
       cause,
       fix,
-      docs: docsFor(RouteFileInvalidError.code),
     });
   }
 }
@@ -151,7 +150,6 @@ export class SurfaceBoundaryError extends UltimateError {
       code: SurfaceBoundaryError.code,
       cause,
       fix,
-      docs: docsFor(SurfaceBoundaryError.code),
     });
   }
 }
@@ -164,7 +162,6 @@ export class BudgetExceededError extends UltimateError {
       code: BudgetExceededError.code,
       cause,
       fix,
-      docs: docsFor(BudgetExceededError.code),
     });
   }
 }
@@ -177,7 +174,6 @@ export class PrerenderFailedError extends UltimateError {
       code: PrerenderFailedError.code,
       cause,
       fix,
-      docs: docsFor(PrerenderFailedError.code),
     });
   }
 }
@@ -190,7 +186,6 @@ export class RouteLoadInvalidError extends UltimateError {
       code: RouteLoadInvalidError.code,
       cause,
       fix,
-      docs: docsFor(RouteLoadInvalidError.code),
     });
   }
 }
@@ -207,7 +202,6 @@ export class IslandInvalidError extends UltimateError {
       code: IslandInvalidError.code,
       cause,
       fix,
-      docs: docsFor(IslandInvalidError.code),
     });
   }
 }
@@ -224,7 +218,6 @@ export class IslandPropsInvalidError extends UltimateError {
       code: IslandPropsInvalidError.code,
       cause,
       fix,
-      docs: docsFor(IslandPropsInvalidError.code),
     });
   }
 }
@@ -242,7 +235,6 @@ export class IslandNotHydratedError extends UltimateError {
       code: IslandNotHydratedError.code,
       cause,
       fix,
-      docs: docsFor(IslandNotHydratedError.code),
     });
   }
 }
@@ -259,7 +251,6 @@ export class RouteLoadFailedError extends UltimateError {
       code: RouteLoadFailedError.code,
       cause,
       fix,
-      docs: docsFor(RouteLoadFailedError.code),
     });
   }
 }

package/src/hydrate.ts CHANGED Viewed

@@ -122,31 +122,44 @@ return el.__x=import(e).then(function(m){return m.mount(el,props)}).then(
 function(r){el.setAttribute('${ISLAND_MOUNTED_ATTRIBUTE}','');return r},
 function(x){el.setAttribute('${ISLAND_FAILED_ATTRIBUTE}',x&&x.message||'1');throw x})}
 function each(s,f){Array.prototype.forEach.call(document.querySelectorAll(s),f)}
+function hush(){}
 `.trim();
+// `hush` above: `boot` rethrows, so every runtime below has to terminate the chain it starts or
+// the page reports an unhandled rejection for a failure it already recorded on the element.
 const RUNTIME_IDLE = `
 each('[data-x-hydrate="idle"]',function(el){
-var go=function(){boot(el)};
+var go=function(){boot(el).catch(hush)};
 if('requestIdleCallback'in window)requestIdleCallback(go,{timeout:${IDLE_HYDRATE_TIMEOUT_MS}});else setTimeout(go,1)})
 `.trim();
 const RUNTIME_VISIBLE = `
 each('[data-x-hydrate="visible"]',function(el){
 var io=new IntersectionObserver(function(es){es.forEach(function(en){
-if(en.isIntersecting){io.disconnect();boot(el)}})},{rootMargin:el.getAttribute('data-x-margin')||'200px'});
+if(en.isIntersecting){io.disconnect();boot(el).catch(hush)}})},{rootMargin:el.getAttribute('data-x-margin')||'200px'});
 io.observe(el)})
 `.trim();
 // Event replay: the listener is registered before the chunk exists, records the event that
 // woke the island, and re-dispatches it once mounted. Without this, the first click on a
 // cold island is silently lost — the failure users read as "the button does nothing".
+//
+// `off` is BOTH arms of the `then`, and the rejection arm is the reason it is a named function.
+// `boot` rethrows on purpose (see the prelude), so `el.__x` holds a rejected promise from the
+// first failed mount onward — and a `.then` with no rejection handler makes a fresh rejected
+// promise out of it on EVERY event, i.e. one unhandled rejection per user click, forever. The
+// queue was the second half: nothing ever set `done`, so the listeners stayed attached and `q`
+// grew by one retained `Event` — each holding a live `target` — per click, for an island that
+// will never mount. Swallowing here loses no signal: the DOM already carries the failure as
+// `data-x-failed`, which is the documented observable.
 const RUNTIME_INTERACTION = `
 each('[data-x-hydrate="interaction"]',function(el){
 var evs=(el.getAttribute('data-x-events')||'click').split(' ');
 var q=[],done=false;
+var off=function(){done=true;evs.forEach(function(n){el.removeEventListener(n,on,true)});q=[]};
 var on=function(ev){if(done)return;q.push(ev);
-boot(el).then(function(){done=true;evs.forEach(function(n){el.removeEventListener(n,on,true)});
-q.forEach(function(ev){var c=new ev.constructor(ev.type,ev);ev.target.dispatchEvent(c)});q=[]})};
+boot(el).then(function(){var r=q;off();
+r.forEach(function(ev){var c=new ev.constructor(ev.type,ev);ev.target.dispatchEvent(c)})},off)};
 evs.forEach(function(n){el.addEventListener(n,on,true)})})
 `.trim();

package/src/index.ts CHANGED Viewed

@@ -1,13 +1,8 @@
-/** Public API of `@ultimat3/render`: the `route` primitive, the five modes, the table. */
-import { installRenderLoader } from './module-loader';
-// A side effect on import, deliberately: a Bun plugin only transforms modules loaded AFTER it, and
-// every consumer that will ever load a `.tsx` route or a `.scss` module imports this package first
-// (an app's route file imports `defineRoute` from here before it imports anything else it owns).
-// Any later hook — `x dev`, `x build`, `server.ts` — would each have to remember, which is four
-// places one fact can be wrong instead of none.
-installRenderLoader();
+/**
+ * The CLIENT half of `@ultimat3/render` — the `route` primitive, the JSX factory, islands, and the
+ * tables describing them — kept disjoint from `@ultimat3/render/server` because everything here
+ * must bundle for a browser, which the loaders cannot (axiom 6).
+ */
 /**
  * The route vocabulary is declared once, at tier 0 (`@ultimat3/core`), and re-exported here
@@ -21,8 +16,6 @@ export type { HydrateStrategy, OfflineStrategy, RenderMode } from '@ultimat3/cor
 // never had); still named here because `@ultimat3/cli`'s budget reporter reads it beside the route
 // table it prints against.
 export { formatBytes, HYDRATE_STRATEGIES, OFFLINE_STRATEGIES, RENDER_MODES } from '@ultimat3/core';
-export type { CompiledStylesheet } from './css-modules';
-export { compileStylesheet, isCssModule, isGlobalStylesheet, scopeClasses } from './css-modules';
 export { parseTtlMs } from './duration';
 export type { RenderErrorCode } from './errors';
 export {
@@ -84,15 +77,7 @@ export type { IslandCollector, IslandCollectorInput } from './island-collector';
 export { createIslandCollector, islandModuleIds } from './island-collector';
 export type { IslandProps, JsonValue } from './island-props';
 export { checkIslandProps, ISLAND_PROPS_MAX_BYTES } from './island-props';
-export type { BudgetReport, BundleGraph, GraphName, Island, RouteBytes } from './islands';
-export {
-  assertBudget,
-  checkBudget,
-  checkBudgets,
-  graphFor,
-  parseByteBudget,
-  routeJsBytes,
-} from './islands';
+export { parseByteBudget } from './islands';
 export type { JsxComponent, JsxNode, JsxProps } from './jsx';
 export { Fragment, h, isJsxNode, JSX_NODE } from './jsx';
 export type { ModeCheckContext, ModeSpec, RouteShape } from './modes';
@@ -104,15 +89,6 @@ export {
   defaultIslandBudget,
   MODE_SPECS,
 } from './modes';
-export type { Stylesheet } from './module-loader';
-export {
-  clearStylesheets,
-  installRenderLoader,
-  loadStylesheet,
-  registeredStylesheets,
-  stylesFor,
-  transformTsx,
-} from './module-loader';
 export type {
   CompiledPattern,
   RegisterRouteInput,
@@ -130,48 +106,6 @@ export {
   routeFor,
   routePathFromFile,
 } from './registry';
-export type { RenderHtmlOptions } from './render-html';
-export { ROOT_ELEMENT_ID, renderComponent, renderToHtml } from './render-html';
-export type {
-  IsrController,
-  IsrControllerOptions,
-  IsrEntry,
-  IsrRenderFn,
-  IsrServeResult,
-  IsrState,
-  IsrStore,
-  MemoryIsrStoreOptions,
-} from './render-isr';
-export {
-  createIsrController,
-  DEFAULT_ISR_MAX_ENTRIES,
-  invalidateAndRevalidate,
-  isrKey,
-  memoryIsrStore,
-} from './render-isr';
-export type { SsrOptions, SsrRenderFn, SsrRenderInput } from './render-ssr';
-export { renderSsr, ssrHeaders } from './render-ssr';
-export type { StaticArtifact, StaticBuildOptions, StaticRenderFn } from './render-static';
-export {
-  assertNoPerRequestState,
-  contentHash,
-  enumeratePrerender,
-  fillPath,
-  renderStatic,
-  staticHeaders,
-  staticResult,
-} from './render-static';
-export type { StreamHole, StreamOptions, StreamPlan } from './render-stream';
-export {
-  collectStream,
-  DEFAULT_HOLE_TIMEOUT_MS,
-  holeId,
-  holeMarker,
-  REVEAL_SCRIPT,
-  renderStreamHtml,
-  revealChunk,
-  streamResult,
-} from './render-stream';
 export type {
   LoadRequirement,
   PrerenderFn,

package/src/islands.ts CHANGED Viewed

@@ -1,50 +1,19 @@
 /**
- * Island boundaries and the two separate bundle graphs. `site/` and `app/` never share a
- * graph: that is the mechanical half of axiom 6 (the surface boundary in `surfaces.ts` is
- * the other half). `site/` starts at a 0kb baseline and every byte after that is an
- * opt-in, budgeted island.
+ * How a byte budget is WRITTEN — `'40kb'` — and nothing else.
+ *
+ * It was the whole graph-based budget API: `Island`, `BundleGraph`, `graphFor`, `routeJsBytes`,
+ * `checkBudget`, `checkBudgets`, `assertBudget`. Every one of them was exported from the barrel and
+ * called by nothing outside this package's own tests. The real gate is `@ultimat3/cli`'s
+ * `checkBudgets` (`packages/cli/src/budgets.ts`), which measures the EMITTED document against the
+ * manifest's per-route `budget` and has its own `parseByteBudget` caller — the near-miss that made
+ * the dead half look reached. Deleted 2026-08-23 rather than wired: two answers to "what does this
+ * route weigh", one of which never ran, is the ambiguity axiom 1 refuses, and a build error nothing
+ * calls is not a build error.
+ *
+ * `defaultIslandBudget` in `modes.ts` is the surviving half of the island-budget story: it is
+ * reached, through `registerRoute`, and it is what puts a number on a route that declares none.
  */
-import type { HydrateStrategy } from '@ultimat3/core';
-// One formatter, in `@ultimat3/core`: the copy that lived here had no `mb` branch, so a 5 MB route
-// read `5120kb` in `X_BUDGET_EXCEEDED` while `@ultimat3/pwa` said `5mb` for the same bytes.
-import { formatBytes } from '@ultimat3/core';
-import { BudgetExceededError } from './errors';
-import type { IslandDirective } from './hydrate';
-import { hydrateRuntimeBytes } from './hydrate';
-import type { RouteEntry } from './registry';
-import type { Surface } from './surfaces';
-import { SURFACE_SPECS } from './surfaces';
-/** A bundle graph is per surface. There are exactly two that ship JS: `site` and `app`. */
-export type GraphName = 'site' | 'app';
-export interface Island {
-  readonly id: string;
-  readonly file: string;
-  readonly graph: GraphName;
-  readonly strategy: HydrateStrategy;
-  /** Measured from the real bundle, gzip-before-brotli agnostic: raw bytes. */
-  readonly bytes: number;
-  /** The import chain that pulled the heaviest dependency in, for error messages. */
-  readonly heaviestChain?: readonly string[];
-}
-export interface BundleGraph {
-  readonly name: GraphName;
-  readonly baselineBytes: number;
-  readonly islands: readonly Island[];
-}
-export function graphFor(surface: Surface, islands: readonly Island[]): BundleGraph {
-  const name: GraphName = surface === 'site' ? 'site' : 'app';
-  return {
-    name,
-    baselineBytes: SURFACE_SPECS[name].jsBaselineBytes,
-    islands: islands.filter((island) => island.graph === name && island.strategy !== 'never'),
-  };
-}
 const UNITS: Readonly<Record<string, number>> = { b: 1, kb: 1024, mb: 1024 * 1024 };
 /** `'40kb'` → 40960. Throws nothing: an unparseable budget is `null` and skipped. */
@@ -57,120 +26,3 @@ export function parseByteBudget(budget: string | undefined): number | null {
   const factor = UNITS[unit];
   return factor === undefined ? null : Math.round(Number(amount) * factor);
 }
-export interface RouteBytes {
-  readonly total: number;
-  readonly baseline: number;
-  readonly islandBytes: number;
-  readonly runtimeBytes: number;
-  readonly heaviest: Island | null;
-}
-export function routeJsBytes(
-  entry: RouteEntry,
-  islands: readonly Island[],
-  directives: readonly IslandDirective[] = [],
-): RouteBytes {
-  const graph = graphFor(entry.surface, islands);
-  // Two sources, unioned: `entry.islands` is what registration declared, and the directives are
-  // what the page actually rendered. Reading only the first is how the runtime bytes of an island
-  // could be charged while its chunk was not — a budget that counts the wrapper and not the code.
-  const onRoute = graph.islands.filter(
-    (island) =>
-      entry.islands.includes(island.id) ||
-      directives.some((directive) => (directive.moduleId ?? directive.islandId) === island.id),
-  );
-  const islandBytes = onRoute.reduce((sum, island) => sum + island.bytes, 0);
-  const runtimeBytes = directives.length > 0 ? hydrateRuntimeBytes(directives) : 0;
-  const baseline = islandBytes === 0 && runtimeBytes === 0 ? 0 : graph.baselineBytes;
-  const heaviest = onRoute.reduce<Island | null>(
-    (max, island) => (max === null || island.bytes > max.bytes ? island : max),
-    null,
-  );
-  return {
-    total: baseline + islandBytes + runtimeBytes,
-    baseline,
-    islandBytes,
-    runtimeBytes,
-    heaviest,
-  };
-}
-export interface BudgetReport {
-  readonly path: string;
-  readonly measured: number;
-  readonly limit: number | null;
-  readonly ok: boolean;
-  readonly cause: string | null;
-}
-/**
- * The build gate. Failure names the *cause* — the island and the transitive import that
- * added the bytes — because "bundle too big" without a chain is not an instruction.
- */
-export function checkBudget(
-  entry: RouteEntry,
-  islands: readonly Island[],
-  directives: readonly IslandDirective[] = [],
-): BudgetReport {
-  const bytes = routeJsBytes(entry, islands, directives);
-  const limit = parseByteBudget(entry.config.budget.js);
-  // site/ has a 0kb default: shipping JS there without declaring a budget is the failure.
-  if (limit === null && entry.surface === 'site' && bytes.total > 0) {
-    return {
-      path: entry.path,
-      measured: bytes.total,
-      limit: 0,
-      ok: false,
-      cause:
-        `${entry.path} is in site/ (0kb JS baseline) and ships ${formatBytes(bytes.total)} ` +
-        `with no budget.js${chainOf(bytes.heaviest)}`,
-    };
-  }
-  if (limit === null) {
-    return { path: entry.path, measured: bytes.total, limit: null, ok: true, cause: null };
-  }
-  const ok = bytes.total <= limit;
-  return {
-    path: entry.path,
-    measured: bytes.total,
-    limit,
-    ok,
-    cause: ok
-      ? null
-      : `${entry.path}  js ${formatBytes(bytes.total)} > ${formatBytes(limit)}${chainOf(bytes.heaviest)}`,
-  };
-}
-function chainOf(island: Island | null): string {
-  if (island === null) return '';
-  const chain = island.heaviestChain;
-  if (chain === undefined || chain.length === 0) return ` (heaviest island: ${island.file})`;
-  return ` (${chain.join(' → ')})`;
-}
-export function assertBudget(
-  entry: RouteEntry,
-  islands: readonly Island[],
-  directives: readonly IslandDirective[] = [],
-): void {
-  const report = checkBudget(entry, islands, directives);
-  if (report.ok || report.cause === null) return;
-  throw new BudgetExceededError(
-    report.cause,
-    `raise budget.js in ${entry.file} deliberately, or remove the import that added the bytes`,
-  );
-}
-/** `x verify` prints every route, not just the first failure. */
-export function checkBudgets(
-  entries: readonly RouteEntry[],
-  islands: readonly Island[],
-): readonly BudgetReport[] {
-  return entries
-    .map((entry) => checkBudget(entry, islands))
-    .sort((a, b) => a.path.localeCompare(b.path));
-}

package/src/modes.ts CHANGED Viewed

@@ -225,18 +225,21 @@ export function defaultHydrate(surface: Surface): HydrateStrategy {
  * (`settings.island.tsx`) is 17,797 B. No `budget.js` under 4096 was reachable by any of them, on
  * any surface, because the allowance is measured above the baseline and not against it.
  *
- * The number: 17,797 (the heaviest island this repo actually ships) + 1,010 (`hydrateRuntimeBytes`
+ * The number: 17,797 (the heaviest island this repo actually ships) + 1,067 (`hydrateRuntimeBytes`
  * for one directive at `DEFAULT_ISLAND_HYDRATE`, which is `'interaction'` — `route.ts:33`, applied
- * at `:253` to any island route declaring no `hydrate`) = **18,807**. That is the worst case an
+ * at `:253` to any island route declaring no `hydrate`) = **18,864**. That is the worst case an
  * app reaches without writing a number down. 20,480 is NOT that rounded up — the next whole
- * kilobyte above it is 19,456 — it is one whole kB further, leaving 1,673 B of headroom and still
- * under 2x 18,807, so a route bundling the same island twice is refused. `island-budget.test.ts`
- * asserts all three. `idle` costs 744 and `visible` 816, so an island route that declares its
+ * kilobyte above it is 19,456 — it is one whole kB further, leaving 1,616 B of headroom and still
+ * under 2x 18,864, so a route bundling the same island twice is refused. `island-budget.test.ts`
+ * asserts all three. `idle` costs 774 and `visible` 846, so an island route that declares its
  * strategy pays less; the default is what the budget has to clear.
  *
  * All three grew by 129 B on 2026-08-21 (from 881 / 615 / 687), when the prelude learned to mark a
- * mount's OUTCOME so `x shot` can tell an island that RAN from one that only started loading. The
- * headroom absorbed it and the conclusion is unchanged — which is the point of stating the
+ * mount's OUTCOME so `x shot` can tell an island that RAN from one that only started loading, and
+ * again on 2026-08-23 — +18 B in the shared prelude (`hush`) for all three, +39 B more on
+ * `interaction` — when each runtime learned to TERMINATE the promise chain `boot` starts rather
+ * than emit one unhandled rejection per user event. The headroom absorbed both and the conclusion
+ * is unchanged, which is the point of stating the
  * arithmetic here rather than the answer alone. It is not
  * derived from Solid's own size on purpose — this package may not import or name `solid-js`
  * (`CLAUDE.md`), so a constant tracking the runtime's version would be a dependency in a comment.

package/src/registry.ts CHANGED Viewed

@@ -269,9 +269,11 @@ export function registerRoute<TData = RouteData>(
     config,
     suspenseBoundaries,
     // The declaration is the ONLY source. It was `input.islands ?? []`, which nothing ever passed,
-    // so `routeJsBytes`'s "what registration declared" half read `[]` on every route in the
-    // framework's history — and keeping the input as a fallback would be a second answer to one
-    // question that can only ever weaken it: a caller passing `[]` un-weighs a declared island.
+    // so the now-deleted `routeJsBytes`'s "what registration declared" half read `[]` on every
+    // route in the framework's history — and keeping the input as a fallback would be a second
+    // answer to one question that can only ever weaken it: a caller passing `[]` un-declares an
+    // island. The field outlives that reader: it is the only record a build has of an island a
+    // page declared but did not render on a given pass.
     islands: config.islands.map((spec) => spec.moduleId),
     pattern: compilePattern(path),
     // Spread, never assigned: `exactOptionalPropertyTypes` makes an explicit `undefined` a

package/src/render-html.ts CHANGED Viewed

@@ -30,6 +30,20 @@ export const ROOT_ELEMENT_ID = 'x-root';
 /** Depth is bounded so a component that renders itself fails with a cause instead of a stack trace. */
 const MAX_DEPTH = 500;
+/**
+ * Asserted at the top of `unwrap`, not only in `renderNode`. The element path was the only one
+ * bounded, and it is not the only one that recurses: `unwrap` walks arrays and calls thunks, both
+ * of which a component's `children` routinely are, so a self-referencing array or a self-returning
+ * accessor escaped `renderToHtml` as a bare `RangeError` — no code, no `fix:`, nothing to catch by.
+ */
+function assertDepth(depth: number): void {
+  if (depth <= MAX_DEPTH) return;
+  throw new PrerenderFailedError(
+    `component tree exceeded ${MAX_DEPTH} levels, so it renders itself`,
+    'remove the self-reference from the component that renders its own tag',
+  );
+}
 /**
  * What the walk carries besides depth. One object per render, never module-global: two concurrent
  * requests render different params, and a shared collector would bill one page for the other's JS.
@@ -41,8 +55,12 @@ export interface RenderHtmlOptions {
 /**
  * A thunk is called, not stringified. Solid's reactive reads are accessors (`count()`), and a
  * `children` prop is routinely a function — evaluating it once is exactly the server's job.
+ *
+ * Which is also why the depth bound belongs HERE and not only on the element path: the array and
+ * thunk branches below recurse, and both are ordinary shapes for a component's children.
  */
 async function unwrap(value: unknown, depth: number, walk: RenderHtmlOptions): Promise<string> {
+  assertDepth(depth);
   if (value === null || value === undefined || value === false || value === true) return '';
   if (typeof value === 'string') return escapeText(value);
   if (typeof value === 'number' || typeof value === 'bigint') return escapeText(String(value));
@@ -106,12 +124,7 @@ async function renderNode(
   depth: number,
   walk: RenderHtmlOptions,
 ): Promise<string> {
-  if (depth > MAX_DEPTH) {
-    throw new PrerenderFailedError(
-      `component tree exceeded ${MAX_DEPTH} levels, so it renders itself`,
-      'remove the self-reference from the component that renders its own tag',
-    );
-  }
+  assertDepth(depth);
   if (typeof type === 'string') return renderElement(type, props, depth, walk);
   return unwrap(type(props), depth + 1, walk);
 }

package/src/server.ts ADDED Viewed

@@ -0,0 +1,72 @@
+/**
+ * The BUILD-TIME half of `@ultimat3/render` — the loaders and the route → bytes pipeline — split
+ * off because `css-modules.ts` imports `node:url`, whose browser polyfill exports neither name it
+ * asks for: one barrel carrying both halves could not be bundled for a browser at all (axiom 6).
+ * Disjoint from `@ultimat3/render` by construction, which `server.test.ts` checks.
+ */
+import { installRenderLoader } from './module-loader';
+// A side effect on import, deliberately, and the reason this barrel is named in `sideEffects`: a
+// Bun plugin only transforms modules loaded AFTER it, so the install has to happen before any
+// `.tsx` route or `.scss` module is imported. It lives on THIS barrel rather than on
+// `@ultimat3/render` because the loader is build-time code — a browser bundle that reached it
+// would carry `sass` and `node:fs`, which is the defect this split closes.
+installRenderLoader();
+// ---- scss → css, and the scoped class map every `import styles from` receives -------------------
+export type { CompiledStylesheet } from './css-modules';
+export { compileStylesheet, isCssModule, isGlobalStylesheet, scopeClasses } from './css-modules';
+// ---- the two Bun loaders: `.tsx` → the server JSX factory, `.scss` → css + a class map ----------
+export type { Stylesheet } from './module-loader';
+export {
+  clearStylesheets,
+  installRenderLoader,
+  loadStylesheet,
+  registeredStylesheets,
+  stylesFor,
+  transformTsx,
+} from './module-loader';
+// ---- the render pipeline: one entry point per mode ----------------------------------------------
+export type { RenderHtmlOptions } from './render-html';
+export { ROOT_ELEMENT_ID, renderComponent, renderToHtml } from './render-html';
+export type {
+  IsrController,
+  IsrControllerOptions,
+  IsrEntry,
+  IsrRenderFn,
+  IsrServeResult,
+  IsrState,
+  IsrStore,
+  MemoryIsrStoreOptions,
+} from './render-isr';
+export {
+  createIsrController,
+  DEFAULT_ISR_MAX_ENTRIES,
+  invalidateAndRevalidate,
+  isrKey,
+  memoryIsrStore,
+} from './render-isr';
+export type { SsrOptions, SsrRenderFn, SsrRenderInput } from './render-ssr';
+export { renderSsr, ssrHeaders } from './render-ssr';
+export type { StaticArtifact, StaticBuildOptions, StaticRenderFn } from './render-static';
+export {
+  assertNoPerRequestState,
+  contentHash,
+  enumeratePrerender,
+  fillPath,
+  renderStatic,
+  staticHeaders,
+  staticResult,
+} from './render-static';
+export type { StreamHole, StreamOptions, StreamPlan } from './render-stream';
+export {
+  collectStream,
+  DEFAULT_HOLE_TIMEOUT_MS,
+  holeId,
+  holeMarker,
+  REVEAL_SCRIPT,
+  renderStreamHtml,
+  revealChunk,
+  streamResult,
+} from './render-stream';