npm - @rshono/core - Versions diffs - 1.0.0-rc.2 → 1.0.0-rc.21 - Mend

@rshono/core 1.0.0-rc.2 → 1.0.0-rc.21

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (208) hide show

package/LICENSE +21 -0
package/README.md +348 -158
package/bin/rshono.mjs +3 -4
package/dist/builder/env-shadow-loader.cjs +123 -8
package/dist/builder/page-entry-loader.cjs +28 -1
package/dist/builder/page-files.d.ts +0 -1
package/dist/builder/page-files.js +7 -3
package/dist/builder/page-files.js.map +1 -1
package/dist/builder/public-env.d.ts +7 -1
package/dist/builder/public-env.js +7 -0
package/dist/builder/public-env.js.map +1 -1
package/dist/builder/react-versions.d.ts +12 -0
package/dist/builder/react-versions.js +74 -0
package/dist/builder/react-versions.js.map +1 -0
package/dist/builder/rspack-config.d.ts +13 -4
package/dist/builder/rspack-config.js +136 -53
package/dist/builder/rspack-config.js.map +1 -1
package/dist/builder/server-only-imports.d.ts +32 -0
package/dist/builder/server-only-imports.js +51 -0
package/dist/builder/server-only-imports.js.map +1 -0
package/dist/cli/build.d.ts +2 -3
package/dist/cli/build.js +51 -13
package/dist/cli/build.js.map +1 -1
package/dist/cli/dev.d.ts +2 -3
package/dist/cli/dev.js +149 -45
package/dist/cli/dev.js.map +1 -1
package/dist/cli/exit.d.ts +12 -0
package/dist/cli/exit.js +16 -0
package/dist/cli/exit.js.map +1 -0
package/dist/cli/index.d.ts +0 -1
package/dist/cli/index.js +91 -30
package/dist/cli/index.js.map +1 -1
package/dist/cli/start.d.ts +0 -1
package/dist/cli/start.js +15 -18
package/dist/cli/start.js.map +1 -1
package/dist/config.d.ts +72 -78
package/dist/config.js +17 -1
package/dist/config.js.map +1 -1
package/dist/deploy/aws-lambda/runtime.d.ts +4 -7
package/dist/deploy/aws-lambda/runtime.js +5 -8
package/dist/deploy/aws-lambda/runtime.js.map +1 -1
package/dist/deploy/build-marker.d.ts +9 -6
package/dist/deploy/build-marker.js +8 -4
package/dist/deploy/build-marker.js.map +1 -1
package/dist/deploy/cloudflare/build.d.ts +0 -1
package/dist/deploy/cloudflare/build.js +17 -13
package/dist/deploy/cloudflare/build.js.map +1 -1
package/dist/deploy/cloudflare/runtime.d.ts +2 -6
package/dist/deploy/cloudflare/runtime.js +73 -68
package/dist/deploy/cloudflare/runtime.js.map +1 -1
package/dist/deploy/contract.d.ts +57 -41
package/dist/deploy/contract.js.map +1 -1
package/dist/deploy/filesystem.d.ts +3 -6
package/dist/deploy/filesystem.js +23 -20
package/dist/deploy/filesystem.js.map +1 -1
package/dist/deploy/node/runtime.d.ts +5 -3
package/dist/deploy/node/runtime.js +23 -9
package/dist/deploy/node/runtime.js.map +1 -1
package/dist/deploy/presets.d.ts +34 -30
package/dist/deploy/presets.js +56 -44
package/dist/deploy/presets.js.map +1 -1
package/dist/deploy/public-paths.d.ts +42 -0
package/dist/deploy/public-paths.js +66 -0
package/dist/deploy/public-paths.js.map +1 -0
package/dist/deploy/vercel/build.d.ts +0 -1
package/dist/deploy/vercel/build.js +25 -16
package/dist/deploy/vercel/build.js.map +1 -1
package/dist/deploy/vercel/runtime.d.ts +10 -7
package/dist/deploy/vercel/runtime.js +48 -11
package/dist/deploy/vercel/runtime.js.map +1 -1
package/dist/index.d.ts +19 -17
package/dist/index.js +20 -10
package/dist/index.js.map +1 -1
package/dist/router.d.ts +212 -120
package/dist/router.js +3 -8
package/dist/router.js.map +1 -1
package/dist/runtime/boundaries.d.ts +62 -48
package/dist/runtime/boundaries.js +32 -34
package/dist/runtime/boundaries.js.map +1 -1
package/dist/runtime/client.d.ts +20 -11
package/dist/runtime/client.js +20 -10
package/dist/runtime/client.js.map +1 -1
package/dist/runtime/context.d.ts +304 -123
package/dist/runtime/context.js +377 -149
package/dist/runtime/context.js.map +1 -1
package/dist/runtime/control.d.ts +15 -1
package/dist/runtime/control.js +24 -0
package/dist/runtime/control.js.map +1 -1
package/dist/runtime/dev-protocol.d.ts +4 -9
package/dist/runtime/dev-protocol.js.map +1 -1
package/dist/runtime/empty-server-app.d.ts +0 -1
package/dist/runtime/entry.client.d.ts +4 -1
package/dist/runtime/entry.client.js +455 -313
package/dist/runtime/entry.client.js.map +1 -1
package/dist/runtime/entry.rsc.d.ts +15 -7
package/dist/runtime/entry.rsc.js +811 -252
package/dist/runtime/entry.rsc.js.map +1 -1
package/dist/runtime/entry.ssr.d.ts +27 -10
package/dist/runtime/entry.ssr.js +30 -48
package/dist/runtime/entry.ssr.js.map +1 -1
package/dist/runtime/failure-document.d.ts +11 -0
package/dist/runtime/failure-document.js +35 -0
package/dist/runtime/failure-document.js.map +1 -0
package/dist/runtime/flight-inject.d.ts +23 -0
package/dist/runtime/flight-inject.js +403 -0
package/dist/runtime/flight-inject.js.map +1 -0
package/dist/runtime/hot-update.d.ts +44 -0
package/dist/runtime/hot-update.js +44 -0
package/dist/runtime/hot-update.js.map +1 -0
package/dist/runtime/navigation.d.ts +46 -54
package/dist/runtime/navigation.js +22 -63
package/dist/runtime/navigation.js.map +1 -1
package/dist/runtime/request.d.ts +42 -8
package/dist/runtime/request.js +84 -7
package/dist/runtime/request.js.map +1 -1
package/dist/runtime/server.d.ts +20 -18
package/dist/runtime/server.js +22 -17
package/dist/runtime/server.js.map +1 -1
package/dist/runtime/validate-entries.d.ts +77 -0
package/dist/runtime/validate-entries.js +405 -0
package/dist/runtime/validate-entries.js.map +1 -0
package/dist/server/headers.d.ts +41 -15
package/dist/server/headers.js +53 -24
package/dist/server/headers.js.map +1 -1
package/dist/server/load-config.d.ts +4 -5
package/dist/server/load-config.js +22 -14
package/dist/server/load-config.js.map +1 -1
package/dist/server/load-env.d.ts +0 -1
package/dist/server/prerendered.d.ts +88 -34
package/dist/server/prerendered.js +184 -24
package/dist/server/prerendered.js.map +1 -1
package/dist/server/server-config.d.ts +35 -50
package/dist/server/server-config.js +27 -74
package/dist/server/server-config.js.map +1 -1
package/dist/server/shutdown.d.ts +5 -4
package/dist/server/shutdown.js +5 -3
package/dist/server/shutdown.js.map +1 -1
package/dist/server/ssg.d.ts +9 -7
package/dist/server/ssg.js +209 -65
package/dist/server/ssg.js.map +1 -1
package/dist/server/static.d.ts +0 -1
package/dist/server/static.js +7 -1
package/dist/server/static.js.map +1 -1
package/package.json +21 -23
package/dist/builder/page-files.d.ts.map +0 -1
package/dist/builder/public-env.d.ts.map +0 -1
package/dist/builder/rspack-config.d.ts.map +0 -1
package/dist/cli/build.d.ts.map +0 -1
package/dist/cli/dev.d.ts.map +0 -1
package/dist/cli/index.d.ts.map +0 -1
package/dist/cli/start.d.ts.map +0 -1
package/dist/config.d.ts.map +0 -1
package/dist/deploy/aws-lambda/runtime.d.ts.map +0 -1
package/dist/deploy/build-marker.d.ts.map +0 -1
package/dist/deploy/bun/runtime.d.ts +0 -11
package/dist/deploy/bun/runtime.d.ts.map +0 -1
package/dist/deploy/bun/runtime.js +0 -22
package/dist/deploy/bun/runtime.js.map +0 -1
package/dist/deploy/cloudflare/build.d.ts.map +0 -1
package/dist/deploy/cloudflare/runtime.d.ts.map +0 -1
package/dist/deploy/contract.d.ts.map +0 -1
package/dist/deploy/deno/runtime.d.ts +0 -11
package/dist/deploy/deno/runtime.d.ts.map +0 -1
package/dist/deploy/deno/runtime.js +0 -16
package/dist/deploy/deno/runtime.js.map +0 -1
package/dist/deploy/filesystem.d.ts.map +0 -1
package/dist/deploy/listen.d.ts +0 -20
package/dist/deploy/listen.d.ts.map +0 -1
package/dist/deploy/listen.js +0 -24
package/dist/deploy/listen.js.map +0 -1
package/dist/deploy/netlify/build.d.ts +0 -8
package/dist/deploy/netlify/build.d.ts.map +0 -1
package/dist/deploy/netlify/build.js +0 -52
package/dist/deploy/netlify/build.js.map +0 -1
package/dist/deploy/netlify/runtime.d.ts +0 -13
package/dist/deploy/netlify/runtime.d.ts.map +0 -1
package/dist/deploy/netlify/runtime.js +0 -24
package/dist/deploy/netlify/runtime.js.map +0 -1
package/dist/deploy/node/runtime.d.ts.map +0 -1
package/dist/deploy/presets.d.ts.map +0 -1
package/dist/deploy/vercel/build.d.ts.map +0 -1
package/dist/deploy/vercel/runtime.d.ts.map +0 -1
package/dist/index.d.ts.map +0 -1
package/dist/router.d.ts.map +0 -1
package/dist/runtime/boundaries.d.ts.map +0 -1
package/dist/runtime/client.d.ts.map +0 -1
package/dist/runtime/context.d.ts.map +0 -1
package/dist/runtime/control.d.ts.map +0 -1
package/dist/runtime/dev-protocol.d.ts.map +0 -1
package/dist/runtime/empty-server-app.d.ts.map +0 -1
package/dist/runtime/entry.client.d.ts.map +0 -1
package/dist/runtime/entry.rsc.d.ts.map +0 -1
package/dist/runtime/entry.ssr.d.ts.map +0 -1
package/dist/runtime/navigation.d.ts.map +0 -1
package/dist/runtime/request.d.ts.map +0 -1
package/dist/runtime/server.d.ts.map +0 -1
package/dist/server/compress.d.ts +0 -15
package/dist/server/compress.d.ts.map +0 -1
package/dist/server/compress.js +0 -76
package/dist/server/compress.js.map +0 -1
package/dist/server/headers.d.ts.map +0 -1
package/dist/server/load-config.d.ts.map +0 -1
package/dist/server/load-env.d.ts.map +0 -1
package/dist/server/prerendered.d.ts.map +0 -1
package/dist/server/server-config.d.ts.map +0 -1
package/dist/server/shutdown.d.ts.map +0 -1
package/dist/server/ssg.d.ts.map +0 -1
package/dist/server/static.d.ts.map +0 -1

