@tinkerlandai/indiana-iam 0.3.0 → 0.4.0

package/src/source-redirects.mjs

@@ -0,0 +1,388 @@
+import { uiRelation } from "./ui-structure.mjs";
+
+/** Bounded source dataflow: current location -> query parameter -> Navigate query consumer.
+ * This records conditional UI relations only. It never runs guards, helpers or authentication. */
+export function sourceRedirects({
+  ts,
+  modules,
+  binding,
+  functionFrom,
+  externalImport,
+  sourceLocation,
+  constant,
+  pages,
+  components,
+  documents,
+}) {
+  const router = (ref) =>
+    ["react-router", "react-router-dom"].includes(ref?.specifier);
+  const unknown = Symbol("unresolved redirect");
+  const unwrap = (n) => {
+    while (
+      n &&
+      (ts.isParenthesizedExpression(n) ||
+        ts.isAsExpression(n) ||
+        ts.isNonNullExpression(n) ||
+        ts.isTypeAssertionExpression(n))
+    )
+      n = n.expression;
+    return n;
+  };
+  const score = (v) =>
+    v?.kind === "url"
+      ? 5
+      : v?.kind === "query"
+        ? 4
+        : v?.kind === "origin"
+          ? 3
+          : typeof v === "string"
+            ? 1
+            : 0;
+  const choose = (values) =>
+    values
+      .filter((v) => v !== unknown && v !== undefined && v !== null)
+      .sort((a, b) => score(b) - score(a))[0] ?? unknown;
+  const definitions = new Map();
+  let budget = 0;
+  function value(raw, module, env, refs, depth = 0) {
+    const node = unwrap(raw);
+    if (!node || depth > 16 || ++budget > 20000) return unknown;
+    const next = (n) => value(n, module, env, refs, depth + 1);
+    if (ts.isIdentifier(node)) {
+      if (env.has(node.text)) return env.get(node.text);
+      const c = constant(node, module);
+      return c === undefined ? unknown : c;
+    }
+    if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node))
+      return node.text;
+    if (ts.isPropertyAccessExpression(node)) {
+      const parent = next(node.expression),
+        key = node.name.text;
+      if (
+        parent?.kind === "location" &&
+        ["pathname", "search", "hash"].includes(key)
+      )
+        return { kind: "origin", pathname: key === "pathname" };
+      if (parent && typeof parent === "object" && Object.hasOwn(parent, key))
+        return parent[key];
+      const c = constant(node, module);
+      return c === undefined ? unknown : c;
+    }
+    if (ts.isObjectLiteralExpression(node))
+      return Object.fromEntries(
+        node.properties.flatMap((p) =>
+          ts.isShorthandPropertyAssignment(p)
+            ? [[p.name.text, next(p.name)]]
+            : ts.isPropertyAssignment(p)
+              ? [[p.name.text, next(p.initializer)]]
+              : [],
+        ),
+      );
+    if (ts.isConditionalExpression(node))
+      return choose([next(node.whenTrue), next(node.whenFalse)]);
+    if (
+      ts.isBinaryExpression(node) &&
+      [ts.SyntaxKind.BarBarToken, ts.SyntaxKind.QuestionQuestionToken].includes(
+        node.operatorToken.kind,
+      )
+    )
+      return choose([next(node.left), next(node.right)]);
+    if (
+      ts.isNewExpression(node) &&
+      ts.isIdentifier(node.expression) &&
+      node.expression.text === "URLSearchParams" &&
+      !node.arguments?.length
+    )
+      return { kind: "params", entries: new Map() };
+    if (ts.isTemplateExpression(node)) {
+      const parts = [node.head.text];
+      for (const span of node.templateSpans)
+        parts.push(next(span.expression), span.literal.text);
+      const dynamic = parts.filter((p) => typeof p !== "string");
+      if (
+        dynamic.length &&
+        dynamic.every((p) => p?.kind === "origin") &&
+        dynamic.some((p) => p.pathname) &&
+        parts.filter((p) => typeof p === "string").every((p) => p === "")
+      )
+        return { kind: "origin", pathname: true };
+      if (dynamic.length === 1 && dynamic[0]?.kind === "querystring") {
+        const index = parts.indexOf(dynamic[0]),
+          prefix = parts.slice(0, index).join(""),
+          suffix = parts.slice(index + 1).join("");
+        if (prefix.endsWith("?") && suffix === "")
+          return {
+            kind: "url",
+            path: prefix.slice(0, -1),
+            entries: dynamic[0].entries,
+          };
+      }
+      return dynamic.length ? unknown : parts.join("");
+    }
+    if (ts.isCallExpression(node)) {
+      if (ts.isIdentifier(node.expression)) {
+        const primitive = externalImport(module, node.expression.text);
+        if (router(primitive) && primitive.name === "useLocation")
+          return { kind: "location" };
+        if (router(primitive) && primitive.name === "useSearchParams")
+          return { kind: "search-hook" };
+        const ref = binding(module, node.expression.text),
+          fn = ref && functionFrom(ref.node);
+        if (
+          fn &&
+          !fn.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) &&
+          fn.parameters.every((p) => ts.isIdentifier(p.name))
+        ) {
+          refs.set(
+            ref.module.file + "#" + ref.name,
+            sourceLocation(ref.module, fn, ref.name),
+          );
+          const local = new Map(
+            fn.parameters.map((p, i) => [p.name.text, next(node.arguments[i])]),
+          );
+          const returns = [];
+          scanBody(fn.body, ref.module, local, refs, returns, null, depth + 1);
+          return choose(returns);
+        }
+      }
+      if (ts.isPropertyAccessExpression(node.expression)) {
+        const parent = next(node.expression.expression),
+          method = node.expression.name.text;
+        if (
+          parent?.kind === "search" &&
+          method === "get" &&
+          node.arguments.length === 1
+        ) {
+          const key = next(node.arguments[0]);
+          return typeof key === "string"
+            ? { kind: "query", parameter: key }
+            : unknown;
+        }
+        if (
+          parent?.kind === "params" &&
+          method === "set" &&
+          node.arguments.length === 2
+        ) {
+          const key = next(node.arguments[0]),
+            v = next(node.arguments[1]);
+          if (typeof key === "string" && v !== unknown)
+            parent.entries.set(key, v);
+          return undefined;
+        }
+        if (parent?.kind === "params" && method === "toString")
+          return { kind: "querystring", entries: parent.entries };
+      }
+    }
+    const c = constant(node, module);
+    return c === undefined ? unknown : c;
+  }
+  function scanBody(
+    node,
+    module,
+    env,
+    refs,
+    returns,
+    onNavigate,
+    depth = 0,
+    condition = null,
+  ) {
+    if (!node || depth > 24) return;
+    if (ts.isBlock(node) || ts.isSourceFile(node))
+      for (const statement of node.statements)
+        scanBody(
+          statement,
+          module,
+          env,
+          refs,
+          returns,
+          onNavigate,
+          depth + 1,
+          condition,
+        );
+    else if (ts.isVariableStatement(node))
+      for (const decl of node.declarationList.declarations) {
+        const v = value(decl.initializer, module, env, refs, depth);
+        if (ts.isIdentifier(decl.name)) env.set(decl.name.text, v);
+        else if (ts.isObjectBindingPattern(decl.name)) {
+          for (const field of decl.name.elements)
+            if (ts.isIdentifier(field.name)) {
+              const key = field.propertyName?.text || field.name.text;
+              env.set(
+                field.name.text,
+                v?.kind === "location" &&
+                  ["pathname", "search", "hash"].includes(key)
+                  ? { kind: "origin", pathname: key === "pathname" }
+                  : v && typeof v === "object"
+                    ? (v[key] ?? unknown)
+                    : unknown,
+              );
+            }
+        } else if (
+          ts.isArrayBindingPattern(decl.name) &&
+          v?.kind === "search-hook"
+        ) {
+          const name = decl.name.elements[0]?.name;
+          if (name && ts.isIdentifier(name))
+            env.set(name.text, { kind: "search" });
+        }
+      }
+    else if (ts.isIfStatement(node)) {
+      const label = node.expression.getText(module.source).slice(0, 160),
+        combine = (text) =>
+          condition ? condition + " && (" + text + ")" : text;
+      scanBody(
+        node.thenStatement,
+        module,
+        new Map(env),
+        refs,
+        returns,
+        onNavigate,
+        depth + 1,
+        combine(label),
+      );
+      if (node.elseStatement)
+        scanBody(
+          node.elseStatement,
+          module,
+          new Map(env),
+          refs,
+          returns,
+          onNavigate,
+          depth + 1,
+          combine("!(" + label + ")"),
+        );
+    } else if (ts.isExpressionStatement(node))
+      value(node.expression, module, env, refs, depth);
+    else if (ts.isReturnStatement(node)) {
+      if (onNavigate)
+        scanJsx(
+          node.expression,
+          module,
+          env,
+          refs,
+          onNavigate,
+          depth,
+          condition,
+        );
+      else returns.push(value(node.expression, module, env, refs, depth));
+    } else if (!ts.isFunctionLike(node) && onNavigate)
+      scanJsx(node, module, env, refs, onNavigate, depth, condition);
+  }
+  function scanJsx(node, module, env, refs, emit, depth, condition) {
+    if (!node || depth > 32) return;
+    if (ts.isConditionalExpression(node)) {
+      const label = node.condition.getText(module.source).slice(0, 160);
+      scanJsx(node.whenTrue, module, env, refs, emit, depth + 1, label);
+      scanJsx(
+        node.whenFalse,
+        module,
+        env,
+        refs,
+        emit,
+        depth + 1,
+        "!(" + label + ")",
+      );
+      return;
+    }
+    if (ts.isJsxElement(node) || ts.isJsxSelfClosingElement(node)) {
+      const opening = ts.isJsxElement(node) ? node.openingElement : node,
+        primitive = externalImport(
+          module,
+          opening.tagName.getText(module.source),
+        );
+      if (router(primitive) && primitive.name === "Navigate") {
+        const to = opening.attributes.properties.find(
+          (p) => ts.isJsxAttribute(p) && p.name.text === "to",
+        );
+        const proof = new Map(refs),
+          target = value(
+            ts.isJsxExpression(to?.initializer)
+              ? to.initializer.expression
+              : to?.initializer,
+            module,
+            env,
+            proof,
+          );
+        emit({
+          target,
+          condition,
+          source: sourceLocation(module, node, "$source-navigation"),
+          refs: [...proof.values()],
+        });
+        return;
+      }
+    }
+    if (ts.isFunctionLike(node)) return;
+    ts.forEachChild(node, (child) =>
+      scanJsx(child, module, env, refs, emit, depth + 1, condition),
+    );
+  }
+  for (const component of components) {
+    const module = modules.get(component.file),
+      ref = module && binding(module, component.name),
+      fn = ref && functionFrom(ref.node);
+    if (!fn?.body) continue;
+    budget = 0;
+    const rows = [];
+    scanBody(fn.body, module, new Map(), new Map(), [], (row) =>
+      rows.push(row),
+    );
+    definitions.set(component.componentKey, rows);
+  }
+  const byRoute = new Map(
+    pages.map((p) => [
+      p.pageKey,
+      p.componentKeys.flatMap((key) => definitions.get(key) ?? []),
+    ]),
+  );
+  const result = [];
+  for (const page of pages)
+    for (const row of byRoute.get(page.pageKey)) {
+      const target = row.target;
+      if (target?.kind !== "url" || !target.path.startsWith("/")) continue;
+      const destination = pages.find((p) => p.route === target.path);
+      if (!destination) continue;
+      for (const [parameter, origin] of target.entries) {
+        if (origin?.kind !== "origin" || !origin.pathname) continue;
+        const consumers = byRoute
+          .get(destination.pageKey)
+          .filter(
+            (r) =>
+              r.target?.kind === "query" && r.target.parameter === parameter,
+          );
+        if (!consumers.length) continue;
+        const hasPassword = documents
+          .filter((d) => d.pageKey === destination.pageKey)
+          .some((d) =>
+            d.nodes.some(
+              (n) => n.tag === "input" && n.attributes.type === "password",
+            ),
+          );
+        const sourceRefs = [row.source, ...row.refs].slice(0, 16);
+        result.push(
+          uiRelation({
+            routeKey: page.pageKey,
+            targetRouteKey: destination.pageKey,
+            kind: hasPassword ? "login" : "redirect",
+            returnParameter: parameter,
+            condition: row.condition,
+            activation: "route-condition",
+            sourceRefs,
+          }),
+        );
+        for (const consumer of consumers)
+          result.push(
+            uiRelation({
+              routeKey: destination.pageKey,
+              targetRouteKey: page.pageKey,
+              kind: "return",
+              returnParameter: parameter,
+              condition: consumer.condition,
+              activation: "route-condition",
+              sourceRefs: [consumer.source, ...consumer.refs].slice(0, 16),
+            }),
+          );
+      }
+    }
+  return [...new Map(result.map((r) => [r.relationKey, r])).values()];
+}

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;