@wular/pnext 0.0.2 → 0.0.4

package/src/compat/react/preact.ts

@@ -1,98 +1,27 @@
 import ReactCompat from 'preact/compat';
-import { options, type ComponentChildren, type ComponentType, type VNode } from 'preact';
-import { wrapComponentForPrimitiveThrows } from '../client/errors/primitive-throw';
-
-const reactForwardRefSymbol = Symbol.for('react.forward_ref');
-const react19RefCompatInstalled = Symbol.for('pnext.react19-ref-compat-installed');
-const reactTextSeparatorSymbol = Symbol.for('pnext.react-text-separator');
-
-type PNextPreactOptions = typeof options & {
-  [react19RefCompatInstalled]?: true;
-};
-
-type RefCompatibleComponent = ComponentType<Record<string, unknown>> & {
-  $$typeof?: symbol;
-  prototype?: { render?: unknown };
-};
-
-// preact's `options.vnode` is process-global and cannot be uninstalled, so its BEHAVIOR follows the
-// active extension host instead: one server process can serve a compat app and then a pure-core one, and
-// the core app must not inherit React parity it never asked for. Defaults to on - importing this module
-// IS compat being wired, and the client never resets.
-let reactCompatActive = true;
-
-/** Enable/disable the react-compat vnode parity pass (see reactCompatActive). */
-export function setReactCompatActive(active: boolean): void {
-  reactCompatActive = active;
-}
-
-const pnextOptions = options as PNextPreactOptions;
-if (!pnextOptions[react19RefCompatInstalled]) {
-  const previousVNode = options.vnode?.bind(options);
-  options.vnode = vnode => {
-    previousVNode?.(vnode);
-    if (!reactCompatActive) return;
-    applyReact19RefProp(vnode);
-    applyAsyncClientComponent(vnode);
-    applyPrimitiveThrowSafety(vnode);
-    applyThenableChildren(vnode);
-    applyReactTextSeparators(vnode);
-  };
-  pnextOptions[react19RefCompatInstalled] = true;
-
-  // Effect scheduling parity with React: preact/hooks flushes passive effects
-  // via requestAnimationFrame + setTimeout(35) (afterNextFrame), both governed
-  // by the page clock. React flushes them through its scheduler's
-  // MessageChannel, which fake-timer installations (Playwright's CDP clock in
-  // Next's own e2e suites) never intercept. Under an installed fake clock the
-  // rAF path loses its "before the next idle callback" ordering and
-  // Suspense-boundary promotions land after a test's post-drain DOM sample.
-  // Route the flush through a MessageChannel task so effect timing is
-  // clock-independent, like React's.
-  if ((process.browser || typeof window !== 'undefined') && typeof MessageChannel !== 'undefined') {
-    const queue: (() => void)[] = [];
-    const channel = new MessageChannel();
-    channel.port1.onmessage = () => {
-      for (const callback of queue.splice(0)) callback();
-    };
-    (options as { requestAnimationFrame?: (cb: () => void) => void }).requestAnimationFrame =
-      callback => {
-        queue.push(callback);
-        channel.port2.postMessage(null);
-      };
-  }
-}
-
-function applyReactTextSeparators(vnode: VNode) {
-  // Server-only. `process.browser` is a client-bundle define (true) and
-  // undefined on the server, so this body folds out of browser builds; the
-  // `typeof window` twin keeps the runtime check for unbundled consumers.
-  if (process.browser || typeof window !== 'undefined') return;
-  const props = vnode.props as Record<string, unknown>;
-  const children = props.children;
-  if (!Array.isArray(children) || children.length < 2) return;
-  const values = children as unknown[];
-
-  const separated: unknown[] = [];
-  let changed = false;
-  for (let index = 0; index < values.length; index += 1) {
-    const child = values[index];
-    separated.push(child);
-    if (!mayRenderText(child) || !mayRenderText(values[index + 1])) continue;
-    separated.push({
-      type: reactTextSeparatorSymbol,
-      props: { UNSTABLE_comment: ' ' },
-    });
-    changed = true;
-  }
-  if (changed) props.children = separated;
-}
-
-function mayRenderText(value: unknown) {
-  if (typeof value === 'string' || typeof value === 'number') return true;
-  if (!value || typeof value !== 'object' || !('type' in value)) return false;
-  return typeof (value as VNode).type !== 'string';
-}
+import { type ComponentChildren, type ComponentType, type VNode } from 'preact';
+import { setSuspenseParity } from './parity';
+import { use } from './use';
+import { useActionState } from './action-state';
+import { useOptimistic, useTransition } from './hooks-extra';
+
+// Full react shim: preact/compat plus the React 19 surface. The vnode parity pass lives in ./parity
+// (compat-free, shared with the lite client shim); the suspense-dependent parity below registers into
+// it here, so it only ships when this module (and preact/compat with it) is in the bundle.
+
+setSuspenseParity({
+  beforeThrowSafety: applyAsyncClientComponent,
+  afterThrowSafety: applyThenableChildren,
+});
+
+export { setReactCompatActive } from './parity';
+export { use, withUseThenableState, type UseThenableState } from './use';
+export {
+  useActionState,
+  consumeActionStateOverride,
+  type FormStateDispatchMeta,
+} from './action-state';
+export { useOptimistic, useTransition } from './hooks-extra';
 
 function applyThenableChildren(vnode: VNode) {
   const props = vnode.props as Record<string, unknown>;
@@ -152,29 +81,9 @@ function applyAsyncClientComponent(vnode: VNode) {
   vnode.type = wrapper;
 }
 
-function applyPrimitiveThrowSafety(vnode: VNode) {
-  // Client-only: this exists to stop a thrown undefined/null from crashing preact's OWN diff.js `e.then`
-  // suspense check during real preact diffing. The server's resolveServerTree is a custom RSC-style tree
-  // walker, not preact's diff - it never hits that crash, and wrapping component references there risks
-  // losing the symbol-keyed metadata resolveServerTree branches on.
-  if (!process.browser && typeof window === 'undefined') return;
-  if (typeof vnode.type !== 'function') return;
-  vnode.type = wrapComponentForPrimitiveThrows(vnode.type);
-}
-
-function applyReact19RefProp(vnode: VNode) {
-  if (!vnode.ref || typeof vnode.type !== 'function') return;
-  const component = vnode.type as RefCompatibleComponent;
-  if (component.prototype?.render || component.$$typeof === reactForwardRefSymbol) return;
-
-  vnode.props = { ...(vnode.props as Record<string, unknown>), ref: vnode.ref } as unknown as typeof vnode.props;
-  vnode.ref = null;
-}
-
-// React 19 APIs preact/compat lacks - use(), useActionState, useOptimistic (function declarations below,
-// hoisted) - must ALSO live on the default export: app code does `import React from 'react';
-// React.use(...)`, not only named imports. server.ts spreads this default into ReactServer, so the
-// augmentation covers both layers.
+// React 19 APIs preact/compat lacks - use(), useActionState, useOptimistic (imported above) - must ALSO
+// live on the default export: app code does `import React from 'react'; React.use(...)`, not only named
+// imports. server.ts spreads this default into ReactServer, so the augmentation covers both layers.
 export default Object.assign(ReactCompat, { use, useActionState, useOptimistic, useTransition });
 
 export const Children = ReactCompat.Children;
@@ -197,7 +106,13 @@ export const hydrate = ReactCompat.hydrate;
 export const isFragment = ReactCompat.isFragment;
 export const isMemo = ReactCompat.isMemo;
 export const isValidElement = ReactCompat.isValidElement;
-export const lazy = ReactCompat.lazy;
+// preact's lazy returns a bare function with no react.lazy $$typeof; tag it so
+// validation (e.g. <Link legacyBehavior>) can recognize lazy components.
+export const lazy: typeof ReactCompat.lazy = loader => {
+  const component = ReactCompat.lazy(loader);
+  (component as unknown as Record<symbol, boolean>)[Symbol.for('pnext.lazy')] = true;
+  return component;
+};
 export const memo = ReactCompat.memo;
 export const render = ReactCompat.render;
 export const startTransition = ReactCompat.startTransition;
@@ -218,305 +133,3 @@ export const useRef = ReactCompat.useRef;
 export const useState = ReactCompat.useState;
 export const useSyncExternalStore = ReactCompat.useSyncExternalStore;
 export const version = ReactCompat.version;
-
-// True when a preact hooks call would succeed (a component render is in flight). preact fires
-// options._render just before invoking a component and options.diffed after it commits; between the two,
-// hooks have a current component. Server-side tree resolution invokes some client components as plain
-// functions, outside any preact render, where hooks would throw - useActionState/useOptimistic fall back
-// to SSR-equivalent static values there instead.
-let renderInFlight = false;
-
-function hooksUsable(): boolean {
-  return renderInFlight;
-}
-
-{
-  const anyOptions = options as unknown as Record<string, unknown>;
-  const previousRender = anyOptions.__r as ((vnode: VNode) => void) | undefined;
-  anyOptions.__r = (vnode: VNode) => {
-    renderInFlight = true;
-    previousRender?.(vnode);
-  };
-  const previousDiffed = options.diffed?.bind(options);
-  options.diffed = vnode => {
-    renderInFlight = false;
-    previousDiffed?.(vnode);
-  };
-}
-
-/**
- * React 19's useActionState, on preact hooks. Returns [state, dispatch, isPending]; dispatch(payload)
- * runs `action(prevState, payload)` (async ok) and swaps the state when it settles. The returned dispatch
- * is also valid as a `<form action={...}>` value - the pnext client runtime intercepts function form
- * actions and calls them with the form's FormData. Queueing follows React: concurrent dispatches chain
- * in order against the latest settled state rather than racing.
- */
-export function useActionState<State, Payload = FormData>(
-  action: (state: Awaited<State>, payload: Payload) => State | Promise<State>,
-  initialState: Awaited<State>,
-  _permalink?: string,
-): [state: Awaited<State>, dispatch: (payload: Payload) => void, isPending: boolean] {
-  // Server resolve may invoke a client component as a plain function (no
-  // preact render context, so hooks throw). SSR output for useActionState is
-  // always the (possibly progressively-updated) initial state with a dispatch
-  // that only works after hydration; fall back to exactly that. The dispatch
-  // carries form-state metadata so SSR can progressively enhance
-  // <form action={dispatch}>.
-  if (!hooksUsable()) {
-    const staticInitial = (consumeActionStateOverride() ?? { value: initialState })
-      .value as Awaited<State>;
-    const staticDispatch = (payload: Payload) =>
-      void Promise.resolve(action(staticInitial, payload));
-    tagFormStateDispatch(staticDispatch, action, staticInitial, _permalink);
-    return [staticInitial, staticDispatch, false];
-  }
-  const initialRef = ReactCompat.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] = ReactCompat.useState<Awaited<State>>(initialRef.current.value);
-  const [pending, setPending] = ReactCompat.useState(0);
-  const lastSettled = ReactCompat.useRef<Awaited<State>>(initialRef.current.value);
-  const chain = ReactCompat.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
-  // value, rather than deferring it to the render - so `setState(() => { throw error })` from inside an
-  // 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 = ReactCompat.useRef<{ error: unknown } | null>(null);
-  const [, forceRender] = ReactCompat.useState(0);
-
-  const dispatch = ReactCompat.useCallback(
-    (payload: Payload) => {
-      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));
-          // 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 = next;
-          setState(() => next);
-        } finally {
-          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);
-      });
-    },
-    [action],
-  );
-
-  if (pendingError.current) {
-    const { error } = pendingError.current;
-    pendingError.current = null;
-    throw error;
-  }
-
-  tagFormStateDispatch(dispatch, action, state, _permalink);
-  return [state, dispatch, pending > 0];
-}
-
-/**
- * Form-state metadata attached to a useActionState dispatch so the server
- * renderer can progressively enhance <form action={dispatch}>: the underlying
- * action (for its wire id), the state at render time (posted back in a hidden
- * field so the server can run `action(state, formData)` without JS), and the
- * optional permalink target.
- */
-export interface FormStateDispatchMeta {
-  action: (state: never, payload: never) => unknown;
-  state: unknown;
-  permalink?: string;
-}
-
-function tagFormStateDispatch(
-  dispatch: (payload: never) => void,
-  action: (state: never, payload: never) => unknown,
-  state: unknown,
-  permalink?: string,
-) {
-  (dispatch as unknown as { $$pnextFormState?: FormStateDispatchMeta }).$$pnextFormState = {
-    action: action,
-    state,
-    ...(permalink !== undefined ? { permalink } : {}),
-  };
-}
-
-/**
- * Consumed-once initial-state override for useActionState, published either by
- * the server before re-rendering a page for a progressive form submission, or
- * by the inline hydration script that mirrors it to the client.
- */
-/** Redirect counter the action-client runtime bumps (see markActionRedirected). */
-function actionRedirectCount(): number {
-  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__;
-  if (
-    override !== null &&
-    typeof override === 'object' &&
-    'skip' in override &&
-    typeof override.skip === 'number' &&
-    override.skip > 0
-  ) {
-    override.skip--;
-    return undefined;
-  }
-  delete holder.__PNEXT_ACTION_STATE__;
-  return {
-    value:
-      override !== null && typeof override === 'object' && 'value' in override
-        ? override.value
-        : override,
-  };
-}
-
-/**
- * React 19's useTransition, on preact hooks. preact/compat's own useTransition is a no-op stub that never
- * tracks pending state, so an async transition callback's in-flight window is invisible. Track it with a
- * counter: startTransition(cb) runs cb, and when cb returns a thenable holds `isPending` true until it
- * settles. Concurrent transitions overlap, each incrementing and decrementing, so isPending stays true
- * while ANY is in flight - matching React.
- */
-export function useTransition(): [boolean, (callback: () => void | Promise<void>) => void] {
-  if (!hooksUsable()) return [false, callback => void callback()];
-  const [pending, setPending] = ReactCompat.useState(0);
-  const startTransition = ReactCompat.useCallback((callback: () => void | Promise<void>) => {
-    const mpaBefore = (globalThis as { __pnextMpaNavigation?: number }).__pnextMpaNavigation ?? 0;
-    let result: void | Promise<void>;
-    try {
-      result = callback();
-    } catch {
-      return;
-    }
-    const mpaAfter = (globalThis as { __pnextMpaNavigation?: number }).__pnextMpaNavigation ?? 0;
-    if (mpaAfter !== mpaBefore) {
-      setPending(count => count + 1);
-      return;
-    }
-    if (result && typeof (result as PromiseLike<unknown>).then === 'function') {
-      setPending(count => count + 1);
-      void Promise.resolve(result).finally(() => setPending(count => count - 1));
-    }
-  }, []);
-  return [pending > 0, startTransition];
-}
-
-/**
- * React 19's useOptimistic, on preact hooks (simplified: the optimistic value
- * resets whenever the passthrough (base) value changes on a rerender, which is
- * when the real state has caught up).
- */
-export function useOptimistic<State, Payload = State>(
-  passthrough: State,
-  reducer?: (state: State, payload: Payload) => State,
-): [State, (payload: Payload) => void] {
-  if (!hooksUsable()) return [passthrough, () => undefined];
-  const [optimistic, setOptimistic] = ReactCompat.useState<{ value: State } | null>(null);
-  const lastBase = ReactCompat.useRef(passthrough);
-  if (lastBase.current !== passthrough) {
-    lastBase.current = passthrough;
-    if (optimistic) setOptimistic(null);
-  }
-  const dispatch = ReactCompat.useCallback(
-    (payload: Payload) => {
-      setOptimistic(current => ({
-        value: reducer
-          ? reducer(current ? current.value : lastBase.current, payload)
-          : (payload as unknown as State),
-      }));
-    },
-    [reducer],
-  );
-  return [optimistic ? optimistic.value : passthrough, dispatch];
-}
-
-interface TrackedThenable<T> extends PromiseLike<T> {
-  status?: 'pending' | 'fulfilled' | 'rejected';
-  value?: T;
-  reason?: unknown;
-}
-
-// Replay state for use() in server components: the renderer replays a component
-// after a thrown thenable settles, and use() call N must resolve to the thenable
-// recorded on the previous attempt (the rerun creates a fresh promise).
-export interface UseThenableState {
-  thenables: TrackedThenable<unknown>[];
-}
-
-let activeUseState: UseThenableState | null = null;
-let activeUseIndex = 0;
-
-export function withUseThenableState<T>(state: UseThenableState, run: () => T): T {
-  const previousState = activeUseState;
-  const previousIndex = activeUseIndex;
-  activeUseState = state;
-  activeUseIndex = 0;
-  try {
-    return run();
-  } finally {
-    activeUseState = previousState;
-    activeUseIndex = previousIndex;
-  }
-}
-
-// React 19's use(): unwrap a thenable via suspense, or read a context.
-export function use<T>(usable: PromiseLike<T> | Parameters<typeof ReactCompat.useContext>[0]): T {
-  if (usable && typeof (usable as PromiseLike<T>).then === 'function') {
-    let thenable = usable as TrackedThenable<T>;
-    if (activeUseState) {
-      const index = activeUseIndex++;
-      const existing = activeUseState.thenables[index];
-      if (existing) thenable = existing as TrackedThenable<T>;
-      else activeUseState.thenables[index] = thenable;
-    }
-    if (thenable.status === 'fulfilled') return thenable.value as T;
-    if (thenable.status === 'rejected') throw thenable.reason;
-    if (thenable.status !== 'pending') {
-      thenable.status = 'pending';
-      thenable.then(
-        value => {
-          thenable.status = 'fulfilled';
-          thenable.value = value;
-        },
-        reason => {
-          thenable.status = 'rejected';
-          thenable.reason = reason;
-        },
-      );
-    }
-    // React use() protocol: suspend by throwing the thenable itself.
-    // eslint-disable-next-line @typescript-eslint/only-throw-error
-    throw thenable;
-  }
-  return ReactCompat.useContext(usable as Parameters<typeof ReactCompat.useContext>[0]) as T;
-}

