npm - @timber-js/app - Versions diffs - 0.2.0-alpha.212 → 0.2.0-alpha.213 - Mend

@timber-js/app 0.2.0-alpha.212 → 0.2.0-alpha.213

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 (92) hide show

package/dist/_chunks/{actions-CCdnVtWm.js → actions-CEootpB1.js} +42 -7
package/dist/_chunks/{actions-CCdnVtWm.js.map → actions-CEootpB1.js.map} +1 -1
package/dist/_chunks/{error-boundary-DsNScGRM.js → error-boundary-9g_Lb2na.js} +3 -3
package/dist/_chunks/{error-boundary-DsNScGRM.js.map → error-boundary-9g_Lb2na.js.map} +1 -1
package/dist/client/browser-entry/action-dispatch.d.ts.map +1 -1
package/dist/client/browser-entry/action-queue.d.ts +1 -0
package/dist/client/browser-entry/action-queue.d.ts.map +1 -1
package/dist/client/browser-entry/form-state.d.ts +22 -0
package/dist/client/browser-entry/form-state.d.ts.map +1 -0
package/dist/client/browser-entry/hydrate.d.ts +9 -1
package/dist/client/browser-entry/hydrate.d.ts.map +1 -1
package/dist/client/browser-entry/index.d.ts +2 -0
package/dist/client/browser-entry/index.d.ts.map +1 -1
package/dist/client/browser-entry/router-init.d.ts.map +1 -1
package/dist/client/error-boundary.js +1 -1
package/dist/client/index.d.ts +1 -0
package/dist/client/index.d.ts.map +1 -1
package/dist/client/index.js +90 -2
package/dist/client/index.js.map +1 -1
package/dist/client/internal.js +8 -7
package/dist/client/internal.js.map +1 -1
package/dist/client/navigation-transition.d.ts +11 -2
package/dist/client/navigation-transition.d.ts.map +1 -1
package/dist/client/router-effects.d.ts +7 -3
package/dist/client/router-effects.d.ts.map +1 -1
package/dist/client/router-pipeline.d.ts +3 -1
package/dist/client/router-pipeline.d.ts.map +1 -1
package/dist/client/router-types.d.ts +12 -1
package/dist/client/router-types.d.ts.map +1 -1
package/dist/client/router.d.ts.map +1 -1
package/dist/client/use-form-field.d.ts +39 -0
package/dist/client/use-form-field.d.ts.map +1 -0
package/dist/config-types.d.ts +2 -1
package/dist/config-types.d.ts.map +1 -1
package/dist/index.js.map +1 -1
package/dist/server/action-client.d.ts +11 -2
package/dist/server/action-client.d.ts.map +1 -1
package/dist/server/flight-scripts.d.ts +9 -0
package/dist/server/flight-scripts.d.ts.map +1 -1
package/dist/server/form-data.d.ts +13 -4
package/dist/server/form-data.d.ts.map +1 -1
package/dist/server/form-state-flight.d.ts +32 -0
package/dist/server/form-state-flight.d.ts.map +1 -0
package/dist/server/index.js +37 -23
package/dist/server/index.js.map +1 -1
package/dist/server/internal.js +1 -1
package/dist/server/rsc-entry/action-dispatcher.d.ts.map +1 -1
package/dist/server/rsc-entry/index.d.ts.map +1 -1
package/dist/server/rsc-entry/render-route.d.ts +2 -0
package/dist/server/rsc-entry/render-route.d.ts.map +1 -1
package/dist/server/rsc-entry/ssr-renderer.d.ts +6 -0
package/dist/server/rsc-entry/ssr-renderer.d.ts.map +1 -1
package/dist/server/ssr-bridge-types.d.ts +7 -5
package/dist/server/ssr-bridge-types.d.ts.map +1 -1
package/dist/server/ssr-entry.d.ts.map +1 -1
package/dist/server/ssr-form-state.d.ts +30 -0
package/dist/server/ssr-form-state.d.ts.map +1 -0
package/dist/shared/form-state-flight.d.ts +36 -0
package/dist/shared/form-state-flight.d.ts.map +1 -0
package/docs/api/31-api-client.mdx +22 -0
package/docs/api/34-api-config.mdx +1 -1
package/docs/learn/08-forms-and-actions.mdx +109 -22
package/package.json +1 -1
package/src/client/browser-entry/action-dispatch.ts +34 -10
package/src/client/browser-entry/action-queue.ts +1 -1
package/src/client/browser-entry/form-state.ts +48 -0
package/src/client/browser-entry/hydrate.ts +9 -18
package/src/client/browser-entry/index.ts +25 -7
package/src/client/browser-entry/router-init.ts +3 -2
package/src/client/index.ts +1 -0
package/src/client/navigation-transition.ts +13 -2
package/src/client/router-effects.ts +8 -4
package/src/client/router-pipeline.ts +7 -3
package/src/client/router-types.ts +12 -1
package/src/client/router.ts +16 -3
package/src/client/use-form-field.ts +132 -0
package/src/config-types.ts +2 -1
package/src/server/action-client.ts +68 -53
package/src/server/flight-scripts.ts +13 -0
package/src/server/form-data.ts +62 -10
package/src/server/form-state-flight.ts +67 -0
package/src/server/rsc-entry/action-dispatcher.ts +3 -0
package/src/server/rsc-entry/index.ts +1 -0
package/src/server/rsc-entry/render-route.ts +16 -0
package/src/server/rsc-entry/ssr-renderer.ts +12 -14
package/src/server/ssr-bridge-types.ts +7 -6
package/src/server/ssr-entry.ts +16 -3
package/src/server/ssr-form-state.ts +58 -0
package/src/shared/form-state-flight.ts +74 -0
package/dist/server/form-state-embed.d.ts +0 -32
package/dist/server/form-state-embed.d.ts.map +0 -1
package/src/server/form-state-embed.ts +0 -63

