@tinkerlandai/indiana-iam 0.2.0 → 0.4.0

package/src/source-resolution.mjs

@@ -0,0 +1,268 @@
+/** Bounded AST references only. No merchant module, getter, factory or callback is invoked. */
+export function sourceResolution({ ts, resolveModule, resolveBinding }) {
+  const unwrap = (node) => {
+    while (
+      node &&
+      (ts.isParenthesizedExpression(node) ||
+        ts.isAsExpression(node) ||
+        ts.isTypeAssertionExpression(node) ||
+        ts.isSatisfiesExpression(node) ||
+        ts.isNonNullExpression(node) ||
+        ts.isAwaitExpression(node))
+    )
+      node = node.expression;
+    return node;
+  };
+  function reference(node, module, seen = new Set()) {
+    node = unwrap(node);
+    if (!node || seen.size >= 32) return null;
+    const key = module.file + ":" + node.pos + ":" + node.end;
+    if (seen.has(key)) return null;
+    seen = new Set([...seen, key]);
+    if (ts.isIdentifier(node)) {
+      const ref = resolveBinding(module, node.text);
+      return ref && reference(ref.node, ref.module, seen);
+    }
+    if (
+      ts.isPropertyAccessExpression(node) ||
+      ts.isElementAccessExpression(node)
+    ) {
+      if (node.questionDotToken) return null;
+      const name = ts.isPropertyAccessExpression(node)
+        ? node.name.text
+        : string(node.argumentExpression, module, seen);
+      if (typeof name !== "string") return null;
+      if (ts.isIdentifier(node.expression)) {
+        const imported = module.imports.get(node.expression.text);
+        if (imported?.name === "*") {
+          const target = resolveModule(module.file, imported.specifier);
+          const ref =
+            target && resolveBinding(target, target.exports.get(name) ?? name);
+          return ref && reference(ref.node, ref.module, seen);
+        }
+      }
+      const record = reference(node.expression, module, seen);
+      if (!record) return null;
+      if (ts.isEnumDeclaration(record.node)) {
+        const member = record.node.members.find(
+          (member) => member.name.text === name,
+        );
+        return member && reference(member.initializer, record.module, seen);
+      }
+      if (
+        !ts.isObjectLiteralExpression(record.node) ||
+        record.node.properties.some(
+          (property) =>
+            !ts.isPropertyAssignment(property) ||
+            (property.name && ts.isComputedPropertyName(property.name)),
+        )
+      )
+        return null;
+      const fields = record.node.properties.filter(
+        (property) => property.name.text === name,
+      );
+      return fields.length === 1
+        ? reference(fields[0].initializer, record.module, seen)
+        : null;
+    }
+    return { node, module };
+  }
+  function string(node, module, seen = new Set()) {
+    const ref = reference(node, module, seen);
+    if (!ref) return undefined;
+    node = ref.node;
+    module = ref.module;
+    if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node))
+      return node.text;
+    const key = module.file + ":string:" + node.pos;
+    if (seen.has(key) || seen.size >= 32) return undefined;
+    seen = new Set([...seen, key]);
+    if (ts.isTemplateExpression(node)) {
+      let result = node.head.text;
+      for (const span of node.templateSpans) {
+        const value = string(span.expression, module, seen);
+        if (value === undefined) return undefined;
+        result += value + span.literal.text;
+        if (result.length > 2048) return undefined;
+      }
+      return result;
+    }
+    if (
+      ts.isBinaryExpression(node) &&
+      node.operatorToken.kind === ts.SyntaxKind.PlusToken
+    ) {
+      const left = string(node.left, module, seen),
+        right = string(node.right, module, seen);
+      return left !== undefined &&
+        right !== undefined &&
+        left.length + right.length <= 2048
+        ? left + right
+        : undefined;
+    }
+    return undefined;
+  }
+  function external(module, node) {
+    node = unwrap(node);
+    if (node && ts.isIdentifier(node)) return module.imports.get(node.text);
+    if (
+      node &&
+      ts.isPropertyAccessExpression(node) &&
+      ts.isIdentifier(node.expression)
+    ) {
+      const owner = module.imports.get(node.expression.text);
+      if (owner && ["*", "default"].includes(owner.name))
+        return { specifier: owner.specifier, name: node.name.text };
+    }
+    return null;
+  }
+  function functionNode(node) {
+    node = unwrap(node);
+    return node &&
+      (ts.isFunctionDeclaration(node) ||
+        ts.isFunctionExpression(node) ||
+        ts.isArrowFunction(node))
+      ? node
+      : null;
+  }
+  function returned(fn) {
+    if (!fn?.body) return null;
+    if (!ts.isBlock(fn.body)) return fn.body;
+    return fn.body.statements.length === 1 &&
+      ts.isReturnStatement(fn.body.statements[0])
+      ? fn.body.statements[0].expression
+      : null;
+  }
+  // Prove only the successful module return of a forwarding function. Catch
+  // side effects are opaque and must rethrow; finally/alternate module returns refuse.
+  function forwards(node, module, parameters, depth = 0) {
+    node = unwrap(node);
+    if (!node || depth > 8 || !ts.isCallExpression(node)) return false;
+    if (
+      ts.isIdentifier(node.expression) &&
+      parameters.has(node.expression.text)
+    )
+      return node.arguments.length === 0;
+    if (!ts.isIdentifier(node.expression)) return false;
+    const ref = resolveBinding(module, node.expression.text),
+      fn = ref && functionNode(ref.node);
+    if (
+      !fn ||
+      fn.asteriskToken ||
+      fn.parameters.length !== 1 ||
+      fn.parameters[0].dotDotDotToken ||
+      !ts.isIdentifier(fn.parameters[0].name) ||
+      node.arguments.length !== 1 ||
+      !ts.isIdentifier(node.arguments[0]) ||
+      !parameters.has(node.arguments[0].text)
+    )
+      return false;
+    const nested = new Set([fn.parameters[0].name.text]);
+    let result = returned(fn);
+    if (
+      !result &&
+      fn.body &&
+      ts.isBlock(fn.body) &&
+      fn.body.statements.length === 1
+    ) {
+      const statement = fn.body.statements[0];
+      if (
+        !ts.isTryStatement(statement) ||
+        statement.finallyBlock ||
+        !statement.catchClause ||
+        !ts.isThrowStatement(statement.catchClause.block.statements.at(-1))
+      )
+        return false;
+      let overrides = false;
+      const visit = (item) => {
+        if (ts.isReturnStatement(item)) overrides = true;
+        ts.forEachChild(item, visit);
+      };
+      visit(statement.catchClause);
+      if (
+        overrides ||
+        statement.tryBlock.statements.length !== 1 ||
+        !ts.isReturnStatement(statement.tryBlock.statements[0])
+      )
+        return false;
+      result = statement.tryBlock.statements[0].expression;
+    }
+    return forwards(result, ref.module, nested, depth + 1);
+  }
+  function lazyFactory(call, module) {
+    if (call.arguments.length !== 1) return null;
+    const imported = external(module, call.expression);
+    if (imported?.specifier === "react" && imported.name === "lazy")
+      return { node: call.arguments[0], module, wrapped: false };
+    if (!ts.isIdentifier(call.expression)) return null;
+    const ref = resolveBinding(module, call.expression.text),
+      fn = ref && functionNode(ref.node);
+    if (
+      !fn ||
+      fn.asteriskToken ||
+      fn.parameters.length !== 1 ||
+      fn.parameters[0].dotDotDotToken ||
+      !ts.isIdentifier(fn.parameters[0].name)
+    )
+      return null;
+    if (fn.modifiers?.some(modifier => modifier.kind === ts.SyntaxKind.AsyncKeyword)) return null;
+    const value = unwrap(returned(fn));
+    if (!value || !ts.isCallExpression(value) || value.arguments.length !== 1)
+      return null;
+    const wrapper = external(ref.module, value.expression),
+      callback = functionNode(value.arguments[0]);
+    if (
+      wrapper?.specifier !== "react" ||
+      wrapper.name !== "lazy" ||
+      !callback ||
+      callback.asteriskToken ||
+      callback.parameters.length ||
+      !forwards(
+        returned(callback),
+        ref.module,
+        new Set([fn.parameters[0].name.text]),
+      )
+    )
+      return null;
+    return { node: call.arguments[0], module, wrapped: true };
+  }
+  function component(module, name) {
+    if (typeof name !== "string" || !name) return null;
+    const parts = name.split(".");
+    let ref;
+    if (parts.length === 2) {
+      const imported = module.imports.get(parts[0]),
+        target =
+          imported &&
+          ["*", "default"].includes(imported.name) &&
+          resolveModule(module.file, imported.specifier);
+      ref =
+        target &&
+        resolveBinding(target, target.exports.get(parts[1]) ?? parts[1]);
+    } else if (parts.length === 1) ref = resolveBinding(module, name);
+    if (!ref) return null;
+    const node = unwrap(ref.node);
+    if (node && ts.isCallExpression(node)) {
+      const factory = lazyFactory(node, ref.module),
+        callback = factory && functionNode(factory.node),
+        body = callback && unwrap(returned(callback));
+      if (
+        body &&
+        !callback.asteriskToken &&
+        !callback.parameters.length &&
+        ts.isCallExpression(body) &&
+        body.expression.kind === ts.SyntaxKind.ImportKeyword &&
+        body.arguments.length === 1
+      ) {
+        const specifier = string(body.arguments[0], factory.module),
+          target =
+            typeof specifier === "string" &&
+            resolveModule(factory.module.file, specifier);
+        const resolved = target && resolveBinding(target, target.defaultName);
+        if (resolved)
+          return { ...resolved, lazy: true, wrapped: factory.wrapped };
+      }
+    }
+    return ref;
+  }
+  return { reference, string, component };
+}

