@multiplatform.one/config 7.45.1 → 7.47.0

package/README.md

@@ -148,8 +148,13 @@ outline, box shadow, shadow or elevation is reported as `field-focus`. Focus
 looks come from MPO: fields take `FIELD_FOCUS_STYLE` (the accent border), other
 controls the theme's focus ring. Zeroing those keys is allowed.
 
-Every violation is tagged with its rule: `field-focus`, `hex`, `geometry`,
-`inline-spacing`, `raw-control`, `styled-mpo` or `token-file`.
+An icon-only button laid in a row beside a field (`Input`, `Select`, an
+`Input.Box` and the other MPO fields) is reported as `field-action` (LC-149). A
+field's own action, such as reveal, clear, copy or an eyedropper, is
+`Input.Action` inside the field's trailing slot.
+
+Every violation is tagged with its rule: `field-action`, `field-focus`, `hex`,
+`geometry`, `inline-spacing`, `raw-control`, `styled-mpo` or `token-file`.
 
 #### Ratchet
 

package/design-lint.mjs

@@ -56,6 +56,13 @@ const svgRoots = new Set(["Svg", "Symbol"]);
 const focusPaint =
   /^(?:outline(?:Width|Color|Offset)?|boxShadow|shadow(?:Color|Opacity|Radius|Offset)|elevation)$/;
 const focusStates = new Set(["focusStyle", "focusVisibleStyle", "focusWithinStyle"]);
