From ff27c735102df377638ee056d40f303f52942590 Mon Sep 17 00:00:00 2001
From: Kyle June <github@kylejune.com>
Date: Fri, 11 Sep 2026 07:55:46 -0400
Subject: [PATCH 1/6] feat: send hydration data as tagged JSON text

The document's hydration payload is now version 3: loader data travels as
JSON text with values JSON cannot carry written as {"$t": tag, "v": value}
objects, instead of base64 of CBOR. Base64 is a third larger and hides the
page's text from the compressor; a prose page drops from ~2.5x to ~1.4x its
own markup in brotli. Data requests keep CBOR and streaming.

The client still decodes version 2, so documents cached before an upgrade
hydrate with the new bundle.

Refs udibo/udibo#974

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
---
 docs/state-management.md             |  30 ++-
 src/_serialization.test.ts           |  12 +-
 src/_serialization.ts                | 219 ++++++++++++++--
 src/_serialization_hydration.test.ts | 359 +++++++++++++++++++++++++++
 src/_server.tsx                      |   3 +-
 src/_server_hydration.test.tsx       | 170 +++++++++++++
 6 files changed, 764 insertions(+), 29 deletions(-)
 create mode 100644 src/_serialization_hydration.test.ts
 create mode 100644 src/_server_hydration.test.tsx

diff --git a/docs/state-management.md b/docs/state-management.md
index 99cdce2..5866e12 100644
--- a/docs/state-management.md
+++ b/docs/state-management.md
@@ -341,9 +341,33 @@ import "@/serialization/url.ts";
 
 The route can then return a URL instance in loader data. Give each registration
 a unique name and import the module wherever standalone server code needs it.
-Use synchronous serializers that return simple, browser-safe values; do not
-assume nested promises or other custom instances in their output will be
-processed recursively.
+Use synchronous serializers that return plain data: JSON values plus
+`undefined`, `Date`, `bigint`, and non-finite numbers. Do not return promises or
+other instances (`Map`, `Set`, `URL`, class instances) from a serializer; its
+output is not processed recursively, and the first document load reduces such
+instances to their enumerable own properties.
+
+#### How Values Travel
+
+The first document load embeds the page's data in an inline script as JSON text
+(hydration payload version 3). Values JSON cannot express are written as tagged
+objects of the form `{"$t": tag, "v": value}`: `Date`, `undefined`, `NaN`,
+`Infinity`, `-Infinity`, `-0`, `bigint` values outside the safe-number range,
+errors, settled promises, and registered types. A plain object that has its own
+`$t` or `__proto__` key is written in an escaped form, so data can never be
+mistaken for a tag. Every `<`, U+2028, and U+2029 in the payload is written as a
+`\u` escape, so no string in loader data can close the script element or start
+an HTML comment.
+
+Client navigations and fetchers request data as CBOR (`application/cbor`, or
+`application/cbor-stream` when deferred promises are still pending). Both paths
+decode to the same values, including the `bigint` normalization described above,
+so a loader's data has the same types whether it arrived with the document or on
+a later navigation.
+
+A document rendered by an earlier Juniper release carries hydration payload
+version 2 (base64-encoded CBOR). The browser client still decodes it, so a page
+restored from cache after an upgrade hydrates with the new client bundle.
 
 ## React Context
 
diff --git a/src/_serialization.test.ts b/src/_serialization.test.ts
index d4f6a5e..119aaf5 100644
--- a/src/_serialization.test.ts
+++ b/src/_serialization.test.ts
@@ -1,4 +1,10 @@
-import { assert, assertEquals, assertRejects, assertThrows } from "@std/assert";
+import {
+  assert,
+  assertEquals,
+  assertRejects,
+  assertStringIncludes,
+  assertThrows,
+} from "@std/assert";
 import { delay } from "@std/async/delay";
 import { afterEach, beforeEach, describe, it } from "@std/testing/bdd";
 import { HttpError } from "@udibo/http-error";
