@tinkerlandai/indiana-iam 0.2.0 → 0.3.0

package/src/dom-payload-browser.mjs

@@ -0,0 +1,28 @@
+import { checkedDomPayload, parsedDomPayload } from "./dom-payload-json.mjs";
+
+/** The viewer decodes locally; it never fetches content or executes merchant code. */
+export async function documentDomBrowser(document) {
+  const payload = checkedDomPayload(document);
+  if (!payload) return { html: document.html, nodes: document.nodes };
+  if (typeof DecompressionStream !== "function") throw Error("Compressed IAM requires DecompressionStream support");
+  const binary = atob(payload.data);
+  if (btoa(binary) !== payload.data) throw Error("Noncanonical compressed DOM base64");
+  const compressed = Uint8Array.from(binary, character => character.charCodeAt(0));
+  const stream = new ReadableStream({ start(controller) { controller.enqueue(compressed); controller.close(); } }).pipeThrough(new DecompressionStream("gzip"));
+  const reader = stream.getReader(), chunks = [];
+  let total = 0;
+  try {
+    for (;;) {
+      const next = await reader.read();
+      if (next.done) break;
+      total += next.value.byteLength;
+      if (total > payload.bytes) throw Error("Expanded DOM byte budget exceeded");
+      chunks.push(next.value);
+    }
+  } finally { await reader.cancel().catch(() => {}); reader.releaseLock(); }
+  if (total !== payload.bytes) throw Error("Expanded DOM byte length mismatch");
+  const decoded = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) { decoded.set(chunk, offset); offset += chunk.byteLength; }
+  return parsedDomPayload(new TextDecoder("utf-8", { fatal: true }).decode(decoded));
+}

package/src/dom-payload-json.mjs

@@ -0,0 +1,12 @@
+/** Shared with the offline viewer. Encodings describe storage, never executable code. */
+export function checkedDomPayload(document) {
+  const payload = document.domPayload;
+  if (!payload) return null;
+  if (document.html !== "" || !Array.isArray(document.nodes) || document.nodes.length || Object.keys(payload).sort().join(",") !== "bytes,data,encoding" || payload.encoding !== "gzip-json-v1" || !Number.isSafeInteger(payload.bytes) || payload.bytes < 1 || payload.bytes > 8_388_608 || typeof payload.data !== "string" || !payload.data.length || payload.data.length > 11_184_812 || payload.data.length % 4 !== 0 || !/^[A-Za-z0-9+/]*={0,2}$/.test(payload.data)) throw Error("Invalid compressed DOM payload");
+  return payload;
+}
+export function parsedDomPayload(text) {
+  const value = JSON.parse(text);
+  if (!value || Object.keys(value).sort().join(",") !== "html,nodes" || typeof value.html !== "string" || value.html.length > 2_000_000 || !value.html.isWellFormed() || !Array.isArray(value.nodes) || value.nodes.length > 12000 || JSON.stringify(value) !== text) throw Error("Invalid expanded DOM payload");
+  return value;
+}

package/src/dom-payload.mjs

