@inflexa-ai/harness 0.42.2 → 0.43.1

package/dist/report-model/authoring-grammar.d.ts

@@ -251,6 +251,123 @@ declare const AUTHORING_ATOM_SCHEMAS: readonly [z.ZodObject<{
         run: z.ZodOptional<z.ZodString>;
         snapshot: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>;
+    statistics: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        value: z.ZodObject<{
+            format: z.ZodOptional<z.ZodString>;
+            kind: z.ZodLiteral<"artifact-value">;
+            path: z.ZodString;
+            unit: z.ZodOptional<z.ZodString>;
+            locator: z.ZodObject<{
+                column: z.ZodString;
+                rowFilter: z.ZodOptional<z.ZodObject<{
+                    column: z.ZodString;
+                    op: z.ZodLiteral<"eq">;
+                    value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+                }, z.core.$strict>>;
+                row: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>;
+            assert: z.ZodOptional<z.ZodObject<{
+                value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+                tolerance: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>>;
+            run: z.ZodOptional<z.ZodString>;
+            snapshot: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>>;
+    track: z.ZodOptional<z.ZodObject<{
+        start: z.ZodString;
+        end: z.ZodString;
+        label: z.ZodString;
+        length: z.ZodOptional<z.ZodString>;
+        binding: z.ZodObject<{
+            format: z.ZodOptional<z.ZodString>;
+            kind: z.ZodLiteral<"artifact-table">;
+            path: z.ZodString;
+            unit: z.ZodOptional<z.ZodString>;
+            rowBound: z.ZodOptional<z.ZodObject<{
+                column: z.ZodString;
+                count: z.ZodNumber;
+                order: z.ZodOptional<z.ZodEnum<{
+                    asc: "asc";
+                    desc: "desc";
+                }>>;
+            }, z.core.$strict>>;
+            columns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            columnMeanings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<{
+                count: "count";
+                identifier: "identifier";
+                category: "category";
+                "p-value": "p-value";
+                effect: "effect";
+            }>>>;
+            columnLabels: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            run: z.ZodOptional<z.ZodString>;
+            snapshot: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    trees: z.ZodOptional<z.ZodObject<{
+        x: z.ZodOptional<z.ZodObject<{
+            parent: z.ZodString;
+            child: z.ZodString;
+            height: z.ZodString;
+            binding: z.ZodObject<{
+                format: z.ZodOptional<z.ZodString>;
+                kind: z.ZodLiteral<"artifact-table">;
+                path: z.ZodString;
+                unit: z.ZodOptional<z.ZodString>;
+                rowBound: z.ZodOptional<z.ZodObject<{
+                    column: z.ZodString;
+                    count: z.ZodNumber;
+                    order: z.ZodOptional<z.ZodEnum<{
+                        asc: "asc";
+                        desc: "desc";
+                    }>>;
+                }, z.core.$strict>>;
+                columns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                columnMeanings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<{
+                    count: "count";
+                    identifier: "identifier";
+                    category: "category";
+                    "p-value": "p-value";
+                    effect: "effect";
+                }>>>;
+                columnLabels: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                run: z.ZodOptional<z.ZodString>;
+                snapshot: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        y: z.ZodOptional<z.ZodObject<{
+            parent: z.ZodString;
+            child: z.ZodString;
+            height: z.ZodString;
+            binding: z.ZodObject<{
+                format: z.ZodOptional<z.ZodString>;
+                kind: z.ZodLiteral<"artifact-table">;
+                path: z.ZodString;
+                unit: z.ZodOptional<z.ZodString>;
+                rowBound: z.ZodOptional<z.ZodObject<{
+                    column: z.ZodString;
+                    count: z.ZodNumber;
+                    order: z.ZodOptional<z.ZodEnum<{
+                        asc: "asc";
+                        desc: "desc";
+                    }>>;
+                }, z.core.$strict>>;
+                columns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                columnMeanings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<{
+                    count: "count";
+                    identifier: "identifier";
+                    category: "category";
+                    "p-value": "p-value";
+                    effect: "effect";
+                }>>>;
+                columnLabels: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                run: z.ZodOptional<z.ZodString>;
+                snapshot: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
     kind: z.ZodLiteral<"chart">;
     id: z.ZodString;
     title: z.ZodOptional<z.ZodString>;
@@ -262,49 +379,240 @@ declare const AUTHORING_ATOM_SCHEMAS: readonly [z.ZodObject<{
         box: "box";
         heatmap: "heatmap";
         pie: "pie";
+        violin: "violin";
+        "stacked-bar": "stacked-bar";
+        "normalized-bar": "normalized-bar";
+        radar: "radar";
         volcano: "volcano";
         manhattan: "manhattan";
         ma: "ma";
         km: "km";
+        pca: "pca";
+        embedding: "embedding";
+        dotplot: "dotplot";
+        forest: "forest";
+        roc: "roc";
+        qq: "qq";
+        gsea: "gsea";
+        oncoprint: "oncoprint";
+        lollipop: "lollipop";
+        upset: "upset";
+        sankey: "sankey";
+        locuszoom: "locuszoom";
     }>>;
     encoding: z.ZodOptional<z.ZodObject<{
         x: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
             column: z.ZodString;
-            transform: z.ZodEnum<{
+            transform: z.ZodOptional<z.ZodEnum<{
                 log10: "log10";
                 neg_log10: "neg_log10";
                 abs: "abs";
                 rank: "rank";
-            }>;
+            }>>;
+            orderBy: z.ZodOptional<z.ZodString>;
+            order: z.ZodOptional<z.ZodEnum<{
+                asc: "asc";
+                desc: "desc";
+            }>>;
         }, z.core.$strict>]>>;
         y: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
             column: z.ZodString;
-            transform: z.ZodEnum<{
+            transform: z.ZodOptional<z.ZodEnum<{
                 log10: "log10";
                 neg_log10: "neg_log10";
                 abs: "abs";
                 rank: "rank";
-            }>;
+            }>>;
+            orderBy: z.ZodOptional<z.ZodString>;
+            order: z.ZodOptional<z.ZodEnum<{
+                asc: "asc";
+                desc: "desc";
+            }>>;
         }, z.core.$strict>]>>;
         group: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
             column: z.ZodString;
-            transform: z.ZodEnum<{
+            transform: z.ZodOptional<z.ZodEnum<{
                 log10: "log10";
                 neg_log10: "neg_log10";
                 abs: "abs";
                 rank: "rank";
-            }>;
+            }>>;
+            orderBy: z.ZodOptional<z.ZodString>;
+            order: z.ZodOptional<z.ZodEnum<{
+                asc: "asc";
+                desc: "desc";
+            }>>;
         }, z.core.$strict>]>>;
         value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
             column: z.ZodString;
-            transform: z.ZodEnum<{
+            transform: z.ZodOptional<z.ZodEnum<{
                 log10: "log10";
                 neg_log10: "neg_log10";
                 abs: "abs";
                 rank: "rank";
-            }>;
+            }>>;
+            orderBy: z.ZodOptional<z.ZodString>;
+            order: z.ZodOptional<z.ZodEnum<{
+                asc: "asc";
+                desc: "desc";
+            }>>;
         }, z.core.$strict>]>>;
         label: z.ZodOptional<z.ZodString>;
+        color: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            column: z.ZodString;
+            transform: z.ZodOptional<z.ZodEnum<{
+                log10: "log10";
+                neg_log10: "neg_log10";
+                abs: "abs";
+                rank: "rank";
+            }>>;
+            orderBy: z.ZodOptional<z.ZodString>;
+            order: z.ZodOptional<z.ZodEnum<{
+                asc: "asc";
+                desc: "desc";
+            }>>;
+        }, z.core.$strict>]>>;
+        size: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            column: z.ZodString;
+            transform: z.ZodOptional<z.ZodEnum<{
+                log10: "log10";
+                neg_log10: "neg_log10";
+                abs: "abs";
+                rank: "rank";
+            }>>;
+            orderBy: z.ZodOptional<z.ZodString>;
+            order: z.ZodOptional<z.ZodEnum<{
+                asc: "asc";
+                desc: "desc";
+            }>>;
+        }, z.core.$strict>]>>;
+        low: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            column: z.ZodString;
+            transform: z.ZodOptional<z.ZodEnum<{
+                log10: "log10";
+                neg_log10: "neg_log10";
+                abs: "abs";
+                rank: "rank";
+            }>>;
+            orderBy: z.ZodOptional<z.ZodString>;
+            order: z.ZodOptional<z.ZodEnum<{
+                asc: "asc";
+                desc: "desc";
+            }>>;
+        }, z.core.$strict>]>>;
+        high: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            column: z.ZodString;
+            transform: z.ZodOptional<z.ZodEnum<{
+                log10: "log10";
+                neg_log10: "neg_log10";
+                abs: "abs";
+                rank: "rank";
+            }>>;
+            orderBy: z.ZodOptional<z.ZodString>;
+            order: z.ZodOptional<z.ZodEnum<{
+                asc: "asc";
+                desc: "desc";
+            }>>;
+        }, z.core.$strict>]>>;
+        facet: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            column: z.ZodString;
+            transform: z.ZodOptional<z.ZodEnum<{
+                log10: "log10";
+                neg_log10: "neg_log10";
+                abs: "abs";
+                rank: "rank";
+            }>>;
+            orderBy: z.ZodOptional<z.ZodString>;
+            order: z.ZodOptional<z.ZodEnum<{
+                asc: "asc";
+                desc: "desc";
+            }>>;
+        }, z.core.$strict>]>>;
+        shape: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            column: z.ZodString;
+            transform: z.ZodOptional<z.ZodEnum<{
+                log10: "log10";
+                neg_log10: "neg_log10";
+                abs: "abs";
+                rank: "rank";
+            }>>;
+            orderBy: z.ZodOptional<z.ZodString>;
+            order: z.ZodOptional<z.ZodEnum<{
+                asc: "asc";
+                desc: "desc";
+            }>>;
+        }, z.core.$strict>]>>;
+        p: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            column: z.ZodString;
+            transform: z.ZodOptional<z.ZodEnum<{
+                log10: "log10";
+                neg_log10: "neg_log10";
+                abs: "abs";
+                rank: "rank";
+            }>>;
+            orderBy: z.ZodOptional<z.ZodString>;
+            order: z.ZodOptional<z.ZodEnum<{
+                asc: "asc";
+                desc: "desc";
+            }>>;
+        }, z.core.$strict>]>>;
+        censor: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            column: z.ZodString;
+            transform: z.ZodOptional<z.ZodEnum<{
+                log10: "log10";
+                neg_log10: "neg_log10";
+                abs: "abs";
+                rank: "rank";
+            }>>;
+            orderBy: z.ZodOptional<z.ZodString>;
+            order: z.ZodOptional<z.ZodEnum<{
+                asc: "asc";
+                desc: "desc";
+            }>>;
+        }, z.core.$strict>]>>;
+        risk: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            column: z.ZodString;
+            transform: z.ZodOptional<z.ZodEnum<{
+                log10: "log10";
+                neg_log10: "neg_log10";
+                abs: "abs";
+                rank: "rank";
+            }>>;
+            orderBy: z.ZodOptional<z.ZodString>;
+            order: z.ZodOptional<z.ZodEnum<{
+                asc: "asc";
+                desc: "desc";
+            }>>;
+        }, z.core.$strict>]>>;
+        hit: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            column: z.ZodString;
+            transform: z.ZodOptional<z.ZodEnum<{
+                log10: "log10";
+                neg_log10: "neg_log10";
+                abs: "abs";
+                rank: "rank";
+            }>>;
+            orderBy: z.ZodOptional<z.ZodString>;
+            order: z.ZodOptional<z.ZodEnum<{
+                asc: "asc";
+                desc: "desc";
+            }>>;
+        }, z.core.$strict>]>>;
+        metric: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            column: z.ZodString;
+            transform: z.ZodOptional<z.ZodEnum<{
+                log10: "log10";
+                neg_log10: "neg_log10";
+                abs: "abs";
+                rank: "rank";
+            }>>;
+            orderBy: z.ZodOptional<z.ZodString>;
+            order: z.ZodOptional<z.ZodEnum<{
+                asc: "asc";
+                desc: "desc";
+            }>>;
+        }, z.core.$strict>]>>;
+        tracks: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>>;
     orientation: z.ZodOptional<z.ZodEnum<{
         vertical: "vertical";
@@ -312,7 +620,7 @@ declare const AUTHORING_ATOM_SCHEMAS: readonly [z.ZodObject<{
     }>>;
     thresholds: z.ZodOptional<z.ZodObject<{
         significance: z.ZodNumber;
-        effect: z.ZodNumber;
+        effect: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strict>>;
     composition: z.ZodOptional<z.ZodObject<{
         series: z.ZodArray<z.ZodObject<{
@@ -326,41 +634,117 @@ declare const AUTHORING_ATOM_SCHEMAS: readonly [z.ZodObject<{
             encoding: z.ZodObject<{
                 x: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
                     column: z.ZodString;
-                    transform: z.ZodEnum<{
+                    transform: z.ZodOptional<z.ZodEnum<{
                         log10: "log10";
                         neg_log10: "neg_log10";
                         abs: "abs";
                         rank: "rank";
-                    }>;
+                    }>>;
+                    orderBy: z.ZodOptional<z.ZodString>;
+                    order: z.ZodOptional<z.ZodEnum<{
+                        asc: "asc";
+                        desc: "desc";
+                    }>>;
                 }, z.core.$strict>]>;
                 y: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
                     column: z.ZodString;
-                    transform: z.ZodEnum<{
+                    transform: z.ZodOptional<z.ZodEnum<{
                         log10: "log10";
                         neg_log10: "neg_log10";
                         abs: "abs";
                         rank: "rank";
-                    }>;
+                    }>>;
+                    orderBy: z.ZodOptional<z.ZodString>;
+                    order: z.ZodOptional<z.ZodEnum<{
+                        asc: "asc";
+                        desc: "desc";
+                    }>>;
                 }, z.core.$strict>]>;
                 y0: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
                     column: z.ZodString;
-                    transform: z.ZodEnum<{
+                    transform: z.ZodOptional<z.ZodEnum<{
                         log10: "log10";
                         neg_log10: "neg_log10";
                         abs: "abs";
                         rank: "rank";
-                    }>;
+                    }>>;
+                    orderBy: z.ZodOptional<z.ZodString>;
+                    order: z.ZodOptional<z.ZodEnum<{
+                        asc: "asc";
+                        desc: "desc";
+                    }>>;
                 }, z.core.$strict>]>>;
                 group: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
                     column: z.ZodString;
-                    transform: z.ZodEnum<{
+                    transform: z.ZodOptional<z.ZodEnum<{
                         log10: "log10";
                         neg_log10: "neg_log10";
                         abs: "abs";
                         rank: "rank";
-                    }>;
+                    }>>;
+                    orderBy: z.ZodOptional<z.ZodString>;
+                    order: z.ZodOptional<z.ZodEnum<{
+                        asc: "asc";
+                        desc: "desc";
+                    }>>;
                 }, z.core.$strict>]>>;
                 label: z.ZodOptional<z.ZodString>;
