@txco/nitro-preset 0.1.0

package/dist/preset.d.ts

@@ -0,0 +1,24 @@
+export type { ThanksComputerOptions } from "./types.js";
+declare const preset: {
+    entry: string;
+    node: boolean;
+    noExternals: boolean;
+    serveStatic: boolean;
+    output: {
+        dir: string;
+        serverDir: string;
+        publicDir: string;
+    };
+    commands: {
+        deploy: string;
+    };
+    modules: {
+        name: string;
+        setup(nitro: import("nitropack").Nitro): Promise<void>;
+    }[];
+    _meta: {
+        name: string;
+        url: string;
+    };
+};
+export default preset;

package/dist/preset.js

@@ -0,0 +1,39 @@
+// @txco/nitro-preset: the `thanks-computer` Nitro preset. It builds a Nitro
+// app (Nuxt, Analog) as a Web ABI build for `txco apply` to install:
+//
+//   txco-web/
+//     txco-web.json   the manifest
+//     public/         the site: Nitro's public output, prerendered pages included
+//     ops/            the navigation op and the catch-all
+//     server/         the app's server as a Fetch handler (`nuxi build` only)
+//
+//   // nuxt.config.ts
+//   export default defineNuxtConfig({ nitro: { preset: "@txco/nitro-preset" } })
+//
+// Written in Nitro's in-tree preset shape, so it can move upstream. It
+// doesn't import nitropack at runtime: a Nuxt app doesn't depend on it
+// directly, and a strict package manager won't resolve it from here.
+import { fileURLToPath } from "node:url";
+import { PRESET } from "./finalize.js";
+import { thanksComputerModule } from "./module.js";
+const preset = {
+    entry: fileURLToPath(new URL("./runtime/entry.js", import.meta.url)),
+    // Node built-ins stay native; every dependency is bundled into server/,
+    // which deploys without an install step.
+    node: true,
+    noExternals: true,
+    // The chassis serves public/ before the app's stack runs.
+    serveStatic: false,
+    output: {
+        dir: "{{ rootDir }}/txco-web",
+        serverDir: "{{ output.dir }}/server",
+        publicDir: "{{ output.dir }}/public/{{ baseURL }}",
+    },
+    commands: {
+        deploy: "txco apply",
+    },
+    modules: [thanksComputerModule],
+    // What defineNitroPreset (nitropack/kit) adds, inlined.
+    _meta: { name: PRESET, url: import.meta.url },
+};
+export default preset;

package/dist/runtime/entry.d.ts

@@ -0,0 +1,10 @@
+import "#nitro-internal-pollyfills";
+interface Context {
+    client?: {
+        ip?: string;
+    };
+}
+declare const _default: {
+    fetch(request: Request, ctx?: Context): Promise<Response>;
+};
+export default _default;

package/dist/runtime/entry.js

@@ -0,0 +1,26 @@
+// The server entry: Nitro's app as a Fetch handler, in the Web ABI's server
+// shape, `export default { fetch(request, ctx) }` with ctx = { client: { ip } }.
+// Nitro bundles this file into server/index.mjs; the imports below are its
+// own, resolved at bundle time.
+import "#nitro-internal-pollyfills";
+import { useNitroApp } from "nitropack/runtime";
+const nitroApp = useNitroApp();
+export default {
+    async fetch(request, ctx) {
+        const url = new URL(request.url);
+        const method = request.method.toUpperCase();
+        const body = method === "GET" || method === "HEAD" ? undefined : Buffer.from(await request.arrayBuffer());
+        return nitroApp.localFetch(url.pathname + url.search, {
+            host: url.hostname,
+            protocol: url.protocol,
+            method,
+            headers: request.headers,
+            body,
+            // Nitro spreads _platform into event.context; h3's getRequestIP reads
+            // context.clientAddress first.
+            context: {
+                _platform: { clientAddress: ctx?.client?.ip, thanksComputer: { client: ctx?.client } },
+            },
+        });
+    },
+};

package/dist/types.d.ts