package/src/static-primitives.mjs

@@ -0,0 +1,48 @@
+/** A finite source-only React Router matcher. No merchant modules or regular expressions run. */
+export function sourceMatchPath(input, pathname) {
+  const options = typeof input === "string" ? { path: input } : input;
+  if (
+    !options ||
+    typeof options.path !== "string" ||
+    typeof pathname !== "string" ||
+    options.path.length > 1024 ||
+    pathname.length > 4000
+  )
+    throw Error("Unsupported source path");
+  const parts = options.path.split("/").filter(Boolean),
+    names = [];
+  let pattern = "^";
+  for (const [index, part] of parts.entries()) {
+    if (part === "*" && index === parts.length - 1) {
+      names.push("*");
+      pattern += "(?:/(.*))?";
+    } else if (/^:[A-Za-z_][\w-]*\??$/.test(part)) {
+      names.push(part.slice(1).replace(/\?$/, ""));
+      pattern += part.endsWith("?") ? "(?:/([^/]+))?" : "/([^/]+)";
+    } else if (/^[\w.~-]+$/.test(part))
+      pattern += "/" + part.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    else throw Error("Unsupported source pattern");
+  }
+  pattern += options.end === false ? "(?=/|$)" : "/*$";
+  const match = new RegExp(pattern, options.caseSensitive ? "" : "i").exec(
+    pathname,
+  );
+  if (!match) return null;
+  return {
+    params: Object.fromEntries(
+      names.map((name, index) => [
+        name,
+        match[index + 1] === undefined
+          ? undefined
+          : decodeURIComponent(match[index + 1]),
+      ]),
+    ),
+    pathname: match[0] || "/",
+    pathnameBase: (match[0] || "/").replace(/\/+$/, "") || "/",
+    pattern: {
+      path: options.path,
+      caseSensitive: options.caseSensitive ?? false,
+      end: options.end ?? true,
+    },
+  };
+}