package/dist/runtime/failure-document.js ADDED Viewed

@@ -0,0 +1,35 @@
+// The baked config, not `process.env.NODE_ENV`: a deploy target need not have a `process`.
+const isDev = __RSHONO_CONFIG__.isDev;
+/** Escapes text going into HTML body content — a stack trace is untrusted input. */
+function escapeHtml(text) {
+    return text.replace(/[&<>]/g, (char) => (char === '&' ? '&amp;' : char === '<' ? '&lt;' : '&gt;'));
+}
+/**
+ * The framework's last-resort 500 document, for a client that asked for HTML and has nothing better to be
+ * given: an app with no `error` page in its `routes.ts`, or one whose `error` page threw in its turn.
+ *
+ * Plain HTML with no client runtime and no stylesheet links. Both would have come from a render that failed,
+ * and there is no payload to hydrate from — attaching the runtime would tear the page down over this very
+ * message. A string rather than a component for the same reason: React is what failed.
+ *
+ * The detail is dev-only, matching how the app's `error` page redacts.
+ */
+export function failureDocument(error) {
+    const detail = isDev ? (error instanceof Error ? (error.stack ?? `${error.name}: ${error.message}`) : String(error)) : null;
+    return ('<!DOCTYPE html><html lang="en"><head><meta charset="utf-8">' +
+        '<meta name="viewport" content="width=device-width, initial-scale=1">' +
+        '<title>500 — Internal Server Error</title></head>' +
+        '<body style="margin:0;padding:2rem;font:16px/1.6 system-ui,-apple-system,sans-serif;color:#18181b">' +
+        '<h1 style="margin:0 0 .5rem;font-size:1.25rem">500 — Internal Server Error</h1>' +
+        '<p style="margin:0 0 1.5rem;color:#52525b">' +
+        (isDev
+            ? 'The request failed and the app’s error page did not answer it: either src/routes.ts declares no <code>error</code> page, or that page threw in its turn. Both are reported on the server.'
+            : 'Something went wrong while handling this request. Please try again.') +
+        '</p>' +
+        (detail
+            ? '<pre style="margin:0;padding:1rem;overflow:auto;background:#f4f4f5;border-left:3px solid #ef4444;' +
+                `font:13px/1.5 ui-monospace,SFMono-Regular,Menlo,monospace;white-space:pre-wrap;word-break:break-word">${escapeHtml(detail)}</pre>`
+            : '') +
+        '</body></html>');
+}
+//# sourceMappingURL=failure-document.js.map

package/dist/runtime/failure-document.js.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"failure-document.js","sourceRoot":"","sources":["../../src/runtime/failure-document.ts"],"names":[],"mappings":"AAAA,2FAA2F;AAC3F,MAAM,KAAK,GAAG,iBAAiB,CAAC,KAAK,CAAC;AAEtC,oFAAoF;AACpF,SAAS,UAAU,CAAC,IAAY;IAC9B,OAAO,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,IAAI,KAAK,GAAG,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,KAAK,GAAG,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;AACrG,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,eAAe,CAAC,KAAc;IAC5C,MAAM,MAAM,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,IAAI,GAAG,KAAK,CAAC,IAAI,KAAK,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;IAC5H,OAAO,CACL,6DAA6D;QAC7D,sEAAsE;QACtE,mDAAmD;QACnD,qGAAqG;QACrG,iFAAiF;QACjF,6CAA6C;QAC7C,CAAC,KAAK;YACJ,CAAC,CAAC,2LAA2L;YAC7L,CAAC,CAAC,qEAAqE,CAAC;QAC1E,MAAM;QACN,CAAC,MAAM;YACL,CAAC,CAAC,mGAAmG;gBACnG,yGAAyG,UAAU,CAAC,MAAM,CAAC,QAAQ;YACrI,CAAC,CAAC,EAAE,CAAC;QACP,gBAAgB,CACjB,CAAC;AACJ,CAAC","sourcesContent":["// The baked config, not `process.env.NODE_ENV`: a deploy target need not have a `process`.\nconst isDev = __RSHONO_CONFIG__.isDev;\n\n/** Escapes text going into HTML body content — a stack trace is untrusted input. */\nfunction escapeHtml(text: string): string {\n return text.replace(/[&<>]/g, (char) => (char === '&' ? '&' : char === '<' ? '<' : '>'));\n}\n\n/**\n * The framework's last-resort 500 document, for a client that asked for HTML and has nothing better to be\n * given: an app with no `error` page in its `routes.ts`, or one whose `error` page threw in its turn.\n *\n * Plain HTML with no client runtime and no stylesheet links. Both would have come from a render that failed,\n * and there is no payload to hydrate from — attaching the runtime would tear the page down over this very\n * message. A string rather than a component for the same reason: React is what failed.\n *\n * The detail is dev-only, matching how the app's `error` page redacts.\n */\nexport function failureDocument(error: unknown): string {\n const detail = isDev ? (error instanceof Error ? (error.stack ?? `${error.name}: ${error.message}`) : String(error)) : null;\n return (\n '<!DOCTYPE html><html lang=\"en\"><head><meta charset=\"utf-8\">' +\n '<meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">' +\n '<title>500 — Internal Server Error</title></head>' +\n '<body style=\"margin:0;padding:2rem;font:16px/1.6 system-ui,-apple-system,sans-serif;color:#18181b\">' +\n '<h1 style=\"margin:0 0 .5rem;font-size:1.25rem\">500 — Internal Server Error</h1>' +\n '<p style=\"margin:0 0 1.5rem;color:#52525b\">' +\n (isDev\n ? 'The request failed and the app’s error page did not answer it: either src/routes.ts declares no <code>error</code> page, or that page threw in its turn. Both are reported on the server.'\n : 'Something went wrong while handling this request. Please try again.') +\n '</p>' +\n (detail\n ? '<pre style=\"margin:0;padding:1rem;overflow:auto;background:#f4f4f5;border-left:3px solid #ef4444;' +\n `font:13px/1.5 ui-monospace,SFMono-Regular,Menlo,monospace;white-space:pre-wrap;word-break:break-word\">${escapeHtml(detail)}</pre>`\n : '') +\n '</body></html>'\n );\n}\n"]}

