@tinkerlandai/indiana-iam 0.2.0 → 0.3.0

package/README.md

@@ -47,7 +47,7 @@ not import merchant modules to execute them. Source enumeration and optional Git
 the package starts no external commands and works without a Git executable. Developers' explicitly configured
 framework callbacks remain part of their normal build.
 
-## Vite and React Router
+## Vite, React Router and TanStack Router
 
 ```js
 // vite.config.mjs
@@ -56,12 +56,20 @@ import { indianaIam } from "@tinkerlandai/indiana-iam/vite";
 export default { plugins: [indianaIam()] };
 ```
 
+Use an ESM Vite config (`vite.config.mjs` or `vite.config.mts`, or a project with `"type": "module"`).
+CommonJS configs cannot `require` this ESM package.
+
 Client builds expose `import.meta.env.INDIANA_IAM_RELEASE_URL` and write the descriptor into the build output folder.
 Server builds are skipped.
 
+Browser apps use the single local module script in `index.html` to select reachable router and React root declarations.
+For multiple entry points, set `indianaIam({ entry: "src/main.tsx" })`, or pass `--entry src/main.tsx` to standalone generation.
+The path must stay inside the scanned root. Next.js uses its App/Pages root instead.
+
 ## Options
 
-Both integrations accept `{ enabled, name, automaticAnchors, strict, rootFont, omitSvgResources, logger, apiKey, baseUrl, upload }`;
+Both integrations accept `{ enabled, name, automaticAnchors, strict, rootFont, omitSvgResources, logger, apiKey, baseUrl, upload, client }`;
+browser applications additionally accept `entry`;
 `withIndianaIam` also takes `root`. By default a source the scanner cannot read prints a warning and the build continues without an IAM;
 `strict: true` fails the build instead. The same source always produces the same release ID and IAM bytes.
 If source changes during compilation, generation fails instead of publishing a descriptor for different code.
@@ -99,7 +107,20 @@ optional command for explicit source annotations. Next and Vite do not need that
 
 ## Scope
 
-Supported source: Next.js App Router and Pages Router, and React Router / single-root React apps built with Vite.
+Supported source: Next.js App Router and Pages Router, React Router / single-root React apps built with Vite,
+and statically generated TanStack file-route trees registered with `createRouter({ routeTree })`.
+React Router supports imported static path constants, inline `Component` functions and source-proven lazy import forwarding.
+TanStack reads the registered generated tree, including pathless layouts, index routes and simple `$param` paths;
+custom history/basepath and complex parameter patterns require separate adapters. Loaders, guards, retry/reload behavior
+and runtime data remain unobserved. Unsupported optional React paths are isolated as gaps.
+The complete validated IAM must fit within 8 MiB; oversized projections fail without emitting a truncated artifact.
+Large artifacts store sizeable HTML/preorder-map pairs as `domPayload` (`gzip-json-v1`), while keeping `html: ""`
+and `nodes: []` in that document's wire record. This lossless storage encoding preserves all source IDs, DOM values,
+HTML/DOM hashes and targets. The document hash pins its encoded storage body; decoding is local and bounded to
+8 MiB per payload and 32 MiB in aggregate. The final IAM file limit stays 8 MiB. Exported page HTML is expanded.
+Use the matching 0.3 generator, validator and viewer together. Indiana ingestion/viewer sources must be updated
+before uploading compressed artifacts; publishing this npm package alone does not deploy Indiana. The offline
+viewer uses the browser's built-in `DecompressionStream` and never fetches a decoder or merchant content.
 The scanner reads source files only; it never runs your build, imports your code or reads env files. Only the upload
 step calls Indiana, and only when a key is set.
 Values that look like credentials, tokens, emails or private URLs are removed, but review what your pages contain.
@@ -108,13 +129,61 @@ Values that look like credentials, tokens, emails or private URLs are removed, b
 
 Create a Key with only the `app-manifests:write` permission (Console → developer settings) and set it as
 `INDIANA_IAM_KEY` in your build environment. Each production build then registers the IAM, stores it through a
-server-signed URL and asks Indiana to validate it; the validated version becomes the environment's current version.
+server-signed URL and asks Indiana to validate it; the validated version becomes its client's current version.
 Rebuilding unchanged source only makes the existing version current again.
 
+An App environment can hold several clients, each a named build with its own current version: for example `web` and
+`web-dashboard`, or later `ios` and `android` apps. Set the `client` option (or `INDIANA_IAM_CLIENT`) to 1-40 lowercase
+letters, digits or hyphens starting with a letter; the default is `web`. A client keeps the platform of its first
+upload, and the same IAM bytes cannot be uploaded for two clients.
+
 - Uploads go to `https://tinker.cash`; set `INDIANA_IAM_BASE_URL` (or the `baseUrl` option) for another Indiana
   environment.
 - On Vercel only production deployments upload by default; `upload: "always"` uploads every build and
   `upload: false` never uploads.
 - A failed upload prints a warning and the build continues, unless `strict: true`.
 - The App's Owner or Admin must turn on the App page map first.