@@ -0,0 +1,22 @@
+/** Options, set as `nitro: { thanksComputer: { … } }` (Nuxt) or the Nitro config's `thanksComputer`. */
+export interface ThanksComputerOptions {
+    /**
+     * Answer every unknown page path with the app shell and 200, for an app
+     * that routes in the browser. Detected for Nuxt `ssr: false` and Analog's
+     * client renderer; set it to force the choice either way.
+     */
+    spa?: boolean;
+    /**
+     * The public/ prefixes cached for a year (`["assets/"]`), each a directory
+     * ending in "/". Derived from the framework's asset dirs when unset (Nuxt:
+     * `_nuxt/`).
+     */
+    immutable?: string[];
+    /** The scope of the navigation op; the catch-all goes 900 above it. Default 900000. */
+    scope?: number;
+}
+declare module "nitropack/presets" {
+    interface PresetOptions {
+        thanksComputer?: ThanksComputerOptions;
+    }
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@txco/nitro-preset",
+  "version": "0.1.0",
+  "description": "Nitro preset for Thanks, Computer (txco): builds a Nuxt or other Nitro app as a Web ABI build — your site as public/, the ops it needs as ops/, its server as server/, and txco-web.json — for `txco apply` to install.",
+  "license": "MIT",
+  "type": "module",
+  "sideEffects": false,
+  "keywords": [
+    "nitro",
+    "nitro-preset",
+    "nuxt",
+    "analog",
+    "txco",
+    "thanks-computer",
+    "static",
+    "web-abi"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/LoremLabs/thanks-computer.git",
+    "directory": "sdk/nitro-preset"
+  },
+  "homepage": "https://github.com/LoremLabs/thanks-computer/tree/master/sdk/nitro-preset#readme",
+  "bugs": "https://github.com/LoremLabs/thanks-computer/issues",
+  "files": [
+    "dist",
+    "src",
+    "README.md"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/preset.d.ts",
+      "default": "./dist/preset.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "clean": "rm -rf dist",
+    "build": "tsc -p tsconfig.json",
+    "prepublishOnly": "npm run clean && npm run build",
+    "test": "npm run build && node --test test/*.test.mjs"
+  },
+  "dependencies": {
+    "@txco/web-abi": "^0.2.0"
+  },
+  "peerDependencies": {
+    "nitropack": "^2.11.0"
+  },
+  "peerDependenciesMeta": {
+    "nitropack": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "nitropack": "^2.13.4",
+    "typescript": "^5.4.0"
+  }
+}

package/src/finalize.ts

