@inflexa-ai/harness 0.17.0 → 0.19.0

package/dist/contracts/organ-system.d.ts

@@ -0,0 +1,49 @@
+/**
+ * The canonical organ-system vocabulary.
+ *
+ * This is the ONLY organ vocabulary in the package. Per-organ evidence is
+ * joined by equality on these tokens, so a second enumeration — even a
+ * "temporary" or deprecated one — reintroduces the string matching this
+ * exists to remove. Producers resolve external and model-supplied organ
+ * names onto these tokens at their own boundary.
+ *
+ * Membership is anatomical, with one deliberate exception: `oncology` is a
+ * therapeutic area rather than an organ system, so grouping by it does not
+ * denote a site. It is retained because malignancy signals — MedDRA neoplasm
+ * SOC terms, and regulatory findings matched on malignancy keywords — have
+ * no other channel to arrive on, and dropping the member would discard them.
+ * Known debt: the honest fix is a separate non-organ signal channel.
+ */
+import { z } from "zod";
+export declare const ORGAN_SYSTEMS: readonly ["cardiac", "vascular", "hepatic", "renal", "cns", "pns", "gi", "pancreas", "endocrine_thyroid", "metabolic", "hematologic", "immune", "respiratory", "reproductive", "musculoskeletal", "dermatologic", "ocular", "oncology"];
+export declare const OrganSystemSchema: z.ZodEnum<{
+    hematologic: "hematologic";
+    metabolic: "metabolic";
+    immune: "immune";
+    hepatic: "hepatic";
+    musculoskeletal: "musculoskeletal";
+    cns: "cns";
+    renal: "renal";
+    reproductive: "reproductive";
+    respiratory: "respiratory";
+    cardiac: "cardiac";
+    vascular: "vascular";
+    pns: "pns";
+    gi: "gi";
+    pancreas: "pancreas";
+    endocrine_thyroid: "endocrine_thyroid";
+    dermatologic: "dermatologic";
+    ocular: "ocular";
+    oncology: "oncology";
+}>;
+export type OrganSystem = (typeof ORGAN_SYSTEMS)[number];
+/**
+ * Reader-facing prose for each canonical token.
+ *
+ * Narrative surfaces (agent voice, rendered dossiers) read these; structured
+ * fields always carry the token. Keeping the prose a projection of the token
+ * — rather than its own list — is what stops the two drifting into the
+ * separate vocabularies this module replaces.
+ */
+export declare const ORGAN_SYSTEM_LABELS: Record<OrganSystem, string>;
+export declare const organSystemLabel: (organ: OrganSystem) => string;

package/dist/contracts/organ-system.js

@@ -0,0 +1,67 @@
+/**
+ * The canonical organ-system vocabulary.
+ *
+ * This is the ONLY organ vocabulary in the package. Per-organ evidence is
+ * joined by equality on these tokens, so a second enumeration — even a
+ * "temporary" or deprecated one — reintroduces the string matching this
+ * exists to remove. Producers resolve external and model-supplied organ
+ * names onto these tokens at their own boundary.
+ *
+ * Membership is anatomical, with one deliberate exception: `oncology` is a
+ * therapeutic area rather than an organ system, so grouping by it does not
+ * denote a site. It is retained because malignancy signals — MedDRA neoplasm
+ * SOC terms, and regulatory findings matched on malignancy keywords — have
+ * no other channel to arrive on, and dropping the member would discard them.
+ * Known debt: the honest fix is a separate non-organ signal channel.
+ */
+import { z } from "zod";
+export const ORGAN_SYSTEMS = [
+    "cardiac",
+    "vascular",
+    "hepatic",
+    "renal",
+    "cns",
+    "pns",
+    "gi",
+    "pancreas",
+    "endocrine_thyroid",
+    "metabolic",
+    "hematologic",
+    "immune",
+    "respiratory",
+    "reproductive",
+    "musculoskeletal",
+    "dermatologic",
+    "ocular",
+    "oncology",
+];
+export const OrganSystemSchema = z.enum(ORGAN_SYSTEMS);
+/**
+ * Reader-facing prose for each canonical token.
+ *
+ * Narrative surfaces (agent voice, rendered dossiers) read these; structured
+ * fields always carry the token. Keeping the prose a projection of the token
+ * — rather than its own list — is what stops the two drifting into the
+ * separate vocabularies this module replaces.
+ */
+export const ORGAN_SYSTEM_LABELS = {
+    cardiac: "cardiac",
+    vascular: "vascular",
+    hepatic: "hepatobiliary",
+    renal: "renal",
+    cns: "central nervous system",
+    pns: "peripheral nervous system",
+    gi: "gastrointestinal",
+    pancreas: "pancreatic",
+    endocrine_thyroid: "endocrine (thyroid)",
+    metabolic: "metabolic",
+    hematologic: "haematologic",
+    immune: "immunologic",
+    respiratory: "respiratory",
+    reproductive: "reproductive",
+    musculoskeletal: "musculoskeletal",
+    dermatologic: "dermatologic",
+    ocular: "ocular",
+    oncology: "oncology",
+};
+export const organSystemLabel = (organ) => ORGAN_SYSTEM_LABELS[organ];

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

