@wular/pnext 0.0.4 → 0.0.7

package/src/compat/react/parity.ts

@@ -1,28 +1,28 @@
-import { options, type ComponentType, type VNode } from 'preact';
-import { wrapComponentForPrimitiveThrows } from '../client/errors/primitive-throw';
+import { options, 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');
+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;
-};
+  [react19RefCompatInstalled]?: true
+}
 
 type RefCompatibleComponent = ComponentType<Record<string, unknown>> & {
-  $$typeof?: symbol;
-  prototype?: { render?: 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;
+let reactCompatActive = true
 
 /** Enable/disable the react-compat vnode parity pass (see reactCompatActive). */
 export function setReactCompatActive(active: boolean): void {
-  reactCompatActive = active;
+  reactCompatActive = active
 }
 
 // Suspense-dependent parity (thenable children, async client components) needs preact/compat, which a
@@ -30,29 +30,29 @@ export function setReactCompatActive(active: boolean): void {
 // the slot empty and its bundle drops preact/compat entirely. Two phases: async-component wrapping must
 // see the raw component (before primitive-throw wraps it); thenable children run after.
 interface SuspenseParity {
-  beforeThrowSafety(vnode: VNode): void;
-  afterThrowSafety(vnode: VNode): void;
+  beforeThrowSafety(vnode: VNode): void
+  afterThrowSafety(vnode: VNode): void
 }
 
-let suspenseParity: SuspenseParity | undefined;
+let suspenseParity: SuspenseParity | undefined
 
 export function setSuspenseParity(pass: SuspenseParity): void {
-  suspenseParity = pass;
+  suspenseParity = pass
 }
 
-const pnextOptions = options as PNextPreactOptions;
+const pnextOptions = options as PNextPreactOptions
 if (!pnextOptions[react19RefCompatInstalled]) {
-  const previousVNode = options.vnode?.bind(options);
+  const previousVNode = options.vnode?.bind(options)
   options.vnode = vnode => {
-    previousVNode?.(vnode);
-    if (!reactCompatActive) return;
-    applyReact19RefProp(vnode);
-    suspenseParity?.beforeThrowSafety(vnode);
-    applyPrimitiveThrowSafety(vnode);
-    suspenseParity?.afterThrowSafety(vnode);
-    applyReactTextSeparators(vnode);
-  };
-  pnextOptions[react19RefCompatInstalled] = true;
+    previousVNode?.(vnode)
+    if (!reactCompatActive) return
+    applyReact19RefProp(vnode)
+    suspenseParity?.beforeThrowSafety(vnode)
+    applyPrimitiveThrowSafety(vnode)
+    suspenseParity?.afterThrowSafety(vnode)
+    applyReactTextSeparators(vnode)
+  }
+  pnextOptions[react19RefCompatInstalled] = true
 
   // Effect scheduling parity with React: preact/hooks flushes passive effects
   // via requestAnimationFrame + setTimeout(35) (afterNextFrame), both governed
@@ -64,16 +64,16 @@ if (!pnextOptions[react19RefCompatInstalled]) {
   // 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();
+    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 =
+      for (const callback of queue.splice(0)) callback()
+    }
+    ;(options as { requestAnimationFrame?: (cb: () => void) => void }).requestAnimationFrame =
       callback => {
-        queue.push(callback);
-        channel.port2.postMessage(null);
-      };
+        queue.push(callback)
+        channel.port2.postMessage(null)
+      }
   }
 }
 
@@ -81,31 +81,31 @@ 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;
+  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;
+    const child = values[index]
+    separated.push(child)
+    if (!mayRenderText(child) || !mayRenderText(values[index + 1])) continue
     separated.push({
       type: reactTextSeparatorSymbol,
       props: { UNSTABLE_comment: ' ' },
-    });
-    changed = true;
+    })
+    changed = true
   }
-  if (changed) props.children = separated;
+  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';
+  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'
 }
 
 function applyPrimitiveThrowSafety(vnode: VNode) {
@@ -113,16 +113,19 @@ function applyPrimitiveThrowSafety(vnode: VNode) {
   // 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);
+  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;
+  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
 }

package/src/compat/react/preact.ts

@@ -1,9 +1,9 @@
-import ReactCompat from 'preact/compat';
-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';
+import ReactCompat from 'preact/compat'
+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
@@ -12,22 +12,22 @@ import { useOptimistic, useTransition } from './hooks-extra';
 setSuspenseParity({
   beforeThrowSafety: applyAsyncClientComponent,
   afterThrowSafety: applyThenableChildren,
-});
+})
 