@@ -0,0 +1,181 @@
+// Turns Nitro's output dir into a Web ABI build: the ops, the manifest, and
+// the cleanup. It runs once, after Nitro has written public/ (and server/).
+import { readFile, rm, stat } from "node:fs/promises";
+import { join, relative, sep } from "node:path";
+
+import { listFiles, writeManifest, writeOps } from "@txco/web-abi/producer";
+
+import { checkImmutable, deriveImmutable, looksHashed, type AssetDir } from "./immutable.js";
+import { renderOps, type Mode, type Page } from "./ops.js";
+import type { ThanksComputerOptions } from "./types.js";
+
+export const NAME = "@txco/nitro-preset";
+export const VERSION = "0.1.0";
+export const PRESET = "thanks-computer";
+export const MANIFEST = "txco-web.json";
+/** The producer band (chassis/webabi ProducerScope). */
+export const PRODUCER_SCOPE = 900000;
+/** An op answer is capped at 4 MiB (--op-payload-max), base64 included. */
+const PAGE_WARN_BYTES = 1 << 20;
+
+/** The part of a Nitro instance finalize reads. A `Nitro` from nitropack 2 is one. */
+export interface FinalizeNitro {
+  options: {
+    static: boolean;
+    baseURL: string;
+    output: { dir: string; publicDir: string; serverDir: string };
+    publicAssets: readonly AssetDir[];
+    routeRules: Record<string, { ssr?: boolean } | undefined>;
+    renderer?: string;
+    framework: { name?: string; version?: string };
+    compressPublicAssets?: unknown;
+    rollupConfig?: { output?: unknown };
+    thanksComputer?: ThanksComputerOptions;
+  };
+  _prerenderedRoutes?: readonly { route: string }[];
+  logger: { info(...args: unknown[]): void; warn(...args: unknown[]): void; success(...args: unknown[]): void };
+}
+
+export interface FinalizeResult {
+  mode: Mode;
+  manifest: Record<string, unknown>;
+  ops: string[];
+  warnings: string[];
+}
+
+const exists = (p: string) => stat(p).then(() => true, () => false);
+const posix = (p: string) => p.split(sep).join("/");
+
+/** Whether the app routes in the browser: the option, or what Nuxt and Analog tell us. */
+export function isSpa(nitro: FinalizeNitro): boolean {
+  const forced = nitro.options.thanksComputer?.spa;
+  if (typeof forced === "boolean") return forced;
+  // Nuxt prerenders /index.html as the shell only for an ssr: false app;
+  // with component islands it turns that into a routeRule instead.
+  if (nitro._prerenderedRoutes?.some((r) => r.route === "/index.html")) return true;
+  if (nitro.options.routeRules?.["/**"]?.ssr === false) return true;
+  // Analog's ssr: false renderer.
+  return typeof nitro.options.renderer === "string" && /CLIENT_RENDERER/.test(nitro.options.renderer);
+}
+
+/**
+ * Writes the build's ops and manifest into Nitro's output dir and removes
+ * what isn't part of a Web ABI build. `server` says whether Nitro built
+ * server/.
+ */
+export async function finalize(nitro: FinalizeNitro, { server }: { server: boolean }): Promise<FinalizeResult> {
+  const o = nitro.options;
+  const { dir, publicDir, serverDir } = o.output;
+  const opts = o.thanksComputer ?? {};
+  const warnings: string[] = [];
+  const warn = (msg: string) => {
+    warnings.push(msg);
+    nitro.logger.warn(`[${PRESET}] ${msg}`);
+  };
+
+  // Nitro's build info: read for the manifest, then dropped (it isn't part
+  // of a Web ABI build, and Nuxt 4's CLI keeps its own).
+  let nitroVersion: string | undefined;
+  try {
+    nitroVersion = JSON.parse(await readFile(join(dir, "nitro.json"), "utf8"))?.versions?.nitro;
+  } catch {}
+  await rm(join(dir, "nitro.json"), { force: true });
+
+  let entry: string | undefined;
+  if (server) {
+    const out = o.rollupConfig?.output as { entryFileNames?: unknown } | undefined;
+    const name = typeof out?.entryFileNames === "string" ? out.entryFileNames : "index.mjs";
+    const file = join(serverDir, name);
+    if (!(await exists(file))) throw new Error(`[${PRESET}] the server build has no entry at ${file}`);
+    entry = posix(relative(dir, file));
+  } else if (await exists(serverDir)) {
+    // No server was built, so server/ holds only build-time leftovers: a
+    // framework can prepare it and then skip the server build, and one that
+    // passes its own output paths into the config (Analog) has the
+    // prerenderer bundle into it.
+    await rm(serverDir, { recursive: true, force: true });
+  }
+
+  const mode: Mode = server ? "server" : isSpa(nitro) ? "spa" : "static";
+  const readPage = async (name: string): Promise<Page | null> => {
+    const html = await readFile(join(publicDir, name), "utf8").catch(() => null);
+    return html === null ? null : { name, html };
+  };
+  const page = mode === "spa" ? ((await readPage("200.html")) ?? (await readPage("index.html"))) : await readPage("404.html");
+  if (mode === "spa" && page === null) {
+    throw new Error(`[${PRESET}] an ssr: false build needs its shell, ${join(publicDir, "200.html")} or index.html, and has neither`);
+  }
+  if (page && Buffer.byteLength(page.html) > PAGE_WARN_BYTES) {
+    warn(`${page.name} is ${Buffer.byteLength(page.html)} bytes; the op that serves it is capped at 4 MiB, base64 included`);
+  }
+
+  const ops = renderOps({ scope: opts.scope ?? PRODUCER_SCOPE, mode, page, producer: NAME });
+  await writeOps(dir, ops);
+
+  // public/ as installed: paths relative to it (they include the app's baseURL).
+  const publicRoot = join(dir, "public");
+  let files = (await exists(publicRoot)) ? await listFiles(publicRoot) : [];
+
+  // What never deploys, taken out rather than shipped: a bundler's .vite/
+  // metadata (vinxi leaves one under _build/), and the .gz/.br copies
+  // compressPublicAssets writes beside a file (nothing serves them; the edge
+  // compresses).
+  const have = new Set(files);
+  const drop = files.filter(
+    (f) =>
+      f.split("/").includes(".vite") ||
+      (Boolean(o.compressPublicAssets) && /\.(gz|br)$/.test(f) && have.has(f.replace(/\.(gz|br)$/, ""))),
+  );
+  for (const f of drop) await rm(join(publicRoot, f), { force: true });
+  for (const d of new Set(files.filter((f) => f.split("/").includes(".vite")).map((f) => f.slice(0, f.indexOf(".vite/") + 5)))) {
+    await rm(join(publicRoot, d), { recursive: true, force: true });
+  }
+  const compressed = drop.filter((f) => /\.(gz|br)$/.test(f)).length;
+  if (compressed > 0) nitro.logger.info(`[${PRESET}] left out ${compressed} precompressed .gz/.br copies (the edge compresses)`);
+  files = files.filter((f) => !drop.includes(f));
+
+  let immutable: string[];
+  if (opts.immutable) {
+    const problems = checkImmutable(opts.immutable);
+    if (problems.length > 0) throw new Error(`[${PRESET}] thanksComputer.immutable: ${problems.join("; ")}`);
+    immutable = [...opts.immutable];
+  } else {
+    immutable = deriveImmutable({ assets: o.publicAssets, appBaseURL: o.baseURL, framework: o.framework.name ?? "" });
+  }
+  for (const prefix of immutable) {
+    const under = files.filter((f) => f.startsWith(prefix));
+    if (under.length === 0) {
+      warn(`the immutable prefix ${prefix} matches no file in public/`);
+      continue;
+    }
+    // Nuxt's builds/latest.json is fetched with a cache-busting query.
+    const unhashed = under.filter((f) => !looksHashed(f.split("/").pop()!) && !/\/builds\/latest\.json$/.test(f));
+    if (unhashed.length > 0) {
+      warn(`${unhashed.length} file(s) under the immutable prefix ${prefix} carry no content hash (${unhashed.slice(0, 3).join(", ")}), so a change to them wouldn't reach a browser for a year`);
+    }
+  }
+
+  const dots = files.filter((f) => f.split("/").some((s) => s.startsWith(".")));
+  if (dots.length > 0) warn(`public/ has ${dots.length} dot path(s) (${dots.slice(0, 3).join(", ")}); they never deploy`);
+
+  const manifest: Record<string, unknown> = {
+    abi: 1,
+    ...(entry ? { server: { entry } } : {}),
+    ...(immutable.length > 0 ? { immutable } : {}),
+    "x-producer": { name: NAME, version: VERSION },
+    "x-nitro": {
+      ...(nitroVersion ? { nitro: nitroVersion } : {}),
+      preset: PRESET,
+      framework: { name: o.framework.name || "nitro", ...(o.framework.version ? { version: o.framework.version } : {}) },
+      mode,
+    },
+  };
+  await writeManifest(dir, manifest);
+
+  nitro.logger.success(`[${PRESET}] Web ABI build (${mode}) at ${dir}: ${files.length} public file(s), ${Object.keys(ops).length} op(s)${entry ? `, server entry ${entry}` : ""}`);
+  nitro.logger.info(
+    `[${PRESET}] Next: \`txco web check ${relative(process.cwd(), dir) || "."}${entry ? " --static-only" : ""}\`, bind it in txco.yaml (stacks: <name>: abi: <dir>), then \`txco apply\`.` +
+      (entry ? " No chassis runs server/ yet: deploy the static half with --static-only." : ""),
+  );
+  return { mode, manifest, ops: Object.keys(ops).sort(), warnings };
+}

