hadars 0.1.9 → 0.1.10

package/src/build.ts

@@ -10,6 +10,7 @@ import { RspackDevServer } from "@rspack/dev-server";
 import pathMod from "node:path";
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { createRequire } from 'node:module';
+import crypto from 'node:crypto';
 import fs from 'node:fs/promises';
 import { existsSync } from 'node:fs';
 import os from 'node:os';
@@ -53,6 +54,9 @@ class RenderWorkerPool {
     private workerPending = new Map<any, Set<number>>();
     private nextId = 0;
     private rrIndex = 0;
+    private _Worker: any = null;
+    private _workerPath = '';
+    private _ssrBundlePath = '';
 
     constructor(workerPath: string, size: number, ssrBundlePath: string) {
         // Dynamically import Worker so this class can be defined at module load
@@ -61,36 +65,42 @@ class RenderWorkerPool {
     }
 
     private _init(workerPath: string, size: number, ssrBundlePath: string) {
+        this._workerPath = workerPath;
+        this._ssrBundlePath = ssrBundlePath;
         import('node:worker_threads').then(({ Worker }) => {
-            for (let i = 0; i < size; i++) {
-                const w = new Worker(workerPath, { workerData: { ssrBundlePath } });
-                this.workerPending.set(w, new Set());
-                w.on('message', (msg: any) => {
-                    const { id, html, headHtml, status, error } = msg;
-                    const p = this.pending.get(id);
-                    if (!p) return;
-                    this.pending.delete(id);
-                    this.workerPending.get(w)?.delete(id);
-                    if (error) p.reject(new Error(error));
-                    else p.resolve({ html, headHtml, status });
-                });
-                w.on('error', (err: Error) => {
-                    console.error('[hadars] Render worker error:', err);
-                    this._handleWorkerDeath(w, err);
-                });
-                w.on('exit', (code: number) => {
-                    if (code !== 0) {
-                        console.error(`[hadars] Render worker exited with code ${code}`);
-                        this._handleWorkerDeath(w, new Error(`Render worker exited with code ${code}`));
-                    }
-                });
-                this.workers.push(w);
-            }
+            this._Worker = Worker;
+            for (let i = 0; i < size; i++) this._spawnWorker();
         }).catch(err => {
             console.error('[hadars] Failed to initialise render worker pool:', err);
         });
     }
 
+    private _spawnWorker() {
+        if (!this._Worker) return;
+        const w = new this._Worker(this._workerPath, { workerData: { ssrBundlePath: this._ssrBundlePath } });
+        this.workerPending.set(w, new Set());
+        w.on('message', (msg: any) => {
+            const { id, html, headHtml, status, error } = msg;
+            const p = this.pending.get(id);
+            if (!p) return;
+            this.pending.delete(id);
+            this.workerPending.get(w)?.delete(id);
+            if (error) p.reject(new Error(error));
+            else p.resolve({ html, headHtml, status });
+        });
+        w.on('error', (err: Error) => {
+            console.error('[hadars] Render worker error:', err);
+            this._handleWorkerDeath(w, err);
+        });
+        w.on('exit', (code: number) => {
+            if (code !== 0) {
+                console.error(`[hadars] Render worker exited with code ${code}`);
+                this._handleWorkerDeath(w, new Error(`Render worker exited with code ${code}`));
+            }
+        });
+        this.workers.push(w);
+    }
+
     private _handleWorkerDeath(w: any, err: Error) {
         const idx = this.workers.indexOf(w);
         if (idx !== -1) this.workers.splice(idx, 1);
@@ -106,6 +116,10 @@ class RenderWorkerPool {
             }
             this.workerPending.delete(w);
         }
+
+        // Spawn a replacement to keep the pool at full capacity.
+        console.log('[hadars] Spawning replacement render worker');
+        this._spawnWorker();
     }
 
     private nextWorker(): any | undefined {
@@ -319,7 +333,7 @@ export const dev = async (options: HadarsRuntimeOptions) => {
     await fs.writeFile(tmpFilePath, clientScript);
 
     // SSR live-reload id to force re-import
-    let ssrBuildId = Date.now();
+    let ssrBuildId = crypto.randomBytes(4).toString('hex');
 
     // Start rspack-dev-server for the client bundle. It provides true React
     // Fast Refresh HMR: the browser's HMR runtime connects directly to the
@@ -435,7 +449,7 @@ export const dev = async (options: HadarsRuntimeOptions) => {
                     const chunk = decoder.decode(value, { stream: true });
                     try { process.stdout.write(chunk); } catch (e) { }
                     if (chunk.includes(rebuildMarker)) {
-                        ssrBuildId = Date.now();
+                        ssrBuildId = crypto.randomBytes(4).toString('hex');
                         console.log('[hadars] SSR bundle updated, build id:', ssrBuildId);
                     }
                 }
@@ -491,25 +505,34 @@ export const dev = async (options: HadarsRuntimeOptions) => {
         // (cache-busting key) rather than a literal filename character on Linux.
         const importPath = pathToFileURL(ssrComponentPath).href + `?t=${ssrBuildId}`;
 
-        const {
-            default: Component,
-            getInitProps,
-            getAfterRenderProps,
-            getFinalProps,
-        } = (await import(importPath)) as HadarsEntryModule<any>;
-
-        const { ReactPage, status, headHtml, renderPayload } = await getReactResponse(request, {
-            document: {
-                body: Component as React.FC<HadarsProps<object>>,
-                lang: 'en',
+        try {
+            const {
+                default: Component,
                 getInitProps,
                 getAfterRenderProps,
                 getFinalProps,
-            },
-        });
+            } = (await import(importPath)) as HadarsEntryModule<any>;
+
+            const { ReactPage, status, headHtml, renderPayload } = await getReactResponse(request, {
+                document: {
+                    body: Component as React.FC<HadarsProps<object>>,
+                    lang: 'en',
+                    getInitProps,
+                    getAfterRenderProps,
+                    getFinalProps,
+                },
+            });
 
-        const unsuspend = (renderPayload.appProps.context as any)?._unsuspend ?? null;
-        return buildSsrResponse(ReactPage, headHtml, status, getPrecontentHtml, unsuspend);
+            const unsuspend = (renderPayload.appProps.context as any)?._unsuspend ?? null;
+            return buildSsrResponse(ReactPage, headHtml, status, getPrecontentHtml, unsuspend);
+        } catch (err: any) {
+            console.error('[hadars] SSR render error:', err);
+            const msg = (err?.stack ?? err?.message ?? String(err)).replace(/</g, '&lt;');
+            return new Response(`<!doctype html><pre style="white-space:pre-wrap">${msg}</pre>`, {
+                status: 500,
+                headers: { 'Content-Type': 'text/html; charset=utf-8' },
+            });
+        }
     }, options.websocket);
 };
 
@@ -656,35 +679,41 @@ export const run = async (options: HadarsRuntimeOptions) => {
         const componentPath = pathToFileURL(
             pathMod.resolve(__dirname, HadarsFolder, SSR_FILENAME)
         ).href;
-        const {
-            default: Component,
-            getInitProps,
-            getAfterRenderProps,
-            getFinalProps,
-        } = (await import(componentPath)) as HadarsEntryModule<any>;
-
-        if (renderPool) {
-            // Worker runs the full lifecycle — no non-serializable objects cross the thread boundary.
-            const serialReq = await serializeRequest(request);
-            const { html, headHtml: wHead, status: wStatus } = await renderPool.renderFull(serialReq);
-            const [precontentHtml, postContent] = await getPrecontentHtml(wHead);
-            return new Response(precontentHtml + html + postContent, {
-                headers: { 'Content-Type': 'text/html; charset=utf-8' },
-                status: wStatus,
-            });
-        }
 
-        const { ReactPage, status, headHtml, renderPayload } = await getReactResponse(request, {
-            document: {
-                body: Component as React.FC<HadarsProps<object>>,
-                lang: 'en',
+        try {
+            const {
+                default: Component,
                 getInitProps,
                 getAfterRenderProps,
                 getFinalProps,
-            },
-        });
+            } = (await import(componentPath)) as HadarsEntryModule<any>;
+
+            if (renderPool) {
+                // Worker runs the full lifecycle — no non-serializable objects cross the thread boundary.
+                const serialReq = await serializeRequest(request);
+                const { html, headHtml: wHead, status: wStatus } = await renderPool.renderFull(serialReq);
+                const [precontentHtml, postContent] = await getPrecontentHtml(wHead);
+                return new Response(precontentHtml + html + postContent, {
+                    headers: { 'Content-Type': 'text/html; charset=utf-8' },
+                    status: wStatus,
+                });
+            }
 
-        const unsuspend = (renderPayload.appProps.context as any)?._unsuspend ?? null;
-        return buildSsrResponse(ReactPage, headHtml, status, getPrecontentHtml, unsuspend);
+            const { ReactPage, status, headHtml, renderPayload } = await getReactResponse(request, {
+                document: {
+                    body: Component as React.FC<HadarsProps<object>>,
+                    lang: 'en',
+                    getInitProps,
+                    getAfterRenderProps,
+                    getFinalProps,
+                },
+            });
+
+            const unsuspend = (renderPayload.appProps.context as any)?._unsuspend ?? null;
+            return buildSsrResponse(ReactPage, headHtml, status, getPrecontentHtml, unsuspend);
+        } catch (err: any) {
+            console.error('[hadars] SSR render error:', err);
+            return new Response('Internal Server Error', { status: 500 });
+        }
     }, options.websocket);
 };

