@rsc-kit/core 0.30.21 → 0.30.23

package/dist/served.js

@@ -0,0 +1,80 @@
+/**
+ * Run the handler and call onRequest once the response it answers is over.
+ *
+ * The body is passed through rather than read, so streaming is untouched: each
+ * chunk goes out as it is produced. onRequest is never awaited and a throw
+ * from it is reported, not raised - a logger that fails must not fail the page.
+ */
+export async function observeServed(request, serve, onRequest, headerNames = []) {
+    const started = performance.now();
+    let reported = false;
+    const report = (status, aborted, error) => {
+        if (reported)
+            return;
+        reported = true;
+        const served = {
+            method: request.method,
+            pathname: new URL(request.url).pathname,
+            status,
+            durationMs: performance.now() - started,
+            aborted,
+            headers: pickHeaders(request.headers, headerNames),
+            ...(error === undefined ? {} : { error }),
+        };
+        try {
+            Promise.resolve(onRequest(served)).catch(failed);
+        }
+        catch (thrown) {
+            failed(thrown);
+        }
+    };
+    let response;
+    try {
+        response = await serve(request);
+    }
+    catch (error) {
+        report(500, false, error);
+        throw error;
+    }
+    if (!response.body) {
+        report(response.status, false);
+        return response;
+    }
+    const reader = response.body.getReader();
+    const body = new ReadableStream({
+        async pull(controller) {
+            try {
+                const { done, value } = await reader.read();
+                if (done) {
+                    controller.close();
+                    report(response.status, false);
+                }
+                else {
+                    controller.enqueue(value);
+                }
+            }
+            catch (error) {
+                controller.error(error);
+                report(response.status, false, error);
+            }
+        },
+        cancel(reason) {
+            report(response.status, true);
+            return reader.cancel(reason);
+        },
+    });
+    return new Response(body, { status: response.status, statusText: response.statusText, headers: response.headers });
+}
+function pickHeaders(headers, names) {
+    const picked = {};
+    for (const name of names) {
+        const value = headers.get(name);
+        if (value !== null)
+            picked[name.toLowerCase()] = value;
+    }
+    return Object.freeze(picked);
+}
+function failed(error) {
+    console.error("[rsc-kit] instrumentation.ts onRequest() failed:", error);
+}
+//# sourceMappingURL=served.js.map