+// LC-149 FIELD-TRAILING-ACTION: a field's own action (reveal, clear, copy,
+// eyedropper) is Input.Action inside the field, never an icon button beside it.
+const fieldTag =
+  /^(?:Input|InputParts|FormsInput|TextArea|SearchInput|CopyField|Password|PasswordInput|Select|Combobox|DatePicker|TimePicker|DatetimePicker|PhoneInput|Stepper|NumberInput|Duration)$|\.Box$/;
+const actionTag =
+  /^(?:Button|IconButton|TamaguiButton|Pressable|TouchableOpacity|TouchableHighlight|button)$|\.Button$/;
+const rowTag = /^(?:XStack|XGroup)$|\.XGroup$/;
 const tokenFactories = new Set([
   "createTokens",
   "createTamagui",
@@ -64,6 +71,7 @@ const tokenFactories = new Set([
   "createFont",
 ]);
 export const designRules = [
+  "field-action",
   "field-focus",
   "hex",
   "geometry",
@@ -266,6 +274,68 @@ export function inspectDesign(source, filename, projectRoot = process.cwd()) {
         `${key} paints its own ${name(painted.name)}; focus comes from MPO (FIELD_FOCUS_STYLE).`,
       );
   }
+  function tagText(tag) {
+    return ts.isIdentifier(tag) ? referenceName(tag) : tag.getText(file);
+  }
+  function opening(element) {
+    return ts.isJsxElement(element) ? element.openingElement : element;
+  }
+  function attribute(element, key) {
+    return opening(element).attributes.properties.find(
+      (attr) => ts.isJsxAttribute(attr) && name(attr.name) === key,
+    );
+  }
+  function iconOnly(element) {
+    const children = ts.isJsxElement(element) ? element.children : [];
+    const hasText = children.some(
+      (child) =>
+        (ts.isJsxText(child) && child.text.trim() !== "") ||
+        ((ts.isJsxElement(child) || ts.isJsxSelfClosingElement(child)) &&
+          !tagText(opening(child).tagName).endsWith("Icon")) ||
+        (ts.isJsxExpression(child) &&
+          !!child.expression &&
+          !ts.isJsxElement(child.expression) &&
+          !ts.isJsxSelfClosingElement(child.expression)),
+    );
+    if (hasText) return false;
+    if (attribute(element, "icon")) return true;
+    return children.some(
+      (child) =>
+        (ts.isJsxElement(child) || ts.isJsxSelfClosingElement(child)) &&
+        tagText(opening(child).tagName).endsWith("Icon"),
+    );
+  }
+  function isRow(element) {
+    if (rowTag.test(tagText(opening(element).tagName))) return true;
+    const direction = attribute(element, "flexDirection");
+    return !!direction?.initializer && /["']row["']/.test(direction.initializer.getText(file));
+  }
+  function checkFieldAction(element) {
+    if (!isRow(element)) return;
+    const children = element.children.flatMap((child) => {
+      if (ts.isJsxElement(child) || ts.isJsxSelfClosingElement(child)) return [child];
+      if (
+        ts.isJsxExpression(child) &&
+        child.expression &&
+        ts.isBinaryExpression(child.expression) &&
+        child.expression.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken
+      ) {
+        const right = child.expression.right;
+        const inner = ts.isParenthesizedExpression(right) ? right.expression : right;
+        if (ts.isJsxElement(inner) || ts.isJsxSelfClosingElement(inner)) return [inner];
+      }
+      return [];
+    });
+    if (!children.some((child) => fieldTag.test(tagText(opening(child).tagName)))) return;
+    for (const child of children) {
+      if (actionTag.test(tagText(opening(child).tagName)) && iconOnly(child))
+        report(
+          child,
+          "field-action",
+          "A field's own action is Input.Action inside the field, not a button beside it.",
+        );
+    }
+  }
   function report(node, rule, message) {
     const { line, character } = file.getLineAndCharacterOfPosition(node.getStart(file));
     errors.push(`${filename}:${line + 1}:${character + 1}: [${rule}] ${message}`);
@@ -325,6 +395,7 @@ export function inspectDesign(source, filename, projectRoot = process.cwd()) {
         "raw-icon",
         "Wrap Phosphor icons in themed() before rendering, or pass the component to an MPO icon slot.",
       );
+    if (ts.isJsxElement(node)) checkFieldAction(node);
     if (
       !tokenFile &&
       ts.isCallExpression(node) &&

package/lint.mjs

@@ -1296,11 +1296,74 @@ function checkReactNativeWebExports() {
   return { ok: true, violations };
 }
 
+const REGEX_PRECEDING_KEYWORDS = new Set([
+  "return",
+  "typeof",
+  "case",
+  "in",
+  "of",
+  "void",
+  "delete",
+  "throw",
+  "yield",
+  "await",
+  "else",
+  "do",
+]);
+
+/**
+ * True when the `/` at `index` opens a regex literal rather than dividing.
+ * @param {string} src
+ * @param {number} index
+ */
+function startsRegex(src, index) {
+  let at = index - 1;
+  while (at >= 0 && /\s/.test(src[at])) at--;
+  if (at < 0) return true;
+  const prev = src[at];
+  if (/[\w$]/.test(prev)) {
+    let start = at;
+    while (start > 0 && /[\w$]/.test(src[start - 1])) start--;
+    return REGEX_PRECEDING_KEYWORDS.has(src.slice(start, at + 1));
+  }
+  return !/[)\]"'`]/.test(prev);
+}
+
+/**
+ * The offset just past the regex literal that opens at `index`, flags
+ * included. A line break before the closing `/` means it was not a regex
+ * after all, and the scan resumes right after the `/`.
+ * @param {string} src
+ * @param {number} index
+ */
+function regexEnd(src, index) {
+  let i = index + 1;
+  let inClass = false;
+  while (i < src.length) {
+    const char = src[i];
+    if (char === "\n") return index + 1;
+    if (char === "\\") {
+      i += 2;
+      continue;
+    }
+    if (char === "[") inClass = true;
+    else if (char === "]") inClass = false;
+    else if (char === "/" && !inClass) break;
+    i++;
+  }
+  i++;
+  while (i < src.length && /[a-z]/i.test(src[i])) i++;
+  return i;
+}
+
 /**
- * Offsets in `src` that are live CODE — not inside a comment, a string or a
- * template literal. One left-to-right pass. Regex literals are treated as
- * code, and a `${…}` interpolation is treated as string, which can only ever
- * make this check miss something, never invent a violation.
+ * Offsets in `src` that are live CODE — not inside a comment, a string, a
+ * template literal or a regex literal. One left-to-right pass. A `${…}`
+ * interpolation is treated as string, which can only ever make a check miss
+ * something. A regex literal has to be skipped: a quote inside one, as in
+ * `/^['"]/`, would otherwise open a string and flip the mask for the rest of
+ * the file. A `/` starts a regex when the code before it cannot end an
+ * expression (an operator, an opening bracket, a keyword such as `return`).
  *
  * @param {string} src
  * @returns {Uint8Array} 1 at every code offset
@@ -1321,6 +1384,10 @@ function codeOffsets(src) {
       i += 2;
       continue;
     }
+    if (char === "/" && startsRegex(src, i)) {
+      i = regexEnd(src, i);
+      continue;
+    }
     if (char === '"' || char === "'" || char === "`") {
       const quote = char;
       i++;
@@ -1405,6 +1472,364 @@ function checkImportMetaInPublicSource() {
   return violations;
 }
 
+// ── bare `instanceof` of a web-only global (FZ-7791) ──────────────────────
+
+/**
+ * Classes a browser defines and Hermes, GJS or a bare Node may not. Naming a
+ * missing global is a ReferenceError, and `instanceof` names it even when the
+ * value on the left is a plain object, so the throw lands before the code it
+ * guards ever runs. React Native ships some of these (Blob, FormData, Headers);
+ * they are listed anyway, because GJS and a consumer's own polyfill set differ.
+ */
+const WEB_ONLY_CLASSES = [
+  "ReadableStream",
+  "WritableStream",
+  "TransformStream",
+  "TextDecoderStream",
+  "TextEncoderStream",
+  "CompressionStream",
+  "DecompressionStream",
+  "Blob",
+  "File",
+  "FileList",
+  "FormData",
+  "URLSearchParams",
+  "Headers",
+  "Request",
+  "Response",
+  "BroadcastChannel",
+  "MessageChannel",
+  "MessagePort",
+  "DOMException",
+  "Event",
+  "EventTarget",
+  "CustomEvent",
+  "KeyboardEvent",
+  "MouseEvent",
+  "PointerEvent",
+  "TouchEvent",
+  "FocusEvent",
+  "Node",
+  "Element",
+  "Document",
+  "Window",
+  "ShadowRoot",
+  "DataTransfer",
+  "Worker",
+  "CryptoKey",
+];
+
+const WEB_ONLY_INSTANCEOF_RE = new RegExp(
+  String.raw`\binstanceof\s+(${WEB_ONLY_CLASSES.join("|")}|HTML\w*Element|SVG\w*Element)\b(?!\s*\.)`,
+  "g",
+);
+
+/** Files that only ever load in a browser engine: a web, webview or extension twin. */
+const WEB_ONLY_FILE_RE = /\.(web|webext|tauri)\.(tsx|ts|jsx|js|mjs)$/;
+const WEB_ONLY_SCANNED_RE = /\.(tsx|ts|jsx|js|mjs|cjs|mts|cts)$/;
+
+/** public/test-utils is the vitest DOM harness; it never ships into an app bundle. */
+const WEB_ONLY_EXEMPT_PACKAGES = new Set(["test-utils"]);
+
+/**
+ * The code that runs before `index` in its own block: from the innermost
+ * unclosed `{` (or the top of the file) up to `index`, with every block that
+ * opened and closed in between dropped. A `typeof X` there guards the
+ * `instanceof X` after it, which covers the same-expression form,
+ * `typeof Blob !== "undefined" && v instanceof Blob`, and an early return,
+ * `if (typeof Element === "undefined") return false;`. A guard inside a
+ * sibling callback or another function does not count.
+ * @param {string} src
+ * @param {Uint8Array} mask
+ * @param {number} index
+ */
+function blockBefore(src, mask, index) {
+  let depth = 0;
+  let kept = "";
+  for (let at = index - 1; at >= 0; at--) {
+    const char = src[at];
+    if (mask[at] === 1 && char === "}") {
+      depth++;
+      continue;
+    }
+    if (mask[at] === 1 && char === "{") {
+      if (depth === 0) break;
+      depth--;
+      continue;
+    }
+    if (depth === 0) kept = char + kept;
+  }
+  return kept;
+}
+
+/**
+ * True when the file binds `name` itself (an import, a declaration), so its
+ * `instanceof name` is not the global at all: prosemirror's Node, a local File.
+ * Only a binding in code counts, not one a comment mentions.
+ * @param {string} src
+ * @param {Uint8Array} mask
+ * @param {string} name
+ */
+function bindsName(src, mask, name) {
+  const binding = new RegExp(
+    String.raw`\bimport\s[^;]*\b${name}\b(?!\s+as\b)[^;]*\bfrom\b|\b(?:const|let|var|class|function)\s+${name}\b`,
+    "g",
+  );
+  for (const match of src.matchAll(binding)) {
+    if (mask[match.index ?? 0] === 1) return true;
+  }
+  return false;
+}
+
+/**
+ * `x instanceof ReadableStream` in a public package's runtime source, with no
+ * `typeof ReadableStream` earlier in the same block (FZ-7791).
+ *
+ * HttpClient.request checked its body with a bare `instanceof ReadableStream`.
+ * Hermes has no ReadableStream, so every POST and PUT with a JSON body threw
+ * a ReferenceError before fetch on every native MPO app, while web, where the
+ * global exists, stayed green. Guard it in place
+ * (`typeof X !== "undefined" && v instanceof X`) or move it into a .web twin.
+ *
+ * Exempt: specs and stories, files that load only in a browser engine
+ * (.web/.webext/.tauri), Node-only tooling (a value import of a `node:`
+ * builtin), and a file that binds the name itself.
+ */
+function checkWebOnlyInstanceof() {
+  /** @type {string[]} */
+  const violations = [];
+  if (!existsSync(PUBLIC_DIR)) return violations;
+  for (const pkg of readdirSync(PUBLIC_DIR, { withFileTypes: true })) {
+    if (!pkg.isDirectory() || pkg.name.startsWith(".") || pkg.name === "node_modules") continue;
+    if (WEB_ONLY_EXEMPT_PACKAGES.has(pkg.name)) continue;
+    walkFiles(join(PUBLIC_DIR, pkg.name, "src"), (filePath) => {
+      if (!WEB_ONLY_SCANNED_RE.test(filePath) || filePath.endsWith(".d.ts")) return;
+      if (/\.(spec|test|stories|story)\./.test(filePath) || WEB_ONLY_FILE_RE.test(filePath)) return;
+      const src = readFileSync(filePath, "utf8");
+      if (!src.includes("instanceof")) return;
+      if (NODE_BUILTIN_IMPORT_RE.test(src)) return;
+      const mask = codeOffsets(src);
+      for (const match of src.matchAll(WEB_ONLY_INSTANCEOF_RE)) {
+        const index = match.index ?? 0;
+        if (mask[index] !== 1) continue;
+        const name = match[1];
+        if (bindsName(src, mask, name)) continue;
+        const guard = new RegExp(String.raw`\btypeof\s+(?:globalThis\.)?${name}\b`);
+        if (guard.test(blockBefore(src, mask, index))) continue;
+        violations.push(`${relative(ROOT, filePath)}:${lineAt(src, index)}  instanceof ${name}`);
+      }
+    });
+  }
+  return violations;
+}
+
+// ── window/document DOM calls without a native guard (FZ-7799) ────────────
+
+/**
+ * Window members a browser defines and React Native's `window` does not. RN
+ * makes `window` the global object, so `typeof window === "undefined"` passes
+ * there, and `window.addEventListener(...)` throws "undefined is not a
+ * function" (FZ-7798, SortableList).
+ */
+const WINDOW_DOM_METHODS = [
+  "addEventListener",
+  "removeEventListener",
+  "dispatchEvent",
+  "matchMedia",
+  "getComputedStyle",
+];
+
+/**
+ * A call, `window.addEventListener(`, or any member of `document`, which is a
+ * ReferenceError on its own where there is none. Not `x.document`, and not an
+ * optional call, `window.matchMedia?.(...)`.
+ */
+const NATIVE_DOM_CALL_RE = new RegExp(
+  String.raw`(?<![\w$.])(?:(window)\s*\??\.\s*(${WINDOW_DOM_METHODS.join("|")})\b(?=\s*\()|(document)\s*\??\.\s*([A-Za-z_$][\w$]*))`,
+  "g",
+);
+
+/**
+ * A guard that holds on native: a function-type check of a window member,
+ * `typeof window.addEventListener === "function"`, a truthiness test of one,
+ * `!window.matchMedia`, a check that a document exists,
+ * `typeof document === "undefined"` (React Native has none), or a web-only
+ * branch, `isWeb` / `Platform.OS === "web"`, which is false on every native
+ * build. `typeof window` alone is the bug, so it does not count.
+ */
+const NATIVE_DOM_GUARD_RE = new RegExp(
+  [
+    String.raw`\btypeof\s+(?:\(\s*)?(?:globalThis\s*\??\.\s*)?(?:window\s*\??\.\s*[A-Za-z_$]|document\b)`,
+    String.raw`(?<![\w$.])window\s*\??\.\s*(?:${WINDOW_DOM_METHODS.join("|")})\b(?!\s*(?:\?\.\s*)?\()`,
+    String.raw`\bisWeb\b`,
+    String.raw`\bPlatform\.OS\s*[!=]==?\s*["']web["']`,
+  ].join("|"),
+);
+
+/**
+ * True when `filePath` has a native twin beside it (`index.native.tsx` next to
+ * `index.tsx`, or both `.ios` and `.android`), so Metro never loads it on a
+ * phone and only the web resolves it.
+ * @param {string} filePath
+ */
+function hasNativeTwin(filePath) {
+  const match = /^(.*)\.(tsx|ts|jsx|js)$/.exec(filePath);
+  if (!match || /\.(native|ios|android)$/.test(match[1])) return false;
+  const twin = (/** @type {string} */ platform) =>
+    ["tsx", "ts", "jsx", "js"].some((ext) => existsSync(`${match[1]}.${platform}.${ext}`));
+  return twin("native") || (twin("ios") && twin("android"));
+}
+
+/**
+ * The code before `index` in every block that encloses it, up to the top of
+ * the file, with each block that opened and closed in between dropped. A guard
+ * at the top of an effect covers the cleanup it returns; a guard inside a
+ * sibling function does not.
+ * @param {string} src
+ * @param {Uint8Array} mask
+ * @param {number} index
+ */
+function enclosingBefore(src, mask, index) {
+  let depth = 0;
+  let kept = "";
+  for (let at = index - 1; at >= 0; at--) {
+    const char = src[at];
+    if (mask[at] === 1 && char === "}") {
+      depth++;
+      continue;
+    }
+    if (mask[at] === 1 && char === "{") {
+      if (depth > 0) depth--;
+      continue;
+    }
+    if (depth === 0) kept = char + kept;
+  }
+  return kept;
+}
+
+/**
+ * Functions this file declares whose own body is a native guard, such as
+ * `function canPickFile() { return typeof document !== "undefined"; }`, so a
+ * call to one guards like the check it wraps. Only the same file counts.
+ * @param {string} src
+ * @param {Uint8Array} mask
+ */
+function guardHelpers(src, mask) {
+  /** @type {string[]} */
+  const names = [];
+  const declaration =
+    /\bfunction\s+([A-Za-z_$][\w$]*)\s*\(|\b(?:const|let)\s+([A-Za-z_$][\w$]*)\s*=\s*(?:\([^()]*\)|[A-Za-z_$][\w$]*)\s*(?::\s*[\w$<>[\]|\s]+)?=>/g;
+  for (const match of src.matchAll(declaration)) {
+    const start = match.index ?? 0;
+    if (mask[start] !== 1) continue;
+    const name = match[1] ?? match[2];
+    let at = start + match[0].length;
+    let depth = match[1] ? 1 : 0;
+    let end = src.length;
+    for (; at < src.length; at++) {
+      if (mask[at] !== 1) continue;
+      const char = src[at];
+      if (char === "(" || char === "{") depth++;
+      else if (char === ")" || char === "}") {
+        depth--;
+        if (depth < 0) {
+          end = at;
+          break;
+        }
+        if (depth === 0 && char === "}") {
+          end = at + 1;
+          break;
+        }
+      } else if (depth === 0 && (char === ";" || char === "\n")) {
+        end = at;
+        break;
+      }
+    }
+    if (NATIVE_DOM_GUARD_RE.test(src.slice(start, end))) names.push(name);
+  }
+  return names;
+}
+
+/**
+ * True when `name` is bound in this file other than as the global: an import,
+ * a declaration, a typed parameter, `(document: GraphDoc) =>`, or a
+ * destructured local, `const { document } = query` or
+ * `const [document, setDocument] = useState(...)`. Passing the global along,
+ * `f(window)`, is not a binding.
+ * @param {string} src
+ * @param {Uint8Array} mask
+ * @param {string} name
+ */
+function bindsNameOrParam(src, mask, name) {
+  if (bindsName(src, mask, name)) return true;
+  const param = new RegExp(
+    String.raw`[(,]\s*${name}\s*\??:\s*[A-Z{]|\b(?:const|let|var)\s*[[{][^\]}]*\b${name}\b[^\]}]*[\]}]\s*=`,
+    "g",
+  );
+  for (const match of src.matchAll(param)) {
+    if (mask[match.index ?? 0] === 1) return true;
+  }
+  return false;
+}
+
+/**
+ * `window.addEventListener(...)`, `window.matchMedia(...)` or any
+ * `document.<member>` in a public package's runtime source, with no native
+ * guard earlier in an enclosing block (FZ-7799).
+ *
+ * React Native defines `window` as the global but leaves out the DOM, and has
+ * no `document` at all. FZ-7798 found SortableList guarding with
+ * `typeof window === "undefined"`, which passes on native, so mounting it threw
+ * on window.addEventListener. Guard in place with
+ * `typeof window.addEventListener === "function"` or
+ * `typeof document !== "undefined"` (or call a same-file helper whose body is
+ * that check), call it optionally (`window.addEventListener?.(...)`), or move
+ * it into a .web twin.
+ *
+ * Exempt like the instanceof check: specs and stories, .web/.webext/.tauri
+ * files, Node-only tooling and public/test-utils; and a file that binds the
+ * name itself.
+ */
+function checkNativeDomCalls() {
+  /** @type {string[]} */
+  const violations = [];
+  if (!existsSync(PUBLIC_DIR)) return violations;
+  for (const pkg of readdirSync(PUBLIC_DIR, { withFileTypes: true })) {
+    if (!pkg.isDirectory() || pkg.name.startsWith(".") || pkg.name === "node_modules") continue;
+    if (WEB_ONLY_EXEMPT_PACKAGES.has(pkg.name)) continue;
+    walkFiles(join(PUBLIC_DIR, pkg.name, "src"), (filePath) => {
+      if (!WEB_ONLY_SCANNED_RE.test(filePath) || filePath.endsWith(".d.ts")) return;
+      if (/\.(spec|test|stories|story)\./.test(filePath) || WEB_ONLY_FILE_RE.test(filePath)) return;
+      const src = readFileSync(filePath, "utf8");
+      if (!src.includes("window") && !src.includes("document")) return;
+      if (hasNativeTwin(filePath)) return;
+      if (NODE_BUILTIN_IMPORT_RE.test(src)) return;
+      const mask = codeOffsets(src);
+      const helpers = guardHelpers(src, mask);
+      const helperCall = helpers.length
+        ? new RegExp(String.raw`(?<!function\s+)\b(?:${helpers.join("|")})\s*\(`)
+        : null;
+      for (const match of src.matchAll(NATIVE_DOM_CALL_RE)) {
+        const index = match.index ?? 0;
+        if (mask[index] !== 1) continue;
+        const name = match[1] ?? match[3];
+        const member = match[2] ?? match[4];
+        if (
+          name === "window" &&
+          /\btypeof\s*\(?\s*$/.test(src.slice(Math.max(0, index - 12), index))
+        ) {
+          continue;
+        }
+        if (bindsNameOrParam(src, mask, name)) continue;
+        const before = enclosingBefore(src, mask, index);
+        if (NATIVE_DOM_GUARD_RE.test(before) || helperCall?.test(before)) continue;
+        violations.push(`${relative(ROOT, filePath)}:${lineAt(src, index)}  ${name}.${member}`);
+      }
+    });
+  }
+  return violations;
+}
+
 // ── React Flow selectors outside the token bridge (MPO-191) ───────────────
 
 const REACT_FLOW_SELECTOR_RE = /\.react-flow__[\w-]+/g;
@@ -2153,6 +2578,8 @@ export function runConventionChecks(options = {}) {
   const metroFallbacks = checkMetroSubpathFallbacks();
   const rnWebExports = checkReactNativeWebExports();
   const importMeta = checkImportMetaInPublicSource();
+  const webOnlyInstanceof = checkWebOnlyInstanceof();
+  const nativeDomCalls = checkNativeDomCalls();
   const graphVars = checkGraphVarsCoverage();
   const retiredScaleKnobs = checkRetiredScaleKnobs();
   const overlayOwnership = checkOverlayOwnership();
@@ -2359,6 +2786,24 @@ export function runConventionChecks(options = {}) {
     console.error("");
   }
 
+  if (webOnlyInstanceof.length) {
+    failed = true;
+    console.error(
+      'Convention (FZ-7791 NO BARE instanceof OF A WEB-ONLY GLOBAL IN public/*/src): `v instanceof ReadableStream` names the global, and a runtime without it (Hermes has no ReadableStream; GJS and bare Node lack other DOM and WHATWG classes) throws a ReferenceError before the code it guards runs. Guard it earlier in the same block, `typeof ReadableStream !== "undefined" && v instanceof ReadableStream`, or move it into a .web twin. Specs, stories, .web/.webext/.tauri files and Node-only tooling (a value import of a `node:` builtin) are exempt.\n',
+    );
+    for (const msg of webOnlyInstanceof) console.error(`  ${msg}`);
+    console.error("");
+  }
+
+  if (nativeDomCalls.length) {
+    failed = true;
+    console.error(
+      'Convention (FZ-7799 NO UNGUARDED window/document DOM CALL IN public/*/src): React Native makes `window` the global but gives it no addEventListener, removeEventListener, dispatchEvent, matchMedia or getComputedStyle, and has no `document`, so `typeof window === "undefined"` is not a native guard. Guard earlier in an enclosing block with `typeof window.addEventListener === "function"` or `typeof document !== "undefined"`, call it optionally (`window.addEventListener?.(...)`), or move it into a .web twin. Specs, stories, .web/.webext/.tauri files and Node-only tooling are exempt.\n',
+    );
+    for (const msg of nativeDomCalls) console.error(`  ${msg}`);
+    console.error("");
+  }
+
   if (tokens.violations.length) {
     failed = true;
     console.error(

package/oxlint.d.ts

@@ -4,6 +4,7 @@ export const CHROME_PROPS: readonly string[];
 export const LAYOUT_PROPS: readonly string[];
 export const GEOMETRY_PROPS: readonly string[];
 export const MARGIN_PROPS: readonly string[];
+export const RAW_TEXT_NAMES: readonly string[];
 export function isPaletteModule(filename: string | undefined): boolean;
 export function matchColorLiteral(value: unknown): string | undefined;
 export function findHexEscapes(src: string): { line: number; reason: string }[];

package/oxlint.mjs

@@ -17,6 +17,12 @@
  *     Tamagui*-prefixed typography escape hatches (TamaguiText, TamaguiHeading,
  *     TamaguiH1…, TamaguiParagraph, TamaguiSizableText, TamaguiAnchor) outside
  *     public/. House Text/Heading shadows are the bare names (MPO-20).
+ *   mpo-conventions/no-voiceless-text — inside public/, raw tamagui typography
+ *     (an import from tamagui, a Tamagui* hatch, or a styled() copy of one)
+ *     renders only with a knob voice: a spread fragment or an explicit
+ *     fontFamily, or nested in a text parent it inherits from. On native a
+ *     bare text node takes no family, so bodyFont never reaches it (LC-137,
+ *     FZ-7739). Everything else rides the house Text.
  *   mpo-conventions/no-chrome-props — ban chrome (background, radius, type,
  *     shadow, elevation) as props on imported @multiplatform.one/* components,
  *     even at a valid token. Layout props (flex, alignSelf, sibling margins)
@@ -89,6 +95,26 @@ function sourceText(context) {
 const RAW_TYPOGRAPHY_HATCH = /^Tamagui(?:Text|SizableText|Paragraph|Heading|H[1-6]|Anchor)$/;
 const HOUSE_PACKAGE = /^@multiplatform\.one\//;
 
+/** Tamagui's own text primitives, by the name their packages export. */
+export const RAW_TEXT_NAMES = Object.freeze([
+  "Text",
+  "SizableText",
+  "Paragraph",
+  "Anchor",
+  "Heading",
+  "H1",
+  "H2",
+  "H3",
+  "H4",
+  "H5",
+  "H6",
+  "Label",
+]);
+const RAW_TEXT_NAME_SET = new Set(RAW_TEXT_NAMES);
+const TAMAGUI_TEXT_SOURCE = /^(?:tamagui|@tamagui\/(?:core|web|text|label))$/;
+/** A JSX element that holds text: a native text child inherits its family. */
+const TEXT_ELEMENT = /(?:^|\.)(?:[A-Za-z]*Text|Paragraph|Anchor|Label|Heading|H[1-6])$/;
+
 /**
  * Chrome props banned on imported `@multiplatform.one/*` components
  * (including Tamagui shorthands). Layout composition through `{...props}`
@@ -515,6 +541,95 @@ export const plugin = {
         };
       },
     },
+    "no-voiceless-text": {
+      meta: {
+        type: "problem",
+        docs: {
+          description:
+            "LC-137 / FZ-7739: raw tamagui typography in public/ must carry its knob voice (a spread fragment or fontFamily) or sit inside a text parent; plain text rides the house Text, SizableText or Paragraph.",
+        },
+        schema: [],
+        messages: {
+          voiceless:
+            "{{name}} is raw tamagui typography with no knob voice. On native it renders the system face whatever bodyFont says (LC-137). Render it through the house Text, SizableText or Paragraph (@multiplatform.one/theme, re-exported by components), or spread its knob voice (knobProps.body, label or heading).",
+        },
+      },
+      create(context) {
+        const raw = new Set();
+        /** Per open JSXElement: does it hold text? */
+        const stack = [];
+        const collect = (statement) => {
+          const node =
+            statement?.type === "ExportNamedDeclaration" ? statement.declaration : statement;
+          if (node?.type === "ImportDeclaration") {
+            if (node.importKind === "type") return false;
+            const fromTamagui = TAMAGUI_TEXT_SOURCE.test(node.source?.value ?? "");
+            let added = false;
+            for (const specifier of node.specifiers ?? []) {
+              if (specifier.type !== "ImportSpecifier" || specifier.importKind === "type") continue;
+              const imported = specifier.imported?.name ?? specifier.imported?.value;
+              const local = specifier.local?.name;
+              if (typeof imported !== "string" || !local || raw.has(local)) continue;
+              if (
+                (fromTamagui && RAW_TEXT_NAME_SET.has(imported)) ||
+                RAW_TYPOGRAPHY_HATCH.test(imported)
+              ) {
+                raw.add(local);
+                added = true;
+              }
+            }
+            return added;
+          }
+          if (node?.type !== "VariableDeclaration") return false;
+          let added = false;
+          for (const declarator of node.declarations ?? []) {
+            const init = declarator.init;
+            const local = declarator.id?.type === "Identifier" ? declarator.id.name : undefined;
+            if (!local || raw.has(local) || init?.type !== "CallExpression") continue;
+            if (init.callee?.type !== "Identifier" || init.callee.name !== "styled") continue;
+            const base = init.arguments?.[0];
+            if (base?.type !== "Identifier" || !raw.has(base.name)) continue;
+            const config = init.arguments?.[1];
+            const namesFamily =
+              config?.type === "ObjectExpression" &&
+              (config.properties ?? []).some(
+                (prop) =>
+                  prop.type === "Property" && (prop.key?.name ?? prop.key?.value) === "fontFamily",
+              );
+            if (!namesFamily) {
+              raw.add(local);
+              added = true;
+            }
+          }
+          return added;
+        };
+        return {
+          Program(node) {
+            // styled() copies can chain and sit below their first use, so the
+            // module scope settles before any JSX is judged.
+            let grew = true;
+            while (grew) grew = (node.body ?? []).map(collect).some(Boolean);
+          },
+          JSXElement(node) {
+            const name = jsxName(node.openingElement?.name);
+            stack.push(raw.has(name) || TEXT_ELEMENT.test(name));
+          },
+          "JSXElement:exit"() {
+            stack.pop();
+          },
+          JSXOpeningElement(node) {
+            const name = jsxName(node.name);
+            if (!raw.has(name)) return;
+            if (stack.slice(0, -1).some(Boolean)) return;
+            const voiced = (node.attributes ?? []).some(
+              (attr) => attr.type === "JSXSpreadAttribute" || jsxAttrName(attr) === "fontFamily",
+            );
+            if (voiced) return;
+            context.report({ node, messageId: "voiceless", data: { name } });
+          },
+        };
+      },
+    },
     "no-chrome-props": {
       meta: {
         type: "problem",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@multiplatform.one/config",
-  "version": "7.45.1",
+  "version": "7.47.0",
   "description": "Shared build and test configuration presets for multiplatform.one",
   "keywords": [
     "config",
@@ -106,7 +106,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@multiplatform.one/utils": "^7.45.1",
+    "@multiplatform.one/utils": "^7.47.0",
     "@tamagui/vite-plugin": "2.7.6",
     "@vitejs/plugin-react": "^6.1.2",
     "dotenv": "^17.4.2",

package/src/lint.spec.ts

@@ -552,6 +552,419 @@ export type Where = PathLike;
   });
 });
 
+describe("no bare instanceof of a web-only global in public/*/src (FZ-7791)", () => {
+  function run(root: string) {
+    const error = vi.spyOn(console, "error").mockImplementation(() => {});
+    const log = vi.spyOn(console, "log").mockImplementation(() => {});
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    const code = runConventionChecks({ roots: { root } });
+    const messages = error.mock.calls.map((call) => String(call[0])).join("\n");
+    error.mockRestore();
+    log.mockRestore();
+    warn.mockRestore();
+    return { code, messages };
+  }
+
+  function publicSrc(root: string, pkg: string, name: string, body: string) {
+    mkdirSync(join(root, "public", pkg, "src"), { recursive: true });
+    writeFileSync(join(root, "public", pkg, "src", name), body);
+    return join("public", pkg, "src", name);
+  }
+
+  it("fails the HttpClient body check that threw on Hermes, naming the file and line", () => {
+    const root = makeTree();
+    const file = publicSrc(
+      root,
+      "frappe",
+      "http.ts",
+      `export function isBodyInit(body: unknown) {
+  return (
+    body instanceof ArrayBuffer ||
+    body instanceof ReadableStream ||
+    ArrayBuffer.isView(body)
+  );
+}
+`,
+    );
+    const { code, messages } = run(root);
+    expect(code).toBe(1);
+    expect(messages).toContain("NO BARE instanceof OF A WEB-ONLY GLOBAL");
+    expect(messages).toContain(`${file}:4  instanceof ReadableStream`);
+    expect(messages).not.toContain("instanceof ArrayBuffer");
+  });
+
+  it("fails DOM classes too, including the HTML*Element family", () => {
+    const root = makeTree();
+    const file = publicSrc(
+      root,
+      "forms",
+      "focus.ts",
+      "export const isInput = (node: unknown) => node instanceof HTMLInputElement;\n",
+    );
+    const { code, messages } = run(root);
+    expect(code).toBe(1);
+    expect(messages).toContain(`${file}:1  instanceof HTMLInputElement`);
+  });
+
+  it("passes a typeof guard in the same expression or an early return in the same block", () => {
+    const root = makeTree();
+    publicSrc(
+      root,
+      "frappe",
+      "guarded.ts",
+      `export function isStream(body: unknown) {
+  return typeof ReadableStream !== "undefined" && body instanceof ReadableStream;
+}
+export function isElement(target: unknown) {
+  if (typeof Element === "undefined") return false;
+  if (!(target instanceof Element)) return false;
+  return target.closest("a") !== null;
+}
+`,
+    );
+    expect(run(root).code).toBe(0);
+  });
+
+  it("does not let a guard in another function cover this one", () => {
+    const root = makeTree();
+    const file = publicSrc(
+      root,
+      "table",
+      "rowPress.ts",
+      `export function hasDom() {
+  return typeof Element !== "undefined";
+}
+export function inRow(next: unknown) {
+  return next instanceof Element;
+}
+`,
+    );
+    const { code, messages } = run(root);
+    expect(code).toBe(1);
+    expect(messages).toContain(`${file}:5  instanceof Element`);
+  });
+
+  it("does not let a guard inside a closed sibling block cover the code after it", () => {
+    const root = makeTree();
+    const file = publicSrc(
+      root,
+      "components",
+      "useFocus.ts",
+      `export function useFocus(node: unknown, onMount: (cb: () => void) => void) {
+  onMount(() => {
+    if (typeof HTMLElement === "undefined") return;
+  });
+  return node instanceof HTMLElement ? node : null;
+}
+export const isEl = (v: unknown) => v instanceof Element;
+export function hasElement() {
+  return typeof Element !== "undefined";
+}
+`,
+    );
+    const { code, messages } = run(root);
+    expect(code).toBe(1);
+    expect(messages).toContain(`${file}:5  instanceof HTMLElement`);
+    expect(messages).toContain(`${file}:7  instanceof Element`);
+  });
+
+  it("keeps reading code after a regex literal that holds a quote", () => {
+    const root = makeTree();
+    const file = publicSrc(
+      root,
+      "theme",
+      "audit.ts",
+      `export const unquote = (v: string) => v.replace(/^['"]|['"]$/g, "");
+export const scoped = (scope: unknown) => (scope instanceof Element ? [scope] : []);
+`,
+    );
+    const { code, messages } = run(root);
+    expect(code).toBe(1);
+    expect(messages).toContain(`${file}:2  instanceof Element`);
+  });
+
+  it("does not exempt a file whose comment only mentions an import of the name", () => {
+    const root = makeTree();
+    const file = publicSrc(
+      root,
+      "forms",
+      "picker.ts",
+      `// import the File from the picker and pass it from here
+export const isFile = (v: unknown) => v instanceof File;
+`,
+    );
+    const { code, messages } = run(root);
+    expect(code).toBe(1);
+    expect(messages).toContain(`${file}:2  instanceof File`);
+  });
+
+  it("exempts comments and strings, web twins, specs, Node tooling and a locally bound name", () => {
+    const root = makeTree();
+    publicSrc(
+      root,
+      "frappe",
+      "doc.ts",
+      `// a bare \`body instanceof ReadableStream\` threw on Hermes
+export const why = "x instanceof Blob is banned";
+`,
+    );
+    publicSrc(
+      root,
+      "components",
+      "focus.web.ts",
+      "export const f = (n: unknown) => n instanceof HTMLElement;\n",
+    );
+    publicSrc(
+      root,
+      "components",
+      "focus.spec.ts",
+      "export const f = (n: unknown) => n instanceof HTMLElement;\n",
+    );
+    publicSrc(
+      root,
+      "cli",
+      "upload.ts",
+      `import { readFileSync } from "node:fs";
+export const isBlob = (v: unknown) => v instanceof Blob;
+export const read = readFileSync;
+`,
+    );
+    publicSrc(
+      root,
+      "rich-text",
+      "schema.ts",
+      `import { Node } from "prosemirror-model";
+export const isDoc = (v: unknown) => v instanceof Node;
+`,
+    );
+    expect(run(root).code).toBe(0);
+  });
+});
+
+describe("no unguarded window/document DOM call in public/*/src (FZ-7799)", () => {
+  function run(root: string) {
+    const error = vi.spyOn(console, "error").mockImplementation(() => {});
+    const log = vi.spyOn(console, "log").mockImplementation(() => {});
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    const code = runConventionChecks({ roots: { root } });
+    const messages = error.mock.calls.map((call) => String(call[0])).join("\n");
+    error.mockRestore();
+    log.mockRestore();
+    warn.mockRestore();
+    return { code, messages };
+  }
+
+  function publicSrc(root: string, pkg: string, name: string, body: string) {
+    const dir = join(root, "public", pkg, "src", ...name.split("/").slice(0, -1));
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(join(root, "public", pkg, "src", name), body);
+    return join("public", pkg, "src", name);
+  }
+
+  it("fails the SortableList keydown listener that a typeof window guard let through on React Native", () => {
+    const root = makeTree();
+    const file = publicSrc(
+      root,
+      "components",
+      "useSortableRows.ts",
+      `export function listen(enabled: boolean, onKey: (e: KeyboardEvent) => void) {
+  if (!enabled || typeof window === "undefined") return;
+  window.addEventListener("keydown", onKey);
+  return () => window.removeEventListener("keydown", onKey);
+}
+`,
+    );
+    const { code, messages } = run(root);
+    expect(code).toBe(1);
+    expect(messages).toContain("NO UNGUARDED window/document DOM CALL");
+    expect(messages).toContain(`${file}:3  window.addEventListener`);
+    expect(messages).toContain(`${file}:4  window.removeEventListener`);
+  });
+
+  it("fails window.matchMedia, window.dispatchEvent and any document member with no guard", () => {
+    const root = makeTree();
+    const file = publicSrc(
+      root,
+      "theme",
+      "dom.ts",
+      `export const dark = () => window.matchMedia("(prefers-color-scheme: dark)").matches;
+export const ping = () => window.dispatchEvent(new Event("ping"));
+export const lock = () => {
+  document.body.style.overflow = "hidden";
+};
+`,
+    );
+    const { code, messages } = run(root);
+    expect(code).toBe(1);
+    expect(messages).toContain(`${file}:1  window.matchMedia`);
+    expect(messages).toContain(`${file}:2  window.dispatchEvent`);
+    expect(messages).toContain(`${file}:4  document.body`);
+  });
+
+  it("fails typeof document.addEventListener on its own, which reads a document native lacks", () => {
+    const root = makeTree();
+    const file = publicSrc(
+      root,
+      "backoffice",
+      "shortcuts.ts",
+      `export function bind(onKey: (e: KeyboardEvent) => void) {
+  if (typeof document.addEventListener !== "function") return;
+  document.addEventListener("keydown", onKey);
+}
+`,
+    );
+    const { code, messages } = run(root);
+    expect(code).toBe(1);
+    expect(messages).toContain(`${file}:2  document.addEventListener`);
+    expect(messages).not.toContain(`${file}:3`);
+  });
+
+  it("passes a function-type check, a document check, an optional call, a truthiness test and a web-only branch", () => {
+    const root = makeTree();
+    publicSrc(
+      root,
+      "components",
+      "guarded.ts",
+      `import { Platform } from "react-native";
+import { isWeb } from "tamagui";
+export function listen(onKey: (e: KeyboardEvent) => void) {
+  if (typeof window === "undefined" || typeof window.addEventListener !== "function") return;
+  window.addEventListener("keydown", onKey);
+  return () => {
+    window.removeEventListener("keydown", onKey);
+  };
+}
+export function lock() {
+  if (typeof document === "undefined") return;
+  document.body.style.overflow = "hidden";
+}
+export const reduced = () => !!window.matchMedia?.("(prefers-reduced-motion: reduce)").matches;
+export function dark() {
+  if (typeof window === "undefined" || !window.matchMedia) return false;
+  return window.matchMedia("(prefers-color-scheme: dark)").matches;
+}
+export function webOnly(onKey: (e: KeyboardEvent) => void) {
+  if (!isWeb) return;
+  window.addEventListener("keydown", onKey);
+}
+export function platformOnly() {
+  if (Platform.OS !== "web") return null;
+  return document.activeElement;
+}
+`,
+    );
+    expect(run(root).code).toBe(0);
+  });
+
+  it("passes a call to a same-file helper whose body is the guard", () => {
+    const root = makeTree();
+    publicSrc(
+      root,
+      "backoffice",
+      "picker.ts",
+      `export function canPickFile(): boolean {
+  return typeof document !== "undefined" && typeof document.createElement === "function";
+}
+export function pickFile() {
+  if (!canPickFile()) return undefined;
+  return document.createElement("input");
+}
+`,
+    );
+    expect(run(root).code).toBe(0);
+  });
+
+  it("does not let a guard in a sibling function cover this one", () => {
+    const root = makeTree();
+    const file = publicSrc(
+      root,
+      "forms",
+      "escape.ts",
+      `export function hasDom() {
+  return typeof document !== "undefined";
+}
+export function useEscape(onKey: (e: KeyboardEvent) => void) {
+  document.addEventListener("keydown", onKey);
+}
+`,
+    );
+    const { code, messages } = run(root);
+    expect(code).toBe(1);
+    expect(messages).toContain(`${file}:5  document.addEventListener`);
+  });
+
+  it("exempts web twins, a file with a native twin, specs, comments, strings and a local document", () => {
+    const root = makeTree();
+    publicSrc(
+      root,
+      "components",
+      "keys.web.ts",
+      'export const on = (f: () => void) => window.addEventListener("keydown", f);\n',
+    );
+    publicSrc(
+      root,
+      "components",
+      "SheetModal/index.tsx",
+      'export const on = (f: () => void) => window.addEventListener("keydown", f);\n',
+    );
+    publicSrc(root, "components", "SheetModal/index.native.tsx", "export const on = () => {};\n");
+    publicSrc(
+      root,
+      "components",
+      "keys.spec.ts",
+      'export const on = (f: () => void) => window.addEventListener("keydown", f);\n',
+    );
+    publicSrc(
+      root,
+      "frappe",
+      "doc.ts",
+      `// window.addEventListener threw on Hermes
+export const why = "document.body is missing on native";
+`,
+    );
+    publicSrc(
+      root,
+      "node-graph",
+      "legal.ts",
+      `export function ids(query: { document: { nodes: { id: string }[] } }) {
+  const { document } = query;
+  return document.nodes.map((node) => node.id);
+}
+export const count = (document: { nodes: unknown[] }) => document.nodes.length;
+`,
+    );
+    publicSrc(
+      root,
+      "node-graph",
+      "useDoc.ts",
+      `import { useState } from "react";
+export function useDoc() {
+  const [document, setDocument] = useState<{ nodes: unknown[] } | null>(null);
+  return { size: document?.nodes.length ?? 0, setDocument };
+}
+`,
+    );
+    expect(run(root).code).toBe(0);
+  });
+
+  it("does not treat passing the global along as a local binding", () => {
+    const root = makeTree();
+    const file = publicSrc(
+      root,
+      "web3",
+      "inject.ts",
+      `export function inject(register: (w: unknown) => void, onReady: () => void) {
+  register(window);
+  window.addEventListener("ready", onReady);
+}
+`,
+    );
+    const { code, messages } = run(root);
+    expect(code).toBe(1);
+    expect(messages).toContain(`${file}:3  window.addEventListener`);
+  });
+});
+
 describe("a scaffolded project, where apps/one is renamed and public/ is pruned (MPO-318)", () => {
   function run(root: string) {
     const error = vi.spyOn(console, "error").mockImplementation(() => {});

package/src/noVoicelessText.spec.ts

@@ -0,0 +1,151 @@
+import { execFileSync } from "node:child_process";
+import { mkdirSync, mkdtempSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { afterAll, describe, expect, it } from "vitest";
+
+// FZ-7739 / LC-137: on native a raw tamagui text node takes no family and
+// inherits none, so bodyFont never reaches it. These run the real oxlint
+// binary over real TSX, so the AST shapes are oxlint's own.
+const packageDir = join(dirname(fileURLToPath(import.meta.url)), "..");
+const oxlintBin = join(
+  dirname(createRequire(import.meta.url).resolve("oxlint/package.json")),
+  "bin",
+  "oxlint",
+);
+
+const project = mkdtempSync(join(tmpdir(), "mpo-voiceless-text-"));
+afterAll(() => rmSync(project, { recursive: true, force: true }));
+
+function lint(source: string): string[] {
+  mkdirSync(join(project, "node_modules", "@multiplatform.one"), { recursive: true });
+  try {
+    symlinkSync(packageDir, join(project, "node_modules", "@multiplatform.one", "config"));
+  } catch {
+    // already linked by an earlier case
+  }
+  writeFileSync(
+    join(project, ".oxlintrc.json"),
+    JSON.stringify({
+      jsPlugins: ["@multiplatform.one/config/oxlint"],
+      rules: { "mpo-conventions/no-voiceless-text": "error" },
+    }),
+  );
+  const file = "public/demo/src/Demo.tsx";
+  mkdirSync(dirname(join(project, file)), { recursive: true });
+  writeFileSync(join(project, file), source);
+  let out: string;
+  try {
+    out = execFileSync(oxlintBin, ["-c", ".oxlintrc.json", "-f", "unix", file], {
+      cwd: project,
+      encoding: "utf8",
+    });
+  } catch (error) {
+    out = String((error as { stdout?: string }).stdout ?? "");
+  }
+  return out
+    .split("\n")
+    .filter((line) => line.includes("no-voiceless-text"))
+    .map((line) => /^[^:]+:(\d+):/.exec(line)?.[1] ?? line);
+}
+
+describe("mpo-conventions/no-voiceless-text (FZ-7739, LC-137)", () => {
+  it("reports raw text with no voice and stays silent on a spread voice or a family", () => {
+    const lines = lint(
+      [
+        'import { useResolvedKnobs } from "@multiplatform.one/theme";',
+        'import { Paragraph, SizableText, Text } from "tamagui";',
+        "export function Demo() {",
+        "  const { knobProps } = useResolvedKnobs();",
+        "  return (",
+        "    <>",
+        "      <Text>dead</Text>",
+        '      <SizableText size="$2">dead</SizableText>',
+        "      <Paragraph>dead</Paragraph>",
+        "      <Text {...knobProps.body}>voiced</Text>",
+        '      <Text fontFamily="$mono">code</Text>',
+        "    </>",
+        "  );",
+        "}",
+        "",
+      ].join("\n"),
+    );
+    expect(lines).toEqual(["7", "8", "9"]);
+  });
+
+  it("lets a text nested in another text inherit, and still reports one inside a view", () => {
+    const lines = lint(
+      [
+        'import { Text } from "@multiplatform.one/theme";',
+        'import { Text as TamaguiText, View } from "tamagui";',
+        "export function Demo() {",
+        "  return (",
+        "    <View>",
+        "      <Text>",
+        '        house <TamaguiText fontWeight="700">bold</TamaguiText>',
+        "      </Text>",
+        "      <TamaguiText>dead</TamaguiText>",
+        "    </View>",
+        "  );",
+        "}",
+        "",
+      ].join("\n"),
+    );
+    expect(lines).toEqual(["9"]);
+  });
+
+  it("follows styled() copies, even ones declared below their use", () => {
+    const lines = lint(
+      [
+        'import { styled, Text } from "tamagui";',
+        "export function Demo() {",
+        "  return (",
+        "    <>",
+        "      <Caption>dead</Caption>",
+        "      <Mono>fixed family</Mono>",
+        "    </>",
+        "  );",
+        "}",
+        'const Caption = styled(Text, { color: "$color11" });',
+        'const Mono = styled(Text, { fontFamily: "$mono" });',
+        "",
+      ].join("\n"),
+    );
+    expect(lines).toEqual(["5"]);
+  });
+
+  it("covers the Tamagui* hatches and stays silent on house names and other packages", () => {
+    const lines = lint(
+      [
+        'import { TamaguiParagraph, Text } from "@multiplatform.one/components";',
+        'import { Text as Other } from "some-other-package";',
+        "export function Demo() {",
+        "  return (",
+        "    <>",
+        "      <TamaguiParagraph>dead</TamaguiParagraph>",
+        "      <Text>house</Text>",
+        "      <Other>other</Other>",
+        "    </>",
+        "  );",
+        "}",
+        "",
+      ].join("\n"),
+    );
+    expect(lines).toEqual(["6"]);
+  });
+
+  it("ignores type-only imports", () => {
+    expect(
+      lint(
+        [
+          'import type { TextProps } from "tamagui";',
+          'import { Text } from "@multiplatform.one/theme";',
+          "export const Demo = (props: TextProps) => <Text {...props} />;",
+          "",
+        ].join("\n"),
+      ),
+    ).toEqual([]);
+  });
+});