@bleedingdev/modern-js-runtime-extensions 3.9.0-ultramodern.2 → 3.9.0-ultramodern.20

package/tests/workspaceEvents.test.ts

@@ -0,0 +1,221 @@
+import * as contracts from '../src/workspaceEvents';
+
+const cases = [
+  {
+    name: 'ultramodern:navigate',
+    valid: { to: '/dashboard', replace: false, state: { from: 'shell' } },
+    invalid: [
+      {},
+      { to: '' },
+      { to: '  ' },
+      { to: 42 },
+      { to: '/', replace: 'false' },
+      { to: '/', state: [] },
+      { to: '/', state: null },
+    ],
+    validate: contracts.isUltramodernNavigatePayload,
+    dispatch: contracts.dispatchUltramodernNavigate,
+    on: contracts.onUltramodernNavigate,
+  },
+  {
+    name: 'ultramodern:route-settled',
+    valid: { pathname: '/cs', locale: 'cs', title: 'Home' },
+    invalid: [
+      {},
+      { pathname: ' ' },
+      { pathname: '/', locale: 'de' },
+      { pathname: '/', locale: null },
+      { pathname: '/', title: '' },
+      { pathname: '/', title: 42 },
+    ],
+    validate: contracts.isUltramodernRouteSettledPayload,
+    dispatch: contracts.dispatchUltramodernRouteSettled,
+    on: contracts.onUltramodernRouteSettled,
+  },
+  {
+    name: 'ultramodern:remote-ready',
+    valid: { appId: 'catalog', build: 'a', surface: 'ui', version: '1' },
+    invalid: [
+      {},
+      { appId: 42 },
+      { appId: ' ' },
+      { appId: 'catalog', build: '' },
+      { appId: 'catalog', surface: null },
+      { appId: 'catalog', version: 1 },
+    ],
+    validate: contracts.isUltramodernRemoteReadyPayload,
+    dispatch: contracts.dispatchUltramodernRemoteReady,
+    on: contracts.onUltramodernRemoteReady,
+  },
+  {
+    name: 'ultramodern:performance-signal',
+    valid: {
+      signalId: 'bfcache',
+      status: 'pass',
+      durationMs: 0,
+      detail: { source: 'browser' },
+    },
+    invalid: [
+      {},
+      { signalId: 'unknown', status: 'pass' },
+      { signalId: 'bfcache', status: 'unknown' },
+      ...[-1, Number.NaN, Number.POSITIVE_INFINITY, '1', null].map(
+        durationMs => ({ signalId: 'bfcache', status: 'pass', durationMs }),
+      ),
+      { signalId: 'bfcache', status: 'pass', detail: [] },
+      { signalId: 'bfcache', status: 'pass', detail: null },
+    ],
+    validate: contracts.isUltramodernPerformanceSignalPayload,
+    dispatch: contracts.dispatchUltramodernPerformanceSignal,
+    on: contracts.onUltramodernPerformanceSignal,
+  },
+] as const;
+
+describe('workspace event contracts', () => {
+  for (const { name, valid, invalid, validate, dispatch, on } of cases) {
+    it(`${name} preserves schema validation and error data`, () => {
+      expect(validate(valid)).toBe(true);
+      expect(
+        contracts.assertUltramodernWorkspaceEventPayload(name, valid),
+      ).toBe(valid);
+      for (const payload of [null, undefined, [], false, 'text', ...invalid]) {
+        expect(validate(payload)).toBe(false);
+        expect(
+          contracts.isUltramodernWorkspaceEventPayload(name, payload),
+        ).toBe(false);
+        let error: unknown;
+        try {
+          contracts.assertUltramodernWorkspaceEventPayload(name, payload);
+        } catch (caught) {
+          error = caught;
+        }
+        expect(error).toBeInstanceOf(
+          contracts.UltramodernWorkspaceEventValidationError,
+        );
+        expect(error).toMatchObject({
+          name: 'UltramodernWorkspaceEventValidationError',
+          eventName: name,
+          payload,
+        });
+      }
+    });
+
+    it(`${name} uses native dispatch, preserves payload identity and cleans up`, () => {
+      const target = new EventTarget();
+      const received: unknown[] = [];
+      const handler = (payload: unknown, event: CustomEvent<unknown>) => {
+        expect(event).toBeInstanceOf(CustomEvent);
+        expect(event.type).toBe(name);
+        expect(event.bubbles).toBe(true);
+        expect(event.composed).toBe(true);
+        expect(event.cancelable).toBe(false);
+        expect(event.target).toBe(target);
+        expect(event.detail).toBe(payload);
+        received.push(payload);
+      };
+      const unsubscribe = on(target, handler);
+      // Each table row correlates the convenience dispatch with its own schema.
+      const dispatchPayload = dispatch as (
+        target: EventTarget,
+        payload: typeof valid,
+      ) => boolean;
+      expect(dispatchPayload(target, valid)).toBe(true);
+      expect(received).toEqual([valid]);
+      expect(received[0]).toBe(valid);
+      unsubscribe();
+      unsubscribe();
+      dispatchPayload(target, valid);
+      expect(received).toEqual([valid]);
+    });
+  }
+
+  it('accepts consumer-owned fields, explicit undefined optionals and every signal id', () => {
+    const payload = {
+      to: '/raw',
+      replace: undefined,
+      state: undefined,
+      extension: 'consumer-owned',
+    };
+    expect(
+      contracts.assertUltramodernWorkspaceEventPayload(
+        'ultramodern:navigate',
+        payload,
+      ),
+    ).toBe(payload);
+    expect(
+      contracts.isUltramodernRouteSettledPayload({
+        pathname: '/',
+        locale: undefined,
+        title: undefined,
+      }),
+    ).toBe(true);
+    for (const signalId of [
+      'bfcache',
+      'core-web-vitals-rum',
+      'duplicate-prefetch-warmup',
+      'cache-policy-sanity',
+      'save-data-behavior',
+      'cloudflare-ssr-cache-hints',
+    ]) {
+      expect(
+        contracts.isUltramodernPerformanceSignalPayload({
+          signalId,
+          status: 'warn',
+        }),
+      ).toBe(true);
+    }
+  });
+
+  it('accepts detail-carrying events from another realm', () => {
+    const target = new EventTarget();
+    const add = rstest.spyOn(target, 'addEventListener');
+    const handler = rstest.fn();
+    const unsubscribe = contracts.onUltramodernNavigate(target, handler);
+    const listener = add.mock.calls[0]?.[1] as EventListener;
+    // A CustomEvent from an iframe/foreign realm fails `instanceof`; the
+    // listener must duck-type on `detail` instead of rejecting it.
+    const payload = { to: '/foreign' };
+    listener({ type: 'ultramodern:navigate', detail: payload } as never);
+    expect(handler).toHaveBeenCalledTimes(1);
+    expect(handler.mock.calls[0]?.[0]).toBe(payload);
+    unsubscribe();
+    add.mockRestore();
+  });
+
+  it('rejects invalid dispatch before notifying listeners', () => {
+    const target = new EventTarget();
+    const handler = rstest.fn();
+    const unsubscribe = contracts.onUltramodernNavigate(target, handler);
+    expect(() =>
+      contracts.dispatchUltramodernNavigate(target, { to: '' }),
+    ).toThrow();
+    expect(handler).not.toHaveBeenCalled();
+    unsubscribe();
+  });
+
+  it('validates incoming event details and removes only its own listener', () => {
+    const target = new EventTarget();
+    const add = rstest.spyOn(target, 'addEventListener');
+    const remove = rstest.spyOn(target, 'removeEventListener');
+    const handler = rstest.fn();
+    const first = contracts.onUltramodernNavigate(target, handler);
+    const listener = add.mock.calls[0]?.[1] as EventListener;
+    for (const event of [
+      new Event('ultramodern:navigate'),
+      new CustomEvent('ultramodern:navigate', { detail: { to: '' } }),
+    ]) {
+      // Native dispatch reports listener errors asynchronously; invoke the
+      // registered listener directly to inspect the precise validation failure.
+      expect(() => listener(event)).toThrow();
+    }
+    expect(handler).not.toHaveBeenCalled();
+    const second = contracts.onUltramodernNavigate(target, handler);
+    first();
+    expect(remove).toHaveBeenCalledWith('ultramodern:navigate', listener);
+    contracts.dispatchUltramodernNavigate(target, { to: '/still-subscribed' });
+    expect(handler).toHaveBeenCalledTimes(1);
+    second();
+    add.mockRestore();
+    remove.mockRestore();
+  });
+});

