@rsc-kit/core 0.7.1 → 0.8.0

package/dist/safeUrl.d.ts

@@ -7,4 +7,3 @@ export declare function isSafeRedirect(value: string): boolean;
  * not name the value leaves nothing to go on.
  */
 export declare function assertSafeRedirect(value: string): void;
-//# sourceMappingURL=safeUrl.d.ts.map

package/dist/safeUrl.js.map

@@ -1 +1 @@
-{"version":3,"file":"safeUrl.js","sourceRoot":"","sources":["../src/safeUrl.ts"],"names":[],"mappings":"AAAA,uEAAuE;AACvE,EAAE;AACF,6EAA6E;AAC7E,+EAA+E;AAC/E,+EAA+E;AAC/E,2EAA2E;AAC3E,EAAE;AACF,4EAA4E;AAC5E,4EAA4E;AAC5E,6EAA6E;AAC7E,2EAA2E;AAE3E,kFAAkF;AAClF,MAAM,OAAO,GAAG,0BAA0B,CAAA;AAE1C,MAAM,UAAU,cAAc,CAAC,KAAa;IAC1C,IAAI,CAAC;QACH,MAAM,EAAE,QAAQ,EAAE,GAAG,IAAI,GAAG,CAAC,KAAK,EAAE,OAAO,CAAC,CAAA;QAE5C,wEAAwE;QACxE,2EAA2E;QAC3E,oDAAoD;QACpD,OAAO,QAAQ,KAAK,OAAO,IAAI,QAAQ,KAAK,QAAQ,CAAA;IACtD,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,KAAK,CAAA;IACd,CAAC;AACH,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,kBAAkB,CAAC,KAAa;IAC9C,IAAI,cAAc,CAAC,KAAK,CAAC;QAAE,OAAM;IAEjC,MAAM,IAAI,KAAK,CACb,kCAAkC,GAAG,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,IAAI;QAC/D,yEAAyE;QACzE,wEAAwE,CAC3E,CAAA;AACH,CAAC"}
+{"version":3,"file":"safeUrl.js","sourceRoot":"","sources":["../src/safeUrl.ts"],"names":[],"mappings":"AAAA,uEAAuE;AACvE,EAAE;AACF,6EAA6E;AAC7E,+EAA+E;AAC/E,+EAA+E;AAC/E,2EAA2E;AAC3E,EAAE;AACF,4EAA4E;AAC5E,4EAA4E;AAC5E,6EAA6E;AAC7E,2EAA2E;AAE3E,kFAAkF;AAClF,MAAM,OAAO,GAAG,0BAA0B,CAAA;AAE1C,MAAM,UAAU,cAAc,CAAC,KAAa;IAC1C,IAAI,CAAC;QACH,MAAM,EAAE,QAAQ,EAAE,GAAG,IAAI,GAAG,CAAC,KAAK,EAAE,OAAO,CAAC,CAAA;QAE5C,wEAAwE;QACxE,2EAA2E;QAC3E,oDAAoD;QACpD,OAAO,QAAQ,KAAK,OAAO,IAAI,QAAQ,KAAK,QAAQ,CAAA;IACtD,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,KAAK,CAAA;IACd,CAAC;AACH,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,kBAAkB,CAAC,KAAa;IAC9C,IAAI,cAAc,CAAC,KAAK,CAAC;QAAE,OAAM;IAEjC,MAAM,IAAI,KAAK,CACb,kCAAkC,GAAG,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,IAAI;QAC/D,yEAAyE;QACzE,wEAAwE,CAC3E,CAAA;AACH,CAAC","sourcesContent":["// Whether a redirect destination is a url a browser should be sent to.\n//\n// A destination is routinely computed rather than written — redirect()'s own\n// documentation describes reading one from a cookie as the usual case — and it\n// reaches location.href, location.replace and an inline script. A scheme other\n// than http(s) in any of those is script execution rather than navigation.\n//\n// Parsed rather than pattern-matched. javascript: can be written with mixed\n// case, with a newline inside it, or behind leading control characters, and\n// each of those is a different regex to get wrong. The URL parser normalises\n// all of it already, so asking it for the protocol is shorter and correct.\n\n/** A base that cannot collide with a real origin, for resolving relative urls. */\nconst NOWHERE = 'https://rsc-kit.invalid/'\n\nexport function isSafeRedirect(value: string): boolean {\n  try {\n    const { protocol } = new URL(value, NOWHERE)\n\n    // http and https only. Not data:, not blob:, not javascript:, and not a\n    // custom app scheme — a browser handing one of those to another program is\n    // not something a render should be able to trigger.\n    return protocol === 'http:' || protocol === 'https:'\n  } catch {\n    return false\n  }\n}\n\n/**\n * The same check, as a refusal.\n *\n * Says the value back, deliberately. A destination that fails this is far more\n * often a bug in what the app computed than an attack, and a message that does\n * not name the value leaves nothing to go on.\n */\nexport function assertSafeRedirect(value: string): void {\n  if (isSafeRedirect(value)) return\n\n  throw new Error(\n    'Not a url a redirect may go to: ' + JSON.stringify(value) + '. ' +\n      'A destination has to be a path or an http(s) url — any other scheme is ' +\n      'handed to the browser as something to run rather than somewhere to go.',\n  )\n}\n"]}

