@thomas.f/prnext 0.1.0-alpha.1

package/runtime/rsc-worker.mjs

@@ -0,0 +1,426 @@
+import React from 'react';
+import { flightBundler } from './worker-metadata.mjs';
+import { removeBasePath, normalizeTrailingSlash } from '../compat/paths.cjs';
+import { renderToReadableStream } from 'react-server-dom-webpack/server.node';
+import { createFromReadableStream } from 'react-server-dom-webpack/client.edge';
+import { parentPort } from 'node:worker_threads';
+import { pathToFileURL } from 'node:url';
+import { createHash } from 'node:crypto';
+import { runRequestContext, currentRequest } from '../compat/headers.cjs';
+import { Metadata } from './app-metadata.mjs';
+import { appTimeoutError } from './app-errors.mjs';
+import { paramsBySegment, selectedLayoutSegments } from './app-segments.mjs';
+import { instantEnabled } from '../compat/instant.cjs';
+import { createAdvancedTree, loadAdvancedRouting } from './app-routing.mjs';
+import { authorizeAdvancedRouting } from './app-routing-access.mjs';
+import { routingBranchRenderer } from './app-routing-context.mjs';
+import { runAction } from './action-server.mjs';
+import { workerStreamChannel, APP_STREAM_CHUNK_BYTES } from './app-stream-channel.mjs';
+import { flushCacheWork, getCachePaths } from '../compat/data-cache.cjs';
+import { staticMetadata, staticSearchParams, staticParams, trackStaticDependency } from '../compat/static-generation.cjs';
+import { collectStaticParams, validateRuntimeStaticConfig } from './app-static-params.mjs';
+import { navigationResponse } from './navigation.mjs';
+import { installFetchCache } from './fetch-cache.mjs';
+import { flightConsumer } from './cache-components-rsc.mjs';
+import { partialModel, isPartialHole, boundedPartialFlight } from './app-partial-model.mjs';
+import { PartialTemplates, canResumePartialDirectly, partialTemplateReuse } from './partial-template.mjs';
+
+installFetchCache();
+
+const MAX_RESPONSE_BYTES = 16 * 1024 * 1024;
+const routeEntries = new Map();
+const partialTemplates = new PartialTemplates();
+async function routeEntry(request) {
+  const key = request.modulePath;
+  if (request.production && routeEntries.has(key)) {
+    const entry = routeEntries.get(key);
+    routeEntries.delete(key); routeEntries.set(key, entry);
+    return entry;
+  }
+  const entry = await import(pathToFileURL(key).href);
+  if (request.production) {
+    if (routeEntries.size >= 64) routeEntries.delete(routeEntries.keys().next().value);
+    routeEntries.set(key, entry);
+  }
+  return entry;
+}
+
+function component(module, name) {
+  const value = module?.default;
+  if (typeof value !== 'function' && (typeof value !== 'object' || value === null)) {
+    throw new Error(`App Router ${name} must export a React component as default`);
+  }
+  return value;
+}
+
+function queryObject(url) {
+  const values = Object.create(null);
+  for (const [name, value] of url.searchParams) {
+    if (name === '_rsc') continue;
+    if (!Object.hasOwn(values, name)) values[name] = value;
+    else values[name] = [...(Array.isArray(values[name]) ? values[name] : [values[name]]), value];
+  }
+  // Client pages receive this promise through Flight, which requires ordinary
+  // plain objects. Spread preserves an own __proto__ query without invoking it.
+  return { ...values };
+}
+
+function createTree(entry, request, fallback = null) {
+  const params = staticParams(request.params || {});
+  const searchParams = staticSearchParams(queryObject(new URL(request.url)), currentRequest(), entry.page?.default?.$$typeof === Symbol.for('react.client.reference'));
+  if (entry.routing && !fallback) return createAdvancedTree(entry, request, searchParams);
+  const segments = entry.segments || [];
+  const page = fallback?.kind === 'not-found' ? segments[fallback.index].notFound : entry.page;
+  const pageKey = `${request.routePattern || new URL(request.url).pathname}:${JSON.stringify(request.params || {})}`;
+  const keyScopes = [];
+  const instantTrees = [];
+  const instantDisabled = [entry.pageConfig, ...segments.map(segment => segment.staticConfig)].some(config => config?.instant && typeof config.instant === 'object' && (config.instant.unstable_disableValidation || (request.production ? config.instant.unstable_disableBuildValidation : config.instant.unstable_disableDevValidation)));
+  function keyScope(prefix, values, liveProps) {
+    const key = prefix + JSON.stringify(values);
+    keyScopes.push({ key, prefix, names: Object.keys(values), ...(liveProps ? { liveProps } : {}) });
+    return key;
+  }
+  if (request.partialParams?.length) keyScope(`${request.routePattern || new URL(request.url).pathname}:`, request.params || {});
+  const metadata = React.createElement(RouteMetadata, { key: 'metadata' });
+  const head = request.cacheComponents ? React.createElement(React.Suspense, { fallback: null, key: 'metadata-boundary' }, metadata) : metadata;
+  const rootLayout = segments.find(segment => segment.layout);
+  let tree = null;
+  if (fallback?.kind !== 'error') {
+    const Page = component(page, fallback ? 'not-found' : 'page');
+    tree = !fallback && entry.ClientPageRoot && Page.$$typeof === Symbol.for('react.client.reference')
+      ? React.createElement(entry.ClientPageRoot, { Component: Page, params, searchParams, key: pageKey })
+      : React.createElement(Page, { params, searchParams, key: pageKey });
+  }
+  const scopes = new Map();
+  const scopedParams = paramsBySegment(segments, request.params || {});
+  for (const segment of segments) {
+    scopes.set(segment, `${segment.path || ''}:${JSON.stringify(scopedParams.get(segment))}`);
+    if (request.partialParams?.length) for (const prefix of ['', 'error:', 'navigation:', 'layout:']) keyScope(`${prefix}${segment.path || ''}:`, scopedParams.get(segment), prefix === 'layout:' ? ['segments'] : undefined);
+  }
+  let instantConfig = entry.pageConfig?.instant;
+  for (const segment of [...(fallback ? segments.slice(0, fallback.index + 1) : segments)].reverse()) {
+    if (segment.loading) tree = React.createElement(React.Suspense, {
+      fallback: React.createElement(component(segment.loading, 'loading')),
+    }, tree);
+    if (request.instantValidation && !instantDisabled && segment.layout) {
+      if (instantEnabled(instantConfig, request.production)) instantTrees.push({ path: segment.path || '/', tree: React.createElement(React.Fragment, null, tree) });
+      if (segment.staticConfig?.instant !== undefined) instantConfig = segment.staticConfig.instant;
+    }
+    if (segment.error && entry.ErrorBoundary) tree = React.createElement(entry.ErrorBoundary, {
+      errorComponent: component(segment.error, 'error'),
+      initialError: fallback?.kind === 'error' && fallback.index === segments.indexOf(segment) ? fallback.error : null,
+      resetKey: request.renderKey,
+      key: `error:${scopes.get(segment)}`,
+    }, tree);
+    if (entry.NavigationBoundary && (segment.notFound || segment === segments[0])) tree = React.createElement(entry.NavigationBoundary, {
+      notFound: segment.notFound ? React.createElement(component(segment.notFound, 'not-found')) : React.createElement('h1', null, '404: This page could not be found.'),
+      resetKey: request.renderKey,
+      key: `navigation:${scopes.get(segment)}`,
+    }, tree);
+    if (segment.template) {
+      const child = segments[segments.indexOf(segment) + 1];
+      tree = React.createElement(component(segment.template, 'template'), { key: child ? scopes.get(child) : pageKey }, tree);
+    }
+    if (segment.layout) {
+      if (request.cacheComponents && segment === rootLayout) tree = React.createElement(React.Fragment, null, head, tree);
+      tree = React.createElement(component(segment.layout, 'layout'), { params: staticParams(scopedParams.get(segment)), key: scopes.get(segment) }, tree);
+      if (entry.LayoutProvider) tree = React.createElement(entry.LayoutProvider, { key: `layout:${scopes.get(segment)}`,
+        segments: { children: selectedLayoutSegments(segments.slice(segments.indexOf(segment) + 1), request.params) } }, tree);
+    }
+  }
+  // Keep module namespaces out of development owner props: they can contain
+  // large application exports which need not be serialized as Flight debug data.
+  async function RouteMetadata() {
+    const pathname = request.originalUrl
+      ? removeBasePath(new URL(request.originalUrl).pathname, request.basePath)
+      : new URL(request.url).pathname;
+    return runRequestContext({ ...currentRequest(), metadataRendering: true }, () =>
+      Metadata({ entry, params, searchParams, pathname, notFoundIndex: fallback?.index ?? -1 }));
+  }
+  return { tree: request.cacheComponents ? tree : React.createElement(React.Fragment, null, head, tree), head, rootLayout: entry.rootLayout,
+    ...(keyScopes.length ? { keyScopes } : {}), ...(request.instantValidation ? { instantTrees } : {}) };
+}
+
+function ordinaryRenderError(error) {
+  return error && error.code !== 'PRNEXT_DYNAMIC_SERVER_USAGE' && !isPartialHole(error) && error.statusCode !== 504 && !navigationResponse(error);
+}
+
+function publicError(error, production) {
+  const digest = typeof error?.digest === 'string' ? error.digest : createHash('sha256').update(String(error?.stack || error?.message || error)).digest('hex').slice(0, 16);
+  return { message: production ? 'An error occurred while rendering this page. See the server logs for details.' : error?.message || String(error), digest };
+}
+
+function errorBoundary(entry, error, production, before = Infinity) {
+  const index = entry.ErrorBoundary ? (entry.segments || []).findLastIndex((segment, index) => index < before && segment.error) : -1;
+  return index < 0 ? null : { kind: 'error', index, error: publicError(error, production) };
+}
+
+async function renderFlight(request, fallback = null, channel = null) {
+  return runRequestContext({ ...request, phase: 'render' }, async () => {
+    const cacheContext = currentRequest();
+    try {
+      if (cacheContext.staticState) trackStaticDependency({ paths: getCachePaths(cacheContext) }, cacheContext);
+      const allowedRouting = request.controlModel || await authorizeAdvancedRouting(request, channel?.signal);
+      const module = await routeEntry(request);
+      const entry = allowedRouting ? await loadAdvancedRouting(module, request) : module;
+      if (!allowedRouting) request.responseStatus = 400;
+      if (cacheContext.staticState) validateRuntimeStaticConfig(entry);
+      if (request.actionNotFound && !fallback) {
+        const index = (entry.segments || []).findLastIndex(segment => segment.notFound);
+        if (index < 0) throw Object.assign(new Error('Not Found'), { digest: 'NEXT_HTTP_ERROR_FALLBACK;404' });
+        fallback = { kind: 'not-found', index };
+      }
+      if (request.fallbackError && !fallback) {
+        fallback = errorBoundary(entry, request.fallbackError, request.production, request.beforeErrorBoundary);
+        if (!fallback) throw Object.assign(new Error(request.fallbackError.message), request.fallbackError);
+      }
+      const url = new URL(request.url);
+      url.searchParams.delete('_rsc');
+      const visible = request.originalUrl ? new URL(request.originalUrl) : url;
+      visible.searchParams.delete('_rsc');
+      const router = { pathname: request.originalUrl ? removeBasePath(visible.pathname, request.basePath) : normalizeTrailingSlash(visible.pathname, request), basePath: request.basePath || '', trailingSlash: request.trailingSlash || false, skipTrailingSlashRedirect: request.skipTrailingSlashRedirect || false, search: request.cacheConfig?.dynamic === 'force-static' ? '' : visible.search, params: request.params || {},
+        ...(request.originalUrl ? { pageSearch: url.search } : {}),
+        ...(request.cacheConfig?.dynamic === 'force-static' ? { forceStatic: true } : {}) };
+      const bundlerConfig = flightBundler(request.clientModules);
+      const abort = new AbortController();
+      const renderSignal = channel ? AbortSignal.any([abort.signal, channel.signal]) : abort.signal;
+      const timeoutMs = request.renderTimeoutMs ?? 25_000;
+      const timeout = setTimeout(() => abort.abort(appTimeoutError('RSC render', timeoutMs)), timeoutMs);
+      let renderError;
+      try {
+        if (request.routingContexts?.size) request.renderRoutingBranch = routingBranchRenderer(cacheContext, bundlerConfig,
+          renderSignal, error => publicError(error, request.production).digest);
+        let model = request.controlModel || { ...(allowedRouting ? createTree(entry, request, fallback) : { tree: null, routingInvalid: true }), router, css: request.css || [], fonts: request.fonts || [], ...(request.instantDiagnostics?.length ? { instantDiagnostics: request.instantDiagnostics } : {}), ...request.actionModel };
+        if (model.routing?.params) model.router.params = model.routing.params;
+        if (request.partialFlight) {
+          const consumer = { serverConsumerManifest: flightConsumer(request), replayConsoleLogs: false };
+          const decode = () => {
+            const bytes = Buffer.from(request.partialFlight, 'base64');
+            return createFromReadableStream(new ReadableStream({ start(controller) { controller.enqueue(bytes); controller.close(); } }), consumer);
+          };
+          const stored = request.production
+            ? await partialTemplates.get(request.partialFlight, consumer.serverConsumerManifest, decode, renderSignal)
+            : await decode();
+          const live = !model.routing && canResumePartialDirectly(stored) ? model : await createFromReadableStream(boundedPartialFlight(renderToReadableStream(model, bundlerConfig, {
+            signal: renderSignal,
+            onError(error) { return publicError(error, request.production).digest; },
+          })), consumer);
+          const keyMap = request.partialKeys ? new Map(request.partialKeys) : undefined;
+          model = partialModel(stored, { live, keyMap, reuse: partialTemplateReuse(stored, keyMap) });
+        }
+        const stream = renderToReadableStream(model, bundlerConfig, {
+          signal: renderSignal,
+          temporaryReferences: request.temporaryReferences,
+          onError(error) {
+            const failure = error && typeof error === 'object' ? error : new Error(String(error));
+            if (cacheContext.staticState?.partial && isPartialHole(failure)) return 'PRNEXT_PPR_DYNAMIC';
+            renderError ??= failure;
+            const digest = publicError(failure, request.production).digest;
+            if (!abort.signal.aborted && !channel?.signal.aborted && ordinaryRenderError(failure)) console.error(`[prnext] ${digest}`, failure?.stack || failure);
+            return digest;
+          },
+        });
+        const reader = stream.getReader();
+        const chunks = [];
+        let length = 0;
+        let lookahead;
+        try {
+          for (;;) {
+            channel?.signal.throwIfAborted();
+            const nextRead = lookahead || reader.read();
+            lookahead = undefined;
+            let { value, done } = await nextRead;
+            if (done) break;
+            length += value.byteLength;
+            if (length > MAX_RESPONSE_BYTES) {
+              const error = new Error('Flight response exceeds the 16 MiB PRNext limit');
+              abort.abort(error);
+              await reader.cancel(error);
+              throw error;
+            }
+            if (channel) {
+              // Flight frequently emits several small rows in one render turn.
+              // Coalesce only reads that are already resolved; an async child
+              // must never hold back the shell while this batch is assembled.
+              const batch = [value];
+              let batchLength = value.byteLength;
+              function prefetch() {
+                const state = {};
+                lookahead = reader.read().then(result => { state.result = result; return result; });
+                lookahead.catch(() => {});
+                return state;
+              }
+              let next = prefetch();
+              if (!channel.started) await new Promise(resolve => setImmediate(resolve));
+              else await Promise.resolve();
+              while (next.result && !next.result.done && batch.length < 64 && batchLength + next.result.value.byteLength <= APP_STREAM_CHUNK_BYTES) {
+                batch.push(next.result.value);
+                batchLength += next.result.value.byteLength;
+                length += next.result.value.byteLength;
+                if (length > MAX_RESPONSE_BYTES) {
+                  const error = new Error('Flight response exceeds the 16 MiB PRNext limit');
+                  abort.abort(error);
+                  await reader.cancel(error);
+                  throw error;
+                }
+                next = prefetch();
+                await Promise.resolve();
+              }
+              // Errors discovered while constructing the first Flight chunk can
+              // still select an HTTP status or render the nearest fallback.
+              if (!channel.started && !request.partialFlight && renderError && !ordinaryRenderError(renderError) && !(entry.routing && renderError.digest === 'NEXT_HTTP_ERROR_FALLBACK;404')) { await reader.cancel(renderError); break; }
+              if (batch.length > 1) {
+                value = new Uint8Array(batchLength);
+                let offset = 0;
+                for (const item of batch) { value.set(item, offset); offset += item.byteLength; }
+              }
+              if (!channel.started) channel.start({ status: request.partialFlight ? 200 : fallback?.kind === 'not-found' || (entry.routing && renderError?.digest === 'NEXT_HTTP_ERROR_FALLBACK;404') ? 404 : renderError || fallback?.kind === 'error' ? 500 : request.responseStatus || 200,
+                rscError: Boolean(ordinaryRenderError(renderError)), boundaryIndex: fallback?.index, headers: request.responseHeaders });
+              await channel.write(value, abort.signal, Boolean(next.result?.done));
+              continue;
+            }
+            // The byte stream hands ownership of each Uint8Array to its reader.
+            // Retain those chunks until assembly instead of copying them again.
+            chunks.push(value);
+          }
+        } finally { reader.releaseLock(); }
+        if (abort.signal.aborted) throw abort.signal.reason;
+        if (cacheContext.staticState?.error) throw cacheContext.staticState.error;
+        let staticNavigation;
+        if (renderError) {
+          if (renderError.code === 'PRNEXT_DYNAMIC_SERVER_USAGE') throw renderError;
+          // After the shell is sent, React's encoded error/digest and the client
+          // navigation/error boundaries complete the response in-band.
+          if (channel?.started && renderError.statusCode !== 504) { channel.end(); return; }
+          if (renderError.digest === 'NEXT_HTTP_ERROR_FALLBACK;404' && !entry.routing) {
+            const boundary = (entry.segments || []).findLastIndex((segment, index) => index < (fallback?.index ?? Infinity) && segment.notFound);
+            if (boundary >= 0) return renderFlight({ ...request, cacheState: cacheContext.cacheState, staticState: cacheContext.staticState }, { kind: 'not-found', index: boundary }, channel);
+          } else if (ordinaryRenderError(renderError)) {
+            if (cacheContext.staticState) throw renderError;
+            // Preserve the original errored Flight tree. React's browser
+            // boundaries know the exact failing subtree; replaying the route
+            // here both repeats user effects and can select a child boundary
+            // for an exception actually thrown by its parent layout.
+          }
+          if (!ordinaryRenderError(renderError) && !(entry.routing && renderError.digest === 'NEXT_HTTP_ERROR_FALLBACK;404')) {
+            staticNavigation = cacheContext.staticState && navigationResponse(renderError);
+            if (!staticNavigation) throw renderError;
+          }
+        }
+        if (channel) {
+          if (!channel.started) channel.start({ status: request.responseStatus || 200, headers: request.responseHeaders });
+          channel.end();
+          return;
+        }
+        // A dedicated ArrayBuffer is transferable even for small responses; a
+        // pooled Node Buffer could otherwise clone its entire allocation pool.
+        const body = new Uint8Array(length);
+        let offset = 0;
+        for (const chunk of chunks) {
+          body.set(chunk, offset);
+          offset += chunk.byteLength;
+        }
+        return { body: body.buffer, status: staticNavigation?.status || (fallback?.kind === 'not-found' || (entry.routing && renderError?.digest === 'NEXT_HTTP_ERROR_FALLBACK;404') ? 404 : renderError || fallback?.kind === 'error' ? 500 : request.responseStatus || 200),
+          rscError: Boolean(ordinaryRenderError(renderError)), boundaryIndex: fallback?.index, headers: { ...request.responseHeaders, ...staticNavigation?.headers },
+          ...(staticNavigation ? { navigation: { status: staticNavigation.status, body: String(staticNavigation.body || '') } } : {}),
+          ...(cacheContext.staticState ? { staticMetadata: staticMetadata(cacheContext) } : {}) };
+      } catch (error) {
+        if (abort.signal.aborted && abort.signal.reason?.statusCode === 504) throw abort.signal.reason;
+        throw error;
+      } finally {
+        clearTimeout(timeout);
+      }
+    } finally {
+      await flushCacheWork(cacheContext);
+    }
+  });
+}
+
+async function handleRequest(request, channel = null) {
+  if (request.operation === 'static-params') {
+    return runRequestContext({ ...request, phase: 'render' }, async () => {
+      const context = currentRequest();
+      try { return { staticParams: await collectStaticParams(await import(pathToFileURL(request.modulePath).href), request.routePattern) }; }
+      finally { await flushCacheWork(context); }
+    });
+  }
+  if (!request.action) return renderFlight(request, null, channel);
+  const outcome = await runAction(request);
+  const responseHeaders = outcome.setCookies.length ? { 'set-cookie': outcome.setCookies } : {};
+  if (outcome.native && outcome.actionRedirect) {
+    return { body: new ArrayBuffer(0), status: 303, headers: { ...responseHeaders, location: outcome.actionRedirect.url } };
+  }
+  const { action, ...renderRequest } = request;
+  const actionModel = { actionResult: outcome.actionResult, actionError: outcome.actionError,
+    formState: outcome.formState, actionRedirect: outcome.actionRedirect };
+  if (renderRequest.routingRequestHeaders && outcome.setCookies.length) {
+    const original = new Headers(renderRequest.routingRequestHeaders);
+    const parsed = value => new Map((value || '').split(';').map(part => { const split = part.indexOf('='); return [part.slice(0, split).trim(), part.slice(split + 1).trim()]; }).filter(([name]) => name));
+    const cookies = parsed(original.get('cookie')), updated = parsed(new Headers(outcome.headers).get('cookie'));
+    for (const line of outcome.setCookies) {
+      const name = line.slice(0, line.indexOf('=')).trim();
+      if (updated.has(name)) cookies.set(name, updated.get(name)); else cookies.delete(name);
+    }
+    if (cookies.size) original.set('cookie', [...cookies].map(([name, value]) => `${name}=${value}`).join('; ')); else original.delete('cookie');
+    renderRequest.routingRequestHeaders = Object.fromEntries(original);
+  }
+  try {
+    return await renderFlight({ ...renderRequest, mutableCookies: false, headers: outcome.headers,
+      temporaryReferences: outcome.temporaryReferences, responseHeaders,
+      responseStatus: outcome.failure ? 500 : 200,
+      actionNotFound: outcome.actionNotFound,
+      ...(outcome.native && outcome.failure ? { fallbackError: outcome.failure } : {}),
+      ...(outcome.actionRedirect ? { controlModel: actionModel } : { actionModel }),
+    }, null, channel);
+  } catch (error) {
+    error.responseHeaders = responseHeaders;
+    throw error;
+  }
+}
+
+const streamChannels = new Map();
+const activeRequests = new Set();
+const cancelledRequests = new Set();
+const manifests = new Map();
+const artifacts = new Map();
+parentPort.on('message', async ({ id, request, type, value }) => {
+  if (type === 'metadata') { manifests.set(id, value); return; }
+  if (type === 'metadata-drop') { manifests.delete(id); return; }
+  if (type === 'artifact') { artifacts.set(id, value); return; }
+  if (type === 'artifact-drop') { artifacts.delete(id); return; }
+  if (type === 'credit') { streamChannels.get(id)?.credit(); return; }
+  if (type === 'cancel') {
+    if (activeRequests.has(id)) cancelledRequests.add(id);
+    else parentPort.postMessage({ id, type: 'settled' });
+    streamChannels.get(id)?.cancel(); return;
+  }
+  for (const field of ['clientModules', 'actions']) {
+    if (request[field + 'Id'] !== undefined) request[field] = manifests.get(request[field + 'Id']);
+  }
+  const channel = request.stream && (!request.action || request.action.id) ? workerStreamChannel(parentPort, id) : null;
+  activeRequests.add(id);
+  if (channel) streamChannels.set(id, channel);
+  try {
+    if (request.partialFlightId !== undefined) {
+      // Resolve synchronously, before the next message can evict this ID.
+      if (!artifacts.has(request.partialFlightId)) throw new Error('Unknown partial Flight artefact');
+      request.partialFlight = artifacts.get(request.partialFlightId);
+      delete request.partialFlightId;
+    }
+    if (channel) {
+      await handleRequest({ ...request, renderKey: id }, channel);
+      return;
+    }
+    const result = await handleRequest({ ...request, renderKey: id });
+    parentPort.postMessage({ id, ...result }, result.body instanceof ArrayBuffer ? [result.body] : []);
+  } catch (error) {
+    parentPort.postMessage({ id, error: {
+      message: error?.message || String(error), stack: error?.stack, digest: error?.digest, statusCode: error?.statusCode,
+      retireWorker: error?.retireWorker, responseHeaders: error?.responseHeaders,
+      code: error?.code, staticMode: error?.staticMode, dynamicReason: error?.dynamicReason,
+    } });
+  } finally {
+    streamChannels.delete(id); activeRequests.delete(id);
+    if (cancelledRequests.delete(id)) parentPort.postMessage({ id, type: 'settled' });
+  }
+});