-export { setReactCompatActive } from './parity';
-export { use, withUseThenableState, type UseThenableState } from './use';
+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';
+} from './action-state'
+export { useOptimistic, useTransition } from './hooks-extra'
 
 function applyThenableChildren(vnode: VNode) {
-  const props = vnode.props as Record<string, unknown>;
-  const children = props.children;
-  const resolved = thenableChildren(children);
-  if (resolved !== children) props.children = resolved;
+  const props = vnode.props as Record<string, unknown>
+  const children = props.children
+  const resolved = thenableChildren(children)
+  if (resolved !== children) props.children = resolved
 }
 
 function thenableChildren(value: unknown): unknown {
@@ -38,98 +38,97 @@ function thenableChildren(value: unknown): unknown {
       ReactCompat.createElement(ThenableChild, {
         value: value as PromiseLike<ComponentChildren>,
       }),
-    );
+    )
   }
-  if (!Array.isArray(value)) return value;
-  let changed = false;
+  if (!Array.isArray(value)) return value
+  let changed = false
   const children = value.map(child => {
-    const resolved = thenableChildren(child);
-    if (resolved !== child) changed = true;
-    return resolved;
-  });
-  return changed ? children : value;
+    const resolved = thenableChildren(child)
+    if (resolved !== child) changed = true
+    return resolved
+  })
+  return changed ? children : value
 }
 
 function ThenableChild({ value }: { value: PromiseLike<ComponentChildren> }) {
-  return use(value);
+  return use(value)
 }
 
 const asyncClientComponents = new WeakMap<
   ComponentType<Record<string, unknown>>,
   ComponentType<Record<string, unknown>>
->();
+>()
 
 function applyAsyncClientComponent(vnode: VNode) {
-  if ((!process.browser && typeof window === 'undefined') || typeof vnode.type !== 'function') return;
-  const component = vnode.type as ComponentType<Record<string, unknown>>;
-  if (component.constructor.name !== 'AsyncFunction') return;
-  const renderComponent = component as (props: Record<string, unknown>) => ComponentChildren;
-  let wrapper = asyncClientComponents.get(component);
+  if ((!process.browser && typeof window === 'undefined') || typeof vnode.type !== 'function')
+    return
+  const component = vnode.type as ComponentType<Record<string, unknown>>
+  if (component.constructor.name !== 'AsyncFunction') return
+  const renderComponent = component as (props: Record<string, unknown>) => ComponentChildren
+  let wrapper = asyncClientComponents.get(component)
   if (!wrapper) {
     wrapper = props => {
-      const [result] = ReactCompat.useState(() =>
-        Promise.resolve(renderComponent(props)),
-      );
+      const [result] = ReactCompat.useState(() => Promise.resolve(renderComponent(props)))
       return ReactCompat.createElement(
         ReactCompat.Suspense,
         { fallback: null },
         ReactCompat.createElement(ThenableChild, { value: result }),
-      );
-    };
-    asyncClientComponents.set(component, wrapper);
+      )
+    }
+    asyncClientComponents.set(component, wrapper)
   }
-  vnode.type = wrapper;
+  vnode.type = wrapper
 }
 
 // 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 default Object.assign(ReactCompat, { use, useActionState, useOptimistic, useTransition })
 
