@@ -0,0 +1,29 @@
+---
+"@objectstack/lint": minor
+---
+
+fix(lint)!: `os build`, `os validate`, `os lint` and the page save door refuse a page component whose `properties` is present but not an object, nested components included (#24991)
+
+Clause-②: no (narrowing: `os lint --strict` refuses a nested page component whose `properties` is `null` or an array)
+
+A page component's `properties` is a record on every node. `PageComponentSchema` refuses anything else, but that parse only reaches the top-level components (`regions[].components[]` and `slots.*`). A nested component, in a container's `children`, a tab or accordion panel's `items[].children` or a card's `footer`, sits in an untyped slot that no parse judges. The component-props rule (`validateComponentProps`) then skipped a nested node whose bag was `null`, an array or a scalar. So a nested `record:related_list` with `properties: null`, or a nested `object-metric` with `properties: []`, passed `os lint --strict`, `os validate` and `tsc`, and the page published a component that had lost every prop it was authored with. An absent bag was already judged as `{}`; this was the present-but-not-an-object residual of the same skip.
+
+The rule now refuses such a bag on every walked node, whatever its `type`, with one `component-props-invalid` error located at the node's `properties` path (for example `pages[0].regions[0].components[0].properties.children[0].properties`). The message names what was received (`null`, an array, a string). No per-prop verdicts are added beside it.
+
+**BREAKING — what moves for consumers.**
+
+- `os build`, `os validate` and `os lint` fail on a page whose nested component carries `properties: null`, `properties: []` or a scalar `properties`. Before, they passed.
+- A page write in publish mode that carries such a component answered 200. It now answers `422 INVALID_METADATA` with a `component-props-invalid` issue at that path, because the page save door runs this same rule.
+
+**Remedy.** Write the bag as an object of the props the component reads (`properties: { … }`), or omit the key when the component needs none. An omitted bag is judged as `{}`, so a component with required props still has to name them.
+
+**Unchanged.**
+
+- A top-level component's non-object bag is refused by the page parse, as before, and that parse runs before any authoring rule at both doors, so no second finding appears beside it.
+- An absent bag keeps its earlier verdict: it is judged as `{}`.
+- A valid bag is judged exactly as before. An unregistered component `type` with an object bag is still skipped.
+- The finding takes the rule's existing id and severity (`component-props-invalid`, `error`). No public export or signature moves.
+- Stored pages are not migrated and are not refused on read. A stored page with such a component keeps loading until it is next saved, and that save is judged.
+- Measured before crossing: no page this repository ships authors a non-object `properties` bag.
+
+<!-- adr-0087: not-required (no-migration-prescription) a refusal at the CLI doors and the page save door of a page component whose properties bag is present but not an object: no authorable key, spelling, export or stored shape moves, and no stored row is read, rewritten or converted. A stored page with such a component keeps loading until it is next saved, and the repair is the author restoring the props the component lost, which no ledger entry can derive. The other categories are closed on facts: the package publishes (not unpublished); no ADR-0087 id covers this verdict (not already-registered); and the change is a lint verdict, not a declaration (not runtime-interface-only or type-surface-only). -->
@@ -12,7 +12,7 @@
 // something.
 import { describe, expect, it } from 'vitest';
 import { normalizeStackInput } from '@objectstack/spec';
-import { ComponentPropsMap } from '@objectstack/spec/ui';
+import { ComponentPropsMap, PageSchema } from '@objectstack/spec/ui';
 import {
   validateComponentProps as validateComponentPropsUnrecorded,
   COMPONENT_PROPS_UNKNOWN_KEY,
@@ -325,19 +325,111 @@ describe('validateComponentProps — value verdicts', () => {
       expect(required(validateComponentProps(stackWith([node])))).toContain(path);
     });
 
-    it('a present bag that is not an object is still left to the parse that owns its shape', () => {
-      expect(validateComponentProps(
-        stackWith([{ type: 'page:section', properties: { children: [{ type: 'record:related_list', properties: 'x' }] } }]),
-      )).toEqual([]);
-    });
-
     it('a nested node whose required props are all optional stays silent with no bag', () => {
       expect(validateComponentProps(
         stackWith([{ type: 'page:section', properties: { children: [{ type: 'page:header' }] } }]),
       )).toEqual([]);
     });
   });
 