package/dist/runtime/flight-inject.d.ts ADDED Viewed

@@ -0,0 +1,23 @@
+/**
+ * Carrying the flight payload inside the HTML document, so the browser hydrates from bytes it already has
+ * rather than fetching the page twice. The reader is `readFlightPayload` in `entry.client.tsx`.
+ *
+ * The wire format is `rsc-html-stream`'s — a run of `<script>(self.__FLIGHT_DATA||=[]).push("…")</script>`
+ * tags — but the implementation is first-party, because that package tests each HTML chunk for the
+ * document trailer with `endsWith`: React's byte writer splits any write straddling its 2 kB views, so
+ * `</body></html>` can arrive as two chunks and the document ends up with two trailers.
+ */
+/**
+ * {@link Transformer} plus the `cancel` hook the Streams standard added for a cancelled readable side —
+ * declared here because the bundled lib types have not caught up with what Node calls.
+ *
+ * It matters because `cancel` is the only notification that a response ended *without* finishing, and both
+ * users of it release a listener that would otherwise outlive the request.
+ */
+export type CancellableTransformer<I, O> = Transformer<I, O> & {
+    cancel?: (reason?: unknown) => void;
+};
+export declare function injectFlightPayload(rscStream: ReadableStream<Uint8Array>, options?: {
+    nonce?: string;
+    onDone?: () => void;
+}): ReadableWritablePair<Uint8Array, Uint8Array>;

package/dist/runtime/flight-inject.js ADDED Viewed