@@ -0,0 +1,50 @@
+import { gzip, Inflate } from "pako";
+import { checkedDomPayload, parsedDomPayload } from "./dom-payload-json.mjs";
+
+export const MAX_EXPANDED_DOM_BYTES = 33_554_432;
+
+/** Lossless, local decoding with a declared and enforced output bound. */
+export function documentDom(document) {
+  const payload = checkedDomPayload(document);
+  if (!payload) return { html: document.html, nodes: document.nodes };
+  const compressed = Buffer.from(payload.data, "base64");
+  if (compressed.toString("base64") !== payload.data) throw Error("Noncanonical compressed DOM base64");
+  const inflater = new Inflate({ windowBits: 31, chunkSize: 32_768 });
+  const chunks = [];
+  let total = 0;
+  inflater.onData = chunk => {
+    total += chunk.byteLength;
+    if (total > payload.bytes) throw Error("Expanded DOM byte budget exceeded");
+    chunks.push(chunk);
+  };
+  if (!inflater.push(compressed, true) || inflater.err || !inflater.ended) throw Error("Invalid compressed DOM stream: " + inflater.msg);
+  if (inflater.strm.avail_in !== 0) throw Error("Trailing compressed DOM data");
+  if (total !== payload.bytes) throw Error("Expanded DOM byte length mismatch");
+  const decoded = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) { decoded.set(chunk, offset); offset += chunk.byteLength; }
+  return parsedDomPayload(new TextDecoder("utf-8", { fatal: true }).decode(decoded));
+}
+
+export function assertDomBudget(documents) {
+  let total = 0;
+  for (const document of documents) {
+    const payload = checkedDomPayload(document);
+    total += payload ? payload.bytes : Buffer.byteLength(JSON.stringify({ html: document.html, nodes: document.nodes }));
+    if (total > MAX_EXPANDED_DOM_BYTES) throw Error("Expanded DOM aggregate byte budget exceeded");
+  }
+}
+
+/** Only sizeable, beneficial payloads are compressed; the original IDs and values survive byte-for-byte. */
+export function packDocumentDom(document) {
+  if (document.domPayload) return false;
+  const raw = Buffer.from(JSON.stringify({ html: document.html, nodes: document.nodes }));
+  if (raw.length < 16_384 || raw.length > 8_388_608) return false;
+  const zipped = gzip(raw, { level: 9, header: { time: 0, os: 255 } });
+  const payload = { encoding: "gzip-json-v1", bytes: raw.length, data: Buffer.from(zipped).toString("base64") };
+  if (Buffer.byteLength(JSON.stringify(payload)) + 1024 >= raw.length) return false;
+  document.html = "";
+  document.nodes = [];
+  document.domPayload = payload;
+  return true;
+}

package/src/framework-routes.mjs

@@ -1,3 +1,4 @@
+import { tanstackRoutes } from "./tanstack-routes.mjs";
 import { pagesRoute } from "./routing.mjs";
 import { routeCompositions } from "./route-composition.mjs";
 import { compositionIdentity, flattenComposition } from "./render-index.mjs";