package/src/server/rsc-entry/render-route.ts CHANGED Viewed

@@ -38,6 +38,8 @@ import type { DenyFallbackRenderer } from './deny-fallback.ts';
 import { isRscRequest } from '../../shared/rsc-media-type.ts';
 import { buildRscPayloadResponse } from './rsc-payload.ts';
 import { renderRscStream } from './rsc-stream.ts';
+import { encodeFormState } from '../form-state-flight.ts';
+import { getFormStateForSsr } from '../request-context.ts';
 import { renderSsrResponse } from './ssr-renderer.ts';
 /**
@@ -51,6 +53,8 @@ export interface RenderRouteDeps {
   clientSegmentCache: boolean;
   renderDenyFallback: DenyFallbackRenderer;
   buildManifest: BuildManifest;
+  /** The resolved `renderTimeoutMs`: bounds encoding a no-JS form state. */
+  renderTimeoutMs: number;
   globalError?: { load: () => Promise<unknown>; filePath: string };
 }
@@ -210,6 +214,17 @@ export async function renderRoute(
     );
   }
+  // The form state of the no-JS action this page answers, if any, as the
+  // Flight bytes both SSR and the browser decode (design/08 §"No-JS Result
+  // Round-Trip"). Encoded while the RSC render above is already running,
+  // under the render timeout and the request's abort signal. A promise in
+  // the result holds the response until it settles: the page must carry the
+  // whole state, as Fizz would wait for it anyway.
+  const pendingFormState = getFormStateForSsr();
+  const formState = pendingFormState
+    ? await encodeFormState(pendingFormState, deps.renderTimeoutMs, req.signal)
+    : null;
   // Pipe through SSR for HTML rendering with streaming Suspense support.
   return renderSsrResponse({
     req,
@@ -225,5 +240,6 @@ export async function renderRoute(
     deferSuspenseFor,
     globalError,
     slotSkipInfo,
+    formState,
   });
 }

package/src/server/rsc-entry/ssr-renderer.ts CHANGED Viewed

@@ -28,8 +28,6 @@ import type { NavContext, SsrRenderResult } from '../ssr-bridge-types.ts';
 import { htmlEscapeJsonString } from '../flight-scripts.ts';
 import { buildSegmentInfo, isAbortError } from './helpers.ts';
 import { getCookiesForSsr } from '../cookie-context.ts';
-import { getFormStateForSsr } from '../request-context.ts';
-import { formStateForRender } from '../form-state-embed.ts';
 import { getDenyStatus, getFirstDeniedSegmentIndex } from '../deny-boundary.ts';
 import { renderErrorPage, type GlobalErrorFile } from './error-renderer.ts';
 import { callSsr } from './ssr-bridge.ts';
