@wular/pnext 0.0.1

package/src/compat/next/font/shared.ts

@@ -0,0 +1,281 @@
+/**
+ * Client-safe font naming/hashing logic shared by the server font runtime
+ * (runtime.ts) and the client font runtime (runtime-client.ts).
+ *
+ * MUST stay free of `node:*` imports (no async_hooks / crypto / fs / module) so
+ * it can be pulled into browser bundles. The SHA-256 here is a pure-JS
+ * implementation whose hex output is byte-identical to
+ * `node:crypto.createHash('sha256').update(value).digest('hex')`, so the
+ * className/variable hashes a client component computes match the server's
+ * exactly.
+ */
+
+export type FontDisplay = 'auto' | 'block' | 'swap' | 'fallback' | 'optional';
+
+export interface GoogleFontOptions {
+  axes?: string[];
+  adjustFontFallback?: boolean;
+  display?: FontDisplay;
+  fallback?: string[];
+  preload?: boolean;
+  subsets?: string[];
+  style?: string | string[];
+  variable?: string;
+  weight?: string | string[];
+}
+
+export interface LocalFontSource {
+  path: string;
+  style?: string;
+  weight?: string;
+}
+
+export interface LocalFontOptions {
+  declarations?: { prop: string; value: string }[];
+  display?: FontDisplay;
+  fallback?: string[];
+  preload?: boolean;
+  src: string | LocalFontSource | LocalFontSource[];
+  style?: string;
+  variable?: string;
+  weight?: string;
+}
+
+export interface NextFont {
+  className: string;
+  style: {
+    fontFamily: string;
+    fontStyle?: string;
+    fontWeight?: number | string;
+  };
+}
+
+export interface NextFontWithVariable extends NextFont {
+  variable: string;
+}
+
+/**
+ * The pre-hashed identifiers + style a client only ever needs off a font object.
+ * Both runtimes derive these from the same inputs, so they agree byte-for-byte.
+ */
+export interface FontNaming {
+  className: string;
+  variable: string;
+  style: NextFont['style'];
+  /** Human-readable CSS family label (single, unquoted). */
+  fontFamily: string;
+  /** 12-char hash used for `__className_<hash>` / `__variable_<hash>`. */
+  hash: string;
+  /** Whether the loader call requested a CSS variable. When false the returned
+   * font object omits the `variable` key entirely (Next only exposes it when
+   * `variable` was passed). */
+  hasVariable: boolean;
+}
+
+/** Naming for a `next/font/google` loader call: keyed on `{family, options}`. */
+export function googleFontNaming(family: string, options: GoogleFontOptions): FontNaming {
+  const normalizedKey = stableJson({ family, options });
+  const hash = hashString(normalizedKey).slice(0, 12);
+  // Next scopes the family to the human-readable font name (`'Inter'`), not a
+  // hashed token; only the className/variable identifiers are hashed.
+  const fontFamily = family;
+  return {
+    className: `__className_${hash}`,
+    variable: `__variable_${hash}`,
+    fontFamily,
+    hash,
+    hasVariable: Boolean(options.variable),
+    style: fontStyle(fontFamily, options, options.fallback ?? []),
+  };
+}
+
+/**
+ * Naming for a `next/font/local` loader call: keyed on `{callerFile, options}`.
+ * `callerFile` MUST be the same value the server sees (the transform threads it
+ * via `withFile(<file>)`), or the hashes diverge.
+ */
+export function localFontNaming(
+  callerFile: string | undefined,
+  options: LocalFontOptions,
+): FontNaming {
+  const normalizedKey = stableJson({ callerFile, options });
+  const hash = hashString(normalizedKey).slice(0, 12);
+  // Next derives the CSS font-family from the loader call's JS binding
+  // (`variableName`). We reproduce the same human-readable label from the
+  // (first) source filename stem: `font1_roboto.woff2` -> `font1`.
+  const fontFamily = localFontFamilyLabel(options) ?? `local_${hash}`;
+  return {
+    className: `__className_${hash}`,
+    variable: `__variable_${hash}`,
+    fontFamily,
+    hash,
+    hasVariable: Boolean(options.variable),
+    style: fontStyle(fontFamily, options, options.fallback ?? []),
+  };
+}
+
+/** Human-readable family label from the first local `src` filename stem. */
+export function localFontFamilyLabel(options: LocalFontOptions): string | undefined {
+  const first = Array.isArray(options.src) ? options.src[0] : options.src;
+  const srcPath = typeof first === 'string' ? first : first?.path;
+  if (!srcPath) return undefined;
+  const base = srcPath.replace(/^.*[\\/]/, '').replace(/\.[^.]+$/, '');
+  const stem = base.split('_', 1)[0] ?? base;
+  return /^[-_a-zA-Z0-9 ]+$/.test(stem) ? stem : undefined;
+}
+
+export function fontStyle(
+  family: string,
+  options: GoogleFontOptions | LocalFontOptions,
+  fallbackFonts: string[],
+): NextFont['style'] {
+  // Next exports numeric font-weight and the raw font-style, but only when a
+  // single (non-range) value is set on the loader call.
+  const weight =
+    typeof options.weight === 'string' && !isRangeValue(options.weight) && !Number.isNaN(Number(options.weight))
+      ? { fontWeight: Number(cssIdentifier(options.weight)) }
+      : {};
+  const style =
+    typeof options.style === 'string' && !isRangeValue(options.style)
+      ? { fontStyle: cssIdentifier(options.style) }
+      : {};
+  return {
+    fontFamily: familyStack(family, fallbackFonts),
+    ...weight,
+    ...style,
+  };
+}
+
+/**
+ * The full family stack Next writes into `style.fontFamily`: the font, then an
+ * `<family> Fallback` metrics-adjusted fallback (adjustFontFallback defaults
+ * on), then any user fallbacks. Single-quoted to match Next's postcss output.
+ */
+export function familyStack(family: string, fallbackFonts: string[] = [], adjustFontFallback = true) {
+  return [
+    singleQuoteFamily(family),
+    ...(adjustFontFallback ? [singleQuoteFamily(`${family} Fallback`)] : []),
+    ...fallbackFonts.map(singleQuoteFamily),
+  ].join(', ');
+}
+
+export function singleQuoteFamily(value: string) {
+  if (!/^[-_a-zA-Z0-9 ]+$/.test(value)) throw new Error(`Invalid font family: ${value}`);
+  return `'${value}'`;
+}
+
+function cssIdentifier(value: string) {
+  if (!/^[-_a-zA-Z0-9. ]+$/.test(value)) throw new Error(`Invalid font option value: ${value}`);
+  return value;
+}
+
+function isRangeValue(value: string) {
+  return value.trim().includes(' ');
+}
+
+export function stableJson(value: unknown): string {
+  return JSON.stringify(sortObject(value));
+}
+
+function sortObject(value: unknown): unknown {
+  if (Array.isArray(value)) return value.map(sortObject);
+  if (!value || typeof value !== 'object') return value;
+  return Object.fromEntries(
+    Object.entries(value as Record<string, unknown>)
+      .filter(([, item]) => item !== undefined)
+      .sort(([a], [b]) => a.localeCompare(b))
+      .map(([key, item]) => [key, sortObject(item)]),
+  );
+}
+
+/**
+ * SHA-256 hex digest of a UTF-8 string. Pure JS (no `node:crypto`) so this
+ * module stays browser-safe; the hex output is byte-identical to
+ * `createHash('sha256').update(value).digest('hex')`, keeping client and server
+ * font hashes in lock-step.
+ */
+export function hashString(value: string): string {
+  return sha256Hex(utf8Bytes(value));
+}
+
+function utf8Bytes(value: string): Uint8Array {
+  // TextEncoder is available in browsers and in Node/Bun.
+  return new TextEncoder().encode(value);
+}
+
+const K = new Uint32Array([
+  0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+  0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+  0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+  0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+  0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+  0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+  0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+  0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
+]);
+
+function sha256Hex(message: Uint8Array): string {
+  const h = new Uint32Array([
+    0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,
+  ]);
+
+  const bitLen = message.length * 8;
+  // Padded length: message + 0x80 + zeros + 8-byte length, up to a 64-byte block.
+  const padded = new Uint8Array((((message.length + 8) >> 6) + 1) << 6);
+  padded.set(message);
+  padded[message.length] = 0x80;
+  // 64-bit big-endian bit length in the final 8 bytes (high 32 bits ~always 0
+  // for our short inputs, but write both halves for correctness).
+  const dv = new DataView(padded.buffer);
+  dv.setUint32(padded.length - 8, Math.floor(bitLen / 0x100000000));
+  dv.setUint32(padded.length - 4, bitLen >>> 0);
+
+  const w = new Uint32Array(64);
+  for (let offset = 0; offset < padded.length; offset += 64) {
+    for (let i = 0; i < 16; i++) w[i] = dv.getUint32(offset + i * 4);
+    for (let i = 16; i < 64; i++) {
+      const w15 = w[i - 15]!;
+      const w2 = w[i - 2]!;
+      const s0 = rotr(w15, 7) ^ rotr(w15, 18) ^ (w15 >>> 3);
+      const s1 = rotr(w2, 17) ^ rotr(w2, 19) ^ (w2 >>> 10);
+      w[i] = (w[i - 16]! + s0 + w[i - 7]! + s1) >>> 0;
+    }
+
+    let a = h[0]!, b = h[1]!, c = h[2]!, d = h[3]!;
+    let e = h[4]!, f = h[5]!, g = h[6]!, hh = h[7]!;
+
+    for (let i = 0; i < 64; i++) {
+      const S1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
+      const ch = (e & f) ^ (~e & g);
+      const t1 = (hh + S1 + ch + K[i]! + w[i]!) >>> 0;
+      const S0 = rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22);
+      const maj = (a & b) ^ (a & c) ^ (b & c);
+      const t2 = (S0 + maj) >>> 0;
+      hh = g;
+      g = f;
+      f = e;
+      e = (d + t1) >>> 0;
+      d = c;
+      c = b;
+      b = a;
+      a = (t1 + t2) >>> 0;
+    }
+
+    h[0] = (h[0]! + a) >>> 0;
+    h[1] = (h[1]! + b) >>> 0;
+    h[2] = (h[2]! + c) >>> 0;
+    h[3] = (h[3]! + d) >>> 0;
+    h[4] = (h[4]! + e) >>> 0;
+    h[5] = (h[5]! + f) >>> 0;
+    h[6] = (h[6]! + g) >>> 0;
+    h[7] = (h[7]! + hh) >>> 0;
+  }
+
+  let hex = '';
+  for (let i = 0; i < 8; i++) hex += h[i]!.toString(16).padStart(8, '0');
+  return hex;
+}
+
+function rotr(value: number, bits: number): number {
+  return ((value >>> bits) | (value << (32 - bits))) >>> 0;
+}