-export const Children = ReactCompat.Children;
-export const Component = ReactCompat.Component;
-export const Fragment = ReactCompat.Fragment;
-export const PureComponent = ReactCompat.PureComponent;
-export const StrictMode = ReactCompat.StrictMode;
-export const Suspense = ReactCompat.Suspense;
-export const SuspenseList = ReactCompat.SuspenseList;
-export const cloneElement = ReactCompat.cloneElement;
-export const createContext = ReactCompat.createContext;
-export const createElement = ReactCompat.createElement;
-export const createFactory = ReactCompat.createFactory;
-export const createPortal = ReactCompat.createPortal;
-export const createRef = ReactCompat.createRef;
-export const findDOMNode = ReactCompat.findDOMNode;
-export const flushSync = ReactCompat.flushSync;
-export const forwardRef = ReactCompat.forwardRef;
-export const hydrate = ReactCompat.hydrate;
-export const isFragment = ReactCompat.isFragment;
-export const isMemo = ReactCompat.isMemo;
-export const isValidElement = ReactCompat.isValidElement;
+export const Children = ReactCompat.Children
+export const Component = ReactCompat.Component
+export const Fragment = ReactCompat.Fragment
+export const PureComponent = ReactCompat.PureComponent
+export const StrictMode = ReactCompat.StrictMode
+export const Suspense = ReactCompat.Suspense
+export const SuspenseList = ReactCompat.SuspenseList
+export const cloneElement = ReactCompat.cloneElement
+export const createContext = ReactCompat.createContext
+export const createElement = ReactCompat.createElement
+export const createFactory = ReactCompat.createFactory
+export const createPortal = ReactCompat.createPortal
+export const createRef = ReactCompat.createRef
+export const findDOMNode = ReactCompat.findDOMNode
+export const flushSync = ReactCompat.flushSync
+export const forwardRef = ReactCompat.forwardRef
+export const hydrate = ReactCompat.hydrate
+export const isFragment = ReactCompat.isFragment
+export const isMemo = ReactCompat.isMemo
+export const isValidElement = ReactCompat.isValidElement
 // 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;
-export const unmountComponentAtNode = ReactCompat.unmountComponentAtNode;
-export const unstable_batchedUpdates = ReactCompat.unstable_batchedUpdates;
-export const useCallback = ReactCompat.useCallback;
-export const useContext = ReactCompat.useContext;
-export const useDebugValue = ReactCompat.useDebugValue;
-export const useDeferredValue = ReactCompat.useDeferredValue;
-export const useEffect = ReactCompat.useEffect;
-export const useId = ReactCompat.useId;
-export const useImperativeHandle = ReactCompat.useImperativeHandle;
-export const useInsertionEffect = ReactCompat.useInsertionEffect;
-export const useLayoutEffect = ReactCompat.useLayoutEffect;
-export const useMemo = ReactCompat.useMemo;
-export const useReducer = ReactCompat.useReducer;
-export const useRef = ReactCompat.useRef;
-export const useState = ReactCompat.useState;
-export const useSyncExternalStore = ReactCompat.useSyncExternalStore;
-export const version = ReactCompat.version;
+  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
+export const unmountComponentAtNode = ReactCompat.unmountComponentAtNode
+export const unstable_batchedUpdates = ReactCompat.unstable_batchedUpdates
+export const useCallback = ReactCompat.useCallback
+export const useContext = ReactCompat.useContext
+export const useDebugValue = ReactCompat.useDebugValue
+export const useDeferredValue = ReactCompat.useDeferredValue
+export const useEffect = ReactCompat.useEffect
+export const useId = ReactCompat.useId
+export const useImperativeHandle = ReactCompat.useImperativeHandle
+export const useInsertionEffect = ReactCompat.useInsertionEffect
+export const useLayoutEffect = ReactCompat.useLayoutEffect
+export const useMemo = ReactCompat.useMemo
+export const useReducer = ReactCompat.useReducer
+export const useRef = ReactCompat.useRef
+export const useState = ReactCompat.useState
+export const useSyncExternalStore = ReactCompat.useSyncExternalStore
+export const version = ReactCompat.version

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

@@ -41,44 +41,44 @@ export {
   useActionState,
   useOptimistic,
   version,
-} from './preact';
-export { cache } from '../../api/cache';
+} from './preact'
+export { cache } from '../../api/cache'
 
-import { ViewTransition, addTransitionType } from './view-transition';
-export { ViewTransition, addTransitionType };
+import { ViewTransition, addTransitionType } from './view-transition'
+export { ViewTransition, addTransitionType }
 
-import { currentPrerenderScope } from '../../ppr';
-import { currentCacheSignal } from '../../cache/context';
+import { currentPrerenderScope } from '../../render/ppr'
+import { currentCacheSignal } from '../../request/cache'
 
 // React.cacheSignal(): the AbortSignal for the current render. During a build
 // prerender it is the prerender scope's signal; during a request/dynamic render
 // it is the cache scope's. Null outside any render. Slow cache components bound
 // their polling on it (see cache-components ppr-partial-hydration).
 export function cacheSignal(): AbortSignal | null {
-  const prerender = currentPrerenderScope();
-  if (prerender) return prerender.signal;
-  return currentCacheSignal();
+  const prerender = currentPrerenderScope()
+  if (prerender) return prerender.signal
+  return currentCacheSignal()
 }
 
