@rsc-kit/core 0.1.0

package/dist/worker.js

@@ -0,0 +1,863 @@
+import { chmodSync, unlinkSync } from "node:fs";
+import { listen, runtimeName, scanScripts, yieldToEventLoop } from "./runtime.js";
+import { createDeferredHost, streamWithDeferredRelease } from "./streaming.js";
+import { join, resolve } from "node:path";
+import { ServerAuthenticationError, ServerAuthorizationError, ServerRedirectError, ServerValidationError } from "./errors.js";
+import { isRedirectSignal } from "./redirectDigest.js";
+import { withCache } from "./cache.js";
+import { withRequest, withResponseDraft } from "./request.js";
+const functions = {};
+function log(...args) {
+    console.error(`[rsc-worker:${runtimeName}]`, ...args);
+}
+async function discoverFunctions(dir) {
+    const scripts = scanScripts(dir);
+    for (const path of scripts) {
+        const mod = await import(join(dir, path));
+        for (const [name, fn] of Object.entries(mod)) {
+            if (typeof fn !== "function")
+                continue;
+            if (name in functions) {
+                log(`Warning: duplicate function "${name}" from ${path}, skipping`);
+                continue;
+            }
+            functions[name] = fn;
+        }
+    }
+}
+async function loadEntryPoints() {
+    const raw = process.env.RSC_ENTRY_POINTS ?? "";
+    const paths = raw.split(",").map((p) => p.trim()).filter(Boolean);
+    for (const entryPath of paths) {
+        const absolute = resolve(entryPath);
+        try {
+            const mod = await import(absolute);
+            for (const [name, fn] of Object.entries(mod)) {
+                if (name === "default" || typeof fn !== "function" || name.length <= 2)
+                    continue;
+                if (name in functions) {
+                    log(`Warning: duplicate function "${name}" from ${entryPath}, skipping`);
+                    continue;
+                }
+                functions[name] = fn;
+            }
+            if (typeof mod.default === "function" && !("default" in functions)) {
+                const baseName = absolute.split("/").pop()?.replace(/\.[^.]+$/, "") ?? "default";
+                const fnName = baseName in functions ? "default" : baseName;
+                if (fnName in functions) {
+                    log(`Warning: duplicate function "${fnName}" from ${entryPath}, skipping`);
+                }
+                else {
+                    functions[fnName] = mod.default;
+                }
+            }
+        }
+        catch (err) {
+            log(`Failed to load entry point "${entryPath}":`, err instanceof Error ? err.message : String(err));
+        }
+    }
+}
+async function handleMessage(message) {
+    switch (message.type) {
+        case "ping":
+            return '{"type":"pong"}';
+        case "call": {
+            // hasOwn: `constructor` and `toString` are not host functions, and a
+            // caller naming one should be told the function is unknown rather than
+            // handed Object's own method to invoke.
+            const name = message.function ?? "";
+            const fn = Object.hasOwn(functions, name) ? functions[name] : undefined;
+            if (!fn) {
+                return JSON.stringify({
+                    error: `Function "${message.function}" not found. Available: ${Object.keys(functions).join(", ")}`,
+                });
+            }
+            try {
+                const result = await fn(message.args ?? {});
+                return JSON.stringify({ result });
+            }
+            catch (err) {
+                return JSON.stringify({
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            }
+        }
+        case "rsc-payload": {
+            if (!rscHandler) {
+                return '{"error":"RSC not enabled."}';
+            }
+            if (!message.component) {
+                return '{"error":"Missing component in RSC message"}';
+            }
+            try {
+                const result = await rscHandler.handleRscPayload(message.component, message.props ?? {}, message.layouts ?? [], message.loadings ?? [], message.parallelSlots ?? {}, message.from ?? 0, message.pageKey ?? "");
+                return JSON.stringify({ result });
+            }
+            catch (err) {
+                return JSON.stringify({ error: err instanceof Error ? err.message : String(err) });
+            }
+        }
+        case "rsc": {
+            if (!rscHandler) {
+                return '{"error":"RSC not enabled. Set RSC_ENABLED=true and run: bun run build:rsc"}';
+            }
+            if (!message.component) {
+                return '{"error":"Missing component in RSC message"}';
+            }
+            try {
+                // Install the host callable if a callback connection is available
+                let cleanupPhp = null;
+                if (message.callbackId) {
+                    const cbConn = await getCallbackConnection(message.callbackId);
+                    cleanupPhp = rscHandler.installHostFn(createPhpFn(cbConn));
+                }
+                try {
+                    // A target asks for one part of this page rather than the whole of
+                    // it, and needs the same host connection a page does.
+                    if (message.target) {
+                        const result = await rscHandler.handleRscRevalidate(message.target, {
+                            component: message.component,
+                            props: message.props ?? {},
+                            layouts: message.layouts ?? [],
+                            loadings: message.loadings ?? [],
+                            parallelSlots: message.parallelSlots ?? {},
+                        });
+                        return JSON.stringify({ result });
+                    }
+                    const metadata = await rscHandler.resolveMetadata(message.component, message.props ?? {}, message.layouts ?? []);
+                    const result = await rscHandler.handleRsc(message.component, message.props ?? {}, message.callbackSocket ?? null, // fallback for old protocol
+                    message.layouts ?? [], message.loadings ?? [], message.parallelSlots ?? {}, message.from ?? 0, message.pageKey ?? "", message.bootstrap !== false);
+                    return JSON.stringify({ result: { ...result, metadata } });
+                }
+                finally {
+                    cleanupPhp?.();
+                    if (message.callbackId)
+                        callbackConnections.delete(message.callbackId);
+                }
+            }
+            catch (err) {
+                return JSON.stringify({
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            }
+        }
+        case "rsc-ppr-shell": {
+            if (!rscHandler) {
+                return '{"error":"RSC not enabled. Set RSC_ENABLED=true and run: bun run build:rsc"}';
+            }
+            if (!message.component) {
+                return '{"error":"Missing component in RSC message"}';
+            }
+            try {
+                const result = await rscHandler.handleRscPprShell(message.component, message.props ?? {}, message.layouts ?? [], message.loadings ?? [], message.parallelSlots ?? {}, 
+                // The url this shell is for, when it is for exactly one. Dropped
+                // here, every shell was rendered as if it were a pattern: params
+                // never settle, a page that awaits them suspends immediately, and
+                // the frozen shell is its loading fallback with no document around
+                // it and no bootstrap in it — so nothing hydrates and nothing fills.
+                message.pageKey ?? "");
+                return JSON.stringify({ result });
+            }
+            catch (err) {
+                return JSON.stringify({
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            }
+        }
+        case "list":
+            return JSON.stringify({ result: Object.keys(functions) });
+        default:
+            return JSON.stringify({ error: `Unknown message type: "${message.type}"` });
+    }
+}
+const functionsDir = process.env.RSC_FUNCTIONS_DIR;
+const socketPath = process.env.RSC_SOCKET ?? "/tmp/bun-bridge.sock";
+// Transport: 'unix' (default) listens on socketPath; 'tcp' listens on
+// RSC_HOST:RSC_MAIN_PORT (main) and RSC_HOST:RSC_CB_PORT (callbacks).
+//
+// The protocol has no authentication of any kind. On a unix socket that is
+// fine — the filesystem permissions are the authentication, and the socket is
+// created private to its owner. Over TCP there is nothing: whoever can open
+// the port can render any component, run any registered host function and read
+// anything either returns. It is for a container where the port is not
+// reachable from outside, and binding it anywhere else is a decision to serve
+// the engine to whoever asks.
+const isTcp = process.env.RSC_TRANSPORT === "tcp";
+const tcpHost = process.env.RSC_HOST ?? "127.0.0.1";
+const mainPort = parseInt(process.env.RSC_MAIN_PORT ?? "0", 10);
+const cbPort = parseInt(process.env.RSC_CB_PORT ?? "0", 10);
+// Said once, loudly, rather than left in a comment nobody reads: an
+// unauthenticated protocol bound to a routable address is a remote code
+// execution surface, and the default of 127.0.0.1 is the only reason this is
+// usually safe.
+if (isTcp && tcpHost !== "127.0.0.1" && tcpHost !== "::1" && tcpHost !== "localhost") {
+    log(`WARNING: listening on ${tcpHost} over TCP. This protocol has no ` +
+        `authentication — anyone who can reach that address can render any component ` +
+        `and call any host function. Bind 127.0.0.1 unless the network is private.`);
+}
+if (functionsDir) {
+    await discoverFunctions(functionsDir);
+}
+await loadEntryPoints();
+let rscHandler = null;
+if (process.env.RSC_DEV_CONFIG) {
+    // Dev mode: the entry comes from Vite's runnable rsc environment rather than
+    // a bundle, so an edit is live without a rebuild. Same module contract.
+    try {
+        const { startDevServer, devEntryPath } = await import("./devServer.js");
+        const outDir = process.env.RSC_OUT_DIR;
+        const dev = await startDevServer({
+            projectRoot: process.env.RSC_PROJECT_ROOT ?? process.cwd(),
+            configFile: process.env.RSC_DEV_CONFIG,
+            entry: devEntryPath(outDir),
+            port: parseInt(process.env.RSC_DEV_PORT ?? "5173", 10),
+        });
+        rscHandler = dev.handler;
+        log(`RSC dev server on ${process.env.RSC_DEV_ORIGIN}`);
+    }
+    catch (err) {
+        log("Failed to start RSC dev server:", err instanceof Error ? err.message : String(err));
+    }
+}
+else if (process.env.RSC_BUNDLE) {
+    try {
+        // The built @vitejs/plugin-rsc entry IS the handler — it exports the
+        // installHostFn / handleRsc* / handleAction / resolveMetadata contract.
+        rscHandler = (await import(process.env.RSC_BUNDLE));
+        log("RSC handler loaded");
+    }
+    catch (err) {
+        log("Failed to load RSC handler:", err instanceof Error ? err.message : String(err));
+    }
+}
+if (Object.keys(functions).length === 0 && !rscHandler) {
+    log("No functions discovered. Provide a functions directory or entry points.");
+    process.exit(1);
+}
+/**
+ * Handles rsc-stream messages.
+ *
+ * Writes Flight data frames back on the main listener's socket (same path as
+ * SSR responses). The listener's drain handler handles
+ * backpressure for large payloads. Runs via setTimeout so writes are not
+ * corked by the data handler's async callback buffering.
+ */
+async function handleRscStreamMessage(mainSocket, message, draft) {
+    if (!rscHandler) {
+        writeFrame(mainSocket, '{"error":"RSC not enabled"}');
+        return;
+    }
+    if (!message.component) {
+        writeFrame(mainSocket, '{"error":"Missing component in RSC message"}');
+        return;
+    }
+    let cleanupPhp = null;
+    try {
+        let deferred = null;
+        if (message.callbackId) {
+            const cbConn = await getCallbackConnection(message.callbackId);
+            deferred = createDeferredHost(createPhpFn(cbConn));
+            cleanupPhp = rscHandler.installHostFn(deferred.hostFn);
+        }
+        const metadata = await rscHandler.resolveMetadata(message.component, message.props ?? {}, message.layouts ?? []);
+        deferred?.begin();
+        const { stream, clientChunks, segmentDepth } = await rscHandler.handleRscStream(message.component, message.props ?? {}, message.layouts ?? [], message.loadings ?? [], message.parallelSlots ?? {}, message.slotOverrides ?? undefined, message.from ?? 0, message.pageKey ?? "");
+        const reader = stream.getReader();
+        const decoder = new TextDecoder();
+        const writeStreamChunk = (value) => {
+            const text = typeof value === "string" ? value : decoder.decode(value, { stream: true });
+            writeFrame(mainSocket, JSON.stringify({ type: "stream-chunk", data: text }));
+        };
+        writeFrame(mainSocket, JSON.stringify({ type: "stream-start", clientChunks, metadata, segmentDepth, headers: draft && draftHeaders(draft) }));
+        // Flight's root model and the rows for each Suspense fallback go out before
+        // any host call is released; see streamWithDeferredRelease.
+        await streamWithDeferredRelease(reader, writeStreamChunk, () => deferred?.flush());
+        writeFrame(mainSocket, '{"type":"stream-end"}');
+    }
+    catch (err) {
+        const errorJson = failureFrame(err, draft);
+        try {
+            writeFrame(mainSocket, errorJson);
+        }
+        catch {
+            // Best effort
+        }
+    }
+    finally {
+        cleanupPhp?.();
+        if (message.callbackId)
+            callbackConnections.delete(message.callbackId);
+    }
+}
+/**
+ * The frame that describes what went wrong, or where to go instead.
+ *
+ * A render that redirects is not a render that failed, and the host has to
+ * tell them apart: one becomes a Location header, the other becomes a 500.
+ * Reported before the shell is written whenever the redirect happened above
+ * every Suspense boundary, which is what leaves PHP a status line to use.
+ */
+function failureFrame(err, draft) {
+    if (isRedirectSignal(err)) {
+        // A redirect is still an answer, and middleware that sets a cookie before
+        // sending someone to the login page means the cookie to survive the trip —
+        // remembering where they were going is the usual one.
+        return JSON.stringify({
+            redirect: err.location,
+            redirectStatus: err.status,
+            headers: draft && draftHeaders(draft),
+        });
+    }
+    return JSON.stringify({ error: err instanceof Error ? err.message : String(err) });
+}
+/**
+ * One request's scopes, opened together.
+ *
+ * The worker has a socket rather than a request, so the host forwards the url
+ * and headers on the message and this rebuilds enough of a Request for
+ * headers() and cookies() to read. A host that forwards nothing leaves the
+ * scope empty, and reading throws — which is the honest answer, since
+ * answering with no headers would look like a visitor who sent none.
+ *
+ * The response draft is open here too, so middleware can set a header or a
+ * cookie. It travels on the stream-start frame, which is the last thing sent
+ * before the body — PHP has not written its status line yet, so there is still
+ * an answer to put them on. Sealed the instant that frame goes out.
+ */
+function inRequest(message, run) {
+    // The parts, not a rebuilt Request: constructing one drops Cookie, because a
+    // Headers built with the request guard refuses the forbidden header names.
+    const forwarded = message.url
+        ? { url: message.url, headers: message.headers ?? {} }
+        : null;
+    return withRequest(forwarded, () => withCache(() => withResponseDraft(run)));
+}
+/**
+ * The draft's headers as the wire carries them: repeats preserved.
+ *
+ * Reported once. An error can arrive after stream-start, and reporting again
+ * there would set every cookie twice on a host that applies what it is given.
+ */
+const reported = new WeakSet();
+function draftHeaders(draft) {
+    if (reported.has(draft))
+        return undefined;
+    reported.add(draft);
+    const headers = draft.taken();
+    const collected = [];
+    headers.forEach((value, name) => {
+        // Set-Cookie is handled once below. forEach already visits it per cookie in
+        // some runtimes and as one joined value in others, and neither is what goes
+        // on the wire — a joined header is one malformed cookie and no session.
+        if (name.toLowerCase() !== "set-cookie")
+            collected.push([name, value]);
+    });
+    for (const cookie of headers.getSetCookie())
+        collected.push(["Set-Cookie", cookie]);
+    draft.seal();
+    return collected;
+}
+/**
+ * Handles rsc-html-stream messages for initial page loads with Suspense.
+ *
+ * Writes HTML + Flight payload frames back on the main listener's socket
+ * (same path as SSR responses). The drain handler
+ * handles backpressure for large payloads.
+ */
+async function handleRscHtmlStreamMessage(mainSocket, message, draft) {
+    if (!rscHandler) {
+        writeFrame(mainSocket, '{"error":"RSC not enabled"}');
+        return;
+    }
+    if (!message.component) {
+        writeFrame(mainSocket, '{"error":"Missing component in RSC message"}');
+        return;
+    }
+    let cleanupPhp = null;
+    try {
+        let deferred = null;
+        if (message.callbackId) {
+            const cbConn = await getCallbackConnection(message.callbackId);
+            deferred = createDeferredHost(createPhpFn(cbConn));
+            cleanupPhp = rscHandler.installHostFn(deferred.hostFn);
+        }
+        const metadata = await rscHandler.resolveMetadata(message.component, message.props ?? {}, message.layouts ?? []);
+        deferred?.begin();
+        const { htmlStream, rscPayloadPromise, clientChunks } = await rscHandler.handleRscHtmlStream(message.component, message.props ?? {}, message.layouts ?? [], message.loadings ?? [], message.parallelSlots ?? {}, message.slotOverrides ?? undefined, message.nonce ?? undefined, message.pageKey ?? "");
+        const reader = htmlStream.getReader();
+        const decoder = new TextDecoder();
+        const writeHtmlChunk = (value) => {
+            const text = typeof value === "string" ? value : decoder.decode(value, { stream: true });
+            writeFrame(mainSocket, JSON.stringify({ type: "html-chunk", data: text }));
+        };
+        // Write html-start and the shell without yielding the event loop
+        writeFrame(mainSocket, JSON.stringify({ type: "html-start", clientChunks, metadata }));
+        // The whole shell, with every Suspense fallback in it, goes out before any
+        // host call is released; see streamWithDeferredRelease.
+        await streamWithDeferredRelease(reader, writeHtmlChunk, () => deferred?.flush());
+        const rscPayload = await rscPayloadPromise;
+        writeFrame(mainSocket, JSON.stringify({ type: "html-end", rscPayload }));
+    }
+    catch (err) {
+        const errorJson = failureFrame(err, draft);
+        try {
+            writeFrame(mainSocket, errorJson);
+        }
+        catch {
+            // Best effort
+        }
+    }
+    finally {
+        cleanupPhp?.();
+        if (message.callbackId)
+            callbackConnections.delete(message.callbackId);
+    }
+}
+/**
+ * Handles rsc-action messages (server action calls).
+ *
+ * Same streaming pattern as handleRscStreamMessage — writes Flight
+ * data frames back on the main socket with action-specific frame types.
+ */
+async function handleRscActionMessage(mainSocket, message, draft) {
+    if (!rscHandler) {
+        writeFrame(mainSocket, '{"error":"RSC not enabled"}');
+        return;
+    }
+    if (!message.actionId) {
+        writeFrame(mainSocket, '{"error":"Missing actionId in rsc-action message"}');
+        return;
+    }
+    let cleanupPhp = null;
+    // Held beyond the block below: what the host marks stale during the action
+    // is collected against this connection and read after the action returns.
+    let cbConn = null;
+    try {
+        if (message.callbackId) {
+            cbConn = await getCallbackConnection(message.callbackId);
+            cleanupPhp = rscHandler.installHostFn(createPhpFn(cbConn));
+        }
+        // Already bytes when a body arrived on its own frame; there is nothing to
+        // decode and nothing to reinterpret.
+        const actionBody = message.body ?? "";
+        const { stream } = await rscHandler.handleAction(message.actionId, actionBody, message.contentType ?? "text/plain", 
+        // The page the action was invoked from, resolved by the host — the
+        // browser knows the url but not which components render it.
+        message.page, () => takeRevalidated(cbConn));
+        // An action's whole point may be the cookie it leaves behind, so its
+        // start frame carries them the same way a render's does.
+        writeFrame(mainSocket, JSON.stringify({ type: "action-start", headers: draft && draftHeaders(draft) }));
+        await yieldToEventLoop();
+        const reader = stream.getReader();
+        const decoder = new TextDecoder();
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            const text = typeof value === "string"
+                ? value
+                : decoder.decode(value, { stream: true });
+            writeFrame(mainSocket, JSON.stringify({ type: "action-chunk", data: text }));
+            await yieldToEventLoop();
+        }
+        // What the host marked stale while the action ran. Reported on the way
+        // out so the answer can carry it; the parts themselves follow once the
+        // worker is given the page context to render them against.
+        const revalidated = takeRevalidated(cbConn);
+        writeFrame(mainSocket, JSON.stringify(revalidated.length > 0 ? { type: "action-end", revalidated } : { type: "action-end" }));
+    }
+    catch (err) {
+        let errorJson;
+        if (err instanceof ServerAuthenticationError) {
+            errorJson = JSON.stringify({
+                unauthenticated: true,
+                error: err.message,
+            });
+        }
+        else if (err instanceof ServerAuthorizationError) {
+            errorJson = JSON.stringify({
+                unauthorized: true,
+                error: err.message,
+            });
+        }
+        else if (err instanceof ServerRedirectError) {
+            errorJson = JSON.stringify({
+                redirect: err.location,
+            });
+        }
+        else if (err instanceof ServerValidationError) {
+            errorJson = JSON.stringify({
+                error: err.message,
+                validation_errors: err.errors,
+            });
+        }
+        else {
+            errorJson = JSON.stringify({
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+        try {
+            writeFrame(mainSocket, errorJson);
+        }
+        catch {
+            // Best effort
+        }
+    }
+    finally {
+        cleanupPhp?.();
+        if (message.callbackId)
+            callbackConnections.delete(message.callbackId);
+    }
+}
+if (!isTcp) {
+    try {
+        unlinkSync(socketPath);
+    }
+    catch {
+        // File doesn't exist
+    }
+}
+const pendingWriteBuffers = new Map();
+const socketBuffers = new Map();
+function drainSocket(socket) {
+    const pending = pendingWriteBuffers.get(socket);
+    if (!pending)
+        return;
+    const written = socket.write(pending);
+    if (written < pending.length) {
+        pendingWriteBuffers.set(socket, pending.subarray(written));
+    }
+    else {
+        pendingWriteBuffers.delete(socket);
+    }
+}
+function writeFrame(socket, json) {
+    const payload = Buffer.from(json, "utf-8");
+    const header = Buffer.alloc(4);
+    header.writeUInt32BE(payload.length, 0);
+    const frame = Buffer.concat([header, payload]);
+    // If there are pending writes from a previous partial write,
+    // queue this frame behind them to maintain frame ordering.
+    // Writing directly would interleave with pending data on the wire.
+    const existing = pendingWriteBuffers.get(socket);
+    if (existing) {
+        pendingWriteBuffers.set(socket, Buffer.concat([existing, frame]));
+        return;
+    }
+    const written = socket.write(frame);
+    if (written < frame.length) {
+        pendingWriteBuffers.set(socket, frame.subarray(written));
+    }
+}
+const MAX_FRAME_SIZE = parseInt(process.env.RSC_MAX_FRAME_SIZE || "1048576", 10); // 1MB default
+/**
+ * Messages whose body is arriving as the next frame.
+ *
+ * An upload body is bytes, and frames are bytes, so it travels as its own
+ * frame instead of being encoded to fit inside the JSON one. The frame after
+ * such a header is that body and must not be parsed as JSON.
+ */
+const pendingBody = new Map();
+/**
+ * What the host marked stale while an action was running, per callback
+ * connection.
+ *
+ * An action knows what it changed and the page does not, so the marks ride
+ * back with each callback's result. Collected here so the answer to the action
+ * can carry the re-rendered parts — rather than telling the browser what went
+ * stale and waiting for it to ask.
+ */
+const revalidations = new Map();
+function markRevalidated(socket, targets) {
+    const marked = revalidations.get(socket) ?? new Set();
+    for (const target of targets)
+        marked.add(target);
+    revalidations.set(socket, marked);
+}
+/** Take what a connection collected and forget it. */
+function takeRevalidated(socket) {
+    if (!socket)
+        return [];
+    const marked = revalidations.get(socket);
+    revalidations.delete(socket);
+    return marked ? [...marked] : [];
+}
+// Create the socket files owner-only. Without this, any local user could
+// connect to the predictable socket path and drive the bridge (invoke server
+// actions / php() callables) with no authenticated session. PHP-FPM must run
+// as the same user as this worker (already implied by sharing the socket).
+try {
+    process.umask(0o077);
+}
+catch { }
+/** Restrict a bound Unix socket to owner read/write only. */
+function secureSocket(path) {
+    try {
+        chmodSync(path, 0o600);
+    }
+    catch (err) {
+        log("Failed to secure socket permissions:", err instanceof Error ? err.message : String(err));
+    }
+}
+const server = listen(isTcp ? { hostname: tcpHost, port: mainPort } : { unix: socketPath }, {
+    async data(socket, rawData) {
+        let buf = socketBuffers.get(socket);
+        buf = buf ? Buffer.concat([buf, Buffer.from(rawData)]) : Buffer.from(rawData);
+        while (buf.length >= 4) {
+            const frameLength = buf.readUInt32BE(0);
+            if (frameLength <= 0 || frameLength > MAX_FRAME_SIZE) {
+                // Hang up, rather than drop the buffer and read on.
+                //
+                // Dropping it leaves the connection open, so the next chunk is
+                // parsed as a fresh frame from an arbitrary offset inside the
+                // payload that was just rejected — and that payload is an action
+                // body, which is to say whatever was uploaded. Bytes chosen to look
+                // like a length prefix and a JSON message then arrive as a control
+                // message on a pooled, long-lived socket: a host function invoked
+                // with arguments from inside a file. There is no way to resynchronise
+                // a stream whose framing is already lost, so the only correct move
+                // is to stop reading it.
+                log("Invalid frame length, closing the connection:", frameLength);
+                socketBuffers.delete(socket);
+                pendingBody.delete(socket);
+                socket.end?.();
+                return;
+            }
+            if (buf.length < 4 + frameLength) {
+                break;
+            }
+            const payload = buf.subarray(4, 4 + frameLength);
+            buf = buf.subarray(4 + frameLength);
+            const awaiting = pendingBody.get(socket);
+            if (awaiting) {
+                pendingBody.delete(socket);
+                // Copied because the read buffer is reused for the frames after it.
+                awaiting.body = Buffer.from(payload);
+                // Through inRequest, like every other message. Dispatching bare left
+                // an action whose body arrived as bytes — which is every file upload
+                // — with no request scope, no response draft and no memo table:
+                // headers() and cookies() threw, cookies().set() threw, and nothing
+                // the action set could reach the response, because the action-start
+                // frame carried no headers to put there.
+                setTimeout(() => void inRequest(awaiting, (draft) => handleRscActionMessage(socket, awaiting, draft)), 0);
+                continue;
+            }
+            try {
+                const message = JSON.parse(payload.toString("utf-8"));
+                if (message.bodyEncoding === "binary" && (message.bodyLength ?? 0) > 0) {
+                    pendingBody.set(socket, message);
+                    continue;
+                }
+                if (message.type === "rsc-stream" || message.type === "rsc-html-stream" || message.type === "rsc-action" || message.type === "rsc-ppr-shell") {
+                    // Run outside the data handler so socket writes are not corked
+                    // and setTimeout/Promise.race timeouts can fire.
+                    if (message.type === "rsc-ppr-shell") {
+                        setTimeout(async () => {
+                            const response = await inRequest(message, () => handleMessage(message));
+                            writeFrame(socket, response);
+                        }, 0);
+                    }
+                    else {
+                        const handler = message.type === "rsc-html-stream"
+                            ? handleRscHtmlStreamMessage
+                            : message.type === "rsc-action"
+                                ? handleRscActionMessage
+                                : handleRscStreamMessage;
+                        // One memo table per message, which is one per request: the
+                        // scope has to be open before the render starts, because that is
+                        // where a guard and a layout ask the same question.
+                        setTimeout(() => void inRequest(message, (draft) => handler(socket, message, draft)), 0);
+                    }
+                }
+                else {
+                    const response = await inRequest(message, () => handleMessage(message));
+                    writeFrame(socket, response);
+                }
+            }
+            catch (err) {
+                log("Failed to parse message:", err);
+                writeFrame(socket, '{"error":"Invalid JSON"}');
+            }
+        }
+        if (buf.length > 0) {
+            socketBuffers.set(socket, buf);
+        }
+        else {
+            socketBuffers.delete(socket);
+        }
+    },
+    drain(socket) {
+        drainSocket(socket);
+    },
+    open() { },
+    close(socket) {
+        pendingWriteBuffers.delete(socket);
+        socketBuffers.delete(socket);
+    },
+    error(_, err) {
+        log("Socket error:", err.message);
+    },
+});
+if (!isTcp)
+    secureSocket(socketPath);
+log(`Listening on ${isTcp ? `${tcpHost}:${mainPort}` : socketPath}`);
+log(`Discovered ${Object.keys(functions).length} functions: ${Object.keys(functions).join(", ")}`);
+// ─── Persistent Callback Server ─────────────────────────────────────────────
+// PHP connects here for php() callbacks instead of per-request temp sockets.
+// Each connection registers with a callbackId that matches the render request.
+const callbackSocketPath = socketPath + ".cb";
+if (!isTcp) {
+    try {
+        unlinkSync(callbackSocketPath);
+    }
+    catch { }
+}
+const callbackConnections = new Map();
+const cbSocketBuffers = new Map();
+const pendingPhpCallbacks = new Map();
+function handleCbResponse(response) {
+    const id = response.id;
+    const pending = pendingPhpCallbacks.get(id);
+    if (!pending)
+        return;
+    pendingPhpCallbacks.delete(id);
+    if (Array.isArray(response.revalidate) && response.revalidate.length > 0) {
+        markRevalidated(pending.socket, response.revalidate);
+    }
+    if (response.unauthenticated) {
+        pending.reject(new ServerAuthenticationError(response.error));
+    }
+    else if (response.unauthorized) {
+        pending.reject(new ServerAuthorizationError(response.error));
+    }
+    else if (response.validation_errors) {
+        pending.reject(new ServerValidationError(response.error ?? "Validation failed", response.validation_errors));
+    }
+    else if (response.redirect) {
+        pending.reject(new ServerRedirectError(response.redirect));
+    }
+    else if (response.error) {
+        pending.reject(new Error(response.error));
+    }
+    else {
+        pending.resolve(response.result);
+    }
+}
+const cbServer = listen(isTcp ? { hostname: tcpHost, port: cbPort } : { unix: callbackSocketPath }, {
+    data(socket, rawData) {
+        let buf = cbSocketBuffers.get(socket);
+        buf = buf ? Buffer.concat([buf, Buffer.from(rawData)]) : Buffer.from(rawData);
+        while (buf.length >= 4) {
+            const frameLength = buf.readUInt32BE(0);
+            if (frameLength <= 0 || frameLength > MAX_FRAME_SIZE) {
+                // Hang up, as on the main listener: framing that cannot be parsed
+                // cannot be resynchronised, and reading on from an arbitrary offset
+                // turns payload bytes into control messages.
+                log("Invalid callback frame length, closing the connection:", frameLength);
+                cbSocketBuffers.delete(socket);
+                socket.end?.();
+                return;
+            }
+            if (buf.length < 4 + frameLength)
+                break;
+            const json = buf.subarray(4, 4 + frameLength).toString("utf-8");
+            buf = buf.subarray(4 + frameLength);
+            try {
+                const msg = JSON.parse(json);
+                if (msg.type === "register" && msg.id) {
+                    callbackConnections.set(msg.id, socket);
+                }
+                else {
+                    handleCbResponse(msg);
+                }
+            }
+            catch { }
+        }
+        if (buf.length > 0) {
+            cbSocketBuffers.set(socket, buf);
+        }
+        else {
+            cbSocketBuffers.delete(socket);
+        }
+    },
+    open() { },
+    close(socket) {
+        for (const [id, s] of callbackConnections) {
+            if (s === socket)
+                callbackConnections.delete(id);
+        }
+        cbSocketBuffers.delete(socket);
+        // Reject any php() callbacks still awaiting a response on this
+        // connection. Without this the awaiting render hangs forever and the
+        // pending map grows for the life of the worker (a slow whole-app leak
+        // when requests are aborted or the PHP side disconnects mid-render).
+        for (const [id, pending] of pendingPhpCallbacks) {
+            if (pending.socket === socket) {
+                pendingPhpCallbacks.delete(id);
+                pending.reject(new Error("Callback connection closed before php() responded"));
+            }
+        }
+    },
+    drain(socket) { drainSocket(socket); },
+    error() { },
+});
+if (!isTcp)
+    secureSocket(callbackSocketPath);
+log(`Callback listener on ${isTcp ? `${tcpHost}:${cbPort}` : callbackSocketPath}`);
+let cbIdCounter = 0;
+function getCallbackConnection(id, timeoutMs = 3000) {
+    const existing = callbackConnections.get(id);
+    if (existing)
+        return Promise.resolve(existing);
+    return new Promise((resolve, reject) => {
+        const check = setInterval(() => {
+            const conn = callbackConnections.get(id);
+            if (conn) {
+                clearInterval(check);
+                clearTimeout(timer);
+                resolve(conn);
+            }
+        }, 5);
+        const timer = setTimeout(() => {
+            clearInterval(check);
+            reject(new Error(`Callback ${id} not registered within ${timeoutMs}ms`));
+        }, timeoutMs);
+    });
+}
+function createPhpFn(cbSocket) {
+    return (functionName, ...args) => {
+        const id = `cb_${++cbIdCounter}`;
+        writeFrame(cbSocket, JSON.stringify({ type: "callback", id, function: functionName, args }));
+        return new Promise((resolve, reject) => {
+            pendingPhpCallbacks.set(id, { resolve, reject, socket: cbSocket });
+        });
+    };
+}
+function shutdown(signal) {
+    log(`Received ${signal}, shutting down`);
+    server.stop();
+    cbServer.stop();
+    if (!isTcp) {
+        try {
+            unlinkSync(socketPath);
+        }
+        catch { }
+        try {
+            unlinkSync(callbackSocketPath);
+        }
+        catch { }
+    }
+    process.exit(0);
+}
+process.on("SIGINT", () => shutdown("SIGINT"));
+process.on("SIGTERM", () => shutdown("SIGTERM"));
+// Prevent unhandled errors from crashing the worker process.
+// These can occur during socket cleanup (e.g., callback socket closed by PHP)
+// or from deferred React rendering microtasks.
+process.on("uncaughtException", (err) => {
+    log("Uncaught exception (worker kept alive):", err.message);
+});
+process.on("unhandledRejection", (reason) => {
+    log("Unhandled rejection (worker kept alive):", reason instanceof Error ? reason.message : String(reason));
+});
+//# sourceMappingURL=worker.js.map