@thomas.f/prnext 0.1.0-alpha.1

package/runtime/pages-paths.mjs

@@ -0,0 +1,80 @@
+import { localePath, withLocale } from '../compat/locale.cjs';
+function validSegment(value, name = 'route') {
+  if (typeof value !== 'string' || !value || value === '.' || value === '..' || /[\\/\u0000-\u001f\u007f]/.test(value)) {
+    throw new Error(`getStaticPaths parameter ${name} must be a nonempty string without path separators, traversal, or control characters.`);
+  }
+  return value;
+}
+
+const parameter = /^\[(\[)?(\.\.\.)?([^\]]+)\]\]?$/;
+
+export function staticPath(pattern, value) {
+  const patternSegments = pattern === '/' ? [] : pattern.split('/').slice(1);
+  if (typeof value === 'string') {
+    if (!value.startsWith('/') || value.startsWith('//') || value.includes('?') || value.includes('#')) {
+      throw new Error(`getStaticPaths returned an invalid pathname: ${value}`);
+    }
+    const normalized = value === '/' ? '/' : value.replace(/\/+$/, '');
+    const pathSegments = normalized === '/' ? [] : normalized.split('/').slice(1).map(part => validSegment(decodeURIComponent(part)));
+    const params = {};
+    let cursor = 0;
+    for (const segment of patternSegments) {
+      const match = parameter.exec(segment);
+      if (!match) {
+        if (segment !== pathSegments[cursor++]) throw new Error(`getStaticPaths pathname ${value} does not match ${pattern}.`);
+      } else {
+        let supplied;
+        if (match[2]) {
+          supplied = pathSegments.slice(cursor);
+          if (!supplied.length && !match[1]) throw new Error(`getStaticPaths pathname ${value} needs at least one ${match[3]} segment.`);
+          cursor = pathSegments.length;
+        } else {
+          if (cursor >= pathSegments.length) throw new Error(`getStaticPaths pathname ${value} is missing parameter ${match[3]}.`);
+          supplied = pathSegments[cursor++];
+        }
+        Object.defineProperty(params, match[3], { value: supplied, enumerable: true, configurable: true, writable: true });
+      }
+    }
+    if (cursor !== pathSegments.length) throw new Error(`getStaticPaths pathname ${value} does not match ${pattern}.`);
+    return { path: '/' + pathSegments.map(encodeURIComponent).join('/'), params };
+  }
+  if (!value || typeof value !== 'object' || Array.isArray(value) || !value.params ||
+      typeof value.params !== 'object' || Array.isArray(value.params) || value.locale) {
+    throw new Error('getStaticPaths entries must be path strings or {params:{...}} objects. Locales are not supported yet.');
+  }
+  const params = value.params;
+  const segments = patternSegments.flatMap(segment => {
+    const match = parameter.exec(segment);
+    if (!match) return [encodeURIComponent(validSegment(segment))];
+    const supplied = Object.hasOwn(params, match[3]) ? params[match[3]] : undefined;
+    if (match[2]) {
+      if (match[1] && (supplied === undefined || supplied === null || supplied === false)) return [];
+      if (!Array.isArray(supplied) || (!supplied.length && !match[1])) {
+        throw new Error(`getStaticPaths parameter ${match[3]} must be ${match[1] ? 'an array of strings' : 'a nonempty array of strings'}.`);
+      }
+      return Array.from(supplied, value => encodeURIComponent(validSegment(value, match[3])));
+    }
+    return [encodeURIComponent(validSegment(supplied, match[3]))];
+  });
+  return { path: '/' + segments.join('/'), params };
+}
+
+export function validateStaticPaths(pattern, result) {
+  if (!result || typeof result !== 'object' || !Array.isArray(result.paths) || ![false, true, 'blocking'].includes(result.fallback)) {
+    throw new Error(`getStaticPaths for ${pattern} must return {paths: [...], fallback: false | true | 'blocking'}.`);
+  }
+  return { paths: result.paths.map(value => staticPath(pattern, value)), fallback: result.fallback };
+}
+
+export function localizedStaticPaths(route, result, i18n) {
+  if(!route.locale) return validateStaticPaths(route.pattern,result);
+  if(!result||!Array.isArray(result.paths)) return validateStaticPaths(route.originalPattern,result);
+  const paths=[];
+  for(const value of result.paths){
+    const parsed=typeof value==='string'?localePath(value,i18n):{locale:value?.locale||i18n.defaultLocale};
+    if(!i18n.locales.includes(parsed.locale))throw new Error(`getStaticPaths returned unknown locale ${parsed.locale}`);
+    if(parsed.locale===route.locale)paths.push(typeof value==='string'?parsed.pathname:{params:value.params});
+  }
+  const validated=validateStaticPaths(route.originalPattern,{...result,paths});
+  return {...validated,paths:validated.paths.map(entry=>({...entry,path:withLocale(entry.path,route.locale,i18n.defaultLocale)}))};
+}

