@inflexa-ai/harness 0.19.2 → 0.21.0

package/dist/contracts/report-blocks.d.ts

@@ -14,12 +14,322 @@
  * rule only when an extra field fails the parse.
  */
 import { z } from "zod";
+/**
+ * The chart vocabulary. The first seven values name one plot form each. The last four are presets of a
+ * scientific plot, and the renderer expands a preset into a composition.
+ */
+declare const ChartTypeSchema: z.ZodEnum<{
+    bar: "bar";
+    line: "line";
+    scatter: "scatter";
+    histogram: "histogram";
+    box: "box";
+    heatmap: "heatmap";
+    pie: "pie";
+    volcano: "volcano";
+    manhattan: "manhattan";
+    ma: "ma";
+    km: "km";
+}>;
+/** The per-row transforms of a channel. Each derived value comes from one cell. */
+declare const ChartTransformSchema: z.ZodEnum<{
+    log10: "log10";
+    neg_log10: "neg_log10";
+    abs: "abs";
+    rank: "rank";
+}>;
+/**
+ * The threshold pair of a preset that classifies its rows.
+ *
+ * One declaration moves the guide lines and the color split together. Thus the split always lands on the
+ * drawn lines, and no second declaration can disagree with the first one.
+ */
+declare const ChartThresholdsSchema: z.ZodObject<{
+    significance: z.ZodNumber;
+    effect: z.ZodNumber;
+}, z.core.$strict>;
+/**
+ * One visual channel: a column name, or a column with a per-row transform.
+ *
+ * The object form carries a column and a transform, and it carries no value. Thus a channel can never
+ * bring a data literal into the chart option.
+ */
+export declare const ChartChannelSchema: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+    column: z.ZodString;
+    transform: z.ZodEnum<{
+        log10: "log10";
+        neg_log10: "neg_log10";
+        abs: "abs";
+        rank: "rank";
+    }>;
+}, z.core.$strict>]>;
+/** The mapping from a data column to a visual channel. Each channel is optional. */
+declare const ChartEncodingSchema: z.ZodObject<{
+    x: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        column: z.ZodString;
+        transform: z.ZodEnum<{
+            log10: "log10";
+            neg_log10: "neg_log10";
+            abs: "abs";
+            rank: "rank";
+        }>;
+    }, z.core.$strict>]>>;
+    y: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        column: z.ZodString;
+        transform: z.ZodEnum<{
+            log10: "log10";
+            neg_log10: "neg_log10";
+            abs: "abs";
+            rank: "rank";
+        }>;
+    }, z.core.$strict>]>>;
+    group: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        column: z.ZodString;
+        transform: z.ZodEnum<{
+            log10: "log10";
+            neg_log10: "neg_log10";
+            abs: "abs";
+            rank: "rank";
+        }>;
+    }, z.core.$strict>]>>;
+    value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        column: z.ZodString;
+        transform: z.ZodEnum<{
+            log10: "log10";
+            neg_log10: "neg_log10";
+            abs: "abs";
+            rank: "rank";
+        }>;
+    }, z.core.$strict>]>>;
+    label: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+/**
+ * One series of a composition: a plot form, its own channels, and an optional legend name.
+ *
+ * A `step` series is a line with the step flag. An `area` series can name a `y0` lower bound, thus a band
+ * between two columns of one row is expressible. The refine holds `y0` to the one form that draws a band,
+ * and the second refine holds the orientation to the one form that carries an arrangement.
+ */
+export declare const ChartSeriesSchema: z.ZodObject<{
+    form: z.ZodEnum<{
+        step: "step";
+        bar: "bar";
+        line: "line";
+        scatter: "scatter";
+        area: "area";
+    }>;
+    encoding: z.ZodObject<{
+        x: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            column: z.ZodString;
+            transform: z.ZodEnum<{
+                log10: "log10";
+                neg_log10: "neg_log10";
+                abs: "abs";
+                rank: "rank";
+            }>;
+        }, z.core.$strict>]>;
+        y: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            column: z.ZodString;
+            transform: z.ZodEnum<{
+                log10: "log10";
+                neg_log10: "neg_log10";
+                abs: "abs";
+                rank: "rank";
+            }>;
+        }, z.core.$strict>]>;
+        y0: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            column: z.ZodString;
+            transform: z.ZodEnum<{
+                log10: "log10";
+                neg_log10: "neg_log10";
+                abs: "abs";
+                rank: "rank";
+            }>;
+        }, z.core.$strict>]>>;
+        group: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            column: z.ZodString;
+            transform: z.ZodEnum<{
+                log10: "log10";
+                neg_log10: "neg_log10";
+                abs: "abs";
+                rank: "rank";
+            }>;
+        }, z.core.$strict>]>>;
+        label: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    name: z.ZodOptional<z.ZodString>;
+    orientation: z.ZodOptional<z.ZodEnum<{
+        vertical: "vertical";
+        horizontal: "horizontal";
+    }>>;
+}, z.core.$strict>;
+/**
+ * One annotation of a composition.
+ *
+ * A reference line and a reference band both carry a declared constant. Such a constant is a guide, and it
+ * is never a plotted value.
+ */
+export declare const ChartAnnotationSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"reference-line">;
+    axis: z.ZodEnum<{
+        x: "x";
+        y: "y";
+    }>;
+    value: z.ZodNumber;
+    label: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"reference-band">;
+    axis: z.ZodEnum<{
+        x: "x";
+        y: "y";
+    }>;
+    from: z.ZodNumber;
+    to: z.ZodNumber;
+    label: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"point-labels">;
+    column: z.ZodString;
+    order: z.ZodEnum<{
+        desc: "desc";
+        asc: "asc";
+    }>;
+    n: z.ZodNumber;
+}, z.core.$strict>], "kind">;
+/** The two axes of a composition. */
+export declare const ChartAxesSchema: z.ZodObject<{
+    x: z.ZodOptional<z.ZodObject<{
+        title: z.ZodOptional<z.ZodString>;
+        scale: z.ZodOptional<z.ZodEnum<{
+            log: "log";
+            linear: "linear";
+        }>>;
+    }, z.core.$strict>>;
+    y: z.ZodOptional<z.ZodObject<{
+        title: z.ZodOptional<z.ZodString>;
+        scale: z.ZodOptional<z.ZodEnum<{
+            log: "log";
+            linear: "linear";
+        }>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+/** The full chart grammar: the series, the annotations, and the axes. Each series reads the one bound table. */
+export declare const ChartCompositionSchema: z.ZodObject<{
+    series: z.ZodArray<z.ZodObject<{
+        form: z.ZodEnum<{
+            step: "step";
+            bar: "bar";
+            line: "line";
+            scatter: "scatter";
+            area: "area";
+        }>;
+        encoding: z.ZodObject<{
+            x: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                column: z.ZodString;
+                transform: z.ZodEnum<{
+                    log10: "log10";
+                    neg_log10: "neg_log10";
+                    abs: "abs";
+                    rank: "rank";
+                }>;
+            }, z.core.$strict>]>;
+            y: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                column: z.ZodString;
+                transform: z.ZodEnum<{
+                    log10: "log10";
+                    neg_log10: "neg_log10";
+                    abs: "abs";
+                    rank: "rank";
+                }>;
+            }, z.core.$strict>]>;
+            y0: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                column: z.ZodString;
+                transform: z.ZodEnum<{
+                    log10: "log10";
+                    neg_log10: "neg_log10";
+                    abs: "abs";
+                    rank: "rank";
+                }>;
+            }, z.core.$strict>]>>;
+            group: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                column: z.ZodString;
+                transform: z.ZodEnum<{
+                    log10: "log10";
+                    neg_log10: "neg_log10";
+                    abs: "abs";
+                    rank: "rank";
+                }>;
+            }, z.core.$strict>]>>;
+            label: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        name: z.ZodOptional<z.ZodString>;
+        orientation: z.ZodOptional<z.ZodEnum<{
+            vertical: "vertical";
+            horizontal: "horizontal";
+        }>>;
+    }, z.core.$strict>>;
+    annotations: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"reference-line">;
+        axis: z.ZodEnum<{
+            x: "x";
+            y: "y";
+        }>;
+        value: z.ZodNumber;
+        label: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"reference-band">;
+        axis: z.ZodEnum<{
+            x: "x";
+            y: "y";
+        }>;
+        from: z.ZodNumber;
+        to: z.ZodNumber;
+        label: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"point-labels">;
+        column: z.ZodString;
+        order: z.ZodEnum<{
+            desc: "desc";
+            asc: "asc";
+        }>;
+        n: z.ZodNumber;
+    }, z.core.$strict>], "kind">>>;
+    axes: z.ZodOptional<z.ZodObject<{
+        x: z.ZodOptional<z.ZodObject<{
+            title: z.ZodOptional<z.ZodString>;
+            scale: z.ZodOptional<z.ZodEnum<{
+                log: "log";
+                linear: "linear";
+            }>>;
+        }, z.core.$strict>>;
+        y: z.ZodOptional<z.ZodObject<{
+            title: z.ZodOptional<z.ZodString>;
+            scale: z.ZodOptional<z.ZodEnum<{
+                log: "log";
+                linear: "linear";
+            }>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+/**
+ * One typed list of a text block: the flag that selects the form, and the items.
+ *
+ * An item is one inline line, and the renderer escapes it as it escapes a paragraph. No item carries
+ * markup, and no item carries a list of its own. A deeper structure composes as a section with blocks.
+ */
+export declare const TextListSchema: z.ZodObject<{
+    ordered: z.ZodBoolean;
+    items: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
 /** Prose with no binding. The absence of a binding field is the rule for this kind. */
 export declare const TextBlockSchema: z.ZodObject<{
     kind: z.ZodLiteral<"text">;
     id: z.ZodString;
     content: z.ZodObject<{
         prose: z.ZodString;
+        list: z.ZodOptional<z.ZodObject<{
+            ordered: z.ZodBoolean;
+            items: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
     }, z.core.$strict>;
 }, z.core.$strict>;
 /** Prose with at least one reference that justifies it. */
@@ -53,7 +363,23 @@ export declare const ClaimBlockSchema: z.ZodObject<{
     }, z.core.$strict>, z.ZodObject<{
         unit: z.ZodOptional<z.ZodString>;
         format: z.ZodOptional<z.ZodString>;
+        rowBound: z.ZodOptional<z.ZodObject<{
+            column: z.ZodString;
+            count: z.ZodNumber;
+            order: z.ZodOptional<z.ZodEnum<{
+                desc: "desc";
+                asc: "asc";
+            }>>;
+        }, 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>;
         path: z.ZodString;
         hash: z.ZodString;
@@ -189,7 +515,23 @@ export declare const TableBlockSchema: z.ZodObject<{
     binding: z.ZodObject<{
         unit: z.ZodOptional<z.ZodString>;
         format: z.ZodOptional<z.ZodString>;
+        rowBound: z.ZodOptional<z.ZodObject<{
+            column: z.ZodString;
+            count: z.ZodNumber;
+            order: z.ZodOptional<z.ZodEnum<{
+                desc: "desc";
+                asc: "asc";
+            }>>;
+        }, 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>;
         path: z.ZodString;
         hash: z.ZodString;
@@ -198,7 +540,16 @@ export declare const TableBlockSchema: z.ZodObject<{
     }, z.core.$strict>;
     caption: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
-/** A whole-table artifact rendered as a chart, with the plot form and the channel mapping. */
+/**
+ * A whole-table artifact rendered as a chart.
+ *
+ * The block carries the quick path or the composition, and never both. The quick path is one chart type
+ * with one encoding. The composition holds the series, the annotations, and the axes. The refine makes the
+ * exactly-one rule a parse failure.
+ *
+ * No member of either path carries a data literal, and no member carries script text. Thus every plotted
+ * value comes from the resolved rows of the bound table.
+ */
 export declare const ChartBlockSchema: z.ZodObject<{
     kind: z.ZodLiteral<"chart">;
     id: z.ZodString;
@@ -206,28 +557,186 @@ export declare const ChartBlockSchema: z.ZodObject<{
     binding: z.ZodObject<{
         unit: z.ZodOptional<z.ZodString>;
         format: z.ZodOptional<z.ZodString>;
+        rowBound: z.ZodOptional<z.ZodObject<{
+            column: z.ZodString;
+            count: z.ZodNumber;
+            order: z.ZodOptional<z.ZodEnum<{
+                desc: "desc";
+                asc: "asc";
+            }>>;
+        }, 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>;
         path: z.ZodString;
         hash: z.ZodString;
         snapshot: z.ZodOptional<z.ZodString>;
         kind: z.ZodLiteral<"artifact-table">;
     }, z.core.$strict>;
-    chartType: z.ZodEnum<{
-        line: "line";
+    chartType: z.ZodOptional<z.ZodEnum<{
         bar: "bar";
+        line: "line";
         scatter: "scatter";
         histogram: "histogram";
         box: "box";
         heatmap: "heatmap";
         pie: "pie";
-    }>;
-    encoding: z.ZodObject<{
-        x: z.ZodOptional<z.ZodString>;
-        y: z.ZodOptional<z.ZodString>;
-        group: z.ZodOptional<z.ZodString>;
-        value: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>;
+        volcano: "volcano";
+        manhattan: "manhattan";
+        ma: "ma";
+        km: "km";
+    }>>;
+    encoding: z.ZodOptional<z.ZodObject<{
+        x: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            column: z.ZodString;
+            transform: z.ZodEnum<{
+                log10: "log10";
+                neg_log10: "neg_log10";
+                abs: "abs";
+                rank: "rank";
+            }>;
+        }, z.core.$strict>]>>;
+        y: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            column: z.ZodString;
+            transform: z.ZodEnum<{
+                log10: "log10";
+                neg_log10: "neg_log10";
+                abs: "abs";
+                rank: "rank";
+            }>;
+        }, z.core.$strict>]>>;
+        group: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            column: z.ZodString;
+            transform: z.ZodEnum<{
+                log10: "log10";
+                neg_log10: "neg_log10";
+                abs: "abs";
+                rank: "rank";
+            }>;
+        }, z.core.$strict>]>>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            column: z.ZodString;
+            transform: z.ZodEnum<{
+                log10: "log10";
+                neg_log10: "neg_log10";
+                abs: "abs";
+                rank: "rank";
+            }>;
+        }, z.core.$strict>]>>;
+        label: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    orientation: z.ZodOptional<z.ZodEnum<{
+        vertical: "vertical";
+        horizontal: "horizontal";
+    }>>;
+    thresholds: z.ZodOptional<z.ZodObject<{
+        significance: z.ZodNumber;
+        effect: z.ZodNumber;
+    }, z.core.$strict>>;
+    composition: z.ZodOptional<z.ZodObject<{
+        series: z.ZodArray<z.ZodObject<{
+            form: z.ZodEnum<{
+                step: "step";
+                bar: "bar";
+                line: "line";
+                scatter: "scatter";
+                area: "area";
+            }>;
+            encoding: z.ZodObject<{
+                x: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                    column: z.ZodString;
+                    transform: z.ZodEnum<{
+                        log10: "log10";
+                        neg_log10: "neg_log10";
+                        abs: "abs";
+                        rank: "rank";
+                    }>;
+                }, z.core.$strict>]>;
+                y: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                    column: z.ZodString;
+                    transform: z.ZodEnum<{
+                        log10: "log10";
+                        neg_log10: "neg_log10";
+                        abs: "abs";
+                        rank: "rank";
+                    }>;
+                }, z.core.$strict>]>;
+                y0: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                    column: z.ZodString;
+                    transform: z.ZodEnum<{
+                        log10: "log10";
+                        neg_log10: "neg_log10";
+                        abs: "abs";
+                        rank: "rank";
+                    }>;
+                }, z.core.$strict>]>>;
+                group: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                    column: z.ZodString;
+                    transform: z.ZodEnum<{
+                        log10: "log10";
+                        neg_log10: "neg_log10";
+                        abs: "abs";
+                        rank: "rank";
+                    }>;
+                }, z.core.$strict>]>>;
+                label: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>;
+            name: z.ZodOptional<z.ZodString>;
+            orientation: z.ZodOptional<z.ZodEnum<{
+                vertical: "vertical";
+                horizontal: "horizontal";
+            }>>;
+        }, z.core.$strict>>;
+        annotations: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"reference-line">;
+            axis: z.ZodEnum<{
+                x: "x";
+                y: "y";
+            }>;
+            value: z.ZodNumber;
+            label: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"reference-band">;
+            axis: z.ZodEnum<{
+                x: "x";
+                y: "y";
+            }>;
+            from: z.ZodNumber;
+            to: z.ZodNumber;
+            label: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"point-labels">;
+            column: z.ZodString;
+            order: z.ZodEnum<{
+                desc: "desc";
+                asc: "asc";
+            }>;
+            n: z.ZodNumber;
+        }, z.core.$strict>], "kind">>>;
+        axes: z.ZodOptional<z.ZodObject<{
+            x: z.ZodOptional<z.ZodObject<{
+                title: z.ZodOptional<z.ZodString>;
+                scale: z.ZodOptional<z.ZodEnum<{
+                    log: "log";
+                    linear: "linear";
+                }>>;
+            }, z.core.$strict>>;
+            y: z.ZodOptional<z.ZodObject<{
+                title: z.ZodOptional<z.ZodString>;
+                scale: z.ZodOptional<z.ZodEnum<{
+                    log: "log";
+                    linear: "linear";
+                }>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
     caption: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
 /** A static image artifact. An image has no per-cell address, thus it is pinned whole-file. */
@@ -278,6 +787,10 @@ export declare const ATOM_BLOCK_SCHEMAS: readonly [z.ZodObject<{
     id: z.ZodString;
     content: z.ZodObject<{
         prose: z.ZodString;
+        list: z.ZodOptional<z.ZodObject<{
+            ordered: z.ZodBoolean;
+            items: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
     }, z.core.$strict>;
 }, z.core.$strict>, z.ZodObject<{
     kind: z.ZodLiteral<"claim">;
@@ -309,7 +822,23 @@ export declare const ATOM_BLOCK_SCHEMAS: readonly [z.ZodObject<{
     }, z.core.$strict>, z.ZodObject<{
         unit: z.ZodOptional<z.ZodString>;
         format: z.ZodOptional<z.ZodString>;
+        rowBound: z.ZodOptional<z.ZodObject<{
+            column: z.ZodString;
+            count: z.ZodNumber;
+            order: z.ZodOptional<z.ZodEnum<{
+                desc: "desc";
+                asc: "asc";
+            }>>;
+        }, 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>;
         path: z.ZodString;
         hash: z.ZodString;
@@ -441,7 +970,23 @@ export declare const ATOM_BLOCK_SCHEMAS: readonly [z.ZodObject<{
     binding: z.ZodObject<{
         unit: z.ZodOptional<z.ZodString>;
         format: z.ZodOptional<z.ZodString>;
+        rowBound: z.ZodOptional<z.ZodObject<{
+            column: z.ZodString;
+            count: z.ZodNumber;
+            order: z.ZodOptional<z.ZodEnum<{
+                desc: "desc";
+                asc: "asc";
+            }>>;
+        }, 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>;
         path: z.ZodString;
         hash: z.ZodString;
@@ -456,28 +1001,186 @@ export declare const ATOM_BLOCK_SCHEMAS: readonly [z.ZodObject<{
     binding: z.ZodObject<{
         unit: z.ZodOptional<z.ZodString>;
         format: z.ZodOptional<z.ZodString>;
+        rowBound: z.ZodOptional<z.ZodObject<{
+            column: z.ZodString;
+            count: z.ZodNumber;
+            order: z.ZodOptional<z.ZodEnum<{
+                desc: "desc";
+                asc: "asc";
+            }>>;
+        }, 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>;
         path: z.ZodString;
         hash: z.ZodString;
         snapshot: z.ZodOptional<z.ZodString>;
         kind: z.ZodLiteral<"artifact-table">;
     }, z.core.$strict>;
-    chartType: z.ZodEnum<{
-        line: "line";
+    chartType: z.ZodOptional<z.ZodEnum<{
         bar: "bar";
+        line: "line";
         scatter: "scatter";
         histogram: "histogram";
         box: "box";
         heatmap: "heatmap";
         pie: "pie";
-    }>;
-    encoding: z.ZodObject<{
-        x: z.ZodOptional<z.ZodString>;
-        y: z.ZodOptional<z.ZodString>;
-        group: z.ZodOptional<z.ZodString>;
-        value: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>;
+        volcano: "volcano";
+        manhattan: "manhattan";
+        ma: "ma";
+        km: "km";
+    }>>;
+    encoding: z.ZodOptional<z.ZodObject<{
+        x: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            column: z.ZodString;
+            transform: z.ZodEnum<{
+                log10: "log10";
+                neg_log10: "neg_log10";
+                abs: "abs";
+                rank: "rank";
+            }>;
+        }, z.core.$strict>]>>;
+        y: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            column: z.ZodString;
+            transform: z.ZodEnum<{
+                log10: "log10";
+                neg_log10: "neg_log10";
+                abs: "abs";
+                rank: "rank";
+            }>;
+        }, z.core.$strict>]>>;
+        group: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            column: z.ZodString;
+            transform: z.ZodEnum<{
+                log10: "log10";
+                neg_log10: "neg_log10";
+                abs: "abs";
+                rank: "rank";
+            }>;
+        }, z.core.$strict>]>>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            column: z.ZodString;
+            transform: z.ZodEnum<{
+                log10: "log10";
+                neg_log10: "neg_log10";
+                abs: "abs";
+                rank: "rank";
+            }>;
+        }, z.core.$strict>]>>;
+        label: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    orientation: z.ZodOptional<z.ZodEnum<{
+        vertical: "vertical";
+        horizontal: "horizontal";
+    }>>;
+    thresholds: z.ZodOptional<z.ZodObject<{
+        significance: z.ZodNumber;
+        effect: z.ZodNumber;
+    }, z.core.$strict>>;
+    composition: z.ZodOptional<z.ZodObject<{
+        series: z.ZodArray<z.ZodObject<{
+            form: z.ZodEnum<{
+                step: "step";
+                bar: "bar";
+                line: "line";
+                scatter: "scatter";
+                area: "area";
+            }>;
+            encoding: z.ZodObject<{
+                x: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                    column: z.ZodString;
+                    transform: z.ZodEnum<{
+                        log10: "log10";
+                        neg_log10: "neg_log10";
+                        abs: "abs";
+                        rank: "rank";
+                    }>;
+                }, z.core.$strict>]>;
+                y: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                    column: z.ZodString;
+                    transform: z.ZodEnum<{
+                        log10: "log10";
+                        neg_log10: "neg_log10";
+                        abs: "abs";
+                        rank: "rank";
+                    }>;
+                }, z.core.$strict>]>;
+                y0: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                    column: z.ZodString;
+                    transform: z.ZodEnum<{
+                        log10: "log10";
+                        neg_log10: "neg_log10";
+                        abs: "abs";
+                        rank: "rank";
+                    }>;
+                }, z.core.$strict>]>>;
+                group: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                    column: z.ZodString;
+                    transform: z.ZodEnum<{
+                        log10: "log10";
+                        neg_log10: "neg_log10";
+                        abs: "abs";
+                        rank: "rank";
+                    }>;
+                }, z.core.$strict>]>>;
+                label: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>;
+            name: z.ZodOptional<z.ZodString>;
+            orientation: z.ZodOptional<z.ZodEnum<{
+                vertical: "vertical";
+                horizontal: "horizontal";
+            }>>;
+        }, z.core.$strict>>;
+        annotations: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"reference-line">;
+            axis: z.ZodEnum<{
+                x: "x";
+                y: "y";
+            }>;
+            value: z.ZodNumber;
+            label: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"reference-band">;
+            axis: z.ZodEnum<{
+                x: "x";
+                y: "y";
+            }>;
+            from: z.ZodNumber;
+            to: z.ZodNumber;
+            label: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"point-labels">;
+            column: z.ZodString;
+            order: z.ZodEnum<{
+                desc: "desc";
+                asc: "asc";
+            }>;
+            n: z.ZodNumber;
+        }, z.core.$strict>], "kind">>>;
+        axes: z.ZodOptional<z.ZodObject<{
+            x: z.ZodOptional<z.ZodObject<{
+                title: z.ZodOptional<z.ZodString>;
+                scale: z.ZodOptional<z.ZodEnum<{
+                    log: "log";
+                    linear: "linear";
+                }>>;
+            }, z.core.$strict>>;
+            y: z.ZodOptional<z.ZodObject<{
+                title: z.ZodOptional<z.ZodString>;
+                scale: z.ZodOptional<z.ZodEnum<{
+                    log: "log";
+                    linear: "linear";
+                }>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
     caption: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>, z.ZodObject<{
     kind: z.ZodLiteral<"figure">;
@@ -554,6 +1257,26 @@ export declare const ReportDocumentSchema: z.ZodObject<{
         blocks: z.ZodLazy<z.ZodArray<z.ZodType<Block, unknown, z.core.$ZodTypeInternals<Block, unknown>>>>;
     }, z.core.$strict>>;
 }, z.core.$strict>;
+/**
+ * The column that one channel names.
+ *
+ * A transform rides beside the column and never in place of it, thus the two channel forms name their
+ * column the same way. The walk, the preset expansion, and the derivation all read the name through this
+ * one function.
+ */
+export declare function channelColumn(channel: ChartChannel): string;
+/** The transform of one channel, or `undefined` when the channel names a plain column. */
+export declare function channelTransform(channel: ChartChannel): ChartTransform | undefined;
+export type ChartChannel = z.infer<typeof ChartChannelSchema>;
+export type ChartTransform = z.infer<typeof ChartTransformSchema>;
+export type ChartEncoding = z.infer<typeof ChartEncodingSchema>;
+export type ChartSeries = z.infer<typeof ChartSeriesSchema>;
+export type ChartAnnotation = z.infer<typeof ChartAnnotationSchema>;
+export type ChartAxes = z.infer<typeof ChartAxesSchema>;
+export type ChartThresholds = z.infer<typeof ChartThresholdsSchema>;
+export type ChartComposition = z.infer<typeof ChartCompositionSchema>;
+export type ChartType = z.infer<typeof ChartTypeSchema>;
+export type TextList = z.infer<typeof TextListSchema>;
 export type TextBlock = z.infer<typeof TextBlockSchema>;
 export type ClaimBlock = z.infer<typeof ClaimBlockSchema>;
 export type MetricBlock = z.infer<typeof MetricBlockSchema>;
@@ -562,3 +1285,4 @@ export type ChartBlock = z.infer<typeof ChartBlockSchema>;
 export type FigureBlock = z.infer<typeof FigureBlockSchema>;
 export type CitationBlock = z.infer<typeof CitationBlockSchema>;
 export type ReportDocument = z.infer<typeof ReportDocumentSchema>;
+export {};