@@ -0,0 +1,403 @@
+/**
+ * Carrying the flight payload inside the HTML document, so the browser hydrates from bytes it already has
+ * rather than fetching the page twice. The reader is `readFlightPayload` in `entry.client.tsx`.
+ *
+ * The wire format is `rsc-html-stream`'s — a run of `<script>(self.__FLIGHT_DATA||=[]).push("…")</script>`
+ * tags — but the implementation is first-party, because that package tests each HTML chunk for the
+ * document trailer with `endsWith`: React's byte writer splits any write straddling its 2 kB views, so
+ * `</body></html>` can arrive as two chunks and the document ends up with two trailers.
+ */
+const encoder = new TextEncoder();
+/** What React closes an `<html>` document with, and what this module re-emits after the last payload script. */
+const TRAILER = '</body></html>';
+const TRAILER_BYTES = encoder.encode(TRAILER);
+const hasSetImmediate = typeof setImmediate === 'function';
+const schedule = hasSetImmediate ? setImmediate : (fn) => setTimeout(fn, 0);
+const unschedule = (handle) => {
+    if (hasSetImmediate)
+        clearImmediate(handle);
+    else
+        clearTimeout(handle);
+};
+/**
+ * Escapes the two sequences that would end a `<script>` element early. Guarded by `includes('<')`, which is
+ * far cheaper than two regex passes over 30 kB of payload that usually has no `<` in it. `</script` becomes
+ * `</\script`, not `<\/script`, which would break the valid JS `0</script/`.
+ */
+function escapeScript(script) {
+    return script.includes('<') ? script.replace(/<!--/g, '<\\!--').replace(/<\/(script)/gi, '</\\$1') : script;
+}
+/**
+ * The bytes of `chunk` as a latin1 string, which is the form `btoa` takes. Sliced because
+ * `String.fromCharCode(...chunk)` passes one argument per byte and overflows the stack.
+ */
+function latin1(chunk) {
+    let out = '';
+    for (let at = 0; at < chunk.length; at += 8192)
+        out += String.fromCharCode(...chunk.subarray(at, at + 8192));
+    return out;
+}
+/** Whether `buffer`'s first `length` bytes end with the document trailer. */
+function endsWithTrailer(buffer, length) {
+    if (length < TRAILER_BYTES.length)
+        return false;
+    const from = length - TRAILER_BYTES.length;
+    for (let i = 0; i < TRAILER_BYTES.length; i++) {
+        if (buffer[from + i] !== TRAILER_BYTES[i])
+            return false;
+    }
+    return true;
+}
+/**
+ * How many of `buffer`'s last bytes could still turn into the document trailer — the length of the longest
+ * suffix of `buffer[0..length)` that is a prefix of it, `TRAILER_BYTES.length` for the whole thing.
+ *
+ * At most 14 bytes are ever held back, and in practice 0: a React flush ends with a closed tag, not with the
+ * start of one. Cheaper than it looks, too — the first comparison rejects every suffix whose first byte is
+ * not `<`.
+ */
+function trailerPrefixLength(buffer, length) {
+    candidate: for (let take = Math.min(length, TRAILER_BYTES.length); take > 0; take--) {
+        const from = length - take;
+        for (let i = 0; i < take; i++)
+            if (buffer[from + i] !== TRAILER_BYTES[i])
+                continue candidate;
+        return take;
+    }
+    return 0;
+}
+/**
+ * The characters a CSP nonce may be made of: base64 and base64url, which is what every generator of one emits
+ * — Hono's `secureHeaders()`, the only source the framework reads, produces base64 of 16 random bytes.
+ *
+ * The tag below is built by hand rather than by React, so this is the one attribute value in a rendered
+ * document that nothing else escapes. The value is not attacker-controlled today, but the framework does not
+ * own where it comes from: `c.get('secureHeadersNonce')` is an ordinary context variable that any middleware
+ * can set, and a nonce carrying a `"` would close the attribute and open a script-injection point in the
+ * document. Anything outside this set is dropped rather than escaped, because a value made of other characters
+ * is not a nonce at all: a page whose payload scripts the policy then refuses is the visible failure to have,
+ * where an escaped garbage nonce would be a silent one.
+ */
+const NONCE_CHARS = /^[A-Za-z0-9+/=_-]+$/;
+export function injectFlightPayload(rscStream, options = {}) {
+    const { nonce, onDone } = options;
+    const safeNonce = nonce !== undefined && NONCE_CHARS.test(nonce) ? nonce : undefined;
+    const scriptOpen = `<script${safeNonce ? ` nonce="${safeNonce}"` : ''}>(self.__FLIGHT_DATA||=[]).push(`;
+    const scriptClose = ')</script>';
+    const { promise: flightWritten, resolve: flightDone } = Promise.withResolvers();
+    let startedFlight = false;
+    const batch = [];
+    let boundary = null;
+    /**
+     * The tail of the last batch that could still be the start of the document trailer, carried into the next
+     * one. See {@link emitBatch}.
+     */
+    let carry = null;
+    /**
+     * Set once the consumer has gone away, so nothing tries to enqueue into a readable that cannot take it.
+     *
+     * The `cancel` hook alone cannot set this: per the Streams standard, cancelling the readable after the
+     * close algorithm has started skips the transformer's `cancel` entirely — and `flush` awaiting the whole
+     * payload is precisely that window. So a failed enqueue counts as the signal too.
+     */
+    let cancelled = false;
+    /** Held so {@link cancelled} can release the teed RSC branch rather than leaving it to be pumped. */
+    let flightReader = null;
+    /**
+     * One permit per chunk the consumer has asked for: the backpressure a `TransformStream` alone does not give
+     * this module.
+     *
+     * A transform's writable side parks a write while its readable's queue is over the mark, which covers the
+     * HTML — but only once something has been enqueued, and `transform` defers that to a macrotask. So a
+     * producer that writes a whole document without ever yielding the microtask queue is admitted in full, and
+     * {@link writeFlight}, which pumps the payload into the same controller from a detached promise, is never
+     * gated at all: measured, a consumer that read one chunk and stalled still pulled all 500 chunks of a test
+     * payload into the queue, where this brings it down to 3. `controller.desiredSize` is no help — a transform
+     * readable's high-water mark is 0, so it is never positive.
+     *
+     * The wrapper readable this function returns is the missing signal: its `pull` runs exactly when the
+     * consumer wants another chunk, and releases one permit. Both producers — the HTML batcher and the payload
+     * pump — take one before they enqueue, so a stalled client parks React instead of filling the process. The
+     * Streams standard calls `pull` again only once the previous call has settled, and a call only settles once
+     * a chunk has arrived, so permits are handed out one at a time and the queue is bounded at a chunk.
+     *
+     * What is left buffered is one React flush, because a flush has to leave here as a single chunk (see
+     * {@link emitBatch}) — the same bound React itself holds while it builds one. The two enqueues in `flush`
+     * are ungated for a related reason: the response is over by then, and parking its last two chunks on a
+     * permit would only add a way for it not to end. They are also why the count can reach two at the very
+     * end — an ungated enqueue settles a pull without spending its permit — which is harmless, there being
+     * nothing left to produce.
+     *
+     * The cost is one extra stream hop and a microtask per chunk: 3.6ms → 4.0ms to push a 187 kB page through
+     * this module with nothing else in the way, which is not the shape of a real response, where the socket
+     * dominates by orders of magnitude.
+     */
+    let permits = 0;
+    const waiting = [];
+    /** Returns nothing when a permit was already free, so the common case costs no microtask. */
+    function takePermit() {
+        // Nothing will release another permit once the consumer is gone, and there is nothing left to protect:
+        // the caller goes on to a failing enqueue, which is what tears the pipeline down.
+        if (cancelled)
+            return;
+        if (permits > 0) {
+            permits--;
+            return;
+        }
+        return new Promise((resolve) => waiting.push(resolve));
+    }
+    function releasePermit() {
+        const next = waiting.shift();
+        if (next)
+            next();
+        else
+            permits++;
+    }
+    /** Fires `onDone` at most once, however the response ended — both cancel paths can reach it. */
+    let ended = false;
+    function reportDone() {
+        if (ended)
+            return;
+        ended = true;
+        onDone?.();
+    }
+    /**
+     * The consumer has gone away: stop producing, release everything the request was holding, and unpark both
+     * producers so they see {@link cancelled} rather than a permit that will never come.
+     *
+     * Called from the wrapper readable's `cancel`, which is reliable, and from the transformer's, which the
+     * standard skips once the close algorithm has started — so it has to be idempotent.
+     */
+    function teardown(reason) {
+        cancelled = true;
+        if (boundary) {
+            unschedule(boundary);
+            boundary = null;
+        }
+        batch.length = 0;
+        carry = null;
+        for (const resolve of waiting.splice(0))
+            resolve();
+        // Otherwise the teed RSC branch keeps being pumped for a response nobody will read, and the tee's
+        // other half buffers every chunk waiting for this one to catch up.
+        flightReader?.cancel(reason).catch(() => { });
+        // Unparks `flush` if it is waiting on a payload that will now never arrive.
+        flightDone();
+        reportDone();
+    }
+    /**
+     * Emits the HTML buffered since the last boundary, holding back the document trailer for `flush` to re-emit
+     * after the payload scripts.
+     *
+     * The batch is joined before the trailer is looked for, so one React split across two views is still found.
+     * A trailer split across two *batches* is not a shape React produces — it writes its final flush in one
+     * synchronous run — but this injector exists because `rsc-html-stream` made a narrower version of that same
+     * assumption and was wrong (see the module header), so anything that could still become a trailer is held
+     * back in {@link carry} rather than assumed not to be. Only `final`, the call from `flush`, may emit such a
+     * tail: by then there is no next batch for it to complete.
+     *
+     * A tail that never does complete therefore leaves after the payload scripts rather than before them, which
+     * is the deliberate half of the trade: releasing it the moment a script wants to go out is the very bug this
+     * guards, because the next batch may be the rest of the trailer. It costs at most 13 bytes of a truncated
+     * document arriving late, still inside `<body>`.
+     */
+    function emitBatch(controller, final = false) {
+        boundary = null;
+        let total = carry?.byteLength ?? 0;
+        for (const chunk of batch)
+            total += chunk.byteLength;
+        if (total === 0) {
+            batch.length = 0;
+            return;
+        }
+        const joined = new Uint8Array(total);
+        let at = 0;
+        if (carry) {
+            joined.set(carry, at);
+            at += carry.byteLength;
+            carry = null;
+        }
+        for (const chunk of batch) {
+            joined.set(chunk, at);
+            at += chunk.byteLength;
+        }
+        batch.length = 0;
+        const held = final ? (endsWithTrailer(joined, total) ? TRAILER_BYTES.length : 0) : trailerPrefixLength(joined, total);
+        const end = total - held;
+        // Copied rather than a `subarray`, which would keep the whole joined flush alive for 14 bytes.
+        if (held > 0 && !final)
+            carry = joined.slice(end);
+        if (end > 0)
+            controller.enqueue(joined.subarray(0, end));
+    }
+    async function writeFlight(controller) {
+        const reader = (flightReader = rscStream.getReader());
+        // One chunk at a time, deliberately *not* `{ stream: true }`: anything that is not valid UTF-8 on its
+        // own — a binary row's bytes, or a chunk that split a multi-byte character — throws, and the catch below
+        // re-encodes that whole chunk byte-exactly.
+        //
+        // Streaming is what makes that fallback wrong. A chunk ending mid-character leaves its lead bytes inside
+        // the decoder to be emitted with the next chunk; when the next chunk is a binary row and throws, those
+        // bytes are in neither `decode()`'s return nor `value`, and the client reassembles a payload short by
+        // them. It also left the end-of-stream flush able to throw from outside any `try`.
+        //
+        // `ignoreBOM` because a per-chunk decode re-runs the BOM check on every call: without it any chunk whose
+        // first three bytes are EF BB BF would silently lose them.
+        const decoder = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true });
+        const push = async (literal) => {
+            const permit = takePermit();
+            if (permit)
+                await permit;
+            if (cancelled)
+                return;
+            controller.enqueue(encoder.encode(scriptOpen + literal + scriptClose));
+        };
+        for (;;) {
+            if (cancelled)
+                return;
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            // Only the decode is guarded: a `push` inside the same `try` would answer a dead controller by
+            // re-encoding the chunk and enqueueing it again.
+            let literal;
+            try {
+                literal = escapeScript(JSON.stringify(decoder.decode(value)));
+            }
+            catch {
+                literal = `Uint8Array.from(atob(${JSON.stringify(btoa(latin1(value)))}), m => m.codePointAt(0))`;
+            }
+            if (cancelled)
+                return;
+            // A failed enqueue means the consumer is gone: release the RSC branch so `flush` unparks now rather
+            // than whenever the payload would have ended on its own.
+            try {
+                await push(literal);
+            }
+            catch {
+                cancelled = true;
+                reader.cancel().catch(() => { });
+                return;
+            }
+        }
+        // No end-of-stream flush: a non-streaming decoder holds nothing between calls, so there is nothing left
+        // to emit — and the flush this replaces could throw, erroring the response mid-document. See above.
+    }
+    const transformer = {
+        async transform(chunk, controller) {
+            if (boundary) {
+                batch.push(chunk);
+                return;
+            }
+            // The permit is taken once per *batch*, not once per chunk: React writes a whole flush in one microtask
+            // cascade and the flush has to leave here as one chunk (see `emitBatch`), so a per-chunk gate would
+            // hand the consumer one chunk per read instead. `transform` is never re-entered concurrently — the
+            // writable side serializes it on the promise this returns — so nothing else can claim the batch in
+            // between.
+            const permit = takePermit();
+            if (permit)
+                await permit;
+            batch.push(chunk);
+            // A macrotask, not a microtask: React writes a whole flush in one synchronous run but `pipeThrough`
+            // delivers it one microtask at a time, and a script injected between two chunks lands inside a tag.
+            boundary = schedule(() => {
+                try {
+                    emitBatch(controller);
+                }
+                catch (error) {
+                    // A dead consumer, all but always. `teardown` rather than `flightDone` alone: a payload pump parked
+                    // on a permit has to be unparked too, and the RSC branch it holds released.
+                    controller.error(error);
+                    teardown(error);
+                    return;
+                }
+                if (!startedFlight) {
+                    startedFlight = true;
+                    // Deliberately not awaited: this runs inside a scheduled callback with nothing to return to, and
+                    // the chain already routes a write failure to `controller.error` before settling `flightDone`.
+                    void writeFlight(controller)
+                        .catch((error) => controller.error(error))
+                        .then(flightDone);
+                }
+            });
+        },
+        async flush(controller) {
+            // Both of these have to happen *before* the await, and in this order.
+            try {
+                // Anything still batched — or carried — belongs ahead of the payload scripts, which sit at the end of
+                // `<body>`. Called unconditionally: a `carry` outlives its boundary, and an empty batch returns early.
+                if (boundary)
+                    unschedule(boundary);
+                emitBatch(controller, true);
+                // A writable side that closed without ever reaching `transform` — an HTML stream with no chunks at
+                // all — leaves nothing to have started the payload, and `flightDone` is only ever called from that
+                // chain or from `cancel`. Without this the await below parks on a promise nothing will settle and the
+                // response never ends. `cancelled` short-circuits it: there is nowhere to write the payload to.
+                if (!startedFlight) {
+                    startedFlight = true;
+                    if (cancelled)
+                        flightDone();
+                    else
+                        void writeFlight(controller)
+                            .catch((error) => controller.error(error))
+                            .then(flightDone);
+                }
+            }
+            catch (error) {
+                // The consumer went away while the batch was being emitted, so there is nothing left to write to and
+                // nothing to wait for. Settled explicitly rather than left dangling, so the payload chain is released.
+                teardown(error);
+                return;
+            }
+            await flightWritten;
+            // That await spans the whole payload, and the consumer can go away inside it — with `cancel` skipped
+            // (see `cancelled`), a throwing enqueue is the only signal. Unguarded it rejects `flush`, which
+            // nothing owns and which surfaces as an unhandled rejection.
+            try {
+                if (!cancelled)
+                    controller.enqueue(encoder.encode(TRAILER));
+            }
+            catch {
+                // Nowhere left to put the trailer. A response the client abandoned is not a fault.
+                cancelled = true;
+                flightReader?.cancel().catch(() => { });
+            }
+            finally {
+                // A `finally` because `onDone` releases the abort forwarder in `renderComponent`, however this ended.
+                reportDone();
+            }
+        },
+        cancel(reason) {
+            teardown(reason);
+        },
+    };
+    const inner = new TransformStream(transformer);
+    const innerReader = inner.readable.getReader();
+    /**
+     * A pull-driven wrapper around the transform's readable, and the only reason this function does not simply
+     * return the transform: `pull` runs once per chunk the consumer takes, which is the demand signal the two
+     * producers park on (see {@link takePermit}). It is also the one cancel notification the standard never
+     * skips, which is what makes {@link teardown} reliable.
+     */
+    const readable = new ReadableStream({
+        async pull(controller) {
+            releasePermit();
+            const { done, value } = await innerReader.read();
+            try {
+                if (done)
+                    controller.close();
+                else
+                    controller.enqueue(value);
+            }
+            catch {
+                // Cancelled while this pull was in flight. `teardown` has already run; there is nobody to hand it to.
+            }
+        },
+        cancel(reason) {
+            teardown(reason);
+            return innerReader.cancel(reason);
+        },
+    });
+    return { readable, writable: inner.writable };
+}
+//# sourceMappingURL=flight-inject.js.map

