akanjs 3.1.0 → 3.1.1-rc.0

package/server/contentEncoding.ts

@@ -1,4 +1,5 @@
-import { brotliCompressSync, constants, gzipSync } from "node:zlib";
+import { promisify } from "node:util";
+import { brotliCompress, constants, createBrotliCompress, createGzip, gzip } from "node:zlib";
 
 const COMPRESSIBLE_TYPES = new Set([
   "application/javascript",
@@ -8,16 +9,35 @@ const COMPRESSIBLE_TYPES = new Set([
 ]);
 
 export const CONTENT_ENCODINGS = [
-  { encoding: "br", ext: ".br", accept: /(?:^|,)\s*(?:br|\*)(?![\w-])\s*(?:;\s*q=([\d.]+))?/i },
-  { encoding: "gzip", ext: ".gz", accept: /(?:^|,)\s*(?:gzip|\*)(?![\w-])\s*(?:;\s*q=([\d.]+))?/i },
+  { encoding: "br", ext: ".br" },
+  { encoding: "gzip", ext: ".gz" },
 ] as const;
 
 export type ContentEncoding = (typeof CONTENT_ENCODINGS)[number]["encoding"];
 
-/** `q=0` is an explicit refusal, not a preference. */
-export const acceptsEncoding = (acceptEncoding: string, accept: RegExp): boolean => {
-  const match = accept.exec(acceptEncoding);
-  return !!match && !(match[1] !== undefined && Number.parseFloat(match[1]) <= 0);
+/** `q=0` is an explicit refusal, and a coding named outright overrides `*`. */
+export const acceptedEncodings = (acceptEncoding: string): ContentEncoding[] => {
+  const qByCoding = new Map<string, number>();
+  for (const part of acceptEncoding.split(",")) {
+    const [coding = "", ...params] = part.split(";");
+    const q = params.map((param) => param.trim()).find((param) => param.toLowerCase().startsWith("q="));
+    qByCoding.set(coding.trim().toLowerCase(), q === undefined ? 1 : Number.parseFloat(q.slice(2)));
+  }
+  return CONTENT_ENCODINGS.map(({ encoding }) => encoding).filter((encoding) => {
+    const q = qByCoding.get(encoding) ?? qByCoding.get("*");
+    return q !== undefined && !(q <= 0);
+  });
+};
+
+export const varyOnEncoding = (headers: Headers) => {
+  if (!/(?:^|,)\s*accept-encoding\s*(?:,|$)/i.test(headers.get("vary") ?? ""))
+    headers.append("Vary", "Accept-Encoding");
+};
+
+export const matchesIfNoneMatch = (ifNoneMatch: string | null, etag: string): boolean => {
+  if (!ifNoneMatch) return false;
+  const opaque = (tag: string) => tag.trim().replace(/^W\//, "");
+  return ifNoneMatch.split(",").some((tag) => tag.trim() === "*" || opaque(tag) === opaque(etag));
 };
 
 export const isCompressibleContentType = (contentType: string): boolean => {
@@ -34,43 +54,161 @@ const MIN_COMPRESS_BYTES = 1024;
 
 const MAX_COMPRESS_BYTES = 4 * 1024 * 1024;
 
+const brotliCompressAsync = promisify(brotliCompress);
+const gzipAsync = promisify(gzip);
+
 const compressBody = (bytes: Uint8Array, encoding: ContentEncoding) =>
   encoding === "br"
-    ? brotliCompressSync(bytes, {
+    ? brotliCompressAsync(bytes, {
         params: {
           [constants.BROTLI_PARAM_QUALITY]: BROTLI_QUALITY,
           [constants.BROTLI_PARAM_SIZE_HINT]: bytes.byteLength,
         },
       })
-    : gzipSync(bytes, { level: GZIP_LEVEL });
+    : gzipAsync(bytes, { level: GZIP_LEVEL });
 
-const isWholeBody = (req: Request, response: Response) =>
+const isWholeBody = (req: Request, response: Pick<Response, "status" | "headers">) =>
   !req.headers.has("range") &&
   !response.headers.has("content-range") &&
   response.status >= 200 &&
   response.status < 300 &&
   response.status !== 206;
 
+const isCompressionOff = () => process.env.AKAN_HTTP_COMPRESS === "false" || process.env.AKAN_HTTP_COMPRESS === "0";
+
+const negotiateEncoding = (req: Request, response: Pick<Response, "status" | "headers">): ContentEncoding | null => {
+  if (response.headers.has("content-encoding")) return null;
+  if (!isWholeBody(req, response)) return null;
+  if (Number(response.headers.get("content-length")) > MAX_COMPRESS_BYTES) return null;
+  if (!isCompressibleContentType(response.headers.get("content-type") ?? "")) return null;
+  if (isCompressionOff()) return null;
+  return acceptedEncodings(req.headers.get("accept-encoding") ?? "")[0] ?? null;
+};
+
 export const compressResponse = async (req: Request, response: Response): Promise<Response> => {
-  if (response.headers.has("content-encoding") || !response.body) return response;
-  if (!isWholeBody(req, response)) return response;
-  if (Number(response.headers.get("content-length")) > MAX_COMPRESS_BYTES) return response;
-  if (!isCompressibleContentType(response.headers.get("content-type") ?? "")) return response;
-  if (process.env.AKAN_HTTP_COMPRESS === "false" || process.env.AKAN_HTTP_COMPRESS === "0") return response;
-  const acceptEncoding = req.headers.get("accept-encoding") ?? "";
-  const encoding = CONTENT_ENCODINGS.find(({ accept }) => acceptsEncoding(acceptEncoding, accept))?.encoding;
-  if (!encoding) return response;
+  const encoding = negotiateEncoding(req, response);
+  if (!encoding || !response.body) return response;
   const bytes = new Uint8Array(await response.arrayBuffer());
-  if (bytes.byteLength < MIN_COMPRESS_BYTES) return new Response(bytes, response);
-  const compressed = compressBody(bytes, encoding);
+  
+  if (bytes.byteLength < MIN_COMPRESS_BYTES || bytes.byteLength > MAX_COMPRESS_BYTES)
+    return new Response(bytes, response);
+  const compressed = await compressBody(bytes, encoding);
   const headers = new Headers(response.headers);
   headers.set("Content-Encoding", encoding);
   headers.set("Content-Length", String(compressed.byteLength));
-  
-  headers.append("Vary", "Accept-Encoding");
+  varyOnEncoding(headers);
   return new Response(compressed, { status: response.status, statusText: response.statusText, headers });
 };
 
+const STREAM_BROTLI_LGWIN = 18;
+const STREAM_FLUSH = { br: constants.BROTLI_OPERATION_FLUSH, gzip: constants.Z_SYNC_FLUSH } as const;
+
+const createStreamCompressor = (encoding: ContentEncoding) => {
+  const compressor =
+    encoding === "br"
+      ? createBrotliCompress({
+          params: {
+            [constants.BROTLI_PARAM_QUALITY]: BROTLI_QUALITY,
+            [constants.BROTLI_PARAM_LGWIN]: STREAM_BROTLI_LGWIN,
+          },
+        })
+      : createGzip({ level: GZIP_LEVEL });
+  let pendingFlush: ReturnType<typeof setImmediate> | null = null;
+  let isCancelled = false;
+  const stop = () => {
+    isCancelled = true;
+    if (pendingFlush) clearImmediate(pendingFlush);
+    compressor.destroy();
+  };
+  
+  const transformer: Transformer<Uint8Array, Uint8Array> & { cancel: () => void } = {
+    start: (controller) => {
+      compressor.on("data", (chunk: Uint8Array) => {
+        if (isCancelled) return;
+
+        try {
+          controller.enqueue(chunk);
+        } catch {
+          stop();
+        }
+      });
+      compressor.on("error", (error) => {
+        if (!isCancelled) controller.error(error);
+      });
+    },
+    transform: (chunk) => {
+      compressor.write(chunk);
+      pendingFlush ??= setImmediate(() => {
+        pendingFlush = null;
+        compressor.flush(STREAM_FLUSH[encoding]);
+      });
+    },
+    flush: () =>
+      new Promise<void>((resolve, reject) => {
+        if (pendingFlush) clearImmediate(pendingFlush);
+        compressor.once("end", resolve).once("close", resolve).once("error", reject).end();
+      }),
+    cancel: stop,
+  };
+  return new TransformStream<Uint8Array, Uint8Array>(transformer);
+};
+
+export const compressStreamResponse = (req: Request, response: Response): Response => {
+  const encoding = negotiateEncoding(req, response);
+  if (!encoding || !response.body) return response;
+  const headers = new Headers(response.headers);
+  headers.set("Content-Encoding", encoding);
+  headers.delete("Content-Length");
+  varyOnEncoding(headers);
+  const etag = headers.get("etag");
+  
+  if (etag && !etag.startsWith("W/")) headers.set("ETag", `W/${etag}`);
+  return new Response(response.body.pipeThrough(createStreamCompressor(encoding)), {
+    status: response.status,
+    statusText: response.statusText,
+    headers,
+  });
+};
+
+export interface EncodedBody {
+  bytes: Uint8Array<ArrayBuffer>;
+  encodings: Partial<Record<ContentEncoding, Uint8Array<ArrayBuffer>>>;
+  /** The raw bytes and every encoding, which is what keeping it costs. */
+  byteLength: number;
+}
+
+export const encodeBody = async (body: string | Uint8Array<ArrayBuffer>): Promise<EncodedBody> => {
+  const bytes = typeof body === "string" ? new TextEncoder().encode(body) : body;
+  const encodings: EncodedBody["encodings"] = {};
+  let byteLength = bytes.byteLength;
+  if (isCompressionOff() || bytes.byteLength < MIN_COMPRESS_BYTES || bytes.byteLength > MAX_COMPRESS_BYTES)
+    return { bytes, encodings, byteLength };
+  await Promise.all(
+    CONTENT_ENCODINGS.map(async ({ encoding }) => {
+      const encoded = await compressBody(bytes, encoding);
+      encodings[encoding] = encoded;
+      byteLength += encoded.byteLength;
+    }),
+  );
+  return { bytes, encodings, byteLength };
+};
+
+export const encodedBodyResponse = (
+  req: Request,
+  body: EncodedBody,
+  init: { status?: number; headers: Headers },
+): Response => {
+  const status = init.status ?? 200;
+  const encoding = negotiateEncoding(req, { status, headers: init.headers });
+  const encoded = encoding ? body.encodings[encoding] : undefined;
+  if (!encoding || !encoded) return new Response(body.bytes, { status, headers: init.headers });
+  const headers = new Headers(init.headers);
+  headers.set("Content-Encoding", encoding);
+  headers.set("Content-Length", String(encoded.byteLength));
+  varyOnEncoding(headers);
+  return new Response(encoded, { status, headers });
+};
+
 export interface EncodedSidecar {
   bytes: ArrayBuffer;
   encoding: string;
@@ -82,9 +220,9 @@ export const resolveEncodedSidecar = async (
   contentType: string,
 ): Promise<EncodedSidecar | null> => {
   if (!isCompressibleContentType(contentType)) return null;
-  const acceptEncoding = req.headers.get("accept-encoding") ?? "";
-  for (const { encoding, ext, accept } of CONTENT_ENCODINGS) {
-    if (!acceptsEncoding(acceptEncoding, accept)) continue;
+  const accepted = acceptedEncodings(req.headers.get("accept-encoding") ?? "");
+  for (const { encoding, ext } of CONTENT_ENCODINGS) {
+    if (!accepted.includes(encoding)) continue;
     const file = Bun.file(`${filePath}${ext}`);
     if (!(await file.exists())) continue;
     const bytes = await file.bytes();
@@ -100,10 +238,10 @@ export const encodedFileResponse = async (
   contentType: string,
   headers: Headers,
 ): Promise<Response> => {
+  if (isCompressibleContentType(contentType)) varyOnEncoding(headers);
   const sidecar = await resolveEncodedSidecar(req, filePath, contentType);
   if (!sidecar) return new Response(Bun.file(filePath).stream(), { headers });
   headers.set("Content-Encoding", sidecar.encoding);
   headers.set("Content-Length", String(sidecar.bytes.byteLength));
-  headers.set("Vary", "Accept-Encoding");
   return new Response(sidecar.bytes, { headers });
 };

package/server/hmr/devArtifactPruner.ts

@@ -1,7 +1,7 @@
 import fs from "node:fs/promises";
 import path from "node:path";
 import { Logger } from "akanjs/common";
-import type { CssAsset } from "../types";
+import type { BaseBuildArtifact, CssAsset } from "../types";
 
 export class DevArtifactPruner {
   
@@ -37,6 +37,15 @@ export class DevArtifactPruner {
     });
   }
 
+  pruneDictionaries(): Promise<void> {
+    return this.#queue(async () => {
+      const keep = new Set((await this.#baseArtifact()).dicts);
+      if (keep.size === 0) return;
+      const dictDir = path.join(this.#artifactDir, "dict");
+      await this.#removeOlder(dictDir, (name) => name.endsWith(".js"), keep, Date.now() - this.#graceMs);
+    });
+  }
+
   #queue(prune: () => Promise<void>): Promise<void> {
     this.#pruning = this.#pruning.then(prune).catch((error: unknown) => {
       this.#logger.verbose(`[dev-artifact] prune skipped: ${String(error)}`);
@@ -64,14 +73,15 @@ export class DevArtifactPruner {
     if (removed > 0) this.#logger.verbose(`[dev-artifact] removed ${removed} superseded file(s) from ${dir}`);
   }
 
-  async #baseArtifact(): Promise<{ pages: string[]; styles: string[] }> {
+  async #baseArtifact(): Promise<{ pages: string[]; styles: string[]; dicts: string[] }> {
     const text = await fs.readFile(path.join(this.#artifactDir, "base-artifact.json"), "utf8").catch(() => null);
     const artifact = text
-      ? (JSON.parse(text) as { pagesBundlePath?: string; cssAssets?: Record<string, CssAsset> })
+      ? (JSON.parse(text) as Partial<Pick<BaseBuildArtifact, "pagesBundlePath" | "cssAssets" | "dictAssets">>)
       : null;
     return {
       pages: artifact?.pagesBundlePath ? [path.resolve(this.#artifactDir, artifact.pagesBundlePath)] : [],
       styles: Object.values(artifact?.cssAssets ?? {}).map((asset) => path.join(this.#artifactDir, asset.cssRelPath)),
+      dicts: Object.values(artifact?.dictAssets ?? {}).map((asset) => path.join(this.#artifactDir, asset.relPath)),
     };
   }
 }

package/server/hmr/devHmrController.ts

@@ -104,6 +104,7 @@ export class DevHmrController {
     this.#artifactDir = artifactDir;
     this.#runningBundlePath = pagesBundlePath ? path.resolve(pagesBundlePath) : null;
     this.#pruner = new DevArtifactPruner(artifactDir);
+    void this.#pruner.pruneDictionaries();
     this.#renderState = renderState;
     this.#rsc = rsc;
     this.#seedIndex = seedIndex;

package/server/imageOptimizer.ts

@@ -3,6 +3,7 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import { Logger } from "akanjs/common";
 import { isAnimatedImage } from "./animatedImage";
+import { matchesIfNoneMatch } from "./contentEncoding";
 import { ImageOptimizerError } from "./imageOptimizerError";
 import { Semaphore } from "./semaphore";
 import { resolveStaticPath } from "./staticPath";
@@ -381,7 +382,8 @@ export class ImageOptimizer {
       ETag: image.etag,
       Vary: "Accept",
     });
-    if (req.headers.get("if-none-match") === image.etag) return new Response(null, { status: 304, headers });
+    if (matchesIfNoneMatch(req.headers.get("if-none-match"), image.etag))
+      return new Response(null, { status: 304, headers });
     return new Response(ImageOptimizer.#toArrayBuffer(image.buffer), { headers });
   }
 

package/server/routeState.ts

@@ -6,6 +6,7 @@ export const AKAN_RSC_CURRENT_ROUTE_HEADER = "X-Akan-Rsc-Current-Route";
 export const AKAN_RSC_CURRENT_STATE_HEADER = "X-Akan-Rsc-Current-State";
 export const AKAN_RSC_RESPONSE_STATE_HEADER = "X-Akan-Rsc-State";
 export const AKAN_RSC_NOT_FOUND_HEADER = "X-Akan-Rsc-Not-Found";
+export const AKAN_RSC_DICTIONARY_HEADER = "X-Akan-Dict";
 export const AKAN_RSC_PATCH_START_INDEX_HEADER = "X-Akan-Rsc-Patch-Start-Index";
 export const AKAN_RSC_PATCH_SEGMENT_PATH_HEADER = "X-Akan-Rsc-Patch-Segment-Path";
 export const AKAN_RSC_PATCH_START_SEGMENT_HEADER = "X-Akan-Rsc-Patch-Start-Segment";

package/server/routing/apiRouter.ts

@@ -2,7 +2,7 @@ import { dayjs } from "akanjs/base";
 import { type Logger, websocketAuthContract, websocketHeartbeatContract } from "akanjs/common";
 import type { InjectRegistry, LiveRegistry } from "akanjs/service";
 import { CrossSiteGuard, isExceptionLike, SignalContext, SignalFailure, type WebsocketReqData } from "akanjs/signal";
-import { compressResponse } from "../contentEncoding";
+import { compressResponse, compressStreamResponse } from "../contentEncoding";
 import type { HmrWsData, HmrWsHub } from "../hmr/wsHub";
 import { copyBunRequestFields, type WebProxyRunner } from "../proxy";
 import { SignalResolver } from "../resolver";
@@ -93,9 +93,10 @@ export class ApiRouter {
       ...Object.fromEntries(builtinEntries),
       ...(renderEnvRoutes ?? {}),
     } as NonNullHttpRoutes;
-    const served = webProxyRunner
+    const proxied = webProxyRunner
       ? ApiRouter.#wrapRoutesWithWebProxy(routeTable, webProxyRunner, prefix, endpointPaths)
       : routeTable;
+    const served = ApiRouter.#compressRenderRoutes(proxied, new Set(Object.keys(renderEnvRoutes ?? {})));
     return hostAllowlist ? ApiRouter.#guardHosts(served, hostAllowlist) : served;
   }
 
@@ -252,6 +253,20 @@ export class ApiRouter {
     });
   }
 
+  static #compressRenderRoutes(routes: NonNullHttpRoutes, renderPaths: Set<string>): NonNullHttpRoutes {
+    return Object.fromEntries(
+      Object.entries(routes).map(([path, route]) => [
+        path,
+        renderPaths.has(path)
+          ? ApiRouter.#mapRoute(route, (handler) => async (req) => {
+              const response = await handler(req);
+              return response ? compressStreamResponse(req, response) : response;
+            })
+          : route,
+      ]),
+    ) as NonNullHttpRoutes;
+  }
+
   static #corsRoute(route: RouteValue): RouteValue {
     if (!route || typeof route !== "object" || route instanceof Response || "OPTIONS" in route) return route;
     const methods = Object.keys(route);

package/server/rscClient.tsx

@@ -1,9 +1,11 @@
 import { createElement, type ReactNode, startTransition, type Usable, use, useLayoutEffect, useState } from "react";
 import { hydrateRoot } from "react-dom/client";
 import { createFromReadableStream } from "react-server-dom-webpack/client.browser";
+import { DictionaryAsset } from "../client/dictionaryAsset";
 import type {} from "../client/rscNavigation";
 import { isAuthTokenKey } from "../common/authCookie";
 import {
+  AKAN_RSC_DICTIONARY_HEADER,
   type AkanHeadSnapshotV1,
   type AkanRouterStateV1,
   type AkanRscPatchMetadata,
@@ -44,6 +46,7 @@ declare global {
   var __RSC_PUSH__: ((type: InlineRscChunk[0], data: string) => void) | undefined;
   var __RSC_CLOSE__: (() => void) | undefined;
   var __AKAN_RSC_INITIAL_STATE__: string | undefined;
+  var __AKAN_DICT_URL__: string | undefined;
 }
 
 function decodeInlineRscChunk([type, data]: InlineRscChunk): Uint8Array {
@@ -236,18 +239,23 @@ async function fetchRsc(
     shouldApplyNavigation,
   });
   if (responseResult.type === "redirected" || responseResult.type === "not-found") return responseResult;
+  
+  const dictionaryReady = DictionaryAsset.load(responseResult.response.headers.get(AKAN_RSC_DICTIONARY_HEADER));
   if (responseResult.type === "patch") {
-    const patchResult = await validateRscPatchForGuardedCommit({
-      partialCommitEnabled: isAkanRscPartialCommitEnabled(),
-      currentTree: currentSegmentTree,
-      response: responseResult.response,
-      patch: responseResult.patch,
-      href,
-      createThenable: createRscThenable,
-      navId: options.navId,
-      getCurrentNavId: () => navigationSeq,
-      getHeadSnapshotPatchFailureReason: getAkanHeadSnapshotPatchFailureReason,
-    });
+    const [patchResult] = await Promise.all([
+      validateRscPatchForGuardedCommit({
+        partialCommitEnabled: isAkanRscPartialCommitEnabled(),
+        currentTree: currentSegmentTree,
+        response: responseResult.response,
+        patch: responseResult.patch,
+        href,
+        createThenable: createRscThenable,
+        navId: options.navId,
+        getCurrentNavId: () => navigationSeq,
+        getHeadSnapshotPatchFailureReason: getAkanHeadSnapshotPatchFailureReason,
+      }),
+      dictionaryReady,
+    ]);
     if (patchResult.status === "patched") {
       if (!patchResult.headSnapshot) throw new Error("[rscClient] validated RSC patch is missing a head snapshot");
       return {
@@ -284,6 +292,7 @@ async function fetchRsc(
     routerState: responseResult.notFound ? null : readAkanRouterStateResponseHeader(res.headers),
   });
   nodeRef.current = node;
+  await dictionaryReady;
   return {
     type: "rsc",
     node,
@@ -604,4 +613,8 @@ const hydrate = () => {
   hydrateRoot(document, createElement(Root));
   scrollRestoration.restoreDocumentLoad();
 };
-void Promise.resolve(initialThenable).then(hydrate, hydrate);
+
+const initialDictionary = DictionaryAsset.load(globalThis.__AKAN_DICT_URL__).catch((error: unknown) =>
+  console.error(`[rscClient] the page's dictionary failed to load: ${String(error)}`),
+);
+void Promise.allSettled([initialThenable, initialDictionary]).then(hydrate);

package/server/ssrFromRscRenderer.tsx

@@ -610,7 +610,7 @@ export class SsrFromRscRenderer {
 
     const withHeadScripts = SsrFromRscRenderer.#injectHeadScriptsIntoHead(htmlStream, {
       importmap: input.importmap,
-      bootstrapModules: input.bootstrapModules,
+      modulePreloads: [...(input.bootstrapModules ?? []), ...(input.modulePreloads ?? [])],
       theme: input.theme,
       injectThemeInitScript: input.injectThemeInitScript,
     });
@@ -714,20 +714,20 @@ export class SsrFromRscRenderer {
     stream: ReadableStream<Uint8Array>,
     options: {
       importmap?: Record<string, string>;
-      bootstrapModules?: string[];
+      modulePreloads: string[];
       theme?: AkanTheme;
       injectThemeInitScript?: boolean;
     },
   ): ReadableStream<Uint8Array> {
     const encoder = new TextEncoder();
     const decoder = new TextDecoder();
-    const { importmap, bootstrapModules, theme, injectThemeInitScript } = options;
+    const { importmap, modulePreloads, theme, injectThemeInitScript } = options;
     const htmlTheme = theme && theme !== "css" && theme !== "system" ? theme : undefined;
     const importmapTag =
       importmap && Object.keys(importmap).length > 0
         ? `<script type="importmap">${JSON.stringify({ imports: importmap })}</script>`
         : "";
-    const modulePreloadTags = SsrFromRscRenderer.#createBootstrapModulePreloadTags(bootstrapModules);
+    const modulePreloadTags = SsrFromRscRenderer.#createModulePreloadTags(modulePreloads);
     const shouldInjectThemeScript = theme === "system" || (theme === undefined && injectThemeInitScript);
     const themeInitTag = shouldInjectThemeScript ? SsrFromRscRenderer.#themeInitScript : "";
     const tags = `${themeInitTag}${importmapTag}${modulePreloadTags}`;
@@ -777,8 +777,8 @@ export class SsrFromRscRenderer {
     );
   }
 
-  static #createBootstrapModulePreloadTags(bootstrapModules: string[] = []): string {
-    return bootstrapModules.map((src) => `<link rel="modulepreload" href="${escapeHtmlAttr(src)}">`).join("");
+  static #createModulePreloadTags(modules: string[]): string {
+    return modules.map((src) => `<link rel="modulepreload" href="${escapeHtmlAttr(src)}">`).join("");
   }
 
   static #createBootstrapModuleScriptTags(bootstrapModules: string[] = []): string {

package/server/ssrTypes.ts

@@ -54,6 +54,8 @@ export interface SsrFromRscInput {
   rscStream: ReadableStream<Uint8Array>;
   ssrManifest: SsrManifest;
   bootstrapModules?: string[];
+  /** Modules a bootstrap module imports at load: preloaded in the head, never run as scripts. */
+  modulePreloads?: string[];
   extraBootstrapInline?: string;
 
   importmap?: Record<string, string>;

package/server/types.tsx

@@ -101,6 +101,8 @@ export type BaseBuildArtifact = {
   pagesBundlePath: string;
   pagesBundleBuildId: number;
   cssAssets: Record<string, CssAsset>;
+  /** Per locale; absent in an artifact older than the asset, whose pages carried their dictionary in the flight. */
+  dictAssets?: Record<string, DictAsset>;
   domains: string[];
   subRoutes: { [key: string]: string[] };
   basePaths: string[];
@@ -140,6 +142,11 @@ export interface CssAsset {
   cssRelPath: string;
 }
 
+export interface DictAsset {
+  url: string;
+  relPath: string;
+}
+
 export interface RenderState {
   buildId: number;
   cssAssets: Record<string, CssAsset>;

package/server/vendor/tailwind-merge.ts

@@ -0,0 +1 @@
+export * from "tailwind-merge";