+                color: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                    column: z.ZodString;
+                    transform: z.ZodOptional<z.ZodEnum<{
+                        log10: "log10";
+                        neg_log10: "neg_log10";
+                        abs: "abs";
+                        rank: "rank";
+                    }>>;
+                    orderBy: z.ZodOptional<z.ZodString>;
+                    order: z.ZodOptional<z.ZodEnum<{
+                        asc: "asc";
+                        desc: "desc";
+                    }>>;
+                }, z.core.$strict>]>>;
+                size: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                    column: z.ZodString;
+                    transform: z.ZodOptional<z.ZodEnum<{
+                        log10: "log10";
+                        neg_log10: "neg_log10";
+                        abs: "abs";
+                        rank: "rank";
+                    }>>;
+                    orderBy: z.ZodOptional<z.ZodString>;
+                    order: z.ZodOptional<z.ZodEnum<{
+                        asc: "asc";
+                        desc: "desc";
+                    }>>;
+                }, z.core.$strict>]>>;
+                low: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                    column: z.ZodString;
+                    transform: z.ZodOptional<z.ZodEnum<{
+                        log10: "log10";
+                        neg_log10: "neg_log10";
+                        abs: "abs";
+                        rank: "rank";
+                    }>>;
+                    orderBy: z.ZodOptional<z.ZodString>;
+                    order: z.ZodOptional<z.ZodEnum<{
+                        asc: "asc";
+                        desc: "desc";
+                    }>>;
+                }, z.core.$strict>]>>;
+                high: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                    column: z.ZodString;
+                    transform: z.ZodOptional<z.ZodEnum<{
+                        log10: "log10";
+                        neg_log10: "neg_log10";
+                        abs: "abs";
+                        rank: "rank";
+                    }>>;
+                    orderBy: z.ZodOptional<z.ZodString>;
+                    order: z.ZodOptional<z.ZodEnum<{
+                        asc: "asc";
+                        desc: "desc";
+                    }>>;
+                }, z.core.$strict>]>>;
             }, z.core.$strict>;
             name: z.ZodOptional<z.ZodString>;
             orientation: z.ZodOptional<z.ZodEnum<{
@@ -410,7 +794,22 @@ declare const AUTHORING_ATOM_SCHEMAS: readonly [z.ZodObject<{
                 }>>;
             }, z.core.$strict>>;
         }, z.core.$strict>>;