package/dist/runtime/flight-inject.js.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"flight-inject.js","sourceRoot":"","sources":["../../src/runtime/flight-inject.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Carrying the flight payload inside the HTML document, so the browser hydrates from bytes it already has\n * rather than fetching the page twice. The reader is `readFlightPayload` in `entry.client.tsx`.\n *\n * The wire format is `rsc-html-stream`'s — a run of `<script>(self.__FLIGHT_DATA||=[]).push(\"…\")</script>`\n * tags — but the implementation is first-party, because that package tests each HTML chunk for the\n * document trailer with `endsWith`: React's byte writer splits any write straddling its 2 kB views, so\n * `</body></html>` can arrive as two chunks and the document ends up with two trailers.\n */\n\n/**\n * {@link Transformer} plus the `cancel` hook the Streams standard added for a cancelled readable side —\n * declared here because the bundled lib types have not caught up with what Node calls.\n *\n * It matters because `cancel` is the only notification that a response ended *without* finishing, and both\n * users of it release a listener that would otherwise outlive the request.\n */\nexport type CancellableTransformer<I, O> = Transformer<I, O> & { cancel?: (reason?: unknown) => void };\n\nconst encoder = new TextEncoder();\n\n/** What React closes an `<html>` document with, and what this module re-emits after the last payload script. */\nconst TRAILER = '</body></html>';\nconst TRAILER_BYTES = encoder.encode(TRAILER);\n\n/**\n * A macrotask boundary: `setImmediate` where there is one, which is the current turn's check phase rather\n * than a timer, and `setTimeout` as the portable fallback. A Node timer has a 1ms floor that every HTML\n * flush would pay — 4.7ms → 3.0ms time-to-last-byte on a 30 kB payload.\n */\ntype TaskHandle = ReturnType<typeof setTimeout> | ReturnType<typeof setImmediate>;\nconst hasSetImmediate = typeof setImmediate === 'function';\nconst schedule: (fn: () => void) => TaskHandle = hasSetImmediate ? setImmediate : (fn) => setTimeout(fn, 0);\nconst unschedule = (handle: TaskHandle): void => {\n if (hasSetImmediate) clearImmediate(handle as ReturnType<typeof setImmediate>);\n else clearTimeout(handle as ReturnType<typeof setTimeout>);\n};\n\n/**\n * Escapes the two sequences that would end a `<script>` element early. Guarded by `includes('<')`, which is\n * far cheaper than two regex passes over 30 kB of payload that usually has no `<` in it. `</script` becomes\n * `</\\script`, not `<\\/script`, which would break the valid JS `0</script/`.\n */\nfunction escapeScript(script: string): string {\n return script.includes('<') ? script.replace(/<!--/g, '<\\\\!--').replace(/<\\/(script)/gi, '</\\\\$1') : script;\n}\n\n/**\n * The bytes of `chunk` as a latin1 string, which is the form `btoa` takes. Sliced because\n * `String.fromCharCode(...chunk)` passes one argument per byte and overflows the stack.\n */\nfunction latin1(chunk: Uint8Array): string {\n let out = '';\n for (let at = 0; at < chunk.length; at += 8192) out += String.fromCharCode(...chunk.subarray(at, at + 8192));\n return out;\n}\n\n/** Whether `buffer`'s first `length` bytes end with the document trailer. */\nfunction endsWithTrailer(buffer: Uint8Array, length: number): boolean {\n if (length < TRAILER_BYTES.length) return false;\n const from = length - TRAILER_BYTES.length;\n for (let i = 0; i < TRAILER_BYTES.length; i++) {\n if (buffer[from + i] !== TRAILER_BYTES[i]) return false;\n }\n return true;\n}\n\n/**\n * How many of `buffer`'s last bytes could still turn into the document trailer — the length of the longest\n * suffix of `buffer[0..length)` that is a prefix of it, `TRAILER_BYTES.length` for the whole thing.\n *\n * At most 14 bytes are ever held back, and in practice 0: a React flush ends with a closed tag, not with the\n * start of one. Cheaper than it looks, too — the first comparison rejects every suffix whose first byte is\n * not `<`.\n */\nfunction trailerPrefixLength(buffer: Uint8Array, length: number): number {\n candidate: for (let take = Math.min(length, TRAILER_BYTES.length); take > 0; take--) {\n const from = length - take;\n for (let i = 0; i < take; i++) if (buffer[from + i] !== TRAILER_BYTES[i]) continue candidate;\n return take;\n }\n return 0;\n}\n\n/**\n * The characters a CSP nonce may be made of: base64 and base64url, which is what every generator of one emits\n * — Hono's `secureHeaders()`, the only source the framework reads, produces base64 of 16 random bytes.\n *\n * The tag below is built by hand rather than by React, so this is the one attribute value in a rendered\n * document that nothing else escapes. The value is not attacker-controlled today, but the framework does not\n * own where it comes from: `c.get('secureHeadersNonce')` is an ordinary context variable that any middleware\n * can set, and a nonce carrying a `\"` would close the attribute and open a script-injection point in the\n * document. Anything outside this set is dropped rather than escaped, because a value made of other characters\n * is not a nonce at all: a page whose payload scripts the policy then refuses is the visible failure to have,\n * where an escaped garbage nonce would be a silent one.\n */\nconst NONCE_CHARS = /^[A-Za-z0-9+/=_-]+$/;\n\nexport function injectFlightPayload(\n rscStream: ReadableStream<Uint8Array>,\n options: { nonce?: string; onDone?: () => void } = {},\n): ReadableWritablePair<Uint8Array, Uint8Array> {\n const { nonce, onDone } = options;\n const safeNonce = nonce !== undefined && NONCE_CHARS.test(nonce) ? nonce : undefined;\n const scriptOpen = `<script${safeNonce ? ` nonce=\"${safeNonce}\"` : ''}>(self.__FLIGHT_DATA||=[]).push(`;\n const scriptClose = ')</script>';\n\n const { promise: flightWritten, resolve: flightDone } = Promise.withResolvers<void>();\n let startedFlight = false;\n\n const batch: Uint8Array[] = [];\n let boundary: TaskHandle | null = null;\n /**\n * The tail of the last batch that could still be the start of the document trailer, carried into the next\n * one. See {@link emitBatch}.\n */\n let carry: Uint8Array | null = null;\n\n /**\n * Set once the consumer has gone away, so nothing tries to enqueue into a readable that cannot take it.\n *\n * The `cancel` hook alone cannot set this: per the Streams standard, cancelling the readable after the\n * close algorithm has started skips the transformer's `cancel` entirely — and `flush` awaiting the whole\n * payload is precisely that window. So a failed enqueue counts as the signal too.\n */\n let cancelled = false;\n /** Held so {@link cancelled} can release the teed RSC branch rather than leaving it to be pumped. */\n let flightReader: ReadableStreamDefaultReader<Uint8Array> | null = null;\n\n /**\n * One permit per chunk the consumer has asked for: the backpressure a `TransformStream` alone does not give\n * this module.\n *\n * A transform's writable side parks a write while its readable's queue is over the mark, which covers the\n * HTML — but only once something has been enqueued, and `transform` defers that to a macrotask. So a\n * producer that writes a whole document without ever yielding the microtask queue is admitted in full, and\n * {@link writeFlight}, which pumps the payload into the same controller from a detached promise, is never\n * gated at all: measured, a consumer that read one chunk and stalled still pulled all 500 chunks of a test\n * payload into the queue, where this brings it down to 3. `controller.desiredSize` is no help — a transform\n * readable's high-water mark is 0, so it is never positive.\n *\n * The wrapper readable this function returns is the missing signal: its `pull` runs exactly when the\n * consumer wants another chunk, and releases one permit. Both producers — the HTML batcher and the payload\n * pump — take one before they enqueue, so a stalled client parks React instead of filling the process. The\n * Streams standard calls `pull` again only once the previous call has settled, and a call only settles once\n * a chunk has arrived, so permits are handed out one at a time and the queue is bounded at a chunk.\n *\n * What is left buffered is one React flush, because a flush has to leave here as a single chunk (see\n * {@link emitBatch}) — the same bound React itself holds while it builds one. The two enqueues in `flush`\n * are ungated for a related reason: the response is over by then, and parking its last two chunks on a\n * permit would only add a way for it not to end. They are also why the count can reach two at the very\n * end — an ungated enqueue settles a pull without spending its permit — which is harmless, there being\n * nothing left to produce.\n *\n * The cost is one extra stream hop and a microtask per chunk: 3.6ms → 4.0ms to push a 187 kB page through\n * this module with nothing else in the way, which is not the shape of a real response, where the socket\n * dominates by orders of magnitude.\n */\n let permits = 0;\n const waiting: Array<() => void> = [];\n\n /** Returns nothing when a permit was already free, so the common case costs no microtask. */\n function takePermit(): Promise<void> | undefined {\n // Nothing will release another permit once the consumer is gone, and there is nothing left to protect:\n // the caller goes on to a failing enqueue, which is what tears the pipeline down.\n if (cancelled) return;\n if (permits > 0) {\n permits--;\n return;\n }\n return new Promise<void>((resolve) => waiting.push(resolve));\n }\n\n function releasePermit(): void {\n const next = waiting.shift();\n if (next) next();\n else permits++;\n }\n\n /** Fires `onDone` at most once, however the response ended — both cancel paths can reach it. */\n let ended = false;\n function reportDone(): void {\n if (ended) return;\n ended = true;\n onDone?.();\n }\n\n /**\n * The consumer has gone away: stop producing, release everything the request was holding, and unpark both\n * producers so they see {@link cancelled} rather than a permit that will never come.\n *\n * Called from the wrapper readable's `cancel`, which is reliable, and from the transformer's, which the\n * standard skips once the close algorithm has started — so it has to be idempotent.\n */\n function teardown(reason?: unknown): void {\n cancelled = true;\n if (boundary) {\n unschedule(boundary);\n boundary = null;\n }\n batch.length = 0;\n carry = null;\n for (const resolve of waiting.splice(0)) resolve();\n // Otherwise the teed RSC branch keeps being pumped for a response nobody will read, and the tee's\n // other half buffers every chunk waiting for this one to catch up.\n flightReader?.cancel(reason).catch(() => {});\n // Unparks `flush` if it is waiting on a payload that will now never arrive.\n flightDone();\n reportDone();\n }\n\n /**\n * Emits the HTML buffered since the last boundary, holding back the document trailer for `flush` to re-emit\n * after the payload scripts.\n *\n * The batch is joined before the trailer is looked for, so one React split across two views is still found.\n * A trailer split across two *batches* is not a shape React produces — it writes its final flush in one\n * synchronous run — but this injector exists because `rsc-html-stream` made a narrower version of that same\n * assumption and was wrong (see the module header), so anything that could still become a trailer is held\n * back in {@link carry} rather than assumed not to be. Only `final`, the call from `flush`, may emit such a\n * tail: by then there is no next batch for it to complete.\n *\n * A tail that never does complete therefore leaves after the payload scripts rather than before them, which\n * is the deliberate half of the trade: releasing it the moment a script wants to go out is the very bug this\n * guards, because the next batch may be the rest of the trailer. It costs at most 13 bytes of a truncated\n * document arriving late, still inside `<body>`.\n */\n function emitBatch(controller: TransformStreamDefaultController<Uint8Array>, final = false): void {\n boundary = null;\n let total = carry?.byteLength ?? 0;\n for (const chunk of batch) total += chunk.byteLength;\n if (total === 0) {\n batch.length = 0;\n return;\n }\n\n const joined = new Uint8Array(total);\n let at = 0;\n if (carry) {\n joined.set(carry, at);\n at += carry.byteLength;\n carry = null;\n }\n for (const chunk of batch) {\n joined.set(chunk, at);\n at += chunk.byteLength;\n }\n batch.length = 0;\n\n const held = final ? (endsWithTrailer(joined, total) ? TRAILER_BYTES.length : 0) : trailerPrefixLength(joined, total);\n const end = total - held;\n // Copied rather than a `subarray`, which would keep the whole joined flush alive for 14 bytes.\n if (held > 0 && !final) carry = joined.slice(end);\n if (end > 0) controller.enqueue(joined.subarray(0, end));\n }\n\n async function writeFlight(controller: TransformStreamDefaultController<Uint8Array>): Promise<void> {\n const reader = (flightReader = rscStream.getReader());\n // One chunk at a time, deliberately *not* `{ stream: true }`: anything that is not valid UTF-8 on its\n // own — a binary row's bytes, or a chunk that split a multi-byte character — throws, and the catch below\n // re-encodes that whole chunk byte-exactly.\n //\n // Streaming is what makes that fallback wrong. A chunk ending mid-character leaves its lead bytes inside\n // the decoder to be emitted with the next chunk; when the next chunk is a binary row and throws, those\n // bytes are in neither `decode()`'s return nor `value`, and the client reassembles a payload short by\n // them. It also left the end-of-stream flush able to throw from outside any `try`.\n //\n // `ignoreBOM` because a per-chunk decode re-runs the BOM check on every call: without it any chunk whose\n // first three bytes are EF BB BF would silently lose them.\n const decoder = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true });\n const push = async (literal: string): Promise<void> => {\n const permit = takePermit();\n if (permit) await permit;\n if (cancelled) return;\n controller.enqueue(encoder.encode(scriptOpen + literal + scriptClose));\n };\n for (;;) {\n if (cancelled) return;\n const { done, value } = await reader.read();\n if (done) break;\n // Only the decode is guarded: a `push` inside the same `try` would answer a dead controller by\n // re-encoding the chunk and enqueueing it again.\n let literal: string;\n try {\n literal = escapeScript(JSON.stringify(decoder.decode(value)));\n } catch {\n literal = `Uint8Array.from(atob(${JSON.stringify(btoa(latin1(value)))}), m => m.codePointAt(0))`;\n }\n if (cancelled) return;\n // A failed enqueue means the consumer is gone: release the RSC branch so `flush` unparks now rather\n // than whenever the payload would have ended on its own.\n try {\n await push(literal);\n } catch {\n cancelled = true;\n reader.cancel().catch(() => {});\n return;\n }\n }\n // No end-of-stream flush: a non-streaming decoder holds nothing between calls, so there is nothing left\n // to emit — and the flush this replaces could throw, erroring the response mid-document. See above.\n }\n\n const transformer: CancellableTransformer<Uint8Array, Uint8Array> = {\n async transform(chunk, controller) {\n if (boundary) {\n batch.push(chunk);\n return;\n }\n // The permit is taken once per *batch*, not once per chunk: React writes a whole flush in one microtask\n // cascade and the flush has to leave here as one chunk (see `emitBatch`), so a per-chunk gate would\n // hand the consumer one chunk per read instead. `transform` is never re-entered concurrently — the\n // writable side serializes it on the promise this returns — so nothing else can claim the batch in\n // between.\n const permit = takePermit();\n if (permit) await permit;\n batch.push(chunk);\n // A macrotask, not a microtask: React writes a whole flush in one synchronous run but `pipeThrough`\n // delivers it one microtask at a time, and a script injected between two chunks lands inside a tag.\n boundary = schedule(() => {\n try {\n emitBatch(controller);\n } catch (error) {\n // A dead consumer, all but always. `teardown` rather than `flightDone` alone: a payload pump parked\n // on a permit has to be unparked too, and the RSC branch it holds released.\n controller.error(error);\n teardown(error);\n return;\n }\n if (!startedFlight) {\n startedFlight = true;\n // Deliberately not awaited: this runs inside a scheduled callback with nothing to return to, and\n // the chain already routes a write failure to `controller.error` before settling `flightDone`.\n void writeFlight(controller)\n .catch((error) => controller.error(error))\n .then(flightDone);\n }\n });\n },\n async flush(controller) {\n // Both of these have to happen *before* the await, and in this order.\n try {\n // Anything still batched — or carried — belongs ahead of the payload scripts, which sit at the end of\n // `<body>`. Called unconditionally: a `carry` outlives its boundary, and an empty batch returns early.\n if (boundary) unschedule(boundary);\n emitBatch(controller, true);\n // A writable side that closed without ever reaching `transform` — an HTML stream with no chunks at\n // all — leaves nothing to have started the payload, and `flightDone` is only ever called from that\n // chain or from `cancel`. Without this the await below parks on a promise nothing will settle and the\n // response never ends. `cancelled` short-circuits it: there is nowhere to write the payload to.\n if (!startedFlight) {\n startedFlight = true;\n if (cancelled) flightDone();\n else\n void writeFlight(controller)\n .catch((error) => controller.error(error))\n .then(flightDone);\n }\n } catch (error) {\n // The consumer went away while the batch was being emitted, so there is nothing left to write to and\n // nothing to wait for. Settled explicitly rather than left dangling, so the payload chain is released.\n teardown(error);\n return;\n }\n\n await flightWritten;\n // That await spans the whole payload, and the consumer can go away inside it — with `cancel` skipped\n // (see `cancelled`), a throwing enqueue is the only signal. Unguarded it rejects `flush`, which\n // nothing owns and which surfaces as an unhandled rejection.\n try {\n if (!cancelled) controller.enqueue(encoder.encode(TRAILER));\n } catch {\n // Nowhere left to put the trailer. A response the client abandoned is not a fault.\n cancelled = true;\n flightReader?.cancel().catch(() => {});\n } finally {\n // A `finally` because `onDone` releases the abort forwarder in `renderComponent`, however this ended.\n reportDone();\n }\n },\n cancel(reason) {\n teardown(reason);\n },\n };\n\n const inner = new TransformStream<Uint8Array, Uint8Array>(transformer);\n const innerReader = inner.readable.getReader();\n /**\n * A pull-driven wrapper around the transform's readable, and the only reason this function does not simply\n * return the transform: `pull` runs once per chunk the consumer takes, which is the demand signal the two\n * producers park on (see {@link takePermit}). It is also the one cancel notification the standard never\n * skips, which is what makes {@link teardown} reliable.\n */\n const readable = new ReadableStream<Uint8Array>({\n async pull(controller) {\n releasePermit();\n const { done, value } = await innerReader.read();\n try {\n if (done) controller.close();\n else controller.enqueue(value);\n } catch {\n // Cancelled while this pull was in flight. `teardown` has already run; there is nobody to hand it to.\n }\n },\n cancel(reason) {\n teardown(reason);\n return innerReader.cancel(reason);\n },\n });\n return { readable, writable: inner.writable };\n}\n"]}

