fix(lint): a view record is a container — resolve _views keys against it (#3583)

Running the new rule over HotCRM (~18k lines of shipped metadata) reported
~40 `_views` keys as orphans. Every one of them was correct; the rule was
wrong, in two compounding ways:

1. A view record is a CONTAINER, not a view. The default list lives at `list`
   and the named tabs at `listViews.<key>` / `formViews.<key>`, each of which
   may also carry its own `name`. Collecting only the record's own `name`
   makes every named tab look undeclared.
2. The object binding lives INSIDE the container (`list.data.object`), not at
   the record root. The record-level lookup resolved to nothing on the
   canonical shape, so the whole record was skipped — which is why the
   universe was empty enough to report the app's entire view surface.

The examples missed this because none of their bundles carried `_views` keys
at all: the walk was exercised, but that one branch of the universe never
was. A corpus with the keys present is what caught it — §6.1's point about a
false-positive floor only meaning something when the walk is non-empty applies
per branch, not per rule.

`collectViewRecord` now registers each container under the object THAT
container binds (falling back to the record, then to the default list), and
accepts both the map key and the inner `name` — authors write either, and the
key is what the console renders the tab from. Form sections are collected in
the same pass, so `_sections` gets the same binding fix. Objects carrying
views directly (`objects[].views`, `objects[].listViews`) go through one code
path with the owner pinned.

Three regression tests pin the HotCRM shape.

Residual on HotCRM after the fix: 6 findings, all true —
`apps.crm_enterprise.navigation.group_products` and `.group_analytics` across
three locales, where the app declares group_sales / group_work /
group_marketing / group_service / group_insights and neither translated id
exists.

Refs #3583

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_015r31hzuSN19iK8ATRPcCpS

Author: claude

packages/lint/src/validate-translation-references.test.ts

@@ -401,6 +401,88 @@ describe('validateTranslationReferences — namespaces deliberately not judged',
   });
 });
 