+  /**
+   * [#24991] A NESTED component whose `properties` is PRESENT but not a record.
+   * `PageComponentSchema` refuses that bag on a top-level node ("expected
+   * record"), but a nested node sits in a `z.array(z.unknown())` slot that no
+   * parse reaches, and this rule used to skip it — `null` and `[]` were measured
+   * passing `lint --strict` on nested `record:related_list` and `object-metric`
+   * in the reporting app. The bag is refused at the node's `properties` path,
+   * once, with no per-prop verdicts beside it.
+   */
+  describe('a nested component whose `properties` is present but not a record (#24991)', () => {
+    const shape = (f: ReturnType<typeof validateComponentProps>) => f.map((x) => [x.rule, x.severity, x.path]);
+    const RELATED = (properties: unknown) => ({ type: 'record:related_list', properties });
+
+    /** The walks #22212 covers, plus a `page:card` footer and a slot's sub-tree. */
+    const WALKS: Array<[string, (child: unknown) => AnyRec, string]> = [
+      ['a container\'s `children`', (child) => stackWith([{ type: 'page:section', properties: { children: [child] } }]),
+        'pages[0].regions[0].components[0].properties.children[0].properties'],
+      ['a tab panel\'s `items[].children`',
+        (child) => stackWith([{ type: 'page:tabs', properties: { items: [{ label: 'T', value: 't', children: [child] }] } }]),
+        'pages[0].regions[0].components[0].properties.items[0].children[0].properties'],
+      ['an accordion panel\'s `items[].children`',
+        (child) => stackWith([{ type: 'page:accordion', properties: { items: [{ label: 'A', children: [child] }] } }]),
+        'pages[0].regions[0].components[0].properties.items[0].children[0].properties'],
+      ['a card\'s `footer`', (child) => stackWith([{ type: 'page:card', properties: { footer: [child] } }]),
+        'pages[0].regions[0].components[0].properties.footer[0].properties'],
+      ['a slot component\'s `children`',
+        (child) => ({ pages: [{ name: 'probe_page', label: 'Probe', type: 'record', object: 'task', kind: 'slotted',
+          slots: { details: [{ type: 'page:section', properties: { children: [child] } }] } }] }),
+        'pages[0].slots.details[0].properties.children[0].properties'],
+    ];
+    const BAGS: Array<[string, unknown, string]> = [
+      ['null', null, '`null`'],
+      ['an array', [], 'an array'],
+      ['a scalar', 'x', 'a string'],
+    ];
+
+    describe.each(WALKS)('in %s', (_walk, wrap, path) => {
+      it.each(BAGS)('a %s bag draws one `component-props-invalid` error at the node\'s `properties`', (_l, bag, received) => {
+        const findings = validateComponentProps(wrap(RELATED(bag)));
+        expect(shape(findings)).toEqual([[COMPONENT_PROPS_INVALID, 'error', path]]);
+        expect(findings[0]!.message).toContain(`received ${received}`);
+      });
+
+      it('control: the same node with a valid bag stays silent', () => {
+        expect(validateComponentProps(wrap(RELATED({ objectName: 'task', relationshipField: 'project' })))).toEqual([]);
+      });
+
+      it('control: the same node with NO bag keeps its #22212 verdict (judged as `{}`)', () => {
+        const paths = invalid(validateComponentProps(wrap({ type: 'record:related_list' }))).map((f) => f.path);
+        expect(paths).toContain(`${path}.relationshipField`);
+        expect(paths).not.toContain(path);
+      });
+    });
+
+    it('`object-metric` nested with `properties: []` — the third measured probe', () => {
+      const findings = validateComponentProps(stackWith([{ type: 'page:section', properties: { children: [{ type: 'object-metric', properties: [] }] } }]));
+      expect(shape(findings)).toEqual([[COMPONENT_PROPS_INVALID, 'error', 'pages[0].regions[0].components[0].properties.children[0].properties']]);
+    });
+
+    it('an unregistered type is refused too: the bag\'s shape is the node\'s contract, not a props schema\'s', () => {
+      const findings = validateComponentProps(stackWith([{ type: 'page:section', properties: { children: [{ type: 'flex', properties: null }] } }]));
+      expect(shape(findings)).toEqual([[COMPONENT_PROPS_INVALID, 'error', 'pages[0].regions[0].components[0].properties.children[0].properties']]);
+      // Control: the same unregistered node with an object bag is still skipped.
+      expect(validateComponentProps(stackWith([{ type: 'page:section', properties: { children: [{ type: 'flex', properties: { anything: 1 } }] } }]))).toEqual([]);
+    });
+
+    it('a data-source-bound element with a malformed bag and no binding draws both node verdicts, nothing more', () => {
+      const findings = validateComponentProps(stackWith([{ type: 'page:section', properties: { children: [{ type: 'element:repeater', properties: null }] } }]));
+      expect(shape(findings).sort()).toEqual([
+        [COMPONENT_PROPS_INVALID, 'error', 'pages[0].regions[0].components[0].properties.children[0].dataSource.object'],
+        [COMPONENT_PROPS_INVALID, 'error', 'pages[0].regions[0].components[0].properties.children[0].properties'],
+      ]);
+    });
+
+    it('top level: the page parse refuses the bag first, and the rule given the raw node answers the same verdict', () => {
+      // The page parse owns the top-level shape — and only that one: the
+      // nested node's bag passes it untouched, which is the whole gap.
+      const top = PageSchema.safeParse((stackWith([RELATED(null)]).pages as AnyRec[])[0]);
+      expect(top.success).toBe(false);
+      expect(top.error!.issues.map((i) => i.path.join('.'))).toContain('regions.0.components.0.properties');
+      const nested = PageSchema.safeParse((stackWith([{ type: 'page:section', properties: { children: [RELATED(null)] } }]).pages as AnyRec[])[0]);
+      expect(nested.success).toBe(true);
+      // An unparsed caller gets one finding, not one per required prop.
+      expect(shape(validateComponentProps(stackWith([RELATED(null)])))).toEqual([
+        [COMPONENT_PROPS_INVALID, 'error', 'pages[0].regions[0].components[0].properties'],
+      ]);
+    });
+
+    it('gates through the shared pipeline at `error`, the rule\'s existing class (#23147)', () => {
+      for (const command of ['validate', 'lint', 'build'] as const) {
+        const mine = runAuthoringRules(command, {
+          normalized: stackWith([{ type: 'page:section', properties: { children: [RELATED(null)] } }]) as never,
+        }).filter((f) => f.rule.startsWith('component-props'));
+        expect(mine.map((f) => [f.rule, f.severity]), command).toEqual([[COMPONENT_PROPS_INVALID, 'error']]);
+      }
+    });
+  });
+
   /**
    * #7702 — `PageHeaderProps.title` used to be required while the platform's
    * own synthesizer (objectui `buildDefaultHeader`) emits every seeded
 
@@ -39,7 +39,10 @@
  *   is loud on its own, passthrough stays silent because the key survives) and
  *   the rename suggestions are single-source, never re-derived here.
  * - **`component-props-invalid`** — a value the props schema rejects: a wrong
- *   type, a missing required key, a value outside a declared enum.
+ *   type, a missing required key, a value outside a declared enum; and a
+ *   `properties` bag that is present but not an object (`null`, an array, a
+ *   scalar), on any walked node (#24991 — a nested node's bag is parsed by
+ *   nothing else).
  *
  * A schema that is STRIP today reports its unknown keys through the walker; one
  * that a later `strictObject` batch closes reports them through `safeParse` as
@@ -180,6 +183,13 @@ function strName(v: unknown): string | undefined {
   return typeof v === 'string' && v.length > 0 ? v : undefined;
 }
 
+/** What a non-record `properties` bag is, for the refusal's message. */
+function describeBag(v: unknown): string {
+  if (v === null) return '`null`';
+  if (Array.isArray(v)) return 'an array';
+  return `a ${typeof v}`;
+}
+
 /** A zod schema, as much of one as this file reads. */
 interface PropsSchema {
   safeParse(value: unknown): { success: boolean; error?: { issues: ReadonlyArray<LintZodIssue> } };
@@ -312,26 +322,44 @@ export function validateComponentProps(stack: AnyRec): ComponentPropsFinding[] {
     for (const { component, path } of walkPageComponents(page, `pages[${pi}]`)) {
       const type = strName(component.type);
       if (!type) continue;
-      // Unregistered type — skipped silently. See the module header: `type` is
-      // an open union and the majority of authored nodes are SDUI blocks this
-      // map does not carry.
+      const where = `page "${pageName}" · ${type}`;
+
+      // ── The bag's own shape ──────────────────────────────────────────
+      // [#24991] A PRESENT bag that is not an object (`null`, an array, a
+      // scalar) is refused at the node's `properties` path, on every walked
+      // node and whatever its `type`. `PageComponentSchema` declares
+      // `properties` a record for every component, but that parse only ever
+      // reaches the top-level ones (`regions[].components[]`, `slots.*`): a
+      // NESTED component sits in a `z.array(z.unknown())` slot that no parse
+      // judges, so until this check its `null` or `[]` bag was skipped here
+      // and published a component stripped of every prop it was authored
+      // with. A top-level non-record bag is the parse's refusal first: both
+      // doors run that parse before any authoring rule and stop on it, so this
+      // finding never sits beside it — on a top-level node it only answers a
+      // caller that hands this rule an unparsed stack, with the same verdict.
+      const bag = component.properties;
+      const malformedBag = bag !== undefined && !isRec(bag);
+      if (malformedBag) {
+        findings.push({
+          severity: 'error',
+          rule: COMPONENT_PROPS_INVALID,
+          where,
+          path: `${path}.properties`,
+          message:
+            `properties: expected an object of props, received ${describeBag(bag)} — a component's ` +
+            '`properties` is a record on every node, nested ones included, and this node carries none ' +
+            'of its props, so it is refused and this stack does not pass until the bag is an object',
+          hint:
+            'Write `properties` as an object of the props this component reads (`properties: { … }`), ' +
+            'or omit the key when it needs none.',
+        });
+      }
+
+      // Unregistered type — no props schema to judge the bag against, so the
+      // rest is skipped. See the module header: `type` is an open union and
+      // the majority of authored nodes are SDUI blocks this map does not carry.
       const schema = PROPS_SCHEMAS[type];
       if (!schema) continue;
-      // [#22212] An ABSENT bag is judged as `{}` — what `PageComponentSchema`'s
-      // `properties` default makes it. That default only ever reaches the
-      // components the schema parses, which are the top-level ones: a NESTED
-      // component (in another's `children` / `items[].children` / `footer`) sits
-      // in a `z.array(z.unknown())` slot and keeps its `undefined`. Skipping
-      // that hid every required prop such a component omits, while the same
-      // node one level up drew `component-props-invalid`. A PRESENT bag that is
-      // not an object is still left to the parse that owns its shape.
-      const props =
-        component.properties === undefined
-          ? {}
-          : isRec(component.properties)
-            ? component.properties
-            : undefined;
-      const where = `page "${pageName}" · ${type}`;
 
       // ── The binding an element reads ─────────────────────────────────
       // Judged before the props bag, and whatever the bag holds: the binding
@@ -354,7 +382,17 @@ export function validateComponentProps(stack: AnyRec): ComponentPropsFinding[] {
         });
       }
 
-      if (!props) continue;
+      // A malformed bag drew its one finding above; judging its props would
+      // only repeat it as a missing-prop verdict per required key.
+      if (malformedBag) continue;
+      // [#22212] An ABSENT bag is judged as `{}` — what `PageComponentSchema`'s
+      // `properties` default makes it. That default only ever reaches the
+      // components the schema parses, which are the top-level ones: a NESTED
+      // component (in another's `children` / `items[].children` / `footer`) sits
+      // in a `z.array(z.unknown())` slot and keeps its `undefined`. Skipping
+      // that hid every required prop such a component omits, while the same
+      // node one level up drew `component-props-invalid`.
+      const props: AnyRec = isRec(bag) ? bag : {};
 
       const base = `${path}.properties`;