package/dist/runtime/hot-update.d.ts ADDED Viewed

@@ -0,0 +1,44 @@
+/**
+ * Walking the page from the build it is running to the build the dev server has announced. Its own module
+ * because every decision in it is about *giving up correctly*, which is worth testing on its own.
+ *
+ * Dev-only: the sole caller sits behind `import.meta.webpackHot`, which a production build replaces with
+ * `false`.
+ */
+/** The slice of `import.meta.webpackHot` the walk uses. */
+export interface HotRuntime {
+    /**
+     * Fetches the update manifest for the build the page is running and, with `autoApply`, applies it.
+     *
+     * Resolves with the updated module ids, or with **null** when the manifest 404s — which the runtime
+     * treats as "nothing to do" rather than an error. Rejects only when an update was found and could not be
+     * applied.
+     */
+    check(autoApply?: boolean): Promise<Array<string | number> | null>;
+    status(): string;
+}
+/** Why the page has to be reloaded rather than patched — `error` only where one was thrown. */
+export interface ReloadReason {
+    reason: string;
+    error?: unknown;
+}
+/**
+ * Advances the page to `targetHash()`, applying one build's worth of updates per round, and reports whether
+ * it got there.
+ *
+ * Both hashes are read through functions because both move underneath this loop: an applied update rewrites
+ * `__webpack_hash__`, and a save landing mid-walk moves the target further out. Reading them fresh each
+ * round is what lets one walk absorb a burst of saves.
+ *
+ * Returns `null` once the page is on the target build, or the reason it cannot get there — every one of
+ * which is a reload, because the alternative is a page that silently stops updating:
+ *
+ * - **An update was already in flight.** `check` may only be called from `idle`.
+ * - **`check` rejected.** An update was found and could not be applied — usually a module that declines
+ *   them, which is the ordinary cost of changing something react-refresh cannot patch.
+ * - **`check` resolved with null, or applied without moving the hash.** The chain of `*.hot-update.json`
+ *   files leading to the target is broken — as it is after a dev-server restart, whose first act is to wipe
+ *   the output directory an already-open tab would ask for. The hash cannot move from there, so retrying
+ *   would re-request the same 404 for as long as the tab stays open.
+ */
+export declare function walkHotUpdates(hot: HotRuntime, currentHash: () => string, targetHash: () => string | undefined): Promise<ReloadReason | null>;

