@tinkerlandai/indiana-iam 0.2.0 → 0.4.0

package/src/tanstack-routes.mjs

@@ -0,0 +1,143 @@
+/** Generated file-route graphs only: read the registered tree, never execute a router. */
+export function tanstackRoutes({ discoveryModules, ts, resolution, gap, component, add, externalImport }) {
+  let routers = 0;
+  const unwrap = node => {
+    while (node && (ts.isParenthesizedExpression(node) || ts.isAsExpression(node) || ts.isSatisfiesExpression(node) || ts.isNonNullExpression(node))) node = node.expression;
+    return node;
+  };
+  const fail = message => { throw Error("TanStack route adapter: " + message); };
+  function ref(node, module) {
+    const resolved = resolution.reference(node, module);
+    if (!resolved) fail("unresolved or cyclic source reference");
+    return resolved;
+  }
+  function fields(node, module) {
+    const resolved = ref(node, module);
+    node = resolved.node;
+    if (!ts.isObjectLiteralExpression(node) || node.properties.some(p => !(ts.isPropertyAssignment(p) || ts.isShorthandPropertyAssignment(p) || ts.isMethodDeclaration(p)) || ts.isComputedPropertyName(p.name))) fail("configuration must be a literal record without spreads or getters");
+    const values = new Map();
+    for (const property of node.properties) {
+      if (values.has(property.name.text)) fail("duplicate configuration field");
+      values.set(property.name.text, ts.isShorthandPropertyAssignment(property) ? property.name : ts.isMethodDeclaration(property) ? property : property.initializer);
+    }
+    return { module: resolved.module, node, values };
+  }
+  function returned(node) {
+    node = unwrap(node);
+    if (!node || !(ts.isArrowFunction(node) || ts.isFunctionExpression(node)) || node.parameters.length) fail("parent must be a parameterless source callback");
+    if (!ts.isBlock(node.body)) return node.body;
+    if (node.body.statements.length === 1 && ts.isReturnStatement(node.body.statements[0])) return node.body.statements[0].expression;
+    fail("parent callback is not a direct return");
+  }
+  function identity(node, module, depth = 0) {
+    if (depth > 32) fail("route reference budget exceeded");
+    const resolved = ref(node, module);
+    node = resolved.node; module = resolved.module;
+    if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && ["update", "_addFileChildren", "_addFileTypes"].includes(node.expression.name.text)) return identity(node.expression.expression, module, depth + 1);
+    return module.file + ":" + node.pos + ":" + node.end;
+  }
+  function graph(node, module, seen = new Set()) {
+    const resolved = ref(node, module);
+    node = resolved.node; module = resolved.module;
+    const key = module.file + ":" + node.pos + ":" + node.end;
+    if (seen.has(key) || seen.size > 32) fail("cyclic or excessive route graph");
+    seen = new Set([...seen, key]);
+    if (!ts.isCallExpression(node)) fail("route graph is not a supported source declaration");
+    if (ts.isPropertyAccessExpression(node.expression)) {
+      const method = node.expression.name.text;
+      if (method === "_addFileTypes" && !node.arguments.length) return graph(node.expression.expression, module, seen);
+      if (method === "_addFileChildren" && node.arguments.length === 1) {
+        const parent = graph(node.expression.expression, module, seen), children = fields(node.arguments[0], module);
+        if (parent.children.length) fail("route children registered more than once");
+        parent.children = [...children.values.values()].map(child => graph(child, children.module, seen));
+        return parent;
+      }
+      if (method === "update" && node.arguments.length === 1) {
+        const original = graph(node.expression.expression, module, seen), config = fields(node.arguments[0], module);
+        if (original.root || original.updated || original.children.length) fail("unexpected route update");
+        if ([...config.values.keys()].some(key => !["id", "path", "getParentRoute"].includes(key))) fail("unsupported generated update field");
+        const routeId = resolution.string(config.values.get("id"), config.module);
+        if (!routeId || !config.values.has("getParentRoute")) fail("route update needs a static id and parent");
+        original.parent = identity(returned(config.values.get("getParentRoute")), config.module);
+        original.path = config.values.has("path") ? resolution.string(config.values.get("path"), config.module) : undefined;
+        if (config.values.has("path") && original.path === undefined) fail("dynamic generated path");
+        original.updated = true;
+        original.id = routeId;
+        original.routeModule = module;
+        original.routeNode = node;
+        return original;
+      }
+      fail("unsupported graph method " + method);
+    }
+    let factory = node.expression, options = node.arguments[0], root = false, sourceId = "$root";
+    if (ts.isCallExpression(factory)) {
+      const creator = externalImport(module, factory.expression.getText(module.source));
+      if (creator?.specifier !== "@tanstack/react-router") fail("unrecognized route factory");
+      if (creator.name === "createFileRoute") {
+        if (factory.arguments.length !== 1 || resolution.string(factory.arguments[0], module) === undefined) fail("file route identity must be static");
+        sourceId = resolution.string(factory.arguments[0], module);
+      } else if (creator.name === "createRootRouteWithContext" && !factory.arguments.length) root = true;
+      else fail("unsupported route factory");
+    } else {
+      const creator = externalImport(module, factory.getText(module.source));
+      if (creator?.specifier !== "@tanstack/react-router" || creator.name !== "createRootRoute") fail("unrecognized root factory");
+      root = true;
+    }
+    if (node.arguments.length !== 1) fail("route factory needs one source configuration");
+    const config = fields(options, module);
+    if (["id", "path", "getParentRoute"].some(key => config.values.has(key))) fail("file-route URL configuration must come from the generated update");
+    if ([...config.values.keys()].some(key => ["loader", "beforeLoad", "validateSearch", "errorComponent", "notFoundComponent", "pendingComponent"].includes(key))) gap("ROUTE_DATA_UNOBSERVED", module.file, "TanStack loaders, guards, search and error states are not executed");
+    return { key: identity(node, module), root, sourceId, config, children: [], routeModule: module, routeNode: node };
+  }
+  function pathOf(parent, child) {
+    if (child === undefined) return parent;
+    if (/[?#\\\s]/.test(child) || child.split("/").some(part => part === "." || part === "..")) fail("invalid generated path");
+    const segments = child.split("/").filter(Boolean).map(part => {
+      if (part === "$") return "*";
+      if (/^\$[A-Za-z_][A-Za-z0-9_]*$/.test(part)) return ":" + part.slice(1);
+      if (/[$\[\]{}()*:]/.test(part)) fail("unsupported parameter pattern");
+      return part;
+    });
+    return (parent.replace(/\/$/, "") + "/" + segments.join("/")).replace(/\/$/, "") || "/";
+  }
+  function project(root) {
+    const registered = new Set();
+    function walk(route, parent, path, ancestors, depth = 0) {
+      if (depth > 16 || registered.size >= 200 || registered.has(route.key)) fail("duplicate, cyclic or excessive registered route");
+      registered.add(route.key);
+      if (parent ? route.root || !route.updated || route.parent !== parent.key : !route.root) fail("registered parent does not match generated parent");
+      const publicPath = pathOf(path, route.path);
+      // Use source route identity, not the public URL, for inline layout symbols.
+      const target = component(route.config.values.get("component"), route.config.module, "$tanstack:" + route.config.module.file + ":" + route.sourceId);
+      let indexAtPath = false;
+      const childIds = new Set();
+      for (const child of route.children) {
+        if (childIds.has(child.id)) fail("duplicate generated child id");
+        childIds.add(child.id);
+      }
+      for (const child of route.children) indexAtPath = walk(child, route, publicPath, target ? [...ancestors, target] : ancestors, depth + 1) || indexAtPath;
+      const ownsPath = route.root || route.path !== undefined;
+      if (ownsPath && !indexAtPath && target) add(route.routeModule, route.routeNode, publicPath, target, ancestors);
+      if (ownsPath && !target && !route.children.length) gap("ROUTE_COMPONENT_UNSUPPORTED", route.config.module.file, "TanStack route without an inspectable component");
+      return ownsPath && publicPath === path || indexAtPath && publicPath === path;
+    }
+    walk(root, null, "/", []);
+  }
+  for (const module of discoveryModules.values()) {
+    function visit(node) {
+      if (ts.isCallExpression(node)) {
+        const imported = externalImport(module, node.expression.getText(module.source));
+        if (imported?.specifier === "@tanstack/react-router" && imported.name === "createRouter") {
+          if (++routers > 1) fail("multiple router authorities require one explicit entry");
+          const options = fields(node.arguments[0], module);
+          if (node.arguments.length !== 1 || !options.values.has("routeTree") || ["basepath", "history", "rewrite", "trailingSlash"].some(key => options.values.has(key))) fail("custom URL routing requires a separate adapter");
+          project(graph(options.values.get("routeTree"), options.module));
+          return;
+        }
+      }
+      ts.forEachChild(node, visit);
+    }
+    visit(module.source);
+  }
+  return routers;
+}

package/src/transform.mjs

@@ -1,6 +1,6 @@
 import MagicString from "magic-string";
 import { dependency } from "./dependencies.mjs";
-import { automaticSourceAnchors, instrumentableSource } from "./anchors.mjs";
+import { automaticSourceAnchors, instrumentableSource, sourceScriptKind } from "./anchors.mjs";
 
 /** Adds build-only anchors without editing merchant source or evaluating any expression. */
 export function transformSourceForIam(code, file) {
@@ -12,7 +12,7 @@ export function transformSourceForIam(code, file) {
     code,
     ts.ScriptTarget.Latest,
     true,
-    /\.jsx?$/.test(file) ? ts.ScriptKind.JSX : ts.ScriptKind.TSX,
+    sourceScriptKind(file, ts),
   );
   if (source.parseDiagnostics.length)
     throw new Error("IAM cannot instrument invalid source: " + file);

package/src/ui-preview.mjs

@@ -0,0 +1,225 @@
+import { JSDOM, VirtualConsole } from "jsdom";
+import { documentDom } from "./dom-payload.mjs";
+import { createStateMachine } from "./ui-state-machine.mjs";
+import { applySourceAttributes } from "./source-attributes.mjs";
+import {
+  applySourceCollections,
+  markUnobservedData,
+} from "./source-collections.mjs";
+
+/** Inert source alternatives for UI inspection. This never changes the admitted render or SDK targets. */
+export function previewUiDocument(manifest, document, options = {}) {
+  const graph = manifest.routeTree,
+    render = graph.renders.find((r) => r.documentKey === document.documentKey);
+  if (!render) throw Error("Unknown UI preview render");
+  const dom = new JSDOM(documentDom(document).html, {
+    virtualConsole: new VirtualConsole(),
+  });
+  try {
+    const doc = dom.window.document;
+    const nodes = new Map(
+      [...doc.querySelectorAll("[data-iam-node]")].map((n) => [
+        n.getAttribute("data-iam-node"),
+        n,
+      ]),
+    );
+    const sourceConditions = new Map(
+      (graph.ui?.conditions ?? []).map((c) => [c.conditionKey, c]),
+    );
+    const conditions = [
+      ...doc.querySelectorAll(
+        '[data-iam-condition][data-iam-alternative="true"]',
+      ),
+    ].map((node) => {
+      const source = sourceConditions.get(
+        node.getAttribute("data-iam-condition"),
+      );
+      if (!source) throw Error("Unknown source condition");
+      const other = node.nextElementSibling;
+      return {
+        ...source,
+        defaultChoice:
+          node.getAttribute("data-iam-condition-default") === "false"
+            ? false
+            : undefined,
+        groupKey: node.getAttribute("data-iam-node"),
+        truthyNodeId: node.getAttribute("data-iam-node"),
+        falsyNodeId:
+          other?.getAttribute("data-iam-condition") === source.conditionKey &&
+          other.getAttribute("data-iam-alternative") === "false"
+            ? other.getAttribute("data-iam-node")
+            : null,
+      };
+    });
+    const selections = new Map();
+    const groups = new Map();
+    for (const row of conditions) {
+      if (!groups.has(row.groupKey)) groups.set(row.groupKey, []);
+      groups.get(row.groupKey).push(row);
+    }
+    if (options.strategy !== undefined && options.strategy !== "content")
+      throw Error("Unknown UI preview strategy");
+    for (const [key, rows] of groups) {
+      const supplied = options.conditions?.[key];
+      if (supplied !== undefined && typeof supplied !== "boolean")
+        throw Error("Invalid UI condition choice");
+      if (supplied !== undefined) selections.set(key, supplied);
+      else if (options.strategy === "content") {
+        if (rows[0].observation) continue;
+        if (rows[0].defaultChoice !== undefined) {
+          selections.set(key, rows[0].defaultChoice);
+          continue;
+        }
+        const score = (id) => {
+          const node = nodes.get(id);
+          return node
+            ? node.textContent.trim().length +
+                node.querySelectorAll("input,button,a,textarea,select").length *
+                  24
+            : 0;
+        };
+        selections.set(
+          key,
+          rows.reduce(
+            (n, r) => n + score(r.truthyNodeId) - score(r.falsyNodeId),
+            0,
+          ) >= 0,
+        );
+      }
+    }
+    for (const key of Object.keys(options.conditions ?? {}))
+      if (!groups.has(key)) throw Error("Unknown UI condition");
+    for (const row of conditions)
+      if (selections.has(row.groupKey)) {
+        nodes
+          .get(row.truthyNodeId)
+          ?.toggleAttribute("hidden", !selections.get(row.groupKey));
+        if (row.falsyNodeId)
+          nodes
+            .get(row.falsyNodeId)
+            ?.toggleAttribute("hidden", selections.get(row.groupKey));
+      }
+    const machine = createStateMachine(
+      graph,
+      render.routeKey,
+      render.renderKey,
+    );
+    if (options.values) machine.preview(options.values);
+    for (const binding of machine.bindings()) {
+      const node = nodes.get(binding.nodeId);
+      if (!node) continue;
+      if (binding.property === "visible")
+        node.toggleAttribute("hidden", !binding.value);
+      else if (binding.property === "text")
+        node.textContent = String(binding.value);
+      else if (binding.property === "className")
+        node.setAttribute("class", String(binding.value));
+      else if (["disabled", "checked"].includes(binding.property))
+        node.toggleAttribute(binding.property, Boolean(binding.value));
+      else if (
+        binding.property === "value" &&
+        node.getAttribute("type") !== "password"
+      )
+        node.setAttribute("value", String(binding.value));
+    }
+    const values = machine.snapshot();
+    for (const tab of graph.ui?.tabs ?? [])
+      if (tab.renderKey === render.renderKey) {
+        const selected = tab.variableKey
+          ? values[tab.variableKey]
+          : tab.initialValue;
+        for (const item of tab.items)
+          nodes
+            .get(item.nodeId)
+            ?.setAttribute("aria-selected", String(item.value === selected));
+      }
+    const regions = (graph.ui?.regions ?? []).filter(
+        (r) => r.renderKey === render.renderKey,
+      ),
+      componentChoices = [];
+    for (const key of Object.keys(options.regions ?? {}))
+      if (!regions.some((r) => r.regionKey === key))
+        throw Error("Unknown component region");
+    for (const region of regions) {
+      const requested = options.regions?.[region.regionKey],
+        stateValue = region.variableKey ? values[region.variableKey] : null;
+      const selected =
+        requested ??
+        (options.strategy === "content"
+          ? region.options.some((o) => o.value === stateValue)
+            ? stateValue
+            : (region.initialValue ?? region.options[0].value)
+          : null);
+      if (
+        selected !== null &&
+        !region.options.some((o) => o.value === selected)
+      )
+        throw Error("Unknown source component alternative");
+      if (selected !== null) {
+        for (const option of region.options)
+          nodes
+            .get(option.nodeId)
+            ?.toggleAttribute("hidden", option.value !== selected);
+        componentChoices.push({
+          regionKey: region.regionKey,
+          value: selected,
+          source: region.source,
+          expression: region.expression,
+        });
+      }
+    }
+    applySourceAttributes(doc, graph.ui, render.renderKey, values);
+    const focus = options.focusNodeId ? nodes.get(options.focusNodeId) : null;
+    const collectionUi = focus
+      ? {
+          ...graph.ui,
+          collections: (graph.ui?.collections ?? []).filter((row) => {
+            const node = nodes.get(row.nodeId);
+            return node && focus.contains(node);
+          }),
+        }
+      : graph.ui;
+    const collectionChoices = applySourceCollections(
+      doc,
+      collectionUi,
+      render.renderKey,
+      values,
+      options.strategy === "content" || Boolean(options.values),
+    );
+    const unobserved = markUnobservedData(
+      doc,
+      graph.ui,
+      options.strategy === "content",
+      selections,
+    );
+    const assumptions = [...groups].flatMap(([key, rows]) => {
+      if (!selections.has(key)) return [];
+      const row = rows.find((r) => {
+        const node = nodes.get(
+          selections.get(key) ? r.truthyNodeId : r.falsyNodeId,
+        );
+        return node && !node.parentElement?.closest("[hidden]");
+      });
+      return row
+        ? [
+            {
+              groupKey: key,
+              expression: row.expression,
+              selected: selections.get(key),
+              source: row.source,
+            },
+          ]
+        : [];
+    });
+    return {
+      html: doc.documentElement.outerHTML,
+      assumptions,
+      values,
+      componentChoices,
+      collectionChoices,
+      unobserved,
+    };
+  } finally {
+    dom.window.close();
+  }
+}

package/src/ui-state-machine.mjs

@@ -0,0 +1,76 @@
+/* Generated from assets/state-machine.js by build-runtime.mjs. */
+/* Indiana declarative UI state machine. Pure computation; no merchant callbacks. */
+export function createStateMachine(graph, routeKey, renderKey) {
+  {
+    renderKey ??= graph.routes.find(route => route.routeKey === routeKey)?.initialRenderKey;
+    if (!graph.renders.some(render => render.renderKey === renderKey && render.routeKey === routeKey)) throw new Error("Unknown UI render");
+  }
+  const owns = row => row.routeKey === routeKey && row.renderKey === renderKey;
+  const variables = new Map(graph.variables.filter(owns).map(v => [v.variableKey, v]));
+  const transitions = graph.transitions.filter(t => owns(t) && t.simulation === "implemented");
+  let values = Object.fromEntries([...variables].map(([key, v]) => [key, v.initialValue]));
+  const read = (expression, payload, snapshot, depth = 0) => {
+    if (depth > 24) throw new Error("Expression budget exceeded");
+    const next = e => read(e, payload, snapshot, depth + 1);
+    switch (expression.op) {
+      case "const": return expression.value;
+      case "var": {
+        if (!variables.has(expression.key)) throw new Error("Unknown variable");
+        return snapshot[expression.key];
+      }
+      case "event": {
+        if (!Object.hasOwn(payload, expression.key)) throw new Error("Missing event input");
+        return payload[expression.key];
+      }
+      case "not": return !next(expression.arg);
+      case "eq": return next(expression.left) === next(expression.right);
+      case "ne": return next(expression.left) !== next(expression.right);
+      case "add":
+      case "subtract": {
+        const left = next(expression.left), right = next(expression.right);
+        if (typeof left !== "number" || typeof right !== "number" || !Number.isFinite(left) || !Number.isFinite(right)) throw new Error("Invalid numeric expression");
+        const value = expression.op === "add" ? left + right : left - right;
+        if (!Number.isFinite(value)) throw new Error("Invalid numeric result");
+        return value;
+      }
+      case "all": return expression.args.every(e => next(e) === true);
+      case "any": return expression.args.some(e => next(e) === true);
+      case "classes": return expression.parts.filter(part=>next(part.when)===true).map(part=>part.value).join(' ');
+      default: throw new Error("Unsupported expression");
+    }
+  };
+  return {
+    snapshot: () => ({ ...values }),
+    preview(input) {
+      if (!input || Array.isArray(input) || typeof input !== "object" || Object.keys(input).length > variables.size) throw new Error("Invalid preview values");
+      const writes = Object.create(null);
+      for (const [key, value] of Object.entries(input)) {
+        const variable = variables.get(key);
+        if (!variable || typeof value !== variable.valueType || typeof value === "string" && value.length > 4000 || typeof value === "number" && !Number.isFinite(value)) throw new Error("Invalid preview value");
+        writes[key] = value;
+      }
+      values = { ...values, ...writes };
+      return { values: { ...values }, evidence: "manual-ui-preview" };
+    },
+    reset: () => { values = Object.fromEntries([...variables].map(([key, v]) => [key, v.initialValue])); },
+    bindings: () => graph.bindings.filter(owns).map(b => ({ ...b, value: read(b.value, {}, values) })),
+    dispatch(nodeId, event, payload = {}) {
+      const candidates = transitions.filter(t => t.trigger.nodeId === nodeId && t.trigger.event === event);
+      for (const t of candidates) {
+        const expected = Object.keys(t.trigger.payload);
+        if (Object.keys(payload).some(key => !expected.includes(key)) || expected.some(key => typeof payload[key] !== t.trigger.payload[key] || typeof payload[key] === "string" && payload[key].length > 4000)) throw new Error("Invalid event input");
+      }
+      const eligible = candidates.filter(t => read(t.guard, payload, values) === true);
+      if (eligible.length > 1) throw new Error("Ambiguous UI transition");
+      if (!eligible.length) return null;
+      const t = eligible[0], writes = Object.create(null);
+      for (const w of t.stateWrites) {
+        const value = read(w.value, payload, values), variable = variables.get(w.variableKey);
+        if (!variable || typeof value !== variable.valueType || typeof value === "string" && value.length > 4000 || typeof value === "number" && !Number.isFinite(value)) throw new Error("Invalid state write");
+        writes[w.variableKey] = value;
+      }
+      values = { ...values, ...writes };
+      return { transitionKey: t.transitionKey, values: { ...values } };
+    },
+  };
+}