package/runtime/script-html.mjs

@@ -0,0 +1,61 @@
+import React from 'react';
+
+const ignored = new Set(['strategy', 'onLoad', 'onReady', 'onError', 'stylesheets', 'children', 'dangerouslySetInnerHTML']);
+export function scriptJSON(value) {
+  return JSON.stringify(value).replace(/[<>&\u2028\u2029]/g, char => ({ '<': '\\u003c', '>': '\\u003e', '&': '\\u0026', '\u2028': '\\u2028', '\u2029': '\\u2029' })[char]);
+}
+
+export function scriptNonce(headers = {}) {
+  const get = name => Object.entries(headers).find(([key]) => key.toLowerCase() === name)?.[1];
+  const policy = get('content-security-policy') || get('content-security-policy-report-only');
+  if (typeof policy !== 'string') return undefined;
+  const directives = policy.split(';').map(value => value.trim());
+  const selected = directives.find(value => value.startsWith('script-src')) || directives.find(value => value.startsWith('default-src'));
+  for (const value of selected?.split(/\s+/).slice(1) || []) {
+    const match = /^'nonce-([A-Za-z0-9+/_-]+={0,2})'$/.exec(value);
+    if (match) return match[1];
+  }
+}
+
+function scriptElement(props, { nonce, crossOrigin, worker = false } = {}) {
+  const attributes = Object.fromEntries(Object.entries(props).filter(([key, value]) => !ignored.has(key) && typeof value !== 'function'));
+  const source = props.dangerouslySetInnerHTML ? props.dangerouslySetInnerHTML.__html || ''
+    : typeof props.children === 'string' ? props.children : Array.isArray(props.children) ? props.children.join('') : '';
+  return React.createElement('script', { ...attributes,
+    ...(props.src ? { defer: worker ? undefined : props.defer ?? true } : { dangerouslySetInnerHTML: { __html: source } }),
+    nonce: worker || !props.src ? nonce : props.nonce || nonce, crossOrigin,
+    ...(worker ? { type: 'text/partytown' } : {}), 'data-nscript': worker ? 'worker' : 'beforeInteractive',
+  });
+}
+
+/** Finalize after one Document render so scripts below NextScript are included. */
+export function completePageScripts(markup, { pageScripts, documentScripts, worker, nonce, crossOrigin }, render) {
+  const all = [...pageScripts, ...documentScripts];
+  const before = all.filter(props => props.strategy === 'beforeInteractive');
+  const inline = before.filter(props => !props.src);
+  const external = before.filter(props => props.src);
+  const elements = [];
+  for (const props of external) elements.push(React.createElement('link', { rel: 'preload', as: 'script', href: props.src,
+    nonce, crossOrigin }));
+  elements.push(...inline.map(props => scriptElement(props, { nonce, crossOrigin })));
+  if (worker) {
+    if (!/\bdata-partytown-config(?:[\s=>])/i.test(markup)) elements.push(React.createElement('script', { nonce, 'data-partytown-config': '',
+      dangerouslySetInnerHTML: { __html: `partytown={lib:${scriptJSON(worker.lib)}};` } }));
+    elements.push(React.createElement('script', { nonce, 'data-partytown': '', dangerouslySetInnerHTML: { __html: worker.snippet } }));
+    elements.push(...pageScripts.filter(props => props.strategy === 'worker').map(props => scriptElement(props, { nonce, crossOrigin, worker: true })));
+  }
+  elements.push(...external.map(props => scriptElement(props, { nonce, crossOrigin })));
+  const html = elements.length ? render(React.createElement(React.Fragment, null, ...elements)) : '';
+  const target = '<prnext-document-script-target></prnext-document-script-target>';
+  // Head's children must run first: <base> affects relative script URLs, and a
+  // user Partytown configuration must be set before its bootstrap executes.
+  markup = markup.includes(target) ? markup.replace(target, () => html).replaceAll(target, '')
+    : markup.replace(/<\/head>/i, closing => html + closing);
+  const items = documentScripts.filter(props => props.strategy !== 'beforeInteractive');
+  if (items.length) {
+    const payload = render(React.createElement('script', { id: '__PRNEXT_SCRIPT_LOADER__', type: 'application/json', nonce,
+      dangerouslySetInnerHTML: { __html: scriptJSON(items) } }));
+    markup = markup.replace(/<\/body>/i, closing => payload + closing);
+  }
+  return markup;
+}