package/src/compat/next/form.tsx

@@ -0,0 +1,156 @@
+'use client';
+
+import { useEffect, useRef, type JSX, type ReactNode } from 'preact/compat';
+import { prefetchRoute, softNavigate } from '../../api/router';
+import { addBasePath } from '../client/base-path';
+
+type FormAction = string | ((formData: FormData) => void | Promise<void>);
+export type FormProps = Omit<JSX.HTMLAttributes<HTMLFormElement>, 'action' | 'method'> & {
+  action: FormAction;
+  replace?: boolean;
+  scroll?: boolean;
+  prefetch?: boolean;
+  children?: ReactNode;
+};
+
+export default function Form({
+  action,
+  replace,
+  scroll,
+  prefetch,
+  onSubmit,
+  children,
+  ...formProps
+}: FormProps) {
+  const formRef = useRef<HTMLFormElement | null>(null);
+  const stringAction = typeof action === 'string' ? action : undefined;
+  const basePathAction = stringAction == null ? undefined : addBasePath(stringAction);
+
+  // Function actions are React form actions; pass through untouched so the
+  // renderer wires them (no soft-nav interception, no GET semantics).
+
+  useEffect(() => {
+    if (basePathAction == null || prefetch === false) return;
+    // No prefetch in dev (per-request rendering); prefetchRoute already no-ops.
+    // Register the form element so a revalidation-triggered retry re-prefetches
+    // visible forms exactly like visible links (the router reads its `action`).
+    void prefetchRoute(basePathAction, { element: formRef.current ?? undefined });
+  }, [basePathAction, prefetch]);
+
+  if (typeof action !== 'string') {
+    return (
+      <form ref={formRef} action={action as never} onSubmit={onSubmit} {...formProps}>
+        {children}
+      </form>
+    );
+  }
+
+  const handleSubmit = (event: JSX.TargetedSubmitEvent<HTMLFormElement>) => {
+    onSubmit?.(event);
+    if (event.defaultPrevented) return;
+
+    const form = event.currentTarget;
+    const submitter = (event as unknown as { submitter?: HTMLElement }).submitter as
+      | HTMLButtonElement
+      | HTMLInputElement
+      | undefined;
+
+    // A submitter that sets encType/method/target to a non-default value isn't
+    // supported for soft-nav; fall back to the browser's native submit.
+    if (submitter && hasUnsupportedSubmitterAttr(submitter)) return;
+    if (submitter && hasReactClientActionAttributes(submitter)) return;
+
+    event.preventDefault();
+
+    const submitterAction = submitter?.getAttribute('formaction');
+    const target = submitterAction != null ? submitterAction : addBasePath(action);
+    const destination = createFormSubmitDestinationUrl(target, form);
+
+    void softNavigate(destination.href, { replace, scroll });
+  };
+
+  return (
+    <form
+      ref={formRef}
+      action={addBasePath(action)}
+      method="get"
+      onSubmit={handleSubmit}
+      {...formProps}
+    >
+      {children}
+    </form>
+  );
+}
+
+export { Form };
+
+// encType/method/target set to a non-default value can't be honored by a
+// soft-nav GET; detect and warn so the caller falls back to native submit.
+const SUBMITTER_ATTRS: { attr: string; name: string; defaults: string[] }[] = [
+  { attr: 'formEncType', name: 'encType', defaults: ['application/x-www-form-urlencoded'] },
+  { attr: 'formMethod', name: 'method', defaults: ['get'] },
+  { attr: 'formTarget', name: 'target', defaults: ['', '_self'] },
+];
+
+function hasUnsupportedSubmitterAttr(submitter: HTMLButtonElement | HTMLInputElement) {
+  for (const { attr, name, defaults } of SUBMITTER_ATTRS) {
+    const raw = submitter.getAttribute(attr) ?? submitter.getAttribute(attr.toLowerCase());
+    if (raw == null || raw === '') continue;
+    if (defaults.includes(raw.toLowerCase())) continue;
+    reportUnsupportedAttr(name);
+    return true;
+  }
+  return false;
+}
+
+function hasReactClientActionAttributes(submitter: HTMLElement) {
+  const name = submitter.getAttribute('name');
+  return Boolean(name && (name.startsWith('$ACTION_ID_') || name.startsWith('$ACTION_REF_')));
+}
+
+function createFormSubmitDestinationUrl(action: string, form: HTMLFormElement) {
+  let targetUrl: URL;
+  try {
+    targetUrl = new URL(action, location.href);
+  } catch (error) {
+    throw new Error(`Cannot parse form action "${action}" as a URL`, {
+      cause: error as Error,
+    });
+  }
+  if (targetUrl.searchParams.size > 0) targetUrl.search = '';
+
+  const data = new FormData(form);
+  for (const [key, value] of data.entries()) {
+    if (typeof value === 'string') {
+      targetUrl.searchParams.append(key, value);
+    } else {
+      warnFileInput();
+      targetUrl.searchParams.append(key, (value as File).name);
+    }
+  }
+  return targetUrl;
+}
+
+let reportedAttrs: Set<string> | undefined;
+function reportUnsupportedAttr(name: string) {
+  if (typeof document === 'undefined' || !isDevDocument()) return;
+  reportedAttrs ??= new Set();
+  if (reportedAttrs.has(name)) return;
+  reportedAttrs.add(name);
+  console.error(
+    `<Form>'s \`${name}\` was set to an unsupported value. Only the default value is supported. See https://nextjs.org/docs/app/api-reference/components/form`,
+  );
+}
+
+let fileInputWarned = false;
+function warnFileInput() {
+  if (fileInputWarned || typeof document === 'undefined' || !isDevDocument()) return;
+  fileInputWarned = true;
+  console.warn(
+    '<Form> only supports file inputs if `action` is a function. Files will not be submitted with a string action.',
+  );
+}
+
+function isDevDocument() {
+  return typeof document !== 'undefined' && Boolean(document.querySelector('script[data-pnext-dev]'));
+}

