@rsc-kit/core 0.30.22 → 0.30.24

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

@@ -465,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`.
  *
@@ -474,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
@@ -576,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

@@ -1907,18 +1907,17 @@ async function prerenderAfterBundles(bundle, staticDir, assetsDir, knownActions
         console.log("     React's cache() dedupes only inside a component render; in a guard, an action or\n" +
             "     an api route it calls straight through. Import it from @rsc-kit/core/cache instead.");
     }
-    // Server files importing a client library. Legal - a server component may
-    // render a client component from a package - but the shape that costs an
-    // afternoon is a file with no "use client" that only wraps them, so the
-    // library's internals run on the server. Said, with the packages and the
-    // importer, so the person reading can tell which it is.
+    // Server files whose code, or a library's under them, reaches a hook on the
+    // server (clientImports.ts). The render that calls one fails naming React,
+    // not the file; this names the file, the package and the hook.
     if (clientLibraryImports.length > 0) {
-        console.log(`\n  \u2139  ${clientLibraryImports.length} server ${clientLibraryImports.length === 1 ? "file imports" : "files import"} a client library: ` +
+        console.log(`\n  \u2139  ${clientLibraryImports.length} server ${clientLibraryImports.length === 1 ? "file reaches" : "files reach"} client-only React: ` +
             clientLibraryImports
-                .map((c) => `${c.file} (${c.packages.join(", ")}${c.from ? `; imported by ${c.from}` : ""})`)
+                .map((c) => `${c.file} (${c.packages.length > 0 ? `${c.packages.join(", ")}: ` : ""}${c.calls.join(", ")}${c.from ? `; imported by ${c.from}` : ""})`)
                 .join("; "));
-        console.log('     Legal for a server component. A file that only wraps client components wants "use client" -\n' +
-            "     as shadcn ships it - so the server stops at the boundary.");
+        console.log('     The server has none of these, so a render that calls one fails with "... is not a function".\n' +
+            '     A file that only wraps client components wants "use client" - as shadcn ships it. A library\n' +
+            "     export holding a hook the page never renders is fine.");
     }
     // Written from the rows that were just printed rather than recomputed: the
     // report and the terminal must not be able to disagree about what happened.
@@ -3121,19 +3120,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}`);
@@ -3146,7 +3132,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;
 }
@@ -3160,12 +3152,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.
@@ -3270,6 +3264,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"))}
@@ -5936,6 +5931,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) {
@@ -7122,6 +7127,7 @@ function clientImportsAudit() {
                 moduleIds: () => this.getModuleIds(),
                 importedIds: (id) => this.getModuleInfo(id)?.importedIds ?? [],
                 importers: (id) => this.getModuleInfo(id)?.importers ?? [],
+                code: (id) => this.getModuleInfo(id)?.code ?? null,
             }, {
                 sourceDir,
                 clientPackages,