@@ -0,0 +1,564 @@
+/**
+ * The composable block tree of a report.
+ *
+ * A block is one of eight kinds. The shape of each kind carries its grammar. A `text` block has no
+ * binding field, thus an unbound claim is unrepresentable. A `metric` value slot admits one scalar
+ * reference only, thus a numeric literal cannot sit there. No atom holds a child-block array, thus a
+ * chart inside a metric is unrepresentable. The grammar is the shape, and not a separate pass.
+ *
+ * The tree is recursive: a `section` holds child blocks, and a child can be another section.
+ *
+ * Every object schema here and in the reference module is strict. A strict object makes an extra field
+ * a parse failure, and not a field that the parser strips in silence. Thus a forbidden field, such as a
+ * binding on a `text` block or a child-block array on an atom, is rejected. The absence of a field is a
+ * rule only when an extra field fails the parse.
+ */
+import { z } from "zod";
+/** 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;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+/** Prose with at least one reference that justifies it. */
+export declare const ClaimBlockSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"claim">;
+    id: z.ZodString;
+    content: z.ZodObject<{
+        prose: z.ZodString;
+    }, z.core.$strict>;
+    bindings: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        unit: z.ZodOptional<z.ZodString>;
+        format: 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>;
+        path: z.ZodString;
+        hash: z.ZodString;
+        snapshot: z.ZodOptional<z.ZodString>;
+        kind: z.ZodLiteral<"artifact-value">;
+    }, z.core.$strict>, z.ZodObject<{
+        unit: z.ZodOptional<z.ZodString>;
+        format: z.ZodOptional<z.ZodString>;
+        columns: z.ZodOptional<z.ZodArray<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>, z.ZodObject<{
+        unit: z.ZodOptional<z.ZodString>;
+        format: z.ZodOptional<z.ZodString>;
+        run: z.ZodOptional<z.ZodString>;
+        path: z.ZodString;
+        hash: z.ZodString;
+        snapshot: z.ZodOptional<z.ZodString>;
+        kind: z.ZodLiteral<"artifact-file">;
+    }, z.core.$strict>, z.ZodObject<{
+        unit: z.ZodOptional<z.ZodString>;
+        format: z.ZodOptional<z.ZodString>;
+        kind: z.ZodLiteral<"derivation">;
+        op: z.ZodEnum<{
+            ratio: "ratio";
+            delta: "delta";
+            pctChange: "pctChange";
+        }>;
+        inputs: z.ZodArray<z.ZodObject<{
+            unit: z.ZodOptional<z.ZodString>;
+            format: 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>;
+            path: z.ZodString;
+            hash: z.ZodString;
+            snapshot: z.ZodOptional<z.ZodString>;
+            kind: z.ZodLiteral<"artifact-value">;
+        }, z.core.$strict>>;
+        assert: z.ZodOptional<z.ZodObject<{
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+            tolerance: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodObject<{
+        unit: z.ZodOptional<z.ZodString>;
+        format: z.ZodOptional<z.ZodString>;
+        kind: z.ZodLiteral<"citation">;
+        idKind: z.ZodEnum<{
+            doi: "doi";
+            pmid: "pmid";
+            arxiv: "arxiv";
+        }>;
+        id: z.ZodString;
+        raw: z.ZodString;
+        assert: z.ZodOptional<z.ZodObject<{
+            value: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>], "kind">>;
+}, z.core.$strict>;
+/** A labeled number whose value comes from one scalar reference. */
+export declare const MetricBlockSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"metric">;
+    id: z.ZodString;
+    label: z.ZodString;
+    value: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        unit: z.ZodOptional<z.ZodString>;
+        format: 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>;
+        path: z.ZodString;
+        hash: z.ZodString;
+        snapshot: z.ZodOptional<z.ZodString>;
+        kind: z.ZodLiteral<"artifact-value">;
+    }, z.core.$strict>, z.ZodObject<{
+        unit: z.ZodOptional<z.ZodString>;
+        format: z.ZodOptional<z.ZodString>;
+        kind: z.ZodLiteral<"derivation">;
+        op: z.ZodEnum<{
+            ratio: "ratio";
+            delta: "delta";
+            pctChange: "pctChange";
+        }>;
+        inputs: z.ZodArray<z.ZodObject<{
+            unit: z.ZodOptional<z.ZodString>;
+            format: 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>;
+            path: z.ZodString;
+            hash: z.ZodString;
+            snapshot: z.ZodOptional<z.ZodString>;
+            kind: z.ZodLiteral<"artifact-value">;
+        }, z.core.$strict>>;
+        assert: z.ZodOptional<z.ZodObject<{
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+            tolerance: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>], "kind">;
+}, z.core.$strict>;
+/** A whole-table artifact rendered as a table. */
+export declare const TableBlockSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"table">;
+    id: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    binding: z.ZodObject<{
+        unit: z.ZodOptional<z.ZodString>;
+        format: z.ZodOptional<z.ZodString>;
+        columns: z.ZodOptional<z.ZodArray<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>;
+    caption: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+/** A whole-table artifact rendered as a chart, with the plot form and the channel mapping. */
+export declare const ChartBlockSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"chart">;
+    id: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    binding: z.ZodObject<{
+        unit: z.ZodOptional<z.ZodString>;
+        format: z.ZodOptional<z.ZodString>;
+        columns: z.ZodOptional<z.ZodArray<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";
+        bar: "bar";
+        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>;
+    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. */
+export declare const FigureBlockSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"figure">;
+    id: z.ZodString;
+    binding: z.ZodObject<{
+        unit: z.ZodOptional<z.ZodString>;
+        format: z.ZodOptional<z.ZodString>;
+        run: z.ZodOptional<z.ZodString>;
+        path: z.ZodString;
+        hash: z.ZodString;
+        snapshot: z.ZodOptional<z.ZodString>;
+        kind: z.ZodLiteral<"artifact-file">;
+    }, z.core.$strict>;
+    caption: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+/** An external source, rendered from a citation reference. */
+export declare const CitationBlockSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"citation">;
+    id: z.ZodString;
+    binding: z.ZodObject<{
+        unit: z.ZodOptional<z.ZodString>;
+        format: z.ZodOptional<z.ZodString>;
+        kind: z.ZodLiteral<"citation">;
+        idKind: z.ZodEnum<{
+            doi: "doi";
+            pmid: "pmid";
+            arxiv: "arxiv";
+        }>;
+        id: z.ZodString;
+        raw: z.ZodString;
+        assert: z.ZodOptional<z.ZodObject<{
+            value: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    note: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+/**
+ * The seven atoms, as one tuple.
+ *
+ * A section is the only kind whose rules differ between a finished report and a draft. Thus the atoms are
+ * the shared part, and every union of block kinds spreads this tuple beside its own section member. A
+ * ninth kind lands here one time, and each union gets it.
+ */
+export declare const ATOM_BLOCK_SCHEMAS: readonly [z.ZodObject<{
+    kind: z.ZodLiteral<"text">;
+    id: z.ZodString;
+    content: z.ZodObject<{
+        prose: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"claim">;
+    id: z.ZodString;
+    content: z.ZodObject<{
+        prose: z.ZodString;
+    }, z.core.$strict>;
+    bindings: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        unit: z.ZodOptional<z.ZodString>;
+        format: 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>;
+        path: z.ZodString;
+        hash: z.ZodString;
+        snapshot: z.ZodOptional<z.ZodString>;
+        kind: z.ZodLiteral<"artifact-value">;
+    }, z.core.$strict>, z.ZodObject<{
+        unit: z.ZodOptional<z.ZodString>;
+        format: z.ZodOptional<z.ZodString>;
+        columns: z.ZodOptional<z.ZodArray<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>, z.ZodObject<{
+        unit: z.ZodOptional<z.ZodString>;
+        format: z.ZodOptional<z.ZodString>;
+        run: z.ZodOptional<z.ZodString>;
+        path: z.ZodString;
+        hash: z.ZodString;
+        snapshot: z.ZodOptional<z.ZodString>;
+        kind: z.ZodLiteral<"artifact-file">;
+    }, z.core.$strict>, z.ZodObject<{
+        unit: z.ZodOptional<z.ZodString>;
+        format: z.ZodOptional<z.ZodString>;
+        kind: z.ZodLiteral<"derivation">;
+        op: z.ZodEnum<{
+            ratio: "ratio";
+            delta: "delta";
+            pctChange: "pctChange";
+        }>;
+        inputs: z.ZodArray<z.ZodObject<{
+            unit: z.ZodOptional<z.ZodString>;
+            format: 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>;
+            path: z.ZodString;
+            hash: z.ZodString;
+            snapshot: z.ZodOptional<z.ZodString>;
+            kind: z.ZodLiteral<"artifact-value">;
+        }, z.core.$strict>>;
+        assert: z.ZodOptional<z.ZodObject<{
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+            tolerance: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodObject<{
+        unit: z.ZodOptional<z.ZodString>;
+        format: z.ZodOptional<z.ZodString>;
+        kind: z.ZodLiteral<"citation">;
+        idKind: z.ZodEnum<{
+            doi: "doi";
+            pmid: "pmid";
+            arxiv: "arxiv";
+        }>;
+        id: z.ZodString;
+        raw: z.ZodString;
+        assert: z.ZodOptional<z.ZodObject<{
+            value: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>], "kind">>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"metric">;
+    id: z.ZodString;
+    label: z.ZodString;
+    value: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        unit: z.ZodOptional<z.ZodString>;
+        format: 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>;
+        path: z.ZodString;
+        hash: z.ZodString;
+        snapshot: z.ZodOptional<z.ZodString>;
+        kind: z.ZodLiteral<"artifact-value">;
+    }, z.core.$strict>, z.ZodObject<{
+        unit: z.ZodOptional<z.ZodString>;
+        format: z.ZodOptional<z.ZodString>;
+        kind: z.ZodLiteral<"derivation">;
+        op: z.ZodEnum<{
+            ratio: "ratio";
+            delta: "delta";
+            pctChange: "pctChange";
+        }>;
+        inputs: z.ZodArray<z.ZodObject<{
+            unit: z.ZodOptional<z.ZodString>;
+            format: 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>;
+            path: z.ZodString;
+            hash: z.ZodString;
+            snapshot: z.ZodOptional<z.ZodString>;
+            kind: z.ZodLiteral<"artifact-value">;
+        }, z.core.$strict>>;
+        assert: z.ZodOptional<z.ZodObject<{
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+            tolerance: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>], "kind">;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"table">;
+    id: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    binding: z.ZodObject<{
+        unit: z.ZodOptional<z.ZodString>;
+        format: z.ZodOptional<z.ZodString>;
+        columns: z.ZodOptional<z.ZodArray<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>;
+    caption: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"chart">;
+    id: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    binding: z.ZodObject<{
+        unit: z.ZodOptional<z.ZodString>;
+        format: z.ZodOptional<z.ZodString>;
+        columns: z.ZodOptional<z.ZodArray<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";
+        bar: "bar";
+        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>;
+    caption: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"figure">;
+    id: z.ZodString;
+    binding: z.ZodObject<{
+        unit: z.ZodOptional<z.ZodString>;
+        format: z.ZodOptional<z.ZodString>;
+        run: z.ZodOptional<z.ZodString>;
+        path: z.ZodString;
+        hash: z.ZodString;
+        snapshot: z.ZodOptional<z.ZodString>;
+        kind: z.ZodLiteral<"artifact-file">;
+    }, z.core.$strict>;
+    caption: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"citation">;
+    id: z.ZodString;
+    binding: z.ZodObject<{
+        unit: z.ZodOptional<z.ZodString>;
+        format: z.ZodOptional<z.ZodString>;
+        kind: z.ZodLiteral<"citation">;
+        idKind: z.ZodEnum<{
+            doi: "doi";
+            pmid: "pmid";
+            arxiv: "arxiv";
+        }>;
+        id: z.ZodString;
+        raw: z.ZodString;
+        assert: z.ZodOptional<z.ZodObject<{
+            value: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    note: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>];
+/** One block of any kind except a section. */
+export type AtomBlock = z.infer<(typeof ATOM_BLOCK_SCHEMAS)[number]>;
+/**
+ * The section shape as a plain type. TypeScript cannot infer the block tree through the union cycle,
+ * thus the recursive members carry an explicit type. `SectionBlock` and `Block` break the cycle.
+ */
+export interface SectionBlock {
+    kind: "section";
+    id: string;
+    title: string;
+    blocks: Block[];
+}
+/** One block of any of the eight kinds. An unknown kind fails validation by construction. */
+export type Block = AtomBlock | SectionBlock;
+/**
+ * A section holds at least one child block, thus an empty section is invalid. The `blocks` field is a
+ * `z.lazy` and not a getter, so the discriminated union reads the `kind` discriminator at construction
+ * time without a reference to `BlockSchema` before it exists.
+ */
+export declare const SectionBlockSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"section">;
+    id: z.ZodString;
+    title: z.ZodString;
+    blocks: z.ZodLazy<z.ZodArray<z.ZodType<Block, unknown, z.core.$ZodTypeInternals<Block, unknown>>>>;
+}, z.core.$strict>;
+/** The block union. A `z.ZodType<Block>` annotation gives the recursive members a stable type. */
+export declare const BlockSchema: z.ZodType<Block>;
+/**
+ * The root of a report. It holds at least one section, thus an empty report is invalid.
+ *
+ * The title carries `min(1)`, because an untitled report is incomplete in the same way that an empty
+ * section is. A draft relaxes it, and this schema gates it one time, at the finish.
+ */
+export declare const ReportDocumentSchema: z.ZodObject<{
+    title: z.ZodString;
+    sections: z.ZodArray<z.ZodObject<{
+        kind: z.ZodLiteral<"section">;
+        id: z.ZodString;
+        title: z.ZodString;
+        blocks: z.ZodLazy<z.ZodArray<z.ZodType<Block, unknown, z.core.$ZodTypeInternals<Block, unknown>>>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type TextBlock = z.infer<typeof TextBlockSchema>;
+export type ClaimBlock = z.infer<typeof ClaimBlockSchema>;
+export type MetricBlock = z.infer<typeof MetricBlockSchema>;
+export type TableBlock = z.infer<typeof TableBlockSchema>;
+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>;