package/src/compat/next/head.tsx

@@ -0,0 +1,10 @@
+import type { ComponentChildren } from 'preact';
+
+/**
+ * Pages-router head hoisting is not supported (Next's own app router rejects
+ * it too); metadata exports are the supported path. Render nothing so shared
+ * components that still carry a <Head> don't break.
+ */
+export default function Head(_props: { children?: ComponentChildren }) {
+  return null;
+}

package/src/compat/next/headers.ts

@@ -0,0 +1,247 @@
+import {
+  currentRequest,
+  currentResponseHeaders,
+  getWorkUnit,
+  requireRequest,
+  requestApiPromise,
+} from '../../request/context';
+import type { NextRequestCookies } from '../../types';
+import {
+  assertDraftModeToggleAllowedInAfter,
+  assertRequestApiAllowedInAfter,
+  lifecycleError,
+} from '../lifecycle/after-scope';
+import { assertNoDynamicApiInsideCache, currentRenderCacheMeta } from '../cache/revalidate';
+
+const COOKIE_MUTATION_ERROR =
+  'Cookies can only be modified in a Server Action or Route Handler. ' +
+  'Read more: https://nextjs.org/docs/app/api-reference/functions/cookies#options';
+
+/**
+ * Cookie writes are only legal while the request is executing a Server Action or a Route Handler. Every
+ * other phase - a page render, an after() callback, or middleware - throws Next's exact message. The
+ * check reads the LIVE work-unit phase at call time, so a cookie store captured during an action still
+ * throws when its .set() runs later inside after(), where the phase has flipped.
+ *
+ * Core does not set a dedicated 'handler' phase, so a route handler is detected via its routeKind
+ * instead; an action sets phase 'action' explicitly. Outside any work unit mutation is left alone.
+ */
+function assertCookieMutationAllowed(): void {
+  const unit = getWorkUnit();
+  if (!unit) return;
+  if (unit.phase === 'action') return;
+  if (unit.phase !== 'after' && unit.routeKind === 'route-handler') return;
+  throw new Error(COOKIE_MUTATION_ERROR);
+}
+
+const HEADERS_MUTATION_ERROR =
+  'Headers cannot be modified. Read more: https://nextjs.org/docs/app/api-reference/functions/headers';
+
+/**
+ * headers() exposes the REQUEST headers, which Next makes read-only: append(), set() and delete() throw
+ * instead of mutating. getSetCookie() is always empty - request headers carry no response Set-Cookie.
+ * Every read method delegates to the underlying Headers unchanged.
+ */
+function readonlyHeaders(source: Headers): Headers {
+  return new Proxy(source, {
+    get(target, prop) {
+      if (prop === 'append' || prop === 'set' || prop === 'delete') {
+        return () => {
+          throw new Error(HEADERS_MUTATION_ERROR);
+        };
+      }
+      if (prop === 'getSetCookie') return () => [];
+      const value: unknown = Reflect.get(target, prop, target);
+      return typeof value === 'function' ? (value as (...args: unknown[]) => unknown).bind(target) : value;
+    },
+  });
+}
+
+export function headers() {
+  assertRequestApiAllowedInAfter('headers()');
+  assertDynamicErrorRequestApi('headers()');
+  assertNoDynamicApiInsideCache('headers()');
+  return requestApiPromise('headers()', () =>
+    readonlyHeaders(new Headers(requireRequest('headers()').headers)),
+  );
+}
+
+export interface CookieSetOptions {
+  name?: string;
+  value?: string;
+  path?: string;
+  maxAge?: number;
+  expires?: Date | number;
+  httpOnly?: boolean;
+  secure?: boolean;
+  sameSite?: 'strict' | 'lax' | 'none' | boolean;
+  domain?: string;
+}
+
+/**
+ * Next's cookies(): reads come from the request jar; writes (allowed in Server
+ * Actions and Route Handlers) update the jar for subsequent reads in the same
+ * request AND append a set-cookie onto the response-headers channel so the
+ * browser persists them. Supports both set(name, value, options) and
+ * set({ name, value, ...options }).
+ */
+export function cookies() {
+  assertRequestApiAllowedInAfter('cookies()');
+  assertDynamicErrorRequestApi('cookies()');
+  assertNoDynamicApiInsideCache('cookies()');
+  return requestApiPromise('cookies()', () => wrapCookieJar(requireRequest('cookies()').cookies));
+}
+
+export function assertDynamicErrorRequestApi(api: 'headers()' | 'cookies()' | 'connection()'): void {
+  const meta = currentRenderCacheMeta();
+  if (!meta?.dynamicError) return;
+  throw lifecycleError(
+    `Route ${meta.route ?? ''} with \`dynamic = "error"\` couldn't be rendered statically because it used \`${api}\`.`,
+  );
+}
+
+function wrapCookieJar(jar: NextRequestCookies) {
+  return {
+    get: (name: CookieNameArg) => jar.get(cookieName(name)),
+    getAll: (name?: CookieNameArg) => (name === undefined ? jar.getAll() : jar.getAll(cookieName(name))),
+    has: (name: CookieNameArg) => jar.has(cookieName(name)),
+    get size() {
+      return jar.getAll().length;
+    },
+    [Symbol.iterator]() {
+      return jar.getAll().map(cookie => [cookie.name, cookie] as const)[Symbol.iterator]();
+    },
+    set(nameOrOptions: string | CookieSetOptions, value?: unknown, options?: CookieSetOptions) {
+      assertCookieMutationAllowed();
+      const parsed = normalizeSetArgs(nameOrOptions, value, options);
+      jar.set(parsed.name, parsed.value);
+      currentResponseHeaders()?.append('set-cookie', serializeSetCookie(parsed));
+      return this;
+    },
+    delete(name: CookieNameArg) {
+      assertCookieMutationAllowed();
+      const resolved = cookieName(name);
+      const existed = jar.delete(resolved);
+      currentResponseHeaders()?.append(
+        'set-cookie',
+        serializeSetCookie({ name: resolved, value: '', path: '/', maxAge: 0 }),
+      );
+      return existed;
+    },
+    clear() {
+      for (const cookie of jar.getAll()) this.delete(cookie.name);
+      return this;
+    },
+    toString() {
+      return jar
+        .getAll()
+        .map(cookie => `${cookie.name}=${encodeURIComponent(cookie.value)}`)
+        .join('; ');
+    },
+  };
+}
+
+interface NormalizedCookie extends CookieSetOptions {
+  name: string;
+  value: string;
+}
+
+/**
+ * Next's RequestCookies accessors take a name OR a cookie-shaped object, so
+ * `cookies().get({ name: 'x', value: undefined })` reads the same entry as `cookies().get('x')`.
+ */
+type CookieNameArg = string | { name?: string };
+
+function cookieName(arg: CookieNameArg): string {
+  if (typeof arg === 'string') return arg;
+  return typeof arg?.name === 'string' ? arg.name : '';
+}
+
+function normalizeSetArgs(
+  nameOrOptions: string | CookieSetOptions,
+  value?: unknown,
+  options?: CookieSetOptions,
+): NormalizedCookie {
+  if (typeof nameOrOptions === 'string') {
+    return { ...(options ?? {}), name: nameOrOptions, value: stringifyCookieValue(value) };
+  }
+  return {
+    ...nameOrOptions,
+    name: String(nameOrOptions.name ?? ''),
+    value: String(nameOrOptions.value ?? ''),
+  };
+}
+
+function stringifyCookieValue(raw: unknown): string {
+  if (raw === undefined || raw === null) return '';
+  if (typeof raw === 'string') return raw;
+  if (typeof raw === 'number' || typeof raw === 'boolean' || typeof raw === 'bigint') {
+    return String(raw);
+  }
+  return JSON.stringify(raw) ?? '';
+}
+
+function serializeSetCookie(cookie: NormalizedCookie): string {
+  const parts = [`${cookie.name}=${encodeURIComponent(cookie.value)}`];
+  parts.push(`Path=${cookie.path ?? '/'}`);
+  if (cookie.maxAge !== undefined) parts.push(`Max-Age=${cookie.maxAge}`);
+  if (cookie.expires !== undefined) {
+    const date = cookie.expires instanceof Date ? cookie.expires : new Date(cookie.expires);
+    parts.push(`Expires=${date.toUTCString()}`);
+  }
+  if (cookie.domain) parts.push(`Domain=${cookie.domain}`);
+  if (cookie.httpOnly) parts.push('HttpOnly');
+  if (cookie.secure) parts.push('Secure');
+  if (cookie.sameSite) {
+    const value = cookie.sameSite === true ? 'Strict' : capitalize(cookie.sameSite);
+    parts.push(`SameSite=${value}`);
+  }
+  return parts.join('; ');
+}
+
+function capitalize(value: string) {
+  return value.charAt(0).toUpperCase() + value.slice(1);
+}
+
+const draftCookieName = '__prerender_bypass';
+
+export interface DraftMode {
+  readonly isEnabled: boolean;
+  enable(): void;
+  disable(): void;
+}
+
+export function draftMode(): Promise<DraftMode> {
+  // Unlike cookies()/headers(), draftMode() never opts a page into dynamic
+  // rendering: during build/partial prerender there is no (real) request and
+  // draft is simply off, so reading isEnabled must not postpone or throw.
+  const request = currentRequest();
+  const requestCookies = request?.cookies;
+  return Promise.resolve({
+    get isEnabled() {
+      return requestCookies?.has(draftCookieName) ?? false;
+    },
+    enable() {
+      assertDraftModeToggleAllowedInAfter('enable');
+      const cookies = requireRequest('draftMode().enable()').cookies;
+      const value = cookies.get(draftCookieName)?.value || bypassToken();
+      cookies.set(draftCookieName, value);
+      currentResponseHeaders()?.append(
+        'set-cookie',
+        `${draftCookieName}=${value}; Path=/; HttpOnly; SameSite=None; Secure`,
+      );
+    },
+    disable() {
+      assertDraftModeToggleAllowedInAfter('disable');
+      requireRequest('draftMode().disable()').cookies.delete(draftCookieName);
+      currentResponseHeaders()?.append(
+        'set-cookie',
+        `${draftCookieName}=; Path=/; Max-Age=0; HttpOnly; SameSite=None; Secure`,
+      );
+    },
+  });
+}
+
+function bypassToken() {
+  return globalThis.crypto?.randomUUID?.().replace(/-/g, '') ?? Math.random().toString(36).slice(2);
+}