@@ -103,6 +101,12 @@ interface SsrRenderOptions {
   /** Tier 2 global-error.tsx file, if present in app/. */
   globalError?: GlobalErrorFile;
   slotSkipInfo?: SlotSkipEntry[];
+  /**
+   * The Flight bytes of the no-JS action's form state this page answers
+   * (`encodeFormState`); absent on every other render. Fizz and hydrateRoot
+   * both decode them.
+   */
+  formState?: Uint8Array | null;
 }
 /**
@@ -142,6 +146,7 @@ export async function renderSsrResponse(opts: SsrRenderOptions): Promise<Respons
     headHtml,
     deferSuspenseFor,
     globalError,
+    formState,
   } = opts;
   // Tee the RSC stream — one copy goes to SSR for HTML rendering,
@@ -172,15 +177,6 @@ export async function renderSsrResponse(opts: SsrRenderOptions): Promise<Respons
   // that is the value every inline script must wear.
   const nonce = getCspNonce();
-  // Only a page answering a no-JS action has one (design/08 §"No-JS Result
-  // Round-Trip"). Fizz gives it to the hook that submitted; the browser
-  // needs the same value for hydrateRoot, or hydration resets that hook.
-  const { formState, script: formStateScript } = formStateForRender(
-    getFormStateForSsr(),
-    clientJsDisabled,
-    nonce
-  );
   const reqUrl = new URL(req.url);
   const navContext: NavContext = {
     pathname: reqUrl.pathname,
@@ -192,8 +188,7 @@ export async function renderSsrResponse(opts: SsrRenderOptions): Promise<Respons
       clientBootstrap.preloadLinks +
       // Initialize __timber_f in <head> so it exists before any streaming
       // chunk scripts arrive in <body>. See flight-scripts.ts, LOCAL-415.
-      (clientJsDisabled ? '' : flightInitScript(nonce)) +
-      formStateScript,
+      (clientJsDisabled ? '' : flightInitScript(nonce)),
     getHeadSegmentScript: clientJsDisabled
       ? undefined
       : () =>
@@ -205,7 +200,10 @@ export async function renderSsrResponse(opts: SsrRenderOptions): Promise<Respons
     deferSuspenseFor: deferSuspenseFor > 0 ? deferSuspenseFor : undefined,
     signal: req.signal,
     cookies: getCookiesForSsr(),
-    formState,
+    // Only a page answering a no-JS action has form state (design/08
+    // §"No-JS Result Round-Trip"). SSR decodes it for Fizz and embeds it
+    // for hydrateRoot (server/ssr-form-state.ts).
+    formState: formState ?? undefined,
     // Stops the Flight injector writing <script> tags once an unhandled RSC
     // error is captured. Without this, React's Flight encoder may write model
     // data for a chunk that already received an error row, causing the

package/src/server/ssr-bridge-types.ts CHANGED Viewed

@@ -50,8 +50,6 @@
  * and `CLAUDE.md` §"RSC and SSR Are Separate Vite Environments".
  */
-import type { ReactFormState } from 'react-dom/client';
 /**
  * Navigation context passed from the RSC environment to SSR.
  *
@@ -107,11 +105,14 @@ export interface NavContext {
   cookies?: Map<string, string>;
   /**
    * The form state of the no-JS action this page answers (React's
-   * `decodeFormState`), passed to Fizz so the `useActionState` hook that
-   * submitted renders with the action's result. Absent on every other
-   * render. See design/08-forms-and-actions.md §"No-JS Result Round-Trip".
+   * `decodeFormState`), as Flight bytes. SSR decodes them for Fizz and,
+   * once they decoded, embeds the same bytes for hydration
+   * (server/ssr-form-state.ts), so the `useActionState` hook that submitted
+   * renders with the value the browser hydrates with. Absent
+   * on every other render. See design/08-forms-and-actions.md §"No-JS Result
+   * Round-Trip".
    */