package/src/guard.ts

@@ -0,0 +1,38 @@
+// The check that runs before Nitro wipes the output dir. Pure (paths in,
+// problems out), so it's unit-tested; the module reads the dir's entries.
+// The generic checks are the kit's; the layout check is Nitro's.
+import { join, resolve } from "node:path";
+
+import { checkOutDir as checkABIOutDir } from "@txco/web-abi/producer";
+
+export interface OutDirInput {
+  /** `nitro.options.output.dir`. */
+  dir: string;
+  /** `nitro.options.output.publicDir`. */
+  publicDir: string;
+  /** `nitro.options.output.serverDir`. */
+  serverDir: string;
+  /** The app's baseURL ("/" for most apps). */
+  baseURL: string;
+  /** Dirs the wipe must not touch: rootDir, srcDir, buildDir, the public asset sources. */
+  protect: readonly string[];
+  /** The dir's current entries, or null when it doesn't exist. */
+  entries: readonly string[] | null;
+}
+
+/** Every reason the build mustn't write (and so wipe) the output dir. Empty when it may. */
+export function checkOutDir(i: OutDirInput): string[] {
+  const dir = resolve(i.dir);
+  const problems: string[] = [];
+  const base = i.baseURL.replace(/^\/+|\/+$/g, "");
+  const wantPublic = resolve(join(dir, "public", base));
+  const wantServer = resolve(join(dir, "server"));
+  if (resolve(i.publicDir) !== wantPublic || resolve(i.serverDir) !== wantServer) {
+    problems.push(
+      `the output dirs don't follow the Web ABI layout: publicDir is ${resolve(i.publicDir)} (want ${wantPublic}) and serverDir is ${resolve(i.serverDir)} (want ${wantServer}). ` +
+        `If your framework sets its own output paths (Analog does), set nitro.output.dir and nitro.output.publicDir together, or leave all three to the preset.`,
+    );
+  }
+  // Nitro's build info is a previous build's own file.
+  return [...checkABIOutDir({ dir, protect: i.protect, entries: i.entries, allow: ["nitro.json"] }), ...problems];
+}