@@ -331,8 +337,8 @@ describe("Serialization Module", () => {
 
       const serialized = await serializeHydrationData(hydrationData);
 
-      assertEquals(serialized.version, 2);
-      assertEquals(typeof serialized.data, "string");
+      assertEquals(serialized.version, 3);
+      assertStringIncludes(JSON.stringify(serialized.data), '"title":"Home"');
 
       const deserialized = deserializeHydrationData(serialized);
       assertEquals(deserialized.matches, hydrationData.matches);
diff --git a/src/_serialization.ts b/src/_serialization.ts
index c56e026..ead7646 100644
--- a/src/_serialization.ts
+++ b/src/_serialization.ts
@@ -1,9 +1,11 @@
 /**
- * Internal serialization module using cbor2.
+ * Internal serialization module.
  *
- * This module provides internal implementation for serializing/deserializing
- * custom types, errors, and context between server and client.
- * Public interfaces and registration functions are exported from mod.ts.
+ * Data requests travel as CBOR (cbor2). The document's hydration payload
+ * travels as tagged JSON text (version 3) so the page stays readable to the
+ * compressor; version 2 (base64 of CBOR) is still decoded for documents cached
+ * before an upgrade. Public interfaces and registration functions are exported
+ * from mod.ts.
  *
  * @internal
  * @module
@@ -762,7 +764,8 @@ export async function deserializeStreamingLoaderData<T = unknown>(
 }
 
 /**
- * Encode data to a base64 string (for embedding in HTML).
+ * Encode data as base64 of CBOR, the version 2 hydration payload format.
+ * Only tests produce it now; documents rendered before version 3 still carry it.
  *
  * @param data - The data to encode
  * @returns The base64 encoded string
@@ -837,9 +840,143 @@ export function deserializeAllContext(
 }
 
 /**
- * Serialized hydration data structure using CBOR.
+ * A JSON value as it appears in the version 3 hydration payload: plain JSON,
+ * with values JSON cannot carry replaced by `{"$t": tag, "v": value}` objects.
  */
-export interface SerializedHydrationData {
+export type TaggedJson =
+  | null
+  | boolean
+  | number
+  | string
+  | TaggedJson[]
+  | { [key: string]: TaggedJson };
+
+const JSON_TAG_KEY = "$t";
+const JSON_VALUE_KEY = "v";
+
+function tagged(tag: string | number, value?: TaggedJson): TaggedJson {
+  return value === undefined
+    ? { [JSON_TAG_KEY]: tag }
+    : { [JSON_TAG_KEY]: tag, [JSON_VALUE_KEY]: value };
+}
+
+function collapseBigIntLikeCbor(value: bigint): number | bigint {
+  return cborDecode<number | bigint>(cborEncode(value));
+}
+
+function numberToTaggedJson(value: number): TaggedJson {
+  if (Number.isNaN(value)) return tagged("number", "NaN");
+  if (value === Infinity) return tagged("number", "Infinity");
+  if (value === -Infinity) return tagged("number", "-Infinity");
+  if (Object.is(value, -0)) return tagged("number", "-0");
+  return value;
+}
+
+function mustEscapeObjectKeys(keys: string[]): boolean {
+  return keys.includes(JSON_TAG_KEY) || keys.includes("__proto__");
+}
+
+/**
+ * Converts a processed value (the output of `processValue`) into JSON-safe
+ * tagged form. Decodes back through `fromTaggedJson` into exactly what CBOR
+ * decoding of the same value produces, so `restoreValue` treats both alike.
+ *
+ * @throws {TypeError} For functions and symbols, which CBOR also refuses.
+ */
+export function toTaggedJson(value: unknown): TaggedJson {
+  if (value === undefined) return tagged("undefined");
+  if (value === null || typeof value === "boolean") return value;
+  if (typeof value === "string") return value.toWellFormed();
+  if (typeof value === "number") return numberToTaggedJson(value);
+  if (typeof value === "bigint") {
+    const collapsed = collapseBigIntLikeCbor(value);
+    return typeof collapsed === "number"
+      ? collapsed
+      : tagged("bigint", collapsed.toString());
+  }
+  if (typeof value === "function" || typeof value === "symbol") {
+    throw new TypeError(`Cannot serialize a ${typeof value} value`);
+  }
+  if (value instanceof Tag) {
+    return tagged(Number(value.tag), toTaggedJson(value.contents));
+  }
+  if (value instanceof Date) {
+    return tagged("Date", numberToTaggedJson(value.getTime()));
+  }
+  if (Array.isArray(value)) return Array.from(value, toTaggedJson);
+
+  const entries = Object.entries(value as Record<string, unknown>).map((
+    [key, entry],
+  ): [string, TaggedJson] => [key.toWellFormed(), toTaggedJson(entry)]);
+  if (mustEscapeObjectKeys(entries.map(([key]) => key))) {
+    return tagged("object", entries);
+  }
+  return Object.fromEntries(entries);
+}
+
+function objectFromEntries(
+  entries: [string, unknown][],
+): Record<string, unknown> {
+  const result: Record<string, unknown> = {};
+  for (const [key, entry] of entries) {
+    Object.defineProperty(result, key, {
+      value: fromTaggedJson(entry),
+      enumerable: true,
+      writable: true,
+      configurable: true,
+    });
+  }
+  return result;
+}
+
+function fromTag(tag: unknown, value: unknown): unknown {
+  if (typeof tag === "number") return new Tag(tag, fromTaggedJson(value));
+  switch (tag) {
+    case "undefined":
+      return undefined;
+    case "number":
+      return Number(value);
+    case "bigint":
+      return BigInt(value as string);
+    case "Date":
+      return new Date(fromTaggedJson(value) as number);
+    case "object":
+      return objectFromEntries(value as [string, unknown][]);
+  }
+  throw new Error(`Unknown hydration data tag: ${String(tag)}`);
+}
+
+/**
+ * Converts the tagged JSON of a version 3 payload back into the value CBOR
+ * decoding would have produced, ready for `restoreValue`.
+ *
+ * @throws {Error} On a tag this version of Juniper does not know.
+ */
+export function fromTaggedJson(value: unknown): unknown {
+  if (value === null || typeof value !== "object") return value;
+  if (Array.isArray(value)) return value.map(fromTaggedJson);
+  const record = value as Record<string, unknown>;
+  if (Object.hasOwn(record, JSON_TAG_KEY)) {
+    return fromTag(record[JSON_TAG_KEY], record[JSON_VALUE_KEY]);
+  }
+  return objectFromEntries(Object.entries(record));
+}
+
+/**
+ * Serializes a value as JSON text that is safe to place inside an inline
+ * `<script>` element: `<` and the U+2028/U+2029 line terminators are written
+ * as escapes, so no string in the value can close the element, open a comment,
+ * or end a line in an older JavaScript parser.
+ */
+export function toInlineScriptJson(value: unknown): string {
+  return JSON.stringify(value)
+    .replaceAll("<", "\\u003c")
+    .replaceAll("\u2028", "\\u2028")
+    .replaceAll("\u2029", "\\u2029");
+}
+
+/** Version 2 hydration payload: loader data as base64 of CBOR. */
+export interface SerializedHydrationDataV2 {
   /** Version identifier for compatibility checking */
   version: 2;
   /** Base64 encoded CBOR data */
@@ -848,6 +985,25 @@ export interface SerializedHydrationData {
   publicEnv?: Record<string, string>;
 }
 
+/** Version 3 hydration payload: loader data as tagged JSON. */
+export interface SerializedHydrationDataV3 {
+  /** Version identifier for compatibility checking */
+  version: 3;
+  /** Tagged JSON data */
+  data: TaggedJson;
+  /** Public environment variables */
+  publicEnv?: Record<string, string>;
+}
+
+/**
+ * Hydration data as embedded in the document. The server writes version 3;
+ * the client also reads version 2, which documents cached before the upgrade
+ * still carry.
+ */
+export type SerializedHydrationData =
+  | SerializedHydrationDataV2
+  | SerializedHydrationDataV3;
+
 /**
  * Hydration data structure.
  */
@@ -873,17 +1029,15 @@ export interface HydrationData {
 }
 
 /**
- * Serialize hydration data for embedding in HTML.
- *
- * @param hydrationData - The hydration data to serialize
- * @returns The serialized hydration data
+ * Applies server error privacy and resolves promises in hydration data,
+ * producing the value every payload version encodes. Exported so tests can
+ * build a version 2 payload from the same input.
  */
-export async function serializeHydrationData(
+export async function processHydrationData(
   hydrationData: HydrationData,
-): Promise<SerializedHydrationData> {
-  const { publicEnv, errors, ...rest } = hydrationData;
-
-  const processedData = await processValue({
+): Promise<unknown> {
+  const { publicEnv: _publicEnv, errors, ...rest } = hydrationData;
+  return await processValue({
     ...rest,
     errors: errors && Object.fromEntries(
       Object.entries(errors).map((
@@ -891,26 +1045,47 @@ export async function serializeHydrationData(
       ) => [id, sanitizeServerError(error)]),
     ),
   });
+}
 
+/**
+ * Serialize hydration data for embedding in HTML.
+ *
+ * @param hydrationData - The hydration data to serialize
+ * @returns The serialized hydration data
+ */
+export async function serializeHydrationData(
+  hydrationData: HydrationData,
+): Promise<SerializedHydrationDataV3> {
   return {
-    version: 2,
-    data: encodeToBase64(processedData),
-    publicEnv,
+    version: 3,
+    data: toTaggedJson(await processHydrationData(hydrationData)),
+    publicEnv: hydrationData.publicEnv,
   };
 }
 
+function decodeHydrationPayload(
+  serialized: SerializedHydrationData,
+): unknown {
+  if (serialized.version === 3) return fromTaggedJson(serialized.data);
+  if (serialized.version === 2) return decodeFromBase64(serialized.data);
+  throw new Error(
+    `Unsupported hydration data version: ${
+      String((serialized as { version: unknown }).version)
+    }`,
+  );
+}
+
 /**
  * Deserialize hydration data from the serialized format.
  *
  * @param serialized - The serialized hydration data
  * @returns The deserialized hydration data
+ * @throws {Error} If the payload version is neither 2 nor 3.
  */
 export function deserializeHydrationData(
   serialized: SerializedHydrationData,
 ): HydrationData {
-  const decoded = decodeFromBase64<Record<string, unknown>>(serialized.data);
-
-  const restored = restoreValue(decoded) as {
+  const restored = restoreValue(decodeHydrationPayload(serialized)) as {
     serializedContext?: unknown;
     matches: { id: string }[];
     errors?: Record<string, unknown> | null;
diff --git a/src/_serialization_hydration.test.ts b/src/_serialization_hydration.test.ts
new file mode 100644
index 0000000..b11d296
--- /dev/null
+++ b/src/_serialization_hydration.test.ts
@@ -0,0 +1,359 @@
+import {
+  assert,
+  assertEquals,
+  assertFalse,
+  assertInstanceOf,
+  assertRejects,
+  assertStringIncludes,
+  assertThrows,
+} from "@std/assert";
+import { afterEach, beforeEach, describe, it } from "@std/testing/bdd";
+import { HttpError } from "@udibo/http-error";
+
+import { registerError, registerType } from "./mod.ts";
+import {
+  deserializeHydrationData,
+  encodeToBase64,
+  processHydrationData,
+  resetRegistries,
+  type SerializedHydrationData,
+  type SerializedHydrationDataV2,
+  serializeHydrationData,
+  toInlineScriptJson,
+} from "./_serialization.ts";
+
+class Point {
+  constructor(public x: number, public y: number) {}
+}
+
+class CustomError extends Error {
+  constructor(message: string, public code: string) {
+    super(message);
+    this.name = "CustomError";
+  }
+}
+
+function registerFixtures(): void {
+  registerType<Point, { x: number; y: number }>({
+    name: "Point",
+    is: (value): value is Point => value instanceof Point,
+    serialize: (point) => ({ x: point.x, y: point.y }),
+    deserialize: (data) => new Point(data.x, data.y),
+  });
+  registerType<{ raw: unknown }, unknown>({
+    name: "Raw",
+    is: (value): value is { raw: unknown } =>
+      value !== null && typeof value === "object" && "raw" in value &&
+      Object.keys(value).length === 1,
+    serialize: (value) => value.raw,
+    deserialize: (data) => ({ raw: data }),
+  });
+  registerError<CustomError>({
+    name: "CustomError",
+    is: (error): error is CustomError => error instanceof CustomError,
+    serialize: (error) => ({ message: error.message, code: error.code }),
+    deserialize: (data) =>
+      new CustomError(data.message as string, data.code as string),
+  });
+}
+
+function asEmbeddedInTheDocument(
+  serialized: SerializedHydrationData,
+): SerializedHydrationData {
+  return new Function(`return ${toInlineScriptJson(serialized)};`)();
+}
+
+async function serializeV2(
+  loaderValue: unknown,
+): Promise<SerializedHydrationDataV2> {
+  return {
+    version: 2,
+    data: encodeToBase64(
+      await processHydrationData({
+        matches: [{ id: "/" }],
+        loaderData: { "/": { value: loaderValue } },
+      }),
+    ),
+  };
+}
+
+async function serializeV3(
+  loaderValue: unknown,
+): Promise<SerializedHydrationData> {
+  return await serializeHydrationData({
+    matches: [{ id: "/" }],
+    loaderData: { "/": { value: loaderValue } },
+  });
+}
+
+function hydratedValue(serialized: SerializedHydrationData): unknown {
+  const { loaderData } = deserializeHydrationData(
+    asEmbeddedInTheDocument(serialized),
+  );
+  return (loaderData?.["/"] as { value: unknown }).value;
+}
+
+async function observed(value: unknown): Promise<unknown> {
+  if (value instanceof Promise) {
+    try {
+      return { resolved: await observed(await value) };
+    } catch (error) {
+      return { rejected: await observed(error) };
+    }
+  }
+  if (value === null) return null;
+  switch (typeof value) {
+    case "number":
+      return { number: Object.is(value, -0) ? "-0" : String(value) };
+    case "bigint":
+      return { bigint: String(value) };
+    case "undefined":
+      return { undefined: true };
+    case "string":
+    case "boolean":
+      return value;
+  }
+  if (value instanceof Date) return { Date: String(value.getTime()) };
+  if (Array.isArray(value)) {
+    return {
+      array: await Promise.all(Array.from(value, observed)),
+      holes: value.length - Object.keys(value).length,
+    };
+  }
+  const object = value as Record<string, unknown>;
+  const prototype = Object.getPrototypeOf(object);
+  const own: [string, unknown][] = [];
+  for (const key of Object.getOwnPropertyNames(object)) {
+    own.push([
+      key,
+      await observed(Object.getOwnPropertyDescriptor(object, key)?.value),
+    ]);
+  }
+  return {
+    constructor: prototype === null ? null : prototype.constructor?.name,
+    plainPrototype: prototype === Object.prototype,
+    inherited: prototype && prototype !== Object.prototype &&
+        prototype.constructor === Object
+      ? await observed({ ...prototype })
+      : undefined,
+    message: object instanceof Error ? object.message : undefined,
+    exposedMessage: object instanceof HttpError
+      ? object.exposedMessage
+      : undefined,
+    own,
+  };
+}
+
+function rejectedWith(error: unknown): Promise<never> {
+  const promise = Promise.reject(error);
+  promise.catch(() => {});
+  return promise;
+}
+
+const ROUND_TRIPS: [string, () => unknown][] = [
+  ["a Date", () => new Date("2026-09-11T12:34:56.789Z")],
+  ["the epoch", () => new Date(0)],
+  ["a Date before the epoch", () => new Date(-1)],
+  ["an invalid Date", () => new Date(NaN)],
+  ["a bigint in the safe range, as CBOR collapses it", () => 123n],
+  ["the lowest bigint CBOR collapses", () => -(2n ** 53n)],
+  ["the lowest bigint CBOR keeps", () => 2n ** 53n],
+  ["a bigint beyond 64 bits", () => 2n ** 64n],
+  ["a negative bigint beyond 64 bits", () => -(2n ** 64n) - 1n],
+  ["NaN", () => NaN],
+  ["Infinity", () => Infinity],
+  ["-Infinity", () => -Infinity],
+  ["-0", () => -0],
+  ["an unsafe integer number", () => 2 ** 60],
+  ["a fraction", () => 1.5],
+  ["undefined", () => undefined],
+  ["a key whose value is undefined", () => ({ kept: undefined })],
+  ["an array hole", () => [1, , 3]],
+  ["an Error", () => new Error("plain")],
+  ["a TypeError", () => new TypeError("typed")],
+  ["an HttpError", () => new HttpError(404, "Missing")],
+  [
+    "an HttpError with an internal message",
+    () => new HttpError(500, "pool exhausted on shard 7"),
+  ],
+  ["an HttpError with an exposed message", () =>
+    new HttpError(400, {
+      message: "internal",
+      exposedMessage: "Try again",
+      instance: "/probe",
+    })],
+  ["a registered error", () => new CustomError("custom", "E42")],
+  ["a resolved promise", () => Promise.resolve(new Date(0))],
+  ["a rejected promise", () => rejectedWith(new HttpError(403, "Forbidden"))],
+  ["a promise rejected with a non-error", () => rejectedWith("plain reason")],
+  ["a registered type", () => new Point(10, 20)],
+  ["a registered type whose data carries tagged values", () => ({
+    raw: { at: new Date(0), big: 2n ** 64n, nan: NaN, gone: undefined },
+  })],
+  ["a plain object that has the tag key", () => ({ $t: 1, v: 2 })],
+  ["a plain object shaped like a tagged Date", () => ({ $t: "Date", v: 0 })],
+  ["a tag-keyed object inside registered data", () => ({
+    raw: { $t: "undefined" },
+  })],
+  ["an own __proto__ key inside registered data", () => ({
+    raw: JSON.parse('{"__proto__":{"polluted":true},"kept":1}'),
+  })],
+  [
+    "an own __proto__ key in loader data",
+    () => JSON.parse('{"__proto__":{"polluted":true},"kept":1}'),
+  ],
+  ["a Map, flattened", () => new Map([["a", 1]])],
+  ["a Set, flattened", () => new Set([1])],
+  ["a RegExp, flattened", () => /x/g],
+  ["a URL, flattened", () => new URL("https://example.com/")],
+  ["a typed array, flattened", () => new Uint8Array([1, 2])],
+  ["a class instance, flattened", () =>
+    new (class Box {
+      inside = 1;
+    })()],
+  ["a lone surrogate", () => ({ "key\uD800": "value\uDC00" })],
+  ["markup and line separators", () => "</script><!--<script>\u2028\u2029"],
+  ["nested data", () => ({
+    list: [{ at: new Date(1), n: [NaN, -0, undefined] }],
+    deep: { deeper: { big: 2n ** 70n } },
+  })],
+];
+
+describe("hydration payload version 3", () => {
+  beforeEach(() => {
+    resetRegistries();
+    registerFixtures();
+  });
+
+  afterEach(() => {
+    resetRegistries();
+  });
+
+  describe("hydrates every value exactly as version 2 did", () => {
+    for (const [name, make] of ROUND_TRIPS) {
+      it(name, async () => {
+        const v2 = hydratedValue(await serializeV2(make()));
+        const v3 = hydratedValue(await serializeV3(make()));
+        assertEquals(await observed(v3), await observed(v2));
+      });
+    }
+  });
+
+  for (
+    const [name, make] of [
+      ["a function", () => () => 1],
+      ["a symbol", () => Symbol("private")],
+    ] as const
+  ) {
+    it(`refuses ${name}, as version 2 did`, async () => {
+      await assertRejects(() => serializeV2({ inside: make() }));
+      await assertRejects(() => serializeV3({ inside: make() }), TypeError);
+    });
+  }
+
+  it("writes loader text into the payload as readable text", async () => {
+    const serialized = await serializeV3({ prose: "Readable by brotli" });
+    assertEquals(serialized.version, 3);
+    assertStringIncludes(JSON.stringify(serialized), "Readable by brotli");
+  });
+
+  it("escapes a plain object that carries the tag key", async () => {
+    const serialized = await serializeV3({ $t: "Date", v: 0 });
+    assertStringIncludes(
+      JSON.stringify(serialized),
+      '{"$t":"object","v":[["$t","Date"],["v",0]]}',
+    );
+    assertEquals(hydratedValue(serialized), { $t: "Date", v: 0 });
+  });
+
+  it("refuses a payload version it does not know", () => {
+    assertThrows(
+      () =>
+        deserializeHydrationData(
+          { version: 4, data: {} } as unknown as SerializedHydrationData,
+        ),
+      Error,
+      "Unsupported hydration data version: 4",
+    );
+  });
+
+  it("refuses a tag it does not know", () => {
+    assertThrows(
+      () =>
+        deserializeHydrationData({
+          version: 3,
+          data: { matches: [], loaderData: { $t: "Map", v: [] } },
+        }),
+      Error,
+      "Unknown hydration data tag: Map",
+    );
+  });
+});
+
+const GOLDEN_V2: SerializedHydrationDataV2 = {
+  version: 2,
+  data:
+    "pXFzZXJpYWxpemVkQ29udGV4dKFkdXNlcqFkbmFtZWNBZGFnbWF0Y2hlc4GhYmlkYS9qbG9hZGVyRGF0YaFhL6pkZGF0ZcH7Qdqo/VwyfvpnbWlzc2luZ/djbmFu+X4AbG5lZ2F0aXZlWmVyb/mAAGVzbWFsbBh7Y2JpZ8JJAQAAAAAAAAAAZXBvaW502ZxComZfX3R5cGVlUG9pbnRkZGF0YaJheAFheQJlZXJyb3LZnEOka19fZXJyb3JUeXBlaUh0dHBFcnJvcmdtZXNzYWdlZ01pc3Npbmdmc3RhdHVzGQGUZmV4cG9zZfVoZGVmZXJyZWTZnEDBAGZmYWlsZWTZnEGka19fZXJyb3JUeXBlaUh0dHBFcnJvcmdtZXNzYWdlaUZvcmJpZGRlbmZzdGF0dXMZAZNmZXhwb3Nl9WdidWlsZElkZ2J1aWxkLTFmZXJyb3JzoWEv2ZxDpGtfX2Vycm9yVHlwZWlIdHRwRXJyb3JnbWVzc2FnZXgvVGhlIHNlcnZlciBlbmNvdW50ZXJlZCBhbiB1bmV4cGVjdGVkIGNvbmRpdGlvbi5mc3RhdHVzGQH0ZmV4cG9zZfU=",
+  publicEnv: { APP_NAME: "Golden" },
+};
+
+describe("hydration payload version 2", () => {
+  beforeEach(() => {
+    resetRegistries();
+    registerFixtures();
+  });
+
+  afterEach(() => {
+    resetRegistries();
+  });
+
+  it("still hydrates a document rendered by Juniper 0.11.5", async () => {
+    const hydration = deserializeHydrationData(
+      asEmbeddedInTheDocument(GOLDEN_V2),
+    );
+    assertEquals(hydration.publicEnv, { APP_NAME: "Golden" });
+    assertEquals(hydration.buildId, "build-1");
+    assertEquals(hydration.matches, [{ id: "/" }]);
+    assertEquals(hydration.serializedContext, { user: { name: "Ada" } });
+
+    const data = hydration.loaderData?.["/"] as Record<string, unknown>;
+    assertInstanceOf(data.date, Date);
+    assertEquals(data.date.toISOString(), "2026-09-11T12:34:56.789Z");
+    assert(Object.hasOwn(data, "missing") && data.missing === undefined);
+    assert(Number.isNaN(data.nan));
+    assert(Object.is(data.negativeZero, -0));
+    assertEquals(data.small, 123);
+    assertEquals(data.big, 2n ** 64n);
+    assertInstanceOf(data.point, Point);
+    assertEquals({ ...data.point }, { x: 1, y: 2 });
+    assertInstanceOf(data.error, HttpError);
+    assertEquals([data.error.status, data.error.message], [404, "Missing"]);
+    assertEquals(((await data.deferred) as Date).getTime(), 0);
+    await assertRejects(
+      () => data.failed as Promise<unknown>,
+      HttpError,
+      "Forbidden",
+    );
+    const error = hydration.errors?.["/"];
+    assertInstanceOf(error, HttpError);
+    assertEquals(error.message, new HttpError(500).exposedMessage);
+  });
+});
+
+describe("toInlineScriptJson", () => {
+  const hostile = "</script><script>alert(1)</script><!--<script>\u2028\u2029";
+
+  it("writes no character that can end or re-enter the script element", () => {
+    const text = toInlineScriptJson({ hostile });
+    assertFalse(text.includes("<"));
+    assertFalse(text.includes("\u2028"));
+    assertFalse(text.includes("\u2029"));
+  });
+
+  it("still reads back as the same value", () => {
+    assertEquals(JSON.parse(toInlineScriptJson({ hostile })), { hostile });
+    assertEquals(new Function(`return ${toInlineScriptJson({ hostile })};`)(), {
+      hostile,
+    });
+  });
+});
diff --git a/src/_server.tsx b/src/_server.tsx
index 2cb96f9..1b28bbc 100644
--- a/src/_server.tsx
+++ b/src/_server.tsx
@@ -41,6 +41,7 @@ import {
   serializeError,
   serializeHydrationData,
   serializeLoaderData,
+  toInlineScriptJson,
 } from "./_serialization.ts";
 import type { SerializedHydrationData } from "./_serialization.ts";
 import { startActiveSpan } from "./utils/_otel.ts";
@@ -375,7 +376,7 @@ async function renderDocument(
           hydrationData,
         ).then((data: SerializedHydrationData) =>
           `import { client } from "/build/main.js"; window.__juniperHydrationData = ${
-            JSON.stringify(data).replaceAll("<", "\\u003c")
+            toInlineScriptJson(data)
           }; await client.hydrate();`
         );
 
diff --git a/src/_server_hydration.test.tsx b/src/_server_hydration.test.tsx
new file mode 100644
index 0000000..3623854
--- /dev/null
+++ b/src/_server_hydration.test.tsx
@@ -0,0 +1,170 @@
+import { brotliCompressSync, constants } from "node:zlib";
+
+import {
+  assert,
+  assertEquals,
+  assertExists,
+  assertFalse,
+  assertInstanceOf,
+} from "@std/assert";
+import { describe, it } from "@std/testing/bdd";
+
+import { Client } from "@udibo/juniper/client";
+import type { RouteProps } from "@udibo/juniper";
+import { createServer } from "@udibo/juniper/server";
+
+import {
+  cborDecode,
+  deserializeHydrationData,
+  encodeToBase64,
+  fromTaggedJson,
+  type SerializedHydrationData,
+  type SerializedHydrationDataV3,
+} from "./_serialization.ts";
+
+const HYDRATION_ASSIGNMENT =
+  /window\.__juniperHydrationData = (.*?); await client\.hydrate\(\);/;
+
+function serverWithLoaderData(loaderData: unknown) {
+  const client = new Client({
+    path: "/",
+    main: { default: () => <div>Home</div> },
+  });
+  return createServer(import.meta.url, client, {
+    path: "/",
+    main: { loader: () => loaderData },
+  });
+}
+
+function scriptBodyContaining(html: string, marker: string): string {
+  const markerAt = html.indexOf(marker);
+  assert(markerAt >= 0, `the document carries no ${marker}`);
+  const bodyStart = html.lastIndexOf(">", markerAt) + 1;
+  const bodyEnd = html.toLowerCase().indexOf("</script", bodyStart);
+  return html.slice(bodyStart, bodyEnd);
+}
+
+describe("the document's hydration payload", () => {
+  const hostile =
+    "</script><script>globalThis.pwned=1</script><!--<script></SCRIPT >\u2028\u2029";
+
+  it("keeps hostile loader text inside the hydration script", async () => {
+    const server = serverWithLoaderData({ text: hostile });
+    const html = await (await server.request("http://localhost/")).text();
+
+    const body = scriptBodyContaining(html, "window.__juniperHydrationData");
+    assert(
+      body.startsWith('import { client } from "/build/main.js";'),
+      "the script element opens with the hydration statement",
+    );
+    assert(
+      body.endsWith("; await client.hydrate();"),
+      "the first </script the HTML parser sees is the one Juniper wrote",
+    );
+    assertFalse(body.includes("<"));
+    assertFalse(body.includes("\u2028"));
+    assertFalse(body.includes("\u2029"));
+
+    const payload = HYDRATION_ASSIGNMENT.exec(body)?.[1];
+    assertExists(payload);
+    const serialized = JSON.parse(payload) as SerializedHydrationData;
+    assertEquals(serialized.version, 3);
+    assertEquals(
+      deserializeHydrationData(serialized).loaderData?.["/"],
+      { text: hostile },
+    );
+  });
+});
+
+describe("data requests", () => {
+  it("still answer in CBOR, with its native types rather than JSON tags", async () => {
+    const server = serverWithLoaderData({
+      at: new Date(0),
+      missing: undefined,
+    });
+    const res = await server.request("http://localhost/", {
+      headers: { "X-Juniper-Route-Id": "/" },
+    });
+    assertEquals(res.headers.get("content-type"), "application/cbor");
+    const data = cborDecode<Record<string, unknown>>(
+      new Uint8Array(await res.arrayBuffer()),
+    );
+    assertInstanceOf(data.at, Date);
+    assertEquals(data.at.getTime(), 0);
+    assert(Object.hasOwn(data, "missing") && data.missing === undefined);
+  });
+
+  it("still stream deferred data as CBOR chunks", async () => {
+    const server = serverWithLoaderData({ later: Promise.resolve(1) });
+    const res = await server.request("http://localhost/", {
+      headers: { "X-Juniper-Route-Id": "/" },
+    });
+    assertEquals(res.headers.get("content-type"), "application/cbor-stream");
+    await res.body?.cancel();
+  });
+});
+
+function brotli(text: string): number {
+  return brotliCompressSync(new TextEncoder().encode(text), {
+    params: { [constants.BROTLI_PARAM_QUALITY]: 5 },
+  }).length;
+}
+
+describe("what a prose page costs to send", () => {
+  it("compresses smaller with version 3 than with version 2", async () => {
+    const prose = await Deno.readTextFile(
+      new URL("../docs/routing.md", import.meta.url),
+    );
+    const paragraphs = prose.split(/\n{2,}/).filter((part) => part.trim());
+    const client = new Client({
+      path: "/",
+      main: {
+        default: ({ loaderData }: RouteProps) => (
+          <article>
+            {(loaderData as { paragraphs: string[] }).paragraphs.map((
+              paragraph,
+              index,
+            ) => <p key={index}>{paragraph}</p>)}
+          </article>
+        ),
+      },
+    });
+    const server = createServer(import.meta.url, client, {
+      path: "/",
+      main: { loader: () => ({ paragraphs }) },
+    });
+    const html = await (await server.request("http://localhost/")).text();
+
+    const script = /<script[^>]*>import \{ client \}[\s\S]*?<\/script>/.exec(
+      html,
+    )?.[0];
+    assertExists(script);
+    const v3Text = HYDRATION_ASSIGNMENT.exec(script)?.[1];
+    assertExists(v3Text);
+    const v3 = JSON.parse(v3Text) as SerializedHydrationDataV3;
+    const v2 = {
+      version: 2 as const,
+      data: encodeToBase64(fromTaggedJson(v3.data)),
+      publicEnv: v3.publicEnv,
+    };
+    assertEquals(
+      deserializeHydrationData(v2).loaderData,
+      deserializeHydrationData(v3).loaderData,
+      "both documents carry the same page",
+    );
+    const v2Html = html.replace(
+      v3Text,
+      () => JSON.stringify(v2).replaceAll("<", "\\u003c"),
+    );
+    const markup = brotli(html.replace(script, ""));
+    const v3Ratio = brotli(html) / markup;
+    const v2Ratio = brotli(v2Html) / markup;
+
+    assert(
+      v3Ratio < v2Ratio,
+      `version 3 ships ${v3Ratio.toFixed(3)}x its markup in brotli against ${
+        v2Ratio.toFixed(3)
+      }x for version 2`,
+    );
+  });
+});

From 0cff3ce92f85930c7615edf9cc9550cb41dfad58 Mon Sep 17 00:00:00 2001
From: Kyle June <github@kylejune.com>
Date: Fri, 11 Sep 2026 08:07:50 -0400
Subject: [PATCH 2/6] test: build lone surrogates at runtime in hydration table

Deno 2.9.6 panics collecting coverage for a module that has an
anonymous class expression followed by an object literal whose key
is a lone-surrogate escape ("key\uD800"): V8's takePreciseCoverage
response carries an escape serde_json rejects ("unexpected end of
hex escape"), so `deno task test --coverage` dies after every test
passed. Build the surrogates with String.fromCharCode instead; the
row round-trips the same key and value as before.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
---
 src/_serialization_hydration.test.ts | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/src/_serialization_hydration.test.ts b/src/_serialization_hydration.test.ts
index b11d296..bf634ee 100644
--- a/src/_serialization_hydration.test.ts
+++ b/src/_serialization_hydration.test.ts
@@ -150,6 +150,9 @@ function rejectedWith(error: unknown): Promise<never> {
   return promise;
 }
 
+const loneLeadSurrogate = String.fromCharCode(0xd800);
+const loneTrailSurrogate = String.fromCharCode(0xdc00);
+
 const ROUND_TRIPS: [string, () => unknown][] = [
   ["a Date", () => new Date("2026-09-11T12:34:56.789Z")],
   ["the epoch", () => new Date(0)],
@@ -211,7 +214,9 @@ const ROUND_TRIPS: [string, () => unknown][] = [
     new (class Box {
       inside = 1;
     })()],
-  ["a lone surrogate", () => ({ "key\uD800": "value\uDC00" })],
+  ["a lone surrogate", () => ({
+    [`key${loneLeadSurrogate}`]: `value${loneTrailSurrogate}`,
+  })],
   ["markup and line separators", () => "</script><!--<script>\u2028\u2029"],
   ["nested data", () => ({
     list: [{ at: new Date(1), n: [NaN, -0, undefined] }],

From 812564adf46b3c83cfcdc7e97dcbe598a43c23c8 Mon Sep 17 00:00:00 2001
From: Kyle June <github@kylejune.com>
Date: Sat, 12 Sep 2026 16:21:07 -0400
Subject: [PATCH 3/6] feat!: use tagged JSON end to end

BREAKING CHANGE: hydration, data requests, and deferred streams use tagged JSON; legacy hydration versions trigger guarded reloads.
---
 .releaserc.json                               |    2 +-
 README.md                                     |   13 +-
 deno.lock                                     |   11 -
 docs/error-handling.md                        |   14 +-
 docs/forms.md                                 |   10 +-
 docs/routing.md                               |   11 +-
 docs/state-management.md                      |   67 +-
 .../routes/features/data/server-deferred.tsx  |    8 +-
 src/_client.tsx                               |   31 +-
 src/_client_wire.test.tsx                     |  179 +++
 src/_serialization.test.ts                    |  108 +-
 src/_serialization.ts                         | 1104 ++++++-----------
 src/_serialization_hydration.test.ts          |  127 +-
 src/_serialization_wire.test.ts               |  499 ++++++++
 src/_server.tsx                               |   36 +-
 src/_server_hydration.test.tsx                |  382 ++++--
 src/_tagged-json.ts                           |  148 +++
 src/build.test.ts                             |    4 +
 src/client.test.tsx                           |   13 +-
 src/client.tsx                                |    5 +
 src/deno.json                                 |    1 -
 src/mod.ts                                    |   17 +-
 src/server.test.tsx                           |   19 +-
 src/utils/_env.ts                             |   10 +-
 24 files changed, 1718 insertions(+), 1101 deletions(-)
 create mode 100644 src/_client_wire.test.tsx
 create mode 100644 src/_serialization_wire.test.ts
 create mode 100644 src/_tagged-json.ts

diff --git a/.releaserc.json b/.releaserc.json
index 5d49281..8c0f8fd 100644
--- a/.releaserc.json
+++ b/.releaserc.json
@@ -7,7 +7,7 @@
       {
         "preset": "angular",
         "releaseRules": [
-          { "breaking": true, "release": "major" },
+          { "breaking": true, "release": "minor" },
           { "revert": true, "release": "patch" },
           { "type": "feat", "release": "minor" },
           { "type": "fix", "release": "patch" },
diff --git a/README.md b/README.md
index a6b0ee6..abbb3bf 100644
--- a/README.md
+++ b/README.md
@@ -1,8 +1,3 @@
----
-title: Juniper
-last_verified: 2026-09-09
----
-
 # Juniper
 
 [![JSR](https://jsr.io/badges/@udibo/juniper)](https://jsr.io/@udibo/juniper)
@@ -27,6 +22,8 @@ seamless full-stack development experience.
   initial page loads and SEO benefits.
 - **Data Loading and Actions** - Fetch data with loaders and handle form
   submissions with actions, on either server or client.
+- **Tagged JSON Transport** - One encoding for hydration, data requests, and
+  streamed deferred promises, with shared custom type and error registration.
 - **Hot Reload** - See changes instantly during development.
 - **TypeScript First** - Full TypeScript support with type-safe route
   parameters, loader data, and action data.
@@ -41,6 +38,12 @@ seamless full-stack development experience.
 
 ## Quick Start
 
+Version 0.12 uses tagged JSON throughout and requires matching server and
+browser builds. Older hydration payloads trigger a guarded document reload.
+Middleware should identify loader/action responses by `X-Juniper: data`. See
+[How Values Travel](docs/state-management.md#how-values-travel) for the wire
+format and registration contracts.
+
 Use `degit` to clone a template and get started:
 
 ```bash
diff --git a/deno.lock b/deno.lock
index 7d8f2cf..9cbcbd0 100644
--- a/deno.lock
+++ b/deno.lock
@@ -34,7 +34,6 @@
     "npm:@types/pg@^8.23.1": "8.23.1",
     "npm:@types/react@^19.2.18": "19.2.18",
     "npm:babel-plugin-react-compiler@1": "1.0.0",
-    "npm:cbor2@^2.3.0": "2.3.0",
     "npm:drizzle-kit@*": "0.31.10",
     "npm:drizzle-kit@~0.31.10": "0.31.10",
     "npm:drizzle-orm@~0.45.2": "0.45.2_@opentelemetry+api@1.9.1_@types+pg@8.23.1_pg@8.23.0",
@@ -353,9 +352,6 @@
     "@csstools/css-tokenizer@4.0.0": {
       "integrity": "sha512-QxULHAm7cNu72w97JUNCBFODFaXpbDg+dP8b/oWFAZ2MTRppA3U00Y2L1HqaS4J6yBqxwa/Y3nMBaxVKbB/NsA=="
     },
-    "@cto.af/wtf8@0.0.5": {
-      "integrity": "sha512-LfUFi+Vv4eDzj+XAtR89e3wwjXA/NZjUSwU5NhwbBrLecxPaBYFy3exCuc1j+D4UZeOVdqlsl8G7LmOt18V0tg=="
-    },
     "@drizzle-team/brocli@0.10.2": {
       "integrity": "sha512-z33Il7l5dKjUgGULTqBsQBQwckHh5AbIuxhdsIxDDiZAzBOrZO6q9ogcWC65kU382AfynTfgNumVcNIjuIua6w=="
     },
@@ -986,12 +982,6 @@
     "caniuse-lite@1.0.30001799": {
       "integrity": "sha512-hG1bReV+OUU+MOqK4t/ZWI0tZOyz3rqS9XuhOUz1cIcbwBKjOyJEJuw9ER5JuNyqxNk8u/JUVbGibBOL1yrjFw=="
     },
-    "cbor2@2.3.0": {
-      "integrity": "sha512-76WB3hq8BoaGkMkBVJ27fW5LJU+qqDLEpgRNCG/SYKhODWXpVPOTD4UcUto3IEzYLA52nsvbhb0wabhHDn3qXg==",
-      "dependencies": [
-        "@cto.af/wtf8"
-      ]
-    },
     "convert-source-map@2.0.0": {
       "integrity": "sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg=="
     },
@@ -1760,7 +1750,6 @@
           "npm:@testing-library/user-event@^14.6.7",
           "npm:@types/react@^19.2.18",
           "npm:babel-plugin-react-compiler@1",
-          "npm:cbor2@^2.3.0",
           "npm:esbuild@~0.28.2",
           "npm:global-jsdom@30",
           "npm:hono@^4.13.7",
diff --git a/docs/error-handling.md b/docs/error-handling.md
index f647d81..9e88c2f 100644
--- a/docs/error-handling.md
+++ b/docs/error-handling.md
@@ -197,7 +197,11 @@ export function ErrorBoundary({
 Errors thrown on the server are serialized for the client. Juniper handles this
 automatically, but you can customize the representation of registered error
 types. See [serializable values](state-management.md#serializable-values) for
-supported data types, numeric normalization, and custom type registration.
+supported data types and custom type registration. Data-request errors use the
+same tagged JSON codec and `X-Juniper: data` marker as successful data.
+Unexpected server failures remain sanitized outside development, and
+`HttpError.exposedMessage` determines the message sent to the browser, including
+deferred rejections.
 
 ### Custom Error Serialization
 
@@ -257,6 +261,14 @@ Import this shared module from the root **client** route so registration occurs
 on the server and in the browser before hydration data is deserialized. An
 import only from `routes/main.ts` never registers the browser-side decoder.
 
+Unknown registered error names throw during decoding. On a deferred stream, only
+the affected promise rejects. Error envelopes keep the registered name in
+`__errorType` and serializer output in `data`; an output property named
+`__errorType` remains data and cannot choose a different deserializer. Output is
+processed recursively and may contain supported values, promises, or registered
+types. A serializer whose output matches its own `is` predicate throws. The
+first matching error registration wins.
+
 ```typescript
 // routes/main.tsx
 import "@/errors/custom.ts";
diff --git a/docs/forms.md b/docs/forms.md
index b47b4c6..eba4733 100644
--- a/docs/forms.md
+++ b/docs/forms.md
@@ -101,11 +101,11 @@ export async function action({
 
 Actions can return data, redirects, or throw redirects. Action data is
 automatically serialized when sent to the client. JSON-shaped data, `undefined`,
-`Date`, and `Error` have built-in handling; `bigint` values are accepted with
-the numeric normalization described in
-[serializable values](state-management.md#serializable-values). Promise values
-can defer data. Register other classes with `registerType` or convert them to
-plain data before returning them.
+`Date`, `Error`, and `bigint` have built-in handling. The same tagged JSON codec
+carries action data in hydration and fetcher responses. Promise values can defer
+data through an NDJSON stream. See
+[How Values Travel](state-management.md#how-values-travel). Register other
+classes with `registerType` or convert them to plain data before returning them.
 
 ```typescript
 // Return data (available in component via actionData)
diff --git a/docs/routing.md b/docs/routing.md
index 8249312..b2059ec 100644
--- a/docs/routing.md
+++ b/docs/routing.md
@@ -193,11 +193,12 @@ Export `publicEnvKeys` from the root **server** module, `routes/main.ts`, to
 allowlist additional environment values in hydration data. See
 [configuration](configuration.md#public-environment-variables).
 
-Juniper serializes JSON-shaped data, `undefined`, `Date`, and `Error`. It also
-accepts `bigint` and promise values, with numeric and deferred-data behavior
-described in [serializable values](state-management.md#serializable-values).
-Register other classes with `registerType`; unregistered objects do not retain
-their class identity.
+Juniper carries JSON-shaped data, `undefined`, `Date`, `Error`, `bigint`, and
+promises through one tagged JSON codec. Client data responses carry
+`X-Juniper: data`: settled values use JSON and deferred values stream as NDJSON.
+See [How Values Travel](state-management.md#how-values-travel). Register other
+classes with `registerType`; unregistered objects do not retain their class
+identity.
 
 ### Layout Wrapper Pattern
 
diff --git a/docs/state-management.md b/docs/state-management.md
index 5866e12..f8303d3 100644
--- a/docs/state-management.md
+++ b/docs/state-management.md
@@ -306,10 +306,8 @@ loader/action data. See [error handling](error-handling.md#error-serialization)
 for the distinction between thrown errors, returned error data, and custom error
 serializers.
 
-`bigint` values are accepted, but the underlying numeric encoding can change
-their JavaScript type: `123n` decodes as the number `123`, while integers beyond
-the safe-number range remain `bigint`. Send a decimal string or register a
-wrapper type if the consumer requires an exact `bigint` contract.
+`bigint` values keep their JavaScript type, including small values such as
+`123n`. `NaN`, `Infinity`, `-Infinity`, and `-0` also round-trip unchanged.
 
 `Map`, `Set`, `RegExp`, and `URL` are **not** built-in round-trip types. Without
 registration, objects are reduced to their enumerable own properties; typical
@@ -341,33 +339,46 @@ import "@/serialization/url.ts";
 
 The route can then return a URL instance in loader data. Give each registration
 a unique name and import the module wherever standalone server code needs it.
-Use synchronous serializers that return plain data: JSON values plus
-`undefined`, `Date`, `bigint`, and non-finite numbers. Do not return promises or
-other instances (`Map`, `Set`, `URL`, class instances) from a serializer; its
-output is not processed recursively, and the first document load reduces such
-instances to their enumerable own properties.
+Serializer output is processed recursively: it can contain `Date`, `undefined`,
+promises, and other registered types. A serializer whose output matches its own
+`is` predicate throws. Avoid cycles between serializers or in their data.
+
+Registered `is` predicates run before the Array and Date checks. When several
+registrations match a value, the first registration wins. Duplicate names throw.
+An unknown registered type or error name throws during decoding; in a deferred
+resolution, only that promise rejects and other resolutions continue. Import
+every registration on both sides. Development hydration includes sorted
+registration names, and the browser logs names missing from its registry.
 
 #### How Values Travel
 
-The first document load embeds the page's data in an inline script as JSON text
-(hydration payload version 3). Values JSON cannot express are written as tagged
-objects of the form `{"$t": tag, "v": value}`: `Date`, `undefined`, `NaN`,
-`Infinity`, `-Infinity`, `-0`, `bigint` values outside the safe-number range,
-errors, settled promises, and registered types. A plain object that has its own
-`$t` or `__proto__` key is written in an escaped form, so data can never be
-mistaken for a tag. Every `<`, U+2028, and U+2029 in the payload is written as a
-`\u` escape, so no string in loader data can close the script element or start
-an HTML comment.
-
-Client navigations and fetchers request data as CBOR (`application/cbor`, or
-`application/cbor-stream` when deferred promises are still pending). Both paths
-decode to the same values, including the `bigint` normalization described above,
-so a loader's data has the same types whether it arrived with the document or on
-a later navigation.
-
-A document rendered by an earlier Juniper release carries hydration payload
-version 2 (base64-encoded CBOR). The browser client still decodes it, so a page
-restored from cache after an upgrade hydrates with the new client bundle.
+Juniper uses tagged JSON text for document hydration, client data requests, and
+deferred resolutions. Values JSON cannot express use string tags of the form
+`{"$t": tag, "v": value}`. The tags are `undefined`, `number`, `bigint`, `Date`,
+`object`, `pending`, `promise`, `rejected`, `type`, and `error`; unknown tags
+throw. Plain objects with an own `$t` or `__proto__` key use escaped entry
+lists, including inside serializer output, so their keys remain ordinary data.
+
+The first document load embeds hydration version 3 with one tagged value
+containing loader/action data, errors, context, and public environment values.
+Every `<`, U+2028, and U+2029 in that script is written as a `\u` escape.
+Documents carrying another hydration version use the guarded document reload
+path. There is no legacy decoder; deploy the server and browser build together.
+
+Client navigations and fetchers receive settled data as `application/json` with
+a UTF-8 `Content-Length`. Deferred data uses `application/x-ndjson`: the first
+line contains tagged data with pending placeholders, followed by lines shaped as
+`{"id":"p0","status":"resolved","value":...}` or
+`{"id":"p0","status":"rejected","error":...}`. Each value or error uses the same
+codec. Resolutions arrive as they become ready, including nested promises. The
+stream respects consumer back-pressure and stops on request cancellation.
+
+Both response kinds, including data-request errors, carry `X-Juniper: data`. Use
+this marker to identify framework data in middleware; JSON content type also
+occurs on ordinary API responses and redirect envelopes. Deferred streams carry
+`Cache-Control: no-transform` and must remain uncompressed at the origin so
+buffering does not delay individual resolutions. Settled JSON can use normal
+HTTP compression. The client uses one text-line decoder for both response kinds.
 
 ## React Context
 
diff --git a/example/routes/features/data/server-deferred.tsx b/example/routes/features/data/server-deferred.tsx
index d9c0814..ecb8767 100644
--- a/example/routes/features/data/server-deferred.tsx
+++ b/example/routes/features/data/server-deferred.tsx
@@ -34,9 +34,9 @@ export default function ServerDeferredDataDemo({
       </h2>
       <p className="text-slate-300 mb-6 leading-relaxed">
         Server loaders can also return promises for deferred data. The promises
-        are serialized using CBOR and streamed to the client for progressive
-        hydration. This demonstrates the full server-to-client data flow with
-        {" "}
+        are serialized using tagged JSON and streamed to the client for
+        progressive hydration. This demonstrates the full server-to-client data
+        flow with{" "}
         <code className="px-2 py-1 bg-slate-700 rounded text-emerald-400">
           Suspense
         </code>{" "}
@@ -104,7 +104,7 @@ export default function ServerDeferredDataDemo({
             Fast data is included in the initial HTML response
           </li>
           <li>
-            Promises are serialized using CBOR with custom tags
+            Promises are serialized using tagged JSON and streamed as NDJSON
           </li>
           <li>
             Client hydrates immediately with Suspense fallbacks
diff --git a/src/_client.tsx b/src/_client.tsx
index 859d83e..94ceb3a 100644
--- a/src/_client.tsx
+++ b/src/_client.tsx
@@ -25,7 +25,6 @@ import { delay } from "@std/async/delay";
 import {
   deserializeError,
   deserializeHydrationData,
-  deserializeLoaderData,
   deserializeStreamingLoaderData,
   type HydrationData,
   type SerializedHydrationData,
@@ -341,6 +340,16 @@ function scheduleDocumentNavigation(
   return promise;
 }
 
+export function reloadUnsupportedHydration(version: number): Promise<never> {
+  if (!shouldReload(BUILD_SKEW_RELOAD_KEY)) {
+    throw new Error(`Unsupported hydration data version: ${version}`);
+  }
+  return scheduleDocumentNavigation(
+    BUILD_SKEW_RELOAD_KEY,
+    () => globalThis.location.reload(),
+  );
+}
+
 async function fetchServerData(
   request: Request,
   method: "GET" | "POST",
@@ -379,29 +388,15 @@ async function fetchServerData(
     }
   }
 
-  const contentType = response.headers.get("Content-Type");
-
-  if (contentType === "application/cbor-stream") {
-    if (!response.ok) {
-      const buffer = await response.arrayBuffer();
-      const deserialized = deserializeLoaderData(new Uint8Array(buffer));
-      throw deserializeError(deserialized as Record<string, unknown>);
-    }
-    return await deserializeStreamingLoaderData(response);
-  }
-
-  if (contentType === "application/cbor") {
-    const buffer = await response.arrayBuffer();
-    const deserialized = deserializeLoaderData(new Uint8Array(buffer));
-
+  const responseType = response.headers.get("X-Juniper");
+  if (responseType === "data") {
+    const deserialized = await deserializeStreamingLoaderData(response);
     if (!response.ok) {
       throw deserializeError(deserialized as Record<string, unknown>);
     }
-
     return deserialized;
   }
 
-  const responseType = response.headers.get("X-Juniper");
   if (responseType === "redirect") {
     const redirectData = await response.json();
     request.signal.throwIfAborted();
diff --git a/src/_client_wire.test.tsx b/src/_client_wire.test.tsx
new file mode 100644
index 0000000..3593c61
--- /dev/null
+++ b/src/_client_wire.test.tsx
@@ -0,0 +1,179 @@
+import "./utils/global-jsdom.ts";
+import { assertEquals, assertExists, assertRejects } from "@std/assert";
+import { afterEach, beforeEach, describe, it } from "@std/testing/bdd";
+import { stub } from "@std/testing/mock";
+import { FakeTime } from "@std/testing/time";
+import { Client } from "@udibo/juniper/client";
+import { HttpError } from "@udibo/juniper";
+import { createRoute } from "./_client.tsx";
+import { createLoaderDataResponse, serializeError } from "./_serialization.ts";
+import type { SerializedHydrationData } from "./_serialization.ts";
+import { env } from "./utils/_env.ts";
+
+describe("client tagged JSON data dispatch", () => {
+  for (const method of ["GET", "POST"]) {
+    it(`decodes settled and deferred ${method} data and the same error envelope`, async () => {
+      const route = createRoute({}, { loader: true, action: true }, "/wire");
+      const handler = method === "GET" ? route.loader : route.action;
+      assertExists(handler);
+      const args = () => ({
+        context: {} as never,
+        params: {},
+        request: new Request("http://localhost/wire", {
+          method,
+          ...(method === "POST" ? { body: new FormData() } : {}),
+        }),
+        url: new URL("http://localhost/wire"),
+        pattern: "/wire",
+      });
+      for (const deferred of [false, true]) {
+        const value = { at: new Date(5), missing: undefined, $t: "Date" };
+        using _fetch = stub(
+          globalThis,
+          "fetch",
+          () =>
+            Promise.resolve(
+              createLoaderDataResponse({
+                value: deferred ? Promise.resolve(value) : value,
+              }),
+            ),
+        );
+        const result = await handler(args()) as { value: unknown };
+        assertEquals(await result.value, value);
+      }
+      using _fetch = stub(globalThis, "fetch", () => {
+        const encoded = createLoaderDataResponse(
+          serializeError(new HttpError(403, "Denied")),
+        );
+        return Promise.resolve(
+          new Response(encoded.body, { status: 403, headers: encoded.headers }),
+        );
+      });
+      await assertRejects(
+        async () => await handler(args()),
+        HttpError,
+        "Denied",
+      );
+    });
+  }
+
+  it("leaves JSON API responses without the data marker as Responses", async () => {
+    const response = Response.json({ $t: "Date", v: 5 });
+    using _fetch = stub(globalThis, "fetch", () => Promise.resolve(response));
+    const route = createRoute({}, { loader: true }, "/wire");
+    assertExists(route.loader);
+    const result = await route.loader({
+      context: {} as never,
+      params: {},
+      request: new Request("http://localhost/wire"),
+      url: new URL("http://localhost/wire"),
+      pattern: "/wire",
+    });
+    assertEquals(result, response);
+    assertEquals(response.bodyUsed, false);
+    await response.body?.cancel();
+  });
+});
+
+describe("hydration version recovery", () => {
+  const key = "__juniper_build_skew_reload";
+  let originalLocation: Location;
+  let reloads: number;
+  beforeEach(() => {
+    reloads = 0;
+    originalLocation = globalThis.location;
+    Object.defineProperty(globalThis, "location", {
+      configurable: true,
+      value: {
+        href: "http://localhost/",
+        reload: () => {
+          reloads++;
+        },
+      },
+    });
+    sessionStorage.removeItem(key);
+  });
+  afterEach(() => {
+    Object.defineProperty(globalThis, "location", {
+      configurable: true,
+      value: originalLocation,
+    });
+    sessionStorage.removeItem(key);
+  });
+
+  for (const version of [2, 4, 0]) {
+    it(`reloads version ${version} before reading its data and coalesces concurrent attempts`, async () => {
+      using time = new FakeTime();
+      let decoded = 0;
+      let loaded = 0;
+      using _data = stub(env, "getHydrationData", () => ({
+        version,
+        get data() {
+          decoded++;
+          throw new Error("must not decode");
+        },
+      } as unknown as SerializedHydrationData));
+      const client = new Client({ path: "/" });
+      using _routes = stub(client, "loadLazyMatches", () => {
+        loaded++;
+        return Promise.resolve();
+      });
+      const outcomes: unknown[] = [];
+      for (let i = 0; i < 3; i++) {
+        client.hydrate().then(
+          () => outcomes.push("resolved"),
+          (e) => outcomes.push(e),
+        );
+      }
+      await time.tickAsync(1);
+      assertEquals(decoded, 0);
+      assertEquals(loaded, 0);
+      assertEquals(reloads, 1);
+      assertEquals(outcomes, []);
+      assertEquals(JSON.parse(sessionStorage.getItem(key)!).count, 1);
+    });
+  }
+
+  it("surfaces an unsupported version after the guarded reload budget is exhausted", async () => {
+    sessionStorage.setItem(
+      key,
+      JSON.stringify({ count: 2, timestamp: Date.now() }),
+    );
+    using _data = stub(
+      env,
+      "getHydrationData",
+      () => ({
+        version: 2,
+        data: "obsolete",
+      } as unknown as SerializedHydrationData),
+    );
+    await assertRejects(
+      () => new Client({ path: "/" }).hydrate(),
+      Error,
+      "Unsupported hydration data version: 2",
+    );
+    assertEquals(reloads, 0);
+  });
+
+  it("surfaces missing type registrations during hydration", async () => {
+    using _data = stub(
+      env,
+      "getHydrationData",
+      () => ({
+        version: 3 as const,
+        data: {
+          matches: [],
+          loaderData: {
+            root: { $t: "type", v: { __type: "Absent", data: 1 } },
+          },
+        },
+      }),
+    );
+    await assertRejects(
+      () => new Client({ path: "/" }).hydrate(),
+      Error,
+      "No deserializer registered for type",
+    );
+    assertEquals(reloads, 0);
+  });
+});
diff --git a/src/_serialization.test.ts b/src/_serialization.test.ts
index 119aaf5..7dd6c79 100644
--- a/src/_serialization.test.ts
+++ b/src/_serialization.test.ts
@@ -10,18 +10,16 @@ import { afterEach, beforeEach, describe, it } from "@std/testing/bdd";
 import { HttpError } from "@udibo/http-error";
 
 import {
-  cborDecode,
-  cborEncode,
   containsPromises,
   createStreamingLoaderData,
-  decodeFromBase64,
   deserializeError,
   deserializeHydrationData,
   deserializeStreamingLoaderData,
-  encodeToBase64,
+  fromTaggedJson,
   resetRegistries,
   serializeError,
   serializeHydrationData,
+  toTaggedJson,
 } from "./_serialization.ts";
 
 import { registerError, registerType } from "./mod.ts";
@@ -35,58 +33,32 @@ describe("Serialization Module", () => {
     resetRegistries();
   });
 
-  describe("cborEncode/cborDecode", () => {
+  describe("toTaggedJson/fromTaggedJson", () => {
     it("should encode and decode primitive values", () => {
-      assertEquals(cborDecode(cborEncode(42)), 42);
-      assertEquals(cborDecode(cborEncode("hello")), "hello");
-      assertEquals(cborDecode(cborEncode(true)), true);
-      assertEquals(cborDecode(cborEncode(null)), null);
-      assertEquals(cborDecode(cborEncode(undefined)), undefined);
+      assertEquals(fromTaggedJson(toTaggedJson(42)), 42);
+      assertEquals(fromTaggedJson(toTaggedJson("hello")), "hello");
+      assertEquals(fromTaggedJson(toTaggedJson(true)), true);
+      assertEquals(fromTaggedJson(toTaggedJson(null)), null);
+      assertEquals(fromTaggedJson(toTaggedJson(undefined)), undefined);
     });
 
     it("should encode and decode arrays", () => {
       const input = [1, 2, 3, "a", "b"];
-      assertEquals(cborDecode(cborEncode(input)), input);
+      assertEquals(fromTaggedJson(toTaggedJson(input)), input);
     });
 
     it("should encode and decode objects", () => {
       const input = { name: "test", value: 123, nested: { a: 1 } };
-      assertEquals(cborDecode(cborEncode(input)), input);
+      assertEquals(fromTaggedJson(toTaggedJson(input)), input);
     });
 
     it("should encode and decode Dates", () => {
       const date = new Date("2025-01-01T00:00:00Z");
-      const decoded = cborDecode<Date>(cborEncode(date));
+      const decoded = fromTaggedJson(toTaggedJson(date)) as Date;
       assertEquals(decoded.toISOString(), date.toISOString());
     });
   });
 
-  describe("encodeToBase64/decodeFromBase64", () => {
-    it("round-trips hydration data larger than the function argument limit", () => {
-      const input = { text: "水🌿".repeat(200_000) };
-      assertEquals(decodeFromBase64(encodeToBase64(input)), input);
-    });
-
-    it("should encode and decode to base64 strings", () => {
-      const input = { message: "hello world", count: 42 };
-      const base64 = encodeToBase64(input);
-      assertEquals(typeof base64, "string");
-      assertEquals(decodeFromBase64(base64), input);
-    });
-
-    it("should handle complex nested structures", () => {
-      const input = {
-        users: [
-          { name: "Alice", age: 30 },
-          { name: "Bob", age: 25 },
-        ],
-        metadata: { version: 1 },
-      };
-      const base64 = encodeToBase64(input);
-      assertEquals(decodeFromBase64(base64), input);
-    });
-  });
-
   describe("registerType", () => {
     it("should register a custom type serializer", async () => {
       class Money {
@@ -169,8 +141,8 @@ describe("Serialization Module", () => {
       const serialized = serializeError(error);
 
       assertEquals(serialized.__errorType, "ValidationError");
-      assertEquals(serialized.message, "Invalid input");
-      assertEquals(serialized.fields, ["email", "name"]);
+      assertEquals(serialized.data.message, "Invalid input");
+      assertEquals(serialized.data.fields, ["email", "name"]);
 
       const deserialized = deserializeError(serialized) as ValidationError;
       assertEquals(deserialized instanceof ValidationError, true);
@@ -208,8 +180,8 @@ describe("Serialization Module", () => {
       const serialized = serializeError(error);
 
       assertEquals(serialized.__errorType, "HttpError");
-      assertEquals(serialized.status, 404);
-      assertEquals(serialized.message, "Not Found");
+      assertEquals(serialized.data.status, 404);
+      assertEquals(serialized.data.message, "Not Found");
 
       const deserialized = deserializeError(serialized) as HttpError;
       assertEquals(deserialized instanceof HttpError, true);
@@ -225,12 +197,12 @@ describe("Serialization Module", () => {
       const serialized = serializeError(error);
 
       assertEquals(
-        serialized.message,
+        serialized.data.message,
         error.exposedMessage,
         "the wire carries what the rendering layer would show",
       );
       assertEquals(
-        (serialized.message as string).includes("connection refused"),
+        (serialized.data.message as string).includes("connection refused"),
         false,
         "and never the internal detail — this payload reaches the browser",
       );
@@ -248,7 +220,7 @@ describe("Serialization Module", () => {
       const error = new HttpError(404, "Tenant not found");
       const serialized = serializeError(error);
 
-      assertEquals(serialized.message, "Tenant not found");
+      assertEquals(serialized.data.message, "Tenant not found");
       assertEquals(
         (deserializeError(serialized) as HttpError).message,
         "Tenant not found",
@@ -262,9 +234,12 @@ describe("Serialization Module", () => {
       });
       const serialized = serializeError(error);
 
-      assertEquals(serialized.message, "You don't have permission to do that.");
       assertEquals(
-        serialized.expose,
+        serialized.data.message,
+        "You don't have permission to do that.",
+      );
+      assertEquals(
+        serialized.data.expose,
         true,
         "what reached the wire is exposable by construction, so the flag says so",
       );
@@ -282,7 +257,7 @@ describe("Serialization Module", () => {
       const serialized = serializeError(error);
 
       assertEquals(serialized.__errorType, "TypeError");
-      assertEquals(serialized.message, "Invalid type");
+      assertEquals(serialized.data.message, "Invalid type");
 
       const deserialized = deserializeError(serialized) as TypeError;
       assertEquals(deserialized instanceof TypeError, true);
@@ -294,7 +269,7 @@ describe("Serialization Module", () => {
       const serialized = serializeError(error);
 
       assertEquals(serialized.__errorType, "RangeError");
-      assertEquals(serialized.message, "Out of range");
+      assertEquals(serialized.data.message, "Out of range");
 
       const deserialized = deserializeError(serialized) as RangeError;
       assertEquals(deserialized instanceof RangeError, true);
@@ -306,7 +281,7 @@ describe("Serialization Module", () => {
       const serialized = serializeError(error);
 
       assertEquals(serialized.__errorType, "Error");
-      assertEquals(serialized.message, "Something went wrong");
+      assertEquals(serialized.data.message, "Something went wrong");
 
       const deserialized = deserializeError(serialized) as Error;
       assertEquals(deserialized instanceof Error, true);
@@ -318,7 +293,7 @@ describe("Serialization Module", () => {
       const serialized = serializeError(thrown);
 
       assertEquals(serialized.__errorType, "Unknown");
-      assertEquals(serialized.value, thrown);
+      assertEquals(serialized.data.value, thrown);
 
       const deserialized = deserializeError(serialized);
       assertEquals(deserialized, thrown);
@@ -553,8 +528,7 @@ describe("Serialization Module", () => {
     for (const framing of ["coalesced", "split", "bytes"] as const) {
       it(`resolves deferred data with ${framing} transport chunks`, async () => {
         const bytes = await deferredFrames();
-        const firstFrameEnd = new DataView(bytes.buffer).getUint32(0, false) +
-          4;
+        const firstFrameEnd = bytes.indexOf(10) + 1;
         const chunks = framing === "coalesced"
           ? [bytes]
           : framing === "bytes"
@@ -580,7 +554,7 @@ describe("Serialization Module", () => {
 
     it("rejects every unresolved value when the stream ends between frames", async () => {
       const bytes = await deferredFrames();
-      const firstFrameEnd = new DataView(bytes.buffer).getUint32(0, false) + 4;
+      const firstFrameEnd = bytes.indexOf(10) + 1;
       const response = chunkedResponse([bytes.slice(0, firstFrameEnd)]);
       const data = await deserializeStreamingLoaderData<{
         first: Promise<string>;
@@ -595,12 +569,12 @@ describe("Serialization Module", () => {
       assertEquals(response.body!.locked, false);
     });
 
-    it("cancels and unlocks a response whose initial CBOR frame cannot decode", async () => {
+    it("cancels and unlocks a response whose initial JSON line cannot decode", async () => {
       let canceled = false;
       const response = new Response(
         new ReadableStream({
           start(controller) {
-            controller.enqueue(Uint8Array.of(0, 0, 0, 1, 0xff));
+            controller.enqueue(new TextEncoder().encode("{invalid\n"));
           },
           cancel() {
             canceled = true;
@@ -614,13 +588,13 @@ describe("Serialization Module", () => {
 
     it("cancels and unlocks a malformed resolution stream after rejecting its values", async () => {
       const bytes = await deferredFrames();
-      const firstFrameEnd = new DataView(bytes.buffer).getUint32(0, false) + 4;
+      const firstFrameEnd = bytes.indexOf(10) + 1;
       let canceled = false;
       const response = new Response(
         new ReadableStream({
           start(controller) {
             controller.enqueue(bytes.slice(0, firstFrameEnd));
-            controller.enqueue(Uint8Array.of(0, 0, 0, 1, 0xff));
+            controller.enqueue(new TextEncoder().encode("{invalid\n"));
           },
           cancel() {
             canceled = true;
@@ -646,7 +620,7 @@ describe("Serialization Module", () => {
       const stream = createStreamingLoaderData(data);
 
       const response = new Response(stream, {
-        headers: { "Content-Type": "application/cbor-stream" },
+        headers: { "Content-Type": "application/x-ndjson" },
       });
 
       const result = await deserializeStreamingLoaderData(response);
@@ -661,7 +635,7 @@ describe("Serialization Module", () => {
 
       const stream = createStreamingLoaderData(data);
       const response = new Response(stream, {
-        headers: { "Content-Type": "application/cbor-stream" },
+        headers: { "Content-Type": "application/x-ndjson" },
       });
 
       const result = await deserializeStreamingLoaderData<{
@@ -683,7 +657,7 @@ describe("Serialization Module", () => {
 
       const stream = createStreamingLoaderData(data);
       const response = new Response(stream, {
-        headers: { "Content-Type": "application/cbor-stream" },
+        headers: { "Content-Type": "application/x-ndjson" },
       });
 
       const result = await deserializeStreamingLoaderData<{
@@ -704,7 +678,7 @@ describe("Serialization Module", () => {
 
       const stream = createStreamingLoaderData(data);
       const response = new Response(stream, {
-        headers: { "Content-Type": "application/cbor-stream" },
+        headers: { "Content-Type": "application/x-ndjson" },
       });
 
       const result = await deserializeStreamingLoaderData<{
@@ -725,7 +699,7 @@ describe("Serialization Module", () => {
 
       const stream = createStreamingLoaderData(data);
       const response = new Response(stream, {
-        headers: { "Content-Type": "application/cbor-stream" },
+        headers: { "Content-Type": "application/x-ndjson" },
       });
 
       const result = await deserializeStreamingLoaderData<{
@@ -752,7 +726,7 @@ describe("Serialization Module", () => {
 
       const stream = createStreamingLoaderData(data);
       const response = new Response(stream, {
-        headers: { "Content-Type": "application/cbor-stream" },
+        headers: { "Content-Type": "application/x-ndjson" },
       });
 
       const result = await deserializeStreamingLoaderData<{
@@ -784,7 +758,7 @@ describe("Serialization Module", () => {
 
       const stream = createStreamingLoaderData(data);
       const response = new Response(stream, {
-        headers: { "Content-Type": "application/cbor-stream" },
+        headers: { "Content-Type": "application/x-ndjson" },
       });
 
       const result = await deserializeStreamingLoaderData<{
@@ -810,7 +784,7 @@ describe("Serialization Module", () => {
 
       const stream = createStreamingLoaderData(data);
       const response = new Response(stream, {
-        headers: { "Content-Type": "application/cbor-stream" },
+        headers: { "Content-Type": "application/x-ndjson" },
       });
 
       const result = await deserializeStreamingLoaderData<{
diff --git a/src/_serialization.ts b/src/_serialization.ts
index ead7646..e7a3885 100644
--- a/src/_serialization.ts
+++ b/src/_serialization.ts
@@ -1,16 +1,17 @@
-/**
- * Internal serialization module.
- *
- * Data requests travel as CBOR (cbor2). The document's hydration payload
- * travels as tagged JSON text (version 3) so the page stays readable to the
- * compressor; version 2 (base64 of CBOR) is still decoded for documents cached
- * before an upgrade. Public interfaces and registration functions are exported
- * from mod.ts.
- *
- * @internal
- * @module
- */
-import { decode, encode, Tag } from "cbor2";
+import {
+  decodeHydrationPayload,
+  defineOwnValue,
+  fromTaggedJson,
+  Tagged,
+  toTaggedJson,
+} from "./_tagged-json.ts";
+import type { TaggedJson } from "./_tagged-json.ts";
+export {
+  fromTaggedJson,
+  toInlineScriptJson,
+  toTaggedJson,
+} from "./_tagged-json.ts";
+export type { TaggedJson } from "./_tagged-json.ts";
 import type { RouterContext, RouterContextProvider } from "react-router";
 import { HttpError, isHttpErrorLike } from "@udibo/http-error";
 
@@ -49,12 +50,6 @@ export interface ContextSerializer<T, S = unknown> {
   deserialize: (data: S | undefined) => T;
 }
 
-const PROMISE_RESOLVED_TAG = 40000;
-const PROMISE_REJECTED_TAG = 40001;
-const CUSTOM_TYPE_TAG = 40002;
-const ERROR_TAG = 40003;
-const PROMISE_PENDING_TAG = 40004;
-
 // deno-lint-ignore no-explicit-any
 const typeRegistry = new Map<string, TypeSerializer<any, any>>();
 // deno-lint-ignore no-explicit-any
@@ -190,109 +185,88 @@ export function sanitizeServerData<T>(data: T): T {
   ) as T;
 }
 
-/**
- * Serialize an error using the registered error serializers.
- *
- * @param error - The error to serialize
- * @returns The serialized error data
- */
-export function serializeError(error: unknown): Record<string, unknown> {
+export interface ErrorEnvelope extends Record<string, unknown> {
+  __errorType: string;
+  data: Record<string, unknown>;
+}
+
+export function serializeError(error: unknown): ErrorEnvelope {
   const serializer = findErrorSerializer(error);
   if (serializer) {
-    return {
-      __errorType: serializer.name,
-      ...serializer.serialize(error as Error),
-    };
+    const data = serializer.serialize(error as Error);
+    if (serializer.is(data)) {
+      throw new Error(
+        `Error serializer "${serializer.name}" output matches its own is predicate`,
+      );
+    }
+    return { __errorType: serializer.name, data };
   }
-
   if (error instanceof Error) {
-    const serialized: Record<string, unknown> = {
+    return {
       __errorType: "Error",
-      message: error.message,
-      name: error.name,
+      data: {
+        message: error.message,
+        name: error.name,
+        ...(isDevelopment() ? { stack: error.stack } : {}),
+      },
     };
-    if (isDevelopment()) {
-      serialized.stack = error.stack;
-    }
-    return serialized;
   }
-
-  return { __errorType: "Unknown", value: error };
+  return { __errorType: "Unknown", data: { value: error } };
 }
 
-/**
- * Deserialize an error from serialized data.
- *
- * @param data - The serialized error data
- * @returns The deserialized error
- */
-export function deserializeError(data: Record<string, unknown>): unknown {
-  const errorType = data.__errorType as string;
-
-  const serializer = errorRegistry.get(errorType);
-  if (serializer) {
-    return serializer.deserialize(data);
+export function deserializeError(envelope: Record<string, unknown>): unknown {
+  const name = envelope.__errorType;
+  const data = envelope.data as Record<string, unknown>;
+  if (name === "Unknown") return data.value;
+  const serializer = errorRegistry.get(name as string);
+  if (!serializer) {
+    throw new Error(`No deserializer registered for error "${String(name)}"`);
   }
-
-  if (errorType === "Unknown") {
-    return data.value;
-  }
-
-  const error = new Error(data.message as string);
-  if (data.name) error.name = data.name as string;
-  if (data.stack) error.stack = data.stack as string;
-  return error;
+  return serializer.deserialize(data);
 }
 
-// Thenable check (not instanceof Promise) for cross-realm compatibility.
 function isThenable(value: unknown): value is PromiseLike<unknown> {
-  return (
-    value !== null &&
-    typeof value === "object" &&
-    "then" in value &&
-    typeof (value as { then: unknown }).then === "function"
-  );
+  return value !== null && typeof value === "object" && "then" in value &&
+    typeof (value as { then: unknown }).then === "function";
 }
 
-async function processValue(value: unknown): Promise<unknown> {
-  if (value === null || value === undefined) {
-    return value;
+function serializeType(
+  value: unknown,
+  serializer: TypeSerializer<unknown>,
+): unknown {
+  const data = serializer.serialize(value);
+  if (serializer.is(data)) {
+    throw new Error(
+      `Type serializer "${serializer.name}" output matches its own is predicate`,
+    );
   }
+  return data;
+}
 
+async function processValue(value: unknown): Promise<unknown> {
+  if (value === null || value === undefined) return value;
   if (isThenable(value)) {
     try {
-      const resolved = await value;
-      const processedValue = await processValue(resolved);
-      return new Tag(PROMISE_RESOLVED_TAG, processedValue);
+      return new Tagged("promise", await processValue(await value));
     } catch (error) {
-      return new Tag(
-        PROMISE_REJECTED_TAG,
-        serializeError(sanitizeServerError(error)),
+      return new Tagged(
+        "rejected",
+        await processValue(serializeError(sanitizeServerError(error))),
       );
     }
   }
-
   if (value instanceof Error || isHttpErrorLike(value)) {
-    return new Tag(ERROR_TAG, serializeError(value));
+    return new Tagged("error", await processValue(serializeError(value)));
   }
-
-  const typeSerializer = findTypeSerializer(value);
-  if (typeSerializer) {
-    return new Tag(CUSTOM_TYPE_TAG, {
-      __type: typeSerializer.name,
-      data: typeSerializer.serialize(value),
+  const serializer = findTypeSerializer(value);
+  if (serializer) {
+    return new Tagged("type", {
+      __type: serializer.name,
+      data: await processValue(serializeType(value, serializer)),
     });
   }
-
-  if (Array.isArray(value)) {
-    const processed = await Promise.all(value.map(processValue));
-    return processed;
-  }
-
-  if (value instanceof Date) {
-    return value;
-  }
-
+  if (Array.isArray(value)) return await Promise.all(value.map(processValue));
+  if (value instanceof Date) return value;
   if (typeof value === "object") {
     const result: Record<string, unknown> = {};
     for (const [key, val] of Object.entries(value)) {
@@ -300,500 +274,408 @@ async function processValue(value: unknown): Promise<unknown> {
     }
     return result;
   }
-
   return value;
 }
 
-function defineOwnValue(
-  target: Record<string, unknown>,
-  key: string,
-  value: unknown,
-): void {
-  Object.defineProperty(target, key, {
-    value,
-    enumerable: true,
-    writable: true,
-    configurable: true,
-  });
-}
+type PromiseResolvers = Map<string, {
+  promise: Promise<unknown>;
+  resolve: (value: unknown) => void;
+  reject: (error: unknown) => void;
+}>;
 
-function restoreValue(value: unknown): unknown {
-  if (value === null || value === undefined) {
-    return value;
-  }
-
-  if (value instanceof Tag) {
-    const tagNum = Number(value.tag);
-
-    if (tagNum === PROMISE_RESOLVED_TAG) {
-      const restored = restoreValue(value.contents);
-      return Promise.resolve(restored);
+function restoreValue(value: unknown, pending?: PromiseResolvers): unknown {
+  if (value instanceof Tagged) {
+    if (value.tag === "pending") {
+      if (!pending || typeof value.contents !== "string") {
+        throw new Error("Unexpected pending promise tag");
+      }
+      const existing = pending.get(value.contents);
+      if (existing) return existing.promise;
+      const resolver = Promise.withResolvers<unknown>();
+      resolver.promise.catch(() => {});
+      pending.set(value.contents, resolver);
+      return resolver.promise;
     }
-
-    if (tagNum === PROMISE_REJECTED_TAG) {
-      const error = deserializeError(value.contents as Record<string, unknown>);
-      return Promise.reject(error);
+    if (value.tag === "promise") {
+      return Promise.resolve(restoreValue(value.contents, pending));
     }
-
-    if (tagNum === CUSTOM_TYPE_TAG) {
+    if (value.tag === "rejected") {
+      const promise = Promise.reject(
+        deserializeError(
+          restoreValue(value.contents, pending) as Record<string, unknown>,
+        ),
+      );
+      promise.catch(() => {});
+      return promise;
+    }
+    if (value.tag === "type") {
       const { __type, data } = value.contents as {
         __type: string;
         data: unknown;
       };
       const serializer = typeRegistry.get(__type);
-      if (serializer) {
-        return serializer.deserialize(data);
+      if (!serializer) {
+        throw new Error(`No deserializer registered for type "${__type}"`);
       }
-      console.warn(`No deserializer registered for type "${__type}"`);
-      return data;
+      return serializer.deserialize(restoreValue(data, pending));
     }
-
-    if (tagNum === ERROR_TAG) {
-      return deserializeError(value.contents as Record<string, unknown>);
+    if (value.tag === "error") {
+      return deserializeError(
+        restoreValue(value.contents, pending) as Record<string, unknown>,
+      );
     }
-
-    return restoreValue(value.contents);
-  }
-
-  if (Array.isArray(value)) {
-    return value.map(restoreValue);
-  }
-
-  if (value instanceof Date) {
-    return value;
+    throw new Error(`Unknown tagged JSON tag: ${String(value.tag)}`);
   }
-
+  if (Array.isArray(value)) return value.map((v) => restoreValue(v, pending));
+  if (value instanceof Date || value === null) return value;
   if (typeof value === "object") {
     const result: Record<string, unknown> = {};
     for (const [key, val] of Object.entries(value)) {
-      defineOwnValue(result, key, restoreValue(val));
+      defineOwnValue(result, key, restoreValue(val, pending));
     }
     return result;
   }
-
   return value;
 }
 
-export function cborEncode(data: unknown): Uint8Array {
-  return encode(data);
+export async function serializeLoaderData(data: unknown): Promise<string> {
+  return JSON.stringify(toTaggedJson(await processValue(data)));
 }
 
-export function cborDecode<T = unknown>(data: Uint8Array): T {
-  return decode(data) as T;
+export function deserializeLoaderData<T = unknown>(data: string): T {
+  return restoreValue(fromTaggedJson(JSON.parse(data))) as T;
 }
 
-/**
- * Serialize loader/action data for client-side data requests.
- * Processes promises, errors, and custom types before CBOR encoding.
- *
- * @param data - The loader/action data to serialize
- * @returns The CBOR encoded data as Uint8Array
- */
-export async function serializeLoaderData(data: unknown): Promise<Uint8Array> {
-  const processed = await processValue(data);
-  return encode(processed);
+interface PendingPromises {
+  nextId: number;
+  entries: { id: string; promise: PromiseLike<unknown> }[];
 }
 
-/**
- * Deserialize loader/action data from client-side data requests.
- * Decodes CBOR and restores promises, errors, and custom types from tags.
- *
- * @param data - The CBOR encoded data
- * @returns The deserialized data with promises and custom types restored
- */
-export function deserializeLoaderData<T = unknown>(data: Uint8Array): T {
-  const decoded = decode(data);
-  return restoreValue(decoded) as T;
-}
-
-interface PendingPromise {
-  id: string;
-  promise: PromiseLike<unknown>;
-}
-
-/**
- * Check if a value contains any promises (thenables).
- * Used to determine if streaming should be used.
- */
 export function containsPromises(value: unknown): boolean {
-  if (value === null || value === undefined) {
-    return false;
-  }
-
-  if (isThenable(value)) {
-    return true;
-  }
-
-  if (Array.isArray(value)) {
-    return value.some(containsPromises);
-  }
-
+  if (value === null || value === undefined) return false;
+  if (isThenable(value)) return true;
   if (typeof value === "object") {
     return Object.values(value).some(containsPromises);
   }
-
   return false;
 }
 
-/**
- * Process a value for streaming, replacing promises with pending tags.
- * Returns the processed structure and a list of pending promises with their IDs.
- */
 function processValueForStreaming(
   value: unknown,
-  pendingPromises: PendingPromise[],
-  idPrefix = "p",
+  pending: PendingPromises,
 ): unknown {
-  if (value === null || value === undefined) {
-    return value;
-  }
-
+  if (value === null || value === undefined) return value;
   if (isThenable(value)) {
-    const id = `${idPrefix}${pendingPromises.length}`;
-    pendingPromises.push({ id, promise: value });
-    return new Tag(PROMISE_PENDING_TAG, id);
+    const id = `p${pending.nextId++}`;
+    pending.entries.push({ id, promise: value });
+    return new Tagged("pending", id);
   }
-
   if (value instanceof Error || isHttpErrorLike(value)) {
-    return new Tag(ERROR_TAG, serializeError(value));
+    return new Tagged(
+      "error",
+      processValueForStreaming(serializeError(value), pending),
+    );
   }
-
-  const typeSerializer = findTypeSerializer(value);
-  if (typeSerializer) {
-    return new Tag(CUSTOM_TYPE_TAG, {
-      __type: typeSerializer.name,
-      data: typeSerializer.serialize(value),
+  const serializer = findTypeSerializer(value);
+  if (serializer) {
+    return new Tagged("type", {
+      __type: serializer.name,
+      data: processValueForStreaming(serializeType(value, serializer), pending),
     });
   }
-
   if (Array.isArray(value)) {
-    return value.map((v, i) =>
-      processValueForStreaming(v, pendingPromises, `${idPrefix}${i}_`)
-    );
-  }
-
-  if (value instanceof Date) {
-    return value;
+    return value.map((v) => processValueForStreaming(v, pending));
   }
-
+  if (value instanceof Date) return value;
   if (typeof value === "object") {
     const result: Record<string, unknown> = {};
     for (const [key, val] of Object.entries(value)) {
-      defineOwnValue(
-        result,
-        key,
-        processValueForStreaming(val, pendingPromises, `${idPrefix}${key}_`),
-      );
+      defineOwnValue(result, key, processValueForStreaming(val, pending));
     }
     return result;
   }
-
   return value;
 }
 
-/**
- * Encode a length-prefixed CBOR chunk.
- * Format: 4-byte big-endian length + CBOR data
- */
-function encodeLengthPrefixedChunk(data: unknown): Uint8Array {
-  const cborData = encode(data);
-  const chunk = new Uint8Array(4 + cborData.length);
-  const view = new DataView(chunk.buffer);
-  view.setUint32(0, cborData.length, false);
-  chunk.set(cborData, 4);
-  return chunk;
-}
-
-/**
- * Resolution message sent for each resolved/rejected promise.
- */
 interface PromiseResolution {
   id: string;
   status: "resolved" | "rejected";
   value?: unknown;
-  error?: Record<string, unknown>;
+  error?: unknown;
 }
 
-/**
- * Create a streaming response for loader data with deferred promises.
- * Returns a ReadableStream that emits length-prefixed CBOR chunks:
- * 1. Initial chunk: data structure with pending promise placeholders
- * 2. Subsequent chunks: promise resolutions as they complete
- *
- * @param data - The loader data (may contain promises)
- * @returns A ReadableStream of CBOR chunks
- */
-export function createStreamingLoaderData(
+function prepareData(
   data: unknown,
-): ReadableStream<Uint8Array> {
-  const pendingPromises: PendingPromise[] = [];
-  const processedData = processValueForStreaming(data, pendingPromises);
+): { processed: unknown; pending: PendingPromises } {
+  const pending: PendingPromises = { nextId: 0, entries: [] };
+  try {
+    return { processed: processValueForStreaming(data, pending), pending };
+  } catch (error) {
+    for (const entry of pending.entries) {
+      Promise.resolve(entry.promise).catch(() => {});
+    }
+    throw error;
+  }
+}
 
+function createDataStream(
+  processed: unknown,
+  pending: PendingPromises,
+  signal?: AbortSignal,
+): ReadableStream<Uint8Array> {
+  const encoder = new TextEncoder();
+  let ready: PromiseResolution[] = [];
+  let readIndex = 0;
+  let waiting: (() => void) | undefined;
+  let outstanding = 0;
+  let initial = true;
+  let stopped = false;
+  let controller: ReadableStreamDefaultController<Uint8Array>;
+  function stop(): void {
+    stopped = true;
+    ready = [];
+    signal?.removeEventListener("abort", abort);
+    waiting?.();
+    waiting = undefined;
+  }
+  function abort(): void {
+    if (stopped) return;
+    controller.error(signal!.reason);
+    stop();
+  }
+  function settle(resolution: PromiseResolution): void {
+    outstanding--;
+    if (stopped) return;
+    ready.push(resolution);
+    waiting?.();
+    waiting = undefined;
+  }
+  function observePending(): void {
+    for (const { id, promise } of pending.entries.splice(0)) {
+      outstanding++;
+      Promise.resolve(promise).then(
+        (value) => settle({ id, status: "resolved", value }),
+        (error) => settle({ id, status: "rejected", error }),
+      );
+    }
+  }
   return new ReadableStream<Uint8Array>({
-    async start(controller) {
-      const initialChunk = encodeLengthPrefixedChunk(processedData);
-      controller.enqueue(initialChunk);
-
-      if (pendingPromises.length === 0) {
-        controller.close();
-        return;
-      }
-
-      const resolutionPromises = pendingPromises.map(
-        async ({ id, promise }) => {
-          try {
-            const resolved = await promise;
-            const processedValue = await processValue(resolved);
-            const resolution: PromiseResolution = {
-              id,
-              status: "resolved",
-              value: processedValue,
-            };
-            return encodeLengthPrefixedChunk(resolution);
-          } catch (error) {
-            const resolution: PromiseResolution = {
-              id,
-              status: "rejected",
-              error: serializeError(sanitizeServerError(error)),
-            };
-            return encodeLengthPrefixedChunk(resolution);
+    start(c) {
+      controller = c;
+      observePending();
+      signal?.addEventListener("abort", abort, { once: true });
+      if (signal?.aborted) abort();
+    },
+    async pull(c) {
+      if (stopped) return;
+      try {
+        if (initial) {
+          initial = false;
+          c.enqueue(
+            encoder.encode(JSON.stringify(toTaggedJson(processed)) + "\n"),
+          );
+          processed = undefined;
+        } else {
+          while (!stopped && readIndex === ready.length && outstanding > 0) {
+            const wake = Promise.withResolvers<void>();
+            waiting = wake.resolve;
+            await wake.promise;
           }
-        },
-      );
-
-      const remaining = [...resolutionPromises];
-      while (remaining.length > 0) {
-        const { chunk, index } = await Promise.race(
-          remaining.map((p, i) => p.then((chunk) => ({ chunk, index: i }))),
-        );
-        controller.enqueue(chunk);
-        remaining.splice(index, 1);
+          if (stopped) return;
+          const resolution = ready[readIndex++];
+          if (resolution) {
+            let line: PromiseResolution;
+            try {
+              line = resolution.status === "resolved"
+                ? {
+                  id: resolution.id,
+                  status: "resolved",
+                  value: toTaggedJson(
+                    processValueForStreaming(resolution.value, pending),
+                  ),
+                }
+                : {
+                  id: resolution.id,
+                  status: "rejected",
+                  error: toTaggedJson(
+                    processValueForStreaming(
+                      serializeError(sanitizeServerError(resolution.error)),
+                      pending,
+                    ),
+                  ),
+                };
+            } catch (error) {
+              line = {
+                id: resolution.id,
+                status: "rejected",
+                error: toTaggedJson(
+                  processValueForStreaming(
+                    serializeError(sanitizeServerError(error)),
+                    pending,
+                  ),
+                ),
+              };
+            } finally {
+              observePending();
+            }
+            c.enqueue(encoder.encode(JSON.stringify(line) + "\n"));
+          }
+          if (readIndex >= ready.length) {
+            ready = [];
+            readIndex = 0;
+          }
+        }
+        if (outstanding === 0 && ready.length === 0) {
+          c.close();
+          stop();
+        }
+      } catch (error) {
+        c.error(error);
+        stop();
       }
-
-      controller.close();
     },
-  });
+    cancel() {
+      stop();
+    },
+  }, { highWaterMark: 0 });
 }
 
-function restoreValueWithPendingPromises(
-  value: unknown,
-  promiseResolvers: Map<string, {
-    resolve: (value: unknown) => void;
-    reject: (error: unknown) => void;
-  }>,
-): unknown {
-  if (value === null || value === undefined) {
-    return value;
-  }
-
-  if (value instanceof Tag) {
-    const tagNum = Number(value.tag);
-
-    if (tagNum === PROMISE_PENDING_TAG) {
-      const id = value.contents as string;
-      const { promise, resolve, reject } = Promise.withResolvers<unknown>();
-      promiseResolvers.set(id, { resolve, reject });
-      return promise;
-    }
-
-    if (tagNum === PROMISE_RESOLVED_TAG) {
-      const restored = restoreValueWithPendingPromises(
-        value.contents,
-        promiseResolvers,
-      );
-      return Promise.resolve(restored);
-    }
-
-    if (tagNum === PROMISE_REJECTED_TAG) {
-      const error = deserializeError(value.contents as Record<string, unknown>);
-      return Promise.reject(error);
-    }
-
-    if (tagNum === CUSTOM_TYPE_TAG) {
-      const { __type, data } = value.contents as {
-        __type: string;
-        data: unknown;
-      };
-      const serializer = typeRegistry.get(__type);
-      if (serializer) {
-        return serializer.deserialize(data);
-      }
-      console.warn(`No deserializer registered for type "${__type}"`);
-      return data;
-    }
-
-    if (tagNum === ERROR_TAG) {
-      return deserializeError(value.contents as Record<string, unknown>);
-    }
-
-    return restoreValueWithPendingPromises(value.contents, promiseResolvers);
-  }
-
-  if (Array.isArray(value)) {
-    return value.map((v) =>
-      restoreValueWithPendingPromises(v, promiseResolvers)
-    );
-  }
-
-  if (value instanceof Date) {
-    return value;
-  }
+export function createStreamingLoaderData(
+  data: unknown,
+  signal?: AbortSignal,
+): ReadableStream<Uint8Array> {
+  const { processed, pending } = prepareData(data);
+  return createDataStream(processed, pending, signal);
+}
 
-  if (typeof value === "object") {
-    const result: Record<string, unknown> = {};
-    for (const [key, val] of Object.entries(value)) {
-      defineOwnValue(
-        result,
-        key,
-        restoreValueWithPendingPromises(val, promiseResolvers),
-      );
-    }
-    return result;
+export function createLoaderDataResponse(
+  data: unknown,
+  signal?: AbortSignal,
+): Response {
+  const { processed, pending } = prepareData(data);
+  if (pending.entries.length) {
+    return new Response(createDataStream(processed, pending, signal), {
+      headers: {
+        "Content-Type": "application/x-ndjson",
+        "X-Juniper": "data",
+        "Cache-Control": "no-transform",
+      },
+    });
   }
-
-  return value;
+  const bytes = new TextEncoder().encode(
+    JSON.stringify(toTaggedJson(processed)),
+  );
+  return new Response(bytes, {
+    headers: {
+      "Content-Type": "application/json",
+      "Content-Length": String(bytes.length),
+      "X-Juniper": "data",
+    },
+  });
 }
 
-function createLengthPrefixedReader(
-  reader: ReadableStreamDefaultReader<Uint8Array>,
-): () => Promise<Uint8Array | null> {
-  let buffer = new Uint8Array(0);
-
+function createLineReader(
+  reader: ReadableStreamDefaultReader<string>,
+): () => Promise<string | null> {
+  let fragments: string[] = [];
+  let buffer = "";
+  let offset = 0;
   return async () => {
-    while (buffer.length < 4) {
-      const { done, value } = await reader.read();
-      if (done) {
-        if (buffer.length === 0) return null;
-        throw new Error("Unexpected end of stream while reading chunk length");
+    while (true) {
+      const end = buffer.indexOf("\n", offset);
+      if (end !== -1) {
+        fragments.push(buffer.slice(offset, end));
+        const line = fragments.join("");
+        fragments = [];
+        offset = end + 1;
+        return line;
       }
-      const newBuffer = new Uint8Array(buffer.length + value.length);
-      newBuffer.set(buffer);
-      newBuffer.set(value, buffer.length);
-      buffer = newBuffer;
-    }
-
-    const view = new DataView(buffer.buffer, buffer.byteOffset);
-    const length = view.getUint32(0, false);
-
-    while (buffer.length < 4 + length) {
-      const { done, value } = await reader.read();
-      if (done) {
-        throw new Error("Unexpected end of stream while reading chunk data");
+      if (offset < buffer.length) fragments.push(buffer.slice(offset));
+      const next = await reader.read();
+      if (next.done) {
+        const line = fragments.length ? fragments.join("") : null;
+        fragments = [];
+        buffer = "";
+        offset = 0;
+        return line;
       }
-      const newBuffer = new Uint8Array(buffer.length + value.length);
-      newBuffer.set(buffer);
-      newBuffer.set(value, buffer.length);
-      buffer = newBuffer;
+      buffer = next.value;
+      offset = 0;
     }
-
-    const chunkData = buffer.slice(4, 4 + length);
-    buffer = buffer.slice(4 + length);
-    return chunkData;
   };
 }
-/**
- * Deserialize streaming loader data from a Response.
- * Reads the stream and returns the data structure with promises that
- * will be resolved as resolution messages arrive.
- *
- * @param response - The streaming Response from the server
- * @returns The deserialized data with live promises
- */
+
 export async function deserializeStreamingLoaderData<T = unknown>(
   response: Response,
 ): Promise<T> {
-  const reader = response.body!.getReader();
-  const promiseResolvers = new Map<
-    string,
-    { resolve: (value: unknown) => void; reject: (error: unknown) => void }
-  >();
-
-  const readChunk = createLengthPrefixedReader(reader);
+  if (!response.body) throw new Error("Empty data response");
+  const reader = response.body.pipeThrough(new TextDecoderStream()).getReader();
+  const pending: PromiseResolvers = new Map();
+  const readLine = createLineReader(reader);
+  function rejectPending(error: unknown): void {
+    for (const resolver of pending.values()) resolver.reject(error);
+    pending.clear();
+  }
   let data: unknown;
   try {
-    const initialChunk = await readChunk();
-    if (!initialChunk) throw new Error("Empty streaming response");
-    data = restoreValueWithPendingPromises(
-      decode(initialChunk),
-      promiseResolvers,
-    );
+    const line = await readLine();
+    if (line === null) throw new Error("Empty data response");
+    data = restoreValue(fromTaggedJson(JSON.parse(line)), pending);
   } catch (error) {
-    reader.cancel(error).catch(() => {});
+    rejectPending(error);
+    await reader.cancel(error).catch(() => {});
     reader.releaseLock();
     throw error;
   }
-
-  if (promiseResolvers.size > 0) {
+  if (!pending.size) {
+    await reader.cancel().catch(() => {});
+    reader.releaseLock();
+  } else {
     (async () => {
       try {
-        let chunk: Uint8Array | null;
-        while ((chunk = await readChunk()) !== null) {
-          const resolution = decode(chunk) as PromiseResolution;
-          const resolver = promiseResolvers.get(resolution.id);
-          if (resolver) {
+        let line: string | null;
+        while ((line = await readLine()) !== null) {
+          const resolution = JSON.parse(line) as PromiseResolution;
+          const resolver = pending.get(resolution.id);
+          if (!resolver) continue;
+          pending.delete(resolution.id);
+          try {
             if (resolution.status === "resolved") {
-              const restoredValue = restoreValue(resolution.value);
-              resolver.resolve(restoredValue);
+              resolver.resolve(
+                restoreValue(fromTaggedJson(resolution.value), pending),
+              );
+            } else if (resolution.status === "rejected") {
+              resolver.reject(
+                deserializeError(
+                  restoreValue(
+                    fromTaggedJson(resolution.error),
+                    pending,
+                  ) as Record<string, unknown>,
+                ),
+              );
             } else {
-              const error = deserializeError(resolution.error!);
-              resolver.reject(error);
+              throw new Error("Invalid promise resolution status");
             }
-            promiseResolvers.delete(resolution.id);
+          } catch (error) {
+            resolver.reject(error);
           }
         }
-        if (promiseResolvers.size > 0) {
+        if (pending.size) {
           throw new Error(
             "Unexpected end of stream before all promises resolved",
           );
         }
       } catch (error) {
-        for (const resolver of promiseResolvers.values()) {
-          resolver.reject(error);
-        }
-        promiseResolvers.clear();
-        reader.cancel(error).catch(() => {});
+        rejectPending(error);
+        await reader.cancel(error).catch(() => {});
       } finally {
         reader.releaseLock();
       }
     })();
-  } else {
-    reader.cancel().catch(() => {});
-    reader.releaseLock();
   }
   return data as T;
 }
 
-/**
- * Encode data as base64 of CBOR, the version 2 hydration payload format.
- * Only tests produce it now; documents rendered before version 3 still carry it.
- *
- * @param data - The data to encode
- * @returns The base64 encoded string
- */
-export function encodeToBase64(data: unknown): string {
-  const bytes = cborEncode(data);
-  let binary = "";
-  for (let offset = 0; offset < bytes.length; offset += 32768) {
-    binary += String.fromCharCode(...bytes.subarray(offset, offset + 32768));
-  }
-  return btoa(binary);
-}
-
-/**
- * Decode data from a base64 string.
- *
- * @param base64 - The base64 string to decode
- * @returns The decoded data
- */
-export function decodeFromBase64<T = unknown>(base64: string): T {
-  const binary = atob(base64);
-  const bytes = new Uint8Array(binary.length);
-  for (let i = 0; i < binary.length; i++) {
-    bytes[i] = binary.charCodeAt(i);
-  }
-  return cborDecode<T>(bytes);
-}
-
 /**
  * Serialize all registered context from RouterContextProvider.
  *
@@ -811,10 +693,10 @@ export function serializeAllContext(
       const value = routerContext.get(serializer.context as any);
       const data = serializer.serialize(value);
       if (data !== undefined) {
-        result[name] = data;
+        defineOwnValue(result, name, data);
       }
     } catch {
-      // skip
+      continue;
     }
   }
 
@@ -839,171 +721,10 @@ export function deserializeAllContext(
   }
 }
 
-/**
- * A JSON value as it appears in the version 3 hydration payload: plain JSON,
- * with values JSON cannot carry replaced by `{"$t": tag, "v": value}` objects.
- */
-export type TaggedJson =
-  | null
-  | boolean
-  | number
-  | string
-  | TaggedJson[]
-  | { [key: string]: TaggedJson };
-
-const JSON_TAG_KEY = "$t";
-const JSON_VALUE_KEY = "v";
-
-function tagged(tag: string | number, value?: TaggedJson): TaggedJson {
-  return value === undefined
-    ? { [JSON_TAG_KEY]: tag }
-    : { [JSON_TAG_KEY]: tag, [JSON_VALUE_KEY]: value };
-}
-
-function collapseBigIntLikeCbor(value: bigint): number | bigint {
-  return cborDecode<number | bigint>(cborEncode(value));
-}
-
-function numberToTaggedJson(value: number): TaggedJson {
-  if (Number.isNaN(value)) return tagged("number", "NaN");
-  if (value === Infinity) return tagged("number", "Infinity");
-  if (value === -Infinity) return tagged("number", "-Infinity");
-  if (Object.is(value, -0)) return tagged("number", "-0");
-  return value;
-}
-
-function mustEscapeObjectKeys(keys: string[]): boolean {
-  return keys.includes(JSON_TAG_KEY) || keys.includes("__proto__");
-}
-
-/**
- * Converts a processed value (the output of `processValue`) into JSON-safe
- * tagged form. Decodes back through `fromTaggedJson` into exactly what CBOR
- * decoding of the same value produces, so `restoreValue` treats both alike.
- *
- * @throws {TypeError} For functions and symbols, which CBOR also refuses.
- */
-export function toTaggedJson(value: unknown): TaggedJson {
-  if (value === undefined) return tagged("undefined");
-  if (value === null || typeof value === "boolean") return value;
-  if (typeof value === "string") return value.toWellFormed();
-  if (typeof value === "number") return numberToTaggedJson(value);
-  if (typeof value === "bigint") {
-    const collapsed = collapseBigIntLikeCbor(value);
-    return typeof collapsed === "number"
-      ? collapsed
-      : tagged("bigint", collapsed.toString());
-  }
-  if (typeof value === "function" || typeof value === "symbol") {
-    throw new TypeError(`Cannot serialize a ${typeof value} value`);
-  }
-  if (value instanceof Tag) {
-    return tagged(Number(value.tag), toTaggedJson(value.contents));
-  }
-  if (value instanceof Date) {
-    return tagged("Date", numberToTaggedJson(value.getTime()));
-  }
-  if (Array.isArray(value)) return Array.from(value, toTaggedJson);
-
-  const entries = Object.entries(value as Record<string, unknown>).map((
-    [key, entry],
-  ): [string, TaggedJson] => [key.toWellFormed(), toTaggedJson(entry)]);
-  if (mustEscapeObjectKeys(entries.map(([key]) => key))) {
-    return tagged("object", entries);
-  }
-  return Object.fromEntries(entries);
-}
-
-function objectFromEntries(
-  entries: [string, unknown][],
-): Record<string, unknown> {
-  const result: Record<string, unknown> = {};
-  for (const [key, entry] of entries) {
-    Object.defineProperty(result, key, {
-      value: fromTaggedJson(entry),
-      enumerable: true,
-      writable: true,
-      configurable: true,
-    });
-  }
-  return result;
-}
-
-function fromTag(tag: unknown, value: unknown): unknown {
-  if (typeof tag === "number") return new Tag(tag, fromTaggedJson(value));
-  switch (tag) {
-    case "undefined":
-      return undefined;
-    case "number":
-      return Number(value);
-    case "bigint":
-      return BigInt(value as string);
-    case "Date":
-      return new Date(fromTaggedJson(value) as number);
-    case "object":
-      return objectFromEntries(value as [string, unknown][]);
-  }
-  throw new Error(`Unknown hydration data tag: ${String(tag)}`);
-}
-
-/**
- * Converts the tagged JSON of a version 3 payload back into the value CBOR
- * decoding would have produced, ready for `restoreValue`.
- *
- * @throws {Error} On a tag this version of Juniper does not know.
- */
-export function fromTaggedJson(value: unknown): unknown {
-  if (value === null || typeof value !== "object") return value;
-  if (Array.isArray(value)) return value.map(fromTaggedJson);
-  const record = value as Record<string, unknown>;
-  if (Object.hasOwn(record, JSON_TAG_KEY)) {
-    return fromTag(record[JSON_TAG_KEY], record[JSON_VALUE_KEY]);
-  }
-  return objectFromEntries(Object.entries(record));
-}
-
-/**
- * Serializes a value as JSON text that is safe to place inside an inline
- * `<script>` element: `<` and the U+2028/U+2029 line terminators are written
- * as escapes, so no string in the value can close the element, open a comment,
- * or end a line in an older JavaScript parser.
- */
-export function toInlineScriptJson(value: unknown): string {
-  return JSON.stringify(value)
-    .replaceAll("<", "\\u003c")
-    .replaceAll("\u2028", "\\u2028")
-    .replaceAll("\u2029", "\\u2029");
-}
-
-/** Version 2 hydration payload: loader data as base64 of CBOR. */
-export interface SerializedHydrationDataV2 {
-  /** Version identifier for compatibility checking */
-  version: 2;
-  /** Base64 encoded CBOR data */
-  data: string;
-  /** Public environment variables */
-  publicEnv?: Record<string, string>;
-}
-
-/** Version 3 hydration payload: loader data as tagged JSON. */
-export interface SerializedHydrationDataV3 {
-  /** Version identifier for compatibility checking */
+export interface SerializedHydrationData {
   version: 3;
-  /** Tagged JSON data */
   data: TaggedJson;
-  /** Public environment variables */
-  publicEnv?: Record<string, string>;
 }
-
-/**
- * Hydration data as embedded in the document. The server writes version 3;
- * the client also reads version 2, which documents cached before the upgrade
- * still carry.
- */
-export type SerializedHydrationData =
-  | SerializedHydrationDataV2
-  | SerializedHydrationDataV3;
-
 /**
  * Hydration data structure.
  */
@@ -1028,78 +749,49 @@ export interface HydrationData {
   buildId?: string;
 }
 
-/**
- * Applies server error privacy and resolves promises in hydration data,
- * producing the value every payload version encodes. Exported so tests can
- * build a version 2 payload from the same input.
- */
-export async function processHydrationData(
+function registeredNames(): string[] {
+  return [
+    ...Array.from(typeRegistry.keys(), (name) => `type:${name}`),
+    ...Array.from(errorRegistry.keys(), (name) => `error:${name}`),
+    ...Array.from(contextRegistry.keys(), (name) => `context:${name}`),
+  ].sort();
+}
+
+export async function serializeHydrationData(
   hydrationData: HydrationData,
-): Promise<unknown> {
-  const { publicEnv: _publicEnv, errors, ...rest } = hydrationData;
-  return await processValue({
+): Promise<SerializedHydrationData> {
+  const { errors, ...rest } = hydrationData;
+  const processed = await processValue({
     ...rest,
     errors: errors && Object.fromEntries(
       Object.entries(errors).map((
         [id, error],
       ) => [id, sanitizeServerError(error)]),
     ),
+    ...(isDevelopment() ? { registeredNames: registeredNames() } : {}),
   });
+  return { version: 3, data: toTaggedJson(processed) };
 }
 
-/**
- * Serialize hydration data for embedding in HTML.
- *
- * @param hydrationData - The hydration data to serialize
- * @returns The serialized hydration data
- */
-export async function serializeHydrationData(
-  hydrationData: HydrationData,
-): Promise<SerializedHydrationDataV3> {
-  return {
-    version: 3,
-    data: toTaggedJson(await processHydrationData(hydrationData)),
-    publicEnv: hydrationData.publicEnv,
-  };
-}
-
-function decodeHydrationPayload(
-  serialized: SerializedHydrationData,
-): unknown {
-  if (serialized.version === 3) return fromTaggedJson(serialized.data);
-  if (serialized.version === 2) return decodeFromBase64(serialized.data);
-  throw new Error(
-    `Unsupported hydration data version: ${
-      String((serialized as { version: unknown }).version)
-    }`,
-  );
-}
-
-/**
- * Deserialize hydration data from the serialized format.
- *
- * @param serialized - The serialized hydration data
- * @returns The deserialized hydration data
- * @throws {Error} If the payload version is neither 2 nor 3.
- */
 export function deserializeHydrationData(
   serialized: SerializedHydrationData,
 ): HydrationData {
-  const restored = restoreValue(decodeHydrationPayload(serialized)) as {
-    serializedContext?: unknown;
-    matches: { id: string }[];
-    errors?: Record<string, unknown> | null;
-    loaderData?: Record<string, unknown> | null;
-    actionData?: Record<string, unknown> | null;
-    buildId?: string;
-  };
-
+  const decoded = decodeHydrationPayload(serialized);
+  if (Array.isArray(decoded.registeredNames)) {
+    const available = new Set(registeredNames());
+    const missing = decoded.registeredNames.filter((name) =>
+      !available.has(name)
+    );
+    if (missing.length) {
+      console.error(`Missing Juniper registrations: ${missing.join(", ")}`);
+    }
+  }
+  const restored = restoreValue(decoded) as HydrationData;
   return {
-    publicEnv: serialized.publicEnv,
+    publicEnv: restored.publicEnv,
     serializedContext: restored.serializedContext,
     buildId: restored.buildId,
     matches: restored.matches,
-    // React Router needs undefined, not null, for these fields.
     errors: restored.errors ?? undefined,
     loaderData: restored.loaderData ?? undefined,
     actionData: restored.actionData ?? undefined,
@@ -1107,23 +799,13 @@ export function deserializeHydrationData(
 }
 
 function initializeBuiltInSerializers(): void {
-  // Order matters: HttpError before generic Error, generic Error registered last as fallback.
   _addErrorSerializer<HttpError>({
     name: "HttpError",
     is: (e): e is HttpError => e instanceof HttpError || isHttpErrorLike(e),
     serialize: (error) => {
-      // `exposedMessage`, never `message`: this payload reaches the browser
-      // through client-navigation data errors and the SSR hydration script, and
-      // `message` is where an app puts detail meant for its own logs. The
-      // rendering layer already drew this boundary; the wire did not, so an
-      // internal message shipped to every client on a data-error path.
       const serialized: Record<string, unknown> = {
         message: error.exposedMessage,
         status: error.status,
-        // Everything written above is exposable by construction, so the flag
-        // says so rather than replaying a server-side decision the client
-        // cannot act on: `expose: false` here would make the deserialized
-        // error's `exposedMessage` disagree with the text it was handed.
         expose: true,
       };
       if (error.instance !== undefined) serialized.instance = error.instance;
@@ -1135,9 +817,11 @@ function initializeBuiltInSerializers(): void {
     deserialize: (data) => {
       const error = new HttpError(
         data.status as number,
-        data.message as string,
+        {
+          message: data.message as string,
+          expose: data.expose as boolean | undefined,
+        },
       );
-      if (data.expose !== undefined) error.expose = data.expose as boolean;
       if (data.instance !== undefined) error.instance = data.instance as string;
       if (data.stack) error.stack = data.stack as string;
       return error;
diff --git a/src/_serialization_hydration.test.ts b/src/_serialization_hydration.test.ts
index bf634ee..5d78f9c 100644
--- a/src/_serialization_hydration.test.ts
+++ b/src/_serialization_hydration.test.ts
@@ -1,8 +1,6 @@
 import {
-  assert,
   assertEquals,
   assertFalse,
-  assertInstanceOf,
   assertRejects,
   assertStringIncludes,
   assertThrows,
@@ -13,11 +11,8 @@ import { HttpError } from "@udibo/http-error";
 import { registerError, registerType } from "./mod.ts";
 import {
   deserializeHydrationData,
-  encodeToBase64,
-  processHydrationData,
   resetRegistries,
   type SerializedHydrationData,
-  type SerializedHydrationDataV2,
   serializeHydrationData,
   toInlineScriptJson,
 } from "./_serialization.ts";
@@ -63,20 +58,6 @@ function asEmbeddedInTheDocument(
   return new Function(`return ${toInlineScriptJson(serialized)};`)();
 }
 
-async function serializeV2(
-  loaderValue: unknown,
-): Promise<SerializedHydrationDataV2> {
-  return {
-    version: 2,
-    data: encodeToBase64(
-      await processHydrationData({
-        matches: [{ id: "/" }],
-        loaderData: { "/": { value: loaderValue } },
-      }),
-    ),
-  };
-}
-
 async function serializeV3(
   loaderValue: unknown,
 ): Promise<SerializedHydrationData> {
@@ -120,6 +101,16 @@ async function observed(value: unknown): Promise<unknown> {
       holes: value.length - Object.keys(value).length,
     };
   }
+  if (value instanceof Error) {
+    return {
+      name: value.name,
+      message: value instanceof HttpError
+        ? value.exposedMessage
+        : value.message,
+      ...(value instanceof HttpError ? { status: value.status } : {}),
+      ...(value instanceof CustomError ? { code: value.code } : {}),
+    };
+  }
   const object = value as Record<string, unknown>;
   const prototype = Object.getPrototypeOf(object);
   const own: [string, unknown][] = [];
@@ -153,14 +144,14 @@ function rejectedWith(error: unknown): Promise<never> {
 const loneLeadSurrogate = String.fromCharCode(0xd800);
 const loneTrailSurrogate = String.fromCharCode(0xdc00);
 
-const ROUND_TRIPS: [string, () => unknown][] = [
+const ROUND_TRIPS: [string, () => unknown, (() => unknown)?][] = [
   ["a Date", () => new Date("2026-09-11T12:34:56.789Z")],
   ["the epoch", () => new Date(0)],
   ["a Date before the epoch", () => new Date(-1)],
   ["an invalid Date", () => new Date(NaN)],
-  ["a bigint in the safe range, as CBOR collapses it", () => 123n],
-  ["the lowest bigint CBOR collapses", () => -(2n ** 53n)],
-  ["the lowest bigint CBOR keeps", () => 2n ** 53n],
+  ["a bigint in the safe range", () => 123n],
+  ["a large negative bigint", () => -(2n ** 53n)],
+  ["a large positive bigint", () => 2n ** 53n],
   ["a bigint beyond 64 bits", () => 2n ** 64n],
   ["a negative bigint beyond 64 bits", () => -(2n ** 64n) - 1n],
   ["NaN", () => NaN],
@@ -171,7 +162,7 @@ const ROUND_TRIPS: [string, () => unknown][] = [
   ["a fraction", () => 1.5],
   ["undefined", () => undefined],
   ["a key whose value is undefined", () => ({ kept: undefined })],
-  ["an array hole", () => [1, , 3]],
+  ["an array hole", () => [1, , 3], () => [1, undefined, 3]],
   ["an Error", () => new Error("plain")],
   ["a TypeError", () => new TypeError("typed")],
   ["an HttpError", () => new HttpError(404, "Missing")],
@@ -205,18 +196,22 @@ const ROUND_TRIPS: [string, () => unknown][] = [
     "an own __proto__ key in loader data",
     () => JSON.parse('{"__proto__":{"polluted":true},"kept":1}'),
   ],
-  ["a Map, flattened", () => new Map([["a", 1]])],
-  ["a Set, flattened", () => new Set([1])],
-  ["a RegExp, flattened", () => /x/g],
-  ["a URL, flattened", () => new URL("https://example.com/")],
-  ["a typed array, flattened", () => new Uint8Array([1, 2])],
+  ["a Map, flattened", () => new Map([["a", 1]]), () => ({})],
+  ["a Set, flattened", () => new Set([1]), () => ({})],
+  ["a RegExp, flattened", () => /x/g, () => ({})],
+  ["a URL, flattened", () => new URL("https://example.com/"), () => ({})],
+  [
+    "a typed array, flattened",
+    () => new Uint8Array([1, 2]),
+    () => ({ 0: 1, 1: 2 }),
+  ],
   ["a class instance, flattened", () =>
     new (class Box {
       inside = 1;
-    })()],
+    })(), () => ({ inside: 1 })],
   ["a lone surrogate", () => ({
     [`key${loneLeadSurrogate}`]: `value${loneTrailSurrogate}`,
-  })],
+  }), () => ({ "key�": "value�" })],
   ["markup and line separators", () => "</script><!--<script>\u2028\u2029"],
   ["nested data", () => ({
     list: [{ at: new Date(1), n: [NaN, -0, undefined] }],
@@ -234,12 +229,12 @@ describe("hydration payload version 3", () => {
     resetRegistries();
   });
 
-  describe("hydrates every value exactly as version 2 did", () => {
-    for (const [name, make] of ROUND_TRIPS) {
+  describe("round trips the supported values and documented flattening", () => {
+    for (const [name, make, expected] of ROUND_TRIPS) {
       it(name, async () => {
-        const v2 = hydratedValue(await serializeV2(make()));
+        const original = (expected ?? make)();
         const v3 = hydratedValue(await serializeV3(make()));
-        assertEquals(await observed(v3), await observed(v2));
+        assertEquals(await observed(v3), await observed(original));
       });
     }
   });
@@ -250,8 +245,7 @@ describe("hydration payload version 3", () => {
       ["a symbol", () => Symbol("private")],
     ] as const
   ) {
-    it(`refuses ${name}, as version 2 did`, async () => {
-      await assertRejects(() => serializeV2({ inside: make() }));
+    it(`refuses ${name}`, async () => {
       await assertRejects(() => serializeV3({ inside: make() }), TypeError);
     });
   }
@@ -290,61 +284,24 @@ describe("hydration payload version 3", () => {
           data: { matches: [], loaderData: { $t: "Map", v: [] } },
         }),
       Error,
-      "Unknown hydration data tag: Map",
+      "Unknown tagged JSON tag: Map",
     );
   });
 });
 
-const GOLDEN_V2: SerializedHydrationDataV2 = {
-  version: 2,
-  data:
-    "pXFzZXJpYWxpemVkQ29udGV4dKFkdXNlcqFkbmFtZWNBZGFnbWF0Y2hlc4GhYmlkYS9qbG9hZGVyRGF0YaFhL6pkZGF0ZcH7Qdqo/VwyfvpnbWlzc2luZ/djbmFu+X4AbG5lZ2F0aXZlWmVyb/mAAGVzbWFsbBh7Y2JpZ8JJAQAAAAAAAAAAZXBvaW502ZxComZfX3R5cGVlUG9pbnRkZGF0YaJheAFheQJlZXJyb3LZnEOka19fZXJyb3JUeXBlaUh0dHBFcnJvcmdtZXNzYWdlZ01pc3Npbmdmc3RhdHVzGQGUZmV4cG9zZfVoZGVmZXJyZWTZnEDBAGZmYWlsZWTZnEGka19fZXJyb3JUeXBlaUh0dHBFcnJvcmdtZXNzYWdlaUZvcmJpZGRlbmZzdGF0dXMZAZNmZXhwb3Nl9WdidWlsZElkZ2J1aWxkLTFmZXJyb3JzoWEv2ZxDpGtfX2Vycm9yVHlwZWlIdHRwRXJyb3JnbWVzc2FnZXgvVGhlIHNlcnZlciBlbmNvdW50ZXJlZCBhbiB1bmV4cGVjdGVkIGNvbmRpdGlvbi5mc3RhdHVzGQH0ZmV4cG9zZfU=",
-  publicEnv: { APP_NAME: "Golden" },
-};
-
-describe("hydration payload version 2", () => {
-  beforeEach(() => {
-    resetRegistries();
-    registerFixtures();
-  });
-
-  afterEach(() => {
-    resetRegistries();
-  });
-
-  it("still hydrates a document rendered by Juniper 0.11.5", async () => {
-    const hydration = deserializeHydrationData(
-      asEmbeddedInTheDocument(GOLDEN_V2),
-    );
-    assertEquals(hydration.publicEnv, { APP_NAME: "Golden" });
-    assertEquals(hydration.buildId, "build-1");
-    assertEquals(hydration.matches, [{ id: "/" }]);
-    assertEquals(hydration.serializedContext, { user: { name: "Ada" } });
-
-    const data = hydration.loaderData?.["/"] as Record<string, unknown>;
-    assertInstanceOf(data.date, Date);
-    assertEquals(data.date.toISOString(), "2026-09-11T12:34:56.789Z");
-    assert(Object.hasOwn(data, "missing") && data.missing === undefined);
-    assert(Number.isNaN(data.nan));
-    assert(Object.is(data.negativeZero, -0));
-    assertEquals(data.small, 123);
-    assertEquals(data.big, 2n ** 64n);
-    assertInstanceOf(data.point, Point);
-    assertEquals({ ...data.point }, { x: 1, y: 2 });
-    assertInstanceOf(data.error, HttpError);
-    assertEquals([data.error.status, data.error.message], [404, "Missing"]);
-    assertEquals(((await data.deferred) as Date).getTime(), 0);
-    await assertRejects(
-      () => data.failed as Promise<unknown>,
-      HttpError,
-      "Forbidden",
+describe("obsolete hydration formats", () => {
+  it("refuses a version 2 document without a fallback decoder", () => {
+    assertThrows(
+      () =>
+        deserializeHydrationData({
+          version: 2,
+          data: "obsolete-base64",
+        } as unknown as SerializedHydrationData),
+      Error,
+      "Unsupported hydration data version: 2",
     );
-    const error = hydration.errors?.["/"];
-    assertInstanceOf(error, HttpError);
-    assertEquals(error.message, new HttpError(500).exposedMessage);
   });
 });
-
 describe("toInlineScriptJson", () => {
   const hostile = "</script><script>alert(1)</script><!--<script>\u2028\u2029";
 
diff --git a/src/_serialization_wire.test.ts b/src/_serialization_wire.test.ts
new file mode 100644
index 0000000..eb0512a
--- /dev/null
+++ b/src/_serialization_wire.test.ts
@@ -0,0 +1,499 @@
+import {
+  assert,
+  assertEquals,
+  assertInstanceOf,
+  assertRejects,
+  assertThrows,
+} from "@std/assert";
+import { afterEach, beforeEach, describe, it } from "@std/testing/bdd";
+import { delay } from "@std/async/delay";
+import { stub } from "@std/testing/mock";
+import { HttpError, registerError, registerType } from "@udibo/juniper";
+import {
+  createLoaderDataResponse,
+  createStreamingLoaderData,
+  deserializeError,
+  deserializeHydrationData,
+  deserializeLoaderData,
+  deserializeStreamingLoaderData,
+  fromTaggedJson,
+  resetRegistries,
+  serializeError,
+  serializeHydrationData,
+  serializeLoaderData,
+  toTaggedJson,
+} from "./_serialization.ts";
+
+class Box {
+  constructor(public value: unknown) {}
+}
+
+const hostileObjects = [
+  { $t: "Date", v: 0 },
+  { $t: "type", v: { __type: "X", data: 1 } },
+  { $t: "object", v: [["admin", true]] },
+  { $t: "pending", v: "p0" },
+  JSON.parse('{"__proto__":{"isAdmin":true}}'),
+];
+
+describe("one tagged JSON wire format", () => {
+  beforeEach(resetRegistries);
+  afterEach(resetRegistries);
+
+  it("encodes settled data as tagged JSON text", async () => {
+    const text = await serializeLoaderData({ value: 123n });
+    assertEquals(typeof text, "string");
+    assertEquals(JSON.parse(String(text)), {
+      value: { $t: "bigint", v: "123" },
+    });
+  });
+
+  it("keeps every bigint including small values", () => {
+    for (const value of [0n, 123n, -(2n ** 53n), 2n ** 70n]) {
+      assertEquals(fromTaggedJson(toTaggedJson(value)), value);
+    }
+  });
+
+  it("keeps tag-shaped data through hydration, settled data and both stream positions", async () => {
+    registerType({
+      name: "Box",
+      is: (v): v is Box => v instanceof Box,
+      serialize: (v) => v.value,
+      deserialize: (v) => new Box(v),
+    });
+    const data = {
+      objects: hostileObjects,
+      nested: [hostileObjects],
+      box: new Box(hostileObjects),
+    };
+    const hydration = deserializeHydrationData(
+      await serializeHydrationData({
+        matches: [],
+        loaderData: { route: data },
+      }),
+    );
+    const settled = deserializeLoaderData(await serializeLoaderData(data));
+    const streaming = await deserializeStreamingLoaderData<
+      { initial: unknown; later: Promise<unknown> }
+    >(
+      new Response(
+        createStreamingLoaderData({
+          initial: data,
+          later: Promise.resolve(data),
+        }),
+      ),
+    );
+    for (
+      const value of [
+        hydration.loaderData?.route,
+        settled,
+        streaming.initial,
+        await streaming.later,
+      ]
+    ) {
+      assertEquals(value, data);
+    }
+  });
+
+  it("recursively restores serializer output with tag keys, own proto, Date, undefined and promises", async () => {
+    registerType({
+      name: "Box",
+      is: (v): v is Box => v instanceof Box,
+      serialize: (v) => v.value,
+      deserialize: (v) => new Box(v),
+    });
+    const value = JSON.parse('{"$t":"Date","v":5,"__proto__":{"x":1}}');
+    value.n = NaN;
+    value.date = new Date(9);
+    value.missing = undefined;
+    value.later = Promise.resolve(new Box(new Date(10)));
+    const result = deserializeLoaderData<Box>(
+      await serializeLoaderData(new Box(value)),
+    );
+    assertInstanceOf(result, Box);
+    const restored = result.value as typeof value;
+    assert(Object.hasOwn(restored, "__proto__"));
+    assertEquals(restored.$t, "Date");
+    assertEquals(restored.n, NaN);
+    assertEquals(restored.date, new Date(9));
+    assert(Object.hasOwn(restored, "missing"));
+    assertInstanceOf(restored.later, Promise);
+    assertEquals(await restored.later, new Box(new Date(10)));
+  });
+
+  it("refuses a serializer whose output matches itself", async () => {
+    registerType({
+      name: "Box",
+      is: (v): v is Box => v instanceof Box,
+      serialize: (v) => v,
+      deserialize: (v) => v,
+    });
+    await assertRejects(
+      () => serializeLoaderData(new Box(1)),
+      Error,
+      "matches its own",
+    );
+    assertThrows(
+      () => createStreamingLoaderData(new Box(1)),
+      Error,
+      "matches its own",
+    );
+  });
+
+  it("keeps registered names separate from error serializer data", () => {
+    class DomainError extends Error {}
+    registerError({
+      name: "DomainError",
+      is: (v): v is DomainError => v instanceof DomainError,
+      serialize: () => ({ __errorType: "TypeError", message: "own data" }),
+      deserialize: (data) => new DomainError(String(data.__errorType)),
+    });
+    const serialized = serializeError(new DomainError());
+    assertEquals(serialized.__errorType, "DomainError");
+    assertEquals(serialized.data, {
+      __errorType: "TypeError",
+      message: "own data",
+    });
+    assertInstanceOf(deserializeError(serialized), DomainError);
+  });
+
+  it("recursively processes error serializer output on every transport", async () => {
+    class DomainError extends Error {
+      constructor(public data: Record<string, unknown>) {
+        super("domain");
+      }
+    }
+    registerError({
+      name: "DomainError",
+      is: (value): value is DomainError => value instanceof DomainError,
+      serialize: (error) => error.data,
+      deserialize: (data) => new DomainError(data),
+    });
+    const data = {
+      __errorType: "TypeError",
+      hostile: hostileObjects,
+      at: new Date(5),
+      missing: undefined,
+      later: Promise.resolve(new Date(6)),
+    };
+    const error = new DomainError(data);
+    const hydration = deserializeHydrationData(
+      await serializeHydrationData({ matches: [], errors: { root: error } }),
+    );
+    const settled = deserializeLoaderData(await serializeLoaderData(error));
+    const streaming = await deserializeStreamingLoaderData<
+      { initial: DomainError; deferred: Promise<DomainError> }
+    >(
+      new Response(
+        createStreamingLoaderData({
+          initial: error,
+          deferred: Promise.reject(error),
+        }),
+      ),
+    );
+    const rejected = await assertRejects(() => streaming.deferred, DomainError);
+    for (
+      const restored of [
+        hydration.errors?.root,
+        settled,
+        streaming.initial,
+        rejected,
+      ]
+    ) {
+      assertInstanceOf(restored, DomainError);
+      assertEquals(restored.data.__errorType, "TypeError");
+      assertEquals(restored.data.hostile, hostileObjects);
+      assertEquals(restored.data.at, new Date(5));
+      assert(Object.hasOwn(restored.data, "missing"));
+      assertEquals(await restored.data.later, new Date(6));
+    }
+  });
+
+  it("rejects error serializer output matching its own predicate", async () => {
+    class DomainError extends Error {}
+    registerError({
+      name: "DomainError",
+      is: (value): value is DomainError =>
+        value instanceof DomainError ||
+        !!(value && typeof value === "object" &&
+          Object.hasOwn(value, "domain")),
+      serialize: () => ({ domain: true }),
+      deserialize: () => new DomainError(),
+    });
+    assertThrows(
+      () => serializeError(new DomainError()),
+      Error,
+      "matches its own",
+    );
+    await assertRejects(
+      () => serializeLoaderData(new DomainError()),
+      Error,
+      "matches its own",
+    );
+    assertThrows(
+      () => createStreamingLoaderData(new DomainError()),
+      Error,
+      "matches its own",
+    );
+  });
+
+  it("preserves an explicitly exposed 500 message through hydration, data and deferred rejection", async () => {
+    const error = new HttpError(500, {
+      message: "private",
+      exposedMessage: "Try again",
+    });
+    const hydration = deserializeHydrationData(
+      await serializeHydrationData({ matches: [], errors: { root: error } }),
+    );
+    const settled = deserializeLoaderData(await serializeLoaderData(error));
+    const streaming = await deserializeStreamingLoaderData<
+      { initial: HttpError; deferred: Promise<never> }
+    >(
+      new Response(
+        createStreamingLoaderData({
+          initial: error,
+          deferred: Promise.reject(error),
+        }),
+      ),
+    );
+    const rejected = await assertRejects(
+      () => streaming.deferred,
+      HttpError,
+      "Try again",
+    );
+    for (
+      const restored of [
+        hydration.errors?.root,
+        settled,
+        streaming.initial,
+        rejected,
+      ]
+    ) {
+      assertInstanceOf(restored, HttpError);
+      assertEquals(restored.message, "Try again");
+      assertEquals(restored.exposedMessage, "Try again");
+    }
+  });
+
+  it("fails closed on unknown type and error registrations", () => {
+    assertThrows(
+      () =>
+        deserializeHydrationData({
+          version: 3,
+          data: {
+            matches: [],
+            loaderData: {
+              route: { $t: "type", v: { __type: "Absent", data: 1 } },
+            },
+          },
+        }),
+      Error,
+      "No deserializer registered for type",
+    );
+    assertThrows(
+      () => deserializeError({ __errorType: "Absent", data: {} }),
+      Error,
+      "No deserializer registered for error",
+    );
+  });
+
+  it("rejects only a bad stream promise and continues decoding later promises", async () => {
+    const lines = [
+      { bad: { $t: "pending", v: "a" }, good: { $t: "pending", v: "b" } },
+      {
+        id: "a",
+        status: "resolved",
+        value: { $t: "type", v: { __type: "Absent", data: 1 } },
+      },
+      { id: "b", status: "resolved", value: { $t: "Date", v: 5 } },
+    ];
+    const result = await deserializeStreamingLoaderData<
+      { bad: Promise<unknown>; good: Promise<Date> }
+    >(
+      new Response(lines.map((line) => JSON.stringify(line)).join("\n") + "\n"),
+    );
+    await assertRejects(
+      () => result.bad,
+      Error,
+      "No deserializer registered for type",
+    );
+    assertEquals(await Promise.allSettled([result.good]), [{
+      status: "fulfilled",
+      value: new Date(5),
+    }]);
+  });
+
+  it("folds public environment into the only tagged hydration value", async () => {
+    const publicEnv = JSON.parse(
+      '{"$t":"Date","__proto__":"kept","APP_ENV":"test"}',
+    );
+    const payload = await serializeHydrationData({ matches: [], publicEnv });
+    assertEquals(Object.keys(payload), ["version", "data"]);
+    assertEquals(deserializeHydrationData(payload).publicEnv, publicEnv);
+  });
+
+  it("runs registered predicates before Array and Date and chooses the first match", async () => {
+    for (const name of ["First", "Second"]) {
+      registerType<Date | unknown[], string>({
+        name,
+        is: (v): v is Date | unknown[] => v instanceof Date || Array.isArray(v),
+        serialize: () => name,
+        deserialize: (v) => [v],
+      });
+    }
+    assertEquals(
+      deserializeLoaderData(await serializeLoaderData(new Date(1))),
+      ["First"],
+    );
+    assertEquals(deserializeLoaderData(await serializeLoaderData([1, 2])), [
+      "First",
+    ]);
+  });
+
+  it("discovers promises created by a serializer and streams nested promises progressively", async () => {
+    const first = Promise.withResolvers<unknown>();
+    const nested = Promise.withResolvers<unknown>();
+    registerType({
+      name: "Box",
+      is: (v): v is Box => v instanceof Box,
+      serialize: () => ({ first: first.promise }),
+      deserialize: (v) => new Box(v),
+    });
+    const response = createLoaderDataResponse(new Box(0));
+    assertEquals(response.headers.get("Content-Type"), "application/x-ndjson");
+    const result = await deserializeStreamingLoaderData<Box>(response);
+    const value = result.value as { first: Promise<{ nested: Promise<Date> }> };
+    assertInstanceOf(value.first, Promise);
+    first.resolve({ nested: nested.promise });
+    const next = await value.first;
+    assertInstanceOf(next.nested, Promise);
+    nested.resolve(new Date(8));
+    assertEquals(await next.nested, new Date(8));
+  });
+
+  it("encodes deferred values only when the consumer pulls", async () => {
+    let serializations = 0;
+    registerType({
+      name: "Box",
+      is: (v): v is Box => v instanceof Box,
+      serialize: (v) => {
+        serializations++;
+        return v.value;
+      },
+      deserialize: (v) => new Box(v),
+    });
+    const stream = createStreamingLoaderData({
+      later: Promise.resolve(new Box(3)),
+    });
+    const reader = stream.getReader();
+    await delay(0);
+    assertEquals(serializations, 0);
+    await reader.read();
+    await delay(0);
+    assertEquals(serializations, 0);
+    await reader.read();
+    assertEquals(serializations, 1);
+    assertEquals((await reader.read()).done, true);
+    reader.releaseLock();
+  });
+
+  it("aborts a waiting stream and stops processing later resolutions", async () => {
+    const controller = new AbortController();
+    const later = Promise.withResolvers<unknown>();
+    let serializations = 0;
+    registerType({
+      name: "Box",
+      is: (v): v is Box => v instanceof Box,
+      serialize: (v) => {
+        serializations++;
+        return v.value;
+      },
+      deserialize: (v) => new Box(v),
+    });
+    const reader = createStreamingLoaderData(
+      { later: later.promise },
+      controller.signal,
+    ).getReader();
+    await reader.read();
+    const next = reader.read();
+    controller.abort(new Error("request ended"));
+    await assertRejects(() => next, Error, "request ended");
+    later.resolve(new Box(4));
+    await delay(0);
+    assertEquals(serializations, 0);
+    reader.releaseLock();
+  });
+
+  it("detaches the request abort listener after cancellation and normal completion", async () => {
+    for (const cancel of [true, false]) {
+      const controller = new AbortController();
+      using removed = stub(
+        controller.signal,
+        "removeEventListener",
+        controller.signal.removeEventListener.bind(controller.signal),
+      );
+      const stream = createStreamingLoaderData(
+        { later: Promise.resolve(1) },
+        controller.signal,
+      );
+      if (cancel) await stream.cancel();
+      else await new Response(stream).text();
+      assertEquals(
+        removed.calls.filter((call) => call.args[0] === "abort").length,
+        1,
+      );
+    }
+  });
+
+  it("uses one text decoder for settled text, NDJSON, and byte-split Unicode", async () => {
+    const text = JSON.stringify(
+      toTaggedJson({ text: "水🌿\nhello", missing: undefined }),
+    );
+    for (const suffix of ["", "\n"]) {
+      const bytes = new TextEncoder().encode(text + suffix);
+      const response = new Response(
+        new ReadableStream({
+          start(c) {
+            for (const byte of bytes) c.enqueue(Uint8Array.of(byte));
+            c.close();
+          },
+        }),
+      );
+      assertEquals(await deserializeStreamingLoaderData(response), {
+        text: "水🌿\nhello",
+        missing: undefined,
+      });
+    }
+  });
+
+  it("rejects unknown string and obsolete numeric tags", () => {
+    for (const tag of [40000, 40002, "Absent"]) {
+      assertThrows(
+        () => fromTaggedJson({ $t: tag, v: 1 }),
+        Error,
+        "Unknown tagged JSON tag",
+      );
+    }
+  });
+
+  it("isolates an unknown error registration in a rejected stream line", async () => {
+    const lines = [
+      { bad: { $t: "pending", v: "a" }, good: { $t: "pending", v: "b" } },
+      {
+        id: "a",
+        status: "rejected",
+        error: { __errorType: "Absent", data: {} },
+      },
+      { id: "b", status: "resolved", value: 7 },
+    ];
+    const result = await deserializeStreamingLoaderData<
+      { bad: Promise<unknown>; good: Promise<number> }
+    >(new Response(lines.map((v) => JSON.stringify(v)).join("\n")));
+    await assertRejects(
+      () => result.bad,
+      Error,
+      "No deserializer registered for error",
+    );
+    assertEquals(await result.good, 7);
+  });
+});
diff --git a/src/_server.tsx b/src/_server.tsx
index 1b28bbc..4e5d94a 100644
--- a/src/_server.tsx
+++ b/src/_server.tsx
@@ -32,15 +32,12 @@ import { getInstance } from "./utils/otel.ts";
 
 import { App, generateRouteId, JuniperContextProvider } from "./_client.tsx";
 import {
-  cborEncode,
-  containsPromises,
-  createStreamingLoaderData,
+  createLoaderDataResponse,
   sanitizeServerData,
   sanitizeServerError,
   serializeAllContext,
   serializeError,
   serializeHydrationData,
-  serializeLoaderData,
   toInlineScriptJson,
 } from "./_serialization.ts";
 import type { SerializedHydrationData } from "./_serialization.ts";
@@ -808,7 +805,7 @@ export function toRedirectEnvelope(response: Response): Response {
 /**
  * Builds the Hono handlers for the client routes — server-rendered documents
  * and data requests — plus the error handler `createServer` installs alongside
- * them, which renders an error as a document, or as a CBOR error response for
+ * them, which renders an error as a document, or as a tagged JSON error response for
  * data requests.
  */
 export function createHandlers<
@@ -880,19 +877,11 @@ export function createHandlers<
           return c.newResponse(response.body, response);
         }
 
-        if (containsPromises(dataOrResponse)) {
-          c.header("Content-Type", "application/cbor-stream");
-
-          const dataStream = createStreamingLoaderData(dataOrResponse);
-          return stream(c, async (streamInstance) => {
-            await streamInstance.pipe(dataStream);
-          });
-        }
-
-        const cborData = await serializeLoaderData(dataOrResponse);
-        return c.newResponse(cborData as Uint8Array<ArrayBuffer>, 200, {
-          "Content-Type": "application/cbor",
-        });
+        const response = createLoaderDataResponse(
+          dataOrResponse,
+          c.req.raw.signal,
+        );
+        return c.newResponse(response.body, response);
       });
     },
   );
@@ -909,14 +898,13 @@ export function createHandlers<
 
     if (c.req.header("X-Juniper-Route-Id")) {
       const serialized = serializeError(error);
-      const cborData = cborEncode(serialized);
-      const headers = new Headers({
-        "Content-Type": "application/cbor",
-      });
+      const response = createLoaderDataResponse(serialized, c.req.raw.signal);
+      const headers = new Headers(response.headers);
       if (error.headers) {
         for (const [key, value] of error.headers.entries()) {
           if (
-            key.toLowerCase() !== "content-type" &&
+            !["content-type", "content-length", "content-encoding", "x-juniper"]
+              .includes(key.toLowerCase()) &&
             key.toLowerCase() !== "set-cookie"
           ) {
             headers.set(key, value);
@@ -926,7 +914,7 @@ export function createHandlers<
           headers.append("Set-Cookie", cookie);
         }
       }
-      return c.newResponse(cborData as Uint8Array<ArrayBuffer>, {
+      return c.newResponse(response.body, {
         status: error.status as StatusCode,
         headers,
       });
diff --git a/src/_server_hydration.test.tsx b/src/_server_hydration.test.tsx
index 3623854..eba147a 100644
--- a/src/_server_hydration.test.tsx
+++ b/src/_server_hydration.test.tsx
@@ -1,29 +1,32 @@
-import { brotliCompressSync, constants } from "node:zlib";
-
 import {
   assert,
   assertEquals,
   assertExists,
   assertFalse,
   assertInstanceOf,
+  assertRejects,
 } from "@std/assert";
-import { describe, it } from "@std/testing/bdd";
-
+import { afterEach, beforeEach, describe, it } from "@std/testing/bdd";
+import { stub } from "@std/testing/mock";
+import { createContext } from "react-router";
 import { Client } from "@udibo/juniper/client";
-import type { RouteProps } from "@udibo/juniper";
+import { HttpError, registerContext, registerType } from "@udibo/juniper";
 import { createServer } from "@udibo/juniper/server";
-
+import { simulateEnvironment } from "@udibo/juniper/utils/testing";
 import {
-  cborDecode,
+  deserializeError,
   deserializeHydrationData,
-  encodeToBase64,
+  deserializeStreamingLoaderData,
   fromTaggedJson,
+  resetRegistries,
   type SerializedHydrationData,
-  type SerializedHydrationDataV3,
+  serializeHydrationData,
 } from "./_serialization.ts";
 
 const HYDRATION_ASSIGNMENT =
   /window\.__juniperHydrationData = (.*?); await client\.hydrate\(\);/;
+const hostile =
+  "</script><script>globalThis.pwned=1</script><!--<script></SCRIPT >\u2028\u2029";
 
 function serverWithLoaderData(loaderData: unknown) {
   const client = new Client({
@@ -32,7 +35,7 @@ function serverWithLoaderData(loaderData: unknown) {
   });
   return createServer(import.meta.url, client, {
     path: "/",
-    main: { loader: () => loaderData },
+    main: { loader: () => loaderData, action: () => loaderData },
   });
 }
 
@@ -44,127 +47,280 @@ function scriptBodyContaining(html: string, marker: string): string {
   return html.slice(bodyStart, bodyEnd);
 }
 
-describe("the document's hydration payload", () => {
-  const hostile =
-    "</script><script>globalThis.pwned=1</script><!--<script></SCRIPT >\u2028\u2029";
-
-  it("keeps hostile loader text inside the hydration script", async () => {
-    const server = serverWithLoaderData({ text: hostile });
-    const html = await (await server.request("http://localhost/")).text();
+function assertEscapedDocument(html: string): SerializedHydrationData {
+  const body = scriptBodyContaining(html, "window.__juniperHydrationData");
+  assert(body.startsWith('import { client } from "/build/main.js";'));
+  assert(
+    body.endsWith("; await client.hydrate();"),
+    "the first closing script belongs to Juniper",
+  );
+  assertFalse(body.includes("<"));
+  assertFalse(body.includes("\u2028"));
+  assertFalse(body.includes("\u2029"));
+  assertFalse(html.includes(hostile));
+  const payload = HYDRATION_ASSIGNMENT.exec(body)?.[1];
+  assertExists(payload);
+  const serialized = JSON.parse(payload) as SerializedHydrationData;
+  assertEquals(serialized.version, 3);
+  return serialized;
+}
 
-    const body = scriptBodyContaining(html, "window.__juniperHydrationData");
-    assert(
-      body.startsWith('import { client } from "/build/main.js";'),
-      "the script element opens with the hydration statement",
-    );
-    assert(
-      body.endsWith("; await client.hydrate();"),
-      "the first </script the HTML parser sees is the one Juniper wrote",
-    );
-    assertFalse(body.includes("<"));
-    assertFalse(body.includes("\u2028"));
-    assertFalse(body.includes("\u2029"));
+describe("the document's hydration payload", () => {
+  beforeEach(resetRegistries);
+  afterEach(resetRegistries);
 
-    const payload = HYDRATION_ASSIGNMENT.exec(body)?.[1];
-    assertExists(payload);
-    const serialized = JSON.parse(payload) as SerializedHydrationData;
-    assertEquals(serialized.version, 3);
+  it("keeps hostile loader text and keys inside the hydration script", async () => {
+    const data = { [hostile]: [{ text: hostile, $t: "Date", v: 5 }] };
+    const html =
+      await (await serverWithLoaderData(data).request("http://localhost/"))
+        .text();
     assertEquals(
-      deserializeHydrationData(serialized).loaderData?.["/"],
-      { text: hostile },
+      deserializeHydrationData(assertEscapedDocument(html)).loaderData?.["/"],
+      data,
     );
   });
+
+  it(
+    "escapes context, public environment and errors in rendered HTML",
+    simulateEnvironment(
+      { APP_ENV: "test", PUBLIC_HOSTILE: hostile },
+      async () => {
+        const context = createContext({ [hostile]: hostile });
+        registerContext({
+          name: "hostile",
+          context,
+          serialize: (v) => v,
+          deserialize: (v) => v!,
+        });
+        const client = new Client({
+          path: "/",
+          main: {
+            default: () => <div>Home</div>,
+            ErrorBoundary: () => <div>Failed</div>,
+          },
+        });
+        const server = createServer(import.meta.url, client, {
+          path: "/",
+          main: {
+            publicEnvKeys: ["PUBLIC_HOSTILE"],
+            loader: () => {
+              throw new HttpError(400, {
+                message: "private",
+                exposedMessage: hostile,
+              });
+            },
+          },
+        });
+        using _log = stub(console, "error");
+        const html = await (await server.request("http://localhost/")).text();
+        const hydration = deserializeHydrationData(assertEscapedDocument(html));
+        assertEquals(hydration.serializedContext, {
+          hostile: { [hostile]: hostile },
+        });
+        assertEquals(hydration.publicEnv?.PUBLIC_HOSTILE, hostile);
+        const error = hydration.errors?.["/"];
+        assertInstanceOf(error, HttpError);
+        assertEquals(error.message, hostile);
+      },
+    ),
+  );
+
+  it(
+    "carries sorted development registrations and logs names missing on the client",
+    simulateEnvironment({ APP_ENV: "development" }, async () => {
+      class Zulu {}
+      class Alpha {}
+      registerType({
+        name: "Zulu",
+        is: (v): v is Zulu => v instanceof Zulu,
+        serialize: () => 1,
+        deserialize: () => new Zulu(),
+      });
+      registerType({
+        name: "Alpha",
+        is: (v): v is Alpha => v instanceof Alpha,
+        serialize: () => 2,
+        deserialize: () => new Alpha(),
+      });
+      const html = await (await serverWithLoaderData({ ok: true }).request(
+        "http://localhost/",
+      )).text();
+      const serialized = assertEscapedDocument(html);
+      const names =
+        (fromTaggedJson(serialized.data) as { registeredNames: string[] })
+          .registeredNames;
+      assertEquals(names, [...names].sort());
+      assert(names.includes("type:Zulu") && names.includes("type:Alpha"));
+      resetRegistries();
+      using logged = stub(console, "error");
+      deserializeHydrationData(serialized);
+      assertEquals(logged.calls.map((call) => call.args[0]), [
+        "Missing Juniper registrations: type:Alpha, type:Zulu",
+      ]);
+    }),
+  );
+
+  it(
+    "omits registration diagnostics in production",
+    simulateEnvironment({ APP_ENV: "production" }, async () => {
+      const serialized = await serializeHydrationData({ matches: [] });
+      assertFalse(
+        Object.hasOwn(
+          fromTaggedJson(serialized.data) as object,
+          "registeredNames",
+        ),
+      );
+    }),
+  );
 });
 
-describe("data requests", () => {
-  it("still answer in CBOR, with its native types rather than JSON tags", async () => {
-    const server = serverWithLoaderData({
-      at: new Date(0),
-      missing: undefined,
-    });
-    const res = await server.request("http://localhost/", {
-      headers: { "X-Juniper-Route-Id": "/" },
-    });
-    assertEquals(res.headers.get("content-type"), "application/cbor");
-    const data = cborDecode<Record<string, unknown>>(
-      new Uint8Array(await res.arrayBuffer()),
-    );
-    assertInstanceOf(data.at, Date);
-    assertEquals(data.at.getTime(), 0);
-    assert(Object.hasOwn(data, "missing") && data.missing === undefined);
+describe("tagged JSON data requests", () => {
+  it("aborts the response stream with the incoming request", async () => {
+    const controller = new AbortController();
+    const later = Promise.withResolvers<number>();
+    const response = await serverWithLoaderData({ later: later.promise })
+      .request("http://localhost/", {
+        signal: controller.signal,
+        headers: { "X-Juniper-Route-Id": "/" },
+      });
+    const reader = response.body!.getReader();
+    await reader.read();
+    const waiting = reader.read();
+    controller.abort(new Error("request canceled"));
+    await assertRejects(() => waiting, Error, "request canceled");
+    later.resolve(1);
+    reader.releaseLock();
   });
 
-  it("still stream deferred data as CBOR chunks", async () => {
-    const server = serverWithLoaderData({ later: Promise.resolve(1) });
-    const res = await server.request("http://localhost/", {
-      headers: { "X-Juniper-Route-Id": "/" },
+  for (const method of ["GET", "POST"]) {
+    it(`answers settled ${method} data with JSON, a marker and UTF-8 byte length`, async () => {
+      const server = serverWithLoaderData({
+        at: new Date(0),
+        missing: undefined,
+        text: "水🌿",
+      });
+      const response = await server.request("http://localhost/", {
+        method,
+        headers: { "X-Juniper-Route-Id": "/" },
+      });
+      const bytes = new Uint8Array(await response.arrayBuffer());
+      assertEquals(response.headers.get("Content-Type"), "application/json");
+      assertEquals(response.headers.get("X-Juniper"), "data");
+      assertEquals(
+        response.headers.get("Content-Length"),
+        String(bytes.length),
+      );
+      const data = await deserializeStreamingLoaderData<
+        Record<string, unknown>
+      >(new Response(bytes));
+      assertEquals(data, { at: new Date(0), missing: undefined, text: "水🌿" });
     });
-    assertEquals(res.headers.get("content-type"), "application/cbor-stream");
-    await res.body?.cancel();
-  });
-});
-
-function brotli(text: string): number {
-  return brotliCompressSync(new TextEncoder().encode(text), {
-    params: { [constants.BROTLI_PARAM_QUALITY]: 5 },
-  }).length;
-}
+    it(`streams deferred ${method} data as progressive NDJSON without origin compression`, async () => {
+      const first = Promise.withResolvers<number>();
+      const second = Promise.withResolvers<number>();
+      const server = serverWithLoaderData({
+        first: first.promise,
+        second: second.promise,
+      });
+      const response = await server.request("http://localhost/", {
+        method,
+        headers: { "X-Juniper-Route-Id": "/", "Accept-Encoding": "br, gzip" },
+      });
+      assertEquals(
+        response.headers.get("Content-Type"),
+        "application/x-ndjson",
+      );
+      assertEquals(response.headers.get("X-Juniper"), "data");
+      assertEquals(response.headers.get("Cache-Control"), "no-transform");
+      assertEquals(response.headers.get("Content-Encoding"), null);
+      assertEquals(response.headers.get("Content-Length"), null);
+      const reader = response.body!.pipeThrough(new TextDecoderStream())
+        .getReader();
+      const initial = await reader.read();
+      assertEquals(JSON.parse(initial.value!), {
+        first: { $t: "pending", v: "p0" },
+        second: { $t: "pending", v: "p1" },
+      });
+      second.resolve(2);
+      assertEquals(JSON.parse((await reader.read()).value!), {
+        id: "p1",
+        status: "resolved",
+        value: 2,
+      });
+      first.resolve(1);
+      assertEquals(JSON.parse((await reader.read()).value!), {
+        id: "p0",
+        status: "resolved",
+        value: 1,
+      });
+      assert((await reader.read()).done);
+      reader.releaseLock();
+    });
+  }
 
-describe("what a prose page costs to send", () => {
-  it("compresses smaller with version 3 than with version 2", async () => {
-    const prose = await Deno.readTextFile(
-      new URL("../docs/routing.md", import.meta.url),
-    );
-    const paragraphs = prose.split(/\n{2,}/).filter((part) => part.trim());
-    const client = new Client({
+  it("uses the same JSON envelope for data errors and preserves exposedMessage", async () => {
+    const client = new Client({ path: "/", main: { default: () => <div /> } });
+    const server = createServer(import.meta.url, client, {
       path: "/",
       main: {
-        default: ({ loaderData }: RouteProps) => (
-          <article>
-            {(loaderData as { paragraphs: string[] }).paragraphs.map((
-              paragraph,
-              index,
-            ) => <p key={index}>{paragraph}</p>)}
-          </article>
-        ),
+        loader: () => {
+          throw new HttpError(500, {
+            message: "private database detail",
+            exposedMessage: "Try again",
+          });
+        },
       },
     });
-    const server = createServer(import.meta.url, client, {
-      path: "/",
-      main: { loader: () => ({ paragraphs }) },
+    using _log = stub(console, "error");
+    const response = await server.request("http://localhost/", {
+      headers: { "X-Juniper-Route-Id": "/" },
     });
-    const html = await (await server.request("http://localhost/")).text();
-
-    const script = /<script[^>]*>import \{ client \}[\s\S]*?<\/script>/.exec(
-      html,
-    )?.[0];
-    assertExists(script);
-    const v3Text = HYDRATION_ASSIGNMENT.exec(script)?.[1];
-    assertExists(v3Text);
-    const v3 = JSON.parse(v3Text) as SerializedHydrationDataV3;
-    const v2 = {
-      version: 2 as const,
-      data: encodeToBase64(fromTaggedJson(v3.data)),
-      publicEnv: v3.publicEnv,
-    };
+    assertEquals(response.status, 500);
+    assertEquals(response.headers.get("Content-Type"), "application/json");
+    assertEquals(response.headers.get("X-Juniper"), "data");
+    const text = await response.text();
+    assertFalse(text.includes("private database detail"));
     assertEquals(
-      deserializeHydrationData(v2).loaderData,
-      deserializeHydrationData(v3).loaderData,
-      "both documents carry the same page",
+      response.headers.get("Content-Length"),
+      String(new TextEncoder().encode(text).length),
     );
-    const v2Html = html.replace(
-      v3Text,
-      () => JSON.stringify(v2).replaceAll("<", "\\u003c"),
-    );
-    const markup = brotli(html.replace(script, ""));
-    const v3Ratio = brotli(html) / markup;
-    const v2Ratio = brotli(v2Html) / markup;
-
-    assert(
-      v3Ratio < v2Ratio,
-      `version 3 ships ${v3Ratio.toFixed(3)}x its markup in brotli against ${
-        v2Ratio.toFixed(3)
-      }x for version 2`,
+    const data = await deserializeStreamingLoaderData<Record<string, unknown>>(
+      new Response(text),
     );
+    assertEquals(data.__errorType, "HttpError");
+    const error = deserializeError(data);
+    assertInstanceOf(error, HttpError);
+    assertEquals(error.exposedMessage, "Try again");
   });
+
+  it(
+    "sanitizes streamed server errors and preserves explicit exposed messages",
+    simulateEnvironment({ APP_ENV: "production" }, async () => {
+      const data = {
+        private: Promise.reject(new Error("private database detail")),
+        exposed: Promise.reject(
+          new HttpError(403, {
+            message: "private lookup",
+            exposedMessage: "Not permitted",
+          }),
+        ),
+      };
+      const response = await serverWithLoaderData(data).request(
+        "http://localhost/",
+        { headers: { "X-Juniper-Route-Id": "/" } },
+      );
+      const text = await response.text();
+      assertFalse(text.includes("private database detail"));
+      assertFalse(text.includes("private lookup"));
+      const restored = await deserializeStreamingLoaderData<typeof data>(
+        new Response(text),
+      );
+      await assertRejects(
+        () => restored.private,
+        HttpError,
+        new HttpError(500).exposedMessage,
+      );
+      await assertRejects(() => restored.exposed, HttpError, "Not permitted");
+    }),
+  );
 });
diff --git a/src/_tagged-json.ts b/src/_tagged-json.ts
new file mode 100644
index 0000000..c5376c5
--- /dev/null
+++ b/src/_tagged-json.ts
@@ -0,0 +1,148 @@
+/** The tagged JSON codec shared by document hydration and data responses. @module */
+export type TaggedJson =
+  | null
+  | boolean
+  | number
+  | string
+  | TaggedJson[]
+  | { [key: string]: TaggedJson };
+
+type ValueTag = "pending" | "promise" | "rejected" | "type" | "error";
+
+export class Tagged {
+  constructor(public tag: ValueTag, public contents: unknown) {}
+}
+
+export function defineOwnValue(
+  target: Record<string, unknown>,
+  key: string,
+  value: unknown,
+): void {
+  Object.defineProperty(target, key, {
+    value,
+    enumerable: true,
+    writable: true,
+    configurable: true,
+  });
+}
+
+function tagged(tag: string, value?: TaggedJson): TaggedJson {
+  return value === undefined ? { $t: tag } : { $t: tag, v: value };
+}
+
+function numberToTaggedJson(value: number): TaggedJson {
+  if (Number.isNaN(value)) return tagged("number", "NaN");
+  if (value === Infinity) return tagged("number", "Infinity");
+  if (value === -Infinity) return tagged("number", "-Infinity");
+  if (Object.is(value, -0)) return tagged("number", "-0");
+  return value;
+}
+
+export function toTaggedJson(value: unknown): TaggedJson {
+  if (value === undefined) return tagged("undefined");
+  if (value === null || typeof value === "boolean") return value;
+  if (typeof value === "string") return value.toWellFormed();
+  if (typeof value === "number") return numberToTaggedJson(value);
+  if (typeof value === "bigint") return tagged("bigint", value.toString());
+  if (typeof value === "function" || typeof value === "symbol") {
+    throw new TypeError(`Cannot serialize a ${typeof value} value`);
+  }
+  if (value instanceof Tagged) {
+    return tagged(value.tag, toTaggedJson(value.contents));
+  }
+  if (value instanceof Date) {
+    return tagged("Date", numberToTaggedJson(value.getTime()));
+  }
+  if (Array.isArray(value)) return Array.from(value, toTaggedJson);
+  const entries = Object.entries(value as Record<string, unknown>).map((
+    [key, entry],
+  ): [string, TaggedJson] => [key.toWellFormed(), toTaggedJson(entry)]);
+  if (entries.some(([key]) => key === "$t" || key === "__proto__")) {
+    return tagged("object", entries);
+  }
+  return Object.fromEntries(entries);
+}
+
+function objectFromEntries(entries: unknown): Record<string, unknown> {
+  if (!Array.isArray(entries)) throw new Error("Invalid object tag entries");
+  const result: Record<string, unknown> = {};
+  for (const entry of entries) {
+    if (
+      !Array.isArray(entry) || entry.length !== 2 ||
+      typeof entry[0] !== "string"
+    ) {
+      throw new Error("Invalid object tag entry");
+    }
+    defineOwnValue(result, entry[0], fromTaggedJson(entry[1]));
+  }
+  return result;
+}
+
+function fromTag(tag: unknown, value: unknown): unknown {
+  switch (tag) {
+    case "undefined":
+      return undefined;
+    case "number":
+      if (!["NaN", "Infinity", "-Infinity", "-0"].includes(value as string)) {
+        throw new Error("Invalid number tag");
+      }
+      return Number(value);
+    case "bigint":
+      if (typeof value !== "string" || !/^-?\d+$/.test(value)) {
+        throw new Error("Invalid bigint tag");
+      }
+      return BigInt(value);
+    case "Date": {
+      const time = fromTaggedJson(value);
+      if (typeof time !== "number") throw new Error("Invalid Date tag");
+      return new Date(time);
+    }
+    case "object":
+      return objectFromEntries(value);
+    case "pending":
+    case "promise":
+    case "rejected":
+    case "type":
+    case "error":
+      return new Tagged(tag, fromTaggedJson(value));
+  }
+  throw new Error(`Unknown tagged JSON tag: ${String(tag)}`);
+}
+
+export function fromTaggedJson(value: unknown): unknown {
+  if (value === null || typeof value !== "object") return value;
+  if (Array.isArray(value)) return value.map(fromTaggedJson);
+  const record = value as Record<string, unknown>;
+  if (Object.hasOwn(record, "$t")) return fromTag(record.$t, record.v);
+  return objectFromEntries(Object.entries(record));
+}
+
+export function toInlineScriptJson(value: unknown): string {
+  return JSON.stringify(value)
+    .replaceAll("<", "\\u003c")
+    .replaceAll("\u2028", "\\u2028")
+    .replaceAll("\u2029", "\\u2029");
+}
+
+const hydrationPayloads = new WeakMap<object, Record<string, unknown>>();
+
+export function decodeHydrationPayload(
+  serialized: { version: number; data: unknown },
+): Record<string, unknown> {
+  if (serialized.version !== 3) {
+    throw new Error(
+      `Unsupported hydration data version: ${String(serialized.version)}`,
+    );
+  }
+  const cached = hydrationPayloads.get(serialized);
+  if (cached) return cached;
+  const decoded = fromTaggedJson(serialized.data);
+  if (
+    !decoded || typeof decoded !== "object" || Array.isArray(decoded) ||
+    decoded instanceof Tagged
+  ) {
+    throw new Error("Invalid hydration data");
+  }
+  hydrationPayloads.set(serialized, decoded as Record<string, unknown>);
+  return decoded as Record<string, unknown>;
+}
diff --git a/src/build.test.ts b/src/build.test.ts
index 7597223..f58fd13 100644
--- a/src/build.test.ts
+++ b/src/build.test.ts
@@ -446,6 +446,10 @@ describe("Builder", () => {
       await Deno.copyFile(clientSrcPath, clientDstPath);
       await Deno.copyFile(clientInternalSrcPath, clientInternalDstPath);
       await Deno.copyFile(serializationSrcPath, serializationDstPath);
+      await Deno.copyFile(
+        path.resolve(projectRootDir, "_tagged-json.ts"),
+        path.resolve(tmp, "_tagged-json.ts"),
+      );
       await Deno.copyFile(envSrcPath, envDstPath);
       await Deno.copyFile(envInternalSrcPath, envInternalDstPath);
 
diff --git a/src/client.test.tsx b/src/client.test.tsx
index e1de7e7..c66891a 100644
--- a/src/client.test.tsx
+++ b/src/client.test.tsx
@@ -24,7 +24,7 @@ import type { ActionFunctionArgs, LoaderFunctionArgs } from "react-router";
 import { Client } from "./client.tsx";
 import {
   _addErrorSerializer,
-  cborEncode,
+  createLoaderDataResponse,
   resetRegistries,
 } from "./_serialization.ts";
 import type { HydrationData, RootClientRoute } from "./client.tsx";
@@ -83,7 +83,7 @@ class CustomError extends Error {
 }
 
 /**
- * Registers CustomError serializer with CBOR registry.
+ * Registers CustomError serializer with serialization registry.
  * Must be called before serialization tests that use CustomError.
  */
 function registerCustomError(): void {
@@ -319,14 +319,7 @@ describe("createRoute", () => {
       globalThis,
       "fetch",
       (_input: RequestInfo | URL, _init?: RequestInit) => {
-        const cborData = cborEncode(payload);
-        return Promise.resolve(
-          new Response(new Uint8Array(cborData), {
-            headers: {
-              "Content-Type": "application/cbor",
-            },
-          }),
-        );
+        return Promise.resolve(createLoaderDataResponse(payload));
       },
     );
 
diff --git a/src/client.tsx b/src/client.tsx
index 88d3c67..91b4432 100644
--- a/src/client.tsx
+++ b/src/client.tsx
@@ -22,6 +22,7 @@ import {
   generateRouteId,
   JuniperContextProvider,
   registerRouter,
+  reloadUnsupportedHydration,
   setClientBuildId,
 } from "./_client.tsx";
 import type { HydrationData, LazyRoute, ServerFlags } from "./_client.tsx";
@@ -304,6 +305,10 @@ export class Client {
    * @throws {Error} If the document has no Juniper hydration data.
    */
   async hydrate(): Promise<void> {
+    const serialized = env.getHydrationData();
+    if (serialized && serialized.version !== 3) {
+      return await reloadUnsupportedHydration(serialized.version);
+    }
     const { matches, serializedContext, buildId, ...hydrationData } = this
       .getHydrationData();
     setClientBuildId(buildId);
diff --git a/src/deno.json b/src/deno.json
index fdd062b..c03ef6c 100644
--- a/src/deno.json
+++ b/src/deno.json
@@ -38,7 +38,6 @@
     "@deno/esbuild-plugin": "jsr:@deno/esbuild-plugin@^1.2.1",
     "@opentelemetry/api": "npm:@opentelemetry/api@^1.9.1",
     "babel-plugin-react-compiler": "npm:babel-plugin-react-compiler@^1.0.0",
-    "cbor2": "npm:cbor2@^2.3.0",
     "esbuild": "npm:esbuild@^0.28.2",
     "isbot": "npm:isbot@^5.2.2",
     "quick-lru": "npm:quick-lru@^7.3.0",
diff --git a/src/mod.ts b/src/mod.ts
index cf9c647..d64fe18 100644
--- a/src/mod.ts
+++ b/src/mod.ts
@@ -60,8 +60,10 @@ export { redirect, redirectDocument };
  * that should be serialized in loader/action data.
  * Register types such as `Map`, `Set`, `RegExp`, and `URL` explicitly; the route
  * data preprocessor does not preserve unregistered class instances. `Date` and
- * errors have built-in handling. Bigints are accepted, but safe integer values
- * can decode as numbers; use an explicit representation when that type matters.
+ * errors have built-in handling. All bigints retain their type. The `is` guard
+ * runs before Array and Date handling; the first matching registration wins.
+ * Serializer output is recursively processed and may contain promises or other
+ * registered types. Output matching the serializer's own `is` guard throws.
  *
  * @template T - The type being serialized
  * @template S - The serialized representation type (defaults to `unknown`)
@@ -185,7 +187,10 @@ export interface ContextSerializer<T, S = unknown> {
  *
  * Call once at module scope in a shared module imported by both server and client.
  * Registrations are process-wide. The first matching type guard wins; keep guards
- * narrow and names stable. Both ends must agree on the name and representation.
+ * narrow and names stable. Guards run before Array and Date handling. Both ends
+ * must agree on the name and representation; an unknown name throws on decode.
+ * A streamed decode failure rejects only the affected promise. Development
+ * hydration logs registrations missing in the browser.
  *
  * @param serializer - Synchronous type guard, encoder, and decoder.
  * @throws {Error} If this type name is already registered.
@@ -215,7 +220,11 @@ export function registerType<T, S = unknown>(
  * Import the registration on both server and client before routes run. Serialize
  * only fields safe for the user to read: Juniper does not redact custom payloads.
  * Built-in errors and `HttpError` already have serializers; give each custom
- * error a distinct name.
+ * error a distinct name. The first matching registration wins. Output is
+ * recursively processed and must not match the serializer's own `is` guard.
+ * An output key named `__errorType` remains data inside the error envelope.
+ * Unknown error names throw on decode, rejecting only the affected promise in
+ * a deferred stream.
  *
  * @param serializer - Synchronous encoder and decoder for a specific error class.
  * @throws {Error} If this error name is already registered.
diff --git a/src/server.test.tsx b/src/server.test.tsx
index 852c6d8..c797d27 100644
--- a/src/server.test.tsx
+++ b/src/server.test.tsx
@@ -28,7 +28,10 @@ import {
   getBuildId,
   mergeServerRoutes,
 } from "./_server.tsx";
-import { cborDecode, deserializeHydrationData } from "./_serialization.ts";
+import {
+  deserializeHydrationData,
+  deserializeLoaderData,
+} from "./_serialization.ts";
 import type { SerializedHydrationData } from "./_serialization.ts";
 
 describe("createServer", () => {
@@ -410,7 +413,7 @@ describe("createServer", () => {
     assertStringIncludes(html, "<div>Home</div>");
   });
 
-  it("should return CBOR for data requests when X-Juniper-Route-Id is present", async () => {
+  it("should return tagged JSON for data requests when X-Juniper-Route-Id is present", async () => {
     const client = new Client({
       path: "/",
       main: {
@@ -429,9 +432,9 @@ describe("createServer", () => {
     });
     assertEquals(res.status, 200);
     const ct = res.headers.get("content-type");
-    assertEquals(ct, "application/cbor");
-    const buffer = await res.arrayBuffer();
-    const data = cborDecode<{ ok: boolean }>(new Uint8Array(buffer));
+    assertEquals(ct, "application/json");
+    const buffer = await res.text();
+    const data = deserializeLoaderData<{ ok: boolean }>(buffer);
     assertEquals(data, { ok: true });
   });
 
@@ -936,9 +939,9 @@ describe("createServer", () => {
     });
     assertEquals(res.status, 200);
     const ct = res.headers.get("content-type");
-    assertEquals(ct, "application/cbor");
-    const buffer = await res.arrayBuffer();
-    const data = cborDecode<{ currentUser: string }>(new Uint8Array(buffer));
+    assertEquals(ct, "application/json");
+    const buffer = await res.text();
+    const data = deserializeLoaderData<{ currentUser: string }>(buffer);
     assertEquals(data, { currentUser: "test-user" });
   });
 
diff --git a/src/utils/_env.ts b/src/utils/_env.ts
index ffdab20..a2a159e 100644
--- a/src/utils/_env.ts
+++ b/src/utils/_env.ts
@@ -1,4 +1,5 @@
 import type { ClientGlobals } from "../_client.tsx";
+import { decodeHydrationPayload } from "../_tagged-json.ts";
 
 /**
  * Internal environment utilities that can be stubbed for testing.
@@ -15,7 +16,14 @@ export const env = {
     if (env.isServer()) {
       return Deno.env.get(key);
     }
-    return env.getHydrationData()?.publicEnv?.[key];
+    const payload = env.getHydrationData();
+    if (!payload || payload.version !== 3) return undefined;
+    const publicEnv = decodeHydrationPayload(payload).publicEnv as
+      | Record<string, string>
+      | undefined;
+    return publicEnv && Object.hasOwn(publicEnv, key)
+      ? publicEnv[key]
+      : undefined;
   },
   getHydrationData: () => {
     return (globalThis as ClientGlobals).__juniperHydrationData;

From 9ff4692fc8a22fb9ca0008cfc396bd4994e9674e Mon Sep 17 00:00:00 2001
From: Kyle June <github@kylejune.com>
Date: Sat, 12 Sep 2026 16:34:29 -0400
Subject: [PATCH 4/6] fix: cover tagged JSON review edge cases

---
 docs/error-handling.md                        |   4 +
 docs/state-management.md                      |   2 +
 .../routes/features/data/server-deferred.tsx  |   6 +-
 src/_serialization.test.ts                    |   2 +-
 src/_serialization.ts                         |  59 ++++---
 src/_serialization_review.test.ts             | 157 ++++++++++++++++++
 src/_server_hydration.test.tsx                |  25 ++-
 7 files changed, 228 insertions(+), 27 deletions(-)
 create mode 100644 src/_serialization_review.test.ts

diff --git a/docs/error-handling.md b/docs/error-handling.md
index 9e88c2f..b859144 100644
--- a/docs/error-handling.md
+++ b/docs/error-handling.md
@@ -269,6 +269,10 @@ processed recursively and may contain supported values, promises, or registered
 types. A serializer whose output matches its own `is` predicate throws. The
 first matching error registration wins.
 
+Non-Error thrown values use a `null` error type in the envelope, leaving every
+string name available for registered errors. A missing string name always
+throws, including a custom registration named `Unknown`.
+
 ```typescript
 // routes/main.tsx
 import "@/errors/custom.ts";
diff --git a/docs/state-management.md b/docs/state-management.md
index f8303d3..7fce278 100644
--- a/docs/state-management.md
+++ b/docs/state-management.md
@@ -361,6 +361,8 @@ lists, including inside serializer output, so their keys remain ordinary data.
 
 The first document load embeds hydration version 3 with one tagged value
 containing loader/action data, errors, context, and public environment values.
+Application registrations do not transform public environment strings or
+diagnostic registration names; these still travel inside the same tagged value.
 Every `<`, U+2028, and U+2029 in that script is written as a `\u` escape.
 Documents carrying another hydration version use the guarded document reload
 path. There is no legacy decoder; deploy the server and browser build together.
diff --git a/example/routes/features/data/server-deferred.tsx b/example/routes/features/data/server-deferred.tsx
index ecb8767..ea76d2b 100644
--- a/example/routes/features/data/server-deferred.tsx
+++ b/example/routes/features/data/server-deferred.tsx
@@ -104,13 +104,13 @@ export default function ServerDeferredDataDemo({
             Fast data is included in the initial HTML response
           </li>
           <li>
-            Promises are serialized using tagged JSON and streamed as NDJSON
+            As promises resolve, the server streams HTML for each section
           </li>
           <li>
-            Client hydrates immediately with Suspense fallbacks
+            The client hydrates after the document's tagged JSON data is ready
           </li>
           <li>
-            As server promises resolve, data streams to the client
+            Later client data requests stream tagged JSON resolutions as NDJSON
           </li>
         </ol>
       </div>
diff --git a/src/_serialization.test.ts b/src/_serialization.test.ts
index 7dd6c79..d979ca9 100644
--- a/src/_serialization.test.ts
+++ b/src/_serialization.test.ts
@@ -292,7 +292,7 @@ describe("Serialization Module", () => {
       const thrown = { custom: "error object" };
       const serialized = serializeError(thrown);
 
-      assertEquals(serialized.__errorType, "Unknown");
+      assertEquals(serialized.__errorType, null);
       assertEquals(serialized.data.value, thrown);
 
       const deserialized = deserializeError(serialized);
diff --git a/src/_serialization.ts b/src/_serialization.ts
index e7a3885..af6f4fe 100644
--- a/src/_serialization.ts
+++ b/src/_serialization.ts
@@ -186,7 +186,7 @@ export function sanitizeServerData<T>(data: T): T {
 }
 
 export interface ErrorEnvelope extends Record<string, unknown> {
-  __errorType: string;
+  __errorType: string | null;
   data: Record<string, unknown>;
 }
 
@@ -211,13 +211,13 @@ export function serializeError(error: unknown): ErrorEnvelope {
       },
     };
   }
-  return { __errorType: "Unknown", data: { value: error } };
+  return { __errorType: null, data: { value: error } };
 }
 
 export function deserializeError(envelope: Record<string, unknown>): unknown {
   const name = envelope.__errorType;
   const data = envelope.data as Record<string, unknown>;
-  if (name === "Unknown") return data.value;
+  if (name === null) return data.value;
   const serializer = errorRegistry.get(name as string);
   if (!serializer) {
     throw new Error(`No deserializer registered for error "${String(name)}"`);
@@ -351,6 +351,12 @@ interface PendingPromises {
   entries: { id: string; promise: PromiseLike<unknown> }[];
 }
 
+function discardPending(pending: PendingPromises): void {
+  for (const entry of pending.entries.splice(0)) {
+    Promise.resolve(entry.promise).catch(() => {});
+  }
+}
+
 export function containsPromises(value: unknown): boolean {
   if (value === null || value === undefined) return false;
   if (isThenable(value)) return true;
@@ -411,9 +417,7 @@ function prepareData(
   try {
     return { processed: processValueForStreaming(data, pending), pending };
   } catch (error) {
-    for (const entry of pending.entries) {
-      Promise.resolve(entry.promise).catch(() => {});
-    }
+    discardPending(pending);
     throw error;
   }
 }
@@ -433,6 +437,7 @@ function createDataStream(
   let controller: ReadableStreamDefaultController<Uint8Array>;
   function stop(): void {
     stopped = true;
+    processed = undefined;
     ready = [];
     signal?.removeEventListener("abort", abort);
     waiting?.();
@@ -505,19 +510,24 @@ function createDataStream(
                   ),
                 };
             } catch (error) {
-              line = {
-                id: resolution.id,
-                status: "rejected",
-                error: toTaggedJson(
-                  processValueForStreaming(
-                    serializeError(sanitizeServerError(error)),
-                    pending,
+              discardPending(pending);
+              try {
+                line = {
+                  id: resolution.id,
+                  status: "rejected",
+                  error: toTaggedJson(
+                    processValueForStreaming(
+                      serializeError(sanitizeServerError(error)),
+                      pending,
+                    ),
                   ),
-                ),
-              };
-            } finally {
-              observePending();
+                };
+              } catch (fallbackError) {
+                discardPending(pending);
+                throw fallbackError;
+              }
             }
+            observePending();
             c.enqueue(encoder.encode(JSON.stringify(line) + "\n"));
           }
           if (readIndex >= ready.length) {
@@ -760,16 +770,23 @@ function registeredNames(): string[] {
 export async function serializeHydrationData(
   hydrationData: HydrationData,
 ): Promise<SerializedHydrationData> {
-  const { errors, ...rest } = hydrationData;
-  const processed = await processValue({
+  const { errors, publicEnv, ...rest } = hydrationData;
+  const data = {
     ...rest,
     errors: errors && Object.fromEntries(
       Object.entries(errors).map((
         [id, error],
       ) => [id, sanitizeServerError(error)]),
     ),
-    ...(isDevelopment() ? { registeredNames: registeredNames() } : {}),
-  });
+  };
+  const processed: Record<string, unknown> = {};
+  for (const [key, value] of Object.entries(data)) {
+    defineOwnValue(processed, key, await processValue(value));
+  }
+  defineOwnValue(processed, "publicEnv", publicEnv);
+  if (isDevelopment()) {
+    defineOwnValue(processed, "registeredNames", registeredNames());
+  }
   return { version: 3, data: toTaggedJson(processed) };
 }
 
diff --git a/src/_serialization_review.test.ts b/src/_serialization_review.test.ts
new file mode 100644
index 0000000..ca3d5e3
--- /dev/null
+++ b/src/_serialization_review.test.ts
@@ -0,0 +1,157 @@
+import {
+  assertEquals,
+  assertInstanceOf,
+  assertRejects,
+  assertThrows,
+} from "@std/assert";
+import { afterEach, beforeEach, describe, it } from "@std/testing/bdd";
+import { stub } from "@std/testing/mock";
+import { FakeTime } from "@std/testing/time";
+import { registerError, registerType } from "@udibo/juniper";
+import { getEnv, isProduction } from "@udibo/juniper/utils/env";
+import { simulateEnvironment } from "@udibo/juniper/utils/testing";
+import {
+  createStreamingLoaderData,
+  deserializeError,
+  deserializeHydrationData,
+  deserializeLoaderData,
+  deserializeStreamingLoaderData,
+  resetRegistries,
+  serializeError,
+  serializeHydrationData,
+  serializeLoaderData,
+} from "./_serialization.ts";
+import { env } from "./utils/_env.ts";
+
+describe("tagged JSON review regressions", () => {
+  beforeEach(resetRegistries);
+  afterEach(resetRegistries);
+
+  it("round-trips a registered error named Unknown and fails closed when its decoder is missing", async () => {
+    class DomainError extends Error {}
+    registerError({
+      name: "Unknown",
+      is: (value): value is DomainError => value instanceof DomainError,
+      serialize: () => ({ message: "domain" }),
+      deserialize: (data) => new DomainError(String(data.message)),
+    });
+    const error = new DomainError("domain");
+    assertEquals(
+      deserializeError(serializeError("plain failure")),
+      "plain failure",
+    );
+    const encoded = serializeError(error);
+    const hydration = await serializeHydrationData({
+      matches: [],
+      errors: { root: error },
+    });
+    const text = await serializeLoaderData(error);
+    const stream = await new Response(
+      createStreamingLoaderData({
+        error: Promise.reject(error),
+        good: Promise.resolve(5),
+      }),
+    ).text();
+    assertInstanceOf(deserializeError(encoded), DomainError);
+    assertInstanceOf(
+      deserializeHydrationData(hydration).errors?.root,
+      DomainError,
+    );
+    assertInstanceOf(deserializeLoaderData(text), DomainError);
+    const restored = await deserializeStreamingLoaderData<
+      { error: Promise<never>; good: Promise<number> }
+    >(new Response(stream));
+    await assertRejects(() => restored.error, DomainError, "domain");
+    resetRegistries();
+    assertThrows(
+      () => deserializeError(encoded),
+      Error,
+      'No deserializer registered for error "Unknown"',
+    );
+    assertThrows(
+      () => deserializeLoaderData(text),
+      Error,
+      'No deserializer registered for error "Unknown"',
+    );
+    const missing = await deserializeStreamingLoaderData<typeof restored>(
+      new Response(stream),
+    );
+    await assertRejects(
+      () => missing.error,
+      Error,
+      'No deserializer registered for error "Unknown"',
+    );
+    assertEquals(await missing.good, 5);
+  });
+
+  it("keeps public environment strings readable when application strings have a serializer", async () => {
+    registerType<string, number[]>({
+      name: "Strings",
+      is: (value): value is string => typeof value === "string",
+      serialize: (value) => [...value].map((c) => c.codePointAt(0)!),
+      deserialize: (data) => String.fromCodePoint(...data),
+    });
+    const payload = await serializeHydrationData({
+      matches: [],
+      publicEnv: { APP_ENV: "production" },
+    });
+    using _browser = stub(env, "isServer", () => false);
+    using _payload = stub(env, "getHydrationData", () => payload);
+    assertEquals(getEnv("APP_ENV"), "production");
+    assertEquals(isProduction(), true);
+  });
+
+  it(
+    "logs missing registrations even when application arrays have a serializer",
+    simulateEnvironment({ APP_ENV: "development" }, async () => {
+      registerType<unknown[], string>({
+        name: "Arrays",
+        is: Array.isArray,
+        serialize: JSON.stringify,
+        deserialize: JSON.parse,
+      });
+      const payload = await serializeHydrationData({ matches: [] });
+      resetRegistries();
+      using logged = stub(console, "error");
+      assertThrows(
+        () => deserializeHydrationData(payload),
+        Error,
+        'No deserializer registered for type "Arrays"',
+      );
+      assertEquals(logged.calls.map((call) => call.args[0]), [
+        "Missing Juniper registrations: type:Arrays",
+      ]);
+    }),
+  );
+
+  it("closes after rejecting a deferred value whose encoding discovered unreachable nested promises", async () => {
+    using time = new FakeTime();
+    const bad = Promise.withResolvers<unknown>();
+    const never = Promise.withResolvers<unknown>();
+    const reader = new Response(
+      createStreamingLoaderData({ bad: bad.promise, good: Promise.resolve(5) }),
+    ).body!.pipeThrough(new TextDecoderStream()).getReader();
+    await reader.read();
+    bad.resolve({ nested: never.promise, invalid: Symbol("unsupported") });
+    const lines = [
+      JSON.parse((await reader.read()).value!),
+      JSON.parse((await reader.read()).value!),
+    ];
+    assertEquals(lines.map((line) => [line.id, line.status]).sort(), [[
+      "p0",
+      "rejected",
+    ], ["p1", "resolved"]]);
+    let closed = false;
+    const ending = reader.read().then((result) => {
+      closed = result.done;
+    });
+    try {
+      await time.tickAsync(1);
+      assertEquals(closed, true);
+    } finally {
+      await reader.cancel();
+      await ending;
+      reader.releaseLock();
+    }
+  });
+});
diff --git a/src/_server_hydration.test.tsx b/src/_server_hydration.test.tsx
index eba147a..1cd090d 100644
--- a/src/_server_hydration.test.tsx
+++ b/src/_server_hydration.test.tsx
@@ -10,7 +10,12 @@ import { afterEach, beforeEach, describe, it } from "@std/testing/bdd";
 import { stub } from "@std/testing/mock";
 import { createContext } from "react-router";
 import { Client } from "@udibo/juniper/client";
-import { HttpError, registerContext, registerType } from "@udibo/juniper";
+import {
+  HttpError,
+  registerContext,
+  registerError,
+  registerType,
+} from "@udibo/juniper";
 import { createServer } from "@udibo/juniper/server";
 import { simulateEnvironment } from "@udibo/juniper/utils/testing";
 import {
@@ -130,6 +135,19 @@ describe("the document's hydration payload", () => {
     simulateEnvironment({ APP_ENV: "development" }, async () => {
       class Zulu {}
       class Alpha {}
+      class Domain extends Error {}
+      registerError({
+        name: "Domain",
+        is: (value): value is Domain => value instanceof Domain,
+        serialize: () => ({}),
+        deserialize: () => new Domain(),
+      });
+      registerContext({
+        name: "Shared",
+        context: createContext(0),
+        serialize: (value) => value,
+        deserialize: (value) => value ?? 0,
+      });
       registerType({
         name: "Zulu",
         is: (v): v is Zulu => v instanceof Zulu,
@@ -151,11 +169,14 @@ describe("the document's hydration payload", () => {
           .registeredNames;
       assertEquals(names, [...names].sort());
       assert(names.includes("type:Zulu") && names.includes("type:Alpha"));
+      assert(
+        names.includes("error:Domain") && names.includes("context:Shared"),
+      );
       resetRegistries();
       using logged = stub(console, "error");
       deserializeHydrationData(serialized);
       assertEquals(logged.calls.map((call) => call.args[0]), [
-        "Missing Juniper registrations: type:Alpha, type:Zulu",
+        "Missing Juniper registrations: context:Shared, error:Domain, type:Alpha, type:Zulu",
       ]);
     }),
   );

From 8c6dac0dd8906adf7872fb29bd4db14a31a25e1f Mon Sep 17 00:00:00 2001
From: Kyle June <github@kylejune.com>
Date: Sat, 12 Sep 2026 18:21:57 -0400
Subject: [PATCH 5/6] docs: describe current serialization behavior

---
 README.md                |  6 ------
 docs/state-management.md | 14 +++++++-------
 2 files changed, 7 insertions(+), 13 deletions(-)

diff --git a/README.md b/README.md
index abbb3bf..8e80a17 100644
--- a/README.md
+++ b/README.md
@@ -38,12 +38,6 @@ seamless full-stack development experience.
 
 ## Quick Start
 
-Version 0.12 uses tagged JSON throughout and requires matching server and
-browser builds. Older hydration payloads trigger a guarded document reload.
-Middleware should identify loader/action responses by `X-Juniper: data`. See
-[How Values Travel](docs/state-management.md#how-values-travel) for the wire
-format and registration contracts.
-
 Use `degit` to clone a template and get started:
 
 ```bash
diff --git a/docs/state-management.md b/docs/state-management.md
index 7fce278..1d9b9fb 100644
--- a/docs/state-management.md
+++ b/docs/state-management.md
@@ -359,13 +359,13 @@ deferred resolutions. Values JSON cannot express use string tags of the form
 throw. Plain objects with an own `$t` or `__proto__` key use escaped entry
 lists, including inside serializer output, so their keys remain ordinary data.
 
-The first document load embeds hydration version 3 with one tagged value
-containing loader/action data, errors, context, and public environment values.
-Application registrations do not transform public environment strings or
-diagnostic registration names; these still travel inside the same tagged value.
-Every `<`, U+2028, and U+2029 in that script is written as a `\u` escape.
-Documents carrying another hydration version use the guarded document reload
-path. There is no legacy decoder; deploy the server and browser build together.
+The first document load embeds one tagged hydration value containing
+loader/action data, errors, context, and public environment values. Application
+registrations do not transform public environment strings or diagnostic
+registration names; these still travel inside the same tagged value. Every `<`,
+U+2028, and U+2029 in that script is written as a `\u` escape. Deploy server
+code and browser assets from the same build. If their hydration formats do not
+match, Juniper uses a guarded document reload.
 
 Client navigations and fetchers receive settled data as `application/json` with
 a UTF-8 `Content-Length`. Deferred data uses `application/x-ndjson`: the first

From 0293095b2aa38138dbf883cce47b1201726a25f7 Mon Sep 17 00:00:00 2001
From: Kyle June <github@kylejune.com>
Date: Sat, 12 Sep 2026 20:11:44 -0400
Subject: [PATCH 6/6] fix: keep private helpers out of API docs

---
 scripts/doc-lint.test.ts | 23 ++++++++++++++++-------
 scripts/doc-lint.ts      | 21 +++++++--------------
 src/build.ts             | 12 ++++++------
 3 files changed, 29 insertions(+), 27 deletions(-)

diff --git a/scripts/doc-lint.test.ts b/scripts/doc-lint.test.ts
index 6b11250..1e6f94b 100644
--- a/scripts/doc-lint.test.ts
+++ b/scripts/doc-lint.test.ts
@@ -98,17 +98,26 @@ describe("public documentation gate", () => {
     );
   });
 
-  it("tolerates the named private Builder methods but rejects making one public without JSDoc", async () => {
+  it("keeps private identifiers out of public docs and rejects undocumented methods", async () => {
     await using project = await fixture({ ".": "./build.ts" }, {
       "build.ts":
-        "/** Fixture API. @module */\n/** Builds the fixture. */\nexport class Builder {\n private collectWatchPaths(): void {}\n}\n",
+        "/** Fixture API. @module */\n/** Builds the fixture. */\nexport class Builder {\n #collectWatchPaths(): void {}\n}\n",
     });
     assertEquals((await runGate(project.config)).success, true);
-    await Deno.writeTextFile(
-      join(project.directory, "build.ts"),
-      "/** Fixture API. @module */\n/** Builds the fixture. */\nexport class Builder {\n collectWatchPaths(): void {}\n}\n",
-    );
-    assertEquals((await runGate(project.config)).success, false);
+    for (const name of ["collectWatchPaths", "isPathIgnored"]) {
+      for (const access of ["private ", ""]) {
+        await Deno.writeTextFile(
+          join(project.directory, "build.ts"),
+          `/** Fixture API. @module */\n/** Builds the fixture. */\nexport class Builder {\n ${access}${name}(): void {}\n}\n`,
+        );
+        const result = await runGate(project.config);
+        assertEquals(result.success, false, `${access}${name}`);
+        assertStringIncludes(
+          new TextDecoder().decode(result.stderr),
+          "error[missing-jsdoc]",
+        );
+      }
+    }
   });
 
   it("does not hide a plain fatal error beside an allowed external reference", async () => {
diff --git a/scripts/doc-lint.ts b/scripts/doc-lint.ts
index f6c5792..1767164 100644
--- a/scripts/doc-lint.ts
+++ b/scripts/doc-lint.ts
@@ -1,8 +1,7 @@
 /**
  * Checks every published entrypoint for undocumented API and optionally checks
  * its JSDoc examples. Known external-type diagnostics are scoped to their file,
- * public symbol, and referenced type; the named private Builder methods are
- * exempt only while their source declarations remain private.
+ * public symbol, and referenced type.
  * @module
  */
 import { fromFileUrl, relative, resolve, toFileUrl } from "@std/path";
@@ -85,7 +84,7 @@ function splitDiagnostics(
   return { blocks, fatal, counts };
 }
 
-async function isTolerated(block: string, sourceDir: string): Promise<boolean> {
+function isTolerated(block: string, sourceDir: string): boolean {
   const location = block.match(/^\s*-->\s+(.+):(\d+):(\d+)\s*$/m);
   if (!location) return false;
   const file = location[1].startsWith("file:")
@@ -102,25 +101,19 @@ async function isTolerated(block: string, sourceDir: string): Promise<boolean> {
       .test(file.replaceAll("\\", "/")) &&
       routerReferences.has(reference);
   }
-  if (!block.startsWith("error[missing-jsdoc]:") || localFile !== "build.ts") {
-    return false;
-  }
-  const sourceLine =
-    (await Deno.readTextFile(file)).split(/\r?\n/)[Number(location[2]) - 1];
-  return /^\s*private\s+(?:async\s+)?(?:collectWatchPaths|isPathIgnored)\s*\(/
-    .test(sourceLine ?? "");
+  return false;
 }
 
 /** Classifies one doc invocation; only the named package/type exceptions can pass a lint failure. */
-export async function assessDocLint(
+export function assessDocLint(
   code: number,
   stderr: string,
   sourceDir: string,
-): Promise<{ passed: boolean; violations: string[] }> {
+): { passed: boolean; violations: string[] } {
   const { blocks, fatal, counts } = splitDiagnostics(stderr);
   const violations = [...fatal];
   for (const block of blocks) {
-    if (!await isTolerated(block, sourceDir)) violations.push(block);
+    if (!isTolerated(block, sourceDir)) violations.push(block);
   }
   if (
     code !== 0 &&
@@ -162,7 +155,7 @@ export async function lintDocumentation(
     stderr: "piped",
   }).output();
   const stderr = new TextDecoder().decode(result.stderr);
-  const assessment = await assessDocLint(result.code, stderr, sourceDir);
+  const assessment = assessDocLint(result.code, stderr, sourceDir);
   if (!assessment.passed) {
     console.error(stderr);
     console.error(
diff --git a/src/build.ts b/src/build.ts
index eb293c3..af73430 100644
--- a/src/build.ts
+++ b/src/build.ts
@@ -244,7 +244,7 @@ export class Builder implements AsyncDisposable {
       : [this.watchPaths];
     const resolved: string[] = [];
     for (const root of roots) {
-      await this.collectWatchPaths(
+      await this.#collectWatchPaths(
         path.resolve(this.projectRoot, root),
         resolved,
       );
@@ -252,11 +252,11 @@ export class Builder implements AsyncDisposable {
     return resolved;
   }
 
-  private async collectWatchPaths(
+  async #collectWatchPaths(
     dir: string,
     into: string[],
   ): Promise<void> {
-    if (this.isPathIgnored(dir)) return;
+    if (this.#isPathIgnored(dir)) return;
     const prefix = toPosixPath(dir).replace(/\/+$/, "") + "/";
     const containsIgnored = this.ignorePaths.some((ignore) =>
       toPosixPath(ignore).startsWith(prefix)
@@ -269,8 +269,8 @@ export class Builder implements AsyncDisposable {
       for await (const entry of Deno.readDir(dir)) {
         const child = path.join(dir, entry.name);
         if (entry.isDirectory) {
-          await this.collectWatchPaths(child, into);
-        } else if (!this.isPathIgnored(child)) {
+          await this.#collectWatchPaths(child, into);
+        } else if (!this.#isPathIgnored(child)) {
           into.push(child);
         }
       }
@@ -279,7 +279,7 @@ export class Builder implements AsyncDisposable {
     }
   }
 
-  private isPathIgnored(absolutePath: string): boolean {
+  #isPathIgnored(absolutePath: string): boolean {
     const target = toPosixPath(absolutePath);
     return this.ignorePaths.some((ignore) => {
       const normalized = toPosixPath(ignore);