package/dist/cjs/rscHtmlStream.js

@@ -1,128 +0,0 @@
-"use strict";
-var __webpack_require__ = {};
-(()=>{
-    __webpack_require__.d = (exports1, getters, values)=>{
-        var define = (defs, kind)=>{
-            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
-                enumerable: true,
-                [kind]: defs[key]
-            });
-        };
-        define(getters, "get");
-        define(values, "value");
-    };
-})();
-(()=>{
-    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
-})();
-(()=>{
-    __webpack_require__.r = (exports1)=>{
-        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
-            value: 'Module'
-        });
-        Object.defineProperty(exports1, '__esModule', {
-            value: true
-        });
-    };
-})();
-var __webpack_exports__ = {};
-__webpack_require__.r(__webpack_exports__);
-const encoder = new TextEncoder();
-const closingTagsPattern = /<\/body>\s*<\/html>\s*$/i;
-const closingTagsPrefixPattern = /(?:<\/body>\s*(?:<\/html>\s*|<\/h(?:t(?:m(?:l>?)?)?)?|<\/?|<)?|<\/b(?:o(?:d(?:y>?)?)?)?|<\/?|<[^>]*)$/i;
-const RSC_HTML_CLOSING_TAIL_LIMIT = 8192;
-function injectRSCPayload(rscStream, { injectClosingTags = true } = {}) {
-    const decoder = new TextDecoder();
-    let retainedTail = '';
-    let committedClosingBody = false;
-    let committedHtmlClose = false;
-    let committedProbe = '';
-    let flightPromise;
-    const startFlight = (controller)=>{
-        if (!flightPromise) {
-            flightPromise = writeRSCStream(rscStream, controller);
-            flightPromise.catch((error)=>controller.error(error));
-        }
-        return flightPromise;
-    };
-    const enqueueHtml = (value, controller)=>{
-        if (value) controller.enqueue(encoder.encode(value));
-    };
-    const processHtml = async (value, controller)=>{
-        if (!value) return;
-        if (committedClosingBody) {
-            const probe = committedProbe + value;
-            committedHtmlClose ||= /<\/html>/i.test(probe);
-            committedProbe = probe.slice(-6);
-            enqueueHtml(value, controller);
-            return;
-        }
-        const html = retainedTail + value;
-        retainedTail = '';
-        const suffix = html.match(closingTagsPrefixPattern)?.[0] ?? '';
-        const prefix = suffix ? html.slice(0, -suffix.length) : html;
-        enqueueHtml(prefix, controller);
-        if (!suffix) return void startFlight(controller);
-        if (suffix.length <= RSC_HTML_CLOSING_TAIL_LIMIT) {
-            retainedTail = suffix;
-            return;
-        }
-        await startFlight(controller);
-        if (/<\/body>/i.test(suffix)) {
-            committedClosingBody = true;
-            committedHtmlClose = /<\/html>/i.test(suffix);
-            committedProbe = suffix.slice(-6);
-        }
-        enqueueHtml(suffix, controller);
-    };
-    return new TransformStream({
-        async transform (chunk, controller) {
-            await processHtml(decoder.decode(chunk, {
-                stream: true
-            }), controller);
-        },
-        async flush (controller) {
-            await processHtml(decoder.decode(), controller);
-            await startFlight(controller);
-            const retainedClosingTags = closingTagsPattern.test(retainedTail);
-            enqueueHtml(retainedTail, controller);
-            if (!injectClosingTags) return;
-            if (committedClosingBody) {
-                if (!committedHtmlClose) enqueueHtml('</html>', controller);
-            } else if (!retainedClosingTags) enqueueHtml('</body></html>', controller);
-        }
-    });
-}
-async function writeRSCStream(rscStream, controller) {
-    const decoder = new TextDecoder('utf-8', {
-        fatal: true
-    });
-    for await (const chunk of rscStream)try {
-        writeChunk(JSON.stringify(decoder.decode(chunk, {
-            stream: true
-        })), controller);
-    } catch  {
-        const base64 = JSON.stringify(btoa(String.fromCodePoint(...chunk)));
-        writeChunk(`Uint8Array.from(atob(${base64}), m => m.codePointAt(0))`, controller);
-    }
-    const remaining = decoder.decode();
-    if (remaining) writeChunk(JSON.stringify(remaining), controller);
-}
-function writeChunk(chunk, controller) {
-    const script = `(self.__FLIGHT_DATA||=[]).push(${chunk})`;
-    controller.enqueue(encoder.encode(`<script>${script.replace(/<!--/g, '<\\!--').replace(/<\/(script)/gi, '</\\$1')}</script>`));
-}
-__webpack_require__.d(__webpack_exports__, {
-    injectRSCPayload: ()=>injectRSCPayload
-}, {
-    RSC_HTML_CLOSING_TAIL_LIMIT: RSC_HTML_CLOSING_TAIL_LIMIT
-});
-exports.RSC_HTML_CLOSING_TAIL_LIMIT = __webpack_exports__.RSC_HTML_CLOSING_TAIL_LIMIT;
-exports.injectRSCPayload = __webpack_exports__.injectRSCPayload;
-for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "RSC_HTML_CLOSING_TAIL_LIMIT",
-    "injectRSCPayload"
-].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
-Object.defineProperty(exports, '__esModule', {
-    value: true
-});