package/src/compat/react/server-inserted-html.ts

@@ -24,16 +24,23 @@ interface Holder {
 }
 
 const collectorKey = Symbol.for('pnext.serverInsertedHTML');
-let getRequestScope: (() => Record<PropertyKey, unknown> | undefined) | undefined;
+type RequestScopeGetter = () => Record<PropertyKey, unknown> | undefined;
+// globalThis-anchored: the prebundled server entry inlines its own copy of this module.
+const SCOPE_GETTER_KEY = Symbol.for('pnext.serverInsertedHTMLScope');
 
-export function setServerInsertedHTMLScope(
-  getter: () => Record<PropertyKey, unknown> | undefined,
-): void {
-  getRequestScope = getter;
+export function setServerInsertedHTMLScope(getter: RequestScopeGetter): void {
+  (globalThis as Record<PropertyKey, unknown>)[SCOPE_GETTER_KEY] = getter;
+}
+
+function requestScope(): Record<PropertyKey, unknown> | undefined {
+  const getter = (globalThis as Record<PropertyKey, unknown>)[SCOPE_GETTER_KEY] as
+    | RequestScopeGetter
+    | undefined;
+  return getter?.();
 }
 
 function collector(): { callbacks: InsertCallback[]; scoped: boolean } {
-  const scope = getRequestScope?.();
+  const scope = requestScope();
   if (scope) {
     return {
       callbacks: (scope[collectorKey] ??= []) as InsertCallback[],
@@ -81,7 +88,7 @@ export function renderServerInsertedHTML(): string {
 
 /** Discard any registered callbacks without rendering (error / reset paths). */
 export function clearServerInsertedHTML(): void {
-  const scope = getRequestScope?.();
+  const scope = requestScope();
   if (scope) scope[collectorKey] = [];
   else (globalThis as Holder).__PNEXT_SERVER_INSERTED_HTML__ = [];
 }

package/src/compat/react/use.ts

@@ -0,0 +1,72 @@
+import { useContext } from 'preact/hooks';
+import type { Context } from 'preact';
+
+interface TrackedThenable<T> extends PromiseLike<T> {
+  status?: 'pending' | 'fulfilled' | 'rejected';
+  value?: T;
+  reason?: unknown;
+}
+
+// Replay state for use() in server components: the renderer replays a component
+// after a thrown thenable settles, and use() call N must resolve to the thenable
+// recorded on the previous attempt (the rerun creates a fresh promise).
+export interface UseThenableState {
+  thenables: TrackedThenable<unknown>[];
+}
+
+// globalThis-anchored: the prebundled server entry inlines its own copy of this module;
+// a replay in one copy must be visible to use() in the other or retries loop forever.
+interface UseReplayState {
+  active: UseThenableState | null;
+  index: number;
+}
+const REPLAY_STATE_KEY = Symbol.for('pnext.useReplayState');
+const replayState = ((globalThis as Record<PropertyKey, unknown>)[REPLAY_STATE_KEY] ??= {
+  active: null,
+  index: 0,
+}) as UseReplayState;
+
+export function withUseThenableState<T>(state: UseThenableState, run: () => T): T {
+  const previousState = replayState.active;
+  const previousIndex = replayState.index;
+  replayState.active = state;
+  replayState.index = 0;
+  try {
+    return run();
+  } finally {
+    replayState.active = previousState;
+    replayState.index = previousIndex;
+  }
+}
+
+// React 19's use(): unwrap a thenable via suspense, or read a context.
+export function use<T>(usable: PromiseLike<T> | Context<T>): T {
+  if (usable && typeof (usable as PromiseLike<T>).then === 'function') {
+    let thenable = usable as TrackedThenable<T>;
+    if (replayState.active) {
+      const index = replayState.index++;
+      const existing = replayState.active.thenables[index];
+      if (existing) thenable = existing as TrackedThenable<T>;
+      else replayState.active.thenables[index] = thenable;
+    }
+    if (thenable.status === 'fulfilled') return thenable.value as T;
+    if (thenable.status === 'rejected') throw thenable.reason;
+    if (thenable.status !== 'pending') {
+      thenable.status = 'pending';
+      thenable.then(
+        value => {
+          thenable.status = 'fulfilled';
+          thenable.value = value;
+        },
+        reason => {
+          thenable.status = 'rejected';
+          thenable.reason = reason;
+        },
+      );
+    }
+    // React use() protocol: suspend by throwing the thenable itself.
+    // eslint-disable-next-line @typescript-eslint/only-throw-error
+    throw thenable;
+  }
+  return useContext(usable as Context<T>);
+}

package/src/compat/register/actions.ts

@@ -43,6 +43,7 @@ import { serverBundleTargetForRuntime } from '../../runtime/server';
 import {
   renderActionReturnElement,
   renderGlobalNotFoundResponse,
+  renderNotFoundForRoute,
   renderPage,
   renderPageResponse,
 } from '../../render';
@@ -163,6 +164,7 @@ export function registerActionExtensions(_config: ResolvedConfig): void {
 interface ActionStepState {
   actions: ActionManifestEntry[];
   actionSources?: string[];
+  actionImporters?: string[];
   deferred?: Promise<void>;
 }
 
@@ -175,6 +177,7 @@ const runActionBuildStep: BuildStep = async (ctx: BuildStepContext): Promise<voi
     ? ctx.log.step('action discovery', () => discoverActions(config))
     : discoverActions(config));
   state.actionSources = actionSourceKeys(config, discovery);
+  state.actionImporters = [...discovery.actionImporters];
   // Compiling those modules to server bundles produces manifest entries nothing
   // upstream of the build manifest reads, so it is handed back to run under the
   // client stage instead of ahead of it.
@@ -436,14 +439,31 @@ function buildServeActionOptions(
   const options: ServeActionOptions = {
     ...(dev ? { dev: true } : {}),
     importModule,
+    // skipNoindex: Next omits the fallback robots meta for an action-triggered
+    // not-found (app-render's NonIndex), keeping the page's own robots value.
     renderNotFound: async notFoundRequest =>
-      renderGlobalNotFoundResponse({
-        config,
-        url: new URL(notFoundRequest.url),
-        // GET conversion: the page renderer refuses non-GET requests.
-        request: new Request(notFoundRequest.url, { headers: notFoundRequest.headers }),
-        ...(dev ? { dev: true, devImportVersion: version } : {}),
-      }),
+      actionTarget?.route.kind === 'page'
+        ? renderNotFoundForRoute(
+            {
+              config,
+              route: actionTarget.route,
+              params: actionTarget.params,
+              url: new URL(notFoundRequest.url),
+              // GET conversion: the page renderer refuses non-GET requests.
+              request: new Request(notFoundRequest.url, { headers: notFoundRequest.headers }),
+              ...(dev ? { dev: true, devImportVersion: version } : {}),
+            },
+            { skipNoindex: true },
+          )
+        : renderGlobalNotFoundResponse(
+            {
+              config,
+              url: new URL(notFoundRequest.url),
+              request: new Request(notFoundRequest.url, { headers: notFoundRequest.headers }),
+              ...(dev ? { dev: true, devImportVersion: version } : {}),
+            },
+            { skipNoindex: true },
+          ),
     renderPageForFormState: async (formRequest, state, actionId) => {
       if (actionTarget?.route.kind !== 'page') return null;
       const formUrl = new URL(formRequest.url);