-  formState?: ReactFormState;
+  formState?: Uint8Array;
   /**
    * Lazy thunk that produces the `<script>self.__timber_segments=…</script>`
    * tag. Invoked by the SSR entry AFTER `renderSsrNodeStream` /

package/src/server/ssr-entry.ts CHANGED Viewed

@@ -41,6 +41,8 @@ import { wrapSsrElement } from './ssr-wrappers.tsx';
 import { withSpan } from './tracing.ts';
 import { registerSsrDataProvider, type SsrData } from '../client/ssr-data.ts';
 import { splitPayloadRoot } from '../shared/payload-root.ts';
+import { formStateForSsr } from './ssr-form-state.ts';
+import { resolveRenderTimeoutMs } from './render-timeout.ts';
 import type { NavContext, SsrRenderResult } from './ssr-bridge-types.ts';
 // Pre-import Node.js stream modules at module load time — not per-request.
@@ -194,11 +196,20 @@ export async function handleSsr(
       // promise resolves, so the flag is settled once the render is awaited.
       const renderTimeoutMs = _runtimeConfig.renderTimeoutMs ?? undefined;
       const requestInfo = { method: 'GET', path: navContext.pathname };
+      // The no-JS action's form state, for Fizz and, only once it decoded,
+      // embedded for the browser to hydrate with (design/08 §"No-JS Result
+      // Round-Trip"). A page whose payload is inlined hydrates.
+      const { formState, script: formStateHead } = await formStateForSsr(navContext.formState, {
+        hydrates: navContext.rscStream !== undefined,
+        nonce,
+        decode: (stream) => createFromReadableStream(stream, { nonce }),
+        timeoutMs: resolveRenderTimeoutMs(renderTimeoutMs),
+      });
       let fizzAllReadyResolved = false;
       const renderOptions: SsrStreamOptions = {
         bootstrapScriptContent: navContext.bootstrapScriptContent || undefined,
         nonce,
-        formState: navContext.formState,
+        formState,
         deferSuspenseFor: navContext.deferSuspenseFor,
         signal: navContext.signal,
         renderTimeoutMs,
@@ -251,7 +262,8 @@ export async function handleSsr(
         // and close cleanly (TIM-1019).
         // Resolve the lazy segment script now that the shell is ready
         // (AccessGates have settled, ALS deny index is authoritative).
-        const resolvedHeadHtml = navContext.headHtml + (navContext.getHeadSegmentScript?.() ?? '');
+        const resolvedHeadHtml =
+          navContext.headHtml + formStateHead + (navContext.getHeadSegmentScript?.() ?? '');
         const output = runNodePipelineWithErrorHandling(
           nodeHtmlStream,
           [
@@ -281,7 +293,8 @@ export async function handleSsr(
         // structure (TIM-527).
         // Resolve the lazy segment script now that the shell is ready
         // (AccessGates have settled, ALS deny index is authoritative).
-        const resolvedHeadHtml = navContext.headHtml + (navContext.getHeadSegmentScript?.() ?? '');
+        const resolvedHeadHtml =
+          navContext.headHtml + formStateHead + (navContext.getHeadSegmentScript?.() ?? '');
         outputStream = htmlStream.pipeThrough(createBufferedTransformStream());
         outputStream = injectHead(outputStream, resolvedHeadHtml);
         outputStream = injectRscPayload(outputStream, navContext.rscStream, {

package/src/server/ssr-form-state.ts ADDED Viewed

@@ -0,0 +1,58 @@
+/**
+ * The no-JS action form state on the SSR side (TIM-1572, design/08
+ * §"No-JS Result Round-Trip").
+ *
+ * SSR is the one owner of both consumers of the Flight bytes the RSC
+ * environment encoded (`NavContext.formState`): it decodes them for Fizz,
+ * and emits the script that embeds the same bytes for `hydrateRoot` only
+ * when that decode succeeded. A browser must never hydrate with a state Fizz
+ * did not render, or the hook that submitted changes state during
+ * hydration. If SSR cannot decode them, neither side gets them.
+ */
+import type { ReactFormState } from 'react-dom/client';
+import { decodeFormState, type FormStateFlightDecoder } from '../shared/form-state-flight.ts';
+import { formStateScript } from './flight-scripts.ts';
+import { swallow } from './logger.ts';
+export interface SsrFormState {
+  /** For Fizz's `formState` option. */
+  formState: ReactFormState | undefined;
+  /** The `<script>` that embeds the same bytes for hydration, or `''`. */
+  script: string;
+}
+const NONE: SsrFormState = { formState: undefined, script: '' };
+export async function formStateForSsr(
+  bytes: Uint8Array | undefined,
+  options: {
+    /**
+     * Whether the page hydrates: its RSC payload is inlined. Without it the
+     * browser never calls `hydrateRoot`, so nothing is embedded.
+     */
+    hydrates: boolean;
+    nonce: string | undefined;
+    decode: FormStateFlightDecoder;
+    timeoutMs: number;
+  }
+): Promise<SsrFormState> {
+  if (!bytes) return NONE;
+  let formState: ReactFormState;
+  try {
+    formState = await decodeFormState(bytes, options.decode, options.timeoutMs);
+  } catch (error) {
+    swallow(
+      error,
+      "a no-JS action's form state did not decode for SSR, so the page renders without it",
+      {
+        level: 'warn',
+      }
+    );
+    return NONE;
+  }
+  return {
+    formState,
+    script: options.hydrates ? formStateScript(bytes, options.nonce) : '',
+  };
+}

