@idlekit/core 0.2.0 → 0.3.0

package/dist/sim/analysis/growthFit.js

@@ -0,0 +1,1798 @@
+import * as _validateReport_1 from "typia/lib/internal/_validateReport";
+import * as _createStandardSchema_1 from "typia/lib/internal/_createStandardSchema";
+import typia, {} from "typia";
+import { legacyGrowthSpeedBucket } from "./growth";
+/**
+ * Growth fit v1.
+ * `analyzeGrowth` stays the legacy speed-bucket report.
+ * This artifact separates shape from log slope and does not prove an asymptote.
+ */
+const GROWTH_FIT_ALGORITHM_VERSION = "growth-fit-v1";
+const GROWTH_FIT_SCHEMA_ID = "https://idlekit.dev/schemas/growth.fit.v1.schema.json";
+const MIN_SAMPLES = 8;
+const MIN_SPAN_SEC = 30;
+const LOG_RMSE_OK = 1e-4;
+const VALUE_REL_OK = 1e-4;
+/** A value-space fit this close is exact for a line or parabola, not an approximation. */
+const VALUE_EXACT = 1e-9;
+const SLOPE_TOLERANCE = 1e-4;
+const DROP_LOG10 = 1;
+/**
+ * @evidence docs/requirements/active/growth-model-classification.md#req-pr12-shape-speed Slow and fast exponentials share a shape. Other formulas stay distinct, and a short trace stays unknown.
+ * @evidenceReview docs/requirements/active/growth-model-classification.md#req-pr12-shape-speed #acbd473 Re-read the section: exp(0.001 t) and exp(0.2 t) are both exponential, and the slopes differ.
+ */
+export const growthShapeIndependentOfSpeed = "shape-independent-of-log-slope";
+/**
+ * @evidence docs/requirements/active/growth-model-classification.md#req-pr12-scale-domain A rescaled huge series keeps its shape. Zero, negative, a drop, irregular time, and one point are not a speed claim.
+ * @evidenceReview docs/requirements/active/growth-model-classification.md#req-pr12-scale-domain #38e5c42 Re-read the section: 1e400 and a constant multiple match, and abs is not applied to a negative sample.
+ */
+export const growthDomainNotDisguised = "non-positive-and-discontinuity-are-not-speed";
+/**
+ * @evidence docs/requirements/active/growth-model-classification.md#req-pr12-legacy-preserved The old report still names speed buckets. netWorthFallback stays on both results.
+ * @evidenceReview docs/requirements/active/growth-model-classification.md#req-pr12-legacy-preserved #1355aa0 Re-read the section: the legacy regime is still a slope bucket, and the fit does not replace it.
+ */
+export const growthLegacyObservationPreserved = "legacy-report-and-net-worth-fallback";
+export function growthFitSchemaId() {
+    return GROWTH_FIT_SCHEMA_ID;
+}
+export function growthFitAlgorithmVersion() {
+    return GROWTH_FIT_ALGORITHM_VERSION;
+}
+export function growthFitSlopeTolerance() {
+    return SLOPE_TOLERANCE;
+}
+export class GrowthFitRejected extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "GrowthFitRejected";
+    }
+}
+/*
+ * typia runs on first call, not at module load. A plugin that the bundled CLI loads
+ * imports core source without the transform, and a module-load call would throw there.
+ */
+let growthFitValidator;
+function buildGrowthFitJsonSchema() {
+    return {
+        components: {
+            schemas: {
+                "ReadonlyschemaVersion1algorithmVersiongrowth-fit-v1methodheuristic-fitstatusAnalysisStatusseriesRequestedmoneynetWorthvalueSourcemoneynetWorthnetWorthFallback---15more---windowsreadonlyReadonly---": {
+                    type: "object",
+                    properties: {
+                        schemaVersion: {
+                            "const": 1
+                        },
+                        algorithmVersion: {
+                            "const": "growth-fit-v1"
+                        },
+                        method: {
+                            "const": "heuristic-fit"
+                        },
+                        status: {
+                            $ref: "#/components/schemas/AnalysisStatus"
+                        },
+                        seriesRequested: {
+                            oneOf: [
+                                {
+                                    "const": "money"
+                                },
+                                {
+                                    "const": "netWorth"
+                                }
+                            ]
+                        },
+                        valueSource: {
+                            oneOf: [
+                                {
+                                    "const": "money"
+                                },
+                                {
+                                    "const": "netWorth"
+                                },
+                                {
+                                    "const": "netWorthFallback"
+                                }
+                            ]
+                        },
+                        windowSec: {
+                            type: "number"
+                        },
+                        samplingBudget: {
+                            type: "number"
+                        },
+                        sampleCount: {
+                            type: "number"
+                        },
+                        inputSampleCount: {
+                            type: "number"
+                        },
+                        slopeTolerance: {
+                            type: "number"
+                        },
+                        fitWindow: {
+                            $ref: "#/components/schemas/ReadonlywindowSecnumberstartSecnumberendSecnumber"
+                        },
+                        irregular: {
+                            type: "boolean"
+                        },
+                        claimsResourceBottleneck: {
+                            "const": false
+                        },
+                        softcap: {
+                            oneOf: [
+                                {
+                                    "const": "absent"
+                                },
+                                {
+                                    "const": "configured"
+                                },
+                                {
+                                    "const": "unknown"
+                                }
+                            ]
+                        },
+                        cadenceSec: {
+                            type: "number"
+                        },
+                        cadenceCoarserThanWindow: {
+                            type: "boolean"
+                        },
+                        downsampled: {
+                            $ref: "#/components/schemas/Readonlyseennumberkeptnumber"
+                        },
+                        retention: {
+                            $ref: "#/components/schemas/ReadonlytotalSeennumberretainednumberdroppednumber"
+                        },
+                        assumptions: {
+                            type: "array",
+                            items: {
+                                type: "string"
+                            }
+                        },
+                        warnings: {
+                            type: "array",
+                            items: {
+                                type: "string"
+                            }
+                        },
+                        windows: {
+                            type: "array",
+                            items: {
+                                $ref: "#/components/schemas/ReadonlystartSecnumberendSecnumbersampleCountnumberdomainGrowthDomainstatusAnalysisStatusshapeGrowthShapediscontinuityGrowthDiscontinuityKindspeedReadonly---legacySpeedBucketGrowthLegacyBucketnullresidualReadonly---qualitystring"
+                            }
+                        }
+                    },
+                    required: [
+                        "schemaVersion",
+                        "algorithmVersion",
+                        "method",
+                        "status",
+                        "seriesRequested",
+                        "valueSource",
+                        "windowSec",
+                        "samplingBudget",
+                        "sampleCount",
+                        "inputSampleCount",
+                        "slopeTolerance",
+                        "fitWindow",
+                        "irregular",
+                        "claimsResourceBottleneck",
+                        "softcap",
+                        "cadenceCoarserThanWindow",
+                        "assumptions",
+                        "warnings",
+                        "windows"
+                    ],
+                    additionalProperties: false
+                },
+                AnalysisStatus: {
+                    oneOf: [
+                        {
+                            "const": "censored"
+                        },
+                        {
+                            "const": "error"
+                        },
+                        {
+                            "const": "insufficient-data"
+                        },
+                        {
+                            "const": "invalid"
+                        },
+                        {
+                            "const": "ok"
+                        },
+                        {
+                            "const": "unknown"
+                        },
+                        {
+                            "const": "unsupported"
+                        }
+                    ]
+                },
+                ReadonlywindowSecnumberstartSecnumberendSecnumber: {
+                    type: "object",
+                    properties: {
+                        windowSec: {
+                            type: "number"
+                        },
+                        startSec: {
+                            type: "number"
+                        },
+                        endSec: {
+                            type: "number"
+                        }
+                    },
+                    required: [
+                        "windowSec",
+                        "startSec",
+                        "endSec"
+                    ],
+                    additionalProperties: false
+                },
+                Readonlyseennumberkeptnumber: {
+                    type: "object",
+                    properties: {
+                        seen: {
+                            type: "number"
+                        },
+                        kept: {
+                            type: "number"
+                        }
+                    },
+                    required: [
+                        "seen",
+                        "kept"
+                    ],
+                    additionalProperties: false
+                },
+                ReadonlytotalSeennumberretainednumberdroppednumber: {
+                    type: "object",
+                    properties: {
+                        totalSeen: {
+                            type: "number"
+                        },
+                        retained: {
+                            type: "number"
+                        },
+                        dropped: {
+                            type: "number"
+                        }
+                    },
+                    required: [
+                        "totalSeen",
+                        "retained",
+                        "dropped"
+                    ],
+                    additionalProperties: false
+                },
+                "ReadonlystartSecnumberendSecnumbersampleCountnumberdomainGrowthDomainstatusAnalysisStatusshapeGrowthShapediscontinuityGrowthDiscontinuityKindspeedReadonly---legacySpeedBucketGrowthLegacyBucketnullresidualReadonly---qualitystring": {
+                    type: "object",
+                    properties: {
+                        startSec: {
+                            type: "number"
+                        },
+                        endSec: {
+                            type: "number"
+                        },
+                        sampleCount: {
+                            type: "number"
+                        },
+                        domain: {
+                            $ref: "#/components/schemas/GrowthDomain"
+                        },
+                        status: {
+                            $ref: "#/components/schemas/AnalysisStatus"
+                        },
+                        shape: {
+                            $ref: "#/components/schemas/GrowthShape"
+                        },
+                        discontinuity: {
+                            $ref: "#/components/schemas/GrowthDiscontinuityKind"
+                        },
+                        speed: {
+                            $ref: "#/components/schemas/ReadonlylogSlopePerSecnumbernulldoublingTimeSecnumbernull"
+                        },
+                        legacySpeedBucket: {
+                            oneOf: [
+                                {
+                                    type: "null"
+                                },
+                                {
+                                    "const": "exp"
+                                },
+                                {
+                                    "const": "softcap"
+                                },
+                                {
+                                    "const": "stall"
+                                },
+                                {
+                                    "const": "super-exp"
+                                }
+                            ]
+                        },
+                        residual: {
+                            $ref: "#/components/schemas/Readonlyspacelog-ratelog10nonevaluermsenumbernull"
+                        },
+                        quality: {
+                            type: "string"
+                        }
+                    },
+                    required: [
+                        "startSec",
+                        "endSec",
+                        "sampleCount",
+                        "domain",
+                        "status",
+                        "shape",
+                        "discontinuity",
+                        "speed",
+                        "legacySpeedBucket",
+                        "residual",
+                        "quality"
+                    ],
+                    additionalProperties: false
+                },
+                GrowthDomain: {
+                    oneOf: [
+                        {
+                            "const": "empty"
+                        },
+                        {
+                            "const": "mixed"
+                        },
+                        {
+                            "const": "negative"
+                        },
+                        {
+                            "const": "nonfinite"
+                        },
+                        {
+                            "const": "positive"
+                        },
+                        {
+                            "const": "zero"
+                        }
+                    ]
+                },
+                GrowthShape: {
+                    oneOf: [
+                        {
+                            "const": "accelerating-log"
+                        },
+                        {
+                            "const": "constant"
+                        },
+                        {
+                            "const": "exponential"
+                        },
+                        {
+                            "const": "polynomial"
+                        },
+                        {
+                            "const": "saturating"
+                        },
+                        {
+                            "const": "unknown"
+                        }
+                    ]
+                },
+                GrowthDiscontinuityKind: {
+                    oneOf: [
+                        {
+                            "const": "drop"
+                        },
+                        {
+                            "const": "none"
+                        },
+                        {
+                            "const": "purchase"
+                        },
+                        {
+                            "const": "reset"
+                        },
+                        {
+                            "const": "sign"
+                        }
+                    ]
+                },
+                ReadonlylogSlopePerSecnumbernulldoublingTimeSecnumbernull: {
+                    type: "object",
+                    properties: {
+                        logSlopePerSec: {
+                            oneOf: [
+                                {
+                                    type: "null"
+                                },
+                                {
+                                    type: "number"
+                                }
+                            ]
+                        },
+                        doublingTimeSec: {
+                            oneOf: [
+                                {
+                                    type: "null"
+                                },
+                                {
+                                    type: "number"
+                                }
+                            ]
+                        }
+                    },
+                    required: [
+                        "logSlopePerSec",
+                        "doublingTimeSec"
+                    ],
+                    additionalProperties: false
+                },
+                "Readonlyspacelog-ratelog10nonevaluermsenumbernull": {
+                    type: "object",
+                    properties: {
+                        space: {
+                            oneOf: [
+                                {
+                                    "const": "log-rate"
+                                },
+                                {
+                                    "const": "log10"
+                                },
+                                {
+                                    "const": "none"
+                                },
+                                {
+                                    "const": "value"
+                                }
+                            ],
+                            description: "\"log-rate\" is the natural log of the per-second growth rate, the space the saturation fit runs in."
+                        },
+                        rmse: {
+                            oneOf: [
+                                {
+                                    type: "null"
+                                },
+                                {
+                                    type: "number"
+                                }
+                            ]
+                        }
+                    },
+                    required: [
+                        "space",
+                        "rmse"
+                    ],
+                    additionalProperties: false
+                }
+            }
+        },
+        schema: {
+            type: "object",
+            properties: {
+                schemaVersion: {
+                    "const": 1
+                },
+                algorithmVersion: {
+                    "const": "growth-fit-v1"
+                },
+                method: {
+                    "const": "heuristic-fit"
+                },
+                status: {
+                    $ref: "#/components/schemas/AnalysisStatus"
+                },
+                seriesRequested: {
+                    oneOf: [
+                        {
+                            "const": "money"
+                        },
+                        {
+                            "const": "netWorth"
+                        }
+                    ]
+                },
+                valueSource: {
+                    oneOf: [
+                        {
+                            "const": "money"
+                        },
+                        {
+                            "const": "netWorth"
+                        },
+                        {
+                            "const": "netWorthFallback"
+                        }
+                    ]
+                },
+                windowSec: {
+                    type: "number"
+                },
+                samplingBudget: {
+                    type: "number"
+                },
+                sampleCount: {
+                    type: "number"
+                },
+                inputSampleCount: {
+                    type: "number"
+                },
+                slopeTolerance: {
+                    type: "number"
+                },
+                fitWindow: {
+                    $ref: "#/components/schemas/ReadonlywindowSecnumberstartSecnumberendSecnumber"
+                },
+                irregular: {
+                    type: "boolean"
+                },
+                claimsResourceBottleneck: {
+                    "const": false
+                },
+                softcap: {
+                    oneOf: [
+                        {
+                            "const": "absent"
+                        },
+                        {
+                            "const": "configured"
+                        },
+                        {
+                            "const": "unknown"
+                        }
+                    ]
+                },
+                cadenceSec: {
+                    type: "number"
+                },
+                cadenceCoarserThanWindow: {
+                    type: "boolean"
+                },
+                downsampled: {
+                    $ref: "#/components/schemas/Readonlyseennumberkeptnumber"
+                },
+                retention: {
+                    $ref: "#/components/schemas/ReadonlytotalSeennumberretainednumberdroppednumber"
+                },
+                assumptions: {
+                    type: "array",
+                    items: {
+                        type: "string"
+                    }
+                },
+                warnings: {
+                    type: "array",
+                    items: {
+                        type: "string"
+                    }
+                },
+                windows: {
+                    type: "array",
+                    items: {
+                        $ref: "#/components/schemas/ReadonlystartSecnumberendSecnumbersampleCountnumberdomainGrowthDomainstatusAnalysisStatusshapeGrowthShapediscontinuityGrowthDiscontinuityKindspeedReadonly---legacySpeedBucketGrowthLegacyBucketnullresidualReadonly---qualitystring"
+                    }
+                }
+            },
+            required: [
+                "schemaVersion",
+                "algorithmVersion",
+                "method",
+                "status",
+                "seriesRequested",
+                "valueSource",
+                "windowSec",
+                "samplingBudget",
+                "sampleCount",
+                "inputSampleCount",
+                "slopeTolerance",
+                "fitWindow",
+                "irregular",
+                "claimsResourceBottleneck",
+                "softcap",
+                "cadenceCoarserThanWindow",
+                "assumptions",
+                "warnings",
+                "windows"
+            ],
+            additionalProperties: false
+        },
+        version: "3.1"
+    };
+}
+let growthFitJsonSchemaUnit;
+/**
+ * @evidence docs/requirements/active/growth-model-classification.md#req-pr12-shape-speed The generated validator accepts this artifact and rejects a missing status.
+ * @evidenceReview docs/requirements/active/growth-model-classification.md#req-pr12-shape-speed #acbd473 Re-read the section: the wire object is growth fit v1.
+ */
+export const validateGrowthFitArtifact = (input) => (growthFitValidator ??= (() => {
+    const _ip0 = input => 1 === input["schemaVersion"];
+    const _ip1 = input => "growth-fit-v1" === input["algorithmVersion"];
+    const _ip2 = input => "heuristic-fit" === input["method"];
+    const _ip3 = input => "censored" === input["status"] || "error" === input["status"] || "insufficient-data" === input["status"] || "invalid" === input["status"] || "ok" === input["status"] || "unknown" === input["status"] || "unsupported" === input["status"];
+    const _ip4 = input => "money" === input["seriesRequested"] || "netWorth" === input["seriesRequested"];
+    const _ip5 = input => "money" === input["valueSource"] || "netWorth" === input["valueSource"] || "netWorthFallback" === input["valueSource"];
+    const _ip6 = input => "number" === typeof input["windowSec"];
+    const _ip7 = input => "number" === typeof input["samplingBudget"];
+    const _ip8 = input => "number" === typeof input["sampleCount"];
+    const _ip9 = input => "number" === typeof input["inputSampleCount"];
+    const _ip10 = input => "number" === typeof input["slopeTolerance"];
+    const _ip11 = input => "object" === typeof input["fitWindow"] && null !== input["fitWindow"] && _io1(input["fitWindow"]);
+    const _ip12 = input => "boolean" === typeof input["irregular"];
+    const _ip13 = input => false === input["claimsResourceBottleneck"];
+    const _ip14 = input => "absent" === input["softcap"] || "configured" === input["softcap"] || "unknown" === input["softcap"];
+    const _ip15 = input => undefined === input["cadenceSec"] || "number" === typeof input["cadenceSec"];
+    const _ip16 = input => "boolean" === typeof input["cadenceCoarserThanWindow"];
+    const _ip17 = input => undefined === input["downsampled"] || "object" === typeof input["downsampled"] && null !== input["downsampled"] && _io2(input["downsampled"]);
+    const _ip18 = input => undefined === input["retention"] || "object" === typeof input["retention"] && null !== input["retention"] && _io3(input["retention"]);
+    const _ip19 = input => Array.isArray(input["assumptions"]) && input["assumptions"].every(elem => "string" === typeof elem);
+    const _ip20 = input => Array.isArray(input["warnings"]) && input["warnings"].every(elem => "string" === typeof elem);
+    const _ip21 = input => Array.isArray(input["windows"]) && input["windows"].every(elem => "object" === typeof elem && null !== elem && _io4(elem));
+    const _ip22 = input => "number" === typeof input["startSec"];
+    const _ip23 = input => "number" === typeof input["endSec"];
+    const _ve0 = "Readonly<{ schemaVersion: 1; algorithmVersion: \"growth-fit-v1\"; method: \"heuristic-fit\"; status: AnalysisStatus; seriesRequested: \"money\" | \"netWorth\"; valueSource: \"money\" | \"netWorth\" | \"netWorthFallback\"; ... 15 more ...; windows: readonly Readonly<...>[]; }>";
+    const _vp0 = (input, _path, _exceptionable = true) => 1 === input["schemaVersion"] || _report(_exceptionable, {
+        path: _path + ".schemaVersion",
+        expected: "1",
+        value: input["schemaVersion"]
+    });
+    const _vp1 = (input, _path, _exceptionable = true) => "growth-fit-v1" === input["algorithmVersion"] || _report(_exceptionable, {
+        path: _path + ".algorithmVersion",
+        expected: "\"growth-fit-v1\"",
+        value: input["algorithmVersion"]
+    });
+    const _vp2 = (input, _path, _exceptionable = true) => "heuristic-fit" === input["method"] || _report(_exceptionable, {
+        path: _path + ".method",
+        expected: "\"heuristic-fit\"",
+        value: input["method"]
+    });
+    const _vp3 = (input, _path, _exceptionable = true) => "censored" === input["status"] || "error" === input["status"] || "insufficient-data" === input["status"] || "invalid" === input["status"] || "ok" === input["status"] || "unknown" === input["status"] || "unsupported" === input["status"] || _report(_exceptionable, {
+        path: _path + ".status",
+        expected: "(\"censored\" | \"error\" | \"insufficient-data\" | \"invalid\" | \"ok\" | \"unknown\" | \"unsupported\")",
+        value: input["status"]
+    });
+    const _vp4 = (input, _path, _exceptionable = true) => "money" === input["seriesRequested"] || "netWorth" === input["seriesRequested"] || _report(_exceptionable, {
+        path: _path + ".seriesRequested",
+        expected: "(\"money\" | \"netWorth\")",
+        value: input["seriesRequested"]
+    });
+    const _vp5 = (input, _path, _exceptionable = true) => "money" === input["valueSource"] || "netWorth" === input["valueSource"] || "netWorthFallback" === input["valueSource"] || _report(_exceptionable, {
+        path: _path + ".valueSource",
+        expected: "(\"money\" | \"netWorth\" | \"netWorthFallback\")",
+        value: input["valueSource"]
+    });
+    const _vp6 = (input, _path, _exceptionable = true) => "number" === typeof input["windowSec"] || _report(_exceptionable, {
+        path: _path + ".windowSec",
+        expected: "number",
+        value: input["windowSec"]
+    });
+    const _vp7 = (input, _path, _exceptionable = true) => "number" === typeof input["samplingBudget"] || _report(_exceptionable, {
+        path: _path + ".samplingBudget",
+        expected: "number",
+        value: input["samplingBudget"]
+    });
+    const _vp8 = (input, _path, _exceptionable = true) => "number" === typeof input["sampleCount"] || _report(_exceptionable, {
+        path: _path + ".sampleCount",
+        expected: "number",
+        value: input["sampleCount"]
+    });
+    const _vp9 = (input, _path, _exceptionable = true) => "number" === typeof input["inputSampleCount"] || _report(_exceptionable, {
+        path: _path + ".inputSampleCount",
+        expected: "number",
+        value: input["inputSampleCount"]
+    });
+    const _vp10 = (input, _path, _exceptionable = true) => "number" === typeof input["slopeTolerance"] || _report(_exceptionable, {
+        path: _path + ".slopeTolerance",
+        expected: "number",
+        value: input["slopeTolerance"]
+    });
+    const _vp11 = (input, _path, _exceptionable = true) => ("object" === typeof input["fitWindow"] && null !== input["fitWindow"] || _report(_exceptionable, {
+        path: _path + ".fitWindow",
+        expected: "Readonly<{ windowSec: number; startSec: number; endSec: number; }>",
+        value: input["fitWindow"]
+    })) && _vo1(input["fitWindow"], _path + ".fitWindow", true && _exceptionable) || _report(_exceptionable, {
+        path: _path + ".fitWindow",
+        expected: "Readonly<{ windowSec: number; startSec: number; endSec: number; }>",
+        value: input["fitWindow"]
+    });
+    const _vp12 = (input, _path, _exceptionable = true) => "boolean" === typeof input["irregular"] || _report(_exceptionable, {
+        path: _path + ".irregular",
+        expected: "boolean",
+        value: input["irregular"]
+    });
+    const _vp13 = (input, _path, _exceptionable = true) => false === input["claimsResourceBottleneck"] || _report(_exceptionable, {
+        path: _path + ".claimsResourceBottleneck",
+        expected: "false",
+        value: input["claimsResourceBottleneck"]
+    });
+    const _vp14 = (input, _path, _exceptionable = true) => "absent" === input["softcap"] || "configured" === input["softcap"] || "unknown" === input["softcap"] || _report(_exceptionable, {
+        path: _path + ".softcap",
+        expected: "(\"absent\" | \"configured\" | \"unknown\")",
+        value: input["softcap"]
+    });
+    const _vp15 = (input, _path, _exceptionable = true) => undefined === input["cadenceSec"] || "number" === typeof input["cadenceSec"] || _report(_exceptionable, {
+        path: _path + ".cadenceSec",
+        expected: "(number | undefined)",
+        value: input["cadenceSec"]
+    });
+    const _vp16 = (input, _path, _exceptionable = true) => "boolean" === typeof input["cadenceCoarserThanWindow"] || _report(_exceptionable, {
+        path: _path + ".cadenceCoarserThanWindow",
+        expected: "boolean",
+        value: input["cadenceCoarserThanWindow"]
+    });
+    const _vp17 = (input, _path, _exceptionable = true) => undefined === input["downsampled"] || ("object" === typeof input["downsampled"] && null !== input["downsampled"] || _report(_exceptionable, {
+        path: _path + ".downsampled",
+        expected: "(Readonly<{ seen: number; kept: number; }> | undefined)",
+        value: input["downsampled"]
+    })) && _vo2(input["downsampled"], _path + ".downsampled", true && _exceptionable) || _report(_exceptionable, {
+        path: _path + ".downsampled",
+        expected: "(Readonly<{ seen: number; kept: number; }> | undefined)",
+        value: input["downsampled"]
+    });
+    const _vp18 = (input, _path, _exceptionable = true) => undefined === input["retention"] || ("object" === typeof input["retention"] && null !== input["retention"] || _report(_exceptionable, {
+        path: _path + ".retention",
+        expected: "(Readonly<{ totalSeen: number; retained: number; dropped: number; }> | undefined)",
+        value: input["retention"]
+    })) && _vo3(input["retention"], _path + ".retention", true && _exceptionable) || _report(_exceptionable, {
+        path: _path + ".retention",
+        expected: "(Readonly<{ totalSeen: number; retained: number; dropped: number; }> | undefined)",
+        value: input["retention"]
+    });
+    const _vp19 = (input, _path, _exceptionable = true) => (Array.isArray(input["assumptions"]) || _report(_exceptionable, {
+        path: _path + ".assumptions",
+        expected: "ReadonlyArray<string>",
+        value: input["assumptions"]
+    })) && input["assumptions"].map((elem, _index4) => "string" === typeof elem || _report(_exceptionable, {
+        path: _path + ".assumptions[" + _index4 + "]",
+        expected: "string",
+        value: elem
+    })).every(flag => flag) || _report(_exceptionable, {
+        path: _path + ".assumptions",
+        expected: "ReadonlyArray<string>",
+        value: input["assumptions"]
+    });
+    const _vp20 = (input, _path, _exceptionable = true) => (Array.isArray(input["warnings"]) || _report(_exceptionable, {
+        path: _path + ".warnings",
+        expected: "ReadonlyArray<string>",
+        value: input["warnings"]
+    })) && input["warnings"].map((elem, _index5) => "string" === typeof elem || _report(_exceptionable, {
+        path: _path + ".warnings[" + _index5 + "]",
+        expected: "string",
+        value: elem
+    })).every(flag => flag) || _report(_exceptionable, {
+        path: _path + ".warnings",
+        expected: "ReadonlyArray<string>",
+        value: input["warnings"]
+    });
+    const _vp21 = (input, _path, _exceptionable = true) => (Array.isArray(input["windows"]) || _report(_exceptionable, {
+        path: _path + ".windows",
+        expected: _ve2,
+        value: input["windows"]
+    })) && input["windows"].map((elem, _index6) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
+        path: _path + ".windows[" + _index6 + "]",
+        expected: _ve1,
+        value: elem
+    })) && _vo4(elem, _path + ".windows[" + _index6 + "]", true && _exceptionable) || _report(_exceptionable, {
+        path: _path + ".windows[" + _index6 + "]",
+        expected: _ve1,
+        value: elem
+    })).every(flag => flag) || _report(_exceptionable, {
+        path: _path + ".windows",
+        expected: _ve2,
+        value: input["windows"]
+    });
+    const _ve1 = "Readonly<{ startSec: number; endSec: number; sampleCount: number; domain: GrowthDomain; status: AnalysisStatus; shape: GrowthShape; discontinuity: GrowthDiscontinuityKind; speed: Readonly<...>; legacySpeedBucket: GrowthLegacyBucket | null; residual: Readonly<...>; quality: string; }>";
+    const _ve2 = "ReadonlyArray<Readonly<{ startSec: number; endSec: number; sampleCount: number; domain: GrowthDomain; status: AnalysisStatus; shape: GrowthShape; discontinuity: GrowthDiscontinuityKind; speed: Readonly<...>; legacySpeedBucket: GrowthLegacyBucket | null; residual: Readonly<...>; quality: string; }>>";
+    const _vp22 = (input, _path, _exceptionable = true) => "number" === typeof input["startSec"] || _report(_exceptionable, {
+        path: _path + ".startSec",
+        expected: "number",
+        value: input["startSec"]
+    });
+    const _vp23 = (input, _path, _exceptionable = true) => "number" === typeof input["endSec"] || _report(_exceptionable, {
+        path: _path + ".endSec",
+        expected: "number",
+        value: input["endSec"]
+    });
+    const _io0 = input => _ip0(input) && _ip1(input) && _ip2(input) && _ip3(input) && _ip4(input) && _ip5(input) && _ip6(input) && _ip7(input) && _ip8(input) && _ip9(input) && _ip10(input) && _ip11(input) && _ip12(input) && _ip13(input) && _ip14(input) && _ip15(input) && _ip16(input) && _ip17(input) && _ip18(input) && _ip19(input) && _ip20(input) && _ip21(input);
+    const _io1 = input => _ip6(input) && _ip22(input) && _ip23(input);
+    const _io2 = input => "number" === typeof input.seen && "number" === typeof input.kept;
+    const _io3 = input => "number" === typeof input.totalSeen && "number" === typeof input.retained && "number" === typeof input.dropped;
+    const _io4 = input => _ip22(input) && _ip23(input) && _ip8(input) && ("empty" === input.domain || "mixed" === input.domain || "negative" === input.domain || "nonfinite" === input.domain || "positive" === input.domain || "zero" === input.domain) && _ip3(input) && ("accelerating-log" === input.shape || "constant" === input.shape || "exponential" === input.shape || "polynomial" === input.shape || "saturating" === input.shape || "unknown" === input.shape) && ("drop" === input.discontinuity || "none" === input.discontinuity || "purchase" === input.discontinuity || "reset" === input.discontinuity || "sign" === input.discontinuity) && ("object" === typeof input.speed && null !== input.speed && _io5(input.speed)) && (null === input.legacySpeedBucket || "exp" === input.legacySpeedBucket || "softcap" === input.legacySpeedBucket || "stall" === input.legacySpeedBucket || "super-exp" === input.legacySpeedBucket) && ("object" === typeof input.residual && null !== input.residual && _io6(input.residual)) && "string" === typeof input.quality;
+    const _io5 = input => (null === input.logSlopePerSec || "number" === typeof input.logSlopePerSec) && (null === input.doublingTimeSec || "number" === typeof input.doublingTimeSec);
+    const _io6 = input => ("log-rate" === input.space || "log10" === input.space || "none" === input.space || "value" === input.space) && (null === input.rmse || "number" === typeof input.rmse);
+    const _vo0 = (input, _path, _exceptionable = true) => [_vp0(input, _path, true && _exceptionable), _vp1(input, _path, true && _exceptionable), _vp2(input, _path, true && _exceptionable), _vp3(input, _path, true && _exceptionable), _vp4(input, _path, true && _exceptionable), _vp5(input, _path, true && _exceptionable), _vp6(input, _path, true && _exceptionable), _vp7(input, _path, true && _exceptionable), _vp8(input, _path, true && _exceptionable), _vp9(input, _path, true && _exceptionable), _vp10(input, _path, true && _exceptionable), _vp11(input, _path, true && _exceptionable), _vp12(input, _path, true && _exceptionable), _vp13(input, _path, true && _exceptionable), _vp14(input, _path, true && _exceptionable), _vp15(input, _path, true && _exceptionable), _vp16(input, _path, true && _exceptionable), _vp17(input, _path, true && _exceptionable), _vp18(input, _path, true && _exceptionable), _vp19(input, _path, true && _exceptionable), _vp20(input, _path, true && _exceptionable), _vp21(input, _path, true && _exceptionable)].every(flag => flag);
+    const _vo1 = (input, _path, _exceptionable = true) => [_vp6(input, _path, true && _exceptionable), _vp22(input, _path, true && _exceptionable), _vp23(input, _path, true && _exceptionable)].every(flag => flag);
+    const _vo2 = (input, _path, _exceptionable = true) => ["number" === typeof input.seen || _report(_exceptionable, {
+            path: _path + ".seen",
+            expected: "number",
+            value: input.seen
+        }), "number" === typeof input.kept || _report(_exceptionable, {
+            path: _path + ".kept",
+            expected: "number",
+            value: input.kept
+        })].every(flag => flag);
+    const _vo3 = (input, _path, _exceptionable = true) => ["number" === typeof input.totalSeen || _report(_exceptionable, {
+            path: _path + ".totalSeen",
+            expected: "number",
+            value: input.totalSeen
+        }), "number" === typeof input.retained || _report(_exceptionable, {
+            path: _path + ".retained",
+            expected: "number",
+            value: input.retained
+        }), "number" === typeof input.dropped || _report(_exceptionable, {
+            path: _path + ".dropped",
+            expected: "number",
+            value: input.dropped
+        })].every(flag => flag);
+    const _vo4 = (input, _path, _exceptionable = true) => [_vp22(input, _path, true && _exceptionable), _vp23(input, _path, true && _exceptionable), _vp8(input, _path, true && _exceptionable), "empty" === input.domain || "mixed" === input.domain || "negative" === input.domain || "nonfinite" === input.domain || "positive" === input.domain || "zero" === input.domain || _report(_exceptionable, {
+            path: _path + ".domain",
+            expected: "(\"empty\" | \"mixed\" | \"negative\" | \"nonfinite\" | \"positive\" | \"zero\")",
+            value: input.domain
+        }), _vp3(input, _path, true && _exceptionable), "accelerating-log" === input.shape || "constant" === input.shape || "exponential" === input.shape || "polynomial" === input.shape || "saturating" === input.shape || "unknown" === input.shape || _report(_exceptionable, {
+            path: _path + ".shape",
+            expected: "(\"accelerating-log\" | \"constant\" | \"exponential\" | \"polynomial\" | \"saturating\" | \"unknown\")",
+            value: input.shape
+        }), "drop" === input.discontinuity || "none" === input.discontinuity || "purchase" === input.discontinuity || "reset" === input.discontinuity || "sign" === input.discontinuity || _report(_exceptionable, {
+            path: _path + ".discontinuity",
+            expected: "(\"drop\" | \"none\" | \"purchase\" | \"reset\" | \"sign\")",
+            value: input.discontinuity
+        }), ("object" === typeof input.speed && null !== input.speed || _report(_exceptionable, {
+            path: _path + ".speed",
+            expected: "Readonly<{ logSlopePerSec: number | null; doublingTimeSec: number | null; }>",
+            value: input.speed
+        })) && _vo5(input.speed, _path + ".speed", true && _exceptionable) || _report(_exceptionable, {
+            path: _path + ".speed",
+            expected: "Readonly<{ logSlopePerSec: number | null; doublingTimeSec: number | null; }>",
+            value: input.speed
+        }), null === input.legacySpeedBucket || "exp" === input.legacySpeedBucket || "softcap" === input.legacySpeedBucket || "stall" === input.legacySpeedBucket || "super-exp" === input.legacySpeedBucket || _report(_exceptionable, {
+            path: _path + ".legacySpeedBucket",
+            expected: "(\"exp\" | \"softcap\" | \"stall\" | \"super-exp\" | null)",
+            value: input.legacySpeedBucket
+        }), ("object" === typeof input.residual && null !== input.residual || _report(_exceptionable, {
+            path: _path + ".residual",
+            expected: "Readonly<{ space: \"log-rate\" | \"log10\" | \"none\" | \"value\"; rmse: number | null; }>",
+            value: input.residual
+        })) && _vo6(input.residual, _path + ".residual", true && _exceptionable) || _report(_exceptionable, {
+            path: _path + ".residual",
+            expected: "Readonly<{ space: \"log-rate\" | \"log10\" | \"none\" | \"value\"; rmse: number | null; }>",
+            value: input.residual
+        }), "string" === typeof input.quality || _report(_exceptionable, {
+            path: _path + ".quality",
+            expected: "string",
+            value: input.quality
+        })].every(flag => flag);
+    const _vo5 = (input, _path, _exceptionable = true) => [null === input.logSlopePerSec || "number" === typeof input.logSlopePerSec || _report(_exceptionable, {
+            path: _path + ".logSlopePerSec",
+            expected: "(null | number)",
+            value: input.logSlopePerSec
+        }), null === input.doublingTimeSec || "number" === typeof input.doublingTimeSec || _report(_exceptionable, {
+            path: _path + ".doublingTimeSec",
+            expected: "(null | number)",
+            value: input.doublingTimeSec
+        })].every(flag => flag);
+    const _vo6 = (input, _path, _exceptionable = true) => ["log-rate" === input.space || "log10" === input.space || "none" === input.space || "value" === input.space || _report(_exceptionable, {
+            path: _path + ".space",
+            expected: "(\"log-rate\" | \"log10\" | \"none\" | \"value\")",
+            value: input.space
+        }), null === input.rmse || "number" === typeof input.rmse || _report(_exceptionable, {
+            path: _path + ".rmse",
+            expected: "(null | number)",
+            value: input.rmse
+        })].every(flag => flag);
+    const __is = input => "object" === typeof input && null !== input && _io0(input);
+    let errors;
+    let _report;
+    return _createStandardSchema_1._createStandardSchema(input => {
+        if (false === __is(input)) {
+            errors = [];
+            _report = _validateReport_1._validateReport(errors);
+            ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _report(true, {
+                path: _path + "",
+                expected: _ve0,
+                value: input
+            })) && _vo0(input, _path + "", true) || _report(true, {
+                path: _path + "",
+                expected: _ve0,
+                value: input
+            }))(input, "$input", true);
+            const success = 0 === errors.length;
+            return success ? {
+                success,
+                data: input
+            } : {
+                success,
+                errors,
+                data: input
+            };
+        }
+        return {
+            success: true,
+            data: input
+        };
+    });
+})())(input);
+/**
+ * @evidence docs/requirements/active/growth-model-classification.md#req-pr12-shape-speed The structural schema is OpenAPI 3.1 from typia.
+ * @evidenceReview docs/requirements/active/growth-model-classification.md#req-pr12-shape-speed #acbd473 Re-read the section: schema version is 3.1.
+ */
+export function growthFitJsonSchema() {
+    growthFitJsonSchemaUnit ??= buildGrowthFitJsonSchema();
+    return growthFitJsonSchemaUnit;
+}
+const ASSUMPTIONS = [
+    "log slope is the least-squares slope of absLog10 per second",
+    "shape and speed are separate fields",
+    "a candidate fit does not prove an asymptotic regime",
+    "negative and zero samples are not passed through abs",
+];
+function assertSampling(sampling) {
+    if (sampling.method !== GROWTH_FIT_ALGORITHM_VERSION || sampling.methodVersion !== 1) {
+        throw new GrowthFitRejected("growth fit requires method growth-fit-v1 version 1");
+    }
+    if (!Number.isInteger(sampling.samplingBudget) || sampling.samplingBudget < 1) {
+        throw new GrowthFitRejected("samplingBudget must be a positive integer");
+    }
+    if (typeof sampling.windowSec !== "number" || !Number.isFinite(sampling.windowSec) || !(sampling.windowSec > 0)) {
+        throw new GrowthFitRejected("windowSec must be a finite number > 0");
+    }
+    if (sampling.cadenceSec !== undefined &&
+        (typeof sampling.cadenceSec !== "number" || !Number.isFinite(sampling.cadenceSec) || !(sampling.cadenceSec > 0))) {
+        throw new GrowthFitRejected("cadenceSec must be a finite number > 0");
+    }
+}
+function readPoint(E, sample) {
+    if (typeof sample.t !== "number" || !Number.isFinite(sample.t)) {
+        throw new GrowthFitRejected("sample time must be a finite number");
+    }
+    if (!E.isFinite(sample.amount)) {
+        return { t: sample.t, sign: "nonfinite", log10: null, numeric: null };
+    }
+    const cmp = E.cmp(sample.amount, E.zero());
+    if (cmp === 0)
+        return { t: sample.t, sign: "zero", log10: null, numeric: 0 };
+    if (cmp < 0)
+        return { t: sample.t, sign: "negative", log10: null, numeric: null };
+    const log10 = E.absLog10(sample.amount);
+    if (!Number.isFinite(log10))
+        return { t: sample.t, sign: "nonfinite", log10: null, numeric: null };
+    let numeric = null;
+    if (log10 <= 300 && log10 >= -300) {
+        const narrowed = E.toNumber(sample.amount);
+        if (Number.isFinite(narrowed) && narrowed > 0)
+            numeric = narrowed;
+    }
+    return { t: sample.t, sign: "positive", log10, numeric };
+}
+function preparePoints(E, samples) {
+    const read = samples.map((sample) => readPoint(E, sample)).sort((left, right) => left.t - right.t);
+    const unique = [];
+    for (const point of read) {
+        const previous = unique[unique.length - 1];
+        if (previous && previous.t === point.t)
+            unique[unique.length - 1] = point;
+        else
+            unique.push(point);
+    }
+    return unique;
+}
+function evenKeep(items, budget) {
+    if (items.length <= budget)
+        return [...items];
+    // A one-point budget keeps the first observation instead of dividing by budget - 1.
+    if (budget <= 1)
+        return items.slice(0, Math.max(0, budget));
+    const last = items.length - 1;
+    const kept = [];
+    for (let index = 0; index < budget; index += 1) {
+        const at = Math.round((index * last) / (budget - 1));
+        const item = items[at];
+        if (item !== undefined && kept[kept.length - 1] !== item)
+            kept.push(item);
+    }
+    return kept;
+}
+/**
+ * Keep samples per fit window, so the budget leaves analyzable windows rather than one point per window. Windows
+ * split the same way slicesOf splits them. When the budget cannot give every window MIN_SAMPLES points, an evenly
+ * spaced subset of windows keeps MIN_SAMPLES each and the rest are left unfitted.
+ */
+/** Two samples hold the same value to within a few ULPs. */
+function sameValue(a, b) {
+    if (a.sign !== b.sign)
+        return false;
+    if (a.numeric !== null && b.numeric !== null) {
+        return Math.abs(b.numeric - a.numeric) <= 4 * Number.EPSILON * Math.max(Math.abs(a.numeric), Math.abs(b.numeric));
+    }
+    return a.log10 !== null && a.log10 === b.log10;
+}
+/**
+ * Thin one window to the budget. A window that settles on its final value keeps its samples for the part before it
+ * settles, plus the settled point and the last one, so a long plateau does not take the samples a saturation fit needs.
+ */
+function thinWindow(window, budget) {
+    if (window.length <= budget)
+        return [...window];
+    const last = window[window.length - 1];
+    let settled = window.length - 1;
+    while (settled > 0 && sameValue(window[settled - 1], last))
+        settled -= 1;
+    // No interior settled samples, or a window that never moves: thin evenly.
+    if (window.length - 1 - settled < 2 || settled === 0)
+        return evenKeep(window, budget);
+    const before = window.slice(0, settled + 1);
+    if (before.length >= budget - 1)
+        return [...evenKeep(before, budget - 1), last];
+    return [...before, ...evenKeep(window.slice(settled + 1), budget - before.length)];
+}
+function windowKeep(items, budget, windowSec, breakTimes) {
+    // Split at breaks first, as slicesOf does, so each side of a break gets its own share of the budget.
+    const opens = new Set();
+    for (const t of breakTimes) {
+        const index = firstIndexAtOrAfter(items, t, false);
+        if (index > 0)
+            opens.add(index);
+    }
+    const segments = [];
+    let segmentStart = 0;
+    for (let index = 1; index <= items.length; index += 1) {
+        if (index === items.length || opens.has(index)) {
+            segments.push(items.slice(segmentStart, index));
+            segmentStart = index;
+        }
+    }
+    const windows = [];
+    for (const segment of segments) {
+        let start = 0;
+        while (start < segment.length) {
+            const endTime = segment[start].t + windowSec;
+            let end = start + 1;
+            while (end < segment.length && segment[end].t <= endTime + 1e-9)
+                end += 1;
+            windows.push(segment.slice(start, end));
+            start = end;
+        }
+    }
+    if (items.length <= budget)
+        return { kept: [...items], windows: windows.length, fittedWindows: windows.length };
+    const perWindow = Math.floor(budget / windows.length);
+    if (perWindow >= MIN_SAMPLES) {
+        return {
+            kept: windows.flatMap((window) => thinWindow(window, perWindow)),
+            windows: windows.length,
+            fittedWindows: windows.length,
+        };
+    }
+    const count = Math.max(1, Math.floor(budget / MIN_SAMPLES));
+    const each = Math.max(1, Math.floor(budget / count));
+    // Spend the budget on windows that can be fitted: enough samples and span. Only when none can is any window used.
+    const fittable = windows
+        .map((window, index) => ({ window, index }))
+        .filter(({ window }) => window.length >= MIN_SAMPLES && window[window.length - 1].t - window[0].t >= MIN_SPAN_SEC)
+        .map(({ index }) => index);
+    const pool = fittable.length > 0 ? fittable : windows.map((_, index) => index);
+    const chosen = evenKeep(pool, count);
+    return {
+        kept: chosen.flatMap((index) => thinWindow(windows[index], each)),
+        windows: windows.length,
+        fittedWindows: chosen.length,
+    };
+}
+function domainOf(points) {
+    if (points.length === 0)
+        return "empty";
+    if (points.some((point) => point.sign === "nonfinite"))
+        return "nonfinite";
+    const signs = new Set(points.map((point) => point.sign));
+    if (signs.size === 1 && signs.has("positive"))
+        return "positive";
+    if (signs.size === 1 && signs.has("negative"))
+        return "negative";
+    if (signs.size === 1 && signs.has("zero"))
+        return "zero";
+    return "mixed";
+}
+function mean(values) {
+    let sum = 0;
+    for (const value of values)
+        sum += value;
+    return sum / values.length;
+}
+function rmseAround(predicted, actual) {
+    let sum = 0;
+    for (let index = 0; index < actual.length; index += 1) {
+        const error = actual[index] - predicted[index];
+        sum += error * error;
+    }
+    return Math.sqrt(sum / actual.length);
+}
+function solve(matrix, rhs) {
+    const size = rhs.length;
+    const rows = matrix.map((row, index) => [...row, rhs[index]]);
+    for (let col = 0; col < size; col += 1) {
+        let pivot = col;
+        for (let row = col + 1; row < size; row += 1) {
+            if (Math.abs(rows[row][col]) > Math.abs(rows[pivot][col]))
+                pivot = row;
+        }
+        const swapped = rows[col];
+        rows[col] = rows[pivot];
+        rows[pivot] = swapped;
+        const diagonal = rows[col][col];
+        if (Math.abs(diagonal) < 1e-18)
+            return null;
+        for (let column = col; column <= size; column += 1)
+            rows[col][column] = rows[col][column] / diagonal;
+        for (let row = 0; row < size; row += 1) {
+            if (row === col)
+                continue;
+            const factor = rows[row][col];
+            for (let column = col; column <= size; column += 1) {
+                rows[row][column] = rows[row][column] - factor * rows[col][column];
+            }
+        }
+    }
+    return rows.map((row) => row[size]);
+}
+/**
+ * Largest |x|, so a fit runs on x / scale. Rebased times can still be wide enough that x * x overflows;
+ * on the scaled axis the moments stay finite, and the coefficients are mapped back.
+ */
+function axisScale(xs) {
+    let scale = 0;
+    for (const x of xs)
+        scale = Math.max(scale, Math.abs(x));
+    return Number.isFinite(scale) && scale > 0 ? scale : 1;
+}
+function fitLinear(xs, ys) {
+    if (xs.length !== ys.length || xs.length < 2)
+        return null;
+    const scale = axisScale(xs);
+    const fit = fitLinearScaled(xs.map((x) => x / scale), ys);
+    if (!fit)
+        return null;
+    const b = fit.b / scale;
+    if (!Number.isFinite(fit.a) || !Number.isFinite(b) || !Number.isFinite(fit.rmse))
+        return null;
+    return { a: fit.a, b, rmse: fit.rmse };
+}
+function fitLinearScaled(xs, ys) {
+    const n = xs.length;
+    let sx = 0;
+    let sy = 0;
+    let sxx = 0;
+    let sxy = 0;
+    for (let index = 0; index < n; index += 1) {
+        const x = xs[index];
+        const y = ys[index];
+        sx += x;
+        sy += y;
+        sxx += x * x;
+        sxy += x * y;
+    }
+    const denom = n * sxx - sx * sx;
+    const b = Math.abs(denom) < 1e-18 ? 0 : (n * sxy - sx * sy) / denom;
+    const a = (sy - b * sx) / n;
+    const predicted = xs.map((x) => a + b * x);
+    return { a, b, rmse: rmseAround(predicted, ys) };
+}
+function fitQuadratic(xs, ys) {
+    if (xs.length !== ys.length || xs.length < 3)
+        return null;
+    const scale = axisScale(xs);
+    const fit = fitQuadraticScaled(xs.map((x) => x / scale), ys);
+    if (!fit)
+        return null;
+    const b = fit.b / scale;
+    const c = fit.c / scale / scale;
+    if (!Number.isFinite(fit.a) || !Number.isFinite(b) || !Number.isFinite(c) || !Number.isFinite(fit.rmse))
+        return null;
+    return { a: fit.a, b, c, rmse: fit.rmse };
+}
+function fitQuadraticScaled(xs, ys) {
+    let sx = 0;
+    let sx2 = 0;
+    let sx3 = 0;
+    let sx4 = 0;
+    let sy = 0;
+    let sxy = 0;
+    let sx2y = 0;
+    for (let index = 0; index < xs.length; index += 1) {
+        const x = xs[index];
+        const y = ys[index];
+        const x2 = x * x;
+        sx += x;
+        sx2 += x2;
+        sx3 += x2 * x;
+        sx4 += x2 * x2;
+        sy += y;
+        sxy += x * y;
+        sx2y += x2 * y;
+    }
+    const solved = solve([
+        [xs.length, sx, sx2],
+        [sx, sx2, sx3],
+        [sx2, sx3, sx4],
+    ], [sy, sxy, sx2y]);
+    if (!solved)
+        return null;
+    const a = solved[0];
+    const b = solved[1];
+    const c = solved[2];
+    const predicted = xs.map((x) => a + b * x + c * x * x);
+    return { a, b, c, rmse: rmseAround(predicted, ys) };
+}
+/**
+ * |mean| of the series, computed on halves so a series near the number range does not overflow the sum.
+ * It is not floored at 1, so a sub-unit series keeps a relative residual and a unit change does not change shape.
+ */
+function seriesScale(values) {
+    let sum = 0;
+    for (const value of values)
+        sum += value / 2;
+    const scale = Math.abs((sum / values.length) * 2);
+    return Number.isFinite(scale) && scale > 0 ? scale : 1;
+}
+/**
+ * Saturation: the growth rate per second decays geometrically. Rates are normalized by each gap, so an
+ * evenly downsampled trace with gaps of 11 and 12 is read the same as the full-resolution trace.
+ */
+/**
+ * The saturation fit's residual in log-rate space, or null when the series is not saturating. A flat tail, where the
+ * series has reached its plateau to the number's precision, is allowed: zero steps are skipped, decreases reject.
+ */
+function saturating(ts, values) {
+    if (values.length < MIN_SAMPLES)
+        return null;
+    const mids = [];
+    const logRates = [];
+    let flat = false;
+    for (let index = 1; index < values.length; index += 1) {
+        const gap = ts[index] - ts[index - 1];
+        const step = values[index] - values[index - 1];
+        if (!(gap > 0) || step < 0 || Number.isNaN(step))
+            return null;
+        // A step within a few ULPs of the values is rounding at the plateau, not growth.
+        const rounding = 4 * Number.EPSILON * Math.max(Math.abs(values[index]), Math.abs(values[index - 1]));
+        if (step <= rounding) {
+            flat = true;
+            continue;
+        }
+        // Real growth after the plateau means the series did not saturate there.
+        if (flat)
+            return null;
+        // previous + gap / 2, not (previous + next) / 2: two finite times near the number limit can sum to Infinity.
+        mids.push(ts[index - 1] + gap / 2);
+        // log(step) - log(gap): the quotient of finite operands can underflow even when its log is representable.
+        logRates.push(Math.log(step) - Math.log(gap));
+    }
+    if (logRates.length < 4)
+        return null;
+    const fit = fitLinear(mids, logRates);
+    if (!fit || !(fit.b < 0) || fit.rmse > 0.1)
+        return null;
+    // The decay is judged over the whole span, not per retained gap, so downsampling cannot change the verdict.
+    return Math.exp(logRates[logRates.length - 1] - logRates[0]) < 0.25 ? fit.rmse : null;
+}
+function irregularSpacing(points) {
+    const gaps = [];
+    for (let index = 1; index < points.length; index += 1) {
+        gaps.push(points[index].t - points[index - 1].t);
+    }
+    if (gaps.length < 2)
+        return false;
+    // A loop, not Math.min(...gaps): a million-point trace exceeds the argument limit of a spread call.
+    let count = 0;
+    let smallest = Number.POSITIVE_INFINITY;
+    let largest = 0;
+    for (const gap of gaps) {
+        if (!(gap > 0))
+            continue;
+        count += 1;
+        if (gap < smallest)
+            smallest = gap;
+        if (gap > largest)
+            largest = gap;
+    }
+    if (count < 2)
+        return false;
+    return largest / smallest > 3;
+}
+function blankWindow(points, discontinuity, status, quality) {
+    const first = points[0];
+    const last = points[points.length - 1];
+    return {
+        startSec: first?.t ?? 0,
+        endSec: last?.t ?? 0,
+        sampleCount: points.length,
+        domain: domainOf(points),
+        status,
+        shape: "unknown",
+        discontinuity,
+        speed: { logSlopePerSec: null, doublingTimeSec: null },
+        legacySpeedBucket: null,
+        residual: { space: "none", rmse: null },
+        quality,
+    };
+}
+function classifyPositive(points, discontinuity, originSec = points[0]?.t ?? 0) {
+    const first = points[0];
+    const last = points[points.length - 1];
+    const span = last.t - first.t;
+    const logs = points.map((point) => point.log10);
+    if (points.length < MIN_SAMPLES || span < MIN_SPAN_SEC || logs.some((value) => value === null)) {
+        return blankWindow(points, discontinuity, "insufficient-data", `samples ${points.length} span ${span}`);
+    }
+    // Fit log values relative to the first one. A large log offset, such as 1e12, otherwise drowns the low-order
+    // digits of the regression sums, and the shape would depend on the series scale.
+    const logOrigin = logs[0];
+    const ys = logs.map((value) => value - logOrigin);
+    // Fit on time since the window start. Raw moments of a large absolute t cancel catastrophically.
+    const ts = points.map((point) => point.t - first.t);
+    // A loop, not Math.max(...ys): a large sampling budget can exceed the argument limit of a spread call.
+    let logLow = Number.POSITIVE_INFINITY;
+    let logHigh = Number.NEGATIVE_INFINITY;
+    for (const y of ys) {
+        if (y < logLow)
+            logLow = y;
+        if (y > logHigh)
+            logHigh = y;
+    }
+    const logSpan = logHigh - logLow;
+    const linear = fitLinear(ts, ys);
+    const quadratic = fitQuadratic(ts, ys);
+    // A power law is fitted from the window start and from the start of its break segment, and the closer fit is kept.
+    // Window partitioning alone then does not change a power law's shape.
+    const localPower = fitLinear(ts.map((t) => Math.log10(t + 1)), ys);
+    const segmentPower = originSec < first.t ? fitLinear(points.map((point) => Math.log10(point.t - originSec + 1)), ys) : null;
+    // The absolute time origin too, when every time is past it, so a trace that starts late keeps the law's basis.
+    const absolutePower = first.t > 0 && Number.isFinite(last.t + 1) ? fitLinear(points.map((point) => Math.log10(point.t + 1)), ys) : null;
+    let power = localPower;
+    for (const candidate of [segmentPower, absolutePower]) {
+        if (candidate !== null && (power === null || candidate.rmse < power.rmse))
+            power = candidate;
+    }
+    // Value-space fits read each amount relative to the window's largest, through its log, when the amount itself is
+    // outside the Number range. A unit change, such as a factor of 1e400, does not switch value-space shapes off.
+    const direct = points.map((point) => point.numeric);
+    const numbers = direct.every((value) => value !== null)
+        ? direct
+        : ys.map((y) => 10 ** (y - logHigh));
+    const valueReady = numbers.every((value) => value !== null && Number.isFinite(value));
+    // Value-space fits run in units of the series scale, so a large series cannot overflow the squared error.
+    const valueScale = valueReady ? seriesScale(numbers) : 1;
+    const scaled = valueReady ? numbers.map((value) => value / valueScale) : [];
+    const valueLinear = valueReady ? fitLinear(ts, scaled) : null;
+    const valueQuadratic = valueReady ? fitQuadratic(ts, scaled) : null;
+    const valueLinearRel = valueLinear ? valueLinear.rmse : null;
+    const valueQuadraticRel = valueQuadratic ? valueQuadratic.rmse : null;
+    const valueRmse = valueLinearRel === null
+        ? null
+        : valueQuadraticRel === null
+            ? valueLinearRel
+            : Math.min(valueLinearRel, valueQuadraticRel);
+    const numericValues = valueReady ? numbers.map((value) => value ?? 0) : [];
+    const expOk = linear !== null && linear.rmse <= LOG_RMSE_OK;
+    // Acceleration is the quadratic term standing well above its residual across the window, with the quadratic fit a
+    // clear improvement on the line. A fixed minimum line residual would make the shape depend on acceleration strength.
+    const accelOk = quadratic !== null &&
+        linear !== null &&
+        quadratic.c > 0 &&
+        quadratic.c * span * span > 1e3 * Math.max(quadratic.rmse, Number.EPSILON) &&
+        quadratic.rmse <= LOG_RMSE_OK &&
+        linear.rmse > quadratic.rmse * 4;
+    const powerOk = power !== null && linear !== null && power.rmse <= 1e-3 && power.rmse * 4 < linear.rmse;
+    const valuePolyOk = valueRmse !== null && valueRmse <= VALUE_REL_OK;
+    const satRmse = valueReady ? saturating(ts, numericValues) : null;
+    const satOk = satRmse !== null;
+    let shape = "unknown";
+    let residual = {
+        space: "log10",
+        rmse: linear?.rmse ?? null,
+    };
+    // An exact value-space line or parabola is polynomial whatever its intercept. A large intercept can make
+    // the same series look nearly straight in log space.
+    // An exact log fit keeps precedence: a value fit wins only when it is closer than the log fit's
+    // relative error (log10 residual times ln 10), so a slow exponential is not read as a parabola.
+    const valueExact = valueRmse !== null &&
+        valueRmse <= VALUE_EXACT &&
+        !(linear !== null && linear.rmse * Math.LN10 < valueRmse) &&
+        !(accelOk && quadratic !== null && quadratic.rmse * Math.LN10 < valueRmse) &&
+        !(powerOk && power !== null && power.rmse * Math.LN10 < valueRmse);
+    // An exact value fit whose change across the window stands well above its residual is a moving series, even
+    // when a large intercept leaves almost no log span. A constant series fits exactly too, but does not move.
+    const valueMoves = valueExact &&
+        ((valueLinear !== null && Math.abs(valueLinear.b * span) > 1e3 * Math.max(valueLinear.rmse, Number.EPSILON)) ||
+            (valueQuadratic !== null &&
+                Math.abs(valueQuadratic.c * span * span) > 1e3 * Math.max(valueQuadratic.rmse, Number.EPSILON)));
+    // The same holds in log space: an exact log-linear fit with a real slope is a slow exponential, not a constant.
+    const logMoves = linear !== null && Math.abs(linear.b * span) > 1e3 * Math.max(linear.rmse, Number.EPSILON);
+    // Detected saturation is not constant, and its decaying rates rule out exponential, accelerating, and power
+    // growth. A value fit exact only against the series scale, not against its movement, does not outrank it either,
+    // so a large baseline under the same curve keeps the shape.
+    if (logSpan < 1e-6 && !valueMoves && !logMoves && !satOk) {
+        shape = "constant";
+        residual = { space: "log10", rmse: rmseAround(ys.map(() => mean(ys)), ys) };
+    }
+    else if (valueExact && (valueMoves || !satOk)) {
+        shape = "polynomial";
+        residual = { space: "value", rmse: valueRmse };
+    }
+    else if (satOk) {
+        shape = "saturating";
+        // The saturation fit's own error, not the unrelated value-space line or parabola.
+        residual = { space: "log-rate", rmse: satRmse };
+    }
+    else if (expOk && !accelOk && !(powerOk && power !== null && power.rmse * 100 < linear.rmse)) {
+        // A power fit far closer than the log-linear one is a power law that only looks exponential over this window.
+        shape = "exponential";
+        residual = { space: "log10", rmse: linear.rmse };
+    }
+    else if (accelOk && quadratic) {
+        shape = "accelerating-log";
+        residual = { space: "log10", rmse: quadratic.rmse };
+    }
+    else if (powerOk && power) {
+        shape = "polynomial";
+        residual = { space: "log10", rmse: power.rmse };
+    }
+    else if (valuePolyOk) {
+        shape = "polynomial";
+        residual = { space: "value", rmse: valueRmse };
+    }
+    const slope = linear && Number.isFinite(linear.b) ? linear.b : null;
+    const status = shape === "unknown" ? "unknown" : "ok";
+    const legacy = status === "ok" && slope !== null ? legacyGrowthSpeedBucket(slope) : null;
+    return {
+        startSec: first.t,
+        endSec: last.t,
+        sampleCount: points.length,
+        domain: "positive",
+        status,
+        shape,
+        discontinuity,
+        speed: {
+            logSlopePerSec: slope,
+            // Any positive slope has a doubling time while the quotient is finite.
+            doublingTimeSec: slope !== null && slope > 0 && Number.isFinite(Math.log10(2) / slope) ? Math.log10(2) / slope : null,
+        },
+        legacySpeedBucket: legacy,
+        residual,
+        quality: `shape=${shape}; logSpan=${logSpan}; exp=${linear?.rmse ?? "none"}; quad=${quadratic?.rmse ?? "none"}; quadC=${quadratic?.c ?? "none"}; power=${power?.rmse ?? "none"}; value=${valueRmse ?? "none"}; sat=${satOk}`,
+    };
+}
+function classifySlice(slice) {
+    const domain = domainOf(slice.points);
+    if (domain !== "positive") {
+        const status = domain === "empty" ? "insufficient-data" : "invalid";
+        return blankWindow(slice.points, slice.discontinuity, status, `domain ${domain}`);
+    }
+    return classifyPositive(slice.points, slice.discontinuity, slice.originSec);
+}
+const BREAK_RANK = { reset: 4, drop: 3, sign: 2, purchase: 1 };
+/**
+ * Breaks keyed by time. One time keeps the highest-ranked kind: reset, then drop, then sign, then purchase.
+ * The map keeps a lookup O(1), so a trace that alternates sign on every point stays linear.
+ */
+function pushBreak(breaks, next) {
+    const existing = breaks.get(next.t);
+    if (!existing || BREAK_RANK[next.kind] > BREAK_RANK[existing.kind])
+        breaks.set(next.t, next);
+}
+/**
+ * Index of the first time-ordered item at or after `t` (strictly after when `strict`), or -1.
+ * Binary search keeps break and action lookups at O(log n) per item.
+ */
+function firstIndexAtOrAfter(items, t, strict) {
+    let low = 0;
+    let high = items.length;
+    while (low < high) {
+        const mid = (low + high) >>> 1;
+        const at = items[mid].t;
+        if (strict ? at > t : at >= t)
+            high = mid;
+        else
+            low = mid + 1;
+    }
+    return low < items.length ? low : -1;
+}
+function slicesOf(points, breaks, windowSec) {
+    const opening = points.map(() => "none");
+    for (const item of breaks) {
+        const index = firstIndexAtOrAfter(points, item.t, false);
+        if (index <= 0)
+            continue;
+        // Breaks that open at one kept point keep the same precedence as breaks at one time.
+        const current = opening[index];
+        if (current === "none" || BREAK_RANK[item.kind] > BREAK_RANK[current])
+            opening[index] = item.kind;
+    }
+    const coarse = [];
+    let start = 0;
+    for (let index = 1; index < points.length; index += 1) {
+        if (opening[index] === "none")
+            continue;
+        coarse.push({ start, end: index, discontinuity: opening[start] ?? "none" });
+        start = index;
+    }
+    coarse.push({ start, end: points.length, discontinuity: opening[start] ?? "none" });
+    const slices = [];
+    for (const segment of coarse) {
+        let cursor = segment.start;
+        let first = true;
+        while (cursor < segment.end) {
+            const endTime = points[cursor].t + windowSec;
+            let next = cursor + 1;
+            while (next < segment.end && points[next].t <= endTime + 1e-9)
+                next += 1;
+            if (next === cursor)
+                next = cursor + 1;
+            slices.push({
+                points: points.slice(cursor, next),
+                discontinuity: first ? segment.discontinuity : "none",
+                originSec: points[segment.start].t,
+            });
+            first = false;
+            cursor = next;
+        }
+    }
+    return slices;
+}
+function rollup(windows) {
+    if (windows.length === 0)
+        return "insufficient-data";
+    const statuses = new Set(windows.map((window) => window.status));
+    if (statuses.size === 1)
+        return windows[0].status;
+    if (windows.some((window) => window.status === "ok"))
+        return "ok";
+    return "unknown";
+}
+function baseArtifact(args) {
+    const first = args.points[0];
+    const last = args.points[args.points.length - 1];
+    return {
+        schemaVersion: 1,
+        algorithmVersion: GROWTH_FIT_ALGORITHM_VERSION,
+        method: "heuristic-fit",
+        status: rollup(args.windows),
+        seriesRequested: args.seriesRequested,
+        valueSource: args.valueSource,
+        windowSec: args.sampling.windowSec,
+        samplingBudget: args.sampling.samplingBudget,
+        sampleCount: args.sampleCount,
+        inputSampleCount: args.inputSampleCount,
+        slopeTolerance: SLOPE_TOLERANCE,
+        fitWindow: {
+            windowSec: args.sampling.windowSec,
+            startSec: first?.t ?? 0,
+            endSec: last?.t ?? 0,
+        },
+        irregular: args.irregular,
+        claimsResourceBottleneck: false,
+        softcap: args.softcap,
+        ...(args.sampling.cadenceSec !== undefined ? { cadenceSec: args.sampling.cadenceSec } : {}),
+        cadenceCoarserThanWindow: args.sampling.cadenceSec !== undefined && args.sampling.cadenceSec >= args.sampling.windowSec,
+        ...(args.downsampled ? { downsampled: args.downsampled } : {}),
+        ...(args.retention ? { retention: args.retention } : {}),
+        assumptions: ASSUMPTIONS,
+        warnings: args.warnings,
+        windows: args.windows,
+    };
+}
+/**
+ * Fit one observed series.
+ * Amounts stay in the Engine until a finite log10, or a safe number, is required.
+ */
+export function fitGrowth(args) {
+    assertSampling(args.sampling);
+    const prepared = preparePoints(args.E, args.samples);
+    // Find sign changes and drops on every prepared point, then keep both sides of each break through the
+    // sampling budget, so downsampling cannot hide an invalid domain or a discontinuity.
+    // Supplied breaks go through the same precedence as detected ones, so a purchase cannot replace a reset.
+    const breakMap = new Map();
+    for (const item of args.discontinuities ?? [])
+        pushBreak(breakMap, item);
+    const boundary = new Set();
+    for (let index = 1; index < prepared.length; index += 1) {
+        const previous = prepared[index - 1];
+        const current = prepared[index];
+        let found = false;
+        if (previous.sign !== current.sign) {
+            pushBreak(breakMap, { t: current.t, kind: "sign" });
+            found = true;
+        }
+        if (previous.sign === "positive" &&
+            current.sign === "positive" &&
+            previous.log10 !== null &&
+            current.log10 !== null &&
+            // An exact tenfold drop is a drop. The tolerance absorbs log10 rounding.
+            previous.log10 - current.log10 >= DROP_LOG10 - 1e-9) {
+            pushBreak(breakMap, { t: current.t, kind: "drop" });
+            found = true;
+        }
+        if (found) {
+            boundary.add(index - 1);
+            boundary.add(index);
+        }
+    }
+    const breaks = [...breakMap.values()].sort((left, right) => left.t - right.t);
+    for (const item of breaks) {
+        const index = firstIndexAtOrAfter(prepared, item.t, false);
+        if (index >= 0) {
+            boundary.add(index);
+            if (index > 0)
+                boundary.add(index - 1);
+        }
+    }
+    const breakTimes = [...breakMap.values()].map((item) => item.t);
+    const windowed = windowKeep(prepared, args.sampling.samplingBudget, args.sampling.windowSec, breakTimes);
+    const keptSet = new Set(windowed.kept);
+    for (const index of boundary)
+        keptSet.add(prepared[index]);
+    const kept = prepared.filter((point) => keptSet.has(point));
+    const downsampled = kept.length === prepared.length ? undefined : { seen: prepared.length, kept: kept.length };
+    const warnings = [
+        "A candidate fit is not a proof of the asymptotic regime.",
+        "legacySpeedBucket is the old slope threshold. It is not the shape and it is not a cause.",
+    ];
+    if (args.softcap === "configured") {
+        warnings.push("A configured softcap is recorded separately. It does not choose the shape.");
+    }
+    if (downsampled) {
+        warnings.push("Samples were evenly reduced to the sampling budget. windowSec is still the time window.");
+    }
+    if (windowed.fittedWindows < windowed.windows) {
+        warnings.push(`The sampling budget fits ${windowed.fittedWindows} of ${windowed.windows} windows with enough samples. The rest are not fitted.`);
+    }
+    if (args.retention && args.retention.dropped > 0) {
+        warnings.push("The fit sees the retained trace only.");
+    }
+    // Irregular spacing is a property of the input cadence; the sampling budget must not hide it.
+    const irregular = irregularSpacing(prepared);
+    if (irregular)
+        warnings.push("Sample spacing is irregular. Observed times are not rewritten onto a grid.");
+    const cadenceCoarse = args.sampling.cadenceSec !== undefined && args.sampling.cadenceSec >= args.sampling.windowSec;
+    if (cadenceCoarse) {
+        warnings.push("Cadence is coarser than windowSec, so the window is not identified.");
+        return baseArtifact({
+            seriesRequested: args.seriesRequested,
+            valueSource: args.valueSource,
+            sampling: args.sampling,
+            inputSampleCount: prepared.length,
+            sampleCount: kept.length,
+            points: kept,
+            softcap: args.softcap ?? "unknown",
+            retention: args.retention,
+            downsampled,
+            irregular,
+            warnings,
+            // Coarse cadence hides the window, not the observed domain. Non-positive or nonfinite values stay invalid.
+            windows: [
+                blankWindow(kept, "none", domainOf(kept) === "positive" || domainOf(kept) === "empty" ? "insufficient-data" : "invalid", "cadence coarser than window"),
+            ],
+        });
+    }
+    const fitted = kept.length === 0
+        ? [blankWindow(kept, "none", "insufficient-data", "no retained samples")]
+        : slicesOf(kept, breaks, args.sampling.windowSec).map((slice) => classifySlice(slice));
+    if (kept.length > args.sampling.samplingBudget) {
+        warnings.push("Break boundary points were kept beyond the sampling budget.");
+    }
+    const incomplete = args.actionHistory === "incomplete";
+    if (incomplete) {
+        warnings.push("The action history is incomplete, so a purchase break can be missing. Shape claims are withheld.");
+    }
+    const windows = incomplete
+        ? fitted.map((window) => 
+        // A fitted window, classified or not, read samples a missing purchase break may have split.
+        window.status === "ok" || window.status === "unknown"
+            ? {
+                ...window,
+                status: "insufficient-data",
+                shape: "unknown",
+                // The fitted shape's residual, speed, and diagnostics would restate the withheld claim.
+                speed: { logSlopePerSec: null, doublingTimeSec: null },
+                legacySpeedBucket: null,
+                residual: { space: "none", rmse: null },
+                quality: `action history incomplete; samples ${window.sampleCount}`,
+            }
+            : window)
+        : fitted;
+    return baseArtifact({
+        seriesRequested: args.seriesRequested,
+        valueSource: args.valueSource,
+        sampling: args.sampling,
+        inputSampleCount: prepared.length,
+        sampleCount: kept.length,
+        points: kept,
+        softcap: args.softcap ?? "unknown",
+        retention: args.retention,
+        downsampled,
+        irregular,
+        warnings,
+        windows,
+    });
+}
+function softcapOf(scenario, explicit, state) {
+    if (explicit)
+        return explicit;
+    if (!scenario?.model.analytic)
+        return scenario ? "absent" : "unknown";
+    // The hint is read at the analyzed run's start, not the scenario's opening state, so a resumed run is judged
+    // by the state it fitted.
+    const hint = scenario.model.analytic(scenario.ctx, state ?? scenario.initial);
+    return hint?.softcap ? "configured" : "absent";
+}
+/**
+ * The break an action row opens. Action.kind is the source of truth: a prestige action is a reset, and every other
+ * action is a purchase whatever its id says, unless a prestige count change confirms a reset.
+ */
+function actionBreakKind(scenario, before, actionId) {
+    const matches = before ? scenario.model.actions(scenario.ctx, before).filter((action) => action.id === actionId) : [];
+    // The log keeps only the id. When actions of different kinds share it, the applied kind is unknown, so the row is
+    // a purchase unless a prestige count change confirms a reset.
+    if (new Set(matches.map((action) => action.kind)).size > 1)
+        return "purchase";
+    const listed = matches[0];
+    if (listed?.kind === "prestige")
+        return "reset";
+    // A custom action, or one the model did not list at the traced state, such as one unlocked between trace points, is
+    // a purchase unless a prestige count change confirms a reset; the count loop below adds those. An id is not
+    // evidence of what the action does.
+    return "purchase";
+}
+/**
+ * Read a run without converting the whole amount to Number first.
+ * `netWorthFallback` matches `analyzeGrowth` when the model has no net worth.
+ */
+export function fitGrowthFromRun(args) {
+    if (args.series === "netWorth" && !args.scenario) {
+        throw new Error("analyzeGrowth requires compiled scenario when series='netWorth'");
+    }
+    const hasNetWorth = args.scenario.model.netWorth !== undefined;
+    const valueSource = args.series === "money" ? "money" : hasNetWorth ? "netWorth" : "netWorthFallback";
+    // A present but empty trace was emptied by retention. It is not replaced by start and end.
+    const states = args.run.trace !== undefined ? args.run.trace : [args.run.start, args.run.end];
+    const samples = states.map((state) => ({
+        t: state.t,
+        amount: valueSource === "netWorth"
+            ? args.scenario.model.netWorth(args.scenario.ctx, state).amount
+            : state.wallet.money.amount,
+    }));
+    const discontinuities = [];
+    for (const row of args.run.actionsLog ?? []) {
+        // An action row is stamped at decision time; the trace point at that t is the state before it.
+        // The break opens at the first trace state strictly after the action, found by binary search.
+        const afterIndex = firstIndexAtOrAfter(states, row.t, true);
+        const after = states[afterIndex];
+        if (!after)
+            continue;
+        discontinuities.push({ t: after.t, kind: actionBreakKind(args.scenario, states[afterIndex - 1], row.actionId) });
+    }
+    const loggedEveryAction = args.run.actionsLog !== undefined && (args.run.actionsLogMeta?.dropped ?? 0) === 0;
+    // A zero count proves no action ran only when the counter was observed. A disabled observation reports 0 too.
+    const noActionApplied = args.run.stats?.actions.status === "observed" && args.run.stats.actions.applied === 0;
+    let previousCount = states[0]?.prestige.count;
+    for (const state of states.slice(1)) {
+        if (previousCount !== undefined && state.prestige.count !== previousCount) {
+            discontinuities.push({ t: state.t, kind: "reset" });
+        }
+        previousCount = state.prestige.count;
+    }
+    return fitGrowth({
+        E: args.scenario.ctx.E,
+        samples,
+        seriesRequested: args.series,
+        valueSource,
+        sampling: args.sampling,
+        discontinuities,
+        actionHistory: loggedEveryAction || noActionApplied ? "complete" : "incomplete",
+        softcap: softcapOf(args.scenario, args.softcap, args.run.start),
+        retention: args.run.traceLog
+            ? {
+                totalSeen: args.run.traceLog.totalSeen,
+                retained: args.run.traceLog.retained,
+                dropped: args.run.traceLog.dropped,
+            }
+            : undefined,
+    });
+}
+//# sourceMappingURL=growthFit.js.map