package/runtime/stream-select.mjs

@@ -0,0 +1,25 @@
+// A read gets one settlement listener. Repeated Promise.race against a slow
+// source otherwise accumulates one listener per chunk from the faster source.
+// Callers keep at most one outstanding read per source and retain backpressure.
+export function streamSelector() {
+  const ready = [];
+  let wake, closed = false;
+  function settle(item) {
+    if (closed) return;
+    ready.push(item);
+    wake?.(); wake = undefined;
+  }
+  return {
+    watch(type, promise) {
+      Promise.resolve(promise).then(value => settle({ type, ...value }), error => settle({ error }));
+    },
+    async next() {
+      while (!ready.length && !closed) await new Promise(resolve => { wake = resolve; });
+      if (closed) throw new Error('Stream selector closed');
+      const item = ready.shift();
+      if (Object.hasOwn(item, 'error')) throw item.error;
+      return item;
+    },
+    close() { closed = true; ready.length = 0; wake?.(); wake = undefined; },
+  };
+}

package/runtime/stream-utils.mjs

@@ -0,0 +1,127 @@
+export const STREAM_CHUNK_BYTES = 64 * 1024;
+
+export function abortError(reason = 'Response body was canceled') {
+  if (reason instanceof Error) return reason;
+  const error = new Error(String(reason));
+  error.name = 'AbortError';
+  return error;
+}
+
+export function apiTimeoutError(phase, milliseconds) {
+  const error = new Error(`API ${phase} timed out after ${milliseconds / 1000} seconds`);
+  error.statusCode = 504;
+  return error;
+}
+
+/** Await user code without leaving an abort listener attached after it settles. */
+export function withSignal(promise, signal) {
+  if (!signal) return Promise.resolve(promise);
+  if (signal.aborted) {
+    Promise.resolve(promise).catch(() => {});
+    return Promise.reject(abortError(signal.reason));
+  }
+  return new Promise((resolve, reject) => {
+    const aborted = () => reject(abortError(signal.reason));
+    signal.addEventListener('abort', aborted, { once: true });
+    Promise.resolve(promise).then(resolve, reject).finally(() => signal.removeEventListener('abort', aborted));
+  });
+}
+
+/**
+ * Pull one source chunk at a time, splitting it without copying its bytes.
+ * Explicit iterator methods also make return() cancel before the first next().
+ */
+export function streamingBody(source, { signal, onCancel, onComplete, timeoutMs = 25_000, runInContext = callback => callback() } = {}) {
+  const reader = source?.getReader?.();
+  const iterator = reader ? {
+    next: () => reader.read(),
+    return: reason => reader.cancel(reason),
+  } : source?.[Symbol.asyncIterator]?.();
+  if (!iterator) throw new TypeError('A streaming response requires a ReadableStream or async iterable');
+  let stopped = false;
+  let failure;
+  let chunk;
+  let offset = 0;
+  let timer;
+  let nextInProgress = false;
+  let rejectPending;
+
+  function clean() {
+    clearTimeout(timer);
+    signal?.removeEventListener('abort', aborted);
+    chunk = undefined;
+    if (reader) {
+      try { reader.releaseLock(); } catch { /* Cancellation may still be settling a pending read. */ }
+    }
+    onComplete?.();
+  }
+
+  function stop(reason, error = false) {
+    if (stopped) return;
+    stopped = true;
+    if (error) failure = abortError(reason);
+    rejectPending?.(failure || abortError(reason));
+    // A user stream may never settle its cancel callback. Release our request
+    // immediately, while observing that callback's eventual rejection.
+    try { Promise.resolve(runInContext(() => iterator.return?.(reason))).catch(() => {}); } catch {}
+    try { onCancel?.(abortError(reason)); }
+    catch (error) { failure ||= error; }
+    finally { clean(); }
+  }
+
+  function touch() {
+    clearTimeout(timer);
+    if (timeoutMs > 0) {
+      timer = setTimeout(() => stop(apiTimeoutError('response idle', timeoutMs), true), timeoutMs);
+      timer.unref?.();
+    }
+  }
+  function aborted() { stop(signal.reason, true); }
+  if (signal?.aborted) aborted();
+  else { signal?.addEventListener('abort', aborted, { once: true }); touch(); }
+
+  const body = {
+    [Symbol.asyncIterator]() { return this; },
+    async next() {
+      if (failure) throw failure;
+      if (stopped) return { done: true, value: undefined };
+      if (nextInProgress) throw new Error('Response body reads must be sequential');
+      nextInProgress = true;
+      try {
+        while (!chunk || offset >= chunk.byteLength) {
+          chunk = undefined;
+          const canceled = new Promise((_, reject) => { rejectPending = reject; });
+          const next = await Promise.race([runInContext(() => iterator.next()), canceled]);
+          rejectPending = undefined;
+          if (stopped) {
+            if (failure) throw failure;
+            return { done: true, value: undefined };
+          }
+          if (next.done) {
+            stopped = true;
+            clean();
+            return { done: true, value: undefined };
+          }
+          if (!(next.value instanceof Uint8Array)) throw new TypeError('Response body chunks must be Uint8Array values');
+          chunk = next.value;
+          offset = 0;
+        }
+        const value = chunk.subarray(offset, Math.min(offset + STREAM_CHUNK_BYTES, chunk.byteLength));
+        offset += value.byteLength;
+        touch();
+        return { done: false, value };
+      } catch (error) {
+        if (stopped && !failure) return { done: true, value: undefined };
+        stop(error, true);
+        throw failure || error;
+      } finally { nextInProgress = false; rejectPending = undefined; }
+    },
+    async return(reason) {
+      stop(reason || abortError());
+      return { done: true, value: undefined };
+    },
+    async throw(error) { stop(error, true); throw error; },
+    cancel(reason) { return body.return(reason); },
+  };
+  return body;
+}