-- `INDIANA_IAM_KEY=<key> indiana-iam upload --file <manifest>` uploads a file generated elsewhere.
+- `INDIANA_IAM_KEY=<key> indiana-iam upload --file <manifest> [--client <key>]` uploads a file generated elsewhere.
+
+## App map annotations
+
+The Console App map groups pages into areas, shows recorded navigation, and opens a main-path workbench before
+opening a page editor. Thumbnails are static source projections. They do not execute authentication, data loaders,
+form submissions or application code.
+
+Optional static attributes preserve product intent that cannot be established from a URL alone:
+
+| Attribute                                          | Location                                 | Meaning                                                                                                           |
+| -------------------------------------------------- | ---------------------------------------- | ----------------------------------------------------------------------------------------------------------------- |
+| `data-indiana-map-area`                            | Page root                                | Functional area label; otherwise the first URL segment groups the directory.                                      |
+| `data-indiana-map-flow`                            | Page root                                | Display name for the process containing this page.                                                                |
+| `data-indiana-map-kind="login"`                    | Page root                                | Declares an authentication page.                                                                                  |
+| `data-indiana-map-auth="public\|required"`         | Page root                                | Declares the page's access requirement. Omission remains unknown.                                                 |
+| `data-indiana-map-edge="step\|tab\|login\|return"` | An existing link or supported UI control | Classifies an existing recorded action. It never invents a destination or makes an unsupported action executable. |
+
+Use one consistent declaration on the outer page element. Native `role="tab"` also classifies a Tab control.
+A link Tab retains its exact destination URL, including query and fragment; a supported state-writing Tab remains
+an in-page action. Login and return links remain separate from ordinary steps. Unsupported actions appear as
+unknown outcomes. Authentication requirements are display declarations, not proof of a session or runtime access.
+
+```tsx
+<main
+  data-indiana-map-area="Workspace"
+  data-indiana-map-flow="Create project"
+  data-indiana-map-auth="required"
+>
+  <a href="/login?next=%2Fprojects" data-indiana-map-edge="login">
+    Sign in
+  </a>
+  <a href="/projects/configure" data-indiana-map-edge="step">
+    Continue
+  </a>
+  <a href="/projects?tab=activity" role="tab">
+    Activity
+  </a>
+</main>
+```
+
+An unambiguous source path can continue automatically until a branch or cycle. Explicit step links take precedence
+over ordinary navigation; login/return links and Tabs are inspected separately. A new IAM build is needed to add
+these annotations to an already uploaded version. Existing immutable versions are never rewritten.

package/assets/viewer.js

@@ -489,6 +489,44 @@ async function mountIamViewer(m, consoleContext) {
   }
   // Verify the compact source document first, then derive its exact v1 hashes.
   // Work is page-local and cancellable; hashes never become another saved authority.
