diff --git a/.changeset/11070-strict-face-read-keys.md b/.changeset/11070-strict-face-read-keys.md
new file mode 100644
index 0000000000..e6acc55e51
--- /dev/null
+++ b/.changeset/11070-strict-face-read-keys.md
@@ -0,0 +1,13 @@
+---
+'@object-ui/types': minor
+---
+
+The strict authoring face accepts keys a registered renderer reads, which it used to refuse as undeclared (objectui#11070). Each key below is now declared on the TypeScript face and on its zod mirror, so `StrictAnyComponentSchema` accepts it and `objectui validate` on that face no longer tells an author to delete a key that works.
+
+- **`form.showSubmit`** (`FormSchema`, a boolean, default `true`). The `form` renderer draws its submit button only while it holds, so `false` renders the fields with no submit button.
+- **`form.fields[]`** (`FormField` / `FormFieldSchema`): `multiple`, `rows`, `accept`, `dimensions`, `reference`, `min`, `max`, `minLength`, `maxLength` and `pattern`. A hand-authored form has no object schema behind it, so the renderer hands each field widget the field entry itself as its metadata carrier, and the built-in `input` / `textarea` branches spread the entry onto the native control. These are the keys that path reads: `multiple` (the `file`, `image`, `lookup` and `user` widgets), `rows` (the `<textarea>` and the `markdown` widget), `accept` (the `file` widget's picker), `dimensions` (the `vector` widget), `reference` (the `lookup` and `user` widgets' target object), `min` / `max` (the `number` widget and the native control), `minLength` / `maxLength` (the native control; `maxLength` is also the `textarea` counter's ceiling) and `pattern` (the native control). All but `pattern` are `@objectstack/spec`'s `FieldSchema` members by reference, with the spec's own value rules; `pattern` is a string, since JSON has no `RegExp`.
+- **`dataSource` on `object-grid`, `object-form`, `object-kanban`, `list-view`, `object-gantt`, `object-map` and `object-calendar`**: `@objectstack/spec`'s per-element binding `ElementDataSourceSchema`, by reference (`{ object, view?, filter?, sort?, limit? }`). It is metadata, not the data-source adapter: `SchemaRenderer` strips it from the props it spreads, and each block's gate-wrapped registration reads it off the node through `ElementDataSourceGate`. The registry already published it as an authored input on these blocks (objectui#6678).
+
+**What now refuses that did not.** A declared key is judged by its declared type on BOTH faces. On `FormFieldSchema`, which strips undeclared keys, a wrong-typed value for one of the ten field keys used to be dropped silently and is now refused (for example `accept: "application/pdf"`, since the spec types `accept` as an array, or `rows: 0`). On the passthrough nodes, a wrong-typed `showSubmit` or `dataSource` used to be kept unjudged and is now refused. That includes a `dataSource` holding the host's adapter object or `null`, which is what the react-page wrapper writes on the nodes it builds in memory: those nodes are rendered, not validated, and `ElementDataSourceGate` ignores a value that is not a binding, so their rendering does not change. An `object-view`'s `table` slot now refuses `dataSource` by name, like the other record sources the view owns (`data`, `staticData`, `bind`), because the view does not hand it to its grid; its `form` slot carries `dataSource` as it carries `bind` and `data`. On the TypeScript face these keys are now typed members rather than the `[key: string]: any` index signature, so a wrong-typed value is a compile error. Measured over the schema catalog, the docs JSON fences and the apps' authored documents, at this change's base (`88fbd793d`) and on this change: the tolerant face refused the same documents both times.
+
+**What is deliberately NOT declared.** The legacy spellings `reference_to` and `min_length` stay refused on the strict face; write the spec's `reference` and `minLength`. `return_type`, `summary_type`, the grid field's `columns`, `object-chart`'s `dataSource` and the dashboard widget keys stay refused until objectui#11070 settles them.
diff --git a/content/docs/api/schema-reference.md b/content/docs/api/schema-reference.md
index deefb0606c..1b0655a4f3 100644
--- a/content/docs/api/schema-reference.md
+++ b/content/docs/api/schema-reference.md
@@ -118,7 +118,7 @@ Top-level page container. Defines a full page with optional regions (header, sid
   "regions": [
     {
       "name": "header",
-      "children": [{ "type": "text", "content": "Welcome back" }]
+      "components": [{ "type": "text", "content": "Welcome back" }]
     }
   ],
   "children": [
diff --git a/content/docs/guide/objectos-integration.mdx b/content/docs/guide/objectos-integration.mdx
index 2b8bc93fa3..6c160dbbc7 100644
--- a/content/docs/guide/objectos-integration.mdx
+++ b/content/docs/guide/objectos-integration.mdx
@@ -265,11 +265,14 @@ const dataSource = new ObjectStackAdapter({
   baseUrl: 'http://localhost:3000/api'
 });
 
-// ObjectQL queries are automatically handled
+// The adapter is injected ONCE, at the renderer boundary —
+// `<SchemaRendererProvider dataSource={dataSource}>` from `@object-ui/react` —
+// never as a schema key. A node's `dataSource` is the per-element BINDING
+// (`{ object, view?, filter?, sort?, limit? }`), not the adapter, and
+// `SchemaRenderer` strips it from the props it spreads.
 const schema: ObjectGridSchema = {
   type: 'object-grid',
   objectName: 'contact',
-  dataSource,
   // Grid filter, JSON-rules form: an array of `{ field, operator, value }`
   // entries, AND-ed together. `operator` takes the canonical view-filter
   // vocabulary (`equals`, `greater_than_or_equal`, ...).
diff --git a/content/docs/guide/schema-playground.md b/content/docs/guide/schema-playground.md
index 1c6c02b156..30fa496f09 100644
--- a/content/docs/guide/schema-playground.md
+++ b/content/docs/guide/schema-playground.md
@@ -143,10 +143,7 @@ A complete form with validation, driven entirely by schema:
       "label": "Email",
       "required": true,
       "placeholder": "jane@example.com",
-      "validation": {
-        "pattern": "^[^@]+@[^@]+\\.[^@]+$",
-        "message": "Enter a valid email address"
-      }
+      "pattern": "^[^@]+@[^@]+\\.[^@]+$"
     },
     {
       "name": "role",
diff --git a/content/docs/plugins/plugin-detail.mdx b/content/docs/plugins/plugin-detail.mdx
index 78472d7992..9d1681b538 100644
--- a/content/docs/plugins/plugin-detail.mdx
+++ b/content/docs/plugins/plugin-detail.mdx
@@ -189,15 +189,17 @@ its own feed. Drop it anywhere inside a record page:
 ```json
 {
   "type": "page:tabs",
-  "items": [
-    {
-      "label": "Activity",
-      "value": "activity",
-      "children": [
-        { "type": "record:activity", "limit": 20, "showCompleted": false }
-      ]
-    }
-  ]
+  "properties": {
+    "items": [
+      {
+        "label": "Activity",
+        "value": "activity",
+        "children": [
+          { "type": "record:activity", "limit": 20, "showCompleted": false }
+        ]
+      }
+    ]
+  }
 }
 ```
 
diff --git a/content/docs/utilities/data-objectstack.mdx b/content/docs/utilities/data-objectstack.mdx
index ccee1a2405..10fa77d5fb 100644
--- a/content/docs/utilities/data-objectstack.mdx
+++ b/content/docs/utilities/data-objectstack.mdx
@@ -338,7 +338,10 @@ its own:
 ```json
 {
   "type": "object-kanban",
-  "dataSource": { "object": "task", "filter": { "project": "acme" } }
+  "dataSource": {
+    "object": "task",
+    "filter": [{ "field": "project", "operator": "equals", "value": "acme" }]
+  }
 }
 ```
 
diff --git a/examples/schema-catalog/src/schemas/fields-auto-number/date-based-ticket-id.json b/examples/schema-catalog/src/schemas/fields-auto-number/date-based-ticket-id.json
index 33b170aec2..640ae34393 100644
--- a/examples/schema-catalog/src/schemas/fields-auto-number/date-based-ticket-id.json
+++ b/examples/schema-catalog/src/schemas/fields-auto-number/date-based-ticket-id.json
@@ -10,7 +10,6 @@
       "name": "ticket_id",
       "label": "Ticket ID",
       "type": "auto_number",
-      "format": "TKT-{YYYY}{MM}-{0000}",
       "readonly": true
     }
   ]
diff --git a/examples/schema-catalog/src/schemas/fields-auto-number/invoice-number-format.json b/examples/schema-catalog/src/schemas/fields-auto-number/invoice-number-format.json
index 7c0357182f..76b57c8d05 100644
--- a/examples/schema-catalog/src/schemas/fields-auto-number/invoice-number-format.json
+++ b/examples/schema-catalog/src/schemas/fields-auto-number/invoice-number-format.json
@@ -10,7 +10,6 @@
       "name": "invoice_id",
       "label": "Invoice ID",
       "type": "auto_number",
-      "format": "INV-{0000}",
       "readonly": true
     }
   ]
diff --git a/examples/schema-catalog/src/schemas/fields-lookup/basic-lookup.json b/examples/schema-catalog/src/schemas/fields-lookup/basic-lookup.json
index a4a7b11b9b..715cf3247a 100644
--- a/examples/schema-catalog/src/schemas/fields-lookup/basic-lookup.json
+++ b/examples/schema-catalog/src/schemas/fields-lookup/basic-lookup.json
@@ -8,7 +8,7 @@
       "label": "Assigned To",
       "type": "lookup",
       "placeholder": "Select user...",
-      "reference_to": "users",
+      "reference": "users",
       "options": [
         {
           "label": "John Doe",
diff --git a/examples/schema-catalog/src/schemas/fields-lookup/multi-select-lookup.json b/examples/schema-catalog/src/schemas/fields-lookup/multi-select-lookup.json
index 3324731693..cc6493eb3e 100644
--- a/examples/schema-catalog/src/schemas/fields-lookup/multi-select-lookup.json
+++ b/examples/schema-catalog/src/schemas/fields-lookup/multi-select-lookup.json
@@ -8,7 +8,7 @@
       "label": "Team Members",
       "type": "lookup",
       "placeholder": "Select team members...",
-      "reference_to": "users",
+      "reference": "users",
       "multiple": true,
       "options": [
         {
diff --git a/examples/schema-catalog/src/schemas/fields-password/with-minimum-length.json b/examples/schema-catalog/src/schemas/fields-password/with-minimum-length.json
index 742f340042..49ed720240 100644
--- a/examples/schema-catalog/src/schemas/fields-password/with-minimum-length.json
+++ b/examples/schema-catalog/src/schemas/fields-password/with-minimum-length.json
@@ -9,7 +9,7 @@
       "type": "password",
       "placeholder": "At least 8 characters",
       "required": true,
-      "min_length": 8
+      "minLength": 8
     }
   ]
 }
diff --git a/packages/app-shell/src/views/ObjectView.relayRungCensus-7559.test.ts b/packages/app-shell/src/views/ObjectView.relayRungCensus-7559.test.ts
index 2856c76068..1ed9854984 100644
--- a/packages/app-shell/src/views/ObjectView.relayRungCensus-7559.test.ts
+++ b/packages/app-shell/src/views/ObjectView.relayRungCensus-7559.test.ts
@@ -475,6 +475,7 @@ const ABSENCES: Record<string, Absence> = {
   performance: { kind: 'unread', reason: 'Imported from the spec by reference; no objectui renderer reads it.' },
   pageName: { kind: 'unread', reason: 'Page-context key with no reader on the list path.' },
   tabs: { kind: 'unread', reason: "Spec view-tab list. ListView has no reader — the object page's tab bar is `ViewTabBar`, driven by `buildViewTabs`, and the `tabs` readers in the tree belong to `plugin-detail`'s DetailView." },
+  dataSource: { kind: 'unread', reason: "The spec's per-element binding (declared on the list-view arm by objectui#11070). `ListView` has no read of `schema.dataSource`: the binding is resolved one layer up, by the registered `list-view` renderer `ListViewBlock` through `ElementDataSourceGate`, and `renderListView` bypasses that layer. It renders `ListView` directly with `schema={fullSchema}` and takes the ADAPTER as its separate `dataSource` argument (`ds`), not off the node." },
 
   // ── Authored on the NODE, resolved by the host ────────────────────────────
   operations: { kind: 'node-authored', reason: "Legacy CRUD affordance authored on the object-view node (`examples/.../object-view-record-surface.json`), not on a view record; the host resolves it upstream (`schema.operations || schema.table?.operations || …`). ListView does read `schema.operations?.export`, but what would feed it here is the NODE's value, and forwarding it is the caller's composition to make — objectui#5097's surface, not a per-view rung." },
diff --git a/packages/types/src/__tests__/form-field-zod-coverage.test.ts b/packages/types/src/__tests__/form-field-zod-coverage.test.ts
index 1981d05bd0..e387f3d6bf 100644
--- a/packages/types/src/__tests__/form-field-zod-coverage.test.ts
+++ b/packages/types/src/__tests__/form-field-zod-coverage.test.ts
@@ -77,6 +77,19 @@ const DECLARED_KEYS = [
   'span',
   // objectui#6236 — the section grouping claim (section-divider rows only).
   'fields',
+  // objectui#11070 — field metadata a hand-authored form writes on the entry
+  // itself, read off it by the field widgets and the built-in branches. All
+  // but `pattern` are the spec's `FieldSchema` members by reference.
+  'multiple',
+  'rows',
+  'accept',
+  'dimensions',
+  'reference',
+  'min',
+  'max',
+  'minLength',
+  'maxLength',
+  'pattern',
 ];
 
 describe('FormFieldSchema covers the FormField contract', () => {
diff --git a/packages/types/src/__tests__/imported-defaults-8317.test.ts b/packages/types/src/__tests__/imported-defaults-8317.test.ts
index 884180b00f..8ec5da6387 100644
--- a/packages/types/src/__tests__/imported-defaults-8317.test.ts
+++ b/packages/types/src/__tests__/imported-defaults-8317.test.ts
@@ -111,7 +111,7 @@ import {
   checkDashboardWidgetStageOrder,
   checkDashboardWidgetMetricMeasureArity,
 } from '@objectstack/spec/ui';
-import { SelectOptionSchema as SpecSelectOptionSchema } from '@objectstack/spec/data';
+import { FieldSchema as SpecFieldSchema, SelectOptionSchema as SpecSelectOptionSchema } from '@objectstack/spec/data';
 import { stripImportedDefaults } from '../zod/imported-defaults.js';
 
 const HERE = dirname(fileURLToPath(import.meta.url));
@@ -270,6 +270,11 @@ const IMPORTED: Array<readonly [string, z.ZodType]> = [
   // like every other one.
   ['ElementNumberPropsSchema', SpecElementNumberPropsSchema],
   ['ElementDataSourceSchema', SpecElementDataSourceSchema],
+  // objectui#11070: `FormFieldSchema` reads nine of the spec's `FieldSchema`
+  // members by reference (the field metadata a hand-authored form writes on
+  // the entry itself), and `multiple` carries the spec's `.default(false)` —
+  // exactly what this boundary exists to keep out of a parse output.
+  ['FieldSchema', SpecFieldSchema],
 ] as const;
 
 /** The subset that actually carries an imported default — where the strip does work. */
@@ -345,14 +350,15 @@ describe('the import boundary strips every imported default (objectui#8317)', ()
     it('the walker docblock\'s `lazy` count is re-derived, not quoted', () => {
       // The `lazy` arm is the one place the identity property cannot hold: it
       // must rebuild without forcing the getter, so a clean subtree behind a
-      // `z.lazy` is rebuilt anyway. The module's docblock names FOUR such
-      // nodes (the fourth, `ViewSchema`'s form-field group, since objectui#7928)
+      // `z.lazy` is rebuilt anyway. The module's docblock names FIVE such
+      // nodes (the fourth, `ViewSchema`'s form-field group, since objectui#7928;
+      // the fifth, under `FieldSchema.relatedListFilter`, since objectui#11070)
       // and says the exception costs nothing extra for every owner but the
       // ones `REBUILT_CLEAN` names (objectui#10872 batch 2), because each
       // other owner sits inside a schema that is being rebuilt regardless.
       // Both halves are measured here, so a spec bump or an import that moves
       // either one is red rather than quietly making the docblock false.
-      expect(walk(IMPORTED.map(([, s]) => s)).lazies).toBe(4);
+      expect(walk(IMPORTED.map(([, s]) => s)).lazies).toBe(5);
       const lazyOwners = IMPORTED.filter(([, s]) => walk([s]).lazies > 0);
       expect(lazyOwners.length, 'no schema owns a lazy — the count above found them elsewhere').toBeGreaterThan(0);
       // The clean owners are exactly the named set: rebuilt (so NOT the spec's
diff --git a/packages/types/src/__tests__/list-view-spec-parity.test.ts b/packages/types/src/__tests__/list-view-spec-parity.test.ts
index 7daddf5183..f8ec7aff32 100644
--- a/packages/types/src/__tests__/list-view-spec-parity.test.ts
+++ b/packages/types/src/__tests__/list-view-spec-parity.test.ts
@@ -132,6 +132,21 @@ const HANDLER_KEY_REFUSALS = new Set<string>([
   'onPageSizeChange',
 ]);
 
+/**
+ * A FOURTH category (objectui#11070): spec members that belong to the page
+ * COMPONENT envelope rather than to the list view it carries.
+ *
+ * `dataSource` is `@objectstack/spec`'s `PageComponentSchema.dataSource` — the
+ * per-element binding every page component may carry — so the spec's
+ * `ListViewSchema` (a view config) has no such member, and this arm, being
+ * the `list-view` NODE, declares it. Neither branch of the #2231 decision
+ * fits: it is not objectui-only, and it cannot be promoted into the spec's
+ * view schema because the spec already owns it one level up. It arrives by
+ * reference to the spec's `ElementDataSourceSchema`; the test below checks
+ * that it behaves as that binding, so this set cannot park a local field.
+ */
+const PAGE_COMPONENT_ENVELOPE = new Set<string>(['dataSource']);
+
 describe('ListView spec parity (#2231 drift guard)', () => {
   it('covers every @objectstack/spec ListView field (spec cannot grow a field objectui ignores)', () => {
     // Fails when the spec adds a field that objectui neither imports nor envelope-owns —
@@ -154,11 +169,25 @@ describe('ListView spec parity (#2231 drift guard)', () => {
         !specShape[k] &&
         !ENVELOPE.has(k) &&
         !SANCTIONED_LOCAL.has(k) &&
-        !HANDLER_KEY_REFUSALS.has(k),
+        !HANDLER_KEY_REFUSALS.has(k) &&
+        !PAGE_COMPONENT_ENVELOPE.has(k),
     );
     expect(rogue).toEqual([]);
   });
 
+  it('every PAGE_COMPONENT_ENVELOPE member is the spec binding — the set cannot hide a local field (objectui#11070)', () => {
+    const node = (extra: Record<string, unknown>) => ({ type: 'list-view', objectName: 'accounts', ...extra });
+    for (const key of PAGE_COMPONENT_ENVELOPE) {
+      expect(ouiKeys.has(key), `${key} is listed but not declared on the arm`).toBe(true);
+      // The spec's binding: a named object with the binding's own keys parses…
+      expect(OuiListViewSchema.safeParse(node({ [key]: { object: 'account', view: 'hot', limit: 10 } })).success).toBe(true);
+      // …a binding that names no object does not (the spec requires `object`)…
+      expect(OuiListViewSchema.safeParse(node({ [key]: { view: 'hot' } })).success).toBe(false);
+      // …and neither does an adapter-shaped value, which is not metadata at all.
+      expect(OuiListViewSchema.safeParse(node({ [key]: 'objectstack' })).success).toBe(false);
+    }
+  });
+
   it('every HANDLER_KEY_REFUSALS member really refuses — the set cannot hide an authorable field', () => {
     const node = (extra: Record<string, unknown>) => ({
       type: 'list-view',
diff --git a/packages/types/src/__tests__/object-kanban-record-source-7780.test.ts b/packages/types/src/__tests__/object-kanban-record-source-7780.test.ts
index 3108b12c1b..6e264cc638 100644
--- a/packages/types/src/__tests__/object-kanban-record-source-7780.test.ts
+++ b/packages/types/src/__tests__/object-kanban-record-source-7780.test.ts
@@ -261,7 +261,10 @@ describe('objectui#8990 — `groupBy` requiredness IS overturned; the record-sou
     // `objectName` upstream of the node), so this document has no record source
     // — and it is STILL refused for that, which is the record-source rule doing
     // its job. What changed is that `groupBy` is no longer among the reasons.
-    const fragment = { type: 'object-kanban', dataSource: { object: 'task', filter: { project: 'acme' } } };
+    const fragment = {
+      type: 'object-kanban',
+      dataSource: { object: 'task', filter: [{ field: 'project', operator: 'equals', value: 'acme' }] },
+    };
     const f = ObjectKanbanSchema.safeParse(fragment);
     expect(f.success).toBe(false);
     if (!f.success) {
diff --git a/packages/types/src/__tests__/object-view-slot-key-lists.test.ts b/packages/types/src/__tests__/object-view-slot-key-lists.test.ts
index 62d5128036..3382dfa816 100644
--- a/packages/types/src/__tests__/object-view-slot-key-lists.test.ts
+++ b/packages/types/src/__tests__/object-view-slot-key-lists.test.ts
@@ -26,10 +26,13 @@
  *
  * ⚠️ Those two member counts are the HISTORICAL reading that produced this
  * pin, kept verbatim because the `-> 0` half is only legible beside them. The
- * LIVE counts are 62 and 68: objectui#6357 declared `bind` on `BaseSchema`,
+ * LIVE counts are 63 and 69: objectui#6357 declared `bind` on `BaseSchema`,
  * both schemas inherit it, and this guard turned red naming them — which is
  * precisely the drift it exists to catch. The key was added to both slot
  * unions in the same change, so the slots still ship the full configuration.
+ * objectui#11070 then declared `dataSource` (the spec's per-element binding)
+ * on both source schemas and the guard named it again: the `form` slot carries
+ * it, and the `table` slot withholds it as a record source the view owns.
  *
  * Nothing errored — the index signature answers every key as `any` — so the
  * symptoms were in the tools that READ the declaration: `table: { colunms: 3 }`
@@ -134,7 +137,7 @@ const TABLE_WITHHELD_BY_REASON = {
    */
   notRelayed: ['description', 'emptyState'],
   /** The view owns it: its own record source, its own row click, its grid's identity. */
-  viewOwned: ['bind', 'data', 'id', 'navigation', 'onNavigate', 'staticData'],
+  viewOwned: ['bind', 'data', 'dataSource', 'id', 'navigation', 'onNavigate', 'staticData'],
   /**
    * A node-level `BaseSchema` key. `ObjectView` draws its grid as a component,
    * not as a schema node, so no renderer applies one of these to it.
@@ -252,18 +255,18 @@ function slotType(slot: 'table' | 'form'): ts.Type {
  * inherited: bump them deliberately when a member is genuinely added.
  */
 describe('the source schemas still declare their full member sets', () => {
-  it('ObjectGridSchema declares 62 members and carries the #5155 index signature', () => {
+  it('ObjectGridSchema declares 63 members and carries the #5155 index signature', () => {
     const grid = exportedType('ObjectGridSchema');
-    expect(memberNames(grid)).toHaveLength(62);
+    expect(memberNames(grid)).toHaveLength(63);
     expect(memberNames(grid)).toEqual(expect.arrayContaining(['columns', 'pageSize', 'rowActions']));
     // When this flips to `false`, objectui#5155 has removed the root index
     // signature and the `Pick` lists this file pins become removable.
     expect(declaresStringIndex(grid)).toBe(true);
   });
 
-  it('ObjectFormSchema declares 68 members and carries the #5155 index signature', () => {
+  it('ObjectFormSchema declares 69 members and carries the #5155 index signature', () => {
     const form = exportedType('ObjectFormSchema');
-    expect(memberNames(form)).toHaveLength(68);
+    expect(memberNames(form)).toHaveLength(69);
     expect(memberNames(form)).toEqual(expect.arrayContaining(['fields', 'sections', 'submitText']));
     expect(declaresStringIndex(form)).toBe(true);
   });
diff --git a/packages/types/src/__tests__/strict-face-read-keys-11070.test.ts b/packages/types/src/__tests__/strict-face-read-keys-11070.test.ts
new file mode 100644
index 0000000000..11d08d26d3
--- /dev/null
+++ b/packages/types/src/__tests__/strict-face-read-keys-11070.test.ts
@@ -0,0 +1,220 @@
+/**
+ * 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.
+ */
+
+/**
+ * Keys a registered renderer READS are declared on both faces, so the strict
+ * authoring face stops refusing them (objectui#11070).
+ *
+ * ## The defect
+ *
+ * `StrictAnyComponentSchema` (objectui#8345) closes every object, so a key no
+ * schema declares is refused by name. PR objectui#11069's measurement of the
+ * shipped face over the repository's own documents found keys refused that way
+ * while a registered renderer reads them — `objectui validate` on the strict
+ * face would tell an author to delete a key that works. This card declares the
+ * ones whose read, spelling and value shape are settled:
+ *
+ *   - `form.showSubmit` — the `form` renderer's submit-button switch;
+ *   - `form.fields[]` — field metadata a hand-authored form writes on the entry
+ *     itself (`multiple`, `rows`, `accept`, `dimensions`, `reference`, `min`,
+ *     `max`, `minLength`, `maxLength`, `pattern`), which the renderer hands
+ *     each field widget as its metadata carrier;
+ *   - `dataSource` on `object-grid`, `object-form`, `object-kanban`,
+ *     `list-view`, `object-gantt`, `object-map` and `object-calendar` — the
+ *     spec's per-element binding, which each block's
+ *     gate-wrapped registration reads off the node through
+ *     `ElementDataSourceGate`.
+ *
+ * Each read is reasoned on the TypeScript member that declares it.
+ *
+ * ## What each block below holds
+ *
+ *   1. a document carrying the key parses on the strict face, and a misspelled
+ *      sibling is still refused BY NAME at the same path — the control that
+ *      shows the face did not open up;
+ *   2. the declared key is judged by its declared type on BOTH faces;
+ *   3. the read keys this card deliberately did NOT declare are still refused
+ *      on the strict face — each waits on a ruling the card records;
+ *   4. the TypeScript faces type the binding, not `any` (type-level, read by
+ *      `tsc -p tsconfig.test.json` only — vitest does not typecheck).
+ */
+
+import { describe, expect, it } from 'vitest';
+import { z } from 'zod';
+
+import type {
+  ListViewSchema,
+  ObjectCalendarSchema,
+  ObjectFormSchema,
+  ObjectGanttSchema,
+  ObjectGridSchema,
+  ObjectKanbanSchema,
+  ObjectMapSchema,
+} from '../objectql.js';
+import type { FormField, FormSchema } from '../form.js';
+import type { ElementDataSource as SpecElementDataSource } from '@objectstack/spec/ui';
+import { AnyComponentSchema, StrictAnyComponentSchema } from '../zod/index.zod.js';
+
+type Issue = { code: string; path: PropertyKey[]; keys?: string[]; errors?: Issue[][] };
+
+const issuesOf = (schema: z.ZodType, doc: unknown): Issue[] | null => {
+  const result = schema.safeParse(doc);
+  return result.success ? null : (result.error.issues as unknown as Issue[]);
+};
+
+/** Every `unrecognized_keys` finding in the issue tree, union arms included, as `path.key`. */
+const undeclared = (issues: Issue[] | null, prefix: PropertyKey[] = []): string[] => {
+  const out: string[] = [];
+  for (const issue of issues ?? []) {
+    const at = [...prefix, ...issue.path];
+    if (issue.code === 'unrecognized_keys') for (const k of issue.keys ?? []) out.push([...at, k].map(String).join('.'));
+    for (const arm of issue.errors ?? []) out.push(...undeclared(arm, at));
+  }
+  return [...new Set(out)];
+};
+
+const form = (field: Record<string, unknown>, node: Record<string, unknown> = {}) => ({
+  type: 'form',
+  ...node,
+  fields: [{ name: 'f', label: 'F', ...field }],
+});
+
+/* ── 1. accepted on the strict face; a misspelling beside it is not ─────── */
+
+describe('objectui#11070 — the declared read keys parse on the strict face', () => {
+  it('`form.showSubmit` parses; `showSubmitt` beside it is refused by name', () => {
+    expect(issuesOf(StrictAnyComponentSchema, form({ type: 'text' }, { showSubmit: false }))).toBeNull();
+    expect(undeclared(issuesOf(StrictAnyComponentSchema, form({ type: 'text' }, { showSubmit: false, showSubmitt: true }))))
+      .toEqual(['showSubmitt']);
+  });
+
+  const FIELD_CASES: ReadonlyArray<readonly [string, Record<string, unknown>]> = [
+    ['multiple', { type: 'file', multiple: true }],
+    ['rows', { type: 'textarea', rows: 6 }],
+    ['accept', { type: 'file', accept: ['application/pdf'] }],
+    ['dimensions', { type: 'vector', dimensions: 768 }],
+    ['reference', { type: 'lookup', reference: 'users' }],
+    ['min', { type: 'number', min: 0 }],
+    ['max', { type: 'number', max: 120 }],
+    ['minLength', { type: 'input', minLength: 3 }],
+    ['maxLength', { type: 'input', maxLength: 20 }],
+    ['pattern', { type: 'input', pattern: '^[^@]+@[^@]+$' }],
+  ];
+
+  it.each(FIELD_CASES)('`fields[].%s` parses; a misspelled sibling is refused at the field', (key, field) => {
+    expect(issuesOf(StrictAnyComponentSchema, form(field))).toBeNull();
+    expect(undeclared(issuesOf(StrictAnyComponentSchema, form({ ...field, [`${key}x`]: 1 }))))
+      .toEqual([`fields.0.${key}x`]);
+  });
+
+  const BINDING = { object: 'task', filter: [{ field: 'project', operator: 'equals', value: 'acme' }] };
+  const BOUND_NODES: ReadonlyArray<readonly [string, Record<string, unknown>]> = [
+    ['object-grid', { objectName: 'task' }],
+    ['object-form', { objectName: 'task', mode: 'edit' }],
+    // `objectName` on every node, deliberately: whether a binding's `object`
+    // may stand in for the node's own required record source (as the spec's
+    // props gate lets it on `element:number`) is a separate question from
+    // whether the key is declared, and this block measures only the second.
+    ['object-kanban', { objectName: 'task' }],
+    ['list-view', { objectName: 'task' }],
+    ['object-gantt', { objectName: 'task' }],
+    ['object-map', { objectName: 'task' }],
+    ['object-calendar', { objectName: 'task' }],
+  ];
+
+  it.each(BOUND_NODES)('`%s.dataSource` parses; `dataSourc` beside it is refused by name', (type, rest) => {
+    expect(issuesOf(StrictAnyComponentSchema, { type, ...rest, dataSource: BINDING })).toBeNull();
+    expect(undeclared(issuesOf(StrictAnyComponentSchema, { type, ...rest, dataSource: BINDING, dataSourc: BINDING })))
+      .toEqual(['dataSourc']);
+  });
+});
+
+/* ── 2. judged by the declared type, on both faces ───────────────────────── */
+
+describe('objectui#11070 — a declared key is judged by its declared type on both faces', () => {
+  const WRONG: ReadonlyArray<readonly [string, unknown]> = [
+    ['a string `showSubmit`', form({ type: 'text' }, { showSubmit: 'false' })],
+    ['a bare-string `accept` (the spec types it as an array)', form({ type: 'file', accept: 'application/pdf' })],
+    ['a zero `rows` (the spec requires a positive integer)', form({ type: 'textarea', rows: 0 })],
+    ['a numeric `pattern`', form({ type: 'input', pattern: 5 })],
+    ['a binding that names no `object`', { type: 'object-kanban', dataSource: { filter: { a: 1 } } }],
+    ['an adapter-shaped `dataSource`', { type: 'object-grid', objectName: 'task', dataSource: 'objectstack' }],
+  ];
+
+  it.each(WRONG)('refuses %s', (_label, doc) => {
+    expect(issuesOf(AnyComponentSchema, doc)).not.toBeNull();
+    expect(issuesOf(StrictAnyComponentSchema, doc)).not.toBeNull();
+  });
+});
+
+/* ── 3. the read keys this card did NOT declare stay refused ─────────────── */
+
+describe('objectui#11070 — the read keys left undeclared pending a ruling stay refused on the strict face', () => {
+  // Each is read by a widget and none is declared. Two are the snake_case
+  // second spelling of a spec key this card DID declare (`reference_to` /
+  // `reference`, `min_length` / `minLength`): the seat's answer on
+  // objectui#11070 keeps the legacy spelling refused, so an author writes the
+  // spec's. Three wait on a question that stays open on objectui#11070: a
+  // snake_case spelling with no read of the spec's to declare instead
+  // (`return_type` / `returnType`, `summary_type` / `summaryOperations`), and
+  // an element shape not yet decided (the grid field's `columns`). ⛔
+  // Declaring one is a contract ruling, not a fix to this list.
+  const PENDING: ReadonlyArray<readonly [string, Record<string, unknown>]> = [
+    ['return_type', { type: 'formula', return_type: 'number' }],
+    ['summary_type', { type: 'summary', summary_type: 'sum' }],
+    ['reference_to', { type: 'lookup', reference_to: 'users' }],
+    ['min_length', { type: 'password', min_length: 8 }],
+    ['columns', { type: 'grid', columns: [{ name: 'qty', type: 'number' }] }],
+  ];
+
+  it.each(PENDING)('`fields[].%s` is refused by name, and the tolerant face still accepts the document', (key, field) => {
+    expect(undeclared(issuesOf(StrictAnyComponentSchema, form(field)))).toEqual([`fields.0.${key}`]);
+    expect(issuesOf(AnyComponentSchema, form(field))).toBeNull();
+  });
+
+  it('`object-chart.dataSource` is refused by name: the react-page wrapper writes the host adapter (or `null`) under that key, and objectui#10770 pins that node as valid on the tolerant face', () => {
+    const doc = { type: 'object-chart', objectName: 'task', chartType: 'bar', dataSource: { object: 'task' } };
+    expect(undeclared(issuesOf(StrictAnyComponentSchema, doc))).toEqual(['dataSource']);
+    expect(issuesOf(AnyComponentSchema, doc)).toBeNull();
+  });
+});
+
+/* ── 4. type level: the TypeScript faces declare the same members ────────── */
+
+type Expect<T extends true> = T;
+type Equal<A, B> = (<T>() => T extends A ? 1 : 2) extends (<T>() => T extends B ? 1 : 2) ? true : false;
+type IsAny<T> = 0 extends 1 & T ? true : false;
+
+/** Each declared member is a named, typed member — not the index signature's `any`. */
+export type assertionFormFieldMembersAreTyped = Expect<Equal<
+  IsAny<FormField['multiple'] | FormField['rows'] | FormField['accept'] | FormField['dimensions']
+    | FormField['reference'] | FormField['min'] | FormField['max'] | FormField['minLength'] | FormField['maxLength'] | FormField['pattern']>,
+  false
+>>;
+export type assertionShowSubmitIsBoolean = Expect<Equal<FormSchema['showSubmit'], boolean | undefined>>;
+/**
+ * Each binding member IS the spec's `ElementDataSource` — an exact match, not a
+ * mere "not `any`": `ListViewSchema` is derived from its zod mirror, and a member
+ * that left the mirror resolves to the index signature's `unknown` there, which
+ * an `IsAny` check would wave through.
+ */
+type BindingOf<T extends { dataSource?: unknown }> = NonNullable<T['dataSource']>;
+export type assertionBindingIsTheSpecBinding = [
+  Expect<Equal<BindingOf<ObjectGridSchema>, SpecElementDataSource>>,
+  Expect<Equal<BindingOf<ObjectFormSchema>, SpecElementDataSource>>,
+  Expect<Equal<BindingOf<ObjectKanbanSchema>, SpecElementDataSource>>,
+  Expect<Equal<BindingOf<ListViewSchema>, SpecElementDataSource>>,
+  Expect<Equal<BindingOf<ObjectGanttSchema>, SpecElementDataSource>>,
+  Expect<Equal<BindingOf<ObjectMapSchema>, SpecElementDataSource>>,
+  Expect<Equal<BindingOf<ObjectCalendarSchema>, SpecElementDataSource>>,
+];
+
+// @ts-expect-error — an adapter is not a binding: the binding names an `object`.
+export const adapterIsNotABinding: ObjectGridSchema['dataSource'] = { find: () => [] };
+export const bindingOnKanban: ObjectKanbanSchema['dataSource'] = { object: 'task', view: 'open', limit: 20 };
+export const bindingOnListView: ListViewSchema['dataSource'] = { object: 'task', view: 'open', limit: 20 };
diff --git a/packages/types/src/__tests__/zod-mirror-parity.test.ts b/packages/types/src/__tests__/zod-mirror-parity.test.ts
index 746abdcd2f..262feb59da 100644
--- a/packages/types/src/__tests__/zod-mirror-parity.test.ts
+++ b/packages/types/src/__tests__/zod-mirror-parity.test.ts
@@ -2584,7 +2584,11 @@ interface KnownDrift {
  * explicit that forcing the 121 per-key decisions now would be wrong. Two splits
  * are recorded here so whoever works them off does not re-derive them:
  *
- *   - **SPEC-DERIVED (3 entries, 34 keys)** — it was 3 / 37 until objectui#11068 closed three
+ *   - **SPEC-DERIVED (4 entries, 35 keys)** — it was 3 / 34 until objectui#11070 declared nine
+ *     field-metadata members on `FormFieldSchema` by reference to the spec's `FieldSchema`:
+ *     none of them was in the ledger, so no key closed, but the spec reference re-derives
+ *     the pair's entry (its one key, `field`) into this half — the objectui#10993 membership
+ *     move again, with ZERO keys repaired. It was 3 / 37 until objectui#11068 closed three
  *     keys of `ObjectGridSchema`'s entry (`emptyState` mirrored, `rowSpecActions` /
  *     `bulkSpecActions` tombstoned), an entry that stayed. It was 2 / 16 until objectui#10993 MIRRORED
  *     five `ObjectFormSchema` members by reference to the spec's `I18nLabelSchema`: none
@@ -2653,7 +2657,9 @@ interface KnownDrift {
  *     spec schema does not model, which is objectui#2231's unification question and
  *     NOT a local mirror edit. They are marked, not exempted: exempting them in the
  *     instrument would re-blind exactly the pairs objectui#5927 leaned on hardest.
- *   - **LOCAL (9 entries, 47 keys)** — plain omissions from a hand-written mirror.
+ *   - **LOCAL (8 entries, 46 keys)** — plain omissions from a hand-written mirror.
+ *     It was 9 / 47 until objectui#11070 re-derived `FormFieldSchema`'s entry (one key)
+ *     into the SPEC-DERIVED half by membership: no key moved between ledgers.
  *     It was 10 / 68 until objectui#10993 re-derived `ObjectFormSchema`'s entry (21
  *     keys) into the SPEC-DERIVED half by membership: no key moved between ledgers.
  *     It was 11 / 69 until objectui#8072 MIRRORED `InputSchema.wrapperClass`: the entry's
@@ -2706,10 +2712,11 @@ interface KnownDrift {
  * `ObjectViewSchema.listViews`, that entry's last key, by reference: the SPEC-DERIVED
  * half lost the entry, and the LOCAL half did not move. objectui#10993 then moved
  * `ObjectFormSchema`'s entry (21 keys) from the LOCAL half to the SPEC-DERIVED one by
- * membership alone, without moving the totals. The seeded pair is no longer
+ * membership alone, without moving the totals, and objectui#11070 moved
+ * `FormFieldSchema`'s entry (one key) the same way. The seeded pair is no longer
  * among them, and the ledger now totals — on ONE line, because the pin below reads
  * this sentence off disk —
- * **12 entries / 81 keys** — 3 / 34 spec-derived, 9 / 47 local.
+ * **12 entries / 81 keys** — 4 / 35 spec-derived, 8 / 46 local.
  *
  * ⛔ The four split figures above and this totals line are PINNED: 'objectui#7279'
  * at the bottom of this file derives every one of them from the `UnmirroredDeclared`
@@ -2797,7 +2804,13 @@ interface UnmirroredDeclared {
     | 'page' | 'rowActionDefs' | 'rowClassName'
     | 'rowCount' | 'rowStyle' | 'search' | 'selectionResetKey' | 'selectionStyle'
     | 'showAddRow' | 'showSelectionCount' | 'singleClickEdit' | 'sort';
-  /** LOCAL. */
+  /**
+   * SPEC-DERIVED by MEMBERSHIP since objectui#11070, LOCAL before it: that card declared
+   * nine field-metadata members by reference to the spec's `FieldSchema`, so
+   * `SPEC_DERIVED_PAIRS` re-derives the pair into that half. ⚠️ `field` itself did not
+   * move and is not a spec key here: it is the resolved object-field metadata stash,
+   * kept out of the authorable surface on purpose (objectui#6609).
+   */
   'form.zod.ts#FormFieldSchema': 'field';
   /**
    * LOCAL. `fields` is in `KnownDrift` above (mirrored, drifted in TYPE; `mode` sat
@@ -4233,6 +4246,12 @@ const SPEC_DERIVED_PAIRS: readonly string[] = [
   // reference (the axis config object `ChartConfigSchema` declares), so a spec
   // bump that moves the axis vocabulary moves ONE side of this pair.
   'data-display.zod.ts#ChartSchema',
+  // objectui#11070: nine of the field-metadata members a hand-authored form
+  // writes on the entry itself are the spec's `FieldSchema` members by
+  // reference (`multiple`, `rows`, `accept`, `dimensions`, `reference`, `min`,
+  // `max`, `minLength`, `maxLength`), so a spec bump that moves one of those field
+  // keys moves ONE side of this pair. The first spec reference in this mirror.
+  'form.zod.ts#FormFieldSchema',
   'form.zod.ts#SelectOptionSchema',
   'layout.zod.ts#PageNodeSchema',
   // ⭐ ONE entry, SIX spec crossings over FIVE spec symbols — three cards put
@@ -4277,6 +4296,13 @@ const SPEC_DERIVED_PAIRS: readonly string[] = [
   // `SpecListViewSchema.shape.exportOptions` (the two-arm union) so the bare-array arm,
   // which LIFTS, is left behind and refused by name on this node instead.
   'objectql.zod.ts#ObjectGridSchema',
+  // objectui#11070: `dataSource` is the spec's `ElementDataSourceSchema` by
+  // reference (the per-element binding `PageComponentSchema.dataSource`
+  // declares) — the first spec reference in this mirror. `ObjectGridSchema`,
+  // `ObjectFormSchema`, `ListViewSchema`, `ObjectGanttSchema`,
+  // `ObjectMapSchema` and `ObjectCalendarSchema` gained the same member and
+  // were already spec-derived.
+  'objectql.zod.ts#ObjectKanbanSchema',
   'objectql.zod.ts#ObjectMapSchema',
   // objectui#7779: BACK, by a real code reference this time — `navigation`,
   // `searchableFields` and `filterableFields` are `SpecListViewSchema.shape.*`
diff --git a/packages/types/src/form.ts b/packages/types/src/form.ts
index e38fc37764..d8499485d0 100644
--- a/packages/types/src/form.ts
+++ b/packages/types/src/form.ts
@@ -17,6 +17,9 @@
 
 import type { BaseSchema, SchemaNode } from './base.js';
 import type { SelectOptionBase } from './select-option.js';
+// objectui#11070 — the field-metadata members `FormField` declares by
+// reference to the spec's `FieldSchema`. Type-only: no runtime edge.
+import type { Field as SpecField } from '@objectstack/spec/data';
 
 /**
  * Button component
@@ -1916,6 +1919,101 @@ export interface FormField {
    * non-divider row the key has no meaning and is ignored by the renderer.
    */
   fields?: string[];
+
+  // ── Field metadata written on the entry itself (objectui#11070) ─────────
+  //
+  // A hand-authored `form` has no object schema behind it, so nothing is
+  // stashed on `field` above: the renderer hands each field widget the ENTRY
+  // ITSELF as its metadata carrier (`field: field.field || field`, the one
+  // `renderFieldComponent` call in `renderers/form/form.tsx`), and the
+  // built-in `input` / `textarea` branches spread the entry's remaining keys
+  // onto the native control. The members below are the keys that path reads
+  // off the entry. Each one `@objectstack/spec` declares on `FieldSchema` is
+  // typed BY REFERENCE to that member, so the two cannot drift; `pattern` is
+  // the one the spec does not declare.
+  //
+  // ⛔ Not every key a widget reads off the carrier is declared here. Four are
+  // read in a snake_case spelling beside a spec key of the same meaning —
+  // `return_type` (spec `returnType`), `summary_type` (spec
+  // `summaryOperations`), `reference_to` (spec `reference`) and `min_length`
+  // (spec `minLength`) — and none of the four is declared: a second spelling
+  // is not added to this contract. Where the widgets already read the SPEC
+  // spelling too, that spelling is the one declared (`reference`, below;
+  // `minLength`, above), and `reference_to` / `min_length` stay refused by the
+  // strict face (the seat's answer on objectui#11070). `return_type` and
+  // `summary_type` have no read of the spec spelling to declare. The grid
+  // field's `columns` is read too, but its element shape is undecided: the
+  // declared `GridColumnDefinition` (`./field-types.ts`) is not the shape
+  // `GridField` reads. Those three remain open on objectui#11070.
+
+  /**
+   * Hold several values instead of one. Read by the `file`, `image`,
+   * `lookup` and `user` field widgets off their metadata carrier: the upload
+   * widgets put `multiple` on their file `<input>`, the pickers switch to
+   * multi-value selection. The built-in `select` branch does not read it.
+   */
+  multiple?: SpecField['multiple'];
+  /**
+   * Height of the inline editor, in text rows. The built-in `textarea` branch
+   * spreads it onto the `<textarea>` as `rows`; the `markdown` widget reads
+   * it for its inline editor (default 8).
+   */
+  rows?: SpecField['rows'];
+  /**
+   * Upload types the file picker offers, as MIME types or extensions
+   * (e.g. `["image/*", ".pdf"]`). The `file` widget joins them into its
+   * `<input type="file">`'s `accept` attribute.
+   */
+  accept?: SpecField['accept'];
+  /**
+   * Vector dimensionality. The `vector` widget prints it beside the value
+   * (`(768D)`), falling back to the value's own length when absent.
+   */
+  dimensions?: SpecField['dimensions'];
+  /**
+   * Target object of a `lookup` / `user` field, as `@objectstack/spec`'s
+   * `FieldSchema` spells it. The `lookup` widget resolves its target as
+   * `reference_to || reference` and the `user` widget as
+   * `reference || reference_to` (falling back to `sys_user`), so this is the
+   * object the picker queries through the injected adapter. The legacy
+   * `reference_to` spelling is still read by both, and is ⛔ NOT declared:
+   * the strict face refuses it, so an author writes this spelling
+   * (objectui#11070).
+   */
+  reference?: SpecField['reference'];
+  /**
+   * Minimum value. The `number` widget and the built-in `input` branch put it
+   * on the native control as `min`, which the browser enforces at submit
+   * (the form sets no `noValidate`). For a react-hook-form rule with its own
+   * message, write `validation.min` instead.
+   */
+  min?: SpecField['min'];
+  /**
+   * Maximum value. Read like {@link FormField.min}, as the native `max`.
+   */
+  max?: SpecField['max'];
+  /**
+   * Minimum character length. The built-in `input` and `textarea` branches
+   * put it on the native control as `minlength`, which the browser enforces
+   * at submit. For a react-hook-form rule with its own message, write
+   * `validation.minLength` instead.
+   */
+  minLength?: SpecField['minLength'];
+  /**
+   * Maximum character length. The built-in `input` and `textarea` branches
+   * resolve it as the control's `maxLength` ceiling (the `textarea` branch
+   * also draws its `{n}/{max}` counter).
+   */
+  maxLength?: SpecField['maxLength'];
+  /**
+   * Regular expression the value must match, as a STRING — JSON has no
+   * `RegExp`. The built-in `input` branch puts it on the native control as
+   * `pattern`, which the browser enforces at submit. This is the spelling
+   * the `validation.pattern` refusal directs JSON authors to: that rule's
+   * `value` must be a compiled `RegExp` (objectui#5099), which a document
+   * cannot carry.
+   */
+  pattern?: string;
 }
 
 /**
@@ -1970,6 +2068,18 @@ export interface FormSchema extends BaseSchema {
    * @default false
    */
   showCancel?: boolean;
+  /**
+   * Show the submit button (objectui#11070).
+   *
+   * The `form` renderer destructures this off the node with a `true` default
+   * and draws its submit button only while it holds (`{showSubmit && (` in
+   * `renderers/form/form.tsx`), so `false` renders the fields with no submit
+   * button — the display-only form the `fields-*` catalog examples author.
+   * Declared on both faces because the strict authoring face refused it as
+   * undeclared while the renderer read it.
+   * @default true
+   */
+  showSubmit?: boolean;
   /**
    * Form layout
    * @default 'vertical'
diff --git a/packages/types/src/objectql.ts b/packages/types/src/objectql.ts
index 94e89c9392..b8116895bb 100644
--- a/packages/types/src/objectql.ts
+++ b/packages/types/src/objectql.ts
@@ -31,6 +31,8 @@ import type { ObjectDataTableDrillDownConfig } from './data-display.js';
 // this adds no cycle in either direction.
 import type { QueryParams } from './data.js';
 import type { BulkActionOperation } from '@objectstack/spec/ui';
+// objectui#11070 — the per-element binding `dataSource` declares, by reference.
+import type { ElementDataSource } from '@objectstack/spec/ui';
 // objectui#7928 — `ObjectViewSchema.listViews` is the protocol's record of this
 // schema, BY REFERENCE. The spec publishes a TS type for `ListView` and none for
 // the object-scoped `ObjectListView`, so the member reads it as `z.input` (the
@@ -772,6 +774,35 @@ export interface ListViewExportOptions {
 export interface ObjectGridSchema extends BaseSchema {
   type: 'object-grid';
 
+  /**
+   * Per-element data binding — `@objectstack/spec`'s `ElementDataSource`
+   * (`PageComponentSchema.dataSource`), by reference: `{ object, view?,
+   * filter?, sort?, limit? }` describing WHAT this block queries
+   * (objectui#11070).
+   *
+   * ⚠️ Metadata, ⛔ NOT the data-source ADAPTER. The two share a name and are
+   * different things: the adapter is injected by the host
+   * (`SchemaRendererProvider`) and reaches the component as a React prop,
+   * while this is authored JSON. `SchemaRenderer` strips `dataSource` from the
+   * props it spreads (objectstack#5576) so the binding can never shadow the
+   * adapter, and the registered renderer reads it off the NODE through
+   * `ElementDataSourceGate` (`@object-ui/react`), which lands `object` on
+   * `objectName` and composes a named saved `view` with the binding's own
+   * keys. Every gate-wrapped registration already PUBLISHES this key as an
+   * authored input (objectui#6678, `ELEMENT_DATA_SOURCE_INPUT` in
+   * `@object-ui/core`); this member is that declaration on the schema faces,
+   * which the strict authoring face refused until it was written. Same
+   * declaration on {@link ObjectFormSchema}, {@link ObjectKanbanSchema},
+   * {@link ObjectGanttSchema}, {@link ObjectMapSchema},
+   * {@link ObjectCalendarSchema} and `ListViewSchema` (derived from its zod
+   * mirror; its absence from `@object-ui/app-shell`'s relay census is declared
+   * there, objectui#7559). ⚠️ Not on {@link ObjectChartSchema}: the react-page
+   * wrapper writes the host's ADAPTER (or `null`) under this key on every data
+   * block it builds, and objectui#10770 pins that `object-chart` node as
+   * valid, so declaring the binding there waits on objectui#11070's seat.
+   */
+  dataSource?: ElementDataSource;
+
   /**
    * RETIRED on this node (objectui#11068, ADR-0049) — a grid has no `name`.
    *
@@ -1514,6 +1545,14 @@ export type SubmitBehavior =
  */
 export interface ObjectFormSchema extends BaseSchema {
   type: 'object-form';
+
+  /**
+   * Per-element data binding — the spec's `ElementDataSource`, by reference
+   * (objectui#11070). A form honours its `object` (it edits one record, so
+   * there is no collection query to filter or page). Metadata, ⛔ not the
+   * adapter: see {@link ObjectGridSchema.dataSource}.
+   */
+  dataSource?: ElementDataSource;
   
   /**
    * Form variant type.
@@ -2072,7 +2111,8 @@ export interface ObjectFormSchema extends BaseSchema {
  * `description` — honoured by the grid since objectui#11068, and kept off
  * this slot by that card's ruling, which enforced them without widening it);
  * the view owns it (the record source
- * `data` / `staticData` / `bind`, the row click `navigation` / `onNavigate`,
+ * `data` / `staticData` / `bind`, and since objectui#11070 the binding
+ * `dataSource`; the row click `navigation` / `onNavigate`;
  * the grid's `id`); the view draws the grid as a component rather than a
  * schema node, so the node-level `BaseSchema` keys have no renderer to apply
  * them (`style`, `testId`, `ariaLabel`, `hidden` / `hiddenOn`,
@@ -2172,6 +2212,10 @@ type ObjectFormSlotKey =
   | 'columns'
   | 'customFields'
   | 'data'
+  // objectui#11070 — joins with `ObjectFormSchema.dataSource`. This slot
+  // withholds nothing but the identity keys (above), so it carries the binding
+  // as it carries `bind` and `data`; `ObjectView` relays neither to its form.
+  | 'dataSource'
   | 'defaultTab'
   | 'defaults'
   | 'description'
@@ -3125,6 +3169,14 @@ export interface ObjectMapConfig {
  */
 export interface ObjectMapSchema extends BaseSchema {
   type: 'object-map';
+  /**
+   * Per-element data binding — the spec's `ElementDataSource`, by reference
+   * (objectui#11070). This block's registration is gate-wrapped
+   * (`elementDataSourceBlock`), so `ElementDataSourceGate` reads the binding
+   * off the node and lands its `object` on `objectName`. Metadata, ⛔ not the
+   * adapter: see {@link ObjectGridSchema.dataSource}.
+   */
+  dataSource?: ElementDataSource;
   /**
    * ObjectQL object name — the THIRD record source `getDataConfig` resolves,
    * after {@link ObjectMapSchema.data} and {@link ObjectMapSchema.staticData}
@@ -3317,6 +3369,14 @@ export interface ObjectTreeSchema extends BaseSchema {
  */
 export interface ObjectGanttSchema extends BaseSchema {
   type: 'object-gantt';
+  /**
+   * Per-element data binding — the spec's `ElementDataSource`, by reference
+   * (objectui#11070). This block's registration is gate-wrapped
+   * (`elementDataSourceBlock`), so `ElementDataSourceGate` reads the binding
+   * off the node and lands its `object` on `objectName`. Metadata, ⛔ not the
+   * adapter: see {@link ObjectGridSchema.dataSource}.
+   */
+  dataSource?: ElementDataSource;
   /**
    * ObjectQL object name — the THIRD record source `resolveRecordSourceConfig`
    * (`@object-ui/core`) resolves, after {@link ObjectGanttSchema.data} and
@@ -3688,6 +3748,14 @@ export interface ObjectGanttSchema extends BaseSchema {
  */
 export interface ObjectCalendarSchema extends BaseSchema {
   type: 'object-calendar';
+  /**
+   * Per-element data binding — the spec's `ElementDataSource`, by reference
+   * (objectui#11070). This block's registration is gate-wrapped
+   * (`elementDataSourceBlock`), so `ElementDataSourceGate` reads the binding
+   * off the node and lands its `object` on `objectName`. Metadata, ⛔ not the
+   * adapter: see {@link ObjectGridSchema.dataSource}.
+   */
+  dataSource?: ElementDataSource;
   /**
    * ObjectQL object name — the THIRD record source `resolveRecordSourceConfig`
    * (`@object-ui/core`) resolves, after {@link ObjectCalendarSchema.data} and
@@ -3954,6 +4022,14 @@ export interface ObjectCalendarSchema extends BaseSchema {
  */
 export interface ObjectKanbanSchema extends BaseSchema {
   type: 'object-kanban';
+  /**
+   * Per-element data binding — the spec's `ElementDataSource`, by reference
+   * (objectui#11070). The board honours its `object` and `filter`, and its
+   * `sort` is where the board's ordering is authored — the spec refuses a
+   * top-level `sort` on this node (see {@link ObjectKanbanSchema.filter}).
+   * Metadata, ⛔ not the adapter: see {@link ObjectGridSchema.dataSource}.
+   */
+  dataSource?: ElementDataSource;
   /**
    * ObjectQL object name — the LAST rung of this board's record-source ladder,
    * and the only one that names an object.
diff --git a/packages/types/src/zod/form.zod.ts b/packages/types/src/zod/form.zod.ts
index 57e762ee4b..b2e5156753 100644
--- a/packages/types/src/zod/form.zod.ts
+++ b/packages/types/src/zod/form.zod.ts
@@ -18,7 +18,7 @@
 
 import { z } from 'zod';
 import { aliasKeyRefusal, handlerKeyRefusal, neitherContentChannelGuidance, retirementTombstone } from './tombstone.zod.js';
-import { SelectOptionSchema as SpecSelectOptionSchema } from '@objectstack/spec/data';
+import { FieldSchema as SpecFieldSchema, SelectOptionSchema as SpecSelectOptionSchema } from '@objectstack/spec/data';
 import { BaseSchema, SchemaNodeSchema } from './base.zod.js';
 // The predicate wire shape (`string | { dialect?, source }`, #2212) was a
 // module-private const here until objectui#7530 hoisted it into
@@ -959,6 +959,25 @@ export const FormFieldSchema = z.object({
   span: z.enum(['auto', 'full']).optional().describe('Relative field width'),
   fields: z.array(z.string()).optional()
     .describe('Section grouping claim (objectui#6236) — section-divider rows only: names of the fields the section claims (the FormFieldTab.fields membership shape); the divider predicate then gates the whole group'),
+  // objectui#11070 — field metadata a hand-authored form writes on the entry
+  // itself, which the renderer hands to each field widget as its metadata
+  // carrier. Every member but `pattern` is the spec's `FieldSchema` member BY
+  // REFERENCE (values, checks and `.describe()` text included), so it cannot
+  // drift from the key the widgets were written against. The reads, and the
+  // read keys deliberately NOT declared, are reasoned on the TS twin.
+  multiple: stripImportedDefaults(SpecFieldSchema).shape.multiple,
+  rows: stripImportedDefaults(SpecFieldSchema).shape.rows,
+  accept: stripImportedDefaults(SpecFieldSchema).shape.accept,
+  dimensions: stripImportedDefaults(SpecFieldSchema).shape.dimensions,
+  // The spec spelling of a lookup / user field's target object; the legacy
+  // `reference_to` is read too and deliberately stays undeclared (objectui#11070).
+  reference: stripImportedDefaults(SpecFieldSchema).shape.reference,
+  min: stripImportedDefaults(SpecFieldSchema).shape.min,
+  max: stripImportedDefaults(SpecFieldSchema).shape.max,
+  minLength: stripImportedDefaults(SpecFieldSchema).shape.minLength,
+  maxLength: stripImportedDefaults(SpecFieldSchema).shape.maxLength,
+  pattern: z.string().optional()
+    .describe('Regular expression the value must match, as a string (JSON has no RegExp) — the built-in input branch puts it on the native control as `pattern`; the field-level spelling the `validation.pattern` refusal directs JSON authors to'),
 }).superRefine((field, ctx) => {
   // objectui#5449 — the namespace rule `@object-ui/core` has enforced since
   // objectui#5375, stated here so `objectui validate` (which reaches this
@@ -994,6 +1013,10 @@ export const FormSchema = BaseSchema.extend({
   submitLabel: z.string().optional().describe('Submit button label'),
   cancelLabel: z.string().optional().describe('Cancel button label'),
   showCancel: z.boolean().optional().describe('Show cancel button'),
+  // objectui#11070 — read by the `form` renderer (destructured off the node,
+  // default `true`; the submit button renders only while it holds) and
+  // refused by the strict authoring face until declared here.
+  showSubmit: z.boolean().optional().describe('Show the submit button (default true); `false` renders the fields with no submit button'),
   layout: z.enum(['vertical', 'horizontal', 'grid']).optional().describe('Form layout'),
   columns: z.number().optional().describe('Number of columns (for grid layout)'),
   validationMode: z.enum(['onSubmit', 'onChange', 'onBlur', 'onTouched', 'all']).optional().describe('Validation mode'),
diff --git a/packages/types/src/zod/imported-defaults.ts b/packages/types/src/zod/imported-defaults.ts
index 739eb34ae7..0fa9694db1 100644
--- a/packages/types/src/zod/imported-defaults.ts
+++ b/packages/types/src/zod/imported-defaults.ts
@@ -134,7 +134,10 @@ const walk = (schema: z.ZodType): z.ZodType => {
   // objectui#7928 added a FOURTH by importing the view container `ViewSchema`
   // for its `listViews` slot: the recursive form-field group under
   // `ViewSchema.formViews[…].groups[].fields[]`, walked because the whole
-  // container crosses the boundary, not only the slot.
+  // container crosses the boundary, not only the slot. objectui#11070 added a
+  // FIFTH by importing the spec's `FieldSchema` for nine `FormFieldSchema`
+  // members: the one under `FieldSchema.relatedListFilter`, walked for the
+  // same reason.
   // Each sits inside a schema that carries a default anyway, so the exception
   // costs no extra rebuild. objectui#10872 batch 2 had ONE named exception,
   // `ElementDataSourceSchema` (the `element:number` arm's `dataSource`), whose
diff --git a/packages/types/src/zod/objectql.zod.ts b/packages/types/src/zod/objectql.zod.ts
index 8b04de1299..091582208c 100644
--- a/packages/types/src/zod/objectql.zod.ts
+++ b/packages/types/src/zod/objectql.zod.ts
@@ -50,6 +50,9 @@ import {
   // `properties` bag, by reference (`ObjectQLPublicBlockComponentSchema` below).
   ObjectMetricPropsSchema as SpecObjectMetricPropsSchema,
   ObjectMasterDetailFormPropsSchema as SpecObjectMasterDetailFormPropsSchema,
+  // objectui#11070 — the per-element data binding (`PageComponentSchema.dataSource`)
+  // the object-bound arms below declare as `dataSource`, by reference.
+  ElementDataSourceSchema as SpecElementDataSourceSchema,
   checkListViewCalendarVisualization,
 } from '@objectstack/spec/ui';
 import { BaseSchema, specFieldsExcept } from './base.zod.js';
@@ -267,12 +270,34 @@ const OBJECT_GRID_PLACEHOLDER_RETIRED =
   'RETIRED on `object-grid` (objectui#11068, ADR-0049) — a grid is not an input, and nothing read '
   + '`placeholder`. The text the grid shows when it has no rows is `emptyState: { message }`.';
 
+/**
+ * objectui#11070 — ONE `.describe()` string for every object-bound arm that declares
+ * the spec's per-element binding as `dataSource` (by reference to
+ * `ElementDataSourceSchema`, spelled inline at each crossing — see `./imported-defaults.ts`
+ * on why the crossing itself is never parked in a const). Each of these blocks' registrations
+ * is gate-wrapped (`elementDataSourceBlock`), which is what publishes the key as an authored
+ * input (objectui#6678); the reads are reasoned on the TypeScript twin of `ObjectGridSchema`.
+ */
+const ELEMENT_DATA_SOURCE_BINDING_DESCRIPTION =
+  'Per-element data binding — `@objectstack/spec` `ElementDataSourceSchema`, the schema '
+  + '`PageComponentSchema.dataSource` declares, by reference: { object, view?, filter?, sort?, limit? } '
+  + 'describing WHAT this block queries. Metadata, never the data-source adapter (the host injects that; '
+  + '`SchemaRenderer` strips this key from the props it spreads so it cannot shadow the adapter).';
+
 /**
  * ObjectGrid Schema
  */
 export const ObjectGridSchema = BaseSchema.extend({
   type: z.literal('object-grid'),
   objectName: z.string().describe('ObjectQL object name'),
+  // objectui#11070 — the spec's per-element binding, by reference, as
+  // `public-blocks.zod.ts`'s `element:number` arm already declares it. The
+  // registered renderer reads it off the node through `ElementDataSourceGate`,
+  // and every gate-wrapped registration publishes it as an authored input
+  // (objectui#6678); the reasoning is on the TS twin's member.
+  dataSource: stripImportedDefaults(SpecElementDataSourceSchema)
+    .optional()
+    .describe(ELEMENT_DATA_SOURCE_BINDING_DESCRIPTION),
   data: ViewDataSchema.optional().describe('Data source configuration'),
   columns: z.union([z.array(z.string()), z.array(ListColumnSchema)]).optional().describe('Columns configuration'),
   filter: z.array(z.any()).optional().describe('Filter criteria'),
@@ -462,6 +487,11 @@ const OBJECT_FORM_NEITHER_CHANNEL = neitherContentChannelGuidance(
  */
 export const ObjectFormSchema = BaseSchema.extend({
   type: z.literal('object-form'),
+  // objectui#11070 — the spec's per-element binding, by reference; see
+  // `ObjectGridSchema.dataSource` above.
+  dataSource: stripImportedDefaults(SpecElementDataSourceSchema)
+    .optional()
+    .describe(ELEMENT_DATA_SOURCE_BINDING_DESCRIPTION),
   objectName: z.string().describe('ObjectQL object name'),
   mode: z.enum(['create', 'edit', 'view']).describe('Form mode'),
   recordId: z
@@ -605,6 +635,9 @@ const OBJECT_VIEW_TABLE_WITHHELD = {
   bind: tableKeyRefusal('bind', TABLE_KEY_RECORD_SOURCE),
   bulkSpecActions: tableKeyRefusal('bulkSpecActions', `${TABLE_KEY_UNREAD} Write \`bulkActions\`.`),
   data: tableKeyRefusal('data', TABLE_KEY_RECORD_SOURCE),
+  // objectui#11070 declared the per-element binding on `ObjectGridSchema`; on
+  // the view's grid it is one more record source the view owns.
+  dataSource: tableKeyRefusal('dataSource', TABLE_KEY_RECORD_SOURCE),
   description: tableKeyRefusal('description', `${TABLE_KEY_NOT_RELAYED} Write \`description\` on the object-view node itself.`),
   disabled: tableKeyRefusal('disabled', TABLE_KEY_NODE_LEVEL),
   disabledOn: tableKeyRefusal('disabledOn', TABLE_KEY_NODE_LEVEL),
@@ -1584,6 +1617,13 @@ export const ListViewSchema = BaseSchema
   .extend({
     // Component discriminator — load-bearing for the ObjectQLComponentSchema union.
     type: z.literal('list-view'),
+    // objectui#11070 — the spec's per-element binding, by reference; see
+    // `ObjectGridSchema.dataSource`. The spec's `ListViewSchema` declares no
+    // `dataSource`, so this is a node-level member of objectui's arm, and the
+    // TS `ListViewSchema` inherits it through `ListViewInferred`.
+    dataSource: stripImportedDefaults(SpecElementDataSourceSchema)
+      .optional()
+      .describe(ELEMENT_DATA_SOURCE_BINDING_DESCRIPTION),
     // objectui-only object binding (spec binds via data.provider:'object'; migration deferred).
     objectName: z.string().describe('Object Name'),
     // Renamed spec `type` (view-kind); enum imported from spec so it can't drift.
@@ -2000,6 +2040,11 @@ const OBJECT_MAP_NEITHER_CHANNEL = neitherContentChannelGuidance(
  */
 export const ObjectMapSchema = BaseSchema.extend({
   type: z.literal('object-map'),
+  // objectui#11070 — the spec's per-element binding, by reference; this block's
+  // registration is gate-wrapped. See `ObjectGridSchema.dataSource`.
+  dataSource: stripImportedDefaults(SpecElementDataSourceSchema)
+    .optional()
+    .describe(ELEMENT_DATA_SOURCE_BINDING_DESCRIPTION),
   objectName: z.string().optional().describe('ObjectQL object name — the THIRD record source getDataConfig resolves, after data and staticData; one of the three must be present'),
   data: ViewDataSchema.optional().describe('Data source configuration — read FIRST by getDataConfig'),
   staticData: z.array(z.any()).optional().describe('Inline records — read SECOND by getDataConfig, wrapped into a { provider: value } config'),
@@ -2073,6 +2118,11 @@ const OBJECT_GANTT_NEITHER_CHANNEL = neitherContentChannelGuidance(
  */
 export const ObjectGanttSchema = BaseSchema.extend({
   type: z.literal('object-gantt'),
+  // objectui#11070 — the spec's per-element binding, by reference; this block's
+  // registration is gate-wrapped. See `ObjectGridSchema.dataSource`.
+  dataSource: stripImportedDefaults(SpecElementDataSourceSchema)
+    .optional()
+    .describe(ELEMENT_DATA_SOURCE_BINDING_DESCRIPTION),
   objectName: z.string().optional().describe('ObjectQL object name — the THIRD record source resolveRecordSourceConfig resolves, after data and staticData; one of the three must be present'),
   data: ViewDataSchema.optional().describe('Data source configuration — read FIRST by resolveRecordSourceConfig'),
   startDateField: z.string().optional().describe('Start date field'),
@@ -2233,6 +2283,11 @@ const OBJECT_CALENDAR_NEITHER_CHANNEL = neitherContentChannelGuidance(
  */
 export const ObjectCalendarSchema = BaseSchema.extend({
   type: z.literal('object-calendar'),
+  // objectui#11070 — the spec's per-element binding, by reference; this block's
+  // registration is gate-wrapped. See `ObjectGridSchema.dataSource`.
+  dataSource: stripImportedDefaults(SpecElementDataSourceSchema)
+    .optional()
+    .describe(ELEMENT_DATA_SOURCE_BINDING_DESCRIPTION),
   objectName: z.string().optional().describe('ObjectQL object name — the THIRD record source resolveRecordSourceConfig resolves, after data and staticData; one of the three must be present (objectui#7313)'),
   // objectui#9239 — the ARRAY arm, mirroring `ComponentPropsMap['object-calendar'].data`
   // on `@objectstack/spec` (`z.array(z.unknown()).optional()`, "Pre-fetched
@@ -2509,6 +2564,11 @@ const OBJECT_KANBAN_NEITHER_CHANNEL = neitherContentChannelGuidance(
 // VIEW-LEVEL alias `KanbanConfig.groupField` above is live and untouched.
 export const ObjectKanbanSchema = BaseSchema.extend({
   type: z.literal('object-kanban'),
+  // objectui#11070 — the spec's per-element binding, by reference; see
+  // `ObjectGridSchema.dataSource`.
+  dataSource: stripImportedDefaults(SpecElementDataSourceSchema)
+    .optional()
+    .describe(ELEMENT_DATA_SOURCE_BINDING_DESCRIPTION),
   objectName: z.string().optional().describe('ObjectQL object name — the LAST rung of the board ladder, after the pre-fetched data prop, bind and the inline row array on data; one of bind, data, objectName must be present (objectui#7780)'),
   // objectui#8990 — OPTIONAL, mirroring `@objectstack/spec`
   // (`ObjectKanbanPropsSchema.groupBy` is `z.string().optional()`). Required