+        facet: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            column: z.ZodString;
+            transform: z.ZodOptional<z.ZodEnum<{
+                log10: "log10";
+                neg_log10: "neg_log10";
+                abs: "abs";
+                rank: "rank";
+            }>>;
+            orderBy: z.ZodOptional<z.ZodString>;
+            order: z.ZodOptional<z.ZodEnum<{
+                asc: "asc";
+                desc: "desc";
+            }>>;
+        }, z.core.$strict>]>>;
     }, z.core.$strict>>;
+    focus: z.ZodOptional<z.ZodArray<z.ZodString>>;
     caption: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>, z.ZodObject<{
     kind: z.ZodLiteral<"figure">;

package/dist/report-model/authoring-grammar.js

@@ -14,7 +14,7 @@
  * payload, thus the grounding and the resolution read the same pin as before.
  */
 import { z } from "zod";
-import { ChartBlockSchema, CitationBlockSchema, ClaimBlockSchema, FigureBlockSchema, MetricBlockSchema, TableBlockSchema, TextBlockSchema, } from "../contracts/report-blocks.js";
+import { ChartBlockSchema, ChartStatisticSchema, ChartTrackSchema, ChartTreeSchema, CitationBlockSchema, ClaimBlockSchema, FigureBlockSchema, MetricBlockSchema, TableBlockSchema, TextBlockSchema, } from "../contracts/report-blocks.js";
 import { ArtifactFileReferenceSchema, ArtifactTableReferenceSchema, ArtifactValueReferenceSchema, CitationReferenceSchema, DerivationReferenceSchema, } from "../contracts/report-reference.js";
 /** A reference to one scalar value inside an artifact, by the path of the artifact and a locator. */
 const AuthoringValueReferenceSchema = ArtifactValueReferenceSchema.omit({ hash: true });
@@ -39,17 +39,38 @@ const AuthoringReferenceSchema = z.discriminatedUnion("kind", [
 ]);
 /** The references of the authoring surface that resolve to one scalar value. */
 const AuthoringScalarReferenceSchema = z.discriminatedUnion("kind", [AuthoringValueReferenceSchema, AuthoringDerivationReferenceSchema]);
+/** The tree of one heatmap axis on the authoring surface: the contract tree with an authoring binding. */
+function authoringTree() {
+    return ChartTreeSchema.extend({ binding: AuthoringTableReferenceSchema.describe(ChartTreeSchema.shape.binding.description ?? "") });
+}
 /**
  * The chart block of the authoring surface.
  *
  * A chart carries a rule over its own fields, and a schema with a rule refuses a replacement of one field.
- * Thus this schema spreads the fields of the contract chart, and it replaces the binding. The rule itself
- * stays out: the core parses each payload with the draft grammar, and that grammar carries the rule. This
- * schema publishes the shape, and it types the read.
+ * Thus this schema spreads the fields of the contract chart, and it replaces each field that carries a pin:
+ * the binding, the value of each statistic, the binding of the track, and the binding of each tree. The rule itself stays out: the core
+ * parses each payload with the draft grammar, and that grammar carries the rule. This schema publishes the
+ * shape, and it types the read.
  */
 const AuthoringChartBlockSchema = z.strictObject({
     ...ChartBlockSchema.shape,
     binding: AuthoringTableReferenceSchema.describe("The whole-table artifact to plot."),
+    statistics: z
+        .array(ChartStatisticSchema.extend({ value: AuthoringValueReferenceSchema.describe(ChartStatisticSchema.shape.value.description ?? "") }))
+        .min(1)
+        .max(4)
+        .optional()
+        .describe(ChartBlockSchema.shape.statistics.description ?? ""),
+    track: ChartTrackSchema.extend({ binding: AuthoringTableReferenceSchema.describe(ChartTrackSchema.shape.binding.description ?? "") })
+        .optional()
+        .describe(ChartBlockSchema.shape.track.description ?? ""),
+    trees: z
+        .strictObject({
+        x: authoringTree().optional().describe("The tree of the `x` categories. It draws above the matrix and above the tracks."),
+        y: authoringTree().optional().describe("The tree of the `y` categories. It draws at the left of the row names."),
+    })
+        .optional()
+        .describe(ChartBlockSchema.shape.trees.description ?? ""),
 });
 /**
  * The seven atoms of the authoring surface.

package/dist/report-model/block-walk.d.ts

@@ -18,17 +18,33 @@ import type { Reference } from "../contracts/report-reference.js";
 import type { DraftBlock } from "./draft.js";
 /** A block of a finished report, or a block of a draft. The atoms are the same shape in both. */
 export type AnyBlock = Block | DraftBlock;
+/**
+ * The place of one reference inside a chart block: the binding, the track, the tree of one axis, or the
+ * statistic at one index of the block, for example `statistic:0`.
+ */
+export type ChartSlot = "binding" | "track" | TreeSlot | `statistic:${number}`;
+/** The slot of the tree of one category axis of a chart. */
+export type TreeSlot = "tree:x" | "tree:y";
+/** The slot of the tree of one axis. */
+export declare function treeSlot(axis: "x" | "y"): TreeSlot;
+/** The slot of the statistic at one index of a chart block. */
+export declare function statisticSlot(index: number): ChartSlot;
 /**
  * One reference that the walk met, tied to the block that carries it.
  *
- * `encodingColumns` is present for a `chart` only. A chart names its columns as free strings, thus the
- * names must be matched against the table that the binding resolves to. Nothing else can catch a chart
- * that plots a column which does not exist. The field carries every column that the chart grammar names,
- * thus the structural tier and the value tier match the same set.
+ * `slot` is present for a `chart` only, because a chart is the one kind that binds more than one reference of
+ * different roles. A failure names the block and the slot, and the resolution files each value under its slot.
+ *
+ * `encodingColumns` is present for the binding, the track, and each tree of a `chart`. A chart names its columns
+ * as free strings, thus the names must be matched against the table that the reference resolves to. Nothing
+ * else can catch a chart that plots a column which does not exist. The binding carries every column that the
+ * chart grammar names, and the track and each tree carry each column that they name, thus the structural tier
+ * and the value tier match the same set.
  */
 export interface CollectedReference {
     blockId: string;
     reference: Reference;
+    slot?: ChartSlot;
     encodingColumns?: string[];
 }
 /** An advisory warning about the prose of one block. The detail is the numeral that the prose carries. */