+describe('validateTranslationReferences — the canonical view-record shape', () => {
+  // Reduced from HotCRM: a view record is a CONTAINER whose object binding
+  // lives inside `list.data.object`, with the named tabs under `listViews`.
+  // Reading `view.name` / `view.data.object` at the record root resolves
+  // nothing here, drops the record, and reports every view key the app ships —
+  // ~40 correct keys on the real corpus.
+  const leadViews = {
+    objects: [{ name: 'crm_lead', fields: { name: { type: 'text' } } }],
+    views: [
+      {
+        list: {
+          type: 'grid',
+          name: 'all_leads',
+          data: { provider: 'object', object: 'crm_lead' },
+        },
+        listViews: {
+          my_leads: { name: 'my_leads', type: 'grid', data: { provider: 'object', object: 'crm_lead' } },
+          kanban_by_status: { name: 'kanban_by_status', type: 'kanban' },
+        },
+        formViews: {
+          default: {
+            type: 'simple',
+            data: { provider: 'object', object: 'crm_lead' },
+            sections: [{ name: 'contact_info', label: 'Contact Info' }],
+          },
+        },
+      },
+    ],
+  };
+
+  it('resolves the default list, every named tab, and a form section', () => {
+    const findings = validateTranslationReferences({
+      ...leadViews,
+      translations: [
+        {
+          en: {
+            objects: {
+              crm_lead: {
+                label: 'Lead',
+                _views: {
+                  all_leads: { label: 'All Leads' },
+                  my_leads: { label: 'My Leads' },
+                  kanban_by_status: { label: 'By Status' },
+                  default: { label: 'Default Form' },
+                },
+                _sections: { contact_info: { label: 'Contact' } },
+              },
+            },
+          },
+        },
+      ],
+    });
+    expect(findings).toEqual([]);
+  });
+
+  it('still flags a view key no container declares', () => {
+    const findings = validateTranslationReferences({
+      ...leadViews,
+      translations: [
+        { en: { objects: { crm_lead: { label: 'Lead', _views: { hot_leads: { label: 'Hot' } } } } } },
+      ],
+    });
+    expect(findings).toHaveLength(1);
+    expect(findings[0].path).toBe('translations[0].en.objects.crm_lead._views.hot_leads');
+    expect(findings[0].hint).toContain('all_leads');
+  });
+
+  it('resolves views embedded on the object itself', () => {
+    const findings = validateTranslationReferences({
+      objects: [
+        {
+          name: 'crm_lead',
+          fields: { name: { type: 'text' } },
+          listViews: { recent: { name: 'recent', type: 'grid' } },
+        },
+      ],
+      translations: [{ en: { objects: { crm_lead: { label: 'Lead', _views: { recent: { label: 'Recent' } } } } } }],
+    });
+    expect(findings).toEqual([]);
+  });
+});
+
 describe('validateTranslationReferences — section anchors', () => {
   it('resolves a section named on a form view or a record:details page', () => {
     const stack = {

packages/lint/src/validate-translation-references.ts

@@ -197,7 +197,70 @@ function emptyFacts(): ObjectFacts {
   return { fields: new Map(), views: new Set(), actions: new Map(), sections: new Set() };
 }
 
-/** The object a view binds to, across the three shapes views are authored in. */
+/**
+ * Register everything ONE view record contributes: the `_views` names it makes
+ * legal, and the `_sections` names its form views declare — each under the
+ * object that container actually binds.
+ *
+ * Two things about the real shape make this more than "read `view.name`", and
+ * both were learned from the HotCRM corpus (~18k lines of shipped metadata),
+ * where a first pass reported ~40 correct keys as orphans:
+ *
+ *  1. A view record is a CONTAINER, not a view. The default list sits at
+ *     `list`; the named tabs at `listViews.<key>` and `formViews.<key>`, each
+ *     of which may also carry its own `name`. Both the map key and the inner
+ *     `name` are accepted — authors write either, and the key is what the
+ *     console renders the tab from.
+ *  2. The object binding lives INSIDE the container (`list.data.object`), not
+ *     at the record root. A record-level lookup alone resolves to nothing on
+ *     the canonical shape, which silently drops the whole record — a rule that
+ *     then reports every view key the app ships.
+ */
+function collectViewRecord(view: AnyRec, factsFor: (objectName: string) => ObjectFacts): void {
+  const recordObject = viewObjectName(view);
+  const bindingOf = (container: AnyRec): string | undefined =>
+    viewObjectName(container) ?? recordObject;
+
+  const addView = (objectName: string | undefined, name: string | undefined) => {
+    if (objectName && name) factsFor(objectName).views.add(name);
+  };
+
+  const listBinding = isRec(view.list) ? bindingOf(view.list) : undefined;
+  if (isRec(view.list)) addView(listBinding, strName(view.list.name));
+  addView(recordObject ?? listBinding, strName(view.name));
+
+  for (const key of ['listViews', 'formViews'] as const) {
+    const container = view[key];
+    if (!isRec(container)) continue;
+    for (const [subKey, sub] of Object.entries(container)) {
+      if (!isRec(sub)) continue;
+      const binding = bindingOf(sub) ?? listBinding;
+      addView(binding, subKey);
+      addView(binding, strName(sub.name));
+
+      // Form sections carry an OPTIONAL `name` that exists purely for the
+      // `_sections` lookup (`ui/view.zod.ts`: "Stable section identifier for
+      // i18n lookup"). A section without one cannot be translated at all, so
+      // it contributes nothing here.
+      if (binding) {
+        for (const section of asArray(sub.sections)) {
+          const sectionName = strName(section.name);
+          if (sectionName) factsFor(binding).sections.add(sectionName);
+        }
+      }
+    }
+  }
+
+  const sectionBinding = recordObject ?? listBinding;
+  if (sectionBinding) {
+    for (const section of asArray(view.sections)) {
+      const sectionName = strName(section.name);
+      if (sectionName) factsFor(sectionBinding).sections.add(sectionName);
+    }
+  }
+}
+
+/** The object a view (or one of its containers) binds to, across the shapes it is authored in. */
 function viewObjectName(view: AnyRec): string | undefined {
   return (
     strName(view.objectName) ??
@@ -269,10 +332,14 @@ function buildUniverse(stack: AnyRec): Universe {
       const actionName = strName(action.name);
       if (actionName) facts.actions.set(actionName, action);
     }
+    // An object can carry views directly, including the `objects[].listViews`
+    // container the chart rule also walks. `{ ...view, object: objectName }`
+    // pins the binding: an embedded view inherits its owner, and nothing here
+    // depends on the container repeating it.
     for (const view of asArray(obj.views)) {
-      const viewName = strName(view.name);
-      if (viewName) facts.views.add(viewName);
+      collectViewRecord({ ...view, object: strName(view.object) ?? objectName }, factsFor);
     }
+    collectViewRecord({ object: objectName, listViews: obj.listViews }, factsFor);
     // ADR-0085: `fieldGroups[].key` is the i18n anchor for `_sections`.
     for (const group of asArray(obj.fieldGroups)) {
       const key = strName(group.key) ?? strName(group.name);
@@ -282,25 +349,7 @@ function buildUniverse(stack: AnyRec): Universe {
 
   // ── Stack-level views: `_views` names + form-section names ──
   for (const view of asArray(stack.views)) {
-    const objectName = viewObjectName(view);
-    if (!objectName) continue;
-    const facts = factsFor(objectName);
-    const viewName = strName(view.name);
-    if (viewName) facts.views.add(viewName);
-
-    // Form sections carry an OPTIONAL `name` that exists purely for this lookup
-    // (`ui/view.zod.ts`: "Stable section identifier for i18n lookup"). A section
-    // without one cannot be translated at all, so it adds nothing here.
-    for (const formView of asArray(view.formViews)) {
-      for (const section of asArray(formView.sections)) {
-        const sectionName = strName(section.name);
-        if (sectionName) facts.sections.add(sectionName);
-      }
-    }
-    for (const section of asArray(view.sections)) {
-      const sectionName = strName(section.name);
-      if (sectionName) facts.sections.add(sectionName);
-    }
+    collectViewRecord(view, factsFor);
   }
 
   // ── Pages: `record:details` sections are the other `_sections` anchor ──