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

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

@@ -62,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(); }
+}