fix(lint): a map-shaped pages: reaches the four source-page lints

`pages` is authorable as a name-keyed map — `MAP_SUPPORTED_FIELDS`
lists it and `normalizeStackInput` folds it into a list before the
schema parses it, which is why `stack.zod.ts` declares only the
post-normalization `z.array(PageSchema)`. These four rules run on the
raw `os lint` path, where nothing has normalized anything, and their
private coercion answered a map with `[]` — so every page lint passed
by never running.

Pins the closure per rule with a specific rule id and the finding path,
plus the list carrier as the positive control.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Vbw3RPgdtqesx4azk9SbW8

Author: claude

.changeset/lint-collection-copies-guarded-readers.md

@@ -2,23 +2,28 @@
 '@objectstack/lint': patch
 ---
 
-Read the last sixteen collection copies through the package's shared, guarded readers.
+Fix: a name-keyed `pages:` map no longer passes every source-page lint vacuously.
 
-Sixteen rule modules still declared their own `(v: unknown) => AnyRec[]`
-collection coercion. Twelve — the `function` form, which had already grown the
-non-record filter locally in two different spellings — now read `recordsOf`
-from `object-graph.ts`. The four page walks (`validate-jsx-pages`,
-`validate-page-source-styling`, `validate-react-page-props`,
-`validate-react-pages`) carried the arrow form, which cast its array branch
-unchecked; they now read `collectionEntries` from `collection-entries.ts`,
-which drops a non-record member inside the reader while carrying each
-survivor's real config path, so a `pages:` list with an empty item no longer
-renumbers the `pages[N].source` path a finding points an editor at.
+`pages` has two authoring carriers — a list, or a map keyed by page name that
+`normalizeStackInput` folds into a list before the schema sees it. Four rules
+(`validate-jsx-pages`, `validate-page-source-styling`,
+`validate-react-page-props`, `validate-react-pages`) read the collection through
+a private coercion that answered a map with an empty list, and they run on the
+raw `os lint` path where nothing has normalized it yet. On a map-shaped stack
+all four therefore returned no findings by never walking a single page: an
+empty source, a syntax error, an unparseable component and a Tailwind
+`className` were all reported as clean. They now read `collectionEntries`,
+which handles both carriers, and a finding on the map carrier is located by the
+author's own key (`pages.home.source`) rather than a synthetic index.
 
-Two behaviour changes fall out, both on input that was already malformed. An
-array-typed member of `agents:` / `skills:` / `tools:` used to survive the
-looser local filter and draw one reference-integrity finding at a position
-nobody authored; it is now dropped. And a member of a name-keyed `validations:`
-map whose value is not a record is now carried as `{ name }` rather than
-discarded, which reaches no check that reads it. No rule id, message or
-severity changes, and every finding path on well-formed metadata is unchanged.
+The same change removes the last sixteen private copies of the collection
+coercion in this package. Twelve rules — the `function` form, which had already
+grown the non-record filter locally in two different spellings — now read
+`recordsOf` from `object-graph.ts`. Two behaviour changes fall out, both on
+input that was already malformed: an array-typed member of `agents:` /
+`skills:` / `tools:` used to survive the looser local filter and draw one
+reference-integrity finding at a position nobody authored, and is now dropped;
+a member of a name-keyed `validations:` map whose value is not a record is now
+carried as `{ name }` rather than discarded, which reaches no check that reads
+it. No rule id, message or severity changes, and every finding path on the list
+carrier is unchanged.

packages/lint/src/page-walk-map-shape.test.ts