-import ReactCompat from './preact';
-import { cache as serverCache } from '../../api/cache';
+import ReactCompat from './preact'
+import { cache as serverCache } from '../../api/cache'
 
 const ReactServer = { ...ReactCompat } as typeof ReactCompat & {
-  cache: typeof serverCache;
-  cacheSignal: typeof cacheSignal;
-};
-delete (ReactServer as { useState?: unknown }).useState;
-delete (ReactServer as { useEffect?: unknown }).useEffect;
-delete (ReactServer as { useLayoutEffect?: unknown }).useLayoutEffect;
-delete (ReactServer as { useInsertionEffect?: unknown }).useInsertionEffect;
-delete (ReactServer as { useImperativeHandle?: unknown }).useImperativeHandle;
-delete (ReactServer as { useReducer?: unknown }).useReducer;
-delete (ReactServer as { useRef?: unknown }).useRef;
-delete (ReactServer as { useDeferredValue?: unknown }).useDeferredValue;
-delete (ReactServer as { useTransition?: unknown }).useTransition;
-delete (ReactServer as { useSyncExternalStore?: unknown }).useSyncExternalStore;
-ReactServer.cache = serverCache;
-ReactServer.cacheSignal = cacheSignal;
-Object.assign(ReactServer, { ViewTransition, addTransitionType });
+  cache: typeof serverCache
+  cacheSignal: typeof cacheSignal
+}
+delete (ReactServer as { useState?: unknown }).useState
+delete (ReactServer as { useEffect?: unknown }).useEffect
+delete (ReactServer as { useLayoutEffect?: unknown }).useLayoutEffect
+delete (ReactServer as { useInsertionEffect?: unknown }).useInsertionEffect
+delete (ReactServer as { useImperativeHandle?: unknown }).useImperativeHandle
+delete (ReactServer as { useReducer?: unknown }).useReducer
+delete (ReactServer as { useRef?: unknown }).useRef
+delete (ReactServer as { useDeferredValue?: unknown }).useDeferredValue
+delete (ReactServer as { useTransition?: unknown }).useTransition
+delete (ReactServer as { useSyncExternalStore?: unknown }).useSyncExternalStore
+ReactServer.cache = serverCache
+ReactServer.cacheSignal = cacheSignal
+Object.assign(ReactServer, { ViewTransition, addTransitionType })
 
-export default ReactServer;
+export default ReactServer

package/src/compat/react/router-shim.ts

@@ -22,5 +22,5 @@ export function nextRouterShimScript(): string {
     'r.replace=r.replace||function(href){location.replace(String(href));return Promise.resolve(true)};' +
     'r.prefetch=r.prefetch||function(){return Promise.resolve(null)};' +
     '})();</script>'
-  );
+  )
 }

package/src/compat/react/server-component-use.ts

@@ -15,14 +15,14 @@
 // Registered onto renderExtensions.wrapServerComponentInvoke; a pure-core app keeps the pass-through
 // default and never loads this module.
 
-import { withUseThenableState, type UseThenableState } from './preact';
+import { withUseThenableState, type UseThenableState } from './preact'
 
 function isThenable(value: unknown): value is PromiseLike<unknown> {
   return (
     value != null &&
     (typeof value === 'object' || typeof value === 'function') &&
     typeof (value as PromiseLike<unknown>).then === 'function'
-  );
+  )
 }
 
 /**
@@ -31,18 +31,18 @@ function isThenable(value: unknown): value is PromiseLike<unknown> {
  * thenable state; async components (and plain returns) pass through.
  */
 export function invokeServerComponentWithUse<T>(invoke: () => T): T {
-  const state: UseThenableState = { thenables: [] };
+  const state: UseThenableState = { thenables: [] }
 
   const attempt = (): T => {
     try {
-      return withUseThenableState(state, invoke);
+      return withUseThenableState(state, invoke)
     } catch (error) {
       // A pending use() thenable suspends the component: await it, then replay
       // with the same state so the settled thenable resolves in place.
-      if (isThenable(error)) return Promise.resolve(error).then(attempt, attempt) as T;
-      throw error;
+      if (isThenable(error)) return Promise.resolve(error).then(attempt, attempt) as T
+      throw error
     }
-  };
+  }
 
-  return attempt();
+  return attempt()
 }

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