+  /* BEGIN COMPRESSED DOM */
+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;
+}
+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;
+}
+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));
+}
+  /* END COMPRESSED DOM */
   /* BEGIN HTML DOM DERIVATION */
 function expandDomNodes(document, body) {
   if(document.nodeEncoding!=='html-preorder-v1'||document.nodeHashMode!=='derived-v1'||!document.sourceMappingsHash||document.nodes.length>12000)throw Error('Invalid HTML-derived DOM mode');
@@ -507,6 +545,14 @@ function expandDomNodes(document, body) {
 }
   /* END HTML DOM DERIVATION */
   async function expandNodeHashes(document,request) {
+    if (document.domPayload) {
+      const {hashes, ...body} = document;
+      if (await hash("iam/document/v1\0" + canonical(body)) !== hashes.document) throw Error("Compressed document hash mismatch");
+      const decoded = await documentDomBrowser(document);
+      if (await hash(decoded.html) !== hashes.html || await hash("iam/dom-map/v1\0" + canonical({rootNodeId: document.rootNodeId, nodes: decoded.nodes, sourceMappingsHash: document.sourceMappingsHash})) !== hashes.dom) throw Error("Expanded DOM hash mismatch");
+      const {domPayload, ...plain} = document;
+      document = {...plain, ...decoded};
+    }
     if(!Array.isArray(document.nodes)||document.nodes.length>12000)throw Error('Node hash budget');
     const nodes=expandDomNodes(document,new DOMParser().parseFromString('<!doctype html><html><body>'+document.html+'</body></html>','text/html').body),byId=new Map(nodes.map(node=>[node.nodeId,node]));
     if(byId.size!==nodes.length)throw Error('Duplicate node');
@@ -601,7 +647,8 @@ function expandDomNodes(document, body) {
     if (data.type === "open-page" && typeof data.routeKey === "string") {
       const next = m.pages.find(p => p.pageKey === data.routeKey);
       if (!next) return;
-      const variableRender=m.routeTree.variables.find(variable=>variable.variableKey===data.variableKey)?.renderKey??consoleContext?.catalog?.graph.variables.find(variable=>variable.id===data.variableKey)?.renderKey;
+      if(typeof data.renderKey==="string"&&!m.routeTree.renders.some(r=>r.routeKey===next.pageKey&&r.renderKey===data.renderKey))return;
+      const variableRender=typeof data.renderKey==="string"?data.renderKey:m.routeTree.variables.find(variable=>variable.variableKey===data.variableKey)?.renderKey??consoleContext?.catalog?.graph.variables.find(variable=>variable.id===data.variableKey)?.renderKey;
       const targetUrl=typeof data.url==="string"?data.url:(next.pageKey===page.pageKey?currentUrl:next.route);
       if (!doc || next.pageKey !== page.pageKey || variableRender && variableRender!==render?.renderKey || targetUrl!==currentUrl) openPage(next,targetUrl,variableRender);
       else consoleContext?.resume?.();
@@ -801,8 +848,14 @@ function expandDomNodes(document, body) {
   if (m.documents.length) {
     const initialRequest = {};
     pendingDocument = initialRequest;
-    m.documents = await Promise.all(m.documents.map(document => expandNodeHashes(document, initialRequest)));
+    const expandedBytes = m.documents.reduce((total, document) => total + (document.domPayload?.bytes ?? new TextEncoder().encode(JSON.stringify({html:document.html,nodes:document.nodes})).byteLength), 0);
+    if (!Number.isSafeInteger(expandedBytes) || expandedBytes > 33_554_432) throw Error("Expanded DOM aggregate byte budget exceeded");
+    // Sequential decoding bounds peak memory for a multi-route artifact.
+    const expandedDocuments = [];
+    for (const document of m.documents) expandedDocuments.push(await expandNodeHashes(document, initialRequest));
+    m.documents = expandedDocuments;
     pendingDocument = null;
+    renderNav();
   }
   openPage(page,consoleContext?.initialPage?.url??page.route,consoleContext?.initialPage?.renderKey??consoleContext?.catalog?.graph.variables.find(variable=>variable.id===consoleContext.initialPage?.variableKey)?.renderKey);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tinkerlandai/indiana-iam",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Build-time Indiana App Manifest (IAM) generator for Next.js and Vite apps: scans source after the production build and writes the IAM and its release descriptor.",
   "license": "UNLICENSED",
   "repository": {
@@ -47,6 +47,7 @@
     "css-tree": "3.2.1",
     "jsdom": "26.1.0",
     "magic-string": "0.30.21",
+    "pako": "3.0.2",
     "tailwind-merge": "3.7.0",
     "tailwindcss": "4.3.3",
     "typescript": "5.9.3"

package/src/analyze.mjs

@@ -1,10 +1,12 @@
 import fs from "node:fs/promises";
 import path from "node:path";
-import { automaticSourceAnchors, anchorAttributes } from "./anchors.mjs";
+import { automaticSourceAnchors, anchorAttributes, sourceScriptKind } from "./anchors.mjs";
 import { sourceFiles } from "./source-files.mjs";
 import { dependency } from "./dependencies.mjs";
 import { assembleRouteTree, readVariables } from "./route-tree.mjs";
+import { sourceEntry } from "./source-entry.mjs";
 import { frameworkRoutes, externalImport } from "./framework-routes.mjs";
+import { sourceResolution } from "./source-resolution.mjs";
 import { routeIndexDigest, refreshRenderHashes } from "./render-index.mjs";
 import { storeDocumentNodes } from "./node-hashes.mjs";
 import { staticQuery } from "./static-query.mjs";
@@ -140,7 +142,8 @@ function functionFrom(node) {
   if (
     ts.isFunctionDeclaration(node) ||
     ts.isArrowFunction(node) ||
-    ts.isFunctionExpression(node)
+    ts.isFunctionExpression(node) ||
+    ts.isMethodDeclaration(node)
   )
     return node;
   if (ts.isCallExpression(node))
@@ -156,6 +159,7 @@ export async function analyze({
   maxFiles = 5000,
   maxBytes = 100_000_000,
   navigationPaths = [],
+  entry,
   automaticAnchors = false,
 }) {
   root = await fs.realpath(root);
@@ -213,7 +217,7 @@ export async function analyze({
       text,
       ts.ScriptTarget.Latest,
       true,
-      /\.jsx?$/.test(file) ? ts.ScriptKind.JSX : ts.ScriptKind.TSX,
+      sourceScriptKind(file, ts),
     );
     const module = {
       file,
@@ -250,6 +254,7 @@ export async function analyze({
       }
       if (ts.isFunctionDeclaration(statement) && (statement.name||statement.modifiers?.some(m=>m.kind===ts.SyntaxKind.DefaultKeyword)))
         module.bindings.set(statement.name?.text||'$default', statement);
+      if (ts.isEnumDeclaration(statement)) module.bindings.set(statement.name.text, statement);
       if (ts.isVariableStatement(statement))
         for (const d of statement.declarationList.declarations)
           if (ts.isIdentifier(d.name) && d.initializer)
@@ -348,10 +353,9 @@ export async function analyze({
     return binding(target,key,seen);
   }
   const componentDefs = new Map();
-  for (const module of modules.values())
-    for (const [symbol, node] of module.bindings) {
+  function registerComponent(module, symbol, node) {
       const fn = functionFrom(node);
-      if (!fn) continue;
+      if (!fn) return null;
       let hasJsx = false;
       function visit(n) {
         if (
@@ -363,7 +367,7 @@ export async function analyze({
         ts.forEachChild(n, visit);
       }
       visit(fn);
-      if (!hasJsx) continue;
+      if (!hasJsx) return null;
       const key = identity("component", { file: module.file, symbol }),
         ordinals = new Map();
       let ordinal = 0;
@@ -403,12 +407,21 @@ export async function analyze({
         source: loc,
         dependencies: [],
       });
-    }
-  for (const def of componentDefs.values()) {
+      return def;
+  }
+  for (const module of modules.values())
+    for (const [symbol, node] of module.bindings) registerComponent(module, symbol, node);
+  const resolution = sourceResolution({ ts, resolveModule, resolveBinding: binding });
+  const componentBinding = (module, name) => {
+    const ref = resolution.component(module, name);
+    if (ref?.wrapped) gap("LAZY_WRAPPER_UNOBSERVED", module.file, name + ": only the statically forwarded successful module is projected; retry/reload behavior is not executed");
+    return ref;
+  };
+  function collectComponentDependencies(def) {
     function collectDependencies(node) {
       if (ts.isJsxElement(node) || ts.isJsxSelfClosingElement(node)) {
         const opening = ts.isJsxElement(node) ? node.openingElement : node,
-          ref = binding(def.module, opening.tagName.getText(def.module.source)),
+          ref = componentBinding(def.module, opening.tagName.getText(def.module.source)),
           target = ref && componentDefs.get(ref.module.file + "#" + ref.name);
         if (
           target &&
@@ -420,6 +433,20 @@ export async function analyze({
     }
     collectDependencies(def.fn);
   }
+  for (const def of componentDefs.values()) collectComponentDependencies(def);
+  const inlineNodes = new WeakMap(), inlineCounts = new Map();
+  function inlineComponent(module, node, route) {
+    if (inlineNodes.has(node)) return inlineNodes.get(node);
+    const group = module.file + "#" + route, occurrence = inlineCounts.get(group) ?? 0;
+    inlineCounts.set(group, occurrence + 1);
+    const symbol = "$route_" + hashObject("iam/inline-route-component/v1", { route, occurrence }).slice(0, 24);
+    module.bindings.set(symbol, node);
+    const def = registerComponent(module, symbol, node);
+    if (def) collectComponentDependencies(def);
+    const target = { file: module.file, symbol };
+    inlineNodes.set(node, target);
+    return target;
+  }
   function sourceLocation(module, node, symbol) {
     const loc = module.source.getLineAndCharacterOfPosition(
       node.getStart(module.source),
@@ -707,11 +734,16 @@ export async function analyze({
                 Object.hasOwn(Object(value), "stateInitial") &&
                 d.name.elements[0]
               ) {
-                const key = d.name.elements[0].name?.text;
+                const stateBinding = d.name.elements[0];
+                if (!ts.isBindingElement(stateBinding) || stateBinding.dotDotDotToken || !ts.isIdentifier(stateBinding.name)) {
+                  gap("STATE_BINDING_UNSUPPORTED", def.module.file, "Omitted, nested or rest state bindings have no named scalar value for UI simulation");
+                  continue;
+                }
+                const key = stateBinding.name.text;
                 ctx[key] = sensitiveName(key) ? UNKNOWN : value.stateInitial;
                 ctx.__iamStates.add(key);
                 ctx.__iamStateNodes[key] = d;
-                if (d.name.elements[1]?.name)
+                if (d.name.elements[1]?.name && !d.name.elements[1].dotDotDotToken && ts.isIdentifier(d.name.elements[1].name))
                   ctx.__iamSetters[d.name.elements[1].name.text] = key;
               }
             }
@@ -768,7 +800,10 @@ export async function analyze({
     !/^\/(?:[^/?#[\]\\\s]+\/)*[^/?#[\]\\\s]+$/.test(routing.basePath)
   )
     throw new Error("Invalid source basePath");
-  const compositions = frameworkRoutes({ modules, resolveModule, ts, sourceLocation, navigationPaths, gap });
+  const selection = await sourceEntry({ root, modules, resolveModule, ts, entry });
+  if (selection.htmlSource) inventory.push(selection.htmlSource);
+  inventory.sort((a, b) => a.file < b.file ? -1 : a.file > b.file ? 1 : 0);
+  const compositions = frameworkRoutes({ modules, ...selection, resolveModule, ts, sourceLocation, navigationPaths, gap, resolution, inlineComponent });
   const pageFiles = compositions.pageFiles;
   routing.framework = compositions.framework;
   if (compositions.routeSources) routing.routeSources = compositions.routeSources;
@@ -927,6 +962,20 @@ export async function analyze({
       const value = evalExpression(node, owner.module, ctx);
       return ["string", "boolean", "number"].includes(typeof value) ? { op: "const", value } : null;
     }
+    function uiExpressionType(expression, payload = {}) {
+      if (!expression) return undefined;
+      if (expression.op === "const") return typeof expression.value;
+      if (expression.op === "var") return ui.variables.find(variable => variable.variableKey === expression.key)?.valueType;
+      if (expression.op === "event") return payload[expression.key];
+      const type = child => uiExpressionType(child, payload);
+      if (expression.op === "not") return type(expression.arg) ? "boolean" : undefined;
+      if (expression.op === "classes") return expression.parts.every(part => type(part.when) === "boolean") ? "string" : undefined;
+      if (["all", "any"].includes(expression.op)) return expression.args.every(child => type(child) === "boolean") ? "boolean" : undefined;
+      const left = type(expression.left), right = type(expression.right);
+      if (["eq", "ne"].includes(expression.op)) return left && left === right ? "boolean" : undefined;
+      if (["add", "subtract"].includes(expression.op)) return left === "number" && right === "number" ? "number" : undefined;
+      return undefined;
+    }
     function uiHandler(initializer, owner, ctx) {
       let fn = initializer && ts.isJsxExpression(initializer) ? unwrap(initializer.expression) : null;
       if (fn && ts.isIdentifier(fn) && ctx.__iamPropHandlers.has(fn.text)) return ctx.__iamPropHandlers.get(fn.text);
@@ -948,6 +997,7 @@ export async function analyze({
       const payload = {};
       function eventInputs(e) { if (e.op === "event") payload[e.key] = e.key === "checked" ? "boolean" : "string"; for (const child of [e.arg, e.left, e.right, ...(e.args || []),...(e.parts||[]).map(part=>part.when)]) if (child) eventInputs(child); }
       eventInputs(value);
+      if (uiExpressionType(value, payload) !== ui.variables.find(variable => variable.variableKey === variableKey)?.valueType) return null;
       return { variableKey, value, payload };
     }
     function unobservedValue(node, owner, instance) {
@@ -1250,7 +1300,7 @@ export async function analyze({
         : props.children?.iamChildren || "";
       if (ctx[tag]?.iamChildren !== undefined) return ctx[tag].iamChildren;
       const routerPrimitive = externalImport(m, tag);
-      if (["react-router", "react-router-dom"].includes(routerPrimitive?.specifier) && routerPrimitive.name === "Outlet") return ctx.__iamOutlet?.iamChildren ?? "";
+      if (["react-router", "react-router-dom", "@tanstack/react-router"].includes(routerPrimitive?.specifier) && routerPrimitive.name === "Outlet") return ctx.__iamOutlet?.iamChildren ?? "";
       if (
         /^(?:ThemeProvider|Providers?|Analytics|TailwindIndicator|Toaster)$/.test(
           tag,
@@ -1265,7 +1315,7 @@ export async function analyze({
         props["data-iam-adapter"] = tag;
       }
       if (/^[A-Z]/.test(tag) && !intrinsicAlias) {
-        if (tag === "Link" || ["react-router", "react-router-dom"].includes(routerPrimitive?.specifier) && ["Link", "NavLink"].includes(routerPrimitive.name)) {
+        if (tag === "Link" || ["react-router", "react-router-dom", "@tanstack/react-router"].includes(routerPrimitive?.specifier) && ["Link", "NavLink"].includes(routerPrimitive.name)) {
           htmlTag = "a";
           if (typeof props.to === "string") props.href = props.to;
         }
@@ -1284,7 +1334,7 @@ export async function analyze({
             .filter((v) => typeof v === "string")
             .join(" ");
         } else {
-          const ref = binding(m, tag),
+          const ref = componentBinding(m, tag),
             target = ref && componentDefs.get(ref.module.file + "#" + ref.name);
           if (target) {
             const own = components.get(owner.key);
@@ -1357,6 +1407,11 @@ export async function analyze({
       }
       for (const binding of uiBindings.filter(b => ["value", "checked", "disabled", "className"].includes(b.property))) {
         if(['value','checked'].includes(binding.property)&&!['input','select','textarea'].includes(htmlTag)){gap('UI_BINDING_TARGET_UNSUPPORTED',m.file,tag+': input property cannot be simulated on a non-input adapter');continue;}
+        const expectedType = ["checked", "disabled"].includes(binding.property) ? "boolean" : "string";
+        if (uiExpressionType(binding.value) !== expectedType) {
+          gap("UI_BINDING_TYPE_UNSUPPORTED", m.file, tag + "." + binding.property + ": source value cannot be represented by the typed UI simulation");
+          continue;
+        }
         ui.bindings.push({ bindingKey: identity("ui-binding", { node: nodeId, property: binding.property }), routeKey: pageKey, nodeId, elementKey, ...binding });
       }
       const sensitiveInput = htmlTag === "input" && (["password", "hidden"].includes(String(props.type).toLowerCase()) || sensitiveName(String(props.name || props.id || "")));
@@ -1394,7 +1449,7 @@ export async function analyze({
             clipRule: "clip-rule",
           }[key] || key;
         if (
-          !/^(?:class|id|name|type|placeholder|value|title|alt|href|src|role|for|disabled|hidden|checked|width|height|viewBox|d|fill|stroke|stroke-width|stroke-linecap|stroke-linejoin|fill-rule|clip-rule|cx|cy|r|x|y|x1|x2|y1|y2|points|aria-[a-z-]+|data-indiana-id|data-testid|data-test|data-qa|data-iam-(?:adapter|toggle))$/.test(
+          !/^(?:class|id|name|type|placeholder|value|title|alt|href|src|role|for|disabled|hidden|checked|width|height|viewBox|d|fill|stroke|stroke-width|stroke-linecap|stroke-linejoin|fill-rule|clip-rule|cx|cy|r|x|y|x1|x2|y1|y2|points|aria-[a-z-]+|data-indiana-id|data-indiana-map-(?:area|flow|kind|auth|edge)|data-testid|data-test|data-qa|data-iam-(?:adapter|toggle))$/.test(
             attr,
           )
         )
@@ -1436,16 +1491,24 @@ export async function analyze({
       );
     }
     function renderEntry(file, props, instance, symbol) {
-      const entryModule = modules.get(file), entryRef = entryModule && binding(entryModule, symbol ?? entryModule.defaultName);
+      const entryModule = modules.get(file), entryRef = entryModule && componentBinding(entryModule, symbol ?? entryModule.defaultName);
       const entryDef = entryRef && componentDefs.get(entryRef.module.file + "#" + entryRef.name);
-      if (!entryDef) { gap("PAGE_NO_JSX", file, "Composition entry has no inspectable JSX; null defaults are inert"); return ""; }
+      if (!entryDef) {
+        if (entryRef) {
+          const key = identity("component", { file: entryRef.module.file, symbol: entryRef.name });
+          if (!components.has(key)) components.set(key, { componentKey: key, file: entryRef.module.file, name: entryRef.name, source: sourceLocation(entryRef.module, entryRef.node, entryRef.name), dependencies: [] });
+        }
+        gap("PAGE_NO_JSX", file, "Composition entry has no inspectable JSX; null defaults are inert");
+        return "";
+      }
       return renderComponent(entryDef, props, instance, 0);
     }
     function renderBranch(branch) {
       let content = renderEntry(branch.file, {}, branch === composition.composition ? "page" : "slot-page:" + branch.file, branch.symbol);
       for (const layer of branch.layers) {
-        const props = { children: { iamChildren: content } };
-        if (routing.framework === "react-router") props.__iamOutlet = { iamChildren: content };
+        const props = ["react-router", "tanstack-router"].includes(routing.framework)
+          ? { __iamOutlet: { iamChildren: content } }
+          : { children: { iamChildren: content } };
         if (/^(?:src\/)?pages\/_app\.[jt]sx?$/.test(layer.file)) { props.Component = { iamChildren: content }; props.pageProps = {}; }
         for (const slot of layer.slots) {
           props[slot.name] = { iamChildren: renderBranch(slot.branch) };
@@ -1481,6 +1544,27 @@ export async function analyze({
     const dom = new JSDOM(
       "<!doctype html><html><body>" + html + "</body></html>",
     );
+    // JSX children may be forwarded more than once, and HTML repair may clone
+    // an invalid nested anchor. Each concrete occurrence needs a unique node;
+    // ambiguous copies remain preview-only and have no simulated state bridge.
+    const occurrences = new Map();
+    for (const element of dom.window.document.querySelectorAll("[data-iam-node]")) {
+      const id = element.getAttribute("data-iam-node");
+      const matches = occurrences.get(id) ?? [];
+      matches.push(element);
+      occurrences.set(id, matches);
+    }
+    for (const [original, matches] of occurrences) {
+      if (matches.length < 2) continue;
+      const rec = record.get(original);
+      if (!rec) throw Error("Unknown repeated source node");
+      gap("REPEATED_SOURCE_INSTANCE", rec.source.file, "Repeated forwarded children or HTML repair: copies are preview-only without a state bridge");
+      for (const [index, element] of matches.entries()) {
+        const id = identity("node", { page: pageKey, original, occurrence: index });
+        element.setAttribute("data-iam-node", id);
+        record.set(id, { ...rec, synthetic: true });
+      }
+    }
     const nodes = [];
     function collect(node, parentId, index) {
       if (node.nodeType !== 1 && node.nodeType !== 3) return null;
@@ -1706,7 +1790,7 @@ export async function analyze({
     schemaVersion: 2,
     producer: {
       name: "indiana-app-manifest-local",
-      version: "0.17.0",
+      version: "0.19.0",
       method: "typescript-ast-and-bounded-static-projection",
     },
     app: { name, platforms: ["web"] },

package/src/anchors.mjs

@@ -9,6 +9,11 @@ export const anchorAttributes = [
   "data-qa",
   "data-indiana-id",
 ];
+export function sourceScriptKind(file, ts) {
+  return /\.[cm]?ts$/.test(file)
+    ? ts.ScriptKind.TS
+    : /\.tsx$/.test(file) ? ts.ScriptKind.TSX : ts.ScriptKind.JSX;
+}
 export function instrumentableSource(file, text) {
   return (
     typeof text === "string" &&

package/src/build-options.d.ts

@@ -6,6 +6,8 @@ export type IndianaIamBuildOptions = {
   enabled?: boolean;
   /** Reuse existing UI IDs and add build-only anchors for unambiguous native JSX (default: true). */
   automaticAnchors?: boolean;
+  /** Browser entry relative to root for apps with multiple source roots. */
+  entry?: string;
   /** App name recorded in the IAM; defaults to the root folder name. */
   name?: string;
   /** Fail the build when the IAM cannot be generated (default: warn and continue). */
@@ -17,6 +19,9 @@ export type IndianaIamBuildOptions = {
   logger?: BuildLogger;
   /** Key holding only app-manifests:write; defaults to `INDIANA_IAM_KEY`. Without one the IAM is not uploaded. */
   apiKey?: string;
+  /** Client this build belongs to, such as `web` or `web-dashboard`; each client has its own current version.
+   * Defaults to `INDIANA_IAM_CLIENT` or `web`. */
+  client?: string;
   /** Indiana origin; defaults to `INDIANA_IAM_BASE_URL` or https://tinker.cash. */
   baseUrl?: string;
   /** "production" (default) skips Vercel preview deployments; "always" uploads every build; false never uploads. */

package/src/build.mjs

@@ -27,10 +27,10 @@ async function guarded({ strict, logger }, action, what) {
  * Before compilation: scans source once per build and returns its release ID.
  * The same source and producer always get the same ID, so the page can embed its descriptor URL before the IAM exists.
  */
-export async function prepareBuildRelease({ root, name, automaticAnchors = true, strict = false, logger = console }) {
+export async function prepareBuildRelease({ root, name, entry, automaticAnchors = true, strict = false, logger = console }) {
   return guarded({ strict, logger }, async () => {
     root = await fs.realpath(root);
-    const analysis = await analyzeSource({ root, name, automaticAnchors });
+    const analysis = await analyzeSource({ root, name, entry, automaticAnchors });
     const releaseId = deriveReleaseId(analysis);
     process.env[STATE] = JSON.stringify({ root, releaseId, automaticAnchors });
     return { releaseId };
@@ -59,6 +59,7 @@ export async function finishBuildRelease({
   root,
   releaseId,
   name,
+  entry,
   automaticAnchors = true,
   cssDirectory,
   mounts,
@@ -71,7 +72,7 @@ export async function finishBuildRelease({
 }) {
   root = await fs.realpath(root);
   return guarded({ strict, logger }, async () => {
-    const analysis = await analyzeSource({ root, name, automaticAnchors });
+    const analysis = await analyzeSource({ root, name, entry, automaticAnchors });
     if (deriveReleaseId(analysis) !== releaseId) throw new Error("Source changed during the build; rebuild before publishing IAM");
     const css = cssDirectory ? await compiledCss(root, cssDirectory) : [];
     const plain = () => generateAppManifest({ root, analysis, releaseId });
@@ -104,11 +105,16 @@ export async function finishBuildRelease({
           serialized: result.serialized,
           digest: result.digest,
           label,
+          client: settings.client,
           apiKey: settings.apiKey,
           baseUrl: settings.baseUrl,
           fetch: upload.fetch,
         });
-        report(logger, "log", `IAM ${result.digest.slice(0, 12)} ${outcome.uploaded ? "uploaded" : "already uploaded"} as the current version (${label})`);
+        report(
+          logger,
+          "log",
+          `IAM ${result.digest.slice(0, 12)} ${outcome.uploaded ? "uploaded" : "already uploaded"} as the current version of client ${settings.client} (${label})`,
+        );
         return outcome.version;
       }, "IAM upload");
     else if (settings.missingKey && upload.upload !== false)

package/src/cli.mjs

@@ -10,9 +10,9 @@ import { planAnchors, applyAnchors } from "./instrument.mjs";
 import { buildLabel, uploadAppManifest, uploadSettings } from "./upload.mjs";
 
 const usage =
-  "Usage: indiana-iam generate --root <app> --out <new directory> [--name <name> --repository <url> --commit <sha> --release-id <uuid> --write-public-release --build-css <file>...]" +
+  "Usage: indiana-iam generate --root <app> --out <new directory> [--entry <source module> --name <name> --repository <url> --commit <sha> --release-id <uuid> --write-public-release --build-css <file>...]" +
   " | indiana-iam validate --file <manifest>" +
-  " | INDIANA_IAM_KEY=<key> indiana-iam upload --file <manifest> [--label <label> --base-url <url>]" +
+  " | INDIANA_IAM_KEY=<key> indiana-iam upload --file <manifest> [--client <key> --label <label> --base-url <url>]" +
   " | indiana-iam prepare --root <app>" +
   " | indiana-iam anchor --root <checkout> --out <new plan file> [--apply --primitive-map <file> --public-labels --forward-anchors]";
 
@@ -22,6 +22,7 @@ const { values, positionals } = parseArgs({
     root: { type: "string" },
     out: { type: "string" },
     name: { type: "string" },
+    entry: { type: "string" },
     repository: { type: "string" },
     commit: { type: "string" },
     file: { type: "string" },
@@ -39,6 +40,7 @@ const { values, positionals } = parseArgs({
     "public-labels": { type: "boolean", default: false },
     "forward-anchors": { type: "boolean", default: false },
     label: { type: "string" },
+    client: { type: "string" },
     "base-url": { type: "string" },
   },
 });
@@ -53,6 +55,7 @@ if (command === "generate") {
   const result = await generateAppManifest({
     root,
     name: values.name,
+    entry: values.entry,
     repository: values.repository || "",
     commit: values.commit || "",
     navigationPaths: (values["navigation-path"] || []).map((value) => JSON.parse(value)),
@@ -90,7 +93,7 @@ if (command === "generate") {
 } else if (command === "upload") {
   if (!values.file) throw new Error("upload requires --file");
   // The key is read from INDIANA_IAM_KEY only, so it stays out of shell history.
-  const settings = uploadSettings({ baseUrl: values["base-url"], upload: "always" });
+  const settings = uploadSettings({ baseUrl: values["base-url"], upload: "always", client: values.client });
   if (settings.missingKey) throw new Error("Set INDIANA_IAM_KEY to a key with only the app-manifests:write permission");
   const bytes = await fs.readFile(values.file),
     serialized = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
@@ -99,10 +102,13 @@ if (command === "generate") {
     serialized,
     digest: sha256(bytes),
     label: values.label || buildLabel(path.dirname(path.resolve(values.file))),
+    client: settings.client,
     apiKey: settings.apiKey,
     baseUrl: settings.baseUrl,
   });
-  console.log(JSON.stringify({ uploaded, version: { id: version.id, state: version.state, isCurrent: version.isCurrent } }, null, 2));
+  console.log(
+    JSON.stringify({ uploaded, version: { id: version.id, client: version.clientKey, state: version.state, isCurrent: version.isCurrent } }, null, 2),
+  );
 } else if (command === "prepare") {
   if (!values.root) throw new Error("prepare requires --root");
   console.log(JSON.stringify(await prepareRelease(values.root)));