@@ -0,0 +1,73 @@
+// Copyright (c) 2026 ObjectStack. Licensed under the Apache-2.0 license.
+//
+// A name-keyed `pages:` map reaches the four source-page lints (#15728).
+//
+// ## What was vacuous, and why it read as green
+//
+// `pages` is an authoring surface with TWO carriers. `MAP_SUPPORTED_FIELDS`
+// (`packages/spec/src/shared/metadata-collection.zod.ts`) lists it, and
+// `normalizeStackInput` folds the map into an array — injecting the map key as
+// `name` — BEFORE `ObjectStackDefinitionSchema` sees it, which is why
+// `stack.zod.ts` declares the post-normalization form `z.array(PageSchema)`
+// and a raw map fails a bare `safeParse`. Reading that declaration alone says
+// "map is not authorable", and that reading is wrong.
+//
+// These four rules are pure `(stack) => Finding[]` (ADR-0019) and run on the
+// RAW `os lint` path as well as the parsed one, so on the raw path they see
+// exactly what the author's file deserialised to — the map. Each of them used
+// to coerce it with a private
+// `(v: unknown): AnyRec[] => (Array.isArray(v) ? (v as AnyRec[]) : [])`, which
+// answers a map with `[]`. So every page lint below passed on a map-shaped
+// stack by never running: no finding, no error, nothing to notice. That is the
+// failure mode this file exists to keep closed — a lint whose green means it
+// looked, not a lint whose green means it never did.
+//
+// Each case therefore asserts a SPECIFIC rule id and the finding's path. The
+// path is the second half of the fix: `collectionEntries` reports the map key
+// (`pages.home.source`), not a synthetic array index nobody can look up, so
+// the finding stays usable as an edit target on either carrier.
+import { describe, expect, it } from 'vitest';
+import { validateJsxPages } from './validate-jsx-pages.js';
+import { validatePageSourceStyling, PAGE_SOURCE_CLASSNAME } from './validate-page-source-styling.js';
+import { validateReactPageProps, REACT_PAGE_SOURCE_UNPARSEABLE } from './validate-react-page-props.js';
+import { validateReactPages } from './validate-react-pages.js';
+
+/** The same page, authored both ways. `home` is the map key and the `name`. */
+const asMap = (page: Record<string, unknown>) => ({ pages: { home: page } });
+const asList = (page: Record<string, unknown>) => ({ pages: [{ name: 'home', ...page }] });
+
+describe('a name-keyed `pages:` map reaches every source-page lint (#15728)', () => {
+  it('validateReactPages reports the empty source it used to walk past', () => {
+    const f = validateReactPages(asMap({ kind: 'react' }));
+    expect(f.map((x) => x.rule)).toContain('react-page-empty-source');
+    expect(f.find((x) => x.rule === 'react-page-empty-source')?.path).toBe('pages.home.source');
+  });
+
+  it('validateJsxPages reports the empty source it used to walk past', () => {
+    const f = validateJsxPages(asMap({ kind: 'html' }));
+    expect(f.map((x) => x.rule)).toContain('jsx-page-empty-source');
+    expect(f.find((x) => x.rule === 'jsx-page-empty-source')?.path).toBe('pages.home.source');
+  });
+
+  it('validatePageSourceStyling reports the Tailwind className it used to walk past', () => {
+    const f = validatePageSourceStyling(asMap({ kind: 'react', source: 'function Page(){ return <div className="p-4" />; }' }));
+    expect(f.map((x) => x.rule)).toContain(PAGE_SOURCE_CLASSNAME);
+    expect(f.find((x) => x.rule === PAGE_SOURCE_CLASSNAME)?.path).toBe('pages.home.source');
+  });
+
+  it('validateReactPageProps reports the unparseable source it used to walk past', () => {
+    const wrecked = 'function Page(){\n  /* TODO\n  return <ObjectForm mode="edit" />;\n}\n';
+    const f = validateReactPageProps(asMap({ kind: 'react', source: wrecked }));
+    expect(f.map((x) => x.rule)).toContain(REACT_PAGE_SOURCE_UNPARSEABLE);
+    expect(f.find((x) => x.rule === REACT_PAGE_SOURCE_UNPARSEABLE)?.path).toBe('pages.home.source');
+  });
+
+  // The array carrier is the control: the same page authored as a list still
+  // reports the same rule at the positional path, so the map cases above are a
+  // carrier the rules GAINED and not a path spelling they swapped to.
+  it('POSITIVE CONTROL — the list carrier still reports at its positional path', () => {
+    const f = validateReactPages(asList({ kind: 'react' }));
+    expect(f.map((x) => x.rule)).toContain('react-page-empty-source');
+    expect(f.find((x) => x.rule === 'react-page-empty-source')?.path).toBe('pages[0].source');
+  });
+});