@tinkerlandai/indiana-iam 0.2.0 → 0.4.0

package/src/framework-routes.mjs

@@ -1,3 +1,5 @@
+import { tanstackRoutes } from "./tanstack-routes.mjs";
+import { routeLazyComponent } from "./route-lazy.mjs";
 import { pagesRoute } from "./routing.mjs";
 import { routeCompositions } from "./route-composition.mjs";
 import { compositionIdentity, flattenComposition } from "./render-index.mjs";
@@ -16,11 +18,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 +54,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 +125,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 +146,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 +259,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 +270,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,11 +284,19 @@ 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,
+      ) ?? (!properties.has("element") && !properties.has("Component") && properties.has("lazy")
+        ? routeLazyComponent(properties.get("lazy"), module, { ts, resolution, resolveModule }) : null);
       const index = properties.get("index")?.kind === ts.SyntaxKind.TrueKeyword;
       if (
         properties.has("index") &&
@@ -455,8 +402,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 +454,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 +472,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 +514,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 +526,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 +564,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,10 +28,12 @@ export async function generateAppManifest({
   repository,
   commit,
   navigationPaths,
+  entry,
   automaticAnchors = false,
   releaseId,
   buildCss = [],
   publicAssets = [],
+  referencedImages = false,
   optimizePublicImages = false,
   rootFont = "",
   omitSvgResources = false,
@@ -39,16 +42,22 @@ 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 };
   }
-  if (buildCss.length || publicAssets.length)
+  if (buildCss.length || publicAssets.length || referencedImages)
     await attachBuildStyles(manifest, {
       root,
       files: buildCss,
       publicFiles: publicAssets,
+      referencedImages,
       optimizePublicImages,
       rootFont,
       omitSvgResources,
@@ -57,6 +66,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 +95,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/graph-sources.mjs

@@ -0,0 +1,54 @@
+import { canonical } from "./integrity.mjs";
+/** Lossless references to repeated source locations; semantic identities and hashes stay unchanged. */
+export function internGraphSources(graph) {
+  const rows = [
+      "variables",
+      "bindings",
+      "transitions",
+      "states",
+      "navigation",
+      "uncovered",
+    ].flatMap((key) => graph[key]),
+    counts = new Map();
+  for (const row of rows) {
+    const key = canonical(row.source);
+    counts.set(key, (counts.get(key) ?? 0) + 1);
+  }
+  const pool = [],
+    indices = new Map();
+  for (const row of rows) {
+    const key = canonical(row.source);
+    if (counts.get(key) < 2) continue;
+    let index = indices.get(key);
+    if (index === undefined) {
+      index = pool.length;
+      indices.set(key, index);
+      pool.push(row.source);
+    }
+    row.source = index;
+  }
+  if (pool.length) graph.sourcePool = pool;
+  const scopes = [],
+    scopeIndices = new Map(),
+    scopeCounts = new Map();
+  for (const v of graph.variables)
+    scopeCounts.set(v.scopeKey, (scopeCounts.get(v.scopeKey) ?? 0) + 1);
+  for (const v of graph.variables)
+    if (scopeCounts.get(v.scopeKey) > 1) {
+      let i = scopeIndices.get(v.scopeKey);
+      if (i === undefined) {
+        i = scopes.length;
+        scopeIndices.set(v.scopeKey, i);
+        scopes.push(v.scopeKey);
+      }
+      v.scopeKey = i;
+    }
+  if (scopes.length) graph.scopePool = scopes;
+}
+export function graphSource(graph, row) {
+  return typeof row?.source === "number"
+    ? Number.isInteger(row.source)
+      ? graph.sourcePool?.[row.source]
+      : undefined
+    : row?.source;
+}

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;
@@ -30,6 +32,8 @@ export type GenerateOptions = {
   releaseId?: string;
   buildCss?: string[];
   publicAssets?: string[];
+  /** Package only projected local raster references; large images use the bounded build preview profile. */
+  referencedImages?: boolean;
   optimizePublicImages?: boolean;
   rootFont?: string;
   omitSvgResources?: boolean;
@@ -47,6 +51,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 +88,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 +122,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 +144,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) {
@@ -81,3 +82,7 @@ export async function renderIamViewer(manifest, context) {
     .replace('<link rel="stylesheet" href="viewer.css" />', base ? '<link rel="stylesheet" href="'+asset(assets.css,'.css')+'" integrity="'+integrity(assets.css)+'" crossorigin="anonymous">' : '<style>' + assets.css.replaceAll(/<\/style/gi, "<\\/style") + '</style>')
     .replace('<script src="viewer.js"></script>', '<script id="iam-context" type="application/json">' + json(context) + '</script>' + (base ? '<script src="'+asset(assets.js,'.js')+'" integrity="'+integrity(assets.js)+'" crossorigin="anonymous"></script>' : '<script>' + script + '</script>'));
 }
+
+export { previewUiDocument as previewIamUiDocument } from './ui-preview.mjs';
+
+export { tabUiScenes as iamTabUiScenes } from './tab-scenes.mjs';

package/src/lucide-source.mjs

@@ -0,0 +1,18 @@
+import { createRequire } from "node:module";
+// Pinned, inert geometry data. Merchant packages and React components are never imported.
+const require = createRequire(import.meta.url),
+  catalog = require("lucide-static/icon-nodes.json");
+export const LUCIDE_SOURCE_VERSION = "1.34.0";
+export const LUCIDE_SOURCE = Symbol("source-lucide");
+export function lucideSource(name) {
+  const key = name
+    .replace(/Icon$/, "")
+    .replace(/([A-Z])([A-Z][a-z])/g, "$1-$2")
+    .replace(/([a-z0-9])([A-Z])/g, "$1-$2")
+    .replace(/([a-zA-Z])(\d)/g, "$1-$2")
+    .toLowerCase();
+  return Object.hasOwn(catalog, key) ? { [LUCIDE_SOURCE]: key } : null;
+}
+export function lucideGeometry(value) {
+  return catalog[value?.[LUCIDE_SOURCE]] ?? null;
+}

package/src/next-loader.cjs

@@ -7,10 +7,16 @@ module.exports = function indianaIamLoader(source, inputMap) {
   const { root } = this.getOptions();
   Promise.all([
     import("./transform.mjs"),
-    fs.realpath(this.resourcePath),
+    fs.realpath(this.resourcePath).catch((error) => {
+      // Turbopack can retype loader output (e.g. icon.svg -> icon.svg.js).
+      // Such virtual modules have no original source binding to instrument.
+      if (error.code === "ENOENT" || error.code === "ENOTDIR") return null;
+      throw error;
+    }),
     fs.realpath(root),
   ])
     .then(([{ transformSourceForIam }, resource, directory]) => {
+      if (!resource) return done(null, source, inputMap);
       const file = path.relative(directory, resource).split(path.sep).join("/");
       if (file.startsWith("../") || path.isAbsolute(file))
         return done(null, source, inputMap);

package/src/next.cjs

@@ -0,0 +1,5 @@
+/** Next transpiles next.config.ts to CommonJS before loading its plugins. */
+exports.withIndianaIam = (nextConfig = {}, options = {}) => async (phase, context) => {
+  const { withIndianaIam } = await import("./next.mjs");
+  return withIndianaIam(nextConfig, options)(phase, context);
+};

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,27 +1,29 @@
-import { canonical, sealNodes, sealDocument } from './integrity.mjs';
+import { documentDom } from "./dom-payload.mjs";
+import { canonical, identity, sealNodes, sealDocument } from './integrity.mjs';
 import { dependency } from './dependencies.mjs';
 import { sourceMappingsHash } from './compact-dom.mjs';
 
 /** HTML already owns the DOM values and ordering. Store only the source map
  * in preorder, rather than repeating attributes, text and every tree edge. */
-export function expandDomNodes(document, body) {
+export function expandDomNodes(document, body, deriveTextId) {
   if(document.nodeEncoding!=='html-preorder-v1'||document.nodeHashMode!=='derived-v1'||!document.sourceMappingsHash||document.nodes.length>12000)throw Error('Invalid HTML-derived DOM mode');
   let index=0;const result=[];
-  function visit(node,parentId,depth){
+  function visit(node,parentId,depth,childIndex=0){
     if(depth>128||![1,3].includes(node.nodeType))throw Error('Invalid HTML-derived DOM structure');
     const ref=document.nodes[index++];
     if(!ref||Object.keys(ref).some(key=>!['nodeId','elementKey','source','synthetic'].includes(key)))throw Error('Mixed HTML-derived DOM values');
-    const element=node.nodeType===1,nodeId=element?node.getAttribute('data-iam-node'):ref.nodeId;
+    const element=node.nodeType===1,nodeId=element?node.getAttribute('data-iam-node'):ref.nodeId??deriveTextId?.(document.pageKey,parentId,childIndex);
     if(!/^node_[a-f0-9]{64}$/.test(nodeId??'')||element&&Object.hasOwn(ref,'nodeId')||Object.hasOwn(ref,'synthetic')&&ref.synthetic!==true)throw Error('HTML-derived DOM identity differs');
     const full={...ref,nodeId,synthetic:ref.synthetic??false,parentId,kind:element?'element':'text',tag:element?node.tagName.toLowerCase():null,text:element?null:node.data,attributes:element?Object.fromEntries([...node.attributes].filter(a=>!a.name.startsWith('data-iam-')).map(a=>[a.name,a.value])):{},children:[]};
-    result.push(full);for(const child of node.childNodes)full.children.push(visit(child,nodeId,depth+1));return nodeId;
+    result.push(full);for(const [i,child]of [...node.childNodes].entries())full.children.push(visit(child,nodeId,depth+1,i));return nodeId;
   }
   if(body.childNodes.length!==1||visit(body.firstChild,null,0)!==document.rootNodeId||index!==document.nodes.length)throw Error('HTML-derived DOM coverage differs');
   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,(page,parentId,index)=>identity('node',{page,parentId,index,kind:3}));}finally{dom.window.close();}
 }
 
 /** Node hashes are pure derived values. IDs, source mappings and algorithms never change. */
@@ -32,11 +34,13 @@ 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';
-  document.nodes = nodes.map(({nodeId,kind,elementKey,synthetic,source}) => ({
-    ...(kind === 'text' ? {nodeId} : {}),
+  const byId=new Map(nodes.map(node=>[node.nodeId,node]));
+  document.nodes = nodes.map(({nodeId,parentId,kind,elementKey,synthetic,source}) => ({
+    ...(kind === 'text' && nodeId!==identity('node',{page:document.pageKey,parentId,index:byId.get(parentId)?.children.indexOf(nodeId)??0,kind:3}) ? {nodeId} : {}),
     elementKey,
     ...(synthetic ? {synthetic:true} : {}),
     ...(source && canonical(source) !== canonical(elements.get(elementKey)?.source) ? {source} : {}),