@wular/pnext 0.0.3 → 0.0.6

package/src/compat/protocol.ts

@@ -11,14 +11,10 @@
 // Core owns the generic "merge, do not overwrite" discipline; compat owns the exact Next header
 // names and values. A pure-core app registers none of this.
 
-import type { ResolvedConfig } from '../config';
-import { getWorkUnit, type WorkUnit } from '../request/context';
-import type {
-  RequestInterceptor,
-  ResponseFinalizer,
-  ResponseFinalizerContext,
-} from '../extensions';
-import { nextCompatEnabled } from '../compat';
+import type { ResolvedConfig } from '../config'
+import { getWorkUnit, type WorkUnit } from '../request/context'
+import type { RequestInterceptor, ResponseFinalizer, ResponseFinalizerContext } from '../extensions'
+import { nextCompatEnabled } from '../compat/aliases'
 
 // Next's router vary tokens appended to every app-router response so a CDN
 // keys its cache on the RSC negotiation headers. Order + spelling match Next.
@@ -27,20 +23,20 @@ const ROUTER_VARY = [
   'next-router-state-tree',
   'next-router-prefetch',
   'next-router-segment-prefetch',
-];
+]
 
 /** Rewrite tracking recorded per request by the compat rewrite interceptor. */
 interface RewriteInfo {
   /** Destination pathname, only when it differs from the requested one. */
-  path?: string;
+  path?: string
   /** Destination query (without leading `?`), only when non-empty. */
-  query?: string;
+  query?: string
 }
 
 // Keyed on the request's work unit (stable for the whole response lifecycle);
 // the interceptor writes it, the finalizer reads it. A WeakMap so completed
 // requests are collected without any explicit teardown.
-const rewrites = new WeakMap<WorkUnit, RewriteInfo>();
+const rewrites = new WeakMap<WorkUnit, RewriteInfo>()
 
 /**
  * Record that a compat rewrite changed the request URL from `from` to `to`.
@@ -48,66 +44,71 @@ const rewrites = new WeakMap<WorkUnit, RewriteInfo>();
  * no-op outside a request work unit or when the URL did not actually change.
  */
 export function recordRewrite(from: URL, to: URL): void {
-  const unit = getWorkUnit();
-  if (!unit) return;
-  if (from.pathname === to.pathname && from.search === to.search) return;
-  const query = to.search.replace(/^\?/, '');
+  const unit = getWorkUnit()
+  if (!unit) return
+  if (from.pathname === to.pathname && from.search === to.search) return
+  const query = to.search.replace(/^\?/, '')
   // Next reports the path header only when the pathname actually changed, and
   // the query header only when the destination carries a query (a query-only
   // rewrite reports query alone; a path-only rewrite reports path alone).
   rewrites.set(unit, {
     ...(to.pathname !== from.pathname ? { path: to.pathname } : {}),
     ...(query ? { query } : {}),
-  });
+  })
 }
 
 /**
  * Internal marker set by the segment responder's `_rsc` cache-busting 307 so
  * this module's redirect normalization leaves it alone. Never reaches a client.
  */
