diff --git a/‎.changeset/10872-envelope-responsive-styles.md‎
Lines changed: 16 additions & 0 deletions b/‎.changeset/10872-envelope-responsive-styles.md‎
Lines changed: 16 additions & 0 deletions
diff --git a/‎packages/types/src/__tests__/imported-defaults-8317.test.ts‎
Lines changed: 9 additions & 0 deletions b/‎packages/types/src/__tests__/imported-defaults-8317.test.ts‎
Lines changed: 9 additions & 0 deletions
diff --git a/‎packages/types/src/__tests__/public-block-responsive-styles-10872.test.ts‎
Lines changed: 257 additions & 0 deletions b/‎packages/types/src/__tests__/public-block-responsive-styles-10872.test.ts‎
Lines changed: 257 additions & 0 deletions
diff --git a/‎packages/types/src/__tests__/zod-mirror-parity.test.ts‎
Lines changed: 8 additions & 0 deletions b/‎packages/types/src/__tests__/zod-mirror-parity.test.ts‎
Lines changed: 8 additions & 0 deletions
diff --git a/‎packages/types/src/zod/README.md‎
Lines changed: 1 addition & 0 deletions b/‎packages/types/src/zod/README.md‎
Lines changed: 1 addition & 0 deletions
@@ -0,0 +1,16 @@
+---
+'@object-ui/types': minor
+---
+
+Every ADR-0080 public-block arm accepts the node-level `responsiveStyles` that `@objectstack/spec`'s `PageComponentSchema` declares, and judges it as the spec does (objectui#10872, batch 8).
+
+**Clause-②: yes (widening)** — the strict authoring face (`StrictAnyComponentSchema`) now accepts a node-level `responsiveStyles` on the 30 public-block arms (`PublicBlockComponentSchema` and `ObjectQLPublicBlockComponentSchema`), where it refused the key by name. On the tolerant face (`safeValidateSchema`) the key was already accepted, unjudged; it is now judged, so a value the spec refuses is refused there too.
+
+**What it was.** `responsiveStyles` is the ADR-0065 per-breakpoint style map that `SchemaRenderer` compiles to CSS scoped to the node. The spec declares it on every page component, the objectstack showcase writes it on public-block nodes (`element:text`, `element:button`, `object-metric`, `page:card`) and objectstack's UI skill teaches it. No arm here declared it, so a spec-valid node failed the strict face with `unrecognized_keys`, and the tolerant face kept any value it was given: `responsiveStyles: 7`, or a breakpoint the spec does not have (`md`), parsed clean and styled nothing.
+
+**What changed, in observable terms.**
+
+- Each public-block arm declares `responsiveStyles` as the spec's `ResponsiveStylesSchema`, by reference, so its breakpoints (`large`, `medium`, `small`, `xsmall`), its strictness and its own unknown-breakpoint message come from the spec. All 30 arms share one declaration.
+- A node such as `{ "type": "page:section", "responsiveStyles": { "large": { "padding": "var(--space-6)" }, "small": { "padding": "var(--space-4)" } } }` parses on both faces, and the map comes back unchanged.
+- A value the spec refuses (a `md` breakpoint, a number instead of a map, a style value that is neither a string nor a number) is refused on both faces at `responsiveStyles`, with the same issue the spec reports. On the tolerant face this is a narrowing: such a value used to pass unjudged, and `SchemaRenderer` would not have applied it.
+- Nothing else widens. `BaseSchema` does not declare `responsiveStyles`, so the strict face still refuses it on the other arms. The other node-level keys the spec declares (`events`, `aria`, `visibility`, `responsive`, and `dataSource` outside the arms that already read it) stay undeclared and are still refused by name on the strict face.
@@ -113,6 +113,8 @@ import {
   // objectui#10872 batch 2 — `element:number`'s row, and the node's `dataSource`.
   ElementNumberPropsSchema as SpecElementNumberPropsSchema,
   ElementDataSourceSchema as SpecElementDataSourceSchema,
+  // objectui#10872 batch 8 — the node-level `responsiveStyles` every public-block arm declares.
+  ResponsiveStylesSchema as SpecResponsiveStylesSchema,
   objectNavTargetExclusivity,
   checkListViewCalendarVisualization,
   checkPageSourceCompleteness,
@@ -297,6 +299,13 @@ const IMPORTED: Array<readonly [string, z.ZodType]> = [
   // like every other one.
   ['ElementNumberPropsSchema', SpecElementNumberPropsSchema],
   ['ElementDataSourceSchema', SpecElementDataSourceSchema],
+  // objectui#10872 batch 8: every public-block arm declares the node-level
+  // `responsiveStyles` as the spec's `ResponsiveStylesSchema` (one shared
+  // `PUBLIC_BLOCK_ENVELOPE`), crossed through this boundary like every other
+  // read. It carries no default and reaches no `z.lazy`, so the strip is the
+  // identity function — the row is here because the census below requires
+  // every imported symbol to be measured, not because the strip does work.
+  ['ResponsiveStylesSchema', SpecResponsiveStylesSchema],
   // objectui#11070: `FormFieldSchema` reads spec `FieldSchema` members by
   // reference (the field metadata a hand-authored form writes on the entry
   // itself; `FormFieldSchema.shape` lists them), and `multiple` carries the
 
@@ -0,0 +1,257 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+/**
+ * Every ADR-0080 public-block arm declares the node-level `responsiveStyles`
+ * that `@objectstack/spec`'s `PageComponentSchema` declares, by reference
+ * (objectui#10872, batch 8 — the envelope-key batch).
+ *
+ * ## The defect these pin
+ *
+ * `PageComponentSchema` declares six node-level keys beside `properties`:
+ * `events`, `responsiveStyles`, `dataSource`, `aria`, `visibility` and the
+ * retired `responsive`. `responsiveStyles` is the one with a producer — the
+ * objectstack showcase writes it on public-block nodes, objectstack's UI skill
+ * teaches it, and `SchemaRenderer` compiles it to id-scoped CSS on every node
+ * (ADR-0065). No arm here declared it, so:
+ *
+ *   - the STRICT authoring face refused a spec-valid node by name
+ *     (`unrecognized_keys`), and
+ *   - the TOLERANT face passed it unjudged — `responsiveStyles: 7`, or a
+ *     breakpoint the spec does not have (`md`), parsed clean and then styled
+ *     nothing.
+ *
+ * ## What is and is not widened
+ *
+ * The key is declared on the public-block arms only — `PublicBlockComponentSchema`
+ * and `ObjectQLPublicBlockComponentSchema` — through ONE shared fragment, and
+ * NOT on `BaseSchema`, which would widen every arm in `AnyComponentSchema`
+ * (a different accept-set change, not granted by the batch's ruling). The other
+ * five envelope keys stay undeclared: they have no producer. The pins below
+ * hold both boundaries.
+ *
+ * Every verdict is read against the INSTALLED spec at run time, not against
+ * transcribed text: the arm's member is compared with the spec's own
+ * `PageComponentSchema.responsiveStyles`, and a refusal's message is compared
+ * with the one the spec itself emits for the same node.
+ */
+
+import { describe, expect, it } from 'vitest';
+import type { z } from 'zod';
+import {
+  PageComponentSchema,
+  ResponsiveStylesSchema as SpecResponsiveStylesSchema,
+  type ResponsiveStyles as SpecResponsiveStyles,
+} from '@objectstack/spec/ui';
+
+import {
+  BaseSchema,
+  ObjectMetricBlockSchema,
+  ObjectQLPublicBlockComponentSchema,
+  PageSectionBlockSchema,
+  PublicBlockComponentSchema,
+  StrictAnyComponentSchema,
+  safeValidateSchema,
+} from '../zod/index.zod.js';
+
+/* ── Type-level pin (compiled by `tsc -p tsconfig.test.json`) ─────────────── */
+
+type Equal<A, B> =
+  (<T>() => T extends A ? 1 : 2) extends (<T>() => T extends B ? 1 : 2) ? true : false;
+type Expect<T extends true> = T;
+type ShapeOf<M> = M extends { shape: infer S } ? S : never;
+type InputOf<T> = T extends z.ZodType ? z.input<T> : never;
+
+/** The member accepts exactly the spec's published type, absent allowed — on a bag arm and an ObjectQL arm. */
+export type assertionResponsiveStylesIsTheSpecType = [
+  Expect<Equal<InputOf<ShapeOf<typeof PageSectionBlockSchema>['responsiveStyles']>, SpecResponsiveStyles | undefined>>,
+  Expect<Equal<InputOf<ShapeOf<typeof ObjectMetricBlockSchema>['responsiveStyles']>, SpecResponsiveStyles | undefined>>,
+];
+/** The helper can FAIL — a narrower map is not the spec's type. */
+export type assertionEqualCanFail = Expect<
+  Equal<Equal<{ large?: Record<string, string> } | undefined, SpecResponsiveStyles | undefined>, false>
+>;
+
+/* ── The population, read off the two unions ─────────────────────────────── */
+
+type Arm = z.ZodObject;
+const optionsOf = (union: unknown): Arm[] => (union as { options: Arm[] }).options;
+const literalOf = (arm: Arm): string => (arm.shape.type as z.ZodLiteral).value as string;
+
+/** Every public-block arm — the population this batch widens, and no other. */
+const ARMS: readonly Arm[] = [
+  ...optionsOf(PublicBlockComponentSchema),
+  ...optionsOf(ObjectQLPublicBlockComponentSchema),
+];
+const TYPES = ARMS.map(literalOf);
+
+/**
+ * The arms that already declared `dataSource` before this batch (objectui#10872
+ * batch 2: `element:number`; objectui#10859 batches 2 and 3: the three ObjectQL
+ * blocks). NAMED rather than read off the shapes, so an arm that gains
+ * `dataSource` later reddens the control below instead of joining it silently.
+ */
+const DECLARES_DATA_SOURCE: ReadonlySet<string> = new Set([
+  'element:number',
+  'object-metric',
+  'object-master-detail-form',
+  'object-timeline',
+]);
+
+/** The five envelope keys the spec declares and this batch leaves undeclared. */
+const UNDECLARED_ENVELOPE = ['events', 'dataSource', 'aria', 'visibility', 'responsive'] as const;
+
+/** A spec-valid map: the unconditional base and two `max-width` overrides. */
+const VALID_STYLES = {
+  large: { padding: 'var(--space-6)', gap: '16px' },
+  small: { padding: 'var(--space-4)' },
+  xsmall: { display: 'none', order: 2 },
+} as const;
+
+/** The two bag nodes the order names: a `page:` container and an ObjectQL block. */
+const BAG_NODES = [
+  {
+    type: 'page:section',
+    id: 'kpis',
+    properties: { children: [{ type: 'element:text', properties: { content: 'Revenue' } }] },
+    responsiveStyles: VALID_STYLES,
+  },
+  {
+    type: 'object-metric',
+    id: 'open-deals',
+    properties: { objectName: 'deal', label: 'Open deals' },
+    responsiveStyles: { large: { minWidth: '0' }, small: { gridColumn: 'span 2' } },
+  },
+] as const;
+
+/** Values the spec refuses: a breakpoint it does not have, a non-object, a non-CSS value. */
+const INVALID_STYLES: ReadonlyArray<readonly [string, unknown]> = [
+  ['a breakpoint the spec does not declare (`md`)', { md: { padding: '8px' } }],
+  ['a number instead of a map', 7],
+  ['a style value that is neither string nor number', { large: { padding: true } }],
+];
+
+type Result = { success: boolean; error?: { issues: z.core.$ZodIssue[] } };
+
+/** Every issue as `{ code, path, message }`, the `code` and `path` the stable part. */
+const issuesOf = (result: Result) =>
+  result.success
+    ? []
+    : result.error!.issues.map((issue) => ({ code: issue.code, path: issue.path.join('.'), message: issue.message }));
+
+/** The keys an `unrecognized_keys` issue names, at any depth of a union. */
+function refusedKeys(result: Result): string[] {
+  if (result.success) return [];
+  const collect = (issues: readonly z.core.$ZodIssue[]): string[] =>
+    issues.flatMap((issue) => {
+      if (issue.code === 'unrecognized_keys') return issue.keys;
+      if (issue.code === 'invalid_union') return issue.errors.flatMap((arm) => collect(arm));
+      return [];
+    });
+  return collect(result.error!.issues);
+}
+
+describe('the population (objectui#10872 batch 8)', () => {
+  it('reads both public-block unions, and every arm is a distinct block', () => {
+    // Non-vacuity: the pins below iterate this list.
+    expect(optionsOf(PublicBlockComponentSchema).length).toBeGreaterThan(20);
+    expect(optionsOf(ObjectQLPublicBlockComponentSchema).length).toBeGreaterThan(2);
+    expect(new Set(TYPES).size).toBe(TYPES.length);
+    // Every named `dataSource` arm is in the population, so the set is not stale.
+    for (const type of DECLARES_DATA_SOURCE) expect(TYPES).toContain(type);
+  });
+
+  it('the spec still declares `responsiveStyles` on its page component, as `ResponsiveStylesSchema` (lit control)', () => {
+    const spec = PageComponentSchema.safeParse({ type: 'page:section', responsiveStyles: VALID_STYLES });
+    expect(spec.success).toBe(true);
+    expect(SpecResponsiveStylesSchema.safeParse(VALID_STYLES).success).toBe(true);
+  });
+});
+
+describe('`responsiveStyles` is declared on every public-block arm, by reference (objectui#10872 batch 8)', () => {
+  it('every arm carries the member, and it is ONE shared object — no per-arm copy', () => {
+    const members = ARMS.map((arm) => arm.shape.responsiveStyles);
+    expect(members.filter((member) => member === undefined).length, 'an arm without the member').toBe(0);
+    expect(new Set(members).size).toBe(1);
+  });
+
+  it('the member is the spec\'s own map: the same breakpoints, the same strictness', () => {
+    const member = (ARMS[0].shape.responsiveStyles as z.ZodOptional).unwrap() as z.ZodObject;
+    const spec = SpecResponsiveStylesSchema as unknown as z.ZodObject;
+    expect(Object.keys(member.shape).sort()).toEqual(Object.keys(spec.shape).sort());
+    // Each breakpoint's value schema is the spec's own object, not a restatement.
+    for (const key of Object.keys(spec.shape)) expect(member.shape[key]).toBe(spec.shape[key]);
+  });
+
+  it('`BaseSchema` is NOT widened — the declaration is the public blocks\' alone', () => {
+    expect(Object.keys(BaseSchema.shape)).not.toContain('responsiveStyles');
+    // Control: a non-public-block node is still refused by name on the strict
+    // face, so the accept-set change is exactly the arms above. This is the
+    // boundary of this batch, not a ruling that it must stay.
+    const flex = { type: 'flex', responsiveStyles: VALID_STYLES };
+    expect(refusedKeys(StrictAnyComponentSchema.safeParse(flex))).toEqual(['responsiveStyles']);
+  });
+});
+
+describe('a valid `responsiveStyles` is accepted on BOTH faces (objectui#10872 batch 8)', () => {
+  it.each(BAG_NODES.map((node) => [node.type, node] as const))(
+    '%s: a bag node with `responsiveStyles` parses on both faces, and the map survives unchanged',
+    (_type, node) => {
+      // Lit control: the spec's own page component accepts the same node.
+      expect(PageComponentSchema.safeParse(node).success).toBe(true);
+      const tolerant = safeValidateSchema(node);
+      expect(issuesOf(tolerant)).toEqual([]);
+      expect((tolerant.data as { responsiveStyles?: unknown }).responsiveStyles).toEqual(node.responsiveStyles);
+      const strict = StrictAnyComponentSchema.safeParse(node);
+      expect(issuesOf(strict)).toEqual([]);
+      expect((strict.data as { responsiveStyles?: unknown }).responsiveStyles).toEqual(node.responsiveStyles);
+    },
+  );
+
+  it.each(TYPES)('%s: a node carrying only `responsiveStyles` is accepted on the strict face', (type) => {
+    const node = { type, responsiveStyles: VALID_STYLES };
+    expect(issuesOf(StrictAnyComponentSchema.safeParse(node))).toEqual([]);
+    expect(issuesOf(safeValidateSchema(node))).toEqual([]);
+  });
+});
+
+describe('an invalid `responsiveStyles` is refused on BOTH faces, with the spec\'s own issue (objectui#10872 batch 8)', () => {
+  const cases = BAG_NODES.flatMap((node) =>
+    INVALID_STYLES.map(([why, value]) => [node.type, why, { ...node, responsiveStyles: value }] as const),
+  );
+
+  it.each(cases)('%s — %s', (_type, _why, node) => {
+    // The spec's verdict on the same node is the expected one, read at run time.
+    const spec = issuesOf(PageComponentSchema.safeParse(node));
+    expect(spec.length, 'lit control: the spec refuses this node').toBeGreaterThan(0);
+    expect(spec.every((issue) => issue.path.startsWith('responsiveStyles'))).toBe(true);
+    // Both faces refuse it at the same path, with the same code and message.
+    expect(issuesOf(safeValidateSchema(node))).toEqual(spec);
+    expect(issuesOf(StrictAnyComponentSchema.safeParse(node))).toEqual(spec);
+  });
+});
+
+describe('the other five envelope keys stay undeclared (objectui#10872 batch 8)', () => {
+  it('no arm gained any of them — `dataSource` only where an earlier batch declared it', () => {
+    const declared = ARMS.flatMap((arm) =>
+      UNDECLARED_ENVELOPE.filter((key) => key in arm.shape).map((key) => `${literalOf(arm)}#${key}`),
+    ).sort();
+    expect(declared).toEqual([...DECLARES_DATA_SOURCE].map((type) => `${type}#dataSource`).sort());
+  });
+
+  const cases = TYPES.flatMap((type) =>
+    UNDECLARED_ENVELOPE.filter((key) => !(key === 'dataSource' && DECLARES_DATA_SOURCE.has(type))).map(
+      (key) => [type, key] as const,
+    ),
+  );
+
+  it.each(cases)('%s: a node-level `%s` is still refused on the strict face, by name', (type, key) => {
+    const node = { type, [key]: { x: 1 } };
+    expect(refusedKeys(StrictAnyComponentSchema.safeParse(node))).toEqual([key]);
+  });
+});
@@ -4333,6 +4333,14 @@ const EXCLUSIONS: Readonly<Record<string, string>> = {
     "spec-owned BY REFERENCE — `BaseSchema` + the `action:menu` literal + `properties`, which IS `ComponentPropsMap['action:menu']`, + the objectui#9256 `body` / `children` refusals (objectui#10872 batch 5; its renderer reads neither channel); no TS declaration in this package restates the node",
   'public-blocks.zod.ts#PublicBlockComponentSchema':
     "a union OVER the public-block arms, not an object of its own — its members are accounted for individually above",
+  // objectui#10872 batch 8 — the node-level envelope every public-block arm
+  // above (and the three ObjectQL public-block arms) spreads beside
+  // `properties`: today `responsiveStyles` alone, the spec's
+  // `ResponsiveStylesSchema` by reference. The arm reasons above describe the
+  // members each arm adds of its own; this fragment is shared by all of them.
+  // Pinned in `./public-block-responsive-styles-10872.test.ts`.
+  'public-blocks.zod.ts#PUBLIC_BLOCK_ENVELOPE':
+    "a shape FRAGMENT, not a schema and not a mirror — `{ responsiveStyles }`, the spec's `ResponsiveStylesSchema` by reference (the schema `PageComponentSchema.responsiveStyles` declares), spread into every public-block arm so the one declaration is shared; no TS declaration in this package restates it",
   // objectui#10919 — the `cloud:plan-status` widget's arm, declared locally from
   // the widget's read points: `@objectstack/spec` has no row for a `cloud:`
   // widget, and the widget's props type lives beside it in `@object-ui/app-shell`,
 
@@ -240,6 +240,7 @@ The ADR-0080 public blocks `object-metric`, `object-master-detail-form` and `obj
 
 ### ADR-0080 Public Blocks (27)
 Each arm's `properties` is the block's `@objectstack/spec` `ComponentPropsMap` row, by reference. `ElementNumberBlockSchema` also declares the spec's `dataSource` binding, and mirrors the spec gate's one waiver: its bag may omit `object` when `dataSource.object` names the object.
+Every arm here, and each of the three ObjectQL public blocks above, declares the node-level `responsiveStyles` (ADR-0065 per-breakpoint style maps, which `SchemaRenderer` compiles to scoped CSS) as the spec's `ResponsiveStylesSchema`, by reference, from one shared fragment, `PUBLIC_BLOCK_ENVELOPE` (objectui#10872 batch 8). The other node-level keys the spec's `PageComponentSchema` declares (`events`, `aria`, `visibility`, `responsive`, and `dataSource` outside the arms that read it) stay undeclared, so the strict face refuses them by name.
 Every arm except the four `page:` containers (`page:card`, `page:section`, `page:footer`, `page:sidebar`) refuses `children` and `body` by name, because its renderer reads neither content channel (objectui#9256; the last six below since objectui#10872 batch 5). The four containers do render a child list, and its home is `properties.children`, the member their spec row declares; they refuse the node-level `children` and `body` with a message naming it, as `@objectstack/spec`'s `PageComponentSchema` refuses a node-level `children` (objectui#10872 batch 6). Two carve-outs: `record:alert` refuses `children` with its own message, while its `body` is the message text and belongs in `properties`, so a flat `body` is refused with a pointer to `properties.body` rather than to `children` (objectui#10872); and `page:tabs` / `page:accordion` refuse the node's own `children` while each item's `children` in `items` stays live.
 - `PageHeaderBlockSchema`, `PageTabsBlockSchema`, `PageCardBlockSchema`, `PageAccordionBlockSchema`
 - `PageSectionBlockSchema`, `PageFooterBlockSchema`, `PageSidebarBlockSchema`