package/src/static-query.mjs

@@ -1,6 +1,7 @@
+import {sourceMatchPath} from './static-primitives.mjs';
 // Abstract interpretation of bounded, synchronous, read-only source helpers.
 // No import(), eval, native callback invocation, await or object mutation.
-export function staticQuery({ ts, node, module, context, binding, unknown, redact, sensitive }) {
+export function staticQuery({ ts, node, module, context, binding, unknown, redact, sensitive, reference, isReference, imported, project }) {
   let steps = 0;
   const closure = Symbol("source-function"), writable = Symbol("function-locals"), fail = () => { throw unknown; };
   const tick = () => { if (++steps > 6000) fail(); };
@@ -9,7 +10,9 @@ export function staticQuery({ ts, node, module, context, binding, unknown, redac
   const scalar = value => value === null || ["string", "boolean", "number", "undefined"].includes(typeof value);
   function clean(value, depth = 0) {
     tick();
-    if (depth > 20 || value === unknown || value?.[closure]) fail();
+    if (depth > 20) fail();
+    if(isReference?.(value))return value;
+    if(value===unknown||value?.[closure]){if(depth>0)return unknown;fail();}
     if (typeof value === "number" && !Number.isFinite(value)) fail();
     if (typeof value === "string") return redact(value);
     if (Array.isArray(value)) { if (value.length > 256) fail(); return value.map(v => clean(v, depth + 1)); }
@@ -20,6 +23,7 @@ export function staticQuery({ ts, node, module, context, binding, unknown, redac
   function read(n, m, env, seen = new Set(), depth = 0) {
     tick(); n = unwrap(n); if (!n || depth > 24) fail();
     const ev = child => read(child, m, env, seen, depth + 1);
+    const opaque=!(ts.isIdentifier(n)&&Object.hasOwn(env,n.text))&&reference?.(n,m);if(opaque)return opaque;
     if (ts.isStringLiteralLike(n)) return redact(n.text);
     if (ts.isNumericLiteral(n)) return Number(n.text);
     if (n.kind === ts.SyntaxKind.TrueKeyword) return true;
@@ -38,11 +42,11 @@ export function staticQuery({ ts, node, module, context, binding, unknown, redac
     if (ts.isObjectLiteralExpression(n)) {
       const value = Object.create(null);
       for (const p of n.properties) {
-        if (ts.isShorthandPropertyAssignment(p)) { value[p.name.text] = sensitive(p.name.text) ? unknown : ev(p.name); continue; }
+        if (ts.isShorthandPropertyAssignment(p)) { try{value[p.name.text] = sensitive(p.name.text) ? unknown : ev(p.name);}catch{value[p.name.text]=unknown;}continue; }
         if (!ts.isPropertyAssignment(p) || !p.name || ts.isComputedPropertyName(p.name)) fail();
         const key = p.name.text; if (!key || ["__proto__", "constructor", "prototype"].includes(key)) fail();
         // Keep unrelated async/mutating helpers opaque, never evaluate their bodies.
-        value[key] = sensitive(key) ? unknown : ev(p.initializer);
+        try{value[key] = sensitive(key) ? unknown : ev(p.initializer);}catch{value[key]=unknown;}
       }
       return value;
     }
@@ -50,8 +54,11 @@ export function staticQuery({ ts, node, module, context, binding, unknown, redac
       const object = ev(n.expression), key = ts.isPropertyAccessExpression(n) ? n.name.text : ev(n.argumentExpression);
       if (object == null && n.questionDotToken) return undefined;
       if (object == null || ["__proto__", "constructor", "prototype"].includes(key) || sensitive(String(key))) fail();
-      return Object.hasOwn(Object(object), key) || key === "length" ? object[key] : undefined;
+      const result=Object.hasOwn(Object(object), key) || key === "length" ? object[key] : undefined;
+      if(result===unknown)fail();return result;
     }
+    if(ts.isTemplateExpression(n)){let text=n.head.text;for(const span of n.templateSpans){const v=ev(span.expression);if(!scalar(v)||v===unknown)fail();text+=String(v)+span.literal.text;if(text.length>4000)fail();}return redact(text);}
+    if(ts.isRegularExpressionLiteral(n)){const raw=n.getText(m.source);if(raw==='/[?#]/')return {sourceRegex:'query-separator'};if(raw==='/\\/+$/')return {sourceRegex:'trailing-slashes'};if(raw==='/^./')return {sourceRegex:'first-character'};fail();}
     if (ts.isTypeOfExpression(n)) return typeof ev(n.expression);
     if (ts.isPrefixUnaryExpression(n)) { const value = ev(n.operand); if (n.operator === ts.SyntaxKind.ExclamationToken) return !value; if (n.operator === ts.SyntaxKind.MinusToken && typeof value === "number") return -value; fail(); }
     if (ts.isBinaryExpression(n)) {
@@ -67,15 +74,34 @@ export function staticQuery({ ts, node, module, context, binding, unknown, redac
     }
     if (ts.isConditionalExpression(n)) return ev(ev(n.condition) ? n.whenTrue : n.whenFalse);
     if (ts.isCallExpression(n)) {
+      const projected=project?.(n,m,env);if(Array.isArray(projected))return projected[0];
       if (n.arguments.length > 8) fail();
+      const primitive=imported?.(m,n.expression.getText(m.source));
+      if(primitive?.specifier==='react'&&primitive.name==='useMemo'&&n.arguments.length===2){const fn=ev(n.arguments[0]);return call(fn,[],depth+1);}
       const args = n.arguments.map(ev);
+      if(ts.isPropertyAccessExpression(n.expression)&&ts.isIdentifier(n.expression.expression)&&n.expression.expression.text==='Object'&&!Object.hasOwn(env,'Object')&&!binding(m,'Object')){
+        const method=n.expression.name.text,target=args[0];
+        if(!plain(target)||isReference?.(target)||Object.keys(target).length>256)fail();
+        if(method==='keys'&&args.length===1)return Object.keys(target);
+        if(method==='hasOwn'&&args.length===2&&['string','number'].includes(typeof args[1]))return Object.hasOwn(target,args[1]);
+        fail();
+      }
+      if(['react-router','react-router-dom'].includes(primitive?.specifier)&&primitive.name==='matchPath'&&args.length===2)return sourceMatchPath(args[0],args[1]);
+      if(ts.isIdentifier(n.expression)&&n.expression.text==='String'&&args.length===1&&scalar(args[0]))return String(args[0]);
       if (ts.isPropertyAccessExpression(n.expression)) {
         const target = ev(n.expression.expression), method = n.expression.name.text;
-        if (Array.isArray(target) && ["find", "filter", "map"].includes(method) && args.length === 1 && args[0]?.[closure]) {
+        if (Array.isArray(target) && ["find", "filter", "map", "some", "every", "flatMap"].includes(method) && args.length === 1 && args[0]?.[closure]) {
           if (target.length > 256) fail();
           const result = [];
-          for (let i = 0; i < target.length; i++) { const value = call(args[0], [target[i], i], depth + 1); if (method === "find" && value) return target[i]; if (method === "filter" && value) result.push(target[i]); if (method === "map") result.push(value); }
-          return method === "find" ? undefined : result;
+          for (let i = 0; i < target.length; i++) { const value = call(args[0], [target[i], i], depth + 1); if (method === "find" && value) return target[i]; if (method === "filter" && value) result.push(target[i]); if (method === "map") result.push(value); if(method==="flatMap"){if(!Array.isArray(value))fail();result.push(...value);} if(method==="some"&&value)return true;if(method==="every"&&!value)return false; }
+          return method === "find" ? undefined : method==="some"?false:method==="every"?true:result;
+        }
+        if(typeof target==='string'&&target.length<=4000){
+          if(['startsWith','endsWith','includes','toLowerCase','toUpperCase','trim','slice'].includes(method)&&args.every(v=>['string','number'].includes(typeof v)))return String.prototype[method].apply(target,args);
+          if(method==='split'&&args[0]?.sourceRegex==='query-separator'&&args[1]===1)return target.split(/[?#]/,1);
+          if(method==='replace'&&args[0]?.sourceRegex==='trailing-slashes'&&args[1]==='')return target.replace(/\/+$/,'');
+          if(method==='replaceAll'&&args.length===2&&typeof args[0]==='string'&&args[0].length&&typeof args[1]==='string'){const result=target.split(args[0]).join(args[1]);if(result.length>4000)fail();return result;}
+          if(method==='replace'&&args[0]?.sourceRegex==='first-character'&&args[1]?.[closure]){const first=call(args[1],[target.charAt(0)],depth+1);if(typeof first!=='string')fail();return first+target.slice(1);}
         }
       }
       return call(ev(n.expression), args, depth + 1);
@@ -86,9 +112,11 @@ export function staticQuery({ ts, node, module, context, binding, unknown, redac
     tick(); if (!fn?.[closure] || depth > 24 || fn.node.modifiers?.some(m => m.kind === ts.SyntaxKind.AsyncKeyword)) fail();
     const env = { ...fn.env, [writable]: new Set() };
     for (let i = 0; i < fn.node.parameters.length; i++) {
-      const p = fn.node.parameters[i]; if (!ts.isIdentifier(p.name) || p.dotDotDotToken) fail();
-      env[p.name.text] = args[i] === undefined && p.initializer ? read(p.initializer, fn.module, env, new Set(), depth + 1) : args[i];
-      env[writable].add(p.name.text);
+      const p = fn.node.parameters[i]; if (p.dotDotDotToken) fail();
+      const value=args[i] === undefined && p.initializer ? read(p.initializer, fn.module, env, new Set(), depth + 1) : args[i];
+      if(ts.isIdentifier(p.name)){env[p.name.text]=value;env[writable].add(p.name.text);}
+      else if(ts.isArrayBindingPattern(p.name)&&Array.isArray(value)&&p.name.elements.length<=8){for(const [index,field] of p.name.elements.entries()){if(ts.isOmittedExpression(field))continue;if(!ts.isIdentifier(field.name)||field.dotDotDotToken)fail();env[field.name.text]=value[index]===undefined&&field.initializer?read(field.initializer,fn.module,env,new Set(),depth+1):value[index];env[writable].add(field.name.text);}}
+      else fail();
     }
     if (!ts.isBlock(fn.node.body)) return read(fn.node.body, fn.module, env, new Set(), depth + 1);
     const result = statements(fn.node.body.statements, fn.module, env, depth + 1); return result?.value;

package/src/tab-scenes.mjs

@@ -0,0 +1,214 @@
+import { JSDOM, VirtualConsole } from "jsdom";
+import { documentDom } from "./dom-payload.mjs";
+import { createStateMachine } from "./ui-state-machine.mjs";
+import { previewUiDocument } from "./ui-preview.mjs";
+import {graphSource} from './graph-sources.mjs';
+
+/** Build thumbnail states and edges by dispatching the IAM's actual scalar transitions. */
+export function tabUiScenes(manifest, tabKey) {
+  const graph = manifest.routeTree,
+    tab = graph.ui?.tabs.find((t) => t.tabKey === tabKey);
+  if (!tab || !tab.variableKey) throw Error("Unknown controlled source Tab");
+  const render = graph.renders.find((r) => r.renderKey === tab.renderKey),
+    document = manifest.documents.find(
+      (d) => d.documentKey === render.documentKey,
+    );
+  const dom = new JSDOM(documentDom(document).html, {
+    virtualConsole: new VirtualConsole(),
+  });
+  try {
+    const doc = dom.window.document,
+      nodes = new Map(
+        [...doc.querySelectorAll("[data-iam-node]")].map((n) => [
+          n.getAttribute("data-iam-node"),
+          n,
+        ]),
+      );
+    const ancestors = [];
+    let current = nodes.get(tab.nodeId);
+    while (current && ancestors.length < 128) {
+      ancestors.push(current);
+      current = current.parentElement;
+    }
+    const conditions = {},
+      regions = {},
+      values = {},
+      ids = new Set(ancestors.map((n) => n.getAttribute("data-iam-node")));
+    for (const node of ancestors) {
+      if (node.hasAttribute("data-iam-condition")) {
+        const truthy = node.getAttribute("data-iam-alternative") === "true",
+          root = truthy ? node : node.previousElementSibling;
+        if (
+          !root ||
+          root.getAttribute("data-iam-condition") !==
+            node.getAttribute("data-iam-condition")
+        )
+          throw Error("Invalid source condition pair");
+        conditions[root.getAttribute("data-iam-node")] = truthy;
+      }
+      if (node.hasAttribute("data-iam-region-value")) {
+        const region = (graph.ui.regions ?? []).find((r) =>
+          r.options.some(
+            (o) => o.nodeId === node.getAttribute("data-iam-node"),
+          ),
+        );
+        if (region)
+          regions[region.regionKey] = node.getAttribute(
+            "data-iam-region-value",
+          );
+      }
+    }
+    for (const binding of graph.bindings.filter(
+      (b) =>
+        b.renderKey === tab.renderKey &&
+        b.property === "visible" &&
+        ids.has(b.nodeId),
+    )) {
+      if (binding.value.op === "var") values[binding.value.key] = true;
+      if (binding.value.op === "not" && binding.value.arg.op === "var")
+        values[binding.value.arg.key] = false;
+      if (
+        binding.value.op === "eq" &&
+        binding.value.left.op === "var" &&
+        binding.value.right.op === "const"
+      )
+        values[binding.value.left.key] = binding.value.right.value;
+    }
+    const scope = nodes.get(tab.scopeNodeId ?? tab.nodeId),
+      overlay = scope?.getAttribute("role") === "dialog",
+      width = Number(
+        /\bw-\[(\d+)px\]/.exec(scope?.getAttribute("class") ?? "")?.[1] || 0,
+      );
+    const viewport = overlay
+      ? {
+          width: width ? Math.max(320, width + 48) : 640,
+          height: width ? 480 : 400,
+        }
+      : { width: 480, height: 760 };
+    const base = {
+      strategy: "content",
+      conditions,
+      regions,
+      values,
+      focusNodeId: tab.scopeNodeId ?? tab.nodeId,
+      viewport,
+    };
+    const initial = createStateMachine(
+        graph,
+        tab.routeKey,
+        tab.renderKey,
+      ).snapshot(),
+      scenes = [];
+    for (const item of tab.items) {
+      const machine = createStateMachine(graph, tab.routeKey, tab.renderKey);
+      machine.preview(values);
+      const transition = graph.transitions.find(
+        (t) =>
+          t.renderKey === tab.renderKey &&
+          t.trigger.nodeId === item.nodeId &&
+          t.trigger.event === "click",
+      );
+      const result = transition
+        ? machine.dispatch(item.nodeId, "click", {})
+        : null;
+      if (!result || machine.snapshot()[tab.variableKey] !== item.value)
+        continue;
+      const changed = Object.fromEntries(
+        Object.entries(machine.snapshot()).filter(
+          ([key, value]) => initial[key] !== value || key === tab.variableKey,
+        ),
+      );
+      const options = { ...base, values: { ...values, ...changed } },
+        preview = previewUiDocument(manifest, document, options),
+        sceneDom = new JSDOM(preview.html, {
+          virtualConsole: new VirtualConsole(),
+        });
+      const focused = [
+        ...sceneDom.window.document.querySelectorAll("[data-iam-node]"),
+      ]
+        .find((n) => n.getAttribute("data-iam-node") === base.focusNodeId)
+        ?.cloneNode(true);
+      focused
+        ?.querySelectorAll("[hidden],[role=tablist]")
+        .forEach((n) => n.remove());
+      const headings = focused
+        ? [...focused.querySelectorAll("h1,h2,h3,h4,label,[role=columnheader]")]
+            .map((n) => n.textContent.replace(/\s+/g, " ").trim())
+            .filter(Boolean)
+        : [];
+      const content = focused?.textContent.replace(/\s+/g, " ").trim() ?? "";
+      const fields = focused
+        ? [...focused.querySelectorAll("input,textarea,select")].map((n) => ({
+            tag: n.tagName.toLowerCase(),
+            label: n.getAttribute("aria-label") ?? "",
+            placeholder: n.getAttribute("placeholder") ?? "",
+          }))
+        : [];
+      const allowedIds = new Set([
+        ...ancestors.map((n) => n.getAttribute("data-iam-node")),
+        ...(scope
+          ? [scope, ...scope.querySelectorAll("[data-iam-node]")].map((n) =>
+              n.getAttribute("data-iam-node"),
+            )
+          : []),
+      ]);
+      scenes.push({
+        assumptions: preview.assumptions.filter((a) =>
+          allowedIds.has(a.groupKey),
+        ),
+        value: item.value,
+        label:
+          nodes.get(item.nodeId)?.textContent.replace(/\s+/g, " ").trim() ||
+          item.value,
+        options,
+        headings: [...new Set(headings)].slice(0, 8),
+        content: content.slice(0, 1000),
+        fields,
+        collections: preview.collectionChoices.filter((c) => {
+          const row = (graph.ui.collections ?? []).find(
+              (r) => r.collectionKey === c.collectionKey,
+            ),
+            node = row && nodes.get(row.nodeId);
+          return node && (scope === node || scope?.contains(node));
+        }),
+        unobserved: preview.unobserved.filter((u) =>
+          allowedIds.has(u.groupKey),
+        ),
+        transitionKey: result.transitionKey,
+        changedNodeIds: tab.contentNodeIds ?? [],
+      });
+      sceneDom.window.close();
+    }
+    const edges = [];
+    for (const from of scenes)
+      for (const to of scenes) {
+        if (from.value === to.value) continue;
+        const item = tab.items.find((i) => i.value === to.value),
+          machine = createStateMachine(graph, tab.routeKey, tab.renderKey);
+        machine.preview(from.options.values);
+        const result = machine.dispatch(item.nodeId, "click", {});
+        if (!result || machine.snapshot()[tab.variableKey] !== to.value)
+          continue;
+        const transition = graph.transitions.find(
+          (t) => t.transitionKey === result.transitionKey,
+        );
+        edges.push({
+          from: from.value,
+          to: to.value,
+          transitionKey: result.transitionKey,
+          event: transition.trigger.event,
+          variableKey: tab.variableKey,
+          writes: transition.stateWrites.map((w) => ({
+            variableKey: w.variableKey,
+            label: graph.variables.find((v) => v.variableKey === w.variableKey)
+              .label,
+            value: machine.snapshot()[w.variableKey],
+          })),
+          sourceRefs: [graphSource(graph,transition), tab.scopeSource],
+        });
+      }
+    return { tabKey, scenes, edges };
+  } finally {
+    dom.window.close();
+  }
+}