package/runtime/pages-revalidate.mjs

@@ -0,0 +1,33 @@
+import { nativeFetch, optionalRequestContext } from '../compat/data-cache.cjs';
+import { removeBasePath } from '../compat/paths.cjs';
+
+export async function revalidatePage(response, pathname, options = {}) {
+  if (!response._canRevalidate) throw new Error('res.revalidate() is only available in Pages API routes');
+  if (response.headersSent || response.writableEnded) throw new Error('res.revalidate() must be called before sending response headers');
+  if (typeof pathname !== 'string' || !pathname.startsWith('/') || pathname.startsWith('//') || /[\\\x00-\x1f\x7f]/.test(pathname)) {
+    throw new TypeError('res.revalidate() requires an absolute application path, such as /posts/1');
+  }
+  if (!options || typeof options !== 'object' || Array.isArray(options) ||
+      (options.unstable_onlyGenerated !== undefined && typeof options.unstable_onlyGenerated !== 'boolean')) {
+    throw new TypeError('res.revalidate() options.unstable_onlyGenerated must be a boolean');
+  }
+  const url = process.env.PRNEXT_CACHE_URL;
+  const token = process.env.PRNEXT_CACHE_TOKEN;
+  if (!url || !token) throw new Error('res.revalidate() requires a running PRNext server');
+  const context = optionalRequestContext();
+  const path = removeBasePath(new URL(pathname, 'http://prnext.local').pathname, context?.basePath || '');
+  const signal = response._revalidateSignal || context?.signal;
+  const timeout = AbortSignal.timeout(25_000);
+  const result = await nativeFetch(new URL('/pages/revalidate', url), {
+    method: 'POST',
+    headers: { 'content-type': 'application/json', authorization: `Bearer ${token}` },
+    body: JSON.stringify({ path, ...(options.unstable_onlyGenerated === undefined ? {} : { onlyGenerated: options.unstable_onlyGenerated }) }),
+    signal: signal ? AbortSignal.any([signal, timeout]) : timeout,
+  });
+  if (!result.ok) {
+    await result.body?.cancel();
+    throw new Error(`Failed to revalidate ${path} (${result.status})`);
+  }
+  const value = await result.json();
+  if (typeof value?.revalidated !== 'boolean') throw new Error('Invalid PRNext page revalidation response');
+}

package/runtime/partial-artifact-cache.mjs

@@ -0,0 +1,37 @@
+// Memoize parsing only AFTER the authoritative data cache returned its bytes.
+// Comparing exact bytes preserves expiry and invalidation even for the same key.
+// Never store live React models, request contexts, cookies or headers here.
+import { createHash } from 'node:crypto';
+
+export class PartialArtifactCache {
+  constructor({ maxEntries = 16, maxBytes = 256 * 1024, maxEntryBytes = 64 * 1024 } = {}) {
+    this.entries = new Map(); this.bytes = 0;
+    this.maxEntries = maxEntries; this.maxBytes = maxBytes; this.maxEntryBytes = maxEntryBytes;
+  }
+  parse(key, bytes) {
+    const hit = this.entries.get(key);
+    if (hit && hit.bytes.equals(bytes)) {
+      this.entries.delete(key); this.entries.set(key, hit);
+      return hit.value;
+    }
+    const value = JSON.parse(bytes.toString());
+    if (hit) { this.entries.delete(key); this.bytes -= hit.bytes.length; }
+    if (bytes.length <= this.maxEntryBytes && bytes.length <= this.maxBytes && this.maxEntries > 0) {
+      while (this.entries.size && (this.entries.size >= this.maxEntries || this.bytes + bytes.length > this.maxBytes)) {
+        const [oldKey, old] = this.entries.entries().next().value;
+        this.entries.delete(oldKey); this.bytes -= old.bytes.length;
+      }
+      // Own compact storage; a cache RPC buffer can share a much larger slab.
+      const owned = Buffer.allocUnsafeSlow(bytes.length); bytes.copy(owned);
+      this.entries.set(key, { bytes: owned, value }); this.bytes += owned.length;
+    }
+    return value;
+  }
+}
+
+const identities = new WeakMap();
+export function partialIdentity(artifact) {
+  let identity = identities.get(artifact);
+  if (!identity) { identity = createHash('sha256').update(artifact.flight).digest('hex'); identities.set(artifact, identity); }
+  return identity;
+}