package/dist/runtime/hot-update.js ADDED Viewed

@@ -0,0 +1,44 @@
+/**
+ * Walking the page from the build it is running to the build the dev server has announced. Its own module
+ * because every decision in it is about *giving up correctly*, which is worth testing on its own.
+ *
+ * Dev-only: the sole caller sits behind `import.meta.webpackHot`, which a production build replaces with
+ * `false`.
+ */
+/**
+ * Advances the page to `targetHash()`, applying one build's worth of updates per round, and reports whether
+ * it got there.
+ *
+ * Both hashes are read through functions because both move underneath this loop: an applied update rewrites
+ * `__webpack_hash__`, and a save landing mid-walk moves the target further out. Reading them fresh each
+ * round is what lets one walk absorb a burst of saves.
+ *
+ * Returns `null` once the page is on the target build, or the reason it cannot get there — every one of
+ * which is a reload, because the alternative is a page that silently stops updating:
+ *
+ * - **An update was already in flight.** `check` may only be called from `idle`.
+ * - **`check` rejected.** An update was found and could not be applied — usually a module that declines
+ *   them, which is the ordinary cost of changing something react-refresh cannot patch.
+ * - **`check` resolved with null, or applied without moving the hash.** The chain of `*.hot-update.json`
+ *   files leading to the target is broken — as it is after a dev-server restart, whose first act is to wipe
+ *   the output directory an already-open tab would ask for. The hash cannot move from there, so retrying
+ *   would re-request the same 404 for as long as the tab stays open.
+ */
+export async function walkHotUpdates(hot, currentHash, targetHash) {
+    while (targetHash() !== undefined && targetHash() !== currentHash()) {
+        if (hot.status() !== 'idle')
+            return { reason: 'a hot update was already in flight' };
+        const before = currentHash();
+        let applied;
+        try {
+            applied = await hot.check(true);
+        }
+        catch (error) {
+            return { reason: 'a hot update failed to apply', error };
+        }
+        if (applied === null || currentHash() === before)
+            return { reason: 'this build cannot be applied on top of the page' };
+    }
+    return null;
+}
+//# sourceMappingURL=hot-update.js.map