@@ -16,11 +17,15 @@ export function externalImport(module, name) {
 /** Source-only adapters. Merchant modules, loaders and configuration are never executed. */
 export function frameworkRoutes({
   modules,
+  discoveryModules = modules,
+  entry,
   resolveModule,
   ts,
   sourceLocation,
   navigationPaths,
   gap,
+  resolution,
+  inlineComponent,
 }) {
   const files = [...modules.keys()];
   const app = routeCompositions(files, navigationPaths);
@@ -48,6 +53,7 @@ export function frameworkRoutes({
     app.entries.length ||
     (pages.length && (explicitNextPages || (!reactRouting && !reactBootstrap)))
   ) {
+    if (entry) throw Error("entry is for browser applications; scope Next.js by its app root");
     const entries = [...app.entries];
     const hardRoutes = new Set(
       entries.filter((e) => e.entryMode === "hard").map((e) => e.route),
@@ -118,87 +124,17 @@ export function frameworkRoutes({
     return node;
   };
   const external = externalImport;
-  function literal(node, module, seen = new Set()) {
-    node = unwrap(node);
-    if (!node || seen.size > 16) return undefined;
-    if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node))
-      return node.text;
-    if (ts.isIdentifier(node)) {
-      if (seen.has(node.text)) return undefined;
-      return literal(
-        module.bindings.get(node.text),
-        module,
-        new Set([...seen, node.text]),
-      );
-    }
-    if (
-      ts.isPropertyAccessExpression(node) &&
-      ts.isIdentifier(node.expression)
-    ) {
-      const declaration = module.source.statements.find(
-        (s) => ts.isEnumDeclaration(s) && s.name.text === node.expression.text,
-      );
-      const member = declaration?.members.find(
-        (m) =>
-          m.name.getText(module.source).replace(/^['"]|['"]$/g, "") ===
-          node.name.text,
-      );
-      if (member) return literal(member.initializer, module, seen);
-      const record = unwrap(module.bindings.get(node.expression.text));
-      if (record && ts.isObjectLiteralExpression(record))
-        return literal(
-          record.properties.find((p) => p.name?.text === node.name.text)
-            ?.initializer,
-          module,
-          seen,
-        );
-    }
-    return undefined;
-  }
+  const literal = (node, module, seen = new Set()) => resolution.string(node, module, seen);
   function component(tag, module) {
-    const imported = module.imports.get(tag);
-    if (imported) {
-      const target = resolveModule(module.file, imported.specifier);
-      return target
-        ? {
-            file: target.file,
-            symbol:
-              imported.name === "default"
-                ? target.defaultName
-                : (target.exports.get(imported.name) ?? imported.name),
-          }
-        : null;
-    }
-    const local = unwrap(module.bindings.get(tag));
-    // React.lazy(() => import("literal")) is inspected, never invoked.
-    if (
-      local &&
-      ts.isCallExpression(local) &&
-      external(module, local.expression.getText(module.source))?.specifier ===
-        "react" &&
-      external(module, local.expression.getText(module.source))?.name === "lazy"
-    ) {
-      const fn = local.arguments[0],
-        body = fn && ts.isArrowFunction(fn) ? unwrap(fn.body) : null;
-      if (
-        body &&
-        ts.isCallExpression(body) &&
-        body.expression.kind === ts.SyntaxKind.ImportKeyword &&
-        body.arguments.length === 1
-      ) {
-        const specifier = literal(body.arguments[0], module),
-          target =
-            typeof specifier === "string" &&
-            resolveModule(module.file, specifier);
-        if (target) return { file: target.file, symbol: target.defaultName };
-      }
-    }
-    return local ? { file: module.file, symbol: tag } : null;
+    const ref = resolution.component(module, tag);
+    if (ref?.wrapped) gap("LAZY_WRAPPER_UNOBSERVED", module.file, tag + ": only a statically forwarded successful module is projected; retry/reload behavior is not executed");
+    return ref ? { file: ref.module.file, symbol: ref.name } : null;
   }
-  function jsxComponent(node, module) {
+  function jsxComponent(node, module, route) {
     node = unwrap(node);
     if (!node) return null;
-    if (ts.isJsxExpression(node)) return jsxComponent(node.expression, module);
+    if (ts.isJsxExpression(node)) return jsxComponent(node.expression, module, route);
+    if (inlineComponent && route !== undefined && (ts.isArrowFunction(node) || ts.isFunctionExpression(node) || ts.isMethodDeclaration(node))) return inlineComponent(module, node, route);
     if (ts.isJsxElement(node)) {
       const name = node.openingElement.tagName.getText(module.source),
         imported = external(module, name);
@@ -209,13 +145,14 @@ export function frameworkRoutes({
         const children = node.children.filter(
           (n) => !ts.isJsxText(n) || n.text.trim(),
         );
-        return children.length === 1 ? jsxComponent(children[0], module) : null;
+        return children.length === 1 ? jsxComponent(children[0], module, route) : null;
       }
       return component(name, module);
     }
     if (ts.isJsxSelfClosingElement(node))
       return component(node.tagName.getText(module.source), module);
     if (ts.isIdentifier(node)) return component(node.text, module);
+    if (ts.isPropertyAccessExpression(node)) return component(node.getText(module.source), module);
     return null;
   }
   function join(parent, child) {
@@ -321,7 +258,8 @@ export function frameworkRoutes({
       node = unwrap(node);
       if (
         !ts.isObjectLiteralExpression(node) ||
-        node.properties.some((p) => !ts.isPropertyAssignment(p))
+        node.properties.some((p) => !(ts.isPropertyAssignment(p) || ts.isShorthandPropertyAssignment(p) || ts.isMethodDeclaration(p)) || ts.isComputedPropertyName(p.name)) ||
+        new Set(node.properties.map(p => p.name.text)).size !== node.properties.length
       ) {
         gap(
           "ROUTES_UNRESOLVED",
@@ -331,7 +269,7 @@ export function frameworkRoutes({
         continue;
       }
       const properties = new Map(
-        node.properties.map((p) => [p.name.text, p.initializer]),
+        node.properties.map((p) => [p.name.text, ts.isMethodDeclaration(p) ? p : ts.isShorthandPropertyAssignment(p) ? p.name : p.initializer]),
       );
       const rawPath = properties.has("path")
         ? literal(properties.get("path"), module)
@@ -345,10 +283,17 @@ export function frameworkRoutes({
         continue;
       }
       const route = join(parent, rawPath);
-      if (route === null) throw Error("Invalid nested React route");
+      if (route === null) {
+        if (typeof rawPath === "string" && /\?/.test(rawPath)) {
+          gap("ROUTE_PATTERN_UNSUPPORTED", module.file, rawPath + ": optional route parameters require an explicit expansion adapter");
+          continue;
+        }
+        throw Error("Invalid nested React route");
+      }
       const target = jsxComponent(
         properties.get("element") ?? properties.get("Component"),
         module,
+        route,
       );
       const index = properties.get("index")?.kind === ts.SyntaxKind.TrueKeyword;
       if (
@@ -455,8 +400,15 @@ export function frameworkRoutes({
         target = jsxComponent(
           props.get("element") ?? props.get("Component"),
           module,
+          route,
         );
-      if (route === null) throw Error("Invalid nested React route");
+      if (route === null) {
+        if (typeof raw === "string" && /\?/.test(raw)) {
+          gap("ROUTE_PATTERN_UNSUPPORTED", module.file, raw + ": optional route parameters require an explicit expansion adapter");
+          continue;
+        }
+        throw Error("Invalid nested React route");
+      }
       const nested =
         ts.isJsxElement(child) &&
         child.children.some(
@@ -500,7 +452,8 @@ export function frameworkRoutes({
         add(module, child, route, target, ancestors);
     }
   }
-  for (const module of modules.values()) {
+  const tanstack = tanstackRoutes({ discoveryModules, ts, resolution, gap, component: jsxComponent, add, externalImport });
+  for (const module of discoveryModules.values()) {
     if (
       /(^|\/)(__tests__|tests?|stories)(\/|$)|\.(test|spec|stories)\./.test(
         module.file,
@@ -517,7 +470,7 @@ export function frameworkRoutes({
           ["react-router", "react-router-dom"].includes(imported?.specifier) &&
           ["createBrowserRouter", "createHashRouter"].includes(imported.name)
         ) {
-          if (++routers > 1)
+          if (++routers > 1 || tanstack)
             throw Error(
               "Multiple React route authorities require an explicit adapter",
             );
@@ -559,7 +512,7 @@ export function frameworkRoutes({
           ["react-router", "react-router-dom"].includes(imported?.specifier) &&
           imported.name === "Routes"
         ) {
-          if (++routers > 1)
+          if (++routers > 1 || tanstack)
             throw Error(
               "Multiple React route authorities require an explicit adapter",
             );
@@ -571,9 +524,9 @@ export function frameworkRoutes({
     }
     visit(module.source);
   }
-  if (!routers) {
+  if (!routers && !tanstack) {
     let roots = 0;
-    for (const module of modules.values()) {
+    for (const module of discoveryModules.values()) {
       if (
         /(^|\/)(__tests__|tests?|stories)(\/|$)|\.(test|spec|stories)\./.test(
           module.file,
@@ -609,7 +562,7 @@ export function frameworkRoutes({
     }
   }
   return {
-    framework: routers ? "react-router" : "react-spa",
+    framework: tanstack ? "tanstack-router" : routers ? "react-router" : "react-spa",
     entries,
     pageFiles: [...new Set(entries.map((e) => e.sourceFile))],
     unsupported: [],

package/src/generate.mjs

@@ -2,7 +2,8 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import { analyze } from "./analyze.mjs";
 import { validate } from "./validate.mjs";
-import { sha256 } from "./integrity.mjs";
+import { documentDom, packDocumentDom, assertDomBudget } from "./dom-payload.mjs";
+import { sha256, sealDocument } from "./integrity.mjs";
 import { attachBuildStyles, shareDocumentStyles } from "./build-styles.mjs";
 import { releasePath } from "./release-metadata.mjs";
 import { shareDocumentScripts, documentScript } from "./shared-scripts.mjs";
@@ -11,9 +12,9 @@ import { refreshRenderHashes } from "./render-index.mjs";
 export const IAM_MAX_BYTES = 8_388_608;
 
 /** Scans the source checkout. The result is the input of {@link generateAppManifest}. */
-export async function analyzeSource({ root, name, repository = "", commit = "", navigationPaths = [], automaticAnchors = false }) {
+export async function analyzeSource({ root, name, repository = "", commit = "", navigationPaths = [], entry, automaticAnchors = false }) {
   root = await fs.realpath(root);
-  return analyze({ root, name: name || path.basename(root), repository, commit, navigationPaths, automaticAnchors });
+  return analyze({ root, name: name || path.basename(root), repository, commit, navigationPaths, entry, automaticAnchors });
 }
 
 /**
@@ -27,6 +28,7 @@ export async function generateAppManifest({
   repository,
   commit,
   navigationPaths,
+  entry,
   automaticAnchors = false,
   releaseId,
   buildCss = [],
@@ -39,7 +41,12 @@ export async function generateAppManifest({
   root = await fs.realpath(root);
   const manifest = analysis
     ? structuredClone(analysis)
-    : await analyzeSource({ root, name, repository, commit, navigationPaths, automaticAnchors });
+    : await analyzeSource({ root, name, repository, commit, navigationPaths, entry, automaticAnchors });
+  for (const document of manifest.documents) if (document.domPayload) {
+    Object.assign(document, documentDom(document));
+    delete document.domPayload;
+    sealDocument(document);
+  }
   if (releaseId) {
     releasePath(releaseId);
     manifest.release.runtimeBinding = { schemaVersion: 1, releaseId };
@@ -57,6 +64,9 @@ export async function generateAppManifest({
   else if (rootFont) throw new Error("rootFont requires build CSS");
   shareDocumentStyles(manifest);
   shareDocumentScripts(manifest);
+  assertDomBudget(manifest.documents);
+  if (Buffer.byteLength(JSON.stringify(manifest)) > 4_194_304)
+    for (const document of manifest.documents) if (packDocumentDom(document)) sealDocument(document);
   refreshRenderHashes(manifest);
   const validation = await validate(manifest);
   const serialized = JSON.stringify(manifest) + "\n",
@@ -83,15 +93,16 @@ export async function writeAppManifestOutput({ root, out, result }) {
       await fs.writeFile(path.join(out, "styles", style.styleKey + ".css"), style.css);
   }
   for (const document of manifest.documents) {
+    const decoded = documentDom(document);
     const folder = path.join(out, "documents", document.documentKey);
     await fs.mkdir(folder, { recursive: true });
     await Promise.all([
-      fs.writeFile(path.join(folder, "page.html"), document.html),
+      fs.writeFile(path.join(folder, "page.html"), decoded.html),
       fs.writeFile(path.join(folder, "page.css"), document.css),
       fs.writeFile(path.join(folder, "page.js"), documentScript(manifest, document)),
       fs.writeFile(
         path.join(folder, "dom-map.json"),
-        JSON.stringify({ rootNodeId: document.rootNodeId, nodes: document.nodes, hashes: document.hashes }, null, 2) + "\n",
+        JSON.stringify({ rootNodeId: document.rootNodeId, nodes: decoded.nodes, hashes: document.hashes }, null, 2) + "\n",
       ),
     ]);
   }

package/src/index.d.ts

@@ -20,6 +20,8 @@ export type ValidationCounts = Record<string, unknown>;
 
 export type GenerateOptions = {
   root: string;
+  /** Browser entry relative to root. Defaults to the single module script in index.html. */
+  entry?: string;
   automaticAnchors?: boolean;
   /** A previous {@link analyzeSource} result; scanned again when omitted. */
   analysis?: AppManifest;
@@ -47,6 +49,8 @@ export type GeneratedAppManifest = {
 export declare const IAM_MAX_BYTES: 8388608;
 export declare function analyzeSource(options: {
   root: string;
+  /** Browser entry relative to root. Defaults to the single module script in index.html. */
+  entry?: string;
   automaticAnchors?: boolean;
   name?: string;
   repository?: string;
@@ -82,6 +86,8 @@ export type BuildLogger = Pick<Console, "log" | "warn">;
 export type BuildReleaseOptions = {
   strict?: boolean;
   logger?: BuildLogger;
+  /** Browser entry relative to root. Defaults to the single module script in index.html. */
+  entry?: string;
   automaticAnchors?: boolean;
 };
 export declare function prepareBuildRelease(
@@ -114,10 +120,13 @@ export declare function finishBuildRelease(
 } | null>;
 
 export declare const DEFAULT_BASE_URL: "https://tinker.cash";
+export declare const DEFAULT_CLIENT: "web";
 export declare function uploadAppManifest(options: {
   serialized: string;
   digest: string;
   label: string;
+  /** Defaults to `web`; each client of an App environment has its own current version. */
+  client?: string;
   apiKey: string;
   baseUrl?: string;
   fetch?: typeof globalThis.fetch;
@@ -133,9 +142,10 @@ export declare function uploadSettings(
     apiKey?: string;
     baseUrl?: string;
     upload?: "production" | "always" | false | true;
+    client?: string;
   },
   env?: Record<string, string | undefined>,
-): { enabled: boolean; apiKey: string; baseUrl: string; missingKey: boolean };
+): { enabled: boolean; apiKey: string; baseUrl: string; client: string; missingKey: boolean };
 export declare function buildLabel(
   root: string,
   env?: Record<string, string | undefined>,

package/src/index.mjs

@@ -6,4 +6,4 @@ export { nextStaticMounts } from "./build-styles.mjs";
 export { transformSourceForIam } from "./transform.mjs";
 export { rebindIamSource } from "./rebind.mjs";
 export { planAnchors, applyAnchors } from "./instrument.mjs";
-export { uploadAppManifest, uploadSettings, buildLabel, DEFAULT_BASE_URL } from "./upload.mjs";
+export { uploadAppManifest, uploadSettings, buildLabel, DEFAULT_BASE_URL, DEFAULT_CLIENT } from "./upload.mjs";

package/src/integrity.mjs

@@ -1,4 +1,5 @@
 import { createHash } from "node:crypto";
+import { documentDom } from "./dom-payload.mjs";
 
 export const sha256 = (bytes) =>
   createHash("sha256").update(bytes).digest("hex");
@@ -70,13 +71,14 @@ export function sealNodes(nodes, rootId) {
 }
 export function sealDocument(document) {
   const { hashes: _hashes, ...body } = document;
+  const dom = documentDom(document);
   document.hashes = {
-    html: sha256(document.html),
+    html: sha256(dom.html),
     css: sha256(document.css),
     js: sha256(document.js),
     dom: hashObject("iam/dom-map/v1", {
       rootNodeId: document.rootNodeId,
-      nodes: document.nodes,
+      nodes: dom.nodes,
       ...(document.sourceMappingsHash?{sourceMappingsHash:document.sourceMappingsHash}:{}),
     }),
     document: hashObject("iam/document/v1", body),

package/src/library-entry.mjs

@@ -8,6 +8,7 @@ import{renderGuardFor}from'./render-index.mjs';
 import { documentScript } from "./shared-scripts.mjs";
 import { documentNodes } from './node-hashes.mjs';
 export { documentNodes as iamDocumentNodes } from './node-hashes.mjs';
+export { documentDom as iamDocumentDom } from './dom-payload.mjs';
 export { rebindIamSource } from './rebind.mjs';
 export const parseIamJson = parseManifest;
 export async function isReviewedIamScript(value) {

package/src/next.mjs

@@ -17,12 +17,12 @@ const sourceLoader = fileURLToPath(new URL("./next-loader.cjs", import.meta.url)
  * for production deployments). Development servers and other phases get the config unchanged.
  */
 export function withIndianaIam(nextConfig = {}, options = {}) {
-  const { enabled = true, root, name, automaticAnchors = true, strict = false, rootFont, omitSvgResources, logger = console, apiKey, baseUrl, upload, fetch } = options;
+  const { enabled = true, root, name, entry, automaticAnchors = true, strict = false, rootFont, omitSvgResources, logger = console, apiKey, baseUrl, upload, client, fetch } = options;
   return async (phase, context) => {
     const config = typeof nextConfig === "function" ? await nextConfig(phase, context) : nextConfig;
     if (phase !== PRODUCTION_BUILD || !enabled) return config;
     const directory = path.resolve(root ?? process.cwd());
-    const prepared = await prepareBuildRelease({ root: directory, name, automaticAnchors, strict, logger });
+    const prepared = await prepareBuildRelease({ root: directory, name, entry, automaticAnchors, strict, logger });
     if (!prepared) return config;
     const { releaseId } = prepared;
     const previous = config.compiler?.runAfterProductionCompile;
@@ -56,13 +56,14 @@ export function withIndianaIam(nextConfig = {}, options = {}) {
             root: build.projectDir,
             releaseId,
             name,
+            entry,
             automaticAnchors,
             cssDirectory: distDir + "/static",
             mounts: nextStaticMounts(distDir, config.basePath ?? ""),
             publicDirectory: "public",
             rootFont,
             omitSvgResources,
-            upload: { apiKey, baseUrl, upload, fetch },
+            upload: { apiKey, baseUrl, upload, client, fetch },
             strict,
             logger,
           });

package/src/node-hashes.mjs

@@ -1,3 +1,4 @@
+import { documentDom } from "./dom-payload.mjs";
 import { canonical, sealNodes, sealDocument } from './integrity.mjs';
 import { dependency } from './dependencies.mjs';
 import { sourceMappingsHash } from './compact-dom.mjs';
@@ -20,8 +21,9 @@ export function expandDomNodes(document, body) {
   return result;
 }
 function domNodes(document){
-  const {JSDOM}=dependency('jsdom').value,dom=new JSDOM('<!doctype html><html><body>'+document.html+'</body></html>');
-  try{return expandDomNodes(document,dom.window.document.body);}finally{dom.window.close();}
+  const decoded = {...document, ...documentDom(document)};
+  const {JSDOM}=dependency('jsdom').value,dom=new JSDOM('<!doctype html><html><body>'+decoded.html+'</body></html>');
+  try{return expandDomNodes(decoded,dom.window.document.body);}finally{dom.window.close();}
 }
 
 /** Node hashes are pure derived values. IDs, source mappings and algorithms never change. */
@@ -32,6 +34,7 @@ export function documentNodes(document) {
 }
 /** Serialize the producer's in-memory DOM into the single admitted wire representation. */
 export function storeDocumentNodes(document, nodes, elements) {
+  delete document.domPayload;
   document.sourceMappingsHash = sourceMappingsHash(nodes, elements);
   document.nodeEncoding = 'html-preorder-v1';
   document.nodeHashMode = 'derived-v1';

package/src/render-index.mjs

@@ -5,7 +5,7 @@ export function flattenComposition(root) {
   const entries = [];
   function visit(branch) {
     if (!branch) return;
-    entries.push({ lane: branch.lane, file: branch.file, layers: branch.layers.map(layer => ({ file: layer.file, slots: layer.slots.map(slot => ({ name: slot.name, lane: slot.branch?.lane ?? null })) })) });
+    entries.push({ lane: branch.lane, file: branch.file, ...(branch.symbol ? { symbol: branch.symbol } : {}), layers: branch.layers.map(layer => ({ file: layer.file, ...(layer.symbol ? { symbol: layer.symbol } : {}), slots: layer.slots.map(slot => ({ name: slot.name, lane: slot.branch?.lane ?? null })) })) });
     for (const layer of branch.layers) for (const slot of layer.slots) visit(slot.branch);
   }
   visit(root);
@@ -36,6 +36,7 @@ export function renderTreeSchema(base) {
   p.renderNavigation=array(object({fromRenderKey:str,toRenderKey:str}),512);
   p.guards = array(object({ routeKey: str, selectorKeys: array({type:"integer",minimum:0,maximum:511}, 512) }), 200);
   p.compositions = array(object({ compositionKey: str, entries: array(object({ lane: str, file: str, layers: array(object({ file: str, slots: array(object({ name: str, lane: nullable(str) }), 32) }), 32) }), 128) }), 1000);
+  for (const shape of [p.compositions.items.properties.entries.items, p.compositions.items.properties.entries.items.properties.layers.items]) shape.properties.symbol = str;
   schema.required.push("renders", "guards", "compositions", "selectorPool", "renderNavigation");
   return schema;
 }
@@ -85,7 +86,7 @@ export function attachRenderIndex(graph, manifest, definitions, navigation=[]) {
 }
 
 export function validateRenderIndex(graph, manifest) {
-  const contained = (file, lane) => lane === "." && ["react-router", "react-spa"].includes(manifest.routing.framework)
+  const contained = (file, lane) => lane === "." && ["react-router", "react-spa", "tanstack-router"].includes(manifest.routing.framework)
     ? !file.startsWith("/") && !file.split("/").includes("..")
     : file.startsWith(lane + "/");
   const unique = (rows, key) => {
@@ -95,14 +96,15 @@ export function validateRenderIndex(graph, manifest) {
   };
   const renders = unique(graph.renders, "renderKey"), compositions = unique(graph.compositions, "compositionKey"), guards = unique(graph.guards, "routeKey");
   const files = new Set(manifest.sourceFiles.map(file => file.file));
+  const knownSymbol = entry => !entry.symbol || manifest.components.some(component => component.file === entry.file && component.name === entry.symbol);
   for (const composition of compositions.values()) {
     if (composition.compositionKey !== compositionIdentity(composition.entries)) throw new Error("Composition identity mismatch");
     const lanes = new Set();
     for (const entry of composition.entries) {
-      if (lanes.has(entry.lane) || !files.has(entry.file) || !contained(entry.file, entry.lane)) throw new Error("Invalid composition entry");
+      if (lanes.has(entry.lane) || !files.has(entry.file) || !contained(entry.file, entry.lane) || !knownSymbol(entry)) throw new Error("Invalid composition entry");
       lanes.add(entry.lane);
       for (const layer of entry.layers) {
-        if (!files.has(layer.file) || !contained(layer.file, entry.lane)) throw new Error("Invalid composition layout");
+        if (!files.has(layer.file) || !contained(layer.file, entry.lane) || !knownSymbol(layer)) throw new Error("Invalid composition layout");
         const folder = layer.file.slice(0, layer.file.lastIndexOf("/"));
         for (const slot of layer.slots) if (slot.lane !== null && slot.lane !== folder + "/@" + slot.name) throw new Error("Invalid composition slot");
       }

package/src/routing.mjs

@@ -26,7 +26,7 @@ export function pagesRoute(file) {
 
 /** Router configuration provenance is explicit for source-declared React routes. */
 export function sourcePageRoute(page, routing) {
-  if (["react-router", "react-spa"].includes(routing.framework)) {
+  if (["react-router", "react-spa", "tanstack-router"].includes(routing.framework)) {
     const rows = routing.routeSources?.filter(
       (row) =>
         row.path === page.route &&

package/src/schema-definition.mjs

@@ -39,7 +39,7 @@ export const schema = {
       platforms: array({ enum: ["web", "ios", "android"] }, 3),
     }),
     routing: object({
-      framework: { enum: ["next-app-router", "next-pages-router", "react-router", "react-spa"] },
+      framework: { enum: ["next-app-router", "next-pages-router", "react-router", "react-spa", "tanstack-router"] },
       basePath: str,
       trailingSlash: { type: "boolean" },
       routeSources: array(object({ path: str, source, componentFile: str, componentSymbol: str }), 200),
@@ -176,3 +176,10 @@ schema.properties.styles=array(object({styleKey:{type:'string',pattern:'^style_[
 schema.properties.documents.items.properties.styleKeys=array({type:'string',pattern:'^style_[a-f0-9]{64}$'},16);
 schema.properties.scripts=array(object({scriptKey:{type:'string',pattern:'^script_[a-f0-9]{64}$'},sha256:hash,js:{type:'string',maxLength:100000}}),8);
 schema.properties.documents.items.properties.scriptKey={type:'string',pattern:'^script_[a-f0-9]{64}$'};
+
+// HTML and preorder mappings may use bounded lossless storage compression.
+schema.properties.documents.items.properties.domPayload = object({
+  encoding: { const: "gzip-json-v1" },
+  bytes: { type: "integer", minimum: 1, maximum: 8_388_608 },
+  data: { type: "string", minLength: 1, maxLength: 11_184_812 },
+});