package/dist/esm/rscHtmlStream.mjs

@@ -1,86 +0,0 @@
-const encoder = new TextEncoder();
-const closingTagsPattern = /<\/body>\s*<\/html>\s*$/i;
-const closingTagsPrefixPattern = /(?:<\/body>\s*(?:<\/html>\s*|<\/h(?:t(?:m(?:l>?)?)?)?|<\/?|<)?|<\/b(?:o(?:d(?:y>?)?)?)?|<\/?|<[^>]*)$/i;
-const RSC_HTML_CLOSING_TAIL_LIMIT = 8192;
-function injectRSCPayload(rscStream, { injectClosingTags = true } = {}) {
-    const decoder = new TextDecoder();
-    let retainedTail = '';
-    let committedClosingBody = false;
-    let committedHtmlClose = false;
-    let committedProbe = '';
-    let flightPromise;
-    const startFlight = (controller)=>{
-        if (!flightPromise) {
-            flightPromise = writeRSCStream(rscStream, controller);
-            flightPromise.catch((error)=>controller.error(error));
-        }
-        return flightPromise;
-    };
-    const enqueueHtml = (value, controller)=>{
-        if (value) controller.enqueue(encoder.encode(value));
-    };
-    const processHtml = async (value, controller)=>{
-        if (!value) return;
-        if (committedClosingBody) {
-            const probe = committedProbe + value;
-            committedHtmlClose ||= /<\/html>/i.test(probe);
-            committedProbe = probe.slice(-6);
-            enqueueHtml(value, controller);
-            return;
-        }
-        const html = retainedTail + value;
-        retainedTail = '';
-        const suffix = html.match(closingTagsPrefixPattern)?.[0] ?? '';
-        const prefix = suffix ? html.slice(0, -suffix.length) : html;
-        enqueueHtml(prefix, controller);
-        if (!suffix) return void startFlight(controller);
-        if (suffix.length <= RSC_HTML_CLOSING_TAIL_LIMIT) {
-            retainedTail = suffix;
-            return;
-        }
-        await startFlight(controller);
-        if (/<\/body>/i.test(suffix)) {
-            committedClosingBody = true;
-            committedHtmlClose = /<\/html>/i.test(suffix);
-            committedProbe = suffix.slice(-6);
-        }
-        enqueueHtml(suffix, controller);
-    };
-    return new TransformStream({
-        async transform (chunk, controller) {
-            await processHtml(decoder.decode(chunk, {
-                stream: true
-            }), controller);
-        },
-        async flush (controller) {
-            await processHtml(decoder.decode(), controller);
-            await startFlight(controller);
-            const retainedClosingTags = closingTagsPattern.test(retainedTail);
-            enqueueHtml(retainedTail, controller);
-            if (!injectClosingTags) return;
-            if (committedClosingBody) {
-                if (!committedHtmlClose) enqueueHtml('</html>', controller);
-            } else if (!retainedClosingTags) enqueueHtml('</body></html>', controller);
-        }
-    });
-}
-async function writeRSCStream(rscStream, controller) {
-    const decoder = new TextDecoder('utf-8', {
-        fatal: true
-    });
-    for await (const chunk of rscStream)try {
-        writeChunk(JSON.stringify(decoder.decode(chunk, {
-            stream: true
-        })), controller);
-    } catch  {
-        const base64 = JSON.stringify(btoa(String.fromCodePoint(...chunk)));
-        writeChunk(`Uint8Array.from(atob(${base64}), m => m.codePointAt(0))`, controller);
-    }
-    const remaining = decoder.decode();
-    if (remaining) writeChunk(JSON.stringify(remaining), controller);
-}
-function writeChunk(chunk, controller) {
-    const script = `(self.__FLIGHT_DATA||=[]).push(${chunk})`;
-    controller.enqueue(encoder.encode(`<script>${script.replace(/<!--/g, '<\\!--').replace(/<\/(script)/gi, '</\\$1')}</script>`));
-}
-export { RSC_HTML_CLOSING_TAIL_LIMIT, injectRSCPayload };