-export const CACHE_BUSTING_REDIRECT_HEADER = 'x-pnext-cache-bust';
+export const CACHE_BUSTING_REDIRECT_HEADER = 'x-pnext-cache-bust'
 
 const APP_ROUTE_KINDS = new Set<ResponseFinalizerContext['routeKind']>([
   'html',
   'data',
   'route-handler',
-]);
+])
 
 const protocolFinalizer: ResponseFinalizer = ctx => {
-  if (!APP_ROUTE_KINDS.has(ctx.routeKind)) return;
-  mergeVary(ctx.headers, ROUTER_VARY);
-  normalizeRscRedirectStatus(ctx);
-  applyRewrittenHeaders(ctx);
-  applyEdgeRuntimeHeader(ctx);
-};
+  if (!APP_ROUTE_KINDS.has(ctx.routeKind)) return
+  mergeVary(ctx.headers, ROUTER_VARY)
+  normalizeRscRedirectStatus(ctx)
+  applyRewrittenHeaders(ctx)
+  applyEdgeRuntimeHeader(ctx)
+}
 
 // Next's edge SSR/route wrappers stamp `x-edge-runtime: 1` on every response
 // from a route whose segment config selects the edge runtime (edge-ssr-app.ts).
 // The matched route's runtime rides on the work-unit response hints.
 function applyEdgeRuntimeHeader(ctx: ResponseFinalizerContext): void {
-  const runtime = ctx.hints?.runtime;
+  const runtime = ctx.hints?.runtime
   if (runtime === 'edge' || runtime === 'experimental-edge') {
-    ctx.headers.set('x-edge-runtime', '1');
+    ctx.headers.set('x-edge-runtime', '1')
   }
 }
 
 // Append `values` to the response's Vary header, preserving any existing tokens
 // (user- or middleware-set) and never duplicating (case-insensitive).
 function mergeVary(headers: Headers, values: readonly string[]): void {
-  const existing = headers.get('vary');
+  const existing = headers.get('vary')
   const present = new Set(
     (existing ?? '')
       .split(',')
       .map(token => token.trim().toLowerCase())
       .filter(Boolean),
-  );
-  const merged = existing ? existing.split(',').map(token => token.trim()).filter(Boolean) : [];
+  )
+  const merged = existing
+    ? existing
+        .split(',')
+        .map(token => token.trim())
+        .filter(Boolean)
+    : []
   for (const value of values) {
-    if (present.has(value.toLowerCase())) continue;
-    present.add(value.toLowerCase());
-    merged.push(value);
+    if (present.has(value.toLowerCase())) continue
+    present.add(value.toLowerCase())
+    merged.push(value)
   }
-  if (merged.length > 0) headers.set('vary', merged.join(', '));
+  if (merged.length > 0) headers.set('vary', merged.join(', '))
 }
 
 // Emit x-nextjs-rewritten-path/query when a compat rewrite changed this