package/dist/vite.d.ts

@@ -4,6 +4,30 @@ export interface RscKitOptions {
     projectRoot?: string;
     /** Directory holding the app/ route tree. Defaults to `src`. */
     sourceDir?: string;
+    /**
+     * Animate navigations with React's `<ViewTransition>`.
+     *
+     * Off by default and a build-time constant rather than a runtime setting, so
+     * an app that does not ask for it does not carry the boundary at all.
+     *
+     * Needs react and react-dom at 19.3 or newer, where ViewTransition is
+     * stable. What it animates is the segment a navigation replaces; what a page
+     * does inside itself is the app's own business and needs no flag.
+     */
+    viewTransitions?: boolean;
+    /**
+     * Serve the app from a service worker, so it survives a reload with no
+     * network at all.
+     *
+     * Everything else this engine keeps — held pages, the prefetch cache — lives
+     * in one page's memory. Reload with no network and the browser shows its own
+     * error page: no script runs, so nothing cached in JavaScript is reachable.
+     * A worker is the only thing on the other side of that line.
+     *
+     * Off by default. It changes what a visitor sees when your deploy is broken,
+     * which is not a decision to make for someone.
+     */
+    offline?: boolean;
     /** Where the server bundles and generated entries go. Defaults to `.rsc`. */
     outDir?: string;
     /**
@@ -144,5 +168,25 @@ export interface RscKitOptions {
      */
     prerender?: boolean;
 }
+/**
+ * The service worker, written into the client output at build time.
+ *
+ * Scoped to the site root because it is served from there, so it sees every
+ * navigation. Three kinds of request, three answers:
+ *
+ * Hashed assets are immutable by construction — the name changes when the
+ * bytes do — so they are answered from the cache and only fetched once ever.
+ *
+ * Documents and payloads go to the network first and fall back to the cache,
+ * because a page whose data moved on should say so while there is a network to
+ * ask. Only the fallback is what makes a reload work with none.
+ *
+ * A document and its payload share a url and differ by header. They do not
+ * collide, because the server sends `Vary: X-RSC, ...` and the Cache API
+ * honours it when a Response is stored whole and matched with its Request.
+ *
+ * Nothing else is touched. An action is a POST and must never be answered from
+ * a cache; anything cross-origin is somebody else's to cache.
+ */
+export declare const SERVICE_WORKER: (version: string, precache: string[]) => string;
 export declare function rscKit(options?: RscKitOptions): PluginOption[];
-//# sourceMappingURL=vite.d.ts.map

package/dist/vite.js

@@ -13,6 +13,7 @@
 // the structural config (entries, output dirs, base). @vitejs/plugin-rsc is
 // included here so it always runs before any react() layer the app adds.
 import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { createHash } from 'node:crypto';
 import { createRequire } from 'node:module';
 import { dirname, join, relative, resolve } from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
@@ -27,6 +28,8 @@ let outDir;
 let appDir;
 let genDir;
 let publicAssetsDir;