package/dist/esm-node/rscHtmlStream.mjs

@@ -1,87 +0,0 @@
-import "node:module";
-const encoder = new TextEncoder();
-const closingTagsPattern = /<\/body>\s*<\/html>\s*$/i;
-const closingTagsPrefixPattern = /(?:<\/body>\s*(?:<\/html>\s*|<\/h(?:t(?:m(?:l>?)?)?)?|<\/?|<)?|<\/b(?:o(?:d(?:y>?)?)?)?|<\/?|<[^>]*)$/i;
-const RSC_HTML_CLOSING_TAIL_LIMIT = 8192;
-function injectRSCPayload(rscStream, { injectClosingTags = true } = {}) {
-    const decoder = new TextDecoder();
-    let retainedTail = '';
-    let committedClosingBody = false;
-    let committedHtmlClose = false;
-    let committedProbe = '';
-    let flightPromise;
-    const startFlight = (controller)=>{
-        if (!flightPromise) {
-            flightPromise = writeRSCStream(rscStream, controller);
-            flightPromise.catch((error)=>controller.error(error));
-        }
-        return flightPromise;
-    };
-    const enqueueHtml = (value, controller)=>{
-        if (value) controller.enqueue(encoder.encode(value));
-    };
-    const processHtml = async (value, controller)=>{
-        if (!value) return;
-        if (committedClosingBody) {
-            const probe = committedProbe + value;
-            committedHtmlClose ||= /<\/html>/i.test(probe);
-            committedProbe = probe.slice(-6);
-            enqueueHtml(value, controller);
-            return;
-        }
-        const html = retainedTail + value;
-        retainedTail = '';
-        const suffix = html.match(closingTagsPrefixPattern)?.[0] ?? '';
-        const prefix = suffix ? html.slice(0, -suffix.length) : html;
-        enqueueHtml(prefix, controller);
-        if (!suffix) return void startFlight(controller);
-        if (suffix.length <= RSC_HTML_CLOSING_TAIL_LIMIT) {
-            retainedTail = suffix;
-            return;
-        }
-        await startFlight(controller);
-        if (/<\/body>/i.test(suffix)) {
-            committedClosingBody = true;
-            committedHtmlClose = /<\/html>/i.test(suffix);
-            committedProbe = suffix.slice(-6);
-        }
-        enqueueHtml(suffix, controller);
-    };
-    return new TransformStream({
-        async transform (chunk, controller) {
-            await processHtml(decoder.decode(chunk, {
-                stream: true
-            }), controller);
-        },
-        async flush (controller) {
-            await processHtml(decoder.decode(), controller);
-            await startFlight(controller);
-            const retainedClosingTags = closingTagsPattern.test(retainedTail);
-            enqueueHtml(retainedTail, controller);
-            if (!injectClosingTags) return;
-            if (committedClosingBody) {
-                if (!committedHtmlClose) enqueueHtml('</html>', controller);
-            } else if (!retainedClosingTags) enqueueHtml('</body></html>', controller);
-        }
-    });
-}
-async function writeRSCStream(rscStream, controller) {
-    const decoder = new TextDecoder('utf-8', {
-        fatal: true
-    });
-    for await (const chunk of rscStream)try {
-        writeChunk(JSON.stringify(decoder.decode(chunk, {
-            stream: true
-        })), controller);
-    } catch  {
-        const base64 = JSON.stringify(btoa(String.fromCodePoint(...chunk)));
-        writeChunk(`Uint8Array.from(atob(${base64}), m => m.codePointAt(0))`, controller);
-    }
-    const remaining = decoder.decode();
-    if (remaining) writeChunk(JSON.stringify(remaining), controller);
-}
-function writeChunk(chunk, controller) {
-    const script = `(self.__FLIGHT_DATA||=[]).push(${chunk})`;
-    controller.enqueue(encoder.encode(`<script>${script.replace(/<!--/g, '<\\!--').replace(/<\/(script)/gi, '</\\$1')}</script>`));
-}
-export { RSC_HTML_CLOSING_TAIL_LIMIT, injectRSCPayload };