@@ -116,13 +117,13 @@ function mergeVary(headers: Headers, values: readonly string[]): void {
 // them. Each header is set only when the rewrite recorded that part. Absent on
 // non-rewritten responses (the WeakMap has no entry).
 function applyRewrittenHeaders(ctx: ResponseFinalizerContext): void {
-  if (ctx.request.headers.get('rsc') !== '1') return;
-  const unit = getWorkUnit();
-  if (!unit) return;
-  const info = rewrites.get(unit);
-  if (!info) return;
-  if (info.path !== undefined) ctx.headers.set('x-nextjs-rewritten-path', info.path);
-  if (info.query !== undefined) ctx.headers.set('x-nextjs-rewritten-query', info.query);
+  if (ctx.request.headers.get('rsc') !== '1') return
+  const unit = getWorkUnit()
+  if (!unit) return
+  const info = rewrites.get(unit)
+  if (!info) return
+  if (info.path !== undefined) ctx.headers.set('x-nextjs-rewritten-path', info.path)
+  if (info.query !== undefined) ctx.headers.set('x-nextjs-rewritten-query', info.query)
 }
 
 function normalizeRscRedirectStatus(ctx: ResponseFinalizerContext): void {
@@ -130,19 +131,19 @@ function normalizeRscRedirectStatus(ctx: ResponseFinalizerContext): void {
   // an app redirect(): Next sends it as a real 307 that every client follows,
   // so it must survive this normalization. The marker is internal — strip it.
   if (ctx.headers.has(CACHE_BUSTING_REDIRECT_HEADER)) {
-    ctx.headers.delete(CACHE_BUSTING_REDIRECT_HEADER);
-    return;
+    ctx.headers.delete(CACHE_BUSTING_REDIRECT_HEADER)
+    return
   }
-  if (ctx.routeKind !== 'html') return;
-  if (ctx.request.headers.get('rsc') !== '1') return;
+  if (ctx.routeKind !== 'html') return
+  if (ctx.request.headers.get('rsc') !== '1') return
   // pnext's own soft-nav client sends rsc:1 but follows real redirects via
   // fetch (it reads response.url as the final URL); rewriting 307/308 to 200
   // would strand it on the source URL. The 200+Location wire form is only
   // meaningful to Next's client, which never sends x-pnext-soft-nav.
-  if (ctx.request.headers.has('x-pnext-soft-nav')) return;
-  if (!ctx.headers.has('location')) return;
-  if (ctx.status !== 307 && ctx.status !== 308) return;
-  ctx.status = 200;
+  if (ctx.request.headers.has('x-pnext-soft-nav')) return
+  if (!ctx.headers.has('location')) return
+  if (ctx.status !== 307 && ctx.status !== 308) return
+  ctx.status = 200
 }
 
 // next-router-state-tree validation (Next's parseAndValidateFlightRouterState).
@@ -154,49 +155,49 @@ function normalizeRscRedirectStatus(ctx: ResponseFinalizerContext): void {
 // rejected. Anything Next's own client can send passes untouched.
 
 function isValidFlightRouterState(value: unknown): boolean {
-  if (!Array.isArray(value)) return false;
-  const [segment, parallelRoutes] = value as unknown[];
-  if (typeof segment !== 'string' && !Array.isArray(segment)) return false;
-  if (typeof parallelRoutes !== 'object' || parallelRoutes === null) return false;
-  if (Array.isArray(parallelRoutes)) return false;
-  return Object.values(parallelRoutes as Record<string, unknown>).every(isValidFlightRouterState);
+  if (!Array.isArray(value)) return false
+  const [segment, parallelRoutes] = value as unknown[]
+  if (typeof segment !== 'string' && !Array.isArray(segment)) return false
+  if (typeof parallelRoutes !== 'object' || parallelRoutes === null) return false
+  if (Array.isArray(parallelRoutes)) return false
+  return Object.values(parallelRoutes as Record<string, unknown>).every(isValidFlightRouterState)
 }
 
 const routerStateTreeInterceptor: RequestInterceptor = request =>
-  Promise.resolve(validateRouterStateTree(request));
+  Promise.resolve(validateRouterStateTree(request))
 
 function validateRouterStateTree(request: Request): Response | undefined {
-  if (request.headers.get('rsc') !== '1') return undefined;
+  if (request.headers.get('rsc') !== '1') return undefined
   // pnext's own client mirrors its richer nav-state object into this header for
-  // wire compat (api/router.ts); that object is not a FlightRouterState and is
+  // wire compat (client/router/index.ts); that object is not a FlightRouterState and is
   // never what this check is about.
-  if (request.headers.has('x-pnext-soft-nav')) return undefined;
-  const header = request.headers.get('next-router-state-tree');
-  if (header === null) return undefined;
+  if (request.headers.has('x-pnext-soft-nav')) return undefined
+  const header = request.headers.get('next-router-state-tree')
+  if (header === null) return undefined
 
-  let tree: unknown;
+  let tree: unknown
   try {
-    tree = JSON.parse(decodeURIComponent(header));
+    tree = JSON.parse(decodeURIComponent(header))
   } catch {
     try {
-      tree = JSON.parse(header);
+      tree = JSON.parse(header)
     } catch {
-      return new Response('Internal Server Error', { status: 500 });
+      return new Response('Internal Server Error', { status: 500 })
     }
   }
   return isValidFlightRouterState(tree)
     ? undefined
-    : new Response('Internal Server Error', { status: 500 });
+    : new Response('Internal Server Error', { status: 500 })
 }
 
 /** The compat request interceptors this module owns, gated on compat.next. */
 export function protocolInterceptors(config: ResolvedConfig): RequestInterceptor[] {
-  if (!nextCompatEnabled(config)) return [];
-  return [routerStateTreeInterceptor];
+  if (!nextCompatEnabled(config)) return []
+  return [routerStateTreeInterceptor]
 }
 
 /** The compat protocol finalizers, gated on compat.next. */
 export function protocolFinalizers(config: ResolvedConfig): ResponseFinalizer[] {
-  if (!nextCompatEnabled(config)) return [];
-  return [protocolFinalizer];
+  if (!nextCompatEnabled(config)) return []
+  return [protocolFinalizer]
 }

package/src/compat/react/action-state.ts

@@ -1,5 +1,5 @@
-import { useCallback, useRef, useState } from 'preact/hooks';
-import { hooksUsable } from './hooks-extra';
+import { useCallback, useRef, useState } from 'preact/hooks'
+import { hooksUsable } from './hooks-extra'
 
 /**
  * React 19's useActionState, on preact hooks. Returns [state, dispatch, isPending]; dispatch(payload)
@@ -21,25 +21,25 @@ export function useActionState<State, Payload = FormData>(
   // <form action={dispatch}>.
   if (!hooksUsable()) {
     const staticInitial = (consumeActionStateOverride() ?? { value: initialState })
-      .value as Awaited<State>;
+      .value as Awaited<State>
     const staticDispatch = (payload: Payload) =>
-      void Promise.resolve(action(staticInitial, payload));
-    tagFormStateDispatch(staticDispatch, action, staticInitial, _permalink);
-    return [staticInitial, staticDispatch, false];
+      void Promise.resolve(action(staticInitial, payload))
+    tagFormStateDispatch(staticDispatch, action, staticInitial, _permalink)
+    return [staticInitial, staticDispatch, false]
   }
-  const initialRef = useRef<{ value: Awaited<State> } | null>(null);
+  const initialRef = useRef<{ value: Awaited<State> } | null>(null)
   if (!initialRef.current) {
     // A progressive (no-JS) submission re-renders the page with the action's
     // result as the form state; the server (and the inline hydration script)
     // publish it via a consumed-once global override.
     initialRef.current = {
       value: (consumeActionStateOverride() ?? { value: initialState }).value as Awaited<State>,
-    };
+    }
   }
-  const [state, setState] = useState<Awaited<State>>(initialRef.current.value);
-  const [pending, setPending] = useState(0);
-  const lastSettled = useRef<Awaited<State>>(initialRef.current.value);
-  const chain = useRef<Promise<unknown>>(Promise.resolve());
+  const [state, setState] = useState<Awaited<State>>(initialRef.current.value)
+  const [pending, setPending] = useState(0)
+  const lastSettled = useRef<Awaited<State>>(initialRef.current.value)
+  const chain = useRef<Promise<unknown>>(Promise.resolve())
   // A rejected action must surface to the nearest error boundary during an actual preact render (only
   // diff() wraps component calls in the getDerivedStateFromError/componentDidCatch try/catch).
   // preact/hooks' setState invokes a functional updater EAGERLY at call time, to bail out on an unchanged
@@ -47,55 +47,55 @@ export function useActionState<State, Payload = FormData>(
   // async .catch handler throws immediately in that microtask, outside any render call stack and outside
   // any try/catch, producing an unhandled rejection instead of reaching the boundary. Stash the error in
   // a ref and force a re-render instead; the throw then happens inside this hook's own render call.
-  const pendingError = useRef<{ error: unknown } | null>(null);
-  const [, forceRender] = useState(0);
+  const pendingError = useRef<{ error: unknown } | null>(null)
+  const [, forceRender] = useState(0)
 
   const dispatch = useCallback(
     (payload: Payload) => {
-      setPending(count => count + 1);
+      setPending(count => count + 1)
       // Chain in dispatch order against the latest settled state. A rejected
       // action leaves the previous state in place (matching React, where the
       // error propagates to the nearest error boundary via the transition) and
       // must not poison the queue for later dispatches.
       chain.current = chain.current.then(async () => {
         try {
-          const redirectsBefore = actionRedirectCount();
-          const next = (await action(lastSettled.current, payload));
+          const redirectsBefore = actionRedirectCount()
+          const next = await action(lastSettled.current, payload)
           // A redirect renders the destination's initial form state even when
           // the shared layout island itself survives the navigation.
           if (next === undefined && actionRedirectCount() !== redirectsBefore) {
-            lastSettled.current = initialRef.current!.value;
-            setState(() => initialRef.current!.value);
-            return;
+            lastSettled.current = initialRef.current!.value
+            setState(() => initialRef.current!.value)
+            return
           }
-          lastSettled.current = next;
-          setState(() => next);
+          lastSettled.current = next
+          setState(() => next)
         } finally {
-          setPending(count => count - 1);
+          setPending(count => count - 1)
         }
-      });
+      })
       // React propagates action errors to the nearest error boundary (they
       // are not catchable at the dispatch site). Stash it and force a render:
       // a class error boundary in the tree catches the throw below; without
       // one the uncaught render error reaches the window 'error' event, where
       // the compat entry's error.js overlay picks it up.
       chain.current = chain.current.catch(error => {
-        if (!process.browser && typeof window === 'undefined') return;
-        pendingError.current = { error };
-        forceRender(count => count + 1);
-      });
+        if (!process.browser && typeof window === 'undefined') return
+        pendingError.current = { error }
+        forceRender(count => count + 1)
+      })
     },
     [action],
-  );
+  )
 
   if (pendingError.current) {
-    const { error } = pendingError.current;
-    pendingError.current = null;
-    throw error;
+    const { error } = pendingError.current
+    pendingError.current = null
+    throw error
   }
 
-  tagFormStateDispatch(dispatch, action, state, _permalink);
-  return [state, dispatch, pending > 0];
+  tagFormStateDispatch(dispatch, action, state, _permalink)
+  return [state, dispatch, pending > 0]
 }
 
 /**
@@ -106,9 +106,9 @@ export function useActionState<State, Payload = FormData>(
  * optional permalink target.
  */
 export interface FormStateDispatchMeta {
-  action: (state: never, payload: never) => unknown;
-  state: unknown;
-  permalink?: string;
+  action: (state: never, payload: never) => unknown
+  state: unknown
+  permalink?: string
 }
 
 function tagFormStateDispatch(
@@ -117,11 +117,11 @@ function tagFormStateDispatch(
   state: unknown,
   permalink?: string,
 ) {
-  (dispatch as unknown as { $$pnextFormState?: FormStateDispatchMeta }).$$pnextFormState = {
+  ;(dispatch as unknown as { $$pnextFormState?: FormStateDispatchMeta }).$$pnextFormState = {
     action: action,
     state,
     ...(permalink !== undefined ? { permalink } : {}),
-  };
+  }
 }
 
 /**
@@ -131,13 +131,13 @@ function tagFormStateDispatch(
  */
 /** Redirect counter the action-client runtime bumps (see markActionRedirected). */
 function actionRedirectCount(): number {
-  return (globalThis as { __pnextActionRedirects?: number }).__pnextActionRedirects ?? 0;
+  return (globalThis as { __pnextActionRedirects?: number }).__pnextActionRedirects ?? 0
 }
 
 export function consumeActionStateOverride(): { value: unknown } | undefined {
-  const holder = globalThis as { __PNEXT_ACTION_STATE__?: unknown };
-  if (!('__PNEXT_ACTION_STATE__' in holder)) return undefined;
-  const override = holder.__PNEXT_ACTION_STATE__;
+  const holder = globalThis as { __PNEXT_ACTION_STATE__?: unknown }
+  if (!('__PNEXT_ACTION_STATE__' in holder)) return undefined
+  const override = holder.__PNEXT_ACTION_STATE__
   if (
     override !== null &&
     typeof override === 'object' &&
@@ -145,15 +145,14 @@ export function consumeActionStateOverride(): { value: unknown } | undefined {
     typeof override.skip === 'number' &&
     override.skip > 0
   ) {
-    override.skip--;
-    return undefined;
+    override.skip--
+    return undefined
   }
-  delete holder.__PNEXT_ACTION_STATE__;
+  delete holder.__PNEXT_ACTION_STATE__
   return {
     value:
       override !== null && typeof override === 'object' && 'value' in override
         ? override.value
         : override,
-  };
+  }
 }
-

package/src/compat/react/client-lite.ts

@@ -1,8 +1,8 @@
 // Lite client `react` alias for compat apps whose client graph provably never suspends and only uses
-// the core-preact-equivalent React surface (see clientCompatSurface in src/client/compat-surface.ts).
+// the core-preact-equivalent React surface (see clientCompatSurface in src/client/react-tier.ts).
 // Everything here is backed by preact core + preact/hooks, so the bundle ships no preact/compat. The
 // parity import wires the same vnode pass (React 19 ref prop, primitive-throw safety) as the full shim.
-import './parity';
+import './parity'
 import {
   Component,
   Fragment,
@@ -11,7 +11,7 @@ import {
   createElement,
   createRef,
   isValidElement,
-} from 'preact';
+} from 'preact'
 import {
   useCallback,
   useContext,
@@ -24,9 +24,9 @@ import {
   useReducer,
   useRef,
   useState,
-} from 'preact/hooks';
-import { useOptimistic, useTransition } from './hooks-extra';
-import { useActionState } from './action-state';
+} from 'preact/hooks'
+import { useOptimistic, useTransition } from './hooks-extra'
+import { useActionState } from './action-state'
 
 export {
   Component,
@@ -50,24 +50,24 @@ export {
   useActionState,
   useOptimistic,
   useTransition,
-};
-export { ViewTransition, addTransitionType } from './view-transition';
+}
+export { ViewTransition, addTransitionType } from './view-transition'
 
 // Same passthrough semantics preact/compat gives these.
-export const StrictMode = Fragment;
-export const startTransition = (callback: () => void) => callback();
-export const useDeferredValue = <T>(value: T): T => value;
-export const useInsertionEffect = useLayoutEffect;
-export const version = '19.0.0';
+export const StrictMode = Fragment
+export const startTransition = (callback: () => void) => callback()
+export const useDeferredValue = <T>(value: T): T => value
+export const useInsertionEffect = useLayoutEffect
+export const version = '19.0.0'
 
 export function cache<Args extends unknown[], Result>(
   fn: (...args: Args) => Result,
 ): (...args: Args) => Result {
-  return (...args: Args) => fn(...args);
+  return (...args: Args) => fn(...args)
 }
 
 export function cacheSignal() {
-  return null;
+  return null
 }
 
 // No default export: the surface scan already forces the full tier for any app doing

package/src/compat/react/client.ts

@@ -45,15 +45,15 @@ export {
   useSyncExternalStore,
   useTransition,
   version,
-} from './preact';
-export { ViewTransition, addTransitionType } from './view-transition';
+} from './preact'
+export { ViewTransition, addTransitionType } from './view-transition'
 
 export function cache<Args extends unknown[], Result>(
   fn: (...args: Args) => Result,
 ): (...args: Args) => Result {
-  return (...args: Args) => fn(...args);
+  return (...args: Args) => fn(...args)
 }
 
 export function cacheSignal() {
-  return null;
+  return null
 }

package/src/compat/react/compiler-runtime.ts

@@ -14,27 +14,27 @@
 // runtime. The remaining exports are only emitted in development/validation builds; pnext ships the
 // production runtime, so they are minimal stubs to keep any stray import resolvable.
 
-import { useMemo } from 'preact/compat';
+import { useMemo } from 'preact/compat'
 
-const $empty = Symbol.for('react.memo_cache_sentinel');
+const $empty = Symbol.for('react.memo_cache_sentinel')
 
 /** React Compiler memo-cache allocator (production fallback over preact useMemo). */
 export function c(size: number): unknown[] {
   return useMemo<unknown[]>(() => {
-    const cache: unknown[] = new Array<unknown>(size);
-    for (let index = 0; index < size; index++) cache[index] = $empty;
-    (cache as unknown as Record<symbol, boolean>)[$empty] = true;
-    return cache;
-  }, []);
+    const cache: unknown[] = new Array<unknown>(size)
+    for (let index = 0; index < size; index++) cache[index] = $empty
+    ;(cache as unknown as Record<symbol, boolean>)[$empty] = true
+    return cache
+  }, [])
 }
 
 /** Reset a memo-cache array back to sentinels (dev-only in upstream). */
 export function $reset(cache: unknown[]): void {
-  for (let index = 0; index < cache.length; index++) cache[index] = $empty;
+  for (let index = 0; index < cache.length; index++) cache[index] = $empty
 }
 
 export function $makeReadOnly<T>(value: T): T {
-  return value;
+  return value
 }
 
 // Dispatcher guards / structural check are dev-only validation hooks; ship as
@@ -47,11 +47,11 @@ export function $structuralCheck(): void {
   /* no-op: dev-only structural equality check */
 }
 
-export const renderCounterRegistry = new Map<string, Set<{ count: number }>>();
+export const renderCounterRegistry = new Map<string, Set<{ count: number }>>()
 
 export function clearRenderCounterRegistry(): void {
   for (const counters of renderCounterRegistry.values()) {
-    for (const counter of counters) counter.count = 0;
+    for (const counter of counters) counter.count = 0
   }
 }