paperlint 10.2.0 → 10.4.0

package/dist/adapters/study-registry/index.d.ts

@@ -1,6 +1,417 @@
-import { type ParsedRegistry } from "../../domain/study-registry.ts";
+/**
+ * The schema of `repro/studies.json` — the one place its shape is checked (docs/design/study-registry.md).
+ * The text is parsed once, here, into the domain's `StudyRegistry`; whatever reads a registry after it
+ * never re-validates.
+ *
+ * A row is a loose object: a paper merges its own measurement metadata into its rows (`role`, `frame`,
+ * `rules_under_test`, `outcome` …), and those fields are kept as they are. The top level is strict, so
+ * a misspelt key is an error rather than a key nobody reads. A measurement keeps its extra fields as a
+ * row does; a requirement and an approval are exactly their fields.
+ *
+ * A study's plan (`plan.json`) is parsed here too, strictly: a key of the paper's own goes in `extra`.
+ * Its texts may be empty — the template's are — and the parser says which: a plan comes out ready or
+ * a draft naming its empty texts, so nothing downstream looks at a text again. A plan still named
+ * `prereg.json` has a loose schema of its own.
+ *
+ * A plan's `mode` (docs/design/study-modes.md) is parsed here too, strictly, a union on its `kind`:
+ * one mode at most, a glob that leaves the study's folder or a decision outside the paper refused,
+ * and a measurement's plan ready only with a mode.
+ */
+import { z } from "zod";
+import { type Approval, type AuthorCheck, type Measurement, type ParsedPlan, type ParsedRegistry, type Requirement, type Study, type PlanTextField, type StudyKind, type StudyPlan, type StudyRegistry } from "../../domain/study-registry.ts";
+import { type Decision, type StudyMode } from "../../domain/study-mode.ts";
 import type { StudyRegistryCodec } from "../../ports/study-registry-codec.ts";