package/dist/runtime/hot-update.js.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"hot-update.js","sourceRoot":"","sources":["../../src/runtime/hot-update.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAqBH;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,CAAC,KAAK,UAAU,cAAc,CAAC,GAAe,EAAE,WAAyB,EAAE,UAAoC;IACnH,OAAO,UAAU,EAAE,KAAK,SAAS,IAAI,UAAU,EAAE,KAAK,WAAW,EAAE,EAAE,CAAC;QACpE,IAAI,GAAG,CAAC,MAAM,EAAE,KAAK,MAAM;YAAE,OAAO,EAAE,MAAM,EAAE,oCAAoC,EAAE,CAAC;QACrF,MAAM,MAAM,GAAG,WAAW,EAAE,CAAC;QAC7B,IAAI,OAAsC,CAAC;QAC3C,IAAI,CAAC;YACH,OAAO,GAAG,MAAM,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QAClC,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO,EAAE,MAAM,EAAE,8BAA8B,EAAE,KAAK,EAAE,CAAC;QAC3D,CAAC;QACD,IAAI,OAAO,KAAK,IAAI,IAAI,WAAW,EAAE,KAAK,MAAM;YAAE,OAAO,EAAE,MAAM,EAAE,iDAAiD,EAAE,CAAC;IACzH,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC","sourcesContent":["/**\n * Walking the page from the build it is running to the build the dev server has announced. Its own module\n * because every decision in it is about *giving up correctly*, which is worth testing on its own.\n *\n * Dev-only: the sole caller sits behind `import.meta.webpackHot`, which a production build replaces with\n * `false`.\n */\n\n/** The slice of `import.meta.webpackHot` the walk uses. */\nexport interface HotRuntime {\n /**\n * Fetches the update manifest for the build the page is running and, with `autoApply`, applies it.\n *\n * Resolves with the updated module ids, or with **null** when the manifest 404s — which the runtime\n * treats as \"nothing to do\" rather than an error. Rejects only when an update was found and could not be\n * applied.\n */\n check(autoApply?: boolean): Promise<Array<string | number> | null>;\n status(): string;\n}\n\n/** Why the page has to be reloaded rather than patched — `error` only where one was thrown. */\nexport interface ReloadReason {\n reason: string;\n error?: unknown;\n}\n\n/**\n * Advances the page to `targetHash()`, applying one build's worth of updates per round, and reports whether\n * it got there.\n *\n * Both hashes are read through functions because both move underneath this loop: an applied update rewrites\n * `__webpack_hash__`, and a save landing mid-walk moves the target further out. Reading them fresh each\n * round is what lets one walk absorb a burst of saves.\n *\n * Returns `null` once the page is on the target build, or the reason it cannot get there — every one of\n * which is a reload, because the alternative is a page that silently stops updating:\n *\n * - **An update was already in flight.** `check` may only be called from `idle`.\n * - **`check` rejected.** An update was found and could not be applied — usually a module that declines\n * them, which is the ordinary cost of changing something react-refresh cannot patch.\n * - **`check` resolved with null, or applied without moving the hash.** The chain of `*.hot-update.json`\n * files leading to the target is broken — as it is after a dev-server restart, whose first act is to wipe\n * the output directory an already-open tab would ask for. The hash cannot move from there, so retrying\n * would re-request the same 404 for as long as the tab stays open.\n */\nexport async function walkHotUpdates(hot: HotRuntime, currentHash: () => string, targetHash: () => string | undefined): Promise<ReloadReason | null> {\n while (targetHash() !== undefined && targetHash() !== currentHash()) {\n if (hot.status() !== 'idle') return { reason: 'a hot update was already in flight' };\n const before = currentHash();\n let applied: Array<string | number> | null;\n try {\n applied = await hot.check(true);\n } catch (error) {\n return { reason: 'a hot update failed to apply', error };\n }\n if (applied === null || currentHash() === before) return { reason: 'this build cannot be applied on top of the page' };\n }\n return null;\n}\n"]}