@thomas.f/prnext 0.1.11-alpha → 0.1.13-alpha

package/runtime/app-routing.mjs

@@ -6,8 +6,9 @@ import path from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { currentRequest, runRequestContext } from '../compat/headers.cjs';
 import { staticParams } from '../compat/static-generation.cjs';
+import { appRoutePlan } from './app-route-plan.mjs';
 
-import { matchAppPattern, readRouterState } from './app-routing-state.mjs';
+import { matchAppPattern, createAppMatcher, readRouterState } from './app-routing-state.mjs';
 export { matchAppPattern, readRouterState, advancedRoutingSources } from './app-routing-state.mjs';
 
 export async function loadAdvancedRouting(entry, request) {
@@ -51,10 +52,12 @@ function selectedSegments(chain, params) {
 /** Parallel slots retain their original Flight children on soft navigation. */
 export function createAdvancedTree(entry, request, searchParams) {
   const pathname = removeBasePath(new URL(request.url).pathname, request.basePath || '');
+  const matchCurrent = createAppMatcher(pathname);
   const old = readRouterState(request), slots = {}, activeParams = { ...request.params };
   const rebuild = !!old && (old.refresh || old.restore || request.method === 'POST');
   let invalid = false;
   const root = entry.routing;
+  const plan = appRoutePlan(root);
   let metadataHead;
   const keyScopes = new Map();
   const instantTrees = [];
@@ -62,18 +65,20 @@ export function createAdvancedTree(entry, request, searchParams) {
     if (request.partialParams?.length) keyScopes.set(key, { key, prefix, suffix, names: Object.keys(values), pattern: node.pattern, ...(liveProps ? { liveProps } : {}), ...(segments ? { segments } : {}) });
     return key;
   }
-  const rootLayouts = new Set();
+  const rootLayouts = plan?.rootLayouts || new Set();
   const metadataSelections = new Map();
   let missing = entry.interceptionOnly && !old, rootPage;
   const all = [];
   function walk(node, chain = []) {
     const next = [...chain, node];
     if (node.files.layout && !chain.some(parent => parent.files.layout)) rootLayouts.add(node.path);
-    if (node.files.page) all.push({ node, chain: next, params: matchAppPattern(node.pattern, pathname) });
+    if (node.files.page) all.push({ node, chain: next, params: matchCurrent(node.pattern) });
     for (const child of node.children) walk(child, next);
     for (const child of Object.values(node.slots)) walk(child, next);
   }
-  walk(root);
+  if (plan) {
+    for (const page of plan.pages) all.push({ ...page, params: matchCurrent(page.node.pattern) });
+  } else walk(root);
   let activeInterceptions;
   function canIntercept(candidate) {
     if (!candidate.node.interception || !old) return false;
@@ -97,14 +102,29 @@ export function createAdvancedTree(entry, request, searchParams) {
   function candidates(node, chain = []) {
     const result = [], next = [...chain, node];
     if (node.files.page) {
-      const params = matchAppPattern(node.pattern, pathname);
+      const params = matchCurrent(node.pattern);
       if (params && (!node.interception || canIntercept({ node }))) result.push({ node, chain: next, params });
     }
     for (const child of node.children) result.push(...candidates(child, next));
     return result.sort((left, right) => Number(!!right.node.interception) - Number(!!left.node.interception) || score(right.node.pattern) - score(left.node.pattern));
   }
+  function firstCandidate(node) {
+    if (!plan) return candidates(node)[0];
+    const scope = plan.nodes.get(node);
+    let best;
+    for (const candidate of all) {
+      if (!candidate.params || candidate.branch !== scope.branch || candidate.start < scope.start || candidate.start >= scope.end
+        || (candidate.node.interception && !canIntercept(candidate))) continue;
+      if (!best || Number(!!candidate.node.interception) > Number(!!best.node.interception)
+        || (!!candidate.node.interception === !!best.node.interception && candidate.score > best.score)) best = candidate;
+    }
+    // Separate request-owned params from the interception/scaffolding candidates,
+    // as in the live traversal. No parameter objects survive this request.
+    return best && { node: best.node, chain: best.chain.slice(scope.depth), params: matchCurrent(best.node.pattern) };
+  }
+  const slotEntries = node => plan?.nodes.get(node).slots || Object.entries(node.slots);
   function scopedParams(node) {
-    const current = matchAppPattern(node.pattern, pathname, true) || (old && matchAppPattern(node.pattern, old.source, true));
+    const current = matchCurrent(node.pattern, true) || (old && matchAppPattern(node.pattern, old.source, true));
     if (current) return current;
     for (const [key, value] of Object.entries(old?.slots || {})) {
       if (!key.startsWith(`${node.path}::`)) continue;
@@ -117,7 +137,7 @@ export function createAdvancedTree(entry, request, searchParams) {
     return registerKey(`${node.path}::${JSON.stringify(scopedParams(node))}`, node, `${node.path}::`);
   }
   function sourceURL(node, previous) {
-    return matchAppPattern(node.pattern, pathname, true) ? pathname + new URL(request.url).search : previous?.source || previous?.url || old?.source || pathname;
+    return matchCurrent(node.pattern, true) ? pathname + new URL(request.url).search : previous?.source || previous?.url || old?.source || pathname;
   }
   function accessURL(url, previous) {
     if (previous?.url === url && previous.accessUrl) return previous.accessUrl;
@@ -148,8 +168,7 @@ export function createAdvancedTree(entry, request, searchParams) {
   function slot(node, owner, name) {
     const key = registerKey(`${scope(owner)}::${name}`, owner, `${owner.path}::`, `::${name}`, ['id']);
     const previous = old?.slots[key];
-    let choices = candidates(node);
-    let selected = rebuild && previous ? savedBranch(node, previous) : choices[0];
+    let selected = rebuild && previous ? savedBranch(node, previous) : firstCandidate(node);
     if (rebuild && previous && !selected) { invalid = true; return { tree: null, segments: [] }; }
     if (!rebuild) {
       for (const candidate of interceptions) {
@@ -189,9 +208,9 @@ export function createAdvancedTree(entry, request, searchParams) {
       // Find the nearest default whose route prefix contains the destination.
       const defaults = [];
       function findDefault(value, chain = []) {
-        if (!matchAppPattern(value.pattern, pathname, true) || (value.interception && !old)) return;
+        if (!matchCurrent(value.pattern, true) || (value.interception && !old)) return;
         const next = [...chain, value];
-        if (value.files.default) defaults.push({ node: value, chain: next, params: matchAppPattern(value.pattern, pathname, true), default: true });
+        if (value.files.default) defaults.push({ node: value, chain: next, params: matchCurrent(value.pattern, true), default: true });
         for (const child of value.children) findDefault(child, next);
       }
       findDefault(node);
@@ -207,9 +226,9 @@ export function createAdvancedTree(entry, request, searchParams) {
     let selectedTree = renderPath(selected.chain, selected, 0, name === 'children' && owner === node);
     const context = request.routingContexts?.get(selectedURL);
     if (context && request.renderRoutingBranch) selectedTree = request.renderRoutingBranch(selectedTree, context);
-    const instant=selected.node.config?.page?.instant ?? [...selected.chain].reverse().find(item=>item.config?.layout?.instant!==undefined)?.config.layout.instant;
-    if(request.instantValidation && name!=='children' && instantEnabled(instant,request.production)){
-      instantTrees.push({path:(owner.path || '/')+' @'+name,tree:selectedTree});
+    if(request.instantValidation && name!=='children'){
+      const instant=selected.node.config?.page?.instant ?? selected.chain.findLast(item=>item.config?.layout?.instant!==undefined)?.config.layout.instant;
+      if(instantEnabled(instant,request.production)) instantTrees.push({path:(owner.path || '/')+' @'+name,tree:selectedTree});
     }
     return { tree: React.createElement(entry.LayoutSlot, { key, id: key, preserve: false }, selectedTree), segments: selected.default ? [] : selectedSegments(selected.chain.slice(node === owner ? 1 : 0), selected.params) };
   }
@@ -248,7 +267,7 @@ export function createAdvancedTree(entry, request, searchParams) {
     const selected = { children: selection.default ? [] : selectedSegments(chain.slice(index + 1), selection.params) };
     if (preserveChild) selected.children = null;
     const parallel = {};
-    for (const [name, child] of Object.entries(node.slots)) {
+    for (const [name, child] of slotEntries(node)) {
       const rendered = slot(child, node, name);
       parallel[name] = rendered.tree; selected[name] = rendered.segments;
     }
@@ -286,7 +305,7 @@ export function createAdvancedTree(entry, request, searchParams) {
       if (layout) metadataItems.push({ module: node.files.layout, params: staticParams(layout.params, currentRequest()), filePath: page ? undefined : node.path, context: layout.context });
       // Next orders paths containing named slots before ordinary children,
       // with slot names in locale order (compareAppPaths in its app loader).
-      for (const [, child] of Object.entries(node.slots).sort(([a], [b]) => a.localeCompare(b))) visit(child);
+      for (const [, child] of plan?.nodes.get(node).metadataSlots || Object.entries(node.slots).sort(([a], [b]) => a.localeCompare(b))) visit(child);
       if (page) metadataItems.push({ module: node.files[page.default ? 'default' : 'page'], params: staticParams(page.params, currentRequest()), searchParams: page.searchParams || searchParams, filePath: node.path, context: request.routingContexts?.get(page.url) });
       for (const child of node.children) visit(child);
     }
@@ -300,7 +319,7 @@ export function createAdvancedTree(entry, request, searchParams) {
   metadataHead = head;
   const main = slot(root, root, 'children');
   const parallel = {}, selected = { children: main.segments };
-  for (const [name, child] of Object.entries(root.slots)) {
+  for (const [name, child] of slotEntries(root)) {
     const result = slot(child, root, name);
     parallel[name] = result.tree; selected[name] = result.segments;
   }
@@ -310,7 +329,7 @@ export function createAdvancedTree(entry, request, searchParams) {
     const content = React.createElement(React.Fragment, null, main.tree, ...Object.values(parallel));
     instantTrees.push({ path: root.path || '/', tree: root.files.loading ? React.createElement(React.Suspense, { fallback: React.createElement(component(root.files.loading, 'loading')) }, content) : content });
   }
-  const instantDisabled = all.flatMap(item => item.chain).some(node => Object.values(node.config || {}).some(config => config.instant && typeof config.instant === 'object' && (config.instant.unstable_disableValidation || (request.production ? config.instant.unstable_disableBuildValidation : config.instant.unstable_disableDevValidation))));
+  const instantDisabled = request.instantValidation && all.some(item => item.chain.some(node => Object.values(node.config || {}).some(config => config.instant && typeof config.instant === 'object' && (config.instant.unstable_disableValidation || (request.production ? config.instant.unstable_disableBuildValidation : config.instant.unstable_disableDevValidation)))));
   let tree = wrap(root, main.tree, parallel, selected, scope(root), {}, rootPage?.chain.slice(1).map(item => item.segment), rootPage?.node);
   if (missing) {
     request.responseStatus = 404;

package/runtime/app-segments.mjs

@@ -1,22 +1,36 @@
+// Weak ownership follows the manifest. Mutable development segment names are
+// re-read, and no request parameter or selected segment value is retained.
+const syntax = new WeakMap();
+function segmentSyntax(segment) {
+  const value = segment.segment || '';
+  const existing = syntax.get(segment);
+  if (existing?.value === value) return existing;
+  const parsed = { value, name: /^\[\[?(?:\.\.\.)?([^\]]+)\]\]?$/.exec(value)?.[1] };
+  if ((typeof segment === 'object' && segment !== null) || typeof segment === 'function') syntax.set(segment, parsed);
+  return parsed;
+}
+
 /** Each layout sees only dynamic parameters declared at or above its segment. */
 export function paramsBySegment(segments, params = {}) {
   const result = new Map();
   const ancestors = Object.create(null);
   for (const segment of segments) {
-    const match = /^\[\[?(?:\.\.\.)?([^\]]+)\]\]?$/.exec(segment.segment || '');
-    if (match && Object.hasOwn(params, match[1])) ancestors[match[1]] = params[match[1]];
+    const { name } = segmentSyntax(segment);
+    if (name && Object.hasOwn(params, name)) ancestors[name] = params[name];
     result.set(segment, { ...ancestors });
   }
   return result;
 }
 
-export function selectedLayoutSegments(segments, params = {}) {
-  return segments.flatMap(segment => {
-    const value = segment.segment || '';
-    if (!value || value.startsWith('@')) return [];
-    const match = /^\[\[?(?:\.\.\.)?([^\]]+)\]\]?$/.exec(value);
-    if (!match) return [value];
-    const parameter = params[match[1]];
-    return parameter === undefined ? [] : [Array.isArray(parameter) ? parameter.join('/') : parameter];
-  });
+export function selectedLayoutSegments(segments, params = {}, start = 0) {
+  const selected = [];
+  for (let index = start, length = segments.length; index < length; index++) {
+    if (!(index in segments)) continue;
+    const { value, name } = segmentSyntax(segments[index]);
+    if (!value || value.startsWith('@')) continue;
+    if (!name) { selected.push(value); continue; }
+    const parameter = params[name];
+    if (parameter !== undefined) selected.push(Array.isArray(parameter) ? parameter.join('/') : parameter);
+  }
+  return selected;
 }

package/runtime/app-static.mjs

@@ -61,7 +61,7 @@ export async function prerenderAppRoute(options) {
             }
             html = completeAppHtml(shell.shell, result.body, { ...options.route, css: [], fonts: [] });
           } else {
-            html = completeAppHtml(await renderHtml(model.tree, model.router, { staticGeneration: true, strictMode: options.manifest?.config?.reactStrictMode !== false }), result.body, options.route);
+            html = completeAppHtml(await renderHtml(model.tree, model.router, { timeoutMs: options.route?.cacheConfig?.maxDuration ? options.route.cacheConfig.maxDuration * 1000 : undefined, staticGeneration: true, strictMode: options.manifest?.config?.reactStrictMode !== false }), result.body, options.route);
           }
         }
         if (staticMetadata(context)?.externalCache) return { dynamic: true, reason: 'External cache handlers require validation on every request' };

package/runtime/app-stream-html.mjs

@@ -1,3 +1,4 @@
+import { htmlEnvelope } from './html-envelope.mjs';
 import React from 'react';
 import { fontPreloads } from './font-preload.mjs';
 import { isDynamicBailout } from '../compat/dynamic-bailout.cjs';
@@ -12,58 +13,6 @@ import { renderAppRecoveryShell } from './app-recovery.mjs';
 import { partialModel } from './app-partial-model.mjs';
 import { streamSelector } from './stream-select.mjs';
 
-// Do not insert bootstrap scripts inside a split HTML tag or raw-text element.
-// React may split a large inline script across arbitrary byte chunks.
-function htmlEnvelope({ resumed = false } = {}) {
-  let pending = '';
-  let closing = '';
-  let received = 0;
-  return {
-    append(text) {
-      received += Buffer.byteLength(text);
-      if (received > MAX_RESPONSE_BYTES) throw new Error('HTML response exceeds the 16 MiB PRNext limit');
-      pending += text;
-      let ready = '';
-      while (pending) {
-        const start = pending.indexOf('<');
-        if (start < 0) { ready += pending; pending = ''; break; }
-        if (start) { ready += pending.slice(0, start); pending = pending.slice(start); }
-        let end = -1;
-        if (pending.startsWith('<!--')) {
-          const comment = pending.indexOf('-->');
-          if (comment >= 0) end = comment + 2;
-        } else {
-          let quote;
-          for (let index = 1; index < pending.length; index++) {
-            const char = pending[index];
-            if (quote) { if (char === quote) quote = undefined; }
-            else if (char === '"' || char === "'") quote = char;
-            else if (char === '>') { end = index; break; }
-          }
-        }
-        if (end < 0) break;
-        const tag = pending.slice(0, end + 1);
-        const raw = /^<(script|style|textarea|title|svg|math)(?:\s|>)/i.exec(tag);
-        if (raw && !tag.endsWith('/>')) {
-          const match = new RegExp(`</${raw[1]}\\s*>`, 'i').exec(pending.slice(end + 1));
-          if (!match) break;
-          end += 1 + match.index + match[0].length;
-          ready += pending.slice(0, end); pending = pending.slice(end);
-        } else {
-          if (/^<\/(body|html)\s*>$/i.test(tag)) closing += tag;
-          else ready += tag;
-          pending = pending.slice(end + 1);
-        }
-      }
-      return ready;
-    },
-    finish() {
-      if (pending || !(resumed ? /^(?:<\/body><\/html>){1,2}$/i : /^<\/body><\/html>$/i).test(closing)) throw new Error('App Router root layout did not close its body and html elements');
-      return resumed ? '</body></html>' : closing;
-    },
-  };
-}
-
 // The SSR decoder and HTML bootstrap share each Flight allocation. Unlike
 // ReadableStream.tee(), this tap stops reading when the HTML consumer stalls.
 // Before a document shell exists, at most the overall 16 MiB response limit can
@@ -113,7 +62,8 @@ function flightTap(source) {
   };
 }
 
-export async function renderProgressiveAppHtml({ result, request, route, responseHeaders, decodeFlight, signal, timeoutMs = 25_000, partial }) {
+export async function renderProgressiveAppHtml({ result, request, route, responseHeaders, decodeFlight, signal, timeoutMs, partial }) {
+  timeoutMs ??= route?.cacheConfig?.maxDuration ? route.cacheConfig.maxDuration * 1000 : 25_000;
   const nonceAttribute = request.nonce ? ` nonce="${escapeHtml(request.nonce)}"` : '';
   const tap = flightTap(result.body);
   const abort = new AbortController();

package/runtime/cache-request.mjs

@@ -1,5 +1,6 @@
 import { runRequestContext, currentRequest } from '../compat/headers.cjs';
 import { flushCacheInvalidations, flushCacheWork } from '../compat/data-cache.cjs';
+import { createAfterScope } from '../compat/after.cjs';
 
 // Keep background fills alive until the transport has sent the response. In
 // particular, serving stale data must not wait for its replacement to finish.
@@ -8,15 +9,22 @@ export function withCacheRequest(options, phase, callback) {
   // only needs metadata, and may survive the response for stale revalidation.
   return runRequestContext({ ...options, body: undefined, routePattern: options.route?.pattern, cacheConfig: options.route?.cacheConfig, phase }, async () => {
     const context = currentRequest();
+    if (phase === 'route' && options.route?.cacheConfig?.runtime !== 'edge') context.afterScope = createAfterScope({ signal: options.signal, timeoutMs: options.timeoutMs ?? (options.route?.cacheConfig?.maxDuration ? options.route.cacheConfig.maxDuration * 1000 : 25000) });
+    let finalized;
+    const finalizeCache = () => finalized ||= (async () => { await context.afterScope?.finish(); await flushCacheWork(context); })();
+    // The worker owns response completion even when application code throws.
+    // Register before invoking it so error responses do not await after().
+    options.deferFinalizer?.(finalizeCache);
     try {
       const response = await callback(context);
       await flushCacheInvalidations(context);
       context.cacheState.closed = true;
       return { ...response,
         ...(context.draftMode || context.draftChanged ? { headers: { ...response.headers, 'cache-control': 'private, no-cache, no-store, max-age=0' } } : {}),
-        finalizeCache: () => flushCacheWork(context) };
+        finalizeCache };
     } catch (error) {
-      await flushCacheWork(context);
+      context.cacheState.closed = true;
+      if (!options.deferFinalizer) await finalizeCache();
       throw error;
     }
   });

package/runtime/cloud/archive.mjs

@@ -0,0 +1,316 @@
+import { lstat, readdir, readFile, realpath, open } from 'node:fs/promises';
+import path from 'node:path';
+import { deflateRawSync } from 'node:zlib';
+import { createHash } from 'node:crypto';
+import picomatch from 'picomatch';
+
+const MiB = 1048576;
+const alwaysExcluded = (name) =>
+  /^(?:node_modules|\.git|\.hg|\.svn|\.next|\.local|\.npm|\.ssh|\.aws|\.azure|\.vercel|coverage|\.DS_Store|__MACOSX)$/i.test(
+    name
+  ) ||
+  /^\.prnext(?:[.-]|$)/i.test(name) ||
+  /^\.env(?:\.|$)/i.test(name) ||
+  /^(?:\.npmrc|\.yarnrc\.yml|\.netrc|id_rsa|id_ed25519)$/i.test(name) ||
+  /\.(?:pem|key|p12|pfx|log|tsbuildinfo)$/i.test(name);
+const crcTable = Array.from({ length: 256 }, (_, n) => {
+  for (let i = 0; i < 8; i++) n = n & 1 ? 0xedb88320 ^ (n >>> 1) : n >>> 1;
+  return n >>> 0;
+});
+const crc32 = (bytes) => {
+  let crc = 0xffffffff;
+  for (const byte of bytes) crc = crcTable[(crc ^ byte) & 255] ^ (crc >>> 8);
+  return (crc ^ 0xffffffff) >>> 0;
+};
+async function ignoreRules(root) {
+  const rules = [];
+  for (const name of ['.gitignore', '.prnextignore']) {
+    const filename = path.join(root, name);
+    let source;
+    try {
+      const stat = await lstat(filename);
+      if (!stat.isFile() || stat.isSymbolicLink() || stat.size > 65536)
+        throw new Error(`${name} must be a regular file of at most 64 KiB.`);
+      source = await readFile(filename, 'utf8');
+    } catch (error) {
+      if (error.code === 'ENOENT') continue;
+      throw error;
+    }
+    for (let pattern of source.split(/\r?\n/)) {
+      pattern = pattern.trim();
+      if (!pattern || pattern.startsWith('#')) continue;
+      const include = pattern.startsWith('!');
+      if (include) pattern = pattern.slice(1);
+      const anchored = pattern.startsWith('/');
+      pattern = pattern.replace(/^\//, '').replace(/\/$/, '');
+      if (!pattern || pattern.length > 512)
+        throw new Error(`Invalid pattern in ${name}.`);
+      const match = picomatch(
+        !anchored && !pattern.includes('/') ? `**/${pattern}` : pattern,
+        { dot: true }
+      );
+      rules.push({
+        include,
+        match,
+        prefix:
+          !anchored && !pattern.includes('/')
+            ? ''
+            : picomatch.scan(pattern).base
+      });
+      if (rules.length > 2000)
+        throw new Error('Too many deployment ignore patterns.');
+    }
+  }
+  const ignored = (name) => {
+    let ignored = false;
+    const parts = name.split('/');
+    const prefixes = parts.map((_, i) => parts.slice(0, i + 1).join('/'));
+    for (const rule of rules)
+      if (prefixes.some((prefix) => rule.match(prefix)))
+        ignored = !rule.include;
+    return ignored;
+  };
+  ignored.canReinclude = (directory) =>
+    rules.some(
+      (rule) =>
+        rule.include &&
+        (!rule.prefix ||
+          rule.prefix === directory ||
+          rule.prefix.startsWith(directory + '/') ||
+          directory.startsWith(rule.prefix + '/'))
+    );
+  return ignored;
+}
+
+/** Build a deterministic, bounded ZIP without following links or running code. */
+export async function archiveProject(
+  directory,
+  {
+    maxArchiveBytes = 7 * MiB,
+    maxSourceBytes = 100 * MiB,
+    maxFileBytes = 15 * MiB,
+    maxFiles = 3000,
+    signal,
+    outputFile
+  } = {}
+) {
+  const root = await realpath(directory);
+  if (outputFile) {
+    const relative = path.relative(root,path.resolve(outputFile));
+    if (!relative || relative !== '..' && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative)) throw new Error('Temporary archive must be outside the project.');
+  }
+  const output = outputFile ? await open(outputFile, 'wx', 0o600) : null;
+  const hash = createHash('sha256');
+  const chunks = [];
+  const append = async (...parts) => {
+    for (const part of parts) { hash.update(part); if (output) await output.writeFile(part); else chunks.push(part); }
+  };
+  try {
+  const ignored = await ignoreRules(root);
+  const files = [],
+    central = [],
+    names = new Set();
+  let expanded = 0,
+    offset = 0,
+    centralSize = 0,
+    visited = 0,
+    excluded = 0,
+    packageJson;
+  async function walk(relative = '') {
+    for (const entry of (
+      await readdir(path.join(root, relative), { withFileTypes: true })
+    ).sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0))) {
+      signal?.throwIfAborted();
+      if (++visited > 20000)
+        throw new Error(
+          'Too many source entries. Deploy a smaller project folder.'
+        );
+      const name = relative ? `${relative}/${entry.name}` : entry.name;
+      if (alwaysExcluded(entry.name)) {
+        excluded++;
+        continue;
+      }
+      if (
+        /[\x00-\x1f\x7f\\:]/.test(name) ||
+        name
+          .split('/')
+          .some(
+            (p) =>
+              p === '..' ||
+              /[. ]$/.test(p) ||
+              /^(con|prn|aux|nul|com[1-9]|lpt[1-9])(?:\.|$)/i.test(p)
+          ) ||
+        Buffer.byteLength(name) > 1024
+      )
+        throw new Error(
+          'A source filename is not portable. Rename files with control characters, backslashes or trailing dots/spaces.'
+        );
+      if (entry.isSymbolicLink()) {
+        if (ignored(name)) {
+          excluded++;
+          continue;
+        }
+        throw new Error(
+          `Symbolic links are not uploaded: ${name}. Exclude it in .prnextignore.`
+        );
+      }
+      if (entry.isDirectory()) {
+        if (ignored(name) && !ignored.canReinclude(name)) {
+          excluded++;
+          continue;
+        }
+        await walk(name);
+        continue;
+      }
+      if (ignored(name)) {
+        excluded++;
+        continue;
+      }
+      if (!entry.isFile())
+        throw new Error(`Only regular source files can be uploaded: ${name}`);
+      if (files.length >= maxFiles)
+        throw new Error(
+          `Source exceeds ${maxFiles} files. Add exclusions to .prnextignore.`
+        );
+      const folded = name.toLowerCase();
+      if (names.has(folded))
+        throw new Error(`Case-conflicting source filename: ${name}`);
+      names.add(folded);
+      const filename = path.join(root, name);
+      const before = await lstat(filename);
+      if (
+        !before.isFile() ||
+        before.isSymbolicLink() ||
+        before.size > maxFileBytes
+      )
+        throw new Error(
+          `Source file is not regular or exceeds ${maxFileBytes / MiB} MiB: ${name}`
+        );
+      if (expanded + before.size > maxSourceBytes)
+        throw new Error(
+          `Expanded sources exceed ${maxSourceBytes / MiB} MiB. Add exclusions to .prnextignore.`
+        );
+      // Recheck identity after opening and after reading to catch concurrent edits.
+      const handle = await open(filename, 'r');
+      let contents;
+      try {
+        const opened = await handle.stat();
+        const current = await lstat(filename);
+        if (
+          current.isSymbolicLink() ||
+          !opened.isFile() ||
+          opened.dev !== before.dev ||
+          opened.ino !== before.ino ||
+          opened.size !== before.size
+        )
+          throw new Error(
+            `Source changed while packaging: ${name}. Try again.`
+          );
+        contents = Buffer.alloc(opened.size);
+        let read = 0;
+        while (read < contents.length) {
+          const next = await handle.read(
+            contents,
+            read,
+            contents.length - read,
+            read
+          );
+          if (!next.bytesRead)
+            throw new Error(
+              `Source changed while packaging: ${name}. Try again.`
+            );
+          read += next.bytesRead;
+        }
+        const after = await handle.stat();
+        if (after.size !== opened.size || after.mtimeMs !== opened.mtimeMs)
+          throw new Error(
+            `Source changed while packaging: ${name}. Try again.`
+          );
+      } finally {
+        await handle.close();
+      }
+      if (name === 'package.json') {
+        try {
+          packageJson = JSON.parse(contents.toString('utf8'));
+        } catch {
+          throw new Error('package.json is not valid JSON.');
+        }
+        if (
+          !packageJson ||
+          typeof packageJson.scripts?.build !== 'string' ||
+          !packageJson.scripts.build.trim()
+        )
+          throw new Error(
+            'Add a production build script to package.json before deploying.'
+          );
+      }
+      let compressed = deflateRawSync(contents, { level: 6 });
+      // The server rejects expansion ratios over 150. Store very repetitive files.
+      const method =
+        compressed.length < contents.length &&
+        contents.length / Math.max(1, compressed.length) <= 140
+          ? 8
+          : 0;
+      if (!method) compressed = contents;
+      const encoded = Buffer.from(name),
+        crc = crc32(contents);
+      const header = Buffer.alloc(30),
+        record = Buffer.alloc(46);
+      header.writeUInt32LE(0x04034b50);
+      header.writeUInt16LE(20, 4);
+      header.writeUInt16LE(0x800, 6);
+      header.writeUInt16LE(method, 8);
+      header.writeUInt16LE(33, 12);
+      header.writeUInt32LE(crc, 14);
+      header.writeUInt32LE(compressed.length, 18);
+      header.writeUInt32LE(contents.length, 22);
+      header.writeUInt16LE(encoded.length, 26);
+      record.writeUInt32LE(0x02014b50);
+      record.writeUInt16LE(0x0314, 4);
+      record.writeUInt16LE(20, 6);
+      record.writeUInt16LE(0x800, 8);
+      record.writeUInt16LE(method, 10);
+      record.writeUInt16LE(33, 14);
+      record.writeUInt32LE(crc, 16);
+      record.writeUInt32LE(compressed.length, 20);
+      record.writeUInt32LE(contents.length, 24);
+      record.writeUInt16LE(encoded.length, 28);
+      record.writeUInt32LE(0x81a40000, 38);
+      record.writeUInt32LE(offset, 42);
+      offset += header.length + encoded.length + compressed.length;
+      centralSize += record.length + encoded.length;
+      if (offset + centralSize + 22 > maxArchiveBytes)
+        throw new Error(
+          `Source archive exceeds ${(maxArchiveBytes / MiB).toFixed(0)} MiB. Exclude unnecessary files in .prnextignore.`
+        );
+      await append(header, encoded, compressed);
+      central.push(record, encoded);
+      files.push(name);
+      expanded += contents.length;
+    }
+  }
+  await walk();
+  if (!packageJson)
+    throw new Error(
+      'The selected directory needs a package.json with a build script; do not exclude it.'
+    );
+  const end = Buffer.alloc(22);
+  end.writeUInt32LE(0x06054b50);
+  end.writeUInt16LE(files.length, 8);
+  end.writeUInt16LE(files.length, 10);
+  end.writeUInt32LE(centralSize, 12);
+  end.writeUInt32LE(offset, 16);
+  await append(...central, end);
+  const buffer = output ? undefined : Buffer.concat(chunks);
+  return {
+    buffer,
+    path: outputFile,
+    size: offset + centralSize + 22,
+    files,
+    expandedBytes: expanded,
+    excluded,
+    digest: hash.digest('hex'),
+    packageJson
+  };
+  } finally { await output?.close(); }
+}