package/src/immutable.ts

@@ -0,0 +1,73 @@
+// Which public/ prefixes the manifest may call immutable (cached for a year).
+// Pure, so it's unit-tested.
+
+/** One of Nitro's public asset dirs, as `nitro.options.publicAssets` holds it. */
+export interface AssetDir {
+  baseURL?: string;
+  maxAge?: number;
+}
+
+export interface ImmutableInput {
+  assets: readonly AssetDir[];
+  /** The app's baseURL ("/" for most apps). */
+  appBaseURL: string;
+  /** `nitro.options.framework.name` ("nuxt", "analog", "nitro", …). */
+  framework: string;
+}
+
+/** A year: what a framework sets on its content-hashed asset dir. */
+export const YEAR = 31536000;
+
+const trim = (u: string) => u.replace(/^\/+|\/+$/g, "");
+const norm = (u: string | undefined) => "/" + trim(u ?? "/");
+const inside = (inner: string, outer: string) => outer === "/" || inner === outer || inner.startsWith(outer + "/");
+
+/**
+ * The prefixes (relative to public/, ending in "/") whose files the
+ * framework already caches for a year: its content-hashed asset dir, like
+ * Nuxt's `_nuxt/`.
+ *
+ * A candidate is a non-root asset dir with a year's maxAge. It is dropped
+ * when a dir with a shorter maxAge shares or sits inside it, since those files
+ * change between builds. The exception is Nuxt's `<buildAssetsDir>/builds`:
+ * Nuxt fetches its `latest.json` with a cache-busting query. Nested
+ * candidates collapse into the outer one.
+ */
+export function deriveImmutable(input: ImmutableInput): string[] {
+  const dirs = input.assets.map((a) => ({ base: norm(a.baseURL), maxAge: a.maxAge ?? 0 }));
+  const kept = dirs
+    .filter((c) => c.maxAge >= YEAR && c.base !== "/")
+    .filter(
+      (c) =>
+        !dirs.some(
+          (o) =>
+            o.maxAge < YEAR &&
+            o.base !== "/" &&
+            inside(o.base, c.base) &&
+            !(input.framework === "nuxt" && o.base === c.base + "/builds"),
+        ),
+    )
+    .map((c) => c.base);
+  const outer = [...new Set(kept)].filter((b) => !kept.some((o) => o !== b && inside(b, o)));
+  const app = trim(input.appBaseURL);
+  return outer.map((b) => (app ? `${app}/` : "") + `${trim(b)}/`).sort();
+}
+
+/** What's wrong with an explicit `immutable` list, if anything. */
+export function checkImmutable(prefixes: readonly string[]): string[] {
+  const problems: string[] = [];
+  for (const p of prefixes) {
+    const segs = p.split("/").slice(0, -1);
+    if (!p.endsWith("/") || p.startsWith("/") || segs.length === 0) {
+      problems.push(`"${p}": an immutable prefix is a directory relative to public/, ending in "/" (e.g. "assets/")`);
+    } else if (segs.some((s) => s === "" || s.startsWith("."))) {
+      problems.push(`"${p}": no empty or dot segments`);
+    } else if (segs[0] === "_txco") {
+      problems.push(`"${p}": _txco/ is reserved for the installer`);
+    }
+  }
+  return problems;
+}
+
+/** Whether a file name carries a content hash (the kit's heuristic, shared by every producer). */
+export { looksHashed } from "@txco/web-abi/producer";