package/runtime/partial-template.mjs

@@ -0,0 +1,174 @@
+// Retain only replayable static values, never React decoder chunks (which can
+// retain their response), streams, server functions or request contexts.
+import { withSignal } from './stream-utils.mjs';
+import { isPartialHole } from './app-partial-model.mjs';
+const LAZY = Symbol.for('react.lazy');
+const CLIENT = Symbol.for('react.client.reference');
+const directModels = new WeakSet();
+const values = new WeakMap();
+const holes = new WeakSet();
+const reusable = new WeakMap();
+const holeError = Object.assign(new Error('Partial request data'), { digest: 'PRNEXT_PPR_DYNAMIC' });
+function throwHole() { throw holeError; }
+const holeLazy = () => { const value = { $$typeof: LAZY, _payload: {}, _init: throwHole }; holes.add(value); return value; };
+class Unreplayable extends Error {}
+// Factories at module scope cannot close over a snapshot's signal or decoder.
+const readyLazy = value => { const copy = { $$typeof: LAZY, _payload: {}, _init() { return value; } }; values.set(copy, value); return copy; };
+const readyPromise = value => { const copy = { then(resolve) { return resolve(value); } }; values.set(copy, value); return copy; };
+
+// Only proven root replacements can consume the original React model directly.
+// A nested hole needs the ordinary Flight decoder to locate a server component's
+// rendered children. Cycles, bindings and advanced routing stay on that path.
+function rootReplacementsOnly(model) {
+  if (!model || Object.getPrototypeOf(model) !== Object.prototype || model.routing || model.keyScopes?.some(scope => scope.liveProps?.length)) return false;
+  const seen = new WeakMap();
+  function classify(value) {
+    if (!value || typeof value !== 'object') return 'static';
+    if (holes.has(value)) return 'hole';
+    if (seen.has(value)) return seen.get(value);
+    seen.set(value, 'nested');
+    let result;
+    if (values.has(value)) result = classify(values.get(value));
+    else {
+      const children = value instanceof Map ? [...value].flat() : value instanceof Set ? [...value] : Object.values(value);
+      result = children.every(child => classify(child) === 'static') ? 'static' : 'nested';
+    }
+    seen.set(value, result); return result;
+  }
+  return Object.values(model).every(value => classify(value) !== 'nested');
+}
+
+export function canResumePartialDirectly(model) { return directModels.has(model); }
+
+// Classify static subtrees once, while no request exists. A subtree with a hole,
+// a live prop binding or a cycle must be copied/merged in the ordinary way.
+// Key remapping is decided per navigation, without retaining its request here.
+function classifyReusable(model) {
+  const entries = new WeakMap();
+  const bindings = new Set((model.keyScopes || []).filter(scope => scope.liveProps?.length).map(scope => scope.key));
+  const empty = [];
+  function visit(value) {
+    if (!value || typeof value !== 'object') return empty;
+    if (entries.has(value)) return entries.get(value);
+    entries.set(value, null);
+    if (holes.has(value) || value.$$typeof === Symbol.for('react.transitional.element') && bindings.has(value.key)) return null;
+    const children = values.has(value) ? [values.get(value)] : value instanceof Map ? [...value].flat() : value instanceof Set ? [...value] : Object.values(value);
+    const keys = new Set(value.$$typeof === Symbol.for('react.transitional.element') && value.key !== null ? [value.key] : []);
+    let stable = true;
+    for (const child of children) {
+      const nested = visit(child);
+      if (nested === null) stable = false;
+      else for (const key of nested) keys.add(key);
+    }
+    const result = stable ? keys.size ? [...keys] : empty : null;
+    entries.set(value, result);
+    return result;
+  }
+  visit(model);
+  return entries;
+}
+export function partialTemplateReuse(model, keyMap) {
+  const entries = reusable.get(model);
+  if (!entries) return undefined;
+  return value => {
+    if (value === model) return false; // The root receives this request's router.
+    const keys = entries.get(value);
+    return keys !== undefined && keys !== null && (!keyMap?.size || keys.every(key => !keyMap.has(key)));
+  };
+}
+
+export async function snapshotPartialTemplate(model, signal) {
+  const seen = new WeakMap();
+  let nodes = 0;
+  async function visit(value, depth = 0) {
+    signal?.throwIfAborted();
+    if (typeof value === 'function') {
+      if (value.$$typeof === CLIENT) return { value };
+      throw new Unreplayable('Function retains decoder state');
+    }
+    if (!value || typeof value !== 'object') return { value };
+    if (seen.has(value)) {
+      const copy = seen.get(value);
+      if (copy === undefined) throw new Unreplayable('Unresolved lazy cycle');
+      return { value: copy };
+    }
+    if (++nodes > 4096 || depth > 128) throw new Unreplayable('Template complexity limit');
+    seen.set(value, undefined);
+    if (value.$$typeof === LAZY || typeof value.then === 'function') {
+      let resolved;
+      try {
+        if (value.$$typeof === LAZY) {
+          for (;;) {
+            signal?.throwIfAborted();
+            try { resolved = value._init(value._payload); break; }
+            catch (error) { if (typeof error?.then !== 'function') throw error; await withSignal(error, signal); }
+          }
+        } else resolved = await withSignal(value, signal);
+      } catch (error) {
+        if (!isPartialHole(error)) throw new Unreplayable('Errored static value');
+        const copy = value.$$typeof === LAZY ? holeLazy() : { then: rejectHole };
+        holes.add(copy);
+        seen.set(value, copy); return { value: copy };
+      }
+      const resolvedCopy = (await visit(resolved, depth + 1)).value;
+      const copy = value.$$typeof === LAZY ? readyLazy(resolvedCopy) : readyPromise(resolvedCopy);
+      seen.set(value, copy); return { value: copy };
+    }
+    let copy;
+    if (value instanceof Date) copy = new Date(value);
+    else if (value instanceof ArrayBuffer) copy = value.slice(0);
+    else if (ArrayBuffer.isView(value)) throw new Unreplayable('Keep typed-array backing identities in the ordinary decoder');
+    else if (value instanceof Map) copy = new Map();
+    else if (value instanceof Set) copy = new Set();
+    else if (Array.isArray(value)) copy = [];
+    else if ([Object.prototype, null].includes(Object.getPrototypeOf(value))) copy = Object.create(Object.getPrototypeOf(value));
+    else throw new Unreplayable('Stream or non-replayable prototype');
+    seen.set(value, copy);
+    if (value instanceof Map) for (const [key, item] of value) copy.set((await visit(key, depth + 1)).value, (await visit(item, depth + 1)).value);
+    else if (value instanceof Set) for (const item of value) copy.add((await visit(item, depth + 1)).value);
+    else if (!(value instanceof Date) && !(value instanceof ArrayBuffer)) for (const key of Object.keys(value)) Object.defineProperty(copy, key, { value: (await visit(value[key], depth + 1)).value, enumerable: true, writable: true, configurable: true });
+    // Box thenables so this async walk does not accidentally assimilate them.
+    return { value: copy };
+  }
+  const copy = (await visit(model)).value;
+  if (rootReplacementsOnly(copy)) directModels.add(copy);
+  if (copy && typeof copy === 'object') reusable.set(copy, classifyReusable(copy));
+  return { model: copy, nodes };
+}
+function rejectHole(_resolve, reject) { return reject(holeError); }
+
+export class PartialTemplates {
+  constructor({ maxEntries = 8, maxBytes = 512 * 1024, maxWireBytes = 64 * 1024 } = {}) {
+    this.entries = new Map(); this.bytes = 0;
+    this.maxEntries = maxEntries; this.maxBytes = maxBytes; this.maxWireBytes = maxWireBytes;
+  }
+  async get(flight, consumer, decode, signal) {
+    const previous = this.entries.get(flight);
+    if (previous && previous.moduleMap === consumer.moduleMap && previous.serverModuleMap === consumer.serverModuleMap) {
+      this.entries.delete(flight); this.entries.set(flight, previous);
+      return previous.bypass ? decode() : previous.model;
+    }
+    const decoded = await decode();
+    if (flight.length > this.maxWireBytes || this.maxEntries === 0) return decoded;
+    let snapshot;
+    try { snapshot = await snapshotPartialTemplate(decoded, signal); }
+    catch (error) {
+      signal?.throwIfAborted();
+      if (!(error instanceof Unreplayable)) throw error;
+      snapshot = { nodes: 0, bypass: true };
+    }
+    // Budget the encoded string conservatively plus a per-node allowance.
+    // This is a retention policy, not a promise about V8's exact heap size.
+    const size = flight.length * 2 + snapshot.nodes * 128;
+    if (size > this.maxBytes) return decoded;
+    const old = this.entries.get(flight);
+    if (old) { this.entries.delete(flight); this.bytes -= old.size; }
+    while (this.entries.size && (this.entries.size >= this.maxEntries || this.bytes + size > this.maxBytes)) {
+      const [key, entry] = this.entries.entries().next().value;
+      this.entries.delete(key); this.bytes -= entry.size;
+    }
+    this.entries.set(flight, { moduleMap: consumer.moduleMap, serverModuleMap: consumer.serverModuleMap, model: snapshot.model, bypass: snapshot.bypass, size });
+    this.bytes += size;
+    return snapshot.bypass ? decoded : snapshot.model;
+  }
+}