+declare const study: z.ZodObject<{
+    id: z.ZodString;
+    folder: z.ZodString;
+    title: z.ZodString;
+    question: z.ZodString;
+    kind: z.ZodEnum<{
+        data: "data";
+        artifact: "artifact";
+        measurement: "measurement";
+        spike: "spike";
+        tooling: "tooling";
+        salvage: "salvage";
+    }>;
+    status: z.ZodEnum<{
+        done: "done";
+        designing: "designing";
+        running: "running";
+        stopped: "stopped";
+        superseded: "superseded";
+        dropped: "dropped";
+    }>;
+    date: z.ZodISODate;
+    result: z.ZodOptional<z.ZodString>;
+    result_file: z.ZodOptional<z.ZodString>;
+    superseded_by: z.ZodOptional<z.ZodString>;
+    in_paper: z.ZodEnum<{
+        yes: "yes";
+        no: "no";
+        registry: "registry";
+    }>;
+    measurement: z.ZodOptional<z.ZodString>;
+    plan: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+declare const requirement: z.ZodObject<{
+    id: z.ZodString;
+    text: z.ZodString;
+    date: z.ZodISODate;
+    source: z.ZodString;
+}, z.core.$strict>;
+declare const approval: z.ZodObject<{
+    by: z.ZodString;
+    date: z.ZodISODate;
+    quote: z.ZodString;
+    source: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+declare const measurement: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    rq: z.ZodOptional<z.ZodString>;
+    role: z.ZodEnum<{
+        baseline: "baseline";
+        headline: "headline";
+    }>;
+    approval: z.ZodOptional<z.ZodObject<{
+        by: z.ZodString;
+        date: z.ZodISODate;
+        quote: z.ZodString;
+        source: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    requirements: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$loose>;
+declare const registry: z.ZodObject<{
+    prefix: z.ZodString;
+    author: z.ZodOptional<z.ZodString>;
+    requirements: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        text: z.ZodString;
+        date: z.ZodISODate;
+        source: z.ZodString;
+    }, z.core.$strict>>>;
+    measurements: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        rq: z.ZodOptional<z.ZodString>;
+        role: z.ZodEnum<{
+            baseline: "baseline";
+            headline: "headline";
+        }>;
+        approval: z.ZodOptional<z.ZodObject<{
+            by: z.ZodString;
+            date: z.ZodISODate;
+            quote: z.ZodString;
+            source: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        requirements: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$loose>>>;
+    studies: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        folder: z.ZodString;
+        title: z.ZodString;
+        question: z.ZodString;
+        kind: z.ZodEnum<{
+            data: "data";
+            artifact: "artifact";
+            measurement: "measurement";
+            spike: "spike";
+            tooling: "tooling";
+            salvage: "salvage";
+        }>;
+        status: z.ZodEnum<{
+            done: "done";
+            designing: "designing";
+            running: "running";
+            stopped: "stopped";
+            superseded: "superseded";
+            dropped: "dropped";
+        }>;
+        date: z.ZodISODate;
+        result: z.ZodOptional<z.ZodString>;
+        result_file: z.ZodOptional<z.ZodString>;
+        superseded_by: z.ZodOptional<z.ZodString>;
+        in_paper: z.ZodEnum<{
+            yes: "yes";
+            no: "no";
+            registry: "registry";
+        }>;
+        measurement: z.ZodOptional<z.ZodString>;
+        plan: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>;
+}, z.core.$strict>;
+declare const authorCheck: z.ZodObject<{
+    by: z.ZodString;
+    date: z.ZodISODate;
+    quote: z.ZodString;
+}, z.core.$strict>;
+declare const decisionShape: z.ZodObject<{
+    file: z.ZodString;
+    note: z.ZodString;
+}, z.core.$strict>;
+/** How the outcomes are kept from the decisions: exactly one mode, by its `kind`. */
+declare const mode: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"decide_before_run">;
+    outputs: z.ZodArray<z.ZodString>;
+    decision: z.ZodObject<{
+        file: z.ZodString;
+        note: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"exploratory">;
+    reason: z.ZodString;
+}, z.core.$strict>], "kind">;
+/** A plan's shape: closed at every level; the paper's own keys go in `extra`. Null is the one "none". */
+declare const planShape: z.ZodObject<{
+    question: z.ZodString;
+    population: z.ZodObject<{
+        source: z.ZodString;
+        draw: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"seeded">;
+            method: z.ZodString;
+            seed: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"all">;
+            method: z.ZodString;
+        }, z.core.$strict>], "kind">;
+    }, z.core.$strict>;
+    arms: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+    }, z.core.$strict>>;
+    primary_outcome: z.ZodString;
+    author_check: z.ZodNullable<z.ZodObject<{
+        by: z.ZodString;
+        date: z.ZodISODate;
+        quote: z.ZodString;
+    }, z.core.$strict>>;
+    extra: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    mode: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"decide_before_run">;
+        outputs: z.ZodArray<z.ZodString>;
+        decision: z.ZodObject<{
+            file: z.ZodString;
+            note: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"exploratory">;
+        reason: z.ZodString;
+    }, z.core.$strict>], "kind">>;
+}, z.core.$strict>;
+/**
+ * A plan under its old name, `prereg.json`, written by hand before the plan had a schema: open at
+ * every level, its own top-level keys kept in `extra`. A seed makes the draw seeded, none (or null) a
+ * draw of all; a size, and keys of its own deeper down, are not read; the file is never rewritten.
+ */
+declare const legacyAsPlan: z.ZodPipe<z.ZodObject<{
+    question: z.ZodString;
+    population: z.ZodObject<{
+        source: z.ZodString;
+        draw: z.ZodObject<{
+            method: z.ZodString;
+            seed: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+        }, z.core.$loose>;
+    }, z.core.$loose>;
+    arms: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+    }, z.core.$loose>>;
+    primary_outcome: z.ZodString;
+    author_check: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        by: z.ZodString;
+        date: z.ZodISODate;
+        quote: z.ZodString;
+    }, z.core.$strict>>>;
+}, z.core.$loose>, z.ZodTransform<StudyPlan, {
+    [x: string]: unknown;
+    question: string;
+    population: {
+        [x: string]: unknown;
+        source: string;
+        draw: {
+            [x: string]: unknown;
+            method: string;
+            seed?: string | number | null | undefined;
+        };
+    };
+    arms: {
+        [x: string]: unknown;
+        name: string;
+    }[];
+    primary_outcome: string;
+    author_check?: {
+        by: string;
+        date: string;
+        quote: string;
+    } | null | undefined;
+}>>;
+/** A plan that parsed: ready, or a draft. */
+type ReadyOrDraft = Exclude<ParsedPlan, {
+    readonly kind: "unreadable";
+}>;
+/** A `plan.json` of a study of `kind`: strict, then ready or draft — a measurement's ready only with its mode. */
+declare const planFor: (kind: StudyKind) => z.ZodPipe<z.ZodObject<{
+    question: z.ZodString;
+    population: z.ZodObject<{
+        source: z.ZodString;
+        draw: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"seeded">;
+            method: z.ZodString;
+            seed: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"all">;
+            method: z.ZodString;
+        }, z.core.$strict>], "kind">;
+    }, z.core.$strict>;
+    arms: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+    }, z.core.$strict>>;
+    primary_outcome: z.ZodString;
+    author_check: z.ZodNullable<z.ZodObject<{
+        by: z.ZodString;
+        date: z.ZodISODate;
+        quote: z.ZodString;
+    }, z.core.$strict>>;
+    extra: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    mode: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"decide_before_run">;
+        outputs: z.ZodArray<z.ZodString>;
+        decision: z.ZodObject<{
+            file: z.ZodString;
+            note: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"exploratory">;
+        reason: z.ZodString;
+    }, z.core.$strict>], "kind">>;
+}, z.core.$strict>, z.ZodTransform<{
+    readonly kind: "ready";
+    readonly plan: StudyPlan;
+} | {
+    readonly kind: "draft";
+    readonly plan: import("../../domain/study-registry.ts").DraftPlan;
+    readonly empty: readonly PlanTextField[];
+}, {
+    question: string;
+    population: {
+        source: string;
+        draw: {
+            kind: "seeded";
+            method: string;
+            seed: string | number;
+        } | {
+            kind: "all";
+            method: string;
+        };
+    };
+    arms: {
+        name: string;
+    }[];
+    primary_outcome: string;
+    author_check: {
+        by: string;
+        date: string;
+        quote: string;
+    } | null;
+    extra?: Record<string, unknown> | undefined;
+    mode?: {
+        kind: "decide_before_run";
+        outputs: string[];
+        decision: {
+            file: string;
+            note: string;
+        };
+    } | {
+        kind: "exploratory";
+        reason: string;
+    } | undefined;
+}>>;
+/**
+ * A `prereg.json`: loose, mapped onto the plan, then ready or draft. Written before modes existed, it
+ * is never asked for one; `repro/study-plan-name` already asks to move it to `plan.json`, where the
+ * strict parser does.
+ */
+declare const legacyPlan: z.ZodPipe<z.ZodPipe<z.ZodObject<{
+    question: z.ZodString;
+    population: z.ZodObject<{
+        source: z.ZodString;
+        draw: z.ZodObject<{
+            method: z.ZodString;
+            seed: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+        }, z.core.$loose>;
+    }, z.core.$loose>;
+    arms: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+    }, z.core.$loose>>;
+    primary_outcome: z.ZodString;
+    author_check: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        by: z.ZodString;
+        date: z.ZodISODate;
+        quote: z.ZodString;
+    }, z.core.$strict>>>;
+}, z.core.$loose>, z.ZodTransform<StudyPlan, {
+    [x: string]: unknown;
+    question: string;
+    population: {
+        [x: string]: unknown;
+        source: string;
+        draw: {
+            [x: string]: unknown;
+            method: string;
+            seed?: string | number | null | undefined;
+        };
+    };
+    arms: {
+        [x: string]: unknown;
+        name: string;
+    }[];
+    primary_outcome: string;
+    author_check?: {
+        by: string;
+        date: string;
+        quote: string;
+    } | null | undefined;
+}>>, z.ZodTransform<{
+    readonly kind: "ready";
+    readonly plan: StudyPlan;
+} | {
+    readonly kind: "draft";
+    readonly plan: import("../../domain/study-registry.ts").DraftPlan;
+    readonly empty: readonly PlanTextField[];
+}, StudyPlan>>;
+/** `T`, readonly all the way down: zod's outputs are mutable, the domain's are not. */
+type Frozen<T> = T extends readonly (infer U)[] ? readonly Frozen<U>[] : T extends object ? {
+    readonly [K in keyof T]: Frozen<T[K]>;
+} : T;
+/**
+ * True when `A` and `B`, both made readonly all the way down, are one type, optional modifiers
+ * included: two generic signatures whose returns are deferred conditionals are related only when
+ * the conditionals are identical. Written out, not through an alias: an alias is compared by the
+ * variance of its parameter, which misses a dropped optional field.
+ */
+type Same<A, B> = (<T>() => T extends Frozen<A> ? readonly [T] : 2) extends <T>() => T extends Frozen<B> ? readonly [T] : 2 ? true : false;
+/** Compiles only when every schema's output is its domain type. */
+export type SchemasAreTheDomain = [
+    Same<z.output<typeof registry>, StudyRegistry>,
+    Same<z.output<typeof study>, Study>,
+    Same<z.output<typeof measurement>, Measurement>,
+    Same<z.output<typeof requirement>, Requirement>,
+    Same<z.output<typeof approval>, Approval>,
+    Same<z.output<typeof authorCheck>, AuthorCheck>,
+    Same<z.output<typeof planShape>, StudyPlan>,
+    Same<z.output<typeof legacyAsPlan>, StudyPlan>,
+    Same<z.output<ReturnType<typeof planFor>>, ReadyOrDraft>,
+    Same<z.output<typeof legacyPlan>, ReadyOrDraft>,
+    Same<z.output<typeof mode>, StudyMode>,
+    Same<z.output<typeof decisionShape>, Decision>
+] extends true[] ? true : never;
+/** The proof is used, so the build checks it. */
+export declare const SCHEMAS_ARE_THE_DOMAIN: SchemasAreTheDomain;
 /** A `studies.json`'s text, parsed once at the boundary: the registry, or every reason it is not one. */
 export declare function parseStudyRegistry(text: string): ParsedRegistry;
+/** A `plan.json` of a study of `kind`: strict. */
+export declare const parseStudyPlan: (text: string, kind: StudyKind) => ParsedPlan;
+/** A plan still named `prereg.json`: loose, read only when a row names it. */
+export declare const parseLegacyPlan: (text: string) => ParsedPlan;
 export declare const studyRegistryCodec: StudyRegistryCodec;
+export {};
 //# sourceMappingURL=index.d.ts.map

package/dist/adapters/study-registry/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/adapters/study-registry/index.ts"],"names":[],"mappings":"AAUA,OAAO,EAKL,KAAK,cAAc,EACpB,MAAM,gCAAgC,CAAC;AACxC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qCAAqC,CAAC;AAgC9E,yGAAyG;AACzG,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,CAe/D;AAED,eAAO,MAAM,kBAAkB,EAAE,kBAEhC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/adapters/study-registry/index.ts"],"names":[],"mappings":"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"}