package/src/module.ts

@@ -0,0 +1,53 @@
+// The preset's Nitro module. Nitro runs modules inside createNitro, before
+// prepare() wipes the output dir, so this is where the guard goes; it also
+// registers the hooks that finish the build.
+import { readdir } from "node:fs/promises";
+
+import type { Nitro } from "nitropack/types";
+
+import { finalize, PRESET, type FinalizeNitro } from "./finalize.js";
+import { checkOutDir } from "./guard.js";
+
+export const thanksComputerModule = {
+  name: PRESET,
+  async setup(nitro: Nitro): Promise<void> {
+    const o = nitro.options;
+    const entries = await readdir(o.output.dir).catch(() => null);
+    const problems = checkOutDir({
+      dir: o.output.dir,
+      publicDir: o.output.publicDir,
+      serverDir: o.output.serverDir,
+      baseURL: o.baseURL,
+      protect: [o.rootDir, o.srcDir, o.buildDir, ...o.publicAssets.map((a) => a.dir)],
+      entries,
+    });
+    if (problems.length > 0) throw new Error(`[${PRESET}] ${problems.join("\n")}`);
+
+    // A static build (nuxi generate) crawls from the home page, as Nitro's
+    // `static` preset does: Nuxt seeds "/" only when crawlLinks is on, and
+    // reads it in nitro:init, after this module. An explicit setting stands.
+    const asked = (o._config as { prerender?: { crawlLinks?: boolean } } | undefined)?.prerender?.crawlLinks;
+    if (o.static && asked === undefined) o.prerender.crawlLinks = true;
+
+    // Hooks registered here, not in the preset's `hooks`: the config merge
+    // lets a user's own `hooks.compiled` replace a preset's.
+    let finalized = false;
+    let prerendered = false;
+    const run = async (server: boolean) => {
+      finalized = true;
+      await finalize(nitro as unknown as FinalizeNitro, { server });
+    };
+    nitro.hooks.hook("prerender:done", ({ failedRoutes }) => {
+      prerendered = !(o.prerender.failOnError && failedRoutes.length > 0);
+    });
+    nitro.hooks.hook("compiled", async () => {
+      if (!finalized) await run(!o.static);
+    });
+    // A framework that prerenders and never calls build() (Analog's static
+    // build) never fires `compiled`; it always closes. Without a finished
+    // prerender (nuxi prepare, a failed build) there is nothing to finish.
+    nitro.hooks.hook("close", async () => {
+      if (!finalized && prerendered) await run(false);
+    });
+  },
+};

package/src/ops.ts

