@actuarial-ts/interchange 0.2.0 → 0.3.0

package/dist/schemas/result.d.ts

@@ -881,9 +881,121 @@ export declare const stochasticSummarySchema: z.ZodObject<{
     /** e.g. { "75": ..., "95": ... } — percentile label → value. */
     percentiles: z.ZodRecord<z.ZodString, z.ZodNumber>;
 }, z.ZodTypeAny, "passthrough">>;
+/**
+ * How much a consumer may rely on re-running this result.
+ *
+ * A seed is NOT the same guarantee as reproducibility: it removes one source
+ * of variance, but the engine underneath may still be non-deterministic. This
+ * field says which promise the document actually carries, so an actuary knows
+ * whether they hold a derivation anyone can regenerate or an observation
+ * somebody recorded.
+ *
+ * - `seeded-reproducible` — re-running with this seed reproduces this document
+ *   byte-for-byte. @actuarial-ts/core's own stochastic layer is this
+ *   (packages/core/test/odpBootstrap.test.ts pins it), because it uses a seeded
+ *   PRNG with no ambient randomness.
+ * - `witnessed` — the engine is NOT byte-reproducible even under a fixed seed.
+ *   The document is an integrity-checked record of what that engine produced on
+ *   that run, not something a reviewer can regenerate. Still legitimate ASOP
+ *   No. 56 evidence — it just supports an attestation, not a replay.
+ *
+ * Absent means unstated (documents written before this field existed); treat
+ * an absent value as unknown, never as a reproducibility guarantee.
+ *
+ * Deterministic methods do not carry this field: kind `method-result` already
+ * implies reproducibility, and the frozen conformance corpus proves it across
+ * three independent shores.
+ */
+export declare const reproducibilitySchema: z.ZodEnum<["seeded-reproducible", "witnessed"]>;
+export type Reproducibility = z.infer<typeof reproducibilitySchema>;
+/**
+ * The engine's own self-check: it ran the identical seeded request more than
+ * once and reports whether the runs agreed. This is what lets a
+ * non-reproducible engine be HONEST rather than silently unstable — the
+ * instability is measured and disclosed on the document instead of surfacing
+ * later as a mysteriously failing test.
+ */
+export declare const stabilityCheckSchema: z.ZodObject<{
+    /** How many independent runs of the identical seeded request were compared (>= 2). */
+    repeats: z.ZodNumber;
+    /** True when every repeat produced the identical semantic body. */
+    byteIdentical: z.ZodBoolean;
+    /**
+     * Worst relative deviation observed across repeats on the summary mean,
+     * using the cross-shore definition |a-b| / max(|a|,|b|). Null when not
+     * computable. Zero with byteIdentical=false means the bodies differed
+     * somewhere other than the summary mean.
+     */
+    maxRelativeDeviation: z.ZodNullable<z.ZodNumber>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    /** How many independent runs of the identical seeded request were compared (>= 2). */
+    repeats: z.ZodNumber;
+    /** True when every repeat produced the identical semantic body. */
+    byteIdentical: z.ZodBoolean;
+    /**
+     * Worst relative deviation observed across repeats on the summary mean,
+     * using the cross-shore definition |a-b| / max(|a|,|b|). Null when not
+     * computable. Zero with byteIdentical=false means the bodies differed
+     * somewhere other than the summary mean.
+     */
+    maxRelativeDeviation: z.ZodNullable<z.ZodNumber>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    /** How many independent runs of the identical seeded request were compared (>= 2). */
+    repeats: z.ZodNumber;
+    /** True when every repeat produced the identical semantic body. */
+    byteIdentical: z.ZodBoolean;
+    /**
+     * Worst relative deviation observed across repeats on the summary mean,
+     * using the cross-shore definition |a-b| / max(|a|,|b|). Null when not
+     * computable. Zero with byteIdentical=false means the bodies differed
+     * somewhere other than the summary mean.
+     */
+    maxRelativeDeviation: z.ZodNullable<z.ZodNumber>;
+}, z.ZodTypeAny, "passthrough">>;
+export type StabilityCheck = z.infer<typeof stabilityCheckSchema>;
 export declare const stochasticResultBodySchema: z.ZodObject<{
     seed: z.ZodOptional<z.ZodNumber>;
     nSims: z.ZodNumber;
+    /** Which reproducibility promise this document carries; see the schema doc. */
+    reproducibility: z.ZodOptional<z.ZodEnum<["seeded-reproducible", "witnessed"]>>;
+    /** The engine's repeat-run self-check, when it performed one. */
+    stability: z.ZodOptional<z.ZodObject<{
+        /** How many independent runs of the identical seeded request were compared (>= 2). */
+        repeats: z.ZodNumber;
+        /** True when every repeat produced the identical semantic body. */
+        byteIdentical: z.ZodBoolean;
+        /**
+         * Worst relative deviation observed across repeats on the summary mean,
+         * using the cross-shore definition |a-b| / max(|a|,|b|). Null when not
+         * computable. Zero with byteIdentical=false means the bodies differed
+         * somewhere other than the summary mean.
+         */
+        maxRelativeDeviation: z.ZodNullable<z.ZodNumber>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        /** How many independent runs of the identical seeded request were compared (>= 2). */
+        repeats: z.ZodNumber;
+        /** True when every repeat produced the identical semantic body. */
+        byteIdentical: z.ZodBoolean;
+        /**
+         * Worst relative deviation observed across repeats on the summary mean,
+         * using the cross-shore definition |a-b| / max(|a|,|b|). Null when not
+         * computable. Zero with byteIdentical=false means the bodies differed
+         * somewhere other than the summary mean.
+         */
+        maxRelativeDeviation: z.ZodNullable<z.ZodNumber>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        /** How many independent runs of the identical seeded request were compared (>= 2). */
+        repeats: z.ZodNumber;
+        /** True when every repeat produced the identical semantic body. */
+        byteIdentical: z.ZodBoolean;
+        /**
+         * Worst relative deviation observed across repeats on the summary mean,
+         * using the cross-shore definition |a-b| / max(|a|,|b|). Null when not
+         * computable. Zero with byteIdentical=false means the bodies differed
+         * somewhere other than the summary mean.
+         */
+        maxRelativeDeviation: z.ZodNullable<z.ZodNumber>;
+    }, z.ZodTypeAny, "passthrough">>>;
     summary: z.ZodObject<{
         mean: z.ZodNumber;
         sd: z.ZodNumber;
@@ -986,6 +1098,46 @@ export declare const stochasticResultBodySchema: z.ZodObject<{
 }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
     seed: z.ZodOptional<z.ZodNumber>;
     nSims: z.ZodNumber;
+    /** Which reproducibility promise this document carries; see the schema doc. */
+    reproducibility: z.ZodOptional<z.ZodEnum<["seeded-reproducible", "witnessed"]>>;
+    /** The engine's repeat-run self-check, when it performed one. */
+    stability: z.ZodOptional<z.ZodObject<{
+        /** How many independent runs of the identical seeded request were compared (>= 2). */
+        repeats: z.ZodNumber;
+        /** True when every repeat produced the identical semantic body. */
+        byteIdentical: z.ZodBoolean;
+        /**
+         * Worst relative deviation observed across repeats on the summary mean,
+         * using the cross-shore definition |a-b| / max(|a|,|b|). Null when not
+         * computable. Zero with byteIdentical=false means the bodies differed
+         * somewhere other than the summary mean.
+         */
+        maxRelativeDeviation: z.ZodNullable<z.ZodNumber>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        /** How many independent runs of the identical seeded request were compared (>= 2). */
+        repeats: z.ZodNumber;
+        /** True when every repeat produced the identical semantic body. */
+        byteIdentical: z.ZodBoolean;
+        /**
+         * Worst relative deviation observed across repeats on the summary mean,
+         * using the cross-shore definition |a-b| / max(|a|,|b|). Null when not
+         * computable. Zero with byteIdentical=false means the bodies differed
+         * somewhere other than the summary mean.
+         */
+        maxRelativeDeviation: z.ZodNullable<z.ZodNumber>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        /** How many independent runs of the identical seeded request were compared (>= 2). */
+        repeats: z.ZodNumber;
+        /** True when every repeat produced the identical semantic body. */
+        byteIdentical: z.ZodBoolean;
+        /**
+         * Worst relative deviation observed across repeats on the summary mean,
+         * using the cross-shore definition |a-b| / max(|a|,|b|). Null when not
+         * computable. Zero with byteIdentical=false means the bodies differed
+         * somewhere other than the summary mean.
+         */
+        maxRelativeDeviation: z.ZodNullable<z.ZodNumber>;
+    }, z.ZodTypeAny, "passthrough">>>;
     summary: z.ZodObject<{
         mean: z.ZodNumber;
         sd: z.ZodNumber;
@@ -1088,6 +1240,46 @@ export declare const stochasticResultBodySchema: z.ZodObject<{
 }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
     seed: z.ZodOptional<z.ZodNumber>;
     nSims: z.ZodNumber;
+    /** Which reproducibility promise this document carries; see the schema doc. */
+    reproducibility: z.ZodOptional<z.ZodEnum<["seeded-reproducible", "witnessed"]>>;
+    /** The engine's repeat-run self-check, when it performed one. */
+    stability: z.ZodOptional<z.ZodObject<{
+        /** How many independent runs of the identical seeded request were compared (>= 2). */
+        repeats: z.ZodNumber;
+        /** True when every repeat produced the identical semantic body. */
+        byteIdentical: z.ZodBoolean;
+        /**
+         * Worst relative deviation observed across repeats on the summary mean,
+         * using the cross-shore definition |a-b| / max(|a|,|b|). Null when not
+         * computable. Zero with byteIdentical=false means the bodies differed
+         * somewhere other than the summary mean.
+         */
+        maxRelativeDeviation: z.ZodNullable<z.ZodNumber>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        /** How many independent runs of the identical seeded request were compared (>= 2). */
+        repeats: z.ZodNumber;
+        /** True when every repeat produced the identical semantic body. */
+        byteIdentical: z.ZodBoolean;
+        /**
+         * Worst relative deviation observed across repeats on the summary mean,
+         * using the cross-shore definition |a-b| / max(|a|,|b|). Null when not
+         * computable. Zero with byteIdentical=false means the bodies differed
+         * somewhere other than the summary mean.
+         */
+        maxRelativeDeviation: z.ZodNullable<z.ZodNumber>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        /** How many independent runs of the identical seeded request were compared (>= 2). */
+        repeats: z.ZodNumber;
+        /** True when every repeat produced the identical semantic body. */
+        byteIdentical: z.ZodBoolean;
+        /**
+         * Worst relative deviation observed across repeats on the summary mean,
+         * using the cross-shore definition |a-b| / max(|a|,|b|). Null when not
+         * computable. Zero with byteIdentical=false means the bodies differed
+         * somewhere other than the summary mean.
+         */
+        maxRelativeDeviation: z.ZodNullable<z.ZodNumber>;
+    }, z.ZodTypeAny, "passthrough">>>;
     summary: z.ZodObject<{
         mean: z.ZodNumber;
         sd: z.ZodNumber;
@@ -1193,6 +1385,46 @@ export declare const stochasticResultDocSchema: z.ZodObject<{
     result: z.ZodObject<{
         seed: z.ZodOptional<z.ZodNumber>;
         nSims: z.ZodNumber;
+        /** Which reproducibility promise this document carries; see the schema doc. */
+        reproducibility: z.ZodOptional<z.ZodEnum<["seeded-reproducible", "witnessed"]>>;
+        /** The engine's repeat-run self-check, when it performed one. */
+        stability: z.ZodOptional<z.ZodObject<{
+            /** How many independent runs of the identical seeded request were compared (>= 2). */
+            repeats: z.ZodNumber;
+            /** True when every repeat produced the identical semantic body. */
+            byteIdentical: z.ZodBoolean;
+            /**
+             * Worst relative deviation observed across repeats on the summary mean,
+             * using the cross-shore definition |a-b| / max(|a|,|b|). Null when not
+             * computable. Zero with byteIdentical=false means the bodies differed
+             * somewhere other than the summary mean.
+             */
+            maxRelativeDeviation: z.ZodNullable<z.ZodNumber>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            /** How many independent runs of the identical seeded request were compared (>= 2). */
+            repeats: z.ZodNumber;
+            /** True when every repeat produced the identical semantic body. */
+            byteIdentical: z.ZodBoolean;
+            /**
+             * Worst relative deviation observed across repeats on the summary mean,
+             * using the cross-shore definition |a-b| / max(|a|,|b|). Null when not
+             * computable. Zero with byteIdentical=false means the bodies differed
+             * somewhere other than the summary mean.
+             */
+            maxRelativeDeviation: z.ZodNullable<z.ZodNumber>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            /** How many independent runs of the identical seeded request were compared (>= 2). */
+            repeats: z.ZodNumber;
+            /** True when every repeat produced the identical semantic body. */
+            byteIdentical: z.ZodBoolean;
+            /**
+             * Worst relative deviation observed across repeats on the summary mean,
+             * using the cross-shore definition |a-b| / max(|a|,|b|). Null when not
+             * computable. Zero with byteIdentical=false means the bodies differed
+             * somewhere other than the summary mean.
+             */
+            maxRelativeDeviation: z.ZodNullable<z.ZodNumber>;
+        }, z.ZodTypeAny, "passthrough">>>;
         summary: z.ZodObject<{
             mean: z.ZodNumber;
             sd: z.ZodNumber;
@@ -1295,6 +1527,46 @@ export declare const stochasticResultDocSchema: z.ZodObject<{
     }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
         seed: z.ZodOptional<z.ZodNumber>;
         nSims: z.ZodNumber;
+        /** Which reproducibility promise this document carries; see the schema doc. */
+        reproducibility: z.ZodOptional<z.ZodEnum<["seeded-reproducible", "witnessed"]>>;
+        /** The engine's repeat-run self-check, when it performed one. */
+        stability: z.ZodOptional<z.ZodObject<{
+            /** How many independent runs of the identical seeded request were compared (>= 2). */
+            repeats: z.ZodNumber;
+            /** True when every repeat produced the identical semantic body. */
+            byteIdentical: z.ZodBoolean;
+            /**
+             * Worst relative deviation observed across repeats on the summary mean,
+             * using the cross-shore definition |a-b| / max(|a|,|b|). Null when not
+             * computable. Zero with byteIdentical=false means the bodies differed
+             * somewhere other than the summary mean.
+             */
+            maxRelativeDeviation: z.ZodNullable<z.ZodNumber>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            /** How many independent runs of the identical seeded request were compared (>= 2). */
+            repeats: z.ZodNumber;
+            /** True when every repeat produced the identical semantic body. */
+            byteIdentical: z.ZodBoolean;
+            /**
+             * Worst relative deviation observed across repeats on the summary mean,
+             * using the cross-shore definition |a-b| / max(|a|,|b|). Null when not
+             * computable. Zero with byteIdentical=false means the bodies differed
+             * somewhere other than the summary mean.
+             */
+            maxRelativeDeviation: z.ZodNullable<z.ZodNumber>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            /** How many independent runs of the identical seeded request were compared (>= 2). */
+            repeats: z.ZodNumber;
+            /** True when every repeat produced the identical semantic body. */
+            byteIdentical: z.ZodBoolean;
+            /**
+             * Worst relative deviation observed across repeats on the summary mean,
+             * using the cross-shore definition |a-b| / max(|a|,|b|). Null when not
+             * computable. Zero with byteIdentical=false means the bodies differed
+             * somewhere other than the summary mean.
+             */
+            maxRelativeDeviation: z.ZodNullable<z.ZodNumber>;
+        }, z.ZodTypeAny, "passthrough">>>;
         summary: z.ZodObject<{
             mean: z.ZodNumber;
             sd: z.ZodNumber;
@@ -1397,6 +1669,46 @@ export declare const stochasticResultDocSchema: z.ZodObject<{
     }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
         seed: z.ZodOptional<z.ZodNumber>;
         nSims: z.ZodNumber;
+        /** Which reproducibility promise this document carries; see the schema doc. */
+        reproducibility: z.ZodOptional<z.ZodEnum<["seeded-reproducible", "witnessed"]>>;
+        /** The engine's repeat-run self-check, when it performed one. */
+        stability: z.ZodOptional<z.ZodObject<{
+            /** How many independent runs of the identical seeded request were compared (>= 2). */
+            repeats: z.ZodNumber;
+            /** True when every repeat produced the identical semantic body. */
+            byteIdentical: z.ZodBoolean;
+            /**
+             * Worst relative deviation observed across repeats on the summary mean,
+             * using the cross-shore definition |a-b| / max(|a|,|b|). Null when not
+             * computable. Zero with byteIdentical=false means the bodies differed
+             * somewhere other than the summary mean.
+             */
+            maxRelativeDeviation: z.ZodNullable<z.ZodNumber>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            /** How many independent runs of the identical seeded request were compared (>= 2). */
+            repeats: z.ZodNumber;
+            /** True when every repeat produced the identical semantic body. */
+            byteIdentical: z.ZodBoolean;
+            /**
+             * Worst relative deviation observed across repeats on the summary mean,
+             * using the cross-shore definition |a-b| / max(|a|,|b|). Null when not
+             * computable. Zero with byteIdentical=false means the bodies differed
+             * somewhere other than the summary mean.
+             */
+            maxRelativeDeviation: z.ZodNullable<z.ZodNumber>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            /** How many independent runs of the identical seeded request were compared (>= 2). */
+            repeats: z.ZodNumber;
+            /** True when every repeat produced the identical semantic body. */
+            byteIdentical: z.ZodBoolean;
+            /**
+             * Worst relative deviation observed across repeats on the summary mean,
+             * using the cross-shore definition |a-b| / max(|a|,|b|). Null when not
+             * computable. Zero with byteIdentical=false means the bodies differed
+             * somewhere other than the summary mean.
+             */
+            maxRelativeDeviation: z.ZodNullable<z.ZodNumber>;
+        }, z.ZodTypeAny, "passthrough">>>;
         summary: z.ZodObject<{
             mean: z.ZodNumber;
             sd: z.ZodNumber;
@@ -1516,6 +1828,46 @@ export declare const stochasticResultDocSchema: z.ZodObject<{
     result: z.ZodObject<{
         seed: z.ZodOptional<z.ZodNumber>;
         nSims: z.ZodNumber;
+        /** Which reproducibility promise this document carries; see the schema doc. */
+        reproducibility: z.ZodOptional<z.ZodEnum<["seeded-reproducible", "witnessed"]>>;
+        /** The engine's repeat-run self-check, when it performed one. */
+        stability: z.ZodOptional<z.ZodObject<{
+            /** How many independent runs of the identical seeded request were compared (>= 2). */
+            repeats: z.ZodNumber;
+            /** True when every repeat produced the identical semantic body. */
+            byteIdentical: z.ZodBoolean;
+            /**
+             * Worst relative deviation observed across repeats on the summary mean,
+             * using the cross-shore definition |a-b| / max(|a|,|b|). Null when not
+             * computable. Zero with byteIdentical=false means the bodies differed
+             * somewhere other than the summary mean.
+             */
+            maxRelativeDeviation: z.ZodNullable<z.ZodNumber>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            /** How many independent runs of the identical seeded request were compared (>= 2). */
+            repeats: z.ZodNumber;
+            /** True when every repeat produced the identical semantic body. */
+            byteIdentical: z.ZodBoolean;
+            /**
+             * Worst relative deviation observed across repeats on the summary mean,
+             * using the cross-shore definition |a-b| / max(|a|,|b|). Null when not
+             * computable. Zero with byteIdentical=false means the bodies differed
+             * somewhere other than the summary mean.
+             */
+            maxRelativeDeviation: z.ZodNullable<z.ZodNumber>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            /** How many independent runs of the identical seeded request were compared (>= 2). */
+            repeats: z.ZodNumber;
+            /** True when every repeat produced the identical semantic body. */
+            byteIdentical: z.ZodBoolean;
+            /**
+             * Worst relative deviation observed across repeats on the summary mean,
+             * using the cross-shore definition |a-b| / max(|a|,|b|). Null when not
+             * computable. Zero with byteIdentical=false means the bodies differed
+             * somewhere other than the summary mean.
+             */
+            maxRelativeDeviation: z.ZodNullable<z.ZodNumber>;
+        }, z.ZodTypeAny, "passthrough">>>;
         summary: z.ZodObject<{
             mean: z.ZodNumber;
             sd: z.ZodNumber;
@@ -1618,6 +1970,46 @@ export declare const stochasticResultDocSchema: z.ZodObject<{
     }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
         seed: z.ZodOptional<z.ZodNumber>;
         nSims: z.ZodNumber;
+        /** Which reproducibility promise this document carries; see the schema doc. */
+        reproducibility: z.ZodOptional<z.ZodEnum<["seeded-reproducible", "witnessed"]>>;
+        /** The engine's repeat-run self-check, when it performed one. */
+        stability: z.ZodOptional<z.ZodObject<{
+            /** How many independent runs of the identical seeded request were compared (>= 2). */
+            repeats: z.ZodNumber;
+            /** True when every repeat produced the identical semantic body. */
+            byteIdentical: z.ZodBoolean;
+            /**
+             * Worst relative deviation observed across repeats on the summary mean,
+             * using the cross-shore definition |a-b| / max(|a|,|b|). Null when not
+             * computable. Zero with byteIdentical=false means the bodies differed
+             * somewhere other than the summary mean.
+             */
+            maxRelativeDeviation: z.ZodNullable<z.ZodNumber>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            /** How many independent runs of the identical seeded request were compared (>= 2). */
+            repeats: z.ZodNumber;
+            /** True when every repeat produced the identical semantic body. */
+            byteIdentical: z.ZodBoolean;
+            /**
+             * Worst relative deviation observed across repeats on the summary mean,
+             * using the cross-shore definition |a-b| / max(|a|,|b|). Null when not
+             * computable. Zero with byteIdentical=false means the bodies differed
+             * somewhere other than the summary mean.
+             */
+            maxRelativeDeviation: z.ZodNullable<z.ZodNumber>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            /** How many independent runs of the identical seeded request were compared (>= 2). */
+            repeats: z.ZodNumber;
+            /** True when every repeat produced the identical semantic body. */
+            byteIdentical: z.ZodBoolean;
+            /**
+             * Worst relative deviation observed across repeats on the summary mean,
+             * using the cross-shore definition |a-b| / max(|a|,|b|). Null when not
+             * computable. Zero with byteIdentical=false means the bodies differed
+             * somewhere other than the summary mean.
+             */
+            maxRelativeDeviation: z.ZodNullable<z.ZodNumber>;
+        }, z.ZodTypeAny, "passthrough">>>;
         summary: z.ZodObject<{
             mean: z.ZodNumber;
             sd: z.ZodNumber;
@@ -1720,6 +2112,46 @@ export declare const stochasticResultDocSchema: z.ZodObject<{
     }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
         seed: z.ZodOptional<z.ZodNumber>;
         nSims: z.ZodNumber;
+        /** Which reproducibility promise this document carries; see the schema doc. */
+        reproducibility: z.ZodOptional<z.ZodEnum<["seeded-reproducible", "witnessed"]>>;
+        /** The engine's repeat-run self-check, when it performed one. */
+        stability: z.ZodOptional<z.ZodObject<{
+            /** How many independent runs of the identical seeded request were compared (>= 2). */
+            repeats: z.ZodNumber;
+            /** True when every repeat produced the identical semantic body. */
+            byteIdentical: z.ZodBoolean;
+            /**
+             * Worst relative deviation observed across repeats on the summary mean,
+             * using the cross-shore definition |a-b| / max(|a|,|b|). Null when not
+             * computable. Zero with byteIdentical=false means the bodies differed
+             * somewhere other than the summary mean.
+             */
+            maxRelativeDeviation: z.ZodNullable<z.ZodNumber>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            /** How many independent runs of the identical seeded request were compared (>= 2). */
+            repeats: z.ZodNumber;
+            /** True when every repeat produced the identical semantic body. */
+            byteIdentical: z.ZodBoolean;
+            /**
+             * Worst relative deviation observed across repeats on the summary mean,
+             * using the cross-shore definition |a-b| / max(|a|,|b|). Null when not
+             * computable. Zero with byteIdentical=false means the bodies differed
+             * somewhere other than the summary mean.
+             */
+            maxRelativeDeviation: z.ZodNullable<z.ZodNumber>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            /** How many independent runs of the identical seeded request were compared (>= 2). */
+            repeats: z.ZodNumber;
+            /** True when every repeat produced the identical semantic body. */
+            byteIdentical: z.ZodBoolean;
+            /**
+             * Worst relative deviation observed across repeats on the summary mean,
+             * using the cross-shore definition |a-b| / max(|a|,|b|). Null when not
+             * computable. Zero with byteIdentical=false means the bodies differed
+             * somewhere other than the summary mean.
+             */
+            maxRelativeDeviation: z.ZodNullable<z.ZodNumber>;
+        }, z.ZodTypeAny, "passthrough">>>;
         summary: z.ZodObject<{
             mean: z.ZodNumber;
             sd: z.ZodNumber;
@@ -1839,6 +2271,46 @@ export declare const stochasticResultDocSchema: z.ZodObject<{
     result: z.ZodObject<{
         seed: z.ZodOptional<z.ZodNumber>;
         nSims: z.ZodNumber;
+        /** Which reproducibility promise this document carries; see the schema doc. */
+        reproducibility: z.ZodOptional<z.ZodEnum<["seeded-reproducible", "witnessed"]>>;
+        /** The engine's repeat-run self-check, when it performed one. */
+        stability: z.ZodOptional<z.ZodObject<{
+            /** How many independent runs of the identical seeded request were compared (>= 2). */
+            repeats: z.ZodNumber;
+            /** True when every repeat produced the identical semantic body. */
+            byteIdentical: z.ZodBoolean;
+            /**
+             * Worst relative deviation observed across repeats on the summary mean,
+             * using the cross-shore definition |a-b| / max(|a|,|b|). Null when not
+             * computable. Zero with byteIdentical=false means the bodies differed
+             * somewhere other than the summary mean.
+             */
+            maxRelativeDeviation: z.ZodNullable<z.ZodNumber>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            /** How many independent runs of the identical seeded request were compared (>= 2). */
+            repeats: z.ZodNumber;
+            /** True when every repeat produced the identical semantic body. */
+            byteIdentical: z.ZodBoolean;
+            /**
+             * Worst relative deviation observed across repeats on the summary mean,
+             * using the cross-shore definition |a-b| / max(|a|,|b|). Null when not
+             * computable. Zero with byteIdentical=false means the bodies differed
+             * somewhere other than the summary mean.
+             */
+            maxRelativeDeviation: z.ZodNullable<z.ZodNumber>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            /** How many independent runs of the identical seeded request were compared (>= 2). */
+            repeats: z.ZodNumber;
+            /** True when every repeat produced the identical semantic body. */
+            byteIdentical: z.ZodBoolean;
+            /**
+             * Worst relative deviation observed across repeats on the summary mean,
+             * using the cross-shore definition |a-b| / max(|a|,|b|). Null when not
+             * computable. Zero with byteIdentical=false means the bodies differed
+             * somewhere other than the summary mean.
+             */
+            maxRelativeDeviation: z.ZodNullable<z.ZodNumber>;
+        }, z.ZodTypeAny, "passthrough">>>;
         summary: z.ZodObject<{
             mean: z.ZodNumber;
             sd: z.ZodNumber;
@@ -1941,6 +2413,46 @@ export declare const stochasticResultDocSchema: z.ZodObject<{
     }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
         seed: z.ZodOptional<z.ZodNumber>;
         nSims: z.ZodNumber;
+        /** Which reproducibility promise this document carries; see the schema doc. */
+        reproducibility: z.ZodOptional<z.ZodEnum<["seeded-reproducible", "witnessed"]>>;
+        /** The engine's repeat-run self-check, when it performed one. */
+        stability: z.ZodOptional<z.ZodObject<{
+            /** How many independent runs of the identical seeded request were compared (>= 2). */
+            repeats: z.ZodNumber;
+            /** True when every repeat produced the identical semantic body. */
+            byteIdentical: z.ZodBoolean;
+            /**
+             * Worst relative deviation observed across repeats on the summary mean,
+             * using the cross-shore definition |a-b| / max(|a|,|b|). Null when not
+             * computable. Zero with byteIdentical=false means the bodies differed
+             * somewhere other than the summary mean.
+             */
+            maxRelativeDeviation: z.ZodNullable<z.ZodNumber>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            /** How many independent runs of the identical seeded request were compared (>= 2). */
+            repeats: z.ZodNumber;
+            /** True when every repeat produced the identical semantic body. */
+            byteIdentical: z.ZodBoolean;
+            /**
+             * Worst relative deviation observed across repeats on the summary mean,
+             * using the cross-shore definition |a-b| / max(|a|,|b|). Null when not
+             * computable. Zero with byteIdentical=false means the bodies differed
+             * somewhere other than the summary mean.
+             */
+            maxRelativeDeviation: z.ZodNullable<z.ZodNumber>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            /** How many independent runs of the identical seeded request were compared (>= 2). */
+            repeats: z.ZodNumber;
+            /** True when every repeat produced the identical semantic body. */
+            byteIdentical: z.ZodBoolean;
+            /**
+             * Worst relative deviation observed across repeats on the summary mean,
+             * using the cross-shore definition |a-b| / max(|a|,|b|). Null when not
+             * computable. Zero with byteIdentical=false means the bodies differed
+             * somewhere other than the summary mean.
+             */
+            maxRelativeDeviation: z.ZodNullable<z.ZodNumber>;
+        }, z.ZodTypeAny, "passthrough">>>;
         summary: z.ZodObject<{
             mean: z.ZodNumber;
             sd: z.ZodNumber;
@@ -2043,6 +2555,46 @@ export declare const stochasticResultDocSchema: z.ZodObject<{
     }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
         seed: z.ZodOptional<z.ZodNumber>;
         nSims: z.ZodNumber;
+        /** Which reproducibility promise this document carries; see the schema doc. */
+        reproducibility: z.ZodOptional<z.ZodEnum<["seeded-reproducible", "witnessed"]>>;
+        /** The engine's repeat-run self-check, when it performed one. */
+        stability: z.ZodOptional<z.ZodObject<{
+            /** How many independent runs of the identical seeded request were compared (>= 2). */
+            repeats: z.ZodNumber;
+            /** True when every repeat produced the identical semantic body. */
+            byteIdentical: z.ZodBoolean;
+            /**
+             * Worst relative deviation observed across repeats on the summary mean,
+             * using the cross-shore definition |a-b| / max(|a|,|b|). Null when not
+             * computable. Zero with byteIdentical=false means the bodies differed
+             * somewhere other than the summary mean.
+             */
+            maxRelativeDeviation: z.ZodNullable<z.ZodNumber>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            /** How many independent runs of the identical seeded request were compared (>= 2). */
+            repeats: z.ZodNumber;
+            /** True when every repeat produced the identical semantic body. */
+            byteIdentical: z.ZodBoolean;
+            /**
+             * Worst relative deviation observed across repeats on the summary mean,
+             * using the cross-shore definition |a-b| / max(|a|,|b|). Null when not
+             * computable. Zero with byteIdentical=false means the bodies differed
+             * somewhere other than the summary mean.
+             */
+            maxRelativeDeviation: z.ZodNullable<z.ZodNumber>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            /** How many independent runs of the identical seeded request were compared (>= 2). */
+            repeats: z.ZodNumber;
+            /** True when every repeat produced the identical semantic body. */
+            byteIdentical: z.ZodBoolean;
+            /**
+             * Worst relative deviation observed across repeats on the summary mean,
+             * using the cross-shore definition |a-b| / max(|a|,|b|). Null when not
+             * computable. Zero with byteIdentical=false means the bodies differed
+             * somewhere other than the summary mean.
+             */
+            maxRelativeDeviation: z.ZodNullable<z.ZodNumber>;
+        }, z.ZodTypeAny, "passthrough">>>;
         summary: z.ZodObject<{
             mean: z.ZodNumber;
             sd: z.ZodNumber;

package/dist/schemas/result.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"result.d.ts","sourceRoot":"","sources":["../../src/schemas/result.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"result.d.ts","sourceRoot":"","sources":["../../src/schemas/result.ts"],"names":[],"mappings":"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"}