+/** Where generated ambient declarations go — `.rsc-kit` at the project root. */
+let typesDir;
 let hotFile;
 let hostCallOptions;
 let packageDir;
@@ -50,6 +53,10 @@ let routeConfig;
 let prerenderAfterBuild;
 /** True during `vite build --watch`, where re-rendering every route is noise. */
 let isWatch = false;
+/** Whether navigations are wrapped in React's ViewTransition — see options. */
+let viewTransitions = false;
+/** Whether a service worker is generated and registered — see options. */
+let offline = false;
 /** Host functions to generate stubs for — see RscKitOptions.hostActions. */
 let hostActions;
 /**
@@ -168,6 +175,7 @@ function resolvePaths(options) {
     // Vite's own default. Nitro overrides it with .output/public, which is why
     // there is nothing here to configure.
     publicAssetsDir = resolve(join(projectRoot, 'dist/client'));
+    typesDir = join(projectRoot, '.rsc-kit');
     hotFile = options.hotFile || process.env.RSC_HOT_FILE || '';
     hostCallOptions = options.hostCall;
     packageDir = resolve(options.packageDir || process.env.RSC_PACKAGE_DIR || thisDir());
@@ -190,6 +198,8 @@ function resolvePaths(options) {
     // A host driving the build out of process cannot pass an option, and may
     // prerender itself afterwards with paths only it knows.
     prerenderAfterBuild = options.prerender ?? process.env.RSC_PRERENDER !== '0';
+    viewTransitions = options.viewTransitions === true;
+    offline = options.offline === true;
     hostActions = options.hostActions ?? fileHostActions(projectRoot);
 }
 function log(...args) {
@@ -378,14 +388,57 @@ function routeManifest() {
         intercepts,
     };
 }
+/**
+ * Say so when the typechecker cannot see the declarations just written.
+ *
+ * Moving them out of the source directory buys a tidy `src/` and costs this:
+ * `include` used to cover them by accident, and now it has to name `.rsc-kit`.
+ * A project that does not is not broken in any way it can notice — every file
+ * is written, every build passes, and `Link` quietly takes `string` again
+ * instead of the route union, so a link to a page that does not exist compiles
+ * and 404s in the browser.
+ *
+ * A guess, deliberately, and only ever a warning: `include` is one of several
+ * ways a tsconfig can reach a file, `extends` can supply it, and a project
+ * with no tsconfig at all is not doing this checking anyway. Wrong here costs
+ * a line of output; silent costs the types.
+ */
+function warnIfTypesUnreachable() {
+    const config = join(projectRoot, 'tsconfig.json');
+    if (!existsSync(config))
+        return;
+    try {
+        // Comments are legal in a tsconfig and JSON.parse does not take them.
+        const text = readFileSync(config, 'utf-8').replace(/\/\*[\s\S]*?\*\/|(^|\s)\/\/.*$/gm, '$1');
+        const include = JSON.parse(text).include;
+        if (!Array.isArray(include))
+            return;
+        if (include.some((entry) => typeof entry === 'string' && entry.includes('.rsc-kit')))
+            return;
+        log(`tsconfig.json does not include .rsc-kit, where the generated types are written.\n` +
+            `  Add ".rsc-kit/**/*" to "include", or typed routes and rpc() fall back to string.`);
+    }
+    catch {
+        // An unparseable tsconfig is the project's own problem, not this one's.
+    }
+}
 // ── What the app imports ─────────────────────────────────────────────────────
 /**
  * Write the modules the app's source imports but nobody writes by hand.
  *
- * All three land in the source directory because that is where the app's own
- * imports and its typechecker can reach them: the stubs are imported by
- * relative path, and an ambient declaration is only ambient if it is inside
- * the project. The build owns that path, which is why it owns this.
+ * Two destinations, and the difference is whether anything imports the file.
+ *
+ * The stubs are imported by relative path, so they have to sit in the source
+ * directory — that path is the app's, and only the build knows it.
+ *
+ * The declarations are not imported by anything. They are ambient, which needs
+ * them inside the project and nothing more, so they go in `.rsc-kit/` at the
+ * root: four generated files in `src/` sat among the app's own and had to be
+ * gitignored one by one, and every one of them was noise beside the pages.
+ *
+ * Ambient still means the typechecker has to be told the directory exists —
+ * see the warning below, because a tsconfig that does not include it turns
+ * every one of these into a file nobody reads.
  *
  * Rewritten on every run. The failure they prevent is invisible at build
  * time — a stale stub calls a global that has since been renamed, and only
@@ -393,26 +446,28 @@ function routeManifest() {
  */
 function writeHostBindings(manifest) {
     mkdirSync(sourceDir, { recursive: true });
+    mkdirSync(typesDir, { recursive: true });
     // The global is installed at runtime, so nothing in app source declares it
     // and a typecheck cannot see it. Written whether or not there are actions:
     // server components call it directly too.
-    writeFileSync(join(sourceDir, 'rsc-env.d.ts'), renderHostGlobalTypes());
+    writeFileSync(join(typesDir, 'rsc-env.d.ts'), renderHostGlobalTypes());
     // The engine's own ambient types, copied where the app's typechecker will
     // see them. Deliberately a separate file from the one above: this one is
     // the engine's and identical everywhere, that one is generated from how
     // this host is configured.
     // The urls this build found, so a link to a page that does not exist fails
     // the typecheck instead of the browser.
-    writeFileSync(join(sourceDir, 'rsc-routes.d.ts'), renderRouteTypes(manifest));
+    writeFileSync(join(typesDir, 'rsc-routes.d.ts'), renderRouteTypes(manifest));
     // The bundle the host imports is generated, so nothing declares it. Written
     // here rather than left to the app: every app needs the identical file, and
     // an app-authored one goes stale — the first version named only RscEngine,
     // which typechecks a server and fails a prerender script.
-    writeFileSync(join(sourceDir, 'rsc-engine.d.ts'), ENGINE_TYPES);
+    writeFileSync(join(typesDir, 'rsc-engine.d.ts'), ENGINE_TYPES);
     const engineTypes = join(packageDir, 'types.d.ts');
     if (existsSync(engineTypes)) {
-        writeFileSync(join(sourceDir, 'rsc-types.d.ts'), readFileSync(engineTypes, 'utf-8'));
+        writeFileSync(join(typesDir, 'rsc-types.d.ts'), readFileSync(engineTypes, 'utf-8'));
     }
+    warnIfTypesUnreachable();
     const target = join(sourceDir, 'server-actions.generated.ts');
     // A host with no functions of its own leaves no file behind: kept, its
     // stubs would go on naming targets the host has stopped answering for.
@@ -471,6 +526,200 @@ function reportAllDynamic() {
 
   ${routes.length} dynamic — prerendering is off`);
 }
+/**
+ * The service worker, written into the client output at build time.
+ *
+ * Scoped to the site root because it is served from there, so it sees every
+ * navigation. Three kinds of request, three answers:
+ *
+ * Hashed assets are immutable by construction — the name changes when the
+ * bytes do — so they are answered from the cache and only fetched once ever.
+ *
+ * Documents and payloads go to the network first and fall back to the cache,
+ * because a page whose data moved on should say so while there is a network to
+ * ask. Only the fallback is what makes a reload work with none.
+ *
+ * A document and its payload share a url and differ by header. They do not
+ * collide, because the server sends `Vary: X-RSC, ...` and the Cache API
+ * honours it when a Response is stored whole and matched with its Request.
+ *
+ * Nothing else is touched. An action is a POST and must never be answered from
+ * a cache; anything cross-origin is somebody else's to cache.
+ */
+export const SERVICE_WORKER = (version, precache) => `// GENERATED by rscKit() — do not edit.
+const VERSION = ${JSON.stringify(version)}
+const CACHE = 'rsc-kit-' + VERSION
+const PRECACHE = ${JSON.stringify(precache, null, 2)}
+
+self.addEventListener('install', (event) => {
+  // The new worker takes over rather than waiting for every tab to close.
+  // Safe here because assets are content-hashed: a page already open keeps
+  // asking for the names it was built with, and those are still cached under
+  // their own version until this activates and sweeps.
+  event.waitUntil(caches.open(CACHE).then((cache) => cache.addAll(PRECACHE)).then(() => self.skipWaiting()))
+})
+
+self.addEventListener('activate', (event) => {
+  event.waitUntil(
+    caches
+      .keys()
+      .then((keys) => Promise.all(keys.filter((k) => k.startsWith('rsc-kit-') && k !== CACHE).map((k) => caches.delete(k))))
+      .then(() => self.clients.claim()),
+  )
+})
+
+const immutable = (url) => url.pathname.startsWith('/assets/') || /-[A-Za-z0-9_-]{8,}\\.[a-z]+$/.test(url.pathname)
+
+// Whether a response may be kept at all.
+//
+// \`no-store\` is not advice here, it is the answer. A query defaults to
+// \`private, no-store\` precisely because it may read the session, and a worker
+// that files it by url alone would serve one visitor's answer to whoever signs
+// in next — the Cache API has no notion of who asked. A live response is worse
+// again: the clone goes on streaming long after the page that opened it is
+// gone.
+//
+// Checked before every put, rather than only for the paths that happen to reach
+// a query today. A new cacheable route added later must not have to remember
+// this.
+const mayStore = (response) =>
+  response.ok && !(response.headers.get('Cache-Control') || '').includes('no-store')
+
+// What a response is filed under. A payload request carries headers the url
+// does not, so the url is where they have to go.
+const keyFor = (request) => {
+  if (!request.headers.get('X-RSC')) return request
+
+  const url = new URL(request.url)
+  url.searchParams.set('__rsc', request.headers.get('X-RSC-Segments') || '')
+
+  return new Request(url, { headers: request.headers })
+}
+
+self.addEventListener('fetch', (event) => {
+  const request = event.request
+  const url = new URL(request.url)
+
+  if (request.method !== 'GET' || url.origin !== self.location.origin) return
+
+  if (immutable(url)) {
+    event.respondWith(
+      caches.match(request).then(
+        (hit) =>
+          hit ??
+          fetch(request).then((response) => {
+            if (mayStore(response)) {
+              const copy = response.clone()
+              caches.open(CACHE).then((cache) => cache.put(request, copy))
+            }
+
+            return response
+          }),
+      ),
+    )
+
+    return
+  }
+
+  event.respondWith(
+    fetch(request)
+      .then((response) => {
+        if (mayStore(response)) {
+          const copy = response.clone()
+          caches.open(CACHE).then((cache) => cache.put(keyFor(request), copy))
+
+          // A document is not enough to boot from. The client hydrates from a
+          // payload it fetches for itself, and on a first visit that request
+          // happens before this worker controls the page — so it is never
+          // cached, and a reload with no network has the markup and nothing to
+          // hydrate it with.
+          //
+          // \`X-RSC: true\` and no segments header is exactly what a fresh boot
+          // sends, which is what makes this entry the one it finds: the server
+          // varies on those, and the Cache API matches on the same.
+          if (request.mode === 'navigate') {
+            const warm = new Request(request.url, { headers: { 'X-RSC': 'true' } })
+
+            fetch(warm)
+              .then((payload) => {
+                if (mayStore(payload)) {
+                  caches.open(CACHE).then((cache) => cache.put(keyFor(warm), payload))
+                }
+              })
+              .catch(() => {})
+          }
+
+          // And the other way round. Moving between pages fetches payloads and
+          // never documents, so a page reached only by a link had nothing to
+          // serve when someone reloaded its url — it navigated fine and then
+          // died on refresh, which is the half of offline nobody would trust.
+          //
+          // Once per url: the document is fetched only when the cache has none,
+          // so this costs one extra request the first time a page is visited
+          // rather than one on every navigation to it.
+          if (request.headers.get('X-RSC')) {
+            const document = new Request(request.url)
+
+            caches.open(CACHE).then(async (cache) => {
+              if (await cache.match(document)) return
+
+              const fresh = await fetch(document).catch(() => null)
+
+              if (fresh && mayStore(fresh)) await cache.put(document, fresh)
+            })
+          }
+        }
+
+        return response
+      })
+      .catch(async () => {
+        const hit = await caches.match(keyFor(request))
+
+        if (hit) return hit
+
+        // Nothing cached for this url and no network to ask. Falling back to
+        // the cached root was worse than failing: the document IS the page
+        // here, so the visitor got the home page's markup under the address
+        // they asked for, and it did not hydrate — a wrong page pretending to
+        // be the right one. Letting it fail says what is true, and a page
+        // already open is unaffected.
+        return Response.error()
+      }),
+  )
+})
+`;
+/**
+ * Write the worker beside the assets it caches.
+ *
+ * The version is a hash of what is being precached rather than a build id from
+ * the environment. The names are content-hashed already, so a build that
+ * changed nothing produces the same list and leaves the visitor's cache alone,
+ * and a build that changed anything produces a different one — which is the
+ * whole of cache invalidation, without asking anyone to set a variable.
+ */
+function writeServiceWorker(clientDir) {
+    if (!existsSync(clientDir))
+        return;
+    const files = [];
+    const walk = (dir, prefix) => {
+        for (const entry of readdirSync(dir, { withFileTypes: true })) {
+            // Not itself, and not a map: a debugger asks for those, a visitor does
+            // not, and precaching them doubles what an install costs.
+            if (entry.name === 'sw.js' || entry.name.endsWith('.map'))
+                continue;
+            const path = join(dir, entry.name);
+            if (entry.isDirectory())
+                walk(path, `${prefix}${entry.name}/`);
+            else
+                files.push(`${prefix}${entry.name}`);
+        }
+    };
+    walk(clientDir, '');
+    const precache = ['/', ...files.map((file) => `/${file}`)].sort();
+    const version = createHash('sha256').update(precache.join('\n')).digest('hex').slice(0, 12);
+    writeFileSync(join(clientDir, 'sw.js'), SERVICE_WORKER(version, precache));
+    log(`offline: ${precache.length} files precached as rsc-kit-${version}`);
+}
 /**
  * The rsc bundle the build just wrote, whatever it decided to call it.
  *
@@ -942,6 +1191,7 @@ import { createRscHandler } from ${JSON.stringify(join(packageDir, "host"))}
 import { httpHostCalls } from ${JSON.stringify(join(packageDir, 'hostCalls'))}
 import { prerenderedBeside } from ${JSON.stringify(join(packageDir, 'files'))}
 import { renderToReadableStream, decodeReply, loadServerAction } from '@vitejs/plugin-rsc/rsc'
+import { isQuery, queryCacheControl } from ${JSON.stringify(join(packageDir, 'query'))}
 import { Suspense, createElement, Fragment } from 'react'
 import { AsyncLocalStorage } from 'node:async_hooks'
 ${imports.join('\n')}
@@ -1629,6 +1879,44 @@ async function renderRevalidated(target: string, page: PageContext): Promise<unk
   })
 }
 
+/**
+ * Answer one read.
+ *
+ * Only functions declared with query() are reachable. The id comes off the url,
+ * and every registered server action has one — without the mark, this address
+ * would invoke mutations over GET, for anyone who can fetch it.
+ */
+export async function handleQuery(
+  id: string,
+  args: string,
+  report?: (error: unknown) => string,
+): Promise<{ stream: ReadableStream; cacheControl: string } | null> {
+  applyHost()
+
+  let fn: unknown
+
+  try {
+    fn = await loadServerAction(id)
+  } catch {
+    return null
+  }
+
+  // Null for both, deliberately. Saying "that exists but is not a query" tells
+  // whoever is probing this endpoint which ids are real actions, and the ids
+  // are stable across a build.
+  if (!isQuery(fn)) return null
+
+  const decoded = (await decodeReply(args)) as unknown[]
+  const result = await (fn as (...a: unknown[]) => unknown)(...decoded)
+
+  return {
+    stream: renderToReadableStream(result, {
+      onError: (error: unknown) => (report ? report(error) : 'Query failed.'),
+    }),
+    cacheControl: queryCacheControl(fn),
+  }
+}
+
 export async function handleAction(
   actionId: string,
   body: string | FormData | Uint8Array,
@@ -1675,6 +1963,19 @@ export async function handleAction(
 
   const args = (await decodeReply(decodable)) as unknown[]
   const action = await loadServerAction(actionId)
+
+  // A query reached the ACTION endpoint, which means it was called directly
+  // rather than through fetchQuery — so it went out as a POST and none of the
+  // reasons it was marked a read apply to it. It still works, which is the
+  // problem: nothing else would ever mention it. Only in development, and only
+  // a warning, because the call is not wrong, just not what was asked for.
+  if (isQuery(action) && import.meta.env?.DEV) {
+    console.warn(
+      '[rsc-kit] ' + actionId + ' is a query but was called directly, so it was sent as a POST. ' +
+        'Call it through fetchQuery() to send a GET.',
+    )
+  }
+
   const result = await (action as (...a: unknown[]) => unknown)(...args)
 
   // Read after the action has run: what it invalidated is only known once its
@@ -2080,6 +2381,7 @@ export default async function handler(request: Request): Promise<Response> {
       handleRscPprShell,
       handleRscResume,
       handleAction,
+      handleQuery,
       resolveMetadata,
       runRouteMiddleware,
     } as never,
@@ -2254,7 +2556,25 @@ if (import.meta.hot) {
     void refresh('all')
   })
 }
-`;
+${offline
+        ? `
+// Registered after load rather than during it, so fetching and installing the
+// worker competes with nothing the first visit actually needs. The second
+// visit is the one it is for.
+//
+// Not in development: the dev server is the thing you are editing, and a
+// worker answering from a cache in front of it turns every edit into a
+// question about which copy you are looking at.
+if ('serviceWorker' in navigator && import.meta.env.PROD) {
+  window.addEventListener('load', () => {
+    void navigator.serviceWorker.register('/sw.js').catch(() => {
+      // A worker that will not register is not a reason for the page to fail.
+      // The app works; it just will not survive being reloaded offline.
+    })
+  })
+}
+`
+        : ''}`;
 }
 /**
  * Intercepted URL patterns, published by the host before the build.
@@ -2384,7 +2704,23 @@ export function rscKit(options = {}) {
             }
             components.clear();
             discover(appDir);
-            log(`Discovered ${components.size} route components:`, [...components.keys()].join(', '));
+            // Silent when it worked. The names were printed on every dev start and
+            // every build — thirty of them for a middling app, above the output that
+            // actually says something, and the build's classification table lists
+            // every route anyway.
+            //
+            // Nothing found is the case worth a word, because the app still builds:
+            // a server with no routes answers 404 to everything, which reads as a
+            // routing bug rather than as an empty directory. Fatal for a build,
+            // said out loud for a dev server — where deleting the last page while
+            // editing is a state to pass through, not to be thrown out of.
+            if (components.size === 0) {
+                const message = `No routes under ${appDir}. A directory with a page.tsx in it is a route; ` +
+                    'without one there is nothing to serve.';
+                if (env.command === 'build')
+                    throw new Error(`[rsc-kit] ${message}`);
+                log(message);
+            }
             const loadingErrors = validateLoadingBoundaries();
             if (loadingErrors.length) {
                 throw new Error('[rsc-kit] A page that blocks before it can paint needs a loading.tsx boundary.\n\n' +
@@ -2446,6 +2782,10 @@ export function rscKit(options = {}) {
                  */
                 define: {
                     'process.env.NODE_ENV': JSON.stringify(env.mode === 'development' ? 'development' : 'production'),
+                    // A constant, so the boundary and its import fall out of the bundle
+                    // entirely when this is off rather than shipping a branch nobody takes.
+                    __RSC_VIEW_TRANSITIONS__: JSON.stringify(viewTransitions),
+                    __RSC_OFFLINE__: JSON.stringify(offline),
                 },
                 /*
                  * This package's client modules are served as source, never
@@ -2666,6 +3006,8 @@ export function rscKit(options = {}) {
                 ? join(dirname(clientOut), 'server', NITRO_STATIC_DIR)
                 : join(outDir, NITRO_STATIC_DIR);
             await prerenderAfterBundles(bundle, staticDir, clientOut ?? publicAssetsDir);
+            if (offline)
+                writeServiceWorker(clientOut ?? publicAssetsDir);
         },
         configResolved(config) {
             isWatch = config.build?.watch != null;