package/src/shared/form-state-flight.ts ADDED Viewed

@@ -0,0 +1,74 @@
+/**
+ * The no-JS action form state on its way to the two renders that need it
+ * (TIM-1572, design/08-forms-and-actions.md §"No-JS Result Round-Trip").
+ *
+ * The RSC environment serializes the form state with Flight
+ * (server/form-state-flight.ts). SSR decodes those bytes for Fizz, and the
+ * browser decodes the same bytes, embedded in the page, for `hydrateRoot`.
+ * Both sides call `decodeFormState` below with their own environment's
+ * Flight client, so the two renders get the same value, and the value a
+ * `useActionState` result has with JS (Flight, through the action response):
+ * a `Date` stays a `Date`, a `Map` a `Map`, and an `undefined` field is
+ * absent on both, because the Flight client drops it.
+ *
+ * The page carries the bytes as base64: Flight may write binary rows (a typed
+ * array in a result), which a text chunk would corrupt, and base64 has no
+ * character that can end a `<script>` element.
+ */
+import type { ReactFormState } from 'react-dom/client';
+/**
+ * A Flight client's `createFromReadableStream`, SSR's or the browser's, typed
+ * to the form state tuple it decodes. React builds `ReactFormState`
+ * (`decodeFormState` on the server) and only React reads it; the Flight
+ * client's type parameter is the only place that type is asserted.
+ */
+export type FormStateFlightDecoder = (
+  stream: ReadableStream<Uint8Array>
+) => PromiseLike<ReactFormState>;
+/**
+ * Decode the form state's Flight bytes. Rejects if they do not decode within
+ * `timeoutMs`. Every byte is in hand, so only a Flight client bug could
+ * stall it, and the caller falls back to rendering without form state.
+ */
+export async function decodeFormState(
+  bytes: Uint8Array,
+  decode: FormStateFlightDecoder,
+  timeoutMs: number
+): Promise<ReactFormState> {
+  const stream = new ReadableStream<Uint8Array>({
+    start(controller) {
+      controller.enqueue(bytes);
+      controller.close();
+    },
+  });
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  const timeout = new Promise<never>((_, reject) => {
+    timer = setTimeout(
+      () => reject(new Error(`form state did not decode within ${timeoutMs}ms`)),
+      timeoutMs
+    );
+  });
+  try {
+    return await Promise.race([decode(stream), timeout]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+/** The form state's Flight bytes as the base64 the page embeds. */
+export function formStateToBase64(bytes: Uint8Array): string {
+  let binary = '';
+  for (const byte of bytes) binary += String.fromCharCode(byte);
+  return btoa(binary);
+}
+/** The embedded base64 back to the Flight bytes. */
+export function formStateFromBase64(text: string): Uint8Array {
+  const binary = atob(text);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+  return bytes;
+}

package/dist/server/form-state-embed.d.ts DELETED Viewed

@@ -1,32 +0,0 @@
-/**
- * The no-JS action form state a page render hands React (TIM-1570).
- *
- * Fizz renders the `useActionState` hook that submitted with the action's
- * result, and the browser must hydrate with the same value, or the hook
- * resets. The browser's copy is embedded as JSON, as Next.js embeds it
- * (`self.__timber_form_state`, read by client/browser-entry/hydrate.ts).
- *
- * Both renders must get the same value, or the hook's state changes during
- * hydration. JSON is lossy (a `Date` becomes a string, a `Map` `{}`, an
- * `undefined` field — `{ data: undefined }` from every void action — is
- * dropped), so Fizz gets the JSON round-trip of the state, not the original:
- * exactly what the browser decodes. On the no-JS path a result is what JSON
- * carries. A state JSON cannot encode at all (a `BigInt`, a cycle) must not
- * turn the page into a 500 after the action's mutation committed, so it is
- * dropped from both renders: the page renders with no result, as for a form
- * without `useActionState`.
- *
- * With client JS disabled nothing is embedded and nothing hydrates, so Fizz
- * gets the original.
- *
- * See design/08-forms-and-actions.md §"No-JS Result Round-Trip".
- */
-import type { ReactFormState } from 'react-dom/client';
-export interface FormStateForRender {
-    /** For Fizz — the same value the embedded script hands `hydrateRoot`. */
-    formState: ReactFormState | undefined;
-    /** The `<script>` that embeds it for hydration, or `''`. */
-    script: string;
-}
-export declare function formStateForRender(formState: ReactFormState | null, clientJsDisabled: boolean, nonce: string | undefined): FormStateForRender;
-//# sourceMappingURL=form-state-embed.d.ts.map

package/dist/server/form-state-embed.d.ts.map DELETED Viewed

@@ -1 +0,0 @@

- {"version":3,"file":"form-state-embed.d.ts","sourceRoot":"","sources":["../../src/server/form-state-embed.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAKvD,MAAM,WAAW,kBAAkB;IACjC,yEAAyE;IACzE,SAAS,EAAE,cAAc,GAAG,SAAS,CAAC;IACtC,4DAA4D;IAC5D,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,cAAc,GAAG,IAAI,EAChC,gBAAgB,EAAE,OAAO,EACzB,KAAK,EAAE,MAAM,GAAG,SAAS,GACxB,kBAAkB,CAsBpB"}

package/src/server/form-state-embed.ts DELETED Viewed

@@ -1,63 +0,0 @@
-/**
- * The no-JS action form state a page render hands React (TIM-1570).
- *
- * Fizz renders the `useActionState` hook that submitted with the action's
- * result, and the browser must hydrate with the same value, or the hook
- * resets. The browser's copy is embedded as JSON, as Next.js embeds it
- * (`self.__timber_form_state`, read by client/browser-entry/hydrate.ts).
- *
- * Both renders must get the same value, or the hook's state changes during
- * hydration. JSON is lossy (a `Date` becomes a string, a `Map` `{}`, an
- * `undefined` field — `{ data: undefined }` from every void action — is
- * dropped), so Fizz gets the JSON round-trip of the state, not the original:
- * exactly what the browser decodes. On the no-JS path a result is what JSON
- * carries. A state JSON cannot encode at all (a `BigInt`, a cycle) must not
- * turn the page into a 500 after the action's mutation committed, so it is
- * dropped from both renders: the page renders with no result, as for a form
- * without `useActionState`.
- *
- * With client JS disabled nothing is embedded and nothing hydrates, so Fizz
- * gets the original.
- *
- * See design/08-forms-and-actions.md §"No-JS Result Round-Trip".
- */
-import type { ReactFormState } from 'react-dom/client';
-import { htmlEscapeJsonString } from './flight-scripts.ts';
-import { swallow } from './logger.ts';
-import { nonceAttr } from './render-utils.ts';
-export interface FormStateForRender {
-  /** For Fizz — the same value the embedded script hands `hydrateRoot`. */
-  formState: ReactFormState | undefined;
-  /** The `<script>` that embeds it for hydration, or `''`. */
-  script: string;
-}
-export function formStateForRender(
-  formState: ReactFormState | null,
-  clientJsDisabled: boolean,
-  nonce: string | undefined
-): FormStateForRender {
-  if (!formState) return { formState: undefined, script: '' };
-  // No client: nothing hydrates, so nothing is embedded.
-  if (clientJsDisabled) return { formState, script: '' };
-  let json: string;
-  try {
-    json = JSON.stringify(formState);
-  } catch (error) {
-    swallow(
-      error,
-      "a no-JS action's result could not be encoded as JSON for hydration, so the page " +
-        'renders without it; return plain data (no BigInt or cycles) from actions',
-      { level: 'warn' }
-    );
-    return { formState: undefined, script: '' };
-  }
-  return {
-    // `JSON.parse` returns the decoded tuple untyped; it is the same
-    // opaque `ReactFormState` React built, as the browser will decode it.
-    formState: JSON.parse(json),
-    script: `<script${nonceAttr(nonce)}>self.__timber_form_state=${htmlEscapeJsonString(json)}</script>`,
-  };
-}