@@ -13,46 +13,45 @@
 // renderServerInsertedHTML() renders each callback's vnode to a string and concatenates it. CSS-in-JS
 // registries clear their emitted rules per call.
 
-import { h, Fragment } from 'preact';
-import type { ComponentChildren, VNode } from 'preact';
-import renderToString from 'preact-render-to-string';
+import { h, Fragment } from 'preact'
+import type { ComponentChildren, VNode } from 'preact'
+import renderToString from 'preact-render-to-string'
 
-type InsertCallback = () => ComponentChildren;
+type InsertCallback = () => ComponentChildren
 
 interface Holder {
-  __PNEXT_SERVER_INSERTED_HTML__?: InsertCallback[];
+  __PNEXT_SERVER_INSERTED_HTML__?: InsertCallback[]
 }
 
-const collectorKey = Symbol.for('pnext.serverInsertedHTML');
-type RequestScopeGetter = () => Record<PropertyKey, unknown> | undefined;
+const collectorKey = Symbol.for('pnext.serverInsertedHTML')
+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');
+const SCOPE_GETTER_KEY = Symbol.for('pnext.serverInsertedHTMLScope')
 
 export function setServerInsertedHTMLScope(getter: RequestScopeGetter): void {
-  (globalThis as Record<PropertyKey, unknown>)[SCOPE_GETTER_KEY] = getter;
+  ;(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?.();
+    RequestScopeGetter | undefined
+  return getter?.()
 }
 
 function collector(): { callbacks: InsertCallback[]; scoped: boolean } {
-  const scope = requestScope();
+  const scope = requestScope()
   if (scope) {
     return {
       callbacks: (scope[collectorKey] ??= []) as InsertCallback[],
       scoped: true,
-    };
+    }
   }
-  const holder = globalThis as Holder;
-  holder.__PNEXT_SERVER_INSERTED_HTML__ ??= [];
-  return { callbacks: holder.__PNEXT_SERVER_INSERTED_HTML__, scoped: false };
+  const holder = globalThis as Holder
+  holder.__PNEXT_SERVER_INSERTED_HTML__ ??= []
+  return { callbacks: holder.__PNEXT_SERVER_INSERTED_HTML__, scoped: false }
 }
 
-const isServer = typeof document === 'undefined';
+const isServer = typeof document === 'undefined'
 
 /**
  * Register HTML to be inserted into the server-rendered document. The callback returns JSX (typically
@@ -60,8 +59,8 @@ const isServer = typeof document === 'undefined';
  * already carries the styles and the CSS-in-JS runtime rehydrates them itself.
  */
 export function useServerInsertedHTML(callback: InsertCallback): void {
-  if (!isServer) return;
-  collector().callbacks.push(callback);
+  if (!isServer) return
+  collector().callbacks.push(callback)
 }
 
 /**
@@ -69,26 +68,26 @@ export function useServerInsertedHTML(callback: InsertCallback): void {
  * for later stream flushes; the non-request fallback is cleared after one use.
  */
 export function renderServerInsertedHTML(): string {
-  const { callbacks, scoped } = collector();
-  if (!scoped) (globalThis as Holder).__PNEXT_SERVER_INSERTED_HTML__ = [];
-  if (callbacks.length === 0) return '';
+  const { callbacks, scoped } = collector()
+  if (!scoped) (globalThis as Holder).__PNEXT_SERVER_INSERTED_HTML__ = []
+  if (callbacks.length === 0) return ''
 
-  const parts: string[] = [];
+  const parts: string[] = []
   for (const callback of callbacks) {
     try {
-      const node = callback();
-      if (node == null || node === false) continue;
-      parts.push(renderToString(h(Fragment, null, node as VNode)));
+      const node = callback()
+      if (node == null || node === false) continue
+      parts.push(renderToString(h(Fragment, null, node as VNode)))
     } catch {
       // A registry that throws during flush is skipped, not fatal.
     }
   }
-  return parts.join('');
+  return parts.join('')
 }
 
 /** Discard any registered callbacks without rendering (error / reset paths). */
 export function clearServerInsertedHTML(): void {
-  const scope = requestScope();
-  if (scope) scope[collectorKey] = [];
-  else (globalThis as Holder).__PNEXT_SERVER_INSERTED_HTML__ = [];
+  const scope = requestScope()
+  if (scope) scope[collectorKey] = []
+  else (globalThis as Holder).__PNEXT_SERVER_INSERTED_HTML__ = []
 }