package/dist/types/rscHtmlStream.d.ts

@@ -1,4 +0,0 @@
-export declare const RSC_HTML_CLOSING_TAIL_LIMIT: number;
-export declare function injectRSCPayload(rscStream: ReadableStream<Uint8Array>, { injectClosingTags }?: {
-    injectClosingTags?: boolean;
-}): TransformStream<Uint8Array, Uint8Array>;

package/src/rscHtmlStream.ts

@@ -1,142 +0,0 @@
-/**
- * Forked and modified from https://github.com/devongovett/rsc-html-stream.
- * License: https://github.com/devongovett/rsc-html-stream/blob/main/LICENSE
- */
-const encoder = new TextEncoder();
-const closingTagsPattern = /<\/body>\s*<\/html>\s*$/i;
-const closingTagsPrefixPattern =
-  /(?:<\/body>\s*(?:<\/html>\s*|<\/h(?:t(?:m(?:l>?)?)?)?|<\/?|<)?|<\/b(?:o(?:d(?:y>?)?)?)?|<\/?|<[^>]*)$/i;
-
-export const RSC_HTML_CLOSING_TAIL_LIMIT = 8 * 1024;
-
-export function injectRSCPayload(
-  rscStream: ReadableStream<Uint8Array>,
-  { injectClosingTags = true }: { injectClosingTags?: boolean } = {},
-): TransformStream<Uint8Array, Uint8Array> {
-  const decoder = new TextDecoder();
-  let retainedTail = '';
-  let committedClosingBody = false;
-  let committedHtmlClose = false;
-  let committedProbe = '';
-  let flightPromise: Promise<void> | undefined;
-
-  const startFlight = (
-    controller: TransformStreamDefaultController<Uint8Array>,
-  ) => {
-    if (!flightPromise) {
-      flightPromise = writeRSCStream(rscStream, controller);
-      void flightPromise.catch(error => controller.error(error));
-    }
-    return flightPromise;
-  };
-
-  const enqueueHtml = (
-    value: string,
-    controller: TransformStreamDefaultController<Uint8Array>,
-  ) => {
-    if (value) {
-      controller.enqueue(encoder.encode(value));
-    }
-  };
-
-  const processHtml = async (
-    value: string,
-    controller: TransformStreamDefaultController<Uint8Array>,
-  ) => {
-    if (!value) {
-      return;
-    }
-
-    if (committedClosingBody) {
-      const probe = committedProbe + value;
-      committedHtmlClose ||= /<\/html>/i.test(probe);
-      committedProbe = probe.slice(-6);
-      enqueueHtml(value, controller);
-      return;
-    }
-
-    const html = retainedTail + value;
-    retainedTail = '';
-    const suffix = html.match(closingTagsPrefixPattern)?.[0] ?? '';
-    const prefix = suffix ? html.slice(0, -suffix.length) : html;
-    enqueueHtml(prefix, controller);
-
-    if (!suffix) {
-      void startFlight(controller);
-      return;
-    }
-    if (suffix.length <= RSC_HTML_CLOSING_TAIL_LIMIT) {
-      retainedTail = suffix;
-      return;
-    }
-
-    await startFlight(controller);
-    if (/<\/body>/i.test(suffix)) {
-      committedClosingBody = true;
-      committedHtmlClose = /<\/html>/i.test(suffix);
-      committedProbe = suffix.slice(-6);
-    }
-    enqueueHtml(suffix, controller);
-  };
-
-  return new TransformStream({
-    async transform(chunk, controller) {
-      await processHtml(decoder.decode(chunk, { stream: true }), controller);
-    },
-    async flush(controller) {
-      await processHtml(decoder.decode(), controller);
-      await startFlight(controller);
-
-      const retainedClosingTags = closingTagsPattern.test(retainedTail);
-      enqueueHtml(retainedTail, controller);
-      if (!injectClosingTags) {
-        return;
-      }
-      if (committedClosingBody) {
-        if (!committedHtmlClose) {
-          enqueueHtml('</html>', controller);
-        }
-      } else if (!retainedClosingTags) {
-        enqueueHtml('</body></html>', controller);
-      }
-    },
-  });
-}
-
-async function writeRSCStream(
-  rscStream: ReadableStream<Uint8Array>,
-  controller: TransformStreamDefaultController<Uint8Array>,
-): Promise<void> {
-  const decoder = new TextDecoder('utf-8', { fatal: true });
-  for await (const chunk of rscStream) {
-    try {
-      writeChunk(
-        JSON.stringify(decoder.decode(chunk, { stream: true })),
-        controller,
-      );
-    } catch {
-      const base64 = JSON.stringify(btoa(String.fromCodePoint(...chunk)));
-      writeChunk(
-        `Uint8Array.from(atob(${base64}), m => m.codePointAt(0))`,
-        controller,
-      );
-    }
-  }
-
-  const remaining = decoder.decode();
-  if (remaining) {
-    writeChunk(JSON.stringify(remaining), controller);
-  }
-}
-
-function writeChunk(
-  chunk: string,
-  controller: TransformStreamDefaultController<Uint8Array>,
-) {
-  const script = `(self.__FLIGHT_DATA||=[]).push(${chunk})`;
-  controller.enqueue(
-    encoder.encode(
-      `<script>${script.replace(/<!--/g, '<\\!--').replace(/<\/(script)/gi, '</\\$1')}</script>`,
-    ),
-  );
-}