package/runtime/profile.mjs

@@ -0,0 +1,9 @@
+import presets from './profiles.json' with { type: 'json' };
+
+export function runtimeProfile(environment = process.env, production = environment.NODE_ENV !== 'development') {
+  const requested = environment.PRNEXT_PROFILE || (environment.PRNEXT_MEMORY_PROFILE === 'compact' ? 'compact' : 'balanced');
+  const name = requested === 'standard' ? 'classic' : requested;
+  if (!Object.hasOwn(presets, name)) throw new Error(`Unknown runtime profile ${JSON.stringify(name)}; use ${Object.keys(presets).join(', ')}`);
+  const effective = production ? name : 'classic';
+  return { name: effective, ...presets[effective] };
+}

package/runtime/profiles.json

@@ -0,0 +1,47 @@
+{
+  "classic": {
+    "optimizeForSize": false,
+    "semiSpaceMiB": null,
+    "youngGenerationMiB": 16,
+    "renderStarts": 16,
+    "liveResponses": 32,
+    "apiConcurrency": 512,
+    "responseBufferMiB": 8
+  },
+  "compact": {
+    "optimizeForSize": true,
+    "semiSpaceMiB": 4,
+    "youngGenerationMiB": 8,
+    "renderStarts": 16,
+    "liveResponses": 32,
+    "apiConcurrency": 512,
+    "responseBufferMiB": 8
+  },
+  "balanced": {
+    "optimizeForSize": true,
+    "semiSpaceMiB": 8,
+    "youngGenerationMiB": 16,
+    "renderStarts": 16,
+    "liveResponses": 32,
+    "apiConcurrency": 256,
+    "responseBufferMiB": 4
+  },
+  "speed": {
+    "optimizeForSize": false,
+    "semiSpaceMiB": 16,
+    "youngGenerationMiB": 32,
+    "renderStarts": 32,
+    "liveResponses": 128,
+    "apiConcurrency": 512,
+    "responseBufferMiB": 16
+  },
+  "memory": {
+    "optimizeForSize": true,
+    "semiSpaceMiB": 2,
+    "youngGenerationMiB": 4,
+    "renderStarts": 8,
+    "liveResponses": 16,
+    "apiConcurrency": 64,
+    "responseBufferMiB": 1
+  }
+}