package/src/ssr-render-worker.ts

@@ -146,6 +146,9 @@ async function runFullLifecycle(serialReq: SerializableRequest) {
             await Promise.all(pending);
         }
     } while (unsuspend.hasPending && ++iters < 25);
+    if (unsuspend.hasPending) {
+        console.warn('[hadars] SSR render loop hit the 25-iteration cap — some useServerData values may not be resolved. Check for data dependencies that are never fulfilled.');
+    }
 
     props = getAfterRenderProps ? await getAfterRenderProps(props, html) : props;
 

package/src/utils/Head.tsx

@@ -175,8 +175,10 @@ export const useApp = () => React.useContext(AppContext);
 const clientServerDataCache = new Map<string, unknown>();
 
 /** Call this before hydrating to seed the client cache from the server's data.
- *  Invoked automatically by the hadars client bootstrap. */
+ *  Invoked automatically by the hadars client bootstrap.
+ *  Always clears the existing cache before populating — call with `{}` to just clear. */
 export function initServerDataCache(data: Record<string, unknown>) {
+    clientServerDataCache.clear();
     for (const [k, v] of Object.entries(data)) {
         clientServerDataCache.set(k, v);
     }
@@ -208,7 +210,7 @@ export function initServerDataCache(data: Record<string, unknown>) {
  * if (!user) return null; // undefined while pending on the first SSR pass
  */
 export function useServerData<T>(key: string | string[], fn: () => Promise<T> | T): T | undefined {
-    const cacheKey = Array.isArray(key) ? key.join('\x00') : key;
+    const cacheKey = Array.isArray(key) ? JSON.stringify(key) : key;
 
     if (typeof window !== 'undefined') {
         // Client: if the server serialised a value for this key, return it directly

package/src/utils/clientScript.tsx

@@ -32,8 +32,12 @@ const main = async () => {
 
     const { location } = props;
 
-    if ( appMod.getClientProps ) {
-        props = await appMod.getClientProps(props);
+    if (appMod.getClientProps) {
+        try {
+            props = await appMod.getClientProps(props);
+        } catch (err) {
+            console.error('[hadars] getClientProps threw an error:', err);
+        }
     }
 
     props = {

package/src/utils/loader.ts

@@ -10,6 +10,12 @@
  *    synchronously on the server, wrapped in Promise.resolve to keep the
  *    API shape identical to the client side.
  *
+ * Transformation strategy:
+ *   Primary  — SWC AST parsing via @swc/core. Handles any valid TS/JS syntax
+ *              including arbitrarily-nested generics, comments, and string
+ *              literals that contain the text "loadModule".
+ *   Fallback — Regex transform used when @swc/core is unavailable.
+ *
  * Example usage:
  *
  *   import { loadModule } from 'hadars';
@@ -21,21 +27,197 @@
  *   const { default: fn } = await loadModule('./heavyUtil');
  */
 
-// Matches: loadModule('./path')
-//          loadModule<SomeType>('./path')   (TypeScript generic, any complexity)
-// Captures group 1 = quote char, group 2 = the module path.
-// The `s` flag lets `.` span newlines so multi-line generics are handled.
-const LOAD_MODULE_RE =
-    /\bloadModule\s*(?:<.*?>\s*)?\(\s*(['"`])((?:\\.|(?!\1)[^\\])*)\1\s*\)/gs;
-
 export default function loader(this: any, source: string): string {
     const isServer = this.target === 'node' || this.target === 'async-node';
+    const resourcePath: string = this.resourcePath ?? this.resource ?? '(unknown)';
+
+    let swc: any;
+    try {
+        swc = require('@swc/core');
+    } catch {
+        return regexTransform.call(this, source, isServer, resourcePath);
+    }
+
+    return swcTransform.call(this, swc, source, isServer, resourcePath);
+}
+
+// ---------------------------------------------------------------------------
+// SWC AST transform
+// ---------------------------------------------------------------------------
+
+function swcTransform(this: any, swc: any, source: string, isServer: boolean, resourcePath: string): string {
+    const isTs = /\.[mc]?tsx?$/.test(resourcePath);
+    const isTsx = /\.(tsx|jsx)$/.test(resourcePath);
+
+    let ast: any;
+    try {
+        ast = swc.parseSync(source, {
+            syntax: isTs ? 'typescript' : 'ecmascript',
+            tsx: isTsx,
+        });
+    } catch {
+        // Unparseable file (e.g., exotic syntax) — fall back to regex
+        return regexTransform.call(this, source, isServer, resourcePath);
+    }
+
+    // SWC spans use 1-based byte offsets into a GLOBAL SourceMap that
+    // accumulates across parseSync calls.
+    //
+    // `ast.span.start` = global position of the FIRST meaningful (non-comment,
+    //   non-whitespace) token.  Subtract the leading non-code bytes to get the
+    //   true global start of byte 0 of this source file.
+    //
+    // We do NOT use `ast.span.end - srcBytes.length` because `ast.span.end`
+    // only reaches the last AST token and does not include trailing whitespace
+    // or newlines — causing a systematic off-by-one for the typical file that
+    // ends with `\n`.
+    const srcBytes = Buffer.from(source, 'utf8');
+    const fileOffset = ast.span.start - countLeadingNonCodeBytes(source);
 
-    return source.replace(LOAD_MODULE_RE, (_match, quote, modulePath) => {
-        if (isServer) {
-            return `Promise.resolve(require(${quote}${modulePath}${quote}))`;
+    const replacements: Array<{ start: number; end: number; replacement: string }> = [];
+
+    walkAst(ast, (node: any) => {
+        if (node.type !== 'CallExpression') return;
+
+        const callee = node.callee;
+        if (!callee || callee.type !== 'Identifier' || callee.value !== 'loadModule') return;
+
+        const args: any[] = node.arguments;
+        if (!args || args.length === 0) return;
+
+        const firstArg = args[0].expression ?? args[0];
+
+        let modulePath: string;
+        let quoteChar: string;
+
+        if (firstArg.type === 'StringLiteral') {
+            modulePath = firstArg.value;
+            // The quote char (' " `) is always ASCII so byte index == char index here.
+            const quoteByteIdx = firstArg.span.start - fileOffset;
+            quoteChar = String.fromCharCode(srcBytes[quoteByteIdx]!);
+        } else if (
+            firstArg.type === 'TemplateLiteral' &&
+            firstArg.expressions.length === 0 &&
+            firstArg.quasis.length === 1
+        ) {
+            // No-interpolation template literal: `./path`
+            modulePath = firstArg.quasis[0].raw;
+            quoteChar = '`';
         } else {
-            return `import(${quote}${modulePath}${quote})`;
+            // Dynamic (non-literal) path — emit a build warning
+            const start0 = node.span.start - fileOffset;
+            const bytesBefore = srcBytes.slice(0, start0);
+            const line = bytesBefore.toString('utf8').split('\n').length;
+            this.emitWarning(
+                new Error(
+                    `[hadars] loadModule() called with a dynamic (non-literal) path at ${resourcePath}:${line}. ` +
+                    `Only string-literal paths are transformed by the loader; dynamic calls fall back to runtime import().`
+                )
+            );
+            return;
         }
+        const replacement = isServer
+            ? `Promise.resolve(require(${quoteChar}${modulePath}${quoteChar}))`
+            : `import(${quoteChar}${modulePath}${quoteChar})`;
+
+        // Normalise to 0-based local byte offsets for Buffer.slice
+        replacements.push({ start: node.span.start - fileOffset, end: node.span.end - fileOffset, replacement });
     });
+
+    if (replacements.length === 0) return source;
+
+    // Apply replacements from last to first so earlier byte offsets stay valid
+    replacements.sort((a, b) => b.start - a.start);
+
+    let result = srcBytes;
+    for (const { start, end, replacement } of replacements) {
+        result = Buffer.concat([result.slice(0, start), Buffer.from(replacement, 'utf8'), result.slice(end)]);
+    }
+    return result.toString('utf8');
+}
+
+// Minimal recursive AST walker — visits every node depth-first.
+function walkAst(node: any, visit: (n: any) => void): void {
+    if (!node || typeof node !== 'object') return;
+    visit(node);
+    for (const key of Object.keys(node)) {
+        if (key === 'span' || key === 'type' || key === 'ctxt') continue;
+        const val = node[key];
+        if (Array.isArray(val)) {
+            for (const child of val) walkAst(child, visit);
+        } else if (val && typeof val === 'object') {
+            walkAst(val, visit);
+        }
+    }
+}
+
+// Returns the number of leading bytes that are pure whitespace / comments /
+// shebangs — i.e. bytes before the first actual code token.  Used to anchor
+// SWC's accumulated global span offsets back to byte-0 of this source file.
+function countLeadingNonCodeBytes(source: string): number {
+    let i = 0;
+    while (i < source.length) {
+        // Whitespace
+        if (source[i] === ' ' || source[i] === '\t' || source[i] === '\r' || source[i] === '\n') {
+            i++;
+            continue;
+        }
+        // Line comment  //...
+        if (source[i] === '/' && source[i + 1] === '/') {
+            while (i < source.length && source[i] !== '\n') i++;
+            continue;
+        }
+        // Block comment  /* ... */
+        if (source[i] === '/' && source[i + 1] === '*') {
+            i += 2;
+            while (i + 1 < source.length && !(source[i] === '*' && source[i + 1] === '/')) i++;
+            if (i + 1 < source.length) i += 2;
+            continue;
+        }
+        // Shebang  #!...  (only valid at position 0)
+        if (i === 0 && source[i] === '#' && source[i + 1] === '!') {
+            while (i < source.length && source[i] !== '\n') i++;
+            continue;
+        }
+        break;
+    }
+    // SWC spans are UTF-8 byte offsets, but `i` here is a char index.
+    // Return the byte length of the leading non-code prefix.
+    return Buffer.byteLength(source.slice(0, i), 'utf8');
+}
+
+// ---------------------------------------------------------------------------
+// Regex fallback (used when @swc/core is not available)
+// ---------------------------------------------------------------------------
+
+// Matches loadModule('./path') with optional TypeScript generic (up to 2 levels
+// of nesting). Captures: group 1 = quote char, group 2 = module path.
+const LOAD_MODULE_RE =
+    /\bloadModule\s*(?:<(?:[^<>]|<[^<>]*>)*>\s*)?\(\s*(['"`])((?:\\.|(?!\1)[^\\])*)\1\s*\)/gs;
+
+// Matches any remaining loadModule( that was NOT handled by the regex above
+// (i.e. a dynamic / non-literal path argument).
+const DYNAMIC_LOAD_MODULE_RE = /\bloadModule\s*(?:<(?:[^<>]|<[^<>]*>)*>\s*)?\(/g;
+
+function regexTransform(this: any, source: string, isServer: boolean, resourcePath: string): string {
+    const transformed = source.replace(LOAD_MODULE_RE, (_match, quote, modulePath) =>
+        isServer
+            ? `Promise.resolve(require(${quote}${modulePath}${quote}))`
+            : `import(${quote}${modulePath}${quote})`
+    );
+
+    // Warn for any remaining dynamic calls
+    let match: RegExpExecArray | null;
+    DYNAMIC_LOAD_MODULE_RE.lastIndex = 0;
+    while ((match = DYNAMIC_LOAD_MODULE_RE.exec(transformed)) !== null) {
+        const line = transformed.slice(0, match.index).split('\n').length;
+        this.emitWarning(
+            new Error(
+                `[hadars] loadModule() called with a dynamic (non-literal) path at ${resourcePath}:${line}. ` +
+                `Only string-literal paths are transformed by the loader; dynamic calls fall back to runtime import().`
+            )
+        );
+    }
+
+    return transformed;
 }

package/src/utils/response.tsx

@@ -30,49 +30,45 @@ interface ReactResponseOptions {
     }
 }
 
-const getHeadHtml = (seoData: AppHead, renderToStaticMarkup: (el: any) => string): string => {
-    const metaEntries = Object.entries(seoData.meta)
-    const linkEntries = Object.entries(seoData.link)
-    const styleEntries = Object.entries(seoData.style)
-    const scriptEntries = Object.entries(seoData.script)
-
-    return renderToStaticMarkup(
-        <>
-            <title>{seoData.title}</title>
-            {
-            metaEntries.map( ([id, options]) => (
-                <meta
-                    key={id}
-                    id={ id }
-                    { ...options }
-                />
-            ) )
-            }
-            {linkEntries.map( ([id, options]) => (
-                <link
-                    key={id}
-                    id={ id }
-                    { ...options }
-                />
-            ))}
-            {styleEntries.map( ([id, options]) => (
-                <style
-                    key={id}
-                    id={id}
-                    { ...options }
-                />
-            ))}
-            {scriptEntries.map( ([id, options]) => (
-                <script
-                    key={id}
-                    id={id}
-                    { ...options }
-                />
-            ))}
-        </>
-    )
+// ── Head HTML serialisation (no React render needed) ─────────────────────────
+
+const ESC: Record<string, string> = { '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;' };
+const escAttr = (s: string) => s.replace(/[&<>"]/g, c => ESC[c]);
+const escText = (s: string) => s.replace(/[&<>]/g, c => ESC[c]);
+
+// React prop → HTML attribute name for the subset used in head tags.
+const ATTR: Record<string, string> = {
+    className: 'class', htmlFor: 'for', httpEquiv: 'http-equiv',
+    charSet: 'charset', crossOrigin: 'crossorigin', noModule: 'nomodule',
+    referrerPolicy: 'referrerpolicy', fetchPriority: 'fetchpriority',
+};
+
+function renderHeadTag(tag: string, id: string, opts: Record<string, unknown>, selfClose = false): string {
+    let attrs = ` id="${escAttr(id)}"`;
+    let inner = '';
+    for (const [k, v] of Object.entries(opts)) {
+        if (k === 'key' || k === 'children') continue;
+        if (k === 'dangerouslySetInnerHTML') { inner = (v as any).__html ?? ''; continue; }
+        const attr = ATTR[k] ?? k;
+        if (v === true) attrs += ` ${attr}`;
+        else if (v !== false && v != null) attrs += ` ${attr}="${escAttr(String(v))}"`;
+    }
+    return selfClose ? `<${tag}${attrs}>` : `<${tag}${attrs}>${inner}</${tag}>`;
 }
 
+const getHeadHtml = (seoData: AppHead): string => {
+    let html = `<title>${escText(seoData.title ?? '')}</title>`;
+    for (const [id, opts] of Object.entries(seoData.meta))
+        html += renderHeadTag('meta', id, opts as Record<string, unknown>, true);
+    for (const [id, opts] of Object.entries(seoData.link))
+        html += renderHeadTag('link', id, opts as Record<string, unknown>, true);
+    for (const [id, opts] of Object.entries(seoData.style))
+        html += renderHeadTag('style', id, opts as Record<string, unknown>);
+    for (const [id, opts] of Object.entries(seoData.script))
+        html += renderHeadTag('script', id, opts as Record<string, unknown>);
+    return html;
+};
+
 
 export const getReactResponse = async (
     req: HadarsRequest,
@@ -141,20 +137,20 @@ export const getReactResponse = async (
         }
         if (unsuspend.hasPending) await processUnsuspend();
     } while (unsuspend.hasPending && ++iters < 25);
+    if (unsuspend.hasPending) {
+        console.warn('[hadars] SSR render loop hit the 25-iteration cap — some useServerData values may not be resolved. Check for data dependencies that are never fulfilled.');
+    }
 
-    props = getAfterRenderProps ? await getAfterRenderProps(props, html) : props;
-    // Re-render to capture any head changes introduced by getAfterRenderProps.
-    try {
-        (globalThis as any).__hadarsUnsuspend = unsuspend;
-        renderToStaticMarkup(
-            <App {...({
-                ...props,
-                location: req.location,
-                context,
-            })} />
-        );
-    } finally {
-        (globalThis as any).__hadarsUnsuspend = null;
+    if (getAfterRenderProps) {
+        props = await getAfterRenderProps(props, html);
+        // Re-render only when getAfterRenderProps is present — it may mutate
+        // props that affect head tags, so we need another pass to capture them.
+        try {
+            (globalThis as any).__hadarsUnsuspend = unsuspend;
+            renderToStaticMarkup(<App {...({ ...props, location: req.location, context })} />);
+        } finally {
+            (globalThis as any).__hadarsUnsuspend = null;
+        }
     }
 
     // Serialize resolved useServerData() values for client hydration.
@@ -188,7 +184,7 @@ export const getReactResponse = async (
     return {
         ReactPage,
         status: context.head.status,
-        headHtml: getHeadHtml(context.head, renderToStaticMarkup),
+        headHtml: getHeadHtml(context.head),
         renderPayload: {
             appProps: { ...props, location: req.location, context } as Record<string, unknown>,
             clientProps: clientProps as Record<string, unknown>,