@@ -0,0 +1,45 @@
+---
+"@object-ui/types": minor
+"@object-ui/plugin-charts": minor
+---
+
+feat(types,plugin-charts): anchor `ObjectChart`'s props to `ObjectChartSchema` and declare the four keys its producers write
+
+`ObjectChart` was published as `(props: any)`, so `ObjectChartSchema` anchored
+nothing: every `schema={{ … }}` literal handed to the component was type-checked
+against nothing at all. Four keys its producers write and its renderer reads —
+`xAxisKey`, `series`, `aggregate`, `filter` — were declared on neither published
+copy of the shape, and rode `BaseSchema`'s index signature / `.passthrough()`
+unvalidated. That is the mechanism that let objectui#7891's undeclared `config`
+rung survive from the day it was written.
+
+Maintainer ruling 2026-09-09 (option A), applying objectui#6576's gallery
+treatment to the chart:
+
+- `ObjectChartProps.schema` is `ObjectChartSchema`; the published `.d.ts` no
+  longer says `props: any`. `ObjectChartProps` is exported.
+- The four keys are declared on BOTH copies, with value types taken from their
+  READ sites (`ChartRendererProps` for `xAxisKey` / `series`, `ObjectChart.tsx`
+  for `aggregate` / `filter`) rather than copied from any producer's literal.
+- `colors` converges: the zod mirror has declared it since objectui#3913 and the
+  TS interface did not, a drift no ratchet could see because a mirror-only key
+  is in neither of the parity guard's two difference ledgers.
+
+Two of the four are AUTHORABLE (`aggregate`, `filter` — the spec names this
+component's own props as their carrier and parses `aggregate` at the react-page
+publish gate) and two are INTERNAL, relay-composed (`xAxisKey`, `series` — every
+producer computes them and the spec's author-facing vocabulary refuses the
+internal spellings by name). The internal pair is declared anyway, because it was
+already passing through unvalidated: declaring buys the value check without
+minting authorable vocabulary, and each description says which it is.
+
+BEHAVIOUR, from what the anchor made visible: `ObjectChart` resolved the
+group-by column twice and only one site normalised the structured
+`groupBy: { field, dateGranularity }` node. The other used the raw union as a row
+index, a field name and a drill-filter key, so a date-bucketed chart lost its
+option-colour resolution, its label→raw reverse map and its drill filter to a
+lookup on the node's stringification. Both sites now share one normalisation.
+
+⚠️ Anchoring does not buy rejection of a MISSPELLED key: `BaseSchema` carries
+`[key: string]: any` (objectui#5155), the same ceiling objectui#6576 accepted.
+What it buys is that a wrong VALUE TYPE is now a compile error.
@@ -55,6 +55,7 @@ vi.mock('recharts', async () => {
 });
 
 import { ObjectChart, resolveChartCategoryField } from './ObjectChart';
+import type { ObjectChartSchema } from '@object-ui/types';
 
 beforeEach(() => {
   vi.stubGlobal('fetch', vi.fn(async () => ({ ok: true, json: async () => ({}) })));
@@ -77,8 +78,13 @@ const dataSourceWithRows = () => ({
   aggregate: vi.fn().mockResolvedValue(ROWS),
 });
 
-const renderChart = (schema: Record<string, unknown>, ds: any = dataSourceWithRows()) =>
-  render(<ObjectChart schema={{ chartType: 'bar', isAnimationActive: false, ...schema }} dataSource={ds} />);
+// `type` moved into the base literal when objectui#7946 anchored
+// `ObjectChartProps.schema` to `ObjectChartSchema`, on which `type` is
+// required and pinned to the registry key. The per-case overrides stay a
+// partial of the anchored type — this file's whole subject is nodes that
+// declare no category axis, so the parameter must keep admitting them.
+const renderChart = (schema: Partial<ObjectChartSchema>, ds: any = dataSourceWithRows()) =>
+  render(<ObjectChart schema={{ type: 'object-chart', chartType: 'bar', isAnimationActive: false, ...schema }} dataSource={ds} />);
 
 /** The refusal is absent AND the chart got far enough to draw. */
 const expectNoRefusal = async () => {
 
@@ -75,7 +75,7 @@ const asBareArray: Envelope = (rows) => rows;
 const asRecords: Envelope = (rows) => ({ records: rows, total: rows.length });
 
 const schema = {
-  type: 'object-chart',
+  type: 'object-chart' as const,
   chartType: 'bar' as const,
   objectName: 'crm_opportunity',
   xAxisKey: 'stage',
 
@@ -90,8 +90,8 @@ afterEach(() => {
 });
 
 const schema = (drillDown: Record<string, unknown>) => ({
-  type: 'object-chart',
-  chartType: 'bar',
+  type: 'object-chart' as const,
+  chartType: 'bar' as const,
   objectName: 'opportunity',
   xAxisKey: 'stage',
   data: [{ stage: 'won', amount: 42 }],
 
@@ -53,7 +53,7 @@ afterEach(() => {
 });
 
 const schema = {
-  type: 'object-chart',
+  type: 'object-chart' as const,
   chartType: 'bar' as const,
   objectName: 'crm_opportunity',
   xAxisKey: 'stage',
 
@@ -111,8 +111,8 @@ describe('ObjectChart — category option colors (objectui#4106)', () => {
     render(
       <ObjectChart
         schema={{
-          type: 'object-chart',
-          chartType: 'bar',
+          type: 'object-chart' as const,
+          chartType: 'bar' as const,
           objectName: 'opportunity',
           xAxisKey: 'stage',
           data: [
@@ -166,8 +166,8 @@ describe('ObjectChart — category option colors (objectui#4106)', () => {
     render(
       <ObjectChart
         schema={{
-          type: 'object-chart',
-          chartType: 'bar',
+          type: 'object-chart' as const,
+          chartType: 'bar' as const,
           dataset: 'showcase_task_metrics',
           dimensions: ['status'],
           values: ['task_count'],
@@ -209,8 +209,8 @@ describe('ObjectChart — category option colors (objectui#4106)', () => {
     render(
       <ObjectChart
         schema={{
-          type: 'object-chart',
-          chartType: 'bar',
+          type: 'object-chart' as const,
+          chartType: 'bar' as const,
           objectName: 'opportunity',
           xAxisKey: 'stage',
           data: [{ stage: 'won', amount: 42 }],
@@ -255,8 +255,8 @@ describe('ObjectChart — option-color probe routing (objectui#4114)', () => {
   };
 
   const OBJECT_CHART_SCHEMA = {
-    type: 'object-chart',
-    chartType: 'bar',
+    type: 'object-chart' as const,
+    chartType: 'bar' as const,
     objectName: 'opportunity',
     xAxisKey: 'stage',
     data: [{ stage: 'won', amount: 42 }],
@@ -326,8 +326,8 @@ describe('ObjectChart — option-color probe routing (objectui#4114)', () => {
       >
         <ObjectChart
           schema={{
-            type: 'object-chart',
-            chartType: 'bar',
+            type: 'object-chart' as const,
+            chartType: 'bar' as const,
             dataset: 'showcase_task_metrics',
             dimensions: ['status'],
             values: ['task_count'],
 
@@ -7,7 +7,7 @@ import { ComponentRegistry, chartMeasureKey, humanizeLabel, extractRecords, comp
 import { Sheet, SheetContent, SheetHeader, SheetTitle, Dialog, DialogContent, DialogHeader, DialogTitle, RefreshIndicator, Button, ChartSkeleton, DataEmptyState } from '@object-ui/components';
 import { AlertCircle, ArrowUpRight, Inbox } from 'lucide-react';
 import { builtinAggregateLabels, useSafeFieldLabel, useSafeTranslate } from '@object-ui/i18n';
-import type { DrillDownConfig } from '@object-ui/types';
+import type { DrillDownConfig, ObjectChartSchema } from '@object-ui/types';
 
 /**
  * Humanize a snake_case or kebab-case string into Title Case.
@@ -126,14 +126,46 @@ export function resolveChartCategoryField(schema: {
 /** Suffix the previous-window value carries under a compareTo overlay. */
 export const COMPARISON_SUFFIX = '__comparison';
 
+/**
+ * The COLUMN an inline `aggregate` projects its group under — the string every
+ * column lookup in this file needs.
+ *
+ * `groupBy` is a union: a bare field name, or the structured date-bucketing
+ * node `{ field, dateGranularity, alias }` the engine takes, in which case the
+ * projected column is the `alias` (or the `field` it defaults to). This is that
+ * normalisation, hoisted out of the comparison-merge leg below, which has
+ * spelled it inline since the structured node arrived — "Normalise to the
+ * underlying string field name so all column lookups work".
+ *
+ * ⚠️ Module-local on purpose: it is a spelling this file already owned twice,
+ * not a new published export. It is also NOT a fourth answer to "what is the
+ * category axis" — {@link resolveChartCategoryField} remains that one, and it
+ * answers a wider question (it also resolves the spec's `xAxis` through
+ * `normalizeChartSchema`). This one answers only "which column did the
+ * aggregate project the group under", which is what a row lookup needs.
+ */
+function aggregateGroupByKey(
+  aggregate: ObjectChartSchema['aggregate'],
+): string | undefined {
+  const gb = aggregate?.groupBy;
+  if (gb && typeof gb === 'object' && !Array.isArray(gb)) return gb.alias || gb.field;
+  return typeof gb === 'string' ? gb : undefined;
+}
+
 /**
  * Client-side aggregation for fetched records.
  * Groups records by `groupBy` field and applies the aggregation function
  * to the `field` values in each group.
+ *
+ * `function` is optional because the `switch` below already implements that:
+ * an absent (or unknown) function falls through to `sum`. The parameter used to
+ * say `function: string`, which was a claim about the CALLER rather than about
+ * this body — and no caller could satisfy it once `ObjectChartSchema.aggregate`
+ * was declared with the requiredness its own reads have (objectui#7946).
  */
 export function aggregateRecords(
   records: any[],
-  aggregate: { field?: string; function: string; groupBy: string }
+  aggregate: { field?: string; function?: string; groupBy: string }
 ): any[] {
   const { field, function: aggFn, groupBy } = aggregate;
   const valueKey = aggregateValueKey(aggregate);
@@ -358,11 +390,53 @@ export async function resolveGroupByLabels(
 // Re-export extractRecords from @object-ui/core for backward compatibility
 export { extractRecords } from '@object-ui/core';
 
-export const ObjectChart = (props: any) => {
+/**
+ * Props of {@link ObjectChart} — anchored to the published `ObjectChartSchema`
+ * (objectui#7946, maintainer ruling 2026-09-09 option A), as objectui#6576 did
+ * for `ObjectGalleryProps.schema`.
+ *
+ * ## What this replaces, and what it buys
+ *
+ * This component was published as `(props: any)`, so every `schema={{ … }}`
+ * literal handed to it — including the two in `app-shell`'s `ObjectView` — was
+ * type-checked against NOTHING. That is the mechanism that let objectui#7891's
+ * undeclared `config` rung live from the day it was written until someone read
+ * the spec by hand, and it is why the two `as any` casts on those literals
+ * measured INERT: an `any` consumer accepts a cast and its absence alike.
+ *
+ * With the anchor, a wrong VALUE TYPE on a declared key is a compile error at
+ * the producer (`xAxisKey: 42`, `series: 'x'`, `type: 'chart'`, and every
+ * `BaseSchema` member — `visible: 42`). ⚠️ A MISSPELLED key is still accepted:
+ * `BaseSchema` carries `[key: string]: any` (objectui#5155), the same ceiling
+ * objectui#6576 accepted knowingly. `__tests__/ObjectChart.schemaAnchor-7946.test.ts`
+ * pins both halves, the ceiling included, so the anchor is not read as more
+ * than it is.
+ */
+export interface ObjectChartProps {
+  /**
+   * The `object-chart` node — anchored to the exported schema type. Every
+   * `BaseSchema` member is writable, `bind` / `className` / `data` included;
+   * the widget's own keys are declared there.
+   */
+  schema: ObjectChartSchema;
+  /**
+   * Host data source. `any` deliberately, and it is NOT a residue of the shape
+   * this card removed: it is the type `SchemaRendererContext.dataSource`
+   * itself carries, and this component falls back to that context value, so a
+   * narrower declaration here would claim a guarantee the fallback cannot
+   * keep. Narrowing it is a repo-wide `dataSource` interface, not this card.
+   */
+  dataSource?: any;
+  /**
+   * Optional host-owned segment click. When provided (e.g. a dataset widget
+   * that owns precise drill-through), it takes over the chart click and the
+   * widget's own object-drill drawer is suppressed.
+   */
+  onSegmentClick?: (ev: ChartSegmentClickEvent) => void;
+}
+
+export const ObjectChart = (props: ObjectChartProps) => {
   const { schema } = props;
-  // Optional host-owned segment click. When provided (e.g. a dataset widget
-  // that owns precise drill-through), it takes over the chart click and the
-  // widget's own object-drill drawer is suppressed.
   const onSegmentClick: ((ev: ChartSegmentClickEvent) => void) | undefined = props.onSegmentClick;
   const context = useContext(SchemaRendererContext);
   const dataSource = props.dataSource || context?.dataSource;
@@ -616,8 +690,16 @@ export const ObjectChart = (props: any) => {
     if (typeof ds.find === 'function') {
       const results = await ds.find(schema.objectName, { $filter: filterForRun });
       let data = extractRecords(results);
-      if (schema.aggregate && data.length > 0) {
-        data = aggregateRecords(data, schema.aggregate);
+      // `aggregateRecords` buckets on `record[groupBy]`, so it needs the
+      // projected COLUMN, not the raw union: a structured `groupBy` node used
+      // as an index stringifies, and every row lands in one bucket keyed by
+      // that stringification. Declaring the key (objectui#7946) is what made
+      // that reachable to a compiler. When no column resolves there is nothing
+      // to group by, and the chart is already refused for exactly that reason
+      // by the absent-category screen below (objectui#8168).
+      const clientGroupBy = aggregateGroupByKey(schema.aggregate);
+      if (schema.aggregate && clientGroupBy && data.length > 0) {
+        data = aggregateRecords(data, { ...schema.aggregate, groupBy: clientGroupBy });
       }
       return data;
     }
@@ -753,15 +835,23 @@ export const ObjectChart = (props: any) => {
           // Resolve groupBy value→label using field metadata. Now that the
           // merge has happened on raw keys, the resolver can convert the
           // shared groupBy column (e.g. 'closed_won' → 'Closed Won') uniformly.
-          if (groupByField && typeof ds.getObjectSchema === 'function') {
+          // `schema.objectName` joins the guard rather than being asserted:
+          // it is OPTIONAL since ADR-0021 (a chart may bind a `dataset`
+          // instead), and every read in this leg — the metadata fetch and the
+          // per-option label lookup — is keyed by an object NAME. Naming the
+          // precondition is what `props: any` used to hide (objectui#7946);
+          // the leg is on the object-bound path, so it is the shape it already
+          // assumed.
+          if (groupByField && schema.objectName && typeof ds.getObjectSchema === 'function') {
+              const objectName = schema.objectName;
               try {
-                  const objectSchema = await ds.getObjectSchema(schema.objectName);
+                  const objectSchema = await ds.getObjectSchema(objectName);
                   data = await resolveGroupByLabels(
                     data,
                     groupByField,
                     objectSchema,
                     ds,
-                    (value, fallback) => fieldOptionLabel(schema.objectName, groupByField, value, fallback),
+                    (value, fallback) => fieldOptionLabel(objectName, groupByField, value, fallback),
                   );
               } catch {
                   // Schema fetch failed — continue with raw values
@@ -853,7 +943,13 @@ export const ObjectChart = (props: any) => {
   // composes an `object-chart` schema directly, and stays absent from the
   // registry `inputs` below.
   const drillDown = (schema as { drillDown?: DrillDownConfig }).drillDown;
-  const groupByField = schema.aggregate?.groupBy || schema.xAxisKey;
+  // Spelled through the shared normalisation rather than `aggregate?.groupBy`
+  // raw: this value is used as a ROW INDEX (`row[groupByField]`), as a FIELD
+  // NAME (`fieldOptionLabel`) and as a drill-filter key, and a structured
+  // `groupBy` node is none of those. The comparison-merge leg above has always
+  // normalised before its own column lookups; this site did not, and `props:
+  // any` is why nothing said so (objectui#7946).
+  const groupByField = aggregateGroupByKey(schema.aggregate) || schema.xAxisKey;
 
   // Build a label→raw map from the resolved chart data. resolveGroupByLabels
   // stashes the original raw enum/id under `__raw_${groupByField}`. The chart
 
@@ -38,6 +38,7 @@ vi.mock('../ChartRenderer', () => ({
 }));
 
 import { ObjectChart, COMPARISON_SUFFIX } from '../ObjectChart';
+import type { ObjectChartSchema } from '@object-ui/types';
 
 /** ObjectChart probes `/api/v1/meta/object/deal` for option colors; answer it. */
 function installMetaFetchDouble() {
@@ -80,10 +81,14 @@ const makeSource = () => ({
   ]),
 });
 
-const renderChart = (chartType: string, dataSource: unknown, series?: unknown) =>
+// `chartType` takes the anchored union rather than a bare `string`
+// (objectui#7946): `ObjectChartProps.schema` is `ObjectChartSchema`, whose
+// `chartType` is the declared family list, and `type` is required there.
+const renderChart = (chartType: ObjectChartSchema['chartType'], dataSource: unknown, series?: ObjectChartSchema['series']) =>
   render(
     <ObjectChart
       schema={{
+        type: 'object-chart',
         objectName: 'deal',
         chartType,
         aggregate: { field: 'amount', function: 'sum', groupBy: 'stage' },
 
@@ -98,6 +98,7 @@ const renderChart = (compareTo: unknown, dataSource: unknown) =>
   render(
     <ObjectChart
       schema={{
+        type: 'object-chart',
         objectName: 'deal',
         chartType: 'bar',
         aggregate: { field: 'amount', function: 'sum', groupBy: 'stage' },
 
@@ -75,9 +75,10 @@ afterEach(() => {
 
 /** Stable module-level schema — a fresh object per render would move `fetchData`'s OTHER deps. */
 const SCHEMA = {
+  type: 'object-chart' as const,
   objectName: 'deal',
-  chartType: 'bar',
-  aggregate: { field: 'amount', function: 'sum', groupBy: 'stage' },
+  chartType: 'bar' as const,
+  aggregate: { field: 'amount', function: 'sum' as const, groupBy: 'stage' },
   xAxisKey: 'stage',
 };
 
@@ -116,7 +117,13 @@ const settle = (ms = 40) => new Promise((resolve) => setTimeout(resolve, ms));
  */
 async function countFetchesAcrossRerenders(wrap: (chart: React.ReactElement) => React.ReactElement) {
   const src = makeSource();
-  const tree = (tick: number) => wrap(<ObjectChart key="chart" schema={SCHEMA} dataSource={src} tick={tick} />);
+  // The `tick` used to ride ON `ObjectChart` as an undeclared prop, which only
+  // compiled because the component was published as `(props: any)`
+  // (objectui#7946). It never reached the component — it exists to make each
+  // rendered element distinct — so it moves to a wrapper element that really
+  // takes it. What the test measures (re-render count vs fetch count) is
+  // unchanged.
+  const tree = (tick: number) => wrap(<ObjectChart key="chart" schema={SCHEMA} dataSource={src} data-tick={tick} />);
 
   const { rerender } = render(tree(0));
   await waitFor(() => expect(lastSchema?.data?.length).toBe(1));