@@ -0,0 +1,57 @@
+// The ops this preset writes into a Web ABI build's ops/. Pure: no filesystem
+// and no Nitro runtime, so the output is golden-tested. The rules come from
+// @txco/web-abi/producer, which every producer shares; this file maps the
+// preset's build modes onto them.
+import { BUILTIN_404, catchAllScope, NAV_GUARD, renderOps as renderABIOps, type Page } from "@txco/web-abi/producer";
+
+export { BUILTIN_404, catchAllScope, NAV_GUARD, type Page };
+
+/**
+ * How the build answers a page navigation nothing else answered:
+ *
+ *  - "static": every page was prerendered into public/, so a path that
+ *    reaches the ops has no page: 404, with the 404 page;
+ *  - "spa": an `ssr: false` app routes in the browser: 200, with the shell;
+ *  - "server": the build has a server (server/). No chassis runs one yet, so
+ *    a --static-only install answers like "static".
+ */
+export type Mode = "static" | "spa" | "server";
+
+export interface RenderOptions {
+  /** The producer band's scope for the navigation op (900000). */
+  scope: number;
+  mode: Mode;
+  /**
+   * The page the navigation op serves: 404.html (static, server) or the
+   * shell (spa). null in static or server mode writes a small built-in 404
+   * page instead. spa mode needs one.
+   */
+  page: Page | null;
+  /** The generated-file header's producer name. */
+  producer: string;
+}
+
+const NOTES: Record<Mode, string[]> = {
+  spa: ["An ssr: false app: the client router renders every page."],
+  static: ["A client route that wasn't prerendered still renders: Nuxt's 404.html", "is its app shell."],
+  server: [
+    "This build has a server (server/), and no chassis runs one yet: a",
+    "--static-only install serves its prerendered pages, and every other page",
+    "navigation ends here. A dispatch op replaces this one once a runner exists.",
+  ],
+};
+
+/**
+ * Renders the build's ops, as path (relative to ops/) → file text: one
+ * navigation op for the mode, and the catch-all, a plain 404 for every other
+ * HTTP request, so every request reaching the end of the stack is answered.
+ */
+export function renderOps(opts: RenderOptions): Record<string, string> {
+  return renderABIOps({
+    scope: opts.scope,
+    producer: opts.producer,
+    mode: opts.mode === "spa" ? "spa" : "404",
+    page: opts.page,
+    notes: NOTES[opts.mode],
+  });
+}

package/src/preset.ts

@@ -0,0 +1,44 @@
+// @txco/nitro-preset: the `thanks-computer` Nitro preset. It builds a Nitro
+// app (Nuxt, Analog) as a Web ABI build for `txco apply` to install:
+//
+//   txco-web/
+//     txco-web.json   the manifest
+//     public/         the site: Nitro's public output, prerendered pages included
+//     ops/            the navigation op and the catch-all
+//     server/         the app's server as a Fetch handler (`nuxi build` only)
+//
+//   // nuxt.config.ts
+//   export default defineNuxtConfig({ nitro: { preset: "@txco/nitro-preset" } })
+//
+// Written in Nitro's in-tree preset shape, so it can move upstream. It
+// doesn't import nitropack at runtime: a Nuxt app doesn't depend on it
+// directly, and a strict package manager won't resolve it from here.
+import { fileURLToPath } from "node:url";
+
+import { PRESET } from "./finalize.js";
+import { thanksComputerModule } from "./module.js";
+
+export type { ThanksComputerOptions } from "./types.js";
+
+const preset = {
+  entry: fileURLToPath(new URL("./runtime/entry.js", import.meta.url)),
+  // Node built-ins stay native; every dependency is bundled into server/,
+  // which deploys without an install step.
+  node: true,
+  noExternals: true,
+  // The chassis serves public/ before the app's stack runs.
+  serveStatic: false,
+  output: {
+    dir: "{{ rootDir }}/txco-web",
+    serverDir: "{{ output.dir }}/server",
+    publicDir: "{{ output.dir }}/public/{{ baseURL }}",
+  },
+  commands: {
+    deploy: "txco apply",
+  },
+  modules: [thanksComputerModule],
+  // What defineNitroPreset (nitropack/kit) adds, inlined.
+  _meta: { name: PRESET, url: import.meta.url },
+};
+
+export default preset;