@binclusive/a11y 0.1.0

package/src/unity-label-resolve.ts

@@ -0,0 +1,249 @@
+/**
+ * Unity label resolution — the core precision rule for the Unity producer (#70, child
+ * of #66, ADR 0004). The Unity analog of the Liquid present/dynamic/absent attribute
+ * seam (`.patterns/liquid-html-parser/attributes.md`, `src/enforce.ts`).
+ *
+ * A uGUI interactive widget (Button / Toggle) carries its accessible label NOT on
+ * itself but on a **child** `TextMeshProUGUI` / `Text`'s `m_text` field. That same
+ * child very often also carries a `LocalizeStringEvent` (Unity Localization package)
+ * whose `m_UpdateString` calls `set_text` on the sibling TMP at runtime, overwriting
+ * `m_text` from a localization table (`m_StringReference.m_TableReference` /
+ * `m_TableEntryReference`). So the static `m_text` a file-reader sees is, for a
+ * localized widget, a placeholder (often a single char like `X`) — the visible label
+ * is injected at runtime and is **not statically knowable**.
+ *
+ * The label therefore has **three** static states, not a boolean:
+ *
+ *   - `Static(text)` — `m_text` is the real label: a text-bearing child exists and no
+ *     enabled LocalizeStringEvent with a real table reference overrides it.
+ *   - `Dynamic`      — an ENABLED LocalizeStringEvent with a non-empty table reference
+ *     is present on the text child: the label is runtime-injected. Treat it OPAQUE —
+ *     do NOT flag as missing (the no-false-positive lock, story 3). This is the
+ *     precision crux: a naive `m_text`-only read false-positives the *majority* of
+ *     localized buttons in a real Unity project, the failure mode that gets an a11y
+ *     tool uninstalled (the precision invariant in `CLAUDE.md`).
+ *   - `Absent`       — no text-bearing child at all: the genuine missing-label finding
+ *     (story 4).
+ *
+ * The precision invariant the whole resolver lives by holds here: resolve to the
+ * correct state or stay opaque (`Dynamic`), never produce a false `Absent` on a
+ * localized widget.
+ *
+ * Why this module re-reads the raw source for the LocalizeStringEvent fields: the L1
+ * AST (`unity-ast.ts`) captures the field surface the *graph* needs (`m_text`,
+ * `m_Script` guid, `m_Children`) but not the LocalizeStringEvent's `m_Enabled` /
+ * nested `m_StringReference` sub-block. Rather than widen the shared AST (this is a
+ * self-contained rule, #70; integration is a later child), the dynamic-detection
+ * fields are read here, keyed by the component's `&fileID`, from the same source the
+ * graph was parsed from.
+ */
+
+import {
+  childGameObjects,
+  resolveComponentIdentity,
+  type FileId,
+  type UnityComponent,
+  type UnityGameObject,
+  type UnityGraph,
+} from "./unity-ast";
+import type { UnityWidgetKind } from "./unity-guid-registry";
+
+/** The serialized class name of the runtime-localization component whose presence +
+ * enabled + table reference makes a label dynamic. */
+const LOCALIZE_STRING_EVENT_TYPE = "LocalizeStringEvent";
+
+/** The stable built-in guid of `LocalizeStringEvent` (Unity Localization package),
+ * grounded against the #70 corpus anchor `UnityTechnologies/open-project-1` @ 608eac98
+ * (`Tab_Item.prefab`, `GenericButton.prefab`, `Button.prefab`). Identity is keyed on
+ * either the type name or this guid — tolerant of which the serializer emitted. */
+export const LOCALIZE_STRING_EVENT_GUID = "56eb0353ae6e5124bb35b17aff880f16";
+
+/** The widget kinds that bear an accessible-name `m_text` — uGUI legacy `Text` and
+ * `TextMeshProUGUI`. A text widget serializes as a generic `MonoBehaviour` whose
+ * IDENTITY is its `m_Script` guid, so we resolve it via the built-in registry (which
+ * maps both to `host: "text"`), never by the serialized type name (which is just
+ * "MonoBehaviour"). This keeps the seam grounded on the same guid table the rest of
+ * the resolver uses. */
+const TEXT_BEARING_WIDGETS = new Set<UnityWidgetKind>([
+  "TextMeshProUGUI",
+  "Text",
+]);
+
+/**
+ * The 3-state label resolution result — a discriminated union, never a boolean. This
+ * mirrors the Liquid attribute seam: `Static` ≙ present literal, `Dynamic` ≙
+ * runtime-injected (opaque, not flagged), `Absent` ≙ genuinely missing (flagged).
+ */
+export type UnityLabel =
+  | { readonly kind: "static"; readonly text: string }
+  | { readonly kind: "dynamic" }
+  | { readonly kind: "absent" };
+
+/** Constructors — keep call sites total and the union the single shape callers match. */
+export const UnityLabel = {
+  static: (text: string): UnityLabel => ({ kind: "static", text }),
+  dynamic: (): UnityLabel => ({ kind: "dynamic" }),
+  absent: (): UnityLabel => ({ kind: "absent" }),
+} as const;
+
+/**
+ * Resolve the accessible label of an interactive widget GameObject to its 3-state value.
+ *
+ * Walks `m_Children` (one level, via the transform indirection `childGameObjects`
+ * resolves) looking for a text-bearing child component (`TextMeshProUGUI` / `Text`):
+ *
+ *   1. No text-bearing child found anywhere in the children → `Absent`.
+ *   2. A text-bearing child whose GameObject also carries an ENABLED
+ *      LocalizeStringEvent with a non-empty table reference → `Dynamic` (opaque).
+ *   3. Otherwise → `Static(m_text)` (the static literal is the label; an empty/missing
+ *      `m_text` with no localization is `Static("")`, still a resolved label state,
+ *      not absent — absence is *no text component at all*).
+ *
+ * `source` is the same Force-Text source the `graph` was parsed from; it is read only
+ * for the LocalizeStringEvent fields the L1 AST does not capture (`m_Enabled`, the
+ * nested `m_StringReference`), keyed by each component's `&fileID`.
+ *
+ * @returns the 3-state `UnityLabel`. Never throws — a malformed sub-block degrades to
+ *          the conservative state (a non-readable LocalizeStringEvent is treated as not
+ *          dynamic, so the visible `m_text` governs).
+ */
+export function resolveUnityLabel(
+  graph: UnityGraph,
+  widget: UnityGameObject,
+  source: string,
+): UnityLabel {
+  const localizeEvents = readLocalizeStringEvents(source);
+
+  // First text-bearing child wins (a uGUI widget has a single label child by
+  // convention; if several exist, the first in hierarchy order is the label).
+  for (const child of childGameObjects(graph, widget)) {
+    const textComponent = child.components.find((c) => isTextBearing(graph, c));
+    if (!textComponent) continue;
+
+    // Dynamic check: does THIS text child's GameObject carry an enabled
+    // LocalizeStringEvent with a real table reference? If so the label is
+    // runtime-injected → opaque, do not flag.
+    const hasDynamicLabel = child.components.some((component) => {
+      if (!isLocalizeStringEvent(component)) return false;
+      const fields = localizeEvents.get(component.fileId);
+      return fields != null && fields.enabled && fields.hasTableReference;
+    });
+    if (hasDynamicLabel) return UnityLabel.dynamic();
+
+    return UnityLabel.static(textComponent.text ?? "");
+  }
+
+  return UnityLabel.absent();
+}
+
+/** A component carries an accessible-name `m_text` (uGUI `Text` / TMP). Resolved via
+ * the built-in-widget guid registry — a text widget serializes as a generic
+ * `MonoBehaviour`, so its identity is its `m_Script` guid, not its type name. */
+function isTextBearing(graph: UnityGraph, component: UnityComponent): boolean {
+  const identity = resolveComponentIdentity(graph, component);
+  return identity.kind === "widget" && TEXT_BEARING_WIDGETS.has(identity.widget);
+}
+
+/** A component is a `LocalizeStringEvent` — keyed on the built-in guid (robust to
+ * Unity's generic `MonoBehaviour` type name) or, defensively, an explicit type name. */
+function isLocalizeStringEvent(component: UnityComponent): boolean {
+  return (
+    component.scriptGuid === LOCALIZE_STRING_EVENT_GUID ||
+    component.typeName === LOCALIZE_STRING_EVENT_TYPE
+  );
+}
+
+/** The dynamic-detection fields of one LocalizeStringEvent, not captured by the L1 AST. */
+interface LocalizeStringEventFields {
+  /** `m_Enabled: 1` — a disabled event injects nothing at runtime (the base prefab's
+   * shape: disabled + empty reference → the static `m_text` governs). */
+  readonly enabled: boolean;
+  /** A non-empty table reference — either a non-empty `m_TableCollectionName` (a name
+   * or a `GUID:<hex>` form) OR a non-zero `m_KeyId` OR a non-empty `m_Key`. Any one is
+   * a real runtime label source. The base prefab's empty-on-all-three reference is NOT
+   * a real reference, so disabled-or-empty ⇒ not dynamic. */
+  readonly hasTableReference: boolean;
+}
+
+const HEADER_RE = /^--- !u!(\d+) &(\d+)/;
+const ENABLED_RE = /^\s*m_Enabled:\s*(\d+)/;
+const TABLE_COLLECTION_RE = /^\s*m_TableCollectionName:\s*(.*)$/;
+const KEY_ID_RE = /^\s*m_KeyId:\s*(\d+)/;
+const KEY_RE = /^\s*m_Key:\s*(.*)$/;
+const GUID_LINE_RE = /guid:\s*([0-9a-fA-F]{32})/;
+
+/**
+ * Read every LocalizeStringEvent document's dynamic-detection fields from the raw
+ * Force-Text source, indexed by the component's `&fileID`. Line-oriented over the same
+ * `--- !u!N &id` document blocks the L1 AST splits on; we only scan blocks whose
+ * `m_Script` guid is the LocalizeStringEvent guid, and read the three reference fields
+ * plus `m_Enabled`. Tolerant: a malformed block simply contributes no entry (treated
+ * as not-dynamic by the caller — the conservative direction).
+ */
+function readLocalizeStringEvents(source: string): Map<FileId, LocalizeStringEventFields> {
+  const out = new Map<FileId, LocalizeStringEventFields>();
+  const lines = source.split("\n");
+
+  let currentFileId: FileId | null = null;
+  let block: string[] = [];
+
+  const flush = () => {
+    if (currentFileId == null) return;
+    const isLocalize = block.some((l) => {
+      const m = /^\s*m_Script:.*$/.test(l) ? GUID_LINE_RE.exec(l) : null;
+      return m != null && m[1]!.toLowerCase() === LOCALIZE_STRING_EVENT_GUID;
+    });
+    if (isLocalize) {
+      out.set(currentFileId, parseFields(block));
+    }
+  };
+
+  for (const line of lines) {
+    const header = HEADER_RE.exec(line);
+    if (header) {
+      flush();
+      currentFileId = header[2]!;
+      block = [];
+    } else if (currentFileId != null) {
+      block.push(line);
+    }
+  }
+  flush();
+
+  return out;
+}
+
+/** Extract `m_Enabled` + whether any table reference is non-empty from one block. */
+function parseFields(lines: readonly string[]): LocalizeStringEventFields {
+  let enabled = false;
+  let hasTableReference = false;
+
+  for (const line of lines) {
+    const enabledMatch = ENABLED_RE.exec(line);
+    if (enabledMatch) {
+      enabled = enabledMatch[1] === "1";
+      continue;
+    }
+    const collectionMatch = TABLE_COLLECTION_RE.exec(line);
+    if (collectionMatch && stripComment(collectionMatch[1] ?? "") !== "") {
+      hasTableReference = true;
+      continue;
+    }
+    const keyIdMatch = KEY_ID_RE.exec(line);
+    if (keyIdMatch && keyIdMatch[1] !== "0") {
+      hasTableReference = true;
+      continue;
+    }
+    const keyMatch = KEY_RE.exec(line);
+    if (keyMatch && stripComment(keyMatch[1] ?? "") !== "") {
+      hasTableReference = true;
+    }
+  }
+
+  return { enabled, hasTableReference };
+}
+
+/** Strip a trailing YAML comment + surrounding whitespace from a scalar value. */
+function stripComment(raw: string): string {
+  return raw.replace(/\s+#.*$/, "").trim();
+}

package/src/unity-rule-color-only.ts

@@ -0,0 +1,127 @@
+/**
+ * The Unity "color-only interactive state" rule — a per-widget structural-absence
+ * check on the Unity producer (issue #73, child of #66), the Unity analog of the
+ * Liquid structural rules in `liquid-rules.ts`.
+ *
+ * What it flags: a uGUI **Selectable** (Button, Toggle, Slider — any component that
+ * carries the Selectable serialization, i.e. an `m_Transition` field) whose
+ * `m_Transition` is **`1` (ColorTint)**. ColorTint conveys every interactive state —
+ * normal / highlighted / pressed / selected / **disabled** — by COLOR ALONE, with no
+ * non-color cue. That is a WCAG 1.4.1 (Use of Color) failure: a state distinguishable
+ * only by color is invisible to color-blind and low-vision users and is never surfaced
+ * to a screen reader.
+ *
+ * The `m_Transition` enum (Unity's `Selectable.Transition`):
+ *   - `0` None        — no visual state cue at all (a *different* defect, out of scope here)
+ *   - `1` ColorTint   — color-only → **finding**
+ *   - `2` SpriteSwap  — the sprite (shape) changes per state → non-color cue → silent
+ *   - `3` Animation   — an animator drives per-state visuals → non-color cue → silent
+ *
+ * Why this is the right cheap signal — real-corpus grounding (#66): in
+ * `UnityTechnologies/open-project-1` @ 608eac9, **41 of 46 Selectables use
+ * `m_Transition: 1`** (~89% prevalence). The transition mode is a single serialized
+ * field on the resolved Selectable, so the check is cheap and high-frequency. The
+ * real-world frequency is carried, like every other producer's findings, by the
+ * corpus enrichment keyed off the WCAG SC (1.4.1) — not by a raw number on the
+ * `Finding` itself.
+ *
+ * Precision invariant (the resolver's law, honored here): we fire ONLY when the
+ * Selectable serialization is present AND `m_Transition` is unambiguously `1`. A
+ * component with no `m_Transition` is not a Selectable (`transition === null`) and is
+ * never touched; an opaque (binary / unparseable) asset contributes no finding rather
+ * than a guess. We never flag SpriteSwap/Animation/None — each carries (or deliberately
+ * omits) a non-color cue, so flagging it would be the false positive that gets the tool
+ * uninstalled.
+ *
+ * Out of scope (a deeper rule, #66 notes): the contrast-ratio computation of the actual
+ * tint colors. This slice flags the *transition mode*, the cheap structural signal.
+ *
+ * Consumes the `collect-unity` producer's output (the parsed `UnityGraph` per asset),
+ * never a re-parse — {@link scanColorOnlyState} walks a {@link UnityScanResult} directly.
+ */
+
+import type { Finding } from "./core";
+import type { UnityAsset, UnityScanResult } from "./collect-unity";
+import type { UnityComponent } from "./unity-ast";
+
+/** This rule's stable id (the `unity/` namespace mirrors `liquid/` rule ids). */
+export const COLOR_ONLY_STATE_RULE_ID = "unity/color-only-state" as const;
+
+/** The `m_Transition: 1` value — ColorTint, the color-only state transition. */
+const COLOR_TINT = 1;
+
+/** The WCAG Success Criteria this rule maps to: 1.4.1 Use of Color. The corpus
+ * enrichment keys off this SC for the real-world frequency signal, exactly as the
+ * other producers' findings do. */
+const RULE_WCAG: readonly string[] = ["1.4.1"];
+
+/** WCAG SCs for the color-only-state rule (the wcag bridge, analog of
+ * `wcagForLiquidRule`). Stable shape: a function so a caller need not import the array. */
+export function wcagForColorOnlyState(): readonly string[] {
+  return RULE_WCAG;
+}
+
+/** What a caller supplies so a finding can be anchored to its asset. The producer's
+ * {@link UnityAsset} already carries both fields, so {@link unityColorOnlyStateFindings}
+ * accepts it directly. */
+export interface ColorOnlyStateContext {
+  /** The `.prefab` / `.unity` file the finding is anchored in. */
+  readonly file: string;
+  /** The asset's parse outcome from the producer (graph, or opaque). */
+  readonly parse: UnityAsset["parse"];
+}
+
+/** A Selectable is any component that serializes `m_Transition` (`transition !== null`). */
+function isSelectable(component: UnityComponent): component is UnityComponent & { transition: number } {
+  return component.transition !== null;
+}
+
+function makeFinding(file: string): Finding {
+  return {
+    file,
+    // A serialized asset has no meaningful source line for a logical component; the
+    // anchor is the file (the asset is the unit), mirroring the axe path's line-0 convention.
+    line: 0,
+    ruleId: COLOR_ONLY_STATE_RULE_ID,
+    message:
+      "uGUI Selectable uses ColorTint transition (`m_Transition: 1`) — interactive state " +
+      "(highlighted / pressed / selected / disabled) is conveyed by color alone. " +
+      "Color-blind and low-vision users, and screen-reader users, get no state cue. " +
+      "Use SpriteSwap or an Animation transition to add a non-color cue.",
+    wcag: RULE_WCAG,
+    // The static floor's default enforcement (the `decideEnforcement` no-contract
+    // default is `block`); a Unity producer asset has no per-file config seam yet, so it
+    // reports at the floor like the other producers' findings.
+    enforcement: "block",
+    provenance: "unity",
+  };
+}
+
+/**
+ * Findings for one Unity asset: one finding per ColorTint (`m_Transition: 1`)
+ * Selectable in the asset's parsed graph. An opaque asset (binary / unparseable)
+ * yields `[]` — opaque is reported by the producer, not guessed at here.
+ */
+export function unityColorOnlyStateFindings(ctx: ColorOnlyStateContext): Finding[] {
+  if (ctx.parse.kind !== "graph") return [];
+  const findings: Finding[] = [];
+  for (const component of ctx.parse.graph.components.values()) {
+    if (isSelectable(component) && component.transition === COLOR_TINT) {
+      findings.push(makeFinding(ctx.file));
+    }
+  }
+  return findings;
+}
+
+/**
+ * Run the color-only-state rule over a whole {@link UnityScanResult} — the entry point
+ * a CLI/dispatch would call. Consumes the producer's per-asset parse output directly
+ * (no re-parse), and is forgiving: an opaque asset simply contributes nothing.
+ */
+export function scanColorOnlyState(scan: UnityScanResult): Finding[] {
+  const findings: Finding[] = [];
+  for (const asset of scan.assets) {
+    findings.push(...unityColorOnlyStateFindings(asset));
+  }
+  return findings;
+}

package/src/unity-rule-missing-label.ts

@@ -0,0 +1,156 @@
+/**
+ * The Unity missing-accessible-label rule — the per-widget structural-absence check
+ * that the 3-state label resolver (`unity-label-resolve.ts`, #70) was built to feed
+ * (#88, child of epic #87). The Unity analog of the Liquid `*-no-name` rules and the
+ * SwiftUI unlabeled-control rule, sitting one altitude up on the resolver's `Absent`
+ * state.
+ *
+ * What it flags: an interactive uGUI widget — a Button / Toggle, or any Selectable —
+ * whose accessible label resolves to `Absent` (`resolveUnityLabel(...).kind ===
+ * "absent"`), i.e. it carries no text-bearing child at all. A control with no
+ * accessible name exposes no name/role to assistive tech: WCAG 1.1.1 (Non-text
+ * Content, for the missing name) / 4.1.2 (Name, Role, Value).
+ *
+ * Precision invariant (ADR 0004, the resolver's law, honored here strictly): we emit
+ * ONLY on `Absent`. We emit NOTHING on:
+ *   - `static` — a real `m_text` label is present (even an empty literal is a resolved
+ *     label state, not an absence).
+ *   - `dynamic` — a runtime-localized label (an enabled LocalizeStringEvent with a real
+ *     table reference): the visible label is injected at runtime and is NOT statically
+ *     knowable, so it is opaque, never flagged. Emitting a false `Absent` here is the
+ *     wrong-host-class failure that gets an a11y tool uninstalled (`CLAUDE.md`).
+ *   - an opaque / binary asset — no graph to walk, so no finding (opaque is reported by
+ *     the producer `scanUnity`, never guessed at here).
+ *
+ * "Interactive widget" = a GameObject carrying a component whose built-in identity is a
+ * control host (`host === "button"`: Button / Toggle) OR a Selectable (any component
+ * serializing `m_Transition`). Both are the controls that owe an accessible name. A
+ * widget resolved to an opaque/custom component is never treated as interactive (the
+ * precision invariant: correct widget or opaque, never wrong-host).
+ *
+ * Consumes the `collect-unity` producer's output (the parsed `UnityGraph` per asset),
+ * never a re-parse — {@link scanMissingLabel} walks a {@link UnityScanResult} directly.
+ */
+
+import type { UnityAsset, UnityScanResult } from "./collect-unity";
+import type { Finding } from "./core";
+import {
+  type UnityComponent,
+  type UnityGameObject,
+  type UnityGraph,
+  resolveComponentIdentity,
+} from "./unity-ast";
+import { resolveUnityLabel } from "./unity-label-resolve";
+
+/** This rule's stable id (the `unity/` namespace mirrors `liquid/` rule ids). */
+export const MISSING_LABEL_RULE_ID = "unity/missing-accessible-label" as const;
+
+/** The WCAG Success Criteria this rule maps to: 1.1.1 Non-text Content (the missing
+ * accessible name) and 4.1.2 Name, Role, Value (a control with no exposed name). The
+ * corpus enrichment keys off these SCs for the real-world frequency signal, exactly as
+ * the other producers' findings do. */
+const RULE_WCAG: readonly string[] = ["1.1.1", "4.1.2"];
+
+/** WCAG SCs for the missing-accessible-label rule (the wcag bridge, analog of
+ * `wcagForColorOnlyState`). Stable shape: a function so a caller need not import the array. */
+export function wcagForMissingLabel(): readonly string[] {
+  return RULE_WCAG;
+}
+
+/** What a caller supplies so a finding can be anchored to its asset. The producer's
+ * {@link UnityAsset} already carries both fields, so {@link unityMissingLabelFindings}
+ * accepts it directly — but it also needs the raw source, which the resolver reads for
+ * the LocalizeStringEvent fields the L1 AST does not capture. */
+export interface MissingLabelContext {
+  /** The `.prefab` / `.unity` file the finding is anchored in. */
+  readonly file: string;
+  /** The asset's parse outcome from the producer (graph, or opaque). */
+  readonly parse: UnityAsset["parse"];
+  /** The raw Force-Text source the asset was parsed from (the resolver re-reads it for
+   * the LocalizeStringEvent dynamic-detection fields). */
+  readonly source: string;
+}
+
+/**
+ * A GameObject is an interactive widget owing an accessible name iff it carries a
+ * component resolving to a control host (`button`) OR a Selectable (a component
+ * serializing `m_Transition`). A custom/opaque component is never treated as
+ * interactive — the precision invariant (correct widget or opaque, never wrong-host).
+ */
+function isInteractiveWidget(graph: UnityGraph, widget: UnityGameObject): boolean {
+  return widget.components.some((component) => isControlHost(graph, component) || isSelectable(component));
+}
+
+/** A component whose built-in identity is a control host (`button` — Button / Toggle). */
+function isControlHost(graph: UnityGraph, component: UnityComponent): boolean {
+  const identity = resolveComponentIdentity(graph, component);
+  return identity.kind === "widget" && identity.host === "button";
+}
+
+/** A Selectable is any component that serializes `m_Transition` (`transition !== null`). */
+function isSelectable(component: UnityComponent): boolean {
+  return component.transition !== null;
+}
+
+function makeFinding(file: string): Finding {
+  return {
+    file,
+    // A serialized asset has no meaningful source line for a logical widget; the anchor
+    // is the file (the asset is the unit), mirroring the color-only rule's convention.
+    line: 0,
+    ruleId: MISSING_LABEL_RULE_ID,
+    message:
+      "Interactive uGUI widget has no accessible label — no text-bearing child " +
+      "(`TextMeshProUGUI` / `Text`) supplies an accessible name. The control exposes " +
+      "no name to assistive technology, so a screen-reader user cannot identify it. " +
+      "Add a text child with the control's label, or set the accessible name explicitly.",
+    wcag: RULE_WCAG,
+    // The static floor's default enforcement (the `decideEnforcement` no-contract
+    // default is `block`), matching the sibling Unity rules.
+    enforcement: "block",
+    provenance: "unity",
+  };
+}
+
+/**
+ * Findings for one Unity asset: one finding per interactive widget whose label resolves
+ * to `Absent`. A `static` or `dynamic` label emits nothing (the precision invariant),
+ * and an opaque asset (binary / unparseable) yields `[]` — opaque is reported by the
+ * producer, not guessed at here.
+ */
+export function unityMissingLabelFindings(ctx: MissingLabelContext): Finding[] {
+  if (ctx.parse.kind !== "graph") return [];
+  const graph = ctx.parse.graph;
+  const findings: Finding[] = [];
+  for (const widget of graph.gameObjects.values()) {
+    if (!isInteractiveWidget(graph, widget)) continue;
+    if (resolveUnityLabel(graph, widget, ctx.source).kind === "absent") {
+      findings.push(makeFinding(ctx.file));
+    }
+  }
+  return findings;
+}
+
+/**
+ * Run the missing-accessible-label rule over a whole {@link UnityScanResult} — the entry
+ * point the aggregator (`unity-findings.ts`) calls. Consumes the producer's per-asset
+ * parse output directly (no re-parse), and is forgiving: an opaque asset simply
+ * contributes nothing. The raw source is re-read per asset (the resolver needs the
+ * LocalizeStringEvent fields the AST does not capture).
+ */
+export async function scanMissingLabel(scan: UnityScanResult): Promise<Finding[]> {
+  const findings: Finding[] = [];
+  for (const asset of scan.assets) {
+    const source = await readAssetSource(asset);
+    findings.push(...unityMissingLabelFindings({ file: asset.file, parse: asset.parse, source }));
+  }
+  return findings;
+}
+
+/** Read an asset's raw source for the resolver's dynamic-detection pass. An opaque
+ * asset is short-circuited (no graph to resolve), so its source is never read. */
+async function readAssetSource(asset: UnityAsset): Promise<string> {
+  if (asset.parse.kind !== "graph") return "";
+  const { readFile } = await import("node:fs/promises");
+  return readFile(asset.file, "utf8");
+}