package/dist/served.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"served.js","sourceRoot":"","sources":["../src/served.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * What instrumentation.ts's onRequest() is told, once a response is over.\n *\n * \"Over\" is the part an app cannot see for itself: a page streams, so the\n * handler has long returned when the last byte leaves, and a visitor who\n * closes the tab mid-stream ends it early. Only the engine holds the body, so\n * only the engine can say which happened, and when.\n */\nexport interface ServedRequest {\n  method: string;\n  /** The url's path, never its query string: a query carries what people typed. */\n  pathname: string;\n  status: number;\n  /** From the request arriving to the last byte sent, or to the stream ending early. */\n  durationMs: number;\n  /** The client went away before the body was sent - a closed tab, a navigation elsewhere. */\n  aborted: boolean;\n  /** The render failed: the handler threw, or the body errored partway. */\n  error?: unknown;\n  /**\n   * Only the headers instrumentation.ts names in `onRequestHeaders`, by\n   * lowercase name, and only those the request had. Nothing else is passed:\n   * not cookies, not authorization.\n   */\n  headers: Readonly<Record<string, string>>;\n}\n\nexport type OnRequest = (served: ServedRequest) => unknown;\n\n/**\n * Run the handler and call onRequest once the response it answers is over.\n *\n * The body is passed through rather than read, so streaming is untouched: each\n * chunk goes out as it is produced. onRequest is never awaited and a throw\n * from it is reported, not raised - a logger that fails must not fail the page.\n */\nexport async function observeServed(\n  request: Request,\n  serve: (request: Request) => Promise<Response>,\n  onRequest: OnRequest,\n  headerNames: readonly string[] = [],\n): Promise<Response> {\n  const started = performance.now();\n  let reported = false;\n\n  const report = (status: number, aborted: boolean, error?: unknown) => {\n    if (reported) return;\n    reported = true;\n\n    const served: ServedRequest = {\n      method: request.method,\n      pathname: new URL(request.url).pathname,\n      status,\n      durationMs: performance.now() - started,\n      aborted,\n      headers: pickHeaders(request.headers, headerNames),\n      ...(error === undefined ? {} : { error }),\n    };\n\n    try {\n      Promise.resolve(onRequest(served)).catch(failed);\n    } catch (thrown) {\n      failed(thrown);\n    }\n  };\n\n  let response: Response;\n\n  try {\n    response = await serve(request);\n  } catch (error) {\n    report(500, false, error);\n    throw error;\n  }\n\n  if (!response.body) {\n    report(response.status, false);\n    return response;\n  }\n\n  const reader = response.body.getReader();\n  const body = new ReadableStream<Uint8Array>({\n    async pull(controller) {\n      try {\n        const { done, value } = await reader.read();\n\n        if (done) {\n          controller.close();\n          report(response.status, false);\n        } else {\n          controller.enqueue(value);\n        }\n      } catch (error) {\n        controller.error(error);\n        report(response.status, false, error);\n      }\n    },\n    cancel(reason) {\n      report(response.status, true);\n      return reader.cancel(reason);\n    },\n  });\n\n  return new Response(body, { status: response.status, statusText: response.statusText, headers: response.headers });\n}\n\nfunction pickHeaders(headers: Headers, names: readonly string[]): Readonly<Record<string, string>> {\n  const picked: Record<string, string> = {};\n\n  for (const name of names) {\n    const value = headers.get(name);\n    if (value !== null) picked[name.toLowerCase()] = value;\n  }\n\n  return Object.freeze(picked);\n}\n\nfunction failed(error: unknown): void {\n  console.error(\"[rsc-kit] instrumentation.ts onRequest() failed:\", error);\n}\n"]}

package/dist/vite.d.ts

@@ -321,6 +321,17 @@ export interface RscKitOptions {
  * whole app, or its own endpoints, to the backend.
  */
 export declare function normaliseBackendPaths(paths: readonly string[] | undefined): string[];
+/**
+ * The prefixes a backend owns, as the route patterns the browser already reads
+ * for a route.ts: the prefix, and everything under it.
+ *
+ * The router never fetches these as pages. A backend url that answers a
+ * payload request with a redirect to another site - an OAuth start - is a hop
+ * a fetch cannot make, so the navigation threw and the visitor stayed where
+ * they were. Listed with the route.ts patterns it is a document load, with no
+ * prefetch, wherever the router meets one: a click, a redirect, a hover.
+ */
+export declare function backendPatterns(paths: readonly string[]): string[];
 /**
  * The service worker, written into the client output at build time.
  *
@@ -454,6 +465,26 @@ export declare function compileStep(root: string): {
     compile?: string;
     binary?: string;
 };
+/**
+ * The app's process bootstrap, if it has one: `instrumentation.ts` beside
+ * `app/`, the name Next uses so a reader arriving from there knows what it
+ * is.
+ *
+ * Two things make it a framework concern rather than an import the app
+ * adds. Module evaluation order: a page that configures a shared package at
+ * import time runs before any module the app could put first, and only the
+ * generated entry can import something before the pages. And "before the
+ * first request": an async `register()` — connecting, validating env — has
+ * to be awaited by every entry point a host or a prerender can call, which
+ * is a list the app cannot see.
+ */
+type InstrumentationFile = {
+    file: string;
+    hasRegister: boolean;
+    hasShutdown: boolean;
+    hasOnRequest?: boolean;
+    hasOnRequestHeaders?: boolean;
+};
 /**
  * How the generated entry imports instrumentation.ts, as `__instrumentation`.
  *
@@ -463,11 +494,7 @@ export declare function compileStep(root: string): {
  * "Import `shutdown` will always be undefined") - the app told off for a file
  * written exactly as documented. The rest are simply absent from the object.
  */
-export declare function instrumentationImport(instrumentation: {
-    file: string;
-    hasRegister: boolean;
-    hasShutdown: boolean;
-} | null): string;
+export declare function instrumentationImport(instrumentation: InstrumentationFile | null): string;
 /**
  * The worker the dev server serves at /sw.js: it removes the one a production
  * run left on this origin, and the caches with it, then reloads each page it
@@ -565,3 +592,4 @@ export declare function publicVariablesSet(mode: string, envDir?: string | false
     where: string;
 }[];
 export declare function rscKit(options?: RscKitOptions): PluginOption[];
+export {};

package/dist/vite.js

@@ -420,14 +420,28 @@ export function normaliseBackendPaths(paths) {
         if (path === "/_rsc" || path.startsWith("/_rsc/")) {
             throw new Error(`[rsc-kit] backendPaths: ${JSON.stringify(raw)} is this package's own endpoint, which the renderer answers.`);
         }
-        if (/[?#*]/.test(path)) {
-            throw new Error(`[rsc-kit] backendPaths: ${JSON.stringify(raw)} is a prefix, not a pattern: no query, fragment or wildcard.`);
+        // A bracket is a dynamic segment to the client, which reads these as route patterns.
+        if (/[?#*[\]]/.test(path)) {
+            throw new Error(`[rsc-kit] backendPaths: ${JSON.stringify(raw)} is a prefix, not a pattern: no query, fragment, wildcard or bracket.`);
         }
         if (!out.includes(path))
             out.push(path);
     }
     return out;
 }
+/**
+ * The prefixes a backend owns, as the route patterns the browser already reads
+ * for a route.ts: the prefix, and everything under it.
+ *
+ * The router never fetches these as pages. A backend url that answers a
+ * payload request with a redirect to another site - an OAuth start - is a hop
+ * a fetch cannot make, so the navigation threw and the visitor stayed where
+ * they were. Listed with the route.ts patterns it is a document load, with no
+ * prefetch, wherever the router meets one: a click, a redirect, a hover.
+ */
+export function backendPatterns(paths) {
+    return paths.flatMap((path) => [path, `${path}/[...rest]`]);
+}
 function resolvePaths(options) {
     projectRoot = resolve(options.projectRoot || process.env.RSC_PROJECT_ROOT || process.cwd());
     sourceDir = resolve(options.sourceDir || process.env.RSC_SOURCE_DIR || join(projectRoot, "src"));
@@ -2171,6 +2185,14 @@ function renderRouteTypes(manifest) {
         // Api routes are a separate union, so Link refuses an api url and apiUrl()
         // refuses a page. Linking to an api route navigates the browser away to a
         // json document, which is the mistake worth catching.
+        // The prefixes rscKit({ backendPaths }) named, so a link or a redirect to
+        // one of the backend's urls compiles without a cast.
+        "  interface RegisterBackend {",
+        backendPaths.length > 0
+            ? "    paths:\n" +
+                backendPaths.map((p) => "      | " + JSON.stringify(p)).join("\n")
+            : "    // No backendPaths named.\n    paths: never",
+        "  }",
         // Regions: every section('name', …) the build read, and every @slot
         // directory. This is what types revalidate().
         "  interface RegisterRegions {",
@@ -3099,19 +3121,6 @@ function installHostCallsOnce(): void {
 }
 
 `;
-/**
- * The app's process bootstrap, if it has one: `instrumentation.ts` beside
- * `app/`, the name Next uses so a reader arriving from there knows what it
- * is.
- *
- * Two things make it a framework concern rather than an import the app
- * adds. Module evaluation order: a page that configures a shared package at
- * import time runs before any module the app could put first, and only the
- * generated entry can import something before the pages. And "before the
- * first request": an async `register()` — connecting, validating env — has
- * to be awaited by every entry point a host or a prerender can call, which
- * is a list the app cannot see.
- */
 function instrumentationFile() {
     for (const ext of ["ts", "tsx", "mts", "js", "mjs"]) {
         const file = join(sourceDir, `instrumentation.${ext}`);
@@ -3124,7 +3133,13 @@ function instrumentationFile() {
         // a file written exactly as documented.
         const source = readFileSync(file, "utf-8");
         const exports = (name) => new RegExp(`export\\s+(?:async\\s+)?(?:function\\s+${name}\\b|const\\s+${name}\\b|let\\s+${name}\\b|\\{[^}]*\\b${name}\\b[^}]*\\})`).test(source);
-        return { file, hasRegister: exports("register"), hasShutdown: exports("shutdown") };
+        return {
+            file,
+            hasRegister: exports("register"),
+            hasShutdown: exports("shutdown"),
+            hasOnRequest: exports("onRequest"),
+            hasOnRequestHeaders: exports("onRequestHeaders"),
+        };
     }
     return null;
 }
@@ -3138,12 +3153,14 @@ function instrumentationFile() {
  * written exactly as documented. The rest are simply absent from the object.
  */
 export function instrumentationImport(instrumentation) {
-    const type = "{ register?: () => unknown; shutdown?: () => unknown }";
+    const type = "{ register?: () => unknown; shutdown?: () => unknown; onRequest?: (served: never) => unknown; onRequestHeaders?: readonly string[] }";
     if (!instrumentation)
         return `const __instrumentation: ${type} = {}`;
     const hooks = [
         ...(instrumentation.hasRegister ? ["register"] : []),
         ...(instrumentation.hasShutdown ? ["shutdown"] : []),
+        ...(instrumentation.hasOnRequest ? ["onRequest"] : []),
+        ...(instrumentation.hasOnRequestHeaders ? ["onRequestHeaders"] : []),
     ];
     const from = JSON.stringify(instrumentation.file);
     // No hooks: still imported, first, for what its import does.
@@ -3248,6 +3265,7 @@ import { httpHostCalls } from ${JSON.stringify(join(packageDir, "hostCalls"))}
 import { backendVersions, installBackendVersionSource } from ${JSON.stringify(join(packageDir, "changed"))}
 import { RefreshOn } from ${JSON.stringify(join(packageDir, "js/refreshOn"))}
 import { prerenderedBeside } from ${JSON.stringify(join(packageDir, "files"))}
+import { observeServed } from ${JSON.stringify(join(packageDir, "served"))}
 import { renderToReadableStream, decodeReply, decodeAction, decodeFormState, loadServerAction } from '@vitejs/plugin-rsc/rsc'
 import { isQuery, queryCacheControl, isQueryValidationError, queryRefusal } from ${JSON.stringify(join(packageDir, "query"))}
 import { isActionValidationError, isActionRefusal, isClientBuilt } from ${JSON.stringify(join(packageDir, "action"))}
@@ -5914,6 +5932,16 @@ ${backendPathConsts()}${fallbackOrigin === false ? "" : FALLBACK_CONSTS.replace(
 let devHandler: ((request: Request) => Promise<Response | null>) | null = null
 
 export default async function handler(request: Request): Promise<Response> {
+  // instrumentation.ts's onRequest(), once each response is over - streamed to
+  // the end, or cut off. Not for the startup probe: no visitor asked for it.
+  if (__instrumentation.onRequest && request.headers.get('x-rsc-kit-startup') === null) {
+    return observeServed(request, served, __instrumentation.onRequest as never, __instrumentation.onRequestHeaders)
+  }
+
+  return served(request)
+}
+
+async function served(request: Request): Promise<Response> {
   try {
     return await serve(request)
   } catch (error) {
@@ -6393,8 +6421,12 @@ createViteRscApp(document, ${JSON.stringify(interceptManifest())}, ${JSON.string
         staticPayloads: staticPayloads || null,
         routes: routesForClient,
         // Every route.ts, as a url pattern, so a link to one is treated as an
-        // anchor rather than prefetched and fetched as a page.
-        apiRoutes: (routeManifest().apis ?? []).map((api) => patternOf(api.segments)),
+        // anchor rather than prefetched and fetched as a page - and so is
+        // anything under a prefix the app named as the backend's.
+        apiRoutes: [
+            ...(routeManifest().apis ?? []).map((api) => patternOf(api.segments)),
+            ...backendPatterns(backendPaths),
+        ],
     })})
 
 // A server component is not a module the browser has, so Vite cannot replace