@idlekit/core 0.2.1 → 0.3.0

package/dist/sim/analysis/eta.js

@@ -1,26 +1,886 @@
+import * as _validateReport_1 from "typia/lib/internal/_validateReport";
+import * as _createStandardSchema_1 from "typia/lib/internal/_createStandardSchema";
+import { parseMoney } from "../../notation/parseMoney";
 import { runScenario } from "../simulator";
 import { assertHorizonReached, runElapsedSec } from "../types";
-import { parseMoney } from "../../notation/parseMoney";
-function targetReached(scenario, targetKind, threshold, run) {
-    const { E } = scenario.ctx;
-    if (targetKind === "money") {
-        return E.cmp(run.end.wallet.money.amount, threshold) >= 0;
+import { evaluateGoal, moneyAtLeast, netWorthAtLeast, walletMoneyMetric, } from "./metrics";
+import typia, {} from "typia";
+/**
+ * ETA estimate v1.
+ * Legacy `ETAResult.seconds` stays a number. This object carries status.
+ * DX-02 may wrap these functions. It should not grow a second ETA engine.
+ */
+const ETA_SUFFIX = { kind: "alphaInfinite", minLen: 2 };
+const ETA_ALGORITHM_VERSION = "eta-estimate-v1";
+const ETA_SCHEMA_ID = "https://idlekit.dev/schemas/eta.estimate.v1.schema.json";
+/**
+ * @evidence docs/requirements/active/eta-numeric-and-goal-semantics.md#req-pr09-engine-ratio The time ratio is divided inside the Engine before any seconds number.
+ * @evidenceReview docs/requirements/active/eta-numeric-and-goal-semantics.md#req-pr09-engine-ratio #fe46221 Re-read the section: 1e402 over 1e400 is 100 seconds, not a narrowed division.
+ */
+export const etaEngineRatio = "engine-divn-before-number";
+/**
+ * @evidence docs/requirements/active/eta-numeric-and-goal-semantics.md#req-pr09-exact-local Exact needs a constant derivative, declared strict comparison, and no purchase, reset, evolve, or policy boundary.
+ * @evidenceReview docs/requirements/active/eta-numeric-and-goal-semantics.md#req-pr09-exact-local #f2b843f Re-read the section: exact needs comparisonIsExact true, tolerant or unknown comparisons remain local, and net worth is not money income.
+ */
+export const etaExactOrLocal = "exact-or-analytic-local";
+/**
+ * @evidence docs/requirements/active/eta-numeric-and-goal-semantics.md#req-pr09-censored-observation A missed horizon is censored. Fixed-step time is the first observation.
+ * @evidenceReview docs/requirements/active/eta-numeric-and-goal-semantics.md#req-pr09-censored-observation #a644d35 Re-read the section: seconds is null, the legacy field stays the horizon, and there is no unreachable claim.
+ */
+export const etaCensoredObservation = "censored-fixed-step";
+export function etaEstimateSchemaId() {
+    return ETA_SCHEMA_ID;
+}
+export function etaEstimateAlgorithmVersion() {
+    return ETA_ALGORITHM_VERSION;
+}
+/*
+ * 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 etaEstimateValidator;
+export const validateEtaEstimate = (input) => (etaEstimateValidator ??= (() => {
+    const _ip0 = input => 1 === input["schemaVersion"];
+    const _ip1 = input => "eta-estimate-v1" === input["algorithmVersion"];
+    const _ip2 = input => "string" === typeof input["goalId"];
+    const _ip3 = input => "number" === typeof input["goalVersion"];
+    const _ip4 = input => "string" === typeof input["metricId"];
+    const _ip5 = input => "string" === typeof input["meaning"];
+    const _ip6 = input => "interval" === input["timeAxis"];
+    const _ip7 = input => "object" === typeof input["target"] && null !== input["target"] && _io1(input["target"]);
+    const _ip8 = input => "censored" === input["status"] || "error" === input["status"] || "insufficient-data" === input["status"] || "invalid" === input["status"] || "ok" === input["status"] || "unknown" === input["status"] || "unsupported" === input["status"];
+    const _ip9 = input => undefined === input["method"] || "analytic-local" === input["method"] || "exact" === input["method"] || "fixed-step" === input["method"] || "heuristic-fit" === input["method"] || "monte-carlo" === input["method"];
+    const _ip10 = input => null === input["seconds"] || "number" === typeof input["seconds"];
+    const _ip11 = input => undefined === input["secondsDecimal"] || "string" === typeof input["secondsDecimal"];
+    const _ip12 = input => undefined === input["observationResolutionSec"] || "number" === typeof input["observationResolutionSec"];
+    const _ip13 = input => undefined === input["bracket"] || "object" === typeof input["bracket"] && null !== input["bracket"] && _io2(input["bracket"]);
+    const _ip14 = input => Array.isArray(input["assumptions"]) && input["assumptions"].every(elem => "string" === typeof elem);
+    const _ip15 = input => Array.isArray(input["warnings"]) && input["warnings"].every(elem => "string" === typeof elem);
+    const _ip16 = input => undefined === input["horizonSec"] || "number" === typeof input["horizonSec"];
+    const _ip17 = input => undefined === input["compare"] || "object" === typeof input["compare"] && null !== input["compare"] && _io3(input["compare"]);
+    const _ve0 = "Readonly<{ schemaVersion: 1; algorithmVersion: \"eta-estimate-v1\"; goalId: string; goalVersion: number; metricId: string; meaning: string; timeAxis: \"interval\"; target: Readonly<{ kind: \"money\" | \"netWorth\"; decimal: string; unit: string; }>; ... 9 more ...; compare?: Readonly<...> | undefined; }>";
+    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) => "eta-estimate-v1" === input["algorithmVersion"] || _report(_exceptionable, {
+        path: _path + ".algorithmVersion",
+        expected: "\"eta-estimate-v1\"",
+        value: input["algorithmVersion"]
+    });
+    const _vp2 = (input, _path, _exceptionable = true) => "string" === typeof input["goalId"] || _report(_exceptionable, {
+        path: _path + ".goalId",
+        expected: "string",
+        value: input["goalId"]
+    });
+    const _vp3 = (input, _path, _exceptionable = true) => "number" === typeof input["goalVersion"] || _report(_exceptionable, {
+        path: _path + ".goalVersion",
+        expected: "number",
+        value: input["goalVersion"]
+    });
+    const _vp4 = (input, _path, _exceptionable = true) => "string" === typeof input["metricId"] || _report(_exceptionable, {
+        path: _path + ".metricId",
+        expected: "string",
+        value: input["metricId"]
+    });
+    const _vp5 = (input, _path, _exceptionable = true) => "string" === typeof input["meaning"] || _report(_exceptionable, {
+        path: _path + ".meaning",
+        expected: "string",
+        value: input["meaning"]
+    });
+    const _vp6 = (input, _path, _exceptionable = true) => "interval" === input["timeAxis"] || _report(_exceptionable, {
+        path: _path + ".timeAxis",
+        expected: "\"interval\"",
+        value: input["timeAxis"]
+    });
+    const _vp7 = (input, _path, _exceptionable = true) => ("object" === typeof input["target"] && null !== input["target"] || _report(_exceptionable, {
+        path: _path + ".target",
+        expected: "Readonly<{ kind: \"money\" | \"netWorth\"; decimal: string; unit: string; }>",
+        value: input["target"]
+    })) && _vo1(input["target"], _path + ".target", true && _exceptionable) || _report(_exceptionable, {
+        path: _path + ".target",
+        expected: "Readonly<{ kind: \"money\" | \"netWorth\"; decimal: string; unit: string; }>",
+        value: input["target"]
+    });
+    const _vp8 = (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 _vp9 = (input, _path, _exceptionable = true) => undefined === input["method"] || "analytic-local" === input["method"] || "exact" === input["method"] || "fixed-step" === input["method"] || "heuristic-fit" === input["method"] || "monte-carlo" === input["method"] || _report(_exceptionable, {
+        path: _path + ".method",
+        expected: "(\"analytic-local\" | \"exact\" | \"fixed-step\" | \"heuristic-fit\" | \"monte-carlo\" | undefined)",
+        value: input["method"]
+    });
+    const _vp10 = (input, _path, _exceptionable = true) => null === input["seconds"] || "number" === typeof input["seconds"] || _report(_exceptionable, {
+        path: _path + ".seconds",
+        expected: "(null | number)",
+        value: input["seconds"]
+    });
+    const _vp11 = (input, _path, _exceptionable = true) => undefined === input["secondsDecimal"] || "string" === typeof input["secondsDecimal"] || _report(_exceptionable, {
+        path: _path + ".secondsDecimal",
+        expected: "(string | undefined)",
+        value: input["secondsDecimal"]
+    });
+    const _vp12 = (input, _path, _exceptionable = true) => undefined === input["observationResolutionSec"] || "number" === typeof input["observationResolutionSec"] || _report(_exceptionable, {
+        path: _path + ".observationResolutionSec",
+        expected: "(number | undefined)",
+        value: input["observationResolutionSec"]
+    });
+    const _vp13 = (input, _path, _exceptionable = true) => undefined === input["bracket"] || ("object" === typeof input["bracket"] && null !== input["bracket"] || _report(_exceptionable, {
+        path: _path + ".bracket",
+        expected: "(Readonly<{ lowerSec: number; upperSec: number; }> | undefined)",
+        value: input["bracket"]
+    })) && _vo2(input["bracket"], _path + ".bracket", true && _exceptionable) || _report(_exceptionable, {
+        path: _path + ".bracket",
+        expected: "(Readonly<{ lowerSec: number; upperSec: number; }> | undefined)",
+        value: input["bracket"]
+    });
+    const _vp14 = (input, _path, _exceptionable = true) => (Array.isArray(input["assumptions"]) || _report(_exceptionable, {
+        path: _path + ".assumptions",
+        expected: "ReadonlyArray<string>",
+        value: input["assumptions"]
+    })) && input["assumptions"].map((elem, _index3) => "string" === typeof elem || _report(_exceptionable, {
+        path: _path + ".assumptions[" + _index3 + "]",
+        expected: "string",
+        value: elem
+    })).every(flag => flag) || _report(_exceptionable, {
+        path: _path + ".assumptions",
+        expected: "ReadonlyArray<string>",
+        value: input["assumptions"]
+    });
+    const _vp15 = (input, _path, _exceptionable = true) => (Array.isArray(input["warnings"]) || _report(_exceptionable, {
+        path: _path + ".warnings",
+        expected: "ReadonlyArray<string>",
+        value: input["warnings"]
+    })) && input["warnings"].map((elem, _index4) => "string" === typeof elem || _report(_exceptionable, {
+        path: _path + ".warnings[" + _index4 + "]",
+        expected: "string",
+        value: elem
+    })).every(flag => flag) || _report(_exceptionable, {
+        path: _path + ".warnings",
+        expected: "ReadonlyArray<string>",
+        value: input["warnings"]
+    });
+    const _vp16 = (input, _path, _exceptionable = true) => undefined === input["horizonSec"] || "number" === typeof input["horizonSec"] || _report(_exceptionable, {
+        path: _path + ".horizonSec",
+        expected: "(number | undefined)",
+        value: input["horizonSec"]
+    });
+    const _vp17 = (input, _path, _exceptionable = true) => undefined === input["compare"] || ("object" === typeof input["compare"] && null !== input["compare"] || _report(_exceptionable, {
+        path: _path + ".compare",
+        expected: _ve1,
+        value: input["compare"]
+    })) && _vo3(input["compare"], _path + ".compare", true && _exceptionable) || _report(_exceptionable, {
+        path: _path + ".compare",
+        expected: _ve1,
+        value: input["compare"]
+    });
+    const _ve1 = "(Readonly<{ localMethod: AnalysisMethod | null; fixedStepMethod: \"fixed-step\"; localSec: number | null; fixedStepSec: number | null; diffSec: number | null; }> | undefined)";
+    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);
+    const _io1 = input => ("money" === input.kind || "netWorth" === input.kind) && "string" === typeof input.decimal && "string" === typeof input.unit;
+    const _io2 = input => "number" === typeof input.lowerSec && "number" === typeof input.upperSec;
+    const _io3 = input => (null === input.localMethod || "analytic-local" === input.localMethod || "exact" === input.localMethod || "fixed-step" === input.localMethod || "heuristic-fit" === input.localMethod || "monte-carlo" === input.localMethod) && "fixed-step" === input.fixedStepMethod && (null === input.localSec || "number" === typeof input.localSec) && (null === input.fixedStepSec || "number" === typeof input.fixedStepSec) && (null === input.diffSec || "number" === typeof input.diffSec);
+    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)].every(flag => flag);
+    const _vo1 = (input, _path, _exceptionable = true) => ["money" === input.kind || "netWorth" === input.kind || _report(_exceptionable, {
+            path: _path + ".kind",
+            expected: "(\"money\" | \"netWorth\")",
+            value: input.kind
+        }), "string" === typeof input.decimal || _report(_exceptionable, {
+            path: _path + ".decimal",
+            expected: "string",
+            value: input.decimal
+        }), "string" === typeof input.unit || _report(_exceptionable, {
+            path: _path + ".unit",
+            expected: "string",
+            value: input.unit
+        })].every(flag => flag);
+    const _vo2 = (input, _path, _exceptionable = true) => ["number" === typeof input.lowerSec || _report(_exceptionable, {
+            path: _path + ".lowerSec",
+            expected: "number",
+            value: input.lowerSec
+        }), "number" === typeof input.upperSec || _report(_exceptionable, {
+            path: _path + ".upperSec",
+            expected: "number",
+            value: input.upperSec
+        })].every(flag => flag);
+    const _vo3 = (input, _path, _exceptionable = true) => [null === input.localMethod || "analytic-local" === input.localMethod || "exact" === input.localMethod || "fixed-step" === input.localMethod || "heuristic-fit" === input.localMethod || "monte-carlo" === input.localMethod || _report(_exceptionable, {
+            path: _path + ".localMethod",
+            expected: "(\"analytic-local\" | \"exact\" | \"fixed-step\" | \"heuristic-fit\" | \"monte-carlo\" | null)",
+            value: input.localMethod
+        }), "fixed-step" === input.fixedStepMethod || _report(_exceptionable, {
+            path: _path + ".fixedStepMethod",
+            expected: "\"fixed-step\"",
+            value: input.fixedStepMethod
+        }), null === input.localSec || "number" === typeof input.localSec || _report(_exceptionable, {
+            path: _path + ".localSec",
+            expected: "(null | number)",
+            value: input.localSec
+        }), null === input.fixedStepSec || "number" === typeof input.fixedStepSec || _report(_exceptionable, {
+            path: _path + ".fixedStepSec",
+            expected: "(null | number)",
+            value: input.fixedStepSec
+        }), null === input.diffSec || "number" === typeof input.diffSec || _report(_exceptionable, {
+            path: _path + ".diffSec",
+            expected: "(null | number)",
+            value: input.diffSec
+        })].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);
+function buildEtaEstimateJsonSchema() {
+    return {
+        components: {
+            schemas: {
+                "ReadonlyschemaVersion1algorithmVersioneta-estimate-v1goalIdstringgoalVersionnumbermetricIdstringmeaningstringtimeAxisintervaltargetReadonlykindmoneynetWorthdecimalstringunitstring---9more---compareReadonly---undefined": {
+                    type: "object",
+                    properties: {
+                        schemaVersion: {
+                            "const": 1
+                        },
+                        algorithmVersion: {
+                            "const": "eta-estimate-v1"
+                        },
+                        goalId: {
+                            type: "string"
+                        },
+                        goalVersion: {
+                            type: "number"
+                        },
+                        metricId: {
+                            type: "string"
+                        },
+                        meaning: {
+                            type: "string"
+                        },
+                        timeAxis: {
+                            "const": "interval"
+                        },
+                        target: {
+                            $ref: "#/components/schemas/ReadonlykindmoneynetWorthdecimalstringunitstring",
+                            description: "The goal threshold this estimate answers, as an engine decimal string and its unit."
+                        },
+                        status: {
+                            $ref: "#/components/schemas/AnalysisStatus"
+                        },
+                        method: {
+                            oneOf: [
+                                {
+                                    "const": "analytic-local"
+                                },
+                                {
+                                    "const": "exact"
+                                },
+                                {
+                                    "const": "fixed-step"
+                                },
+                                {
+                                    "const": "heuristic-fit"
+                                },
+                                {
+                                    "const": "monte-carlo"
+                                }
+                            ]
+                        },
+                        seconds: {
+                            oneOf: [
+                                {
+                                    type: "null"
+                                },
+                                {
+                                    type: "number"
+                                }
+                            ]
+                        },
+                        secondsDecimal: {
+                            type: "string"
+                        },
+                        observationResolutionSec: {
+                            type: "number"
+                        },
+                        bracket: {
+                            $ref: "#/components/schemas/ReadonlylowerSecnumberupperSecnumber"
+                        },
+                        assumptions: {
+                            type: "array",
+                            items: {
+                                type: "string"
+                            }
+                        },
+                        warnings: {
+                            type: "array",
+                            items: {
+                                type: "string"
+                            }
+                        },
+                        horizonSec: {
+                            type: "number"
+                        },
+                        compare: {
+                            $ref: "#/components/schemas/ReadonlylocalMethodAnalysisMethodnullfixedStepMethodfixed-steplocalSecnumbernullfixedStepSecnumbernulldiffSecnumbernull"
+                        }
+                    },
+                    required: [
+                        "schemaVersion",
+                        "algorithmVersion",
+                        "goalId",
+                        "goalVersion",
+                        "metricId",
+                        "meaning",
+                        "timeAxis",
+                        "target",
+                        "status",
+                        "seconds",
+                        "assumptions",
+                        "warnings"
+                    ],
+                    additionalProperties: false
+                },
+                ReadonlykindmoneynetWorthdecimalstringunitstring: {
+                    type: "object",
+                    properties: {
+                        kind: {
+                            oneOf: [
+                                {
+                                    "const": "money"
+                                },
+                                {
+                                    "const": "netWorth"
+                                }
+                            ]
+                        },
+                        decimal: {
+                            type: "string"
+                        },
+                        unit: {
+                            type: "string"
+                        }
+                    },
+                    required: [
+                        "kind",
+                        "decimal",
+                        "unit"
+                    ],
+                    additionalProperties: false
+                },
+                AnalysisStatus: {
+                    oneOf: [
+                        {
+                            "const": "censored"
+                        },
+                        {
+                            "const": "error"
+                        },
+                        {
+                            "const": "insufficient-data"
+                        },
+                        {
+                            "const": "invalid"
+                        },
+                        {
+                            "const": "ok"
+                        },
+                        {
+                            "const": "unknown"
+                        },
+                        {
+                            "const": "unsupported"
+                        }
+                    ]
+                },
+                ReadonlylowerSecnumberupperSecnumber: {
+                    type: "object",
+                    properties: {
+                        lowerSec: {
+                            type: "number"
+                        },
+                        upperSec: {
+                            type: "number"
+                        }
+                    },
+                    required: [
+                        "lowerSec",
+                        "upperSec"
+                    ],
+                    additionalProperties: false
+                },
+                "ReadonlylocalMethodAnalysisMethodnullfixedStepMethodfixed-steplocalSecnumbernullfixedStepSecnumbernulldiffSecnumbernull": {
+                    type: "object",
+                    properties: {
+                        localMethod: {
+                            oneOf: [
+                                {
+                                    type: "null"
+                                },
+                                {
+                                    "const": "analytic-local"
+                                },
+                                {
+                                    "const": "exact"
+                                },
+                                {
+                                    "const": "fixed-step"
+                                },
+                                {
+                                    "const": "heuristic-fit"
+                                },
+                                {
+                                    "const": "monte-carlo"
+                                }
+                            ]
+                        },
+                        fixedStepMethod: {
+                            "const": "fixed-step"
+                        },
+                        localSec: {
+                            oneOf: [
+                                {
+                                    type: "null"
+                                },
+                                {
+                                    type: "number"
+                                }
+                            ]
+                        },
+                        fixedStepSec: {
+                            oneOf: [
+                                {
+                                    type: "null"
+                                },
+                                {
+                                    type: "number"
+                                }
+                            ]
+                        },
+                        diffSec: {
+                            oneOf: [
+                                {
+                                    type: "null"
+                                },
+                                {
+                                    type: "number"
+                                }
+                            ]
+                        }
+                    },
+                    required: [
+                        "localMethod",
+                        "fixedStepMethod",
+                        "localSec",
+                        "fixedStepSec",
+                        "diffSec"
+                    ],
+                    additionalProperties: false
+                }
+            }
+        },
+        schema: {
+            type: "object",
+            properties: {
+                schemaVersion: {
+                    "const": 1
+                },
+                algorithmVersion: {
+                    "const": "eta-estimate-v1"
+                },
+                goalId: {
+                    type: "string"
+                },
+                goalVersion: {
+                    type: "number"
+                },
+                metricId: {
+                    type: "string"
+                },
+                meaning: {
+                    type: "string"
+                },
+                timeAxis: {
+                    "const": "interval"
+                },
+                target: {
+                    $ref: "#/components/schemas/ReadonlykindmoneynetWorthdecimalstringunitstring",
+                    description: "The goal threshold this estimate answers, as an engine decimal string and its unit."
+                },
+                status: {
+                    $ref: "#/components/schemas/AnalysisStatus"
+                },
+                method: {
+                    oneOf: [
+                        {
+                            "const": "analytic-local"
+                        },
+                        {
+                            "const": "exact"
+                        },
+                        {
+                            "const": "fixed-step"
+                        },
+                        {
+                            "const": "heuristic-fit"
+                        },
+                        {
+                            "const": "monte-carlo"
+                        }
+                    ]
+                },
+                seconds: {
+                    oneOf: [
+                        {
+                            type: "null"
+                        },
+                        {
+                            type: "number"
+                        }
+                    ]
+                },
+                secondsDecimal: {
+                    type: "string"
+                },
+                observationResolutionSec: {
+                    type: "number"
+                },
+                bracket: {
+                    $ref: "#/components/schemas/ReadonlylowerSecnumberupperSecnumber"
+                },
+                assumptions: {
+                    type: "array",
+                    items: {
+                        type: "string"
+                    }
+                },
+                warnings: {
+                    type: "array",
+                    items: {
+                        type: "string"
+                    }
+                },
+                horizonSec: {
+                    type: "number"
+                },
+                compare: {
+                    $ref: "#/components/schemas/ReadonlylocalMethodAnalysisMethodnullfixedStepMethodfixed-steplocalSecnumbernullfixedStepSecnumbernulldiffSecnumbernull"
+                }
+            },
+            required: [
+                "schemaVersion",
+                "algorithmVersion",
+                "goalId",
+                "goalVersion",
+                "metricId",
+                "meaning",
+                "timeAxis",
+                "target",
+                "status",
+                "seconds",
+                "assumptions",
+                "warnings"
+            ],
+            additionalProperties: false
+        },
+        version: "3.1"
+    };
+}
+let etaEstimateJsonSchemaUnit;
+export function etaEstimateJsonSchema() {
+    etaEstimateJsonSchemaUnit ??= buildEtaEstimateJsonSchema();
+    return etaEstimateJsonSchemaUnit;
+}
+function finiteSeconds(value) {
+    if (!Number.isFinite(value) || value < 0)
+        return undefined;
+    return value;
+}
+/**
+ * Divide the gap by the rate in the Engine, then narrow.
+ * `toNumber` sees only that ratio, and only when it is a finite seconds count.
+ */
+export function etaSecondsFromEngineRatio(E, target, current, rate, provenConstant) {
+    if (!E.isFinite(target) || !E.isFinite(current) || !E.isFinite(rate)) {
+        return { status: "invalid", seconds: null };
+    }
+    if (E.cmp(rate, E.zero()) <= 0) {
+        return {
+            status: provenConstant ? "unsupported" : "insufficient-data",
+            seconds: null,
+        };
+    }
+    const ratio = E.divN(E.sub(target, current), rate);
+    if (!E.isFinite(ratio))
+        return { status: "invalid", seconds: null, secondsDecimal: E.toString(ratio) };
+    const magnitude = E.absLog10(ratio);
+    if (Number.isFinite(magnitude) && magnitude > 308) {
+        return { status: "invalid", seconds: null, secondsDecimal: E.toString(ratio) };
+    }
+    const seconds = finiteSeconds(E.toNumber(ratio));
+    if (seconds === undefined) {
+        return { status: "invalid", seconds: null, secondsDecimal: E.toString(ratio) };
     }
-    const worth = scenario.model.netWorth?.(scenario.ctx, run.end) ?? run.end.wallet.money;
-    return E.cmp(worth.amount, threshold) >= 0;
+    // The engine division itself can lose a positive gap, before narrowing sees it.
+    if (seconds === 0 && !Number.isFinite(magnitude) && E.cmp(target, current) > 0) {
+        return { status: "invalid", seconds: null };
+    }
+    // A nonzero ratio below the number range narrows to 0, which would read as already reached.
+    // absLog10 is finite only for a nonzero value; cmp against zero can round such a ratio to equal.
+    // The engine's own division can also lose the ratio, so a nonzero gap is checked as well.
+    if (seconds === 0 && (Number.isFinite(magnitude) || Number.isFinite(E.absLog10(E.sub(target, current))))) {
+        return { status: "invalid", seconds: null, secondsDecimal: E.toString(ratio) };
+    }
+    return { status: "ok", seconds };
 }
-export function etaSimulate(args) {
-    const threshold = parseMoney(args.scenario.ctx.E, args.target.value, {
-        unit: args.scenario.ctx.unit,
-        suffix: { kind: "alphaInfinite", minLen: 2 },
+export function parseEtaAmount(scenario, value) {
+    return parseMoney(scenario.ctx.E, value, {
+        unit: scenario.ctx.unit,
+        suffix: ETA_SUFFIX,
     }).amount;
-    const until = (s) => {
-        if (args.target.kind === "money") {
-            return args.scenario.ctx.E.cmp(s.wallet.money.amount, threshold) >= 0;
+}
+export function etaGoalForTarget(scenario, target) {
+    const threshold = parseEtaAmount(scenario, target.value);
+    const wire = scenario.ctx.E.toString(threshold);
+    const identity = { kind: target.kind, decimal: wire, unit: scenario.ctx.unit.code };
+    if (target.kind === "money") {
+        const metric = walletMoneyMetric();
+        return { goal: moneyAtLeast(wire), threshold, target: identity, metricId: metric.id, meaning: metric.meaning };
+    }
+    return {
+        goal: netWorthAtLeast({
+            target: wire,
+            netWorth: (state, ctx) => scenario.model.netWorth?.(ctx, state)?.amount,
+            fallbackToWallet: scenario.model.netWorth === undefined,
+        }),
+        threshold,
+        target: identity,
+        metricId: "netWorth",
+        meaning: "Current net worth amount",
+    };
+}
+const COMPARISON_BOUNDARY = "goal comparison uses a tolerance or has no exactness declaration";
+function exactBlocks(scenario) {
+    const blocks = [];
+    const hint = scenario.model.analytic?.(scenario.ctx, scenario.initial);
+    if (hint?.incomeKind !== "constant")
+        blocks.push("income derivative is not confirmed constant");
+    if (scenario.model.actions(scenario.ctx, scenario.initial).length > 0) {
+        blocks.push("an action can change income");
+    }
+    if (scenario.model.evolve)
+        blocks.push("evolve can change the state inside a step");
+    if (scenario.model.prestige)
+        blocks.push("prestige reset can make the metric non-monotonic");
+    if (scenario.strategy)
+        blocks.push("a strategy can apply a decision");
+    if (scenario.constraints)
+        blocks.push("a policy constraint can change the schedule");
+    if (scenario.ctx.tickPolicy.maxLogGap !== undefined) {
+        blocks.push("tick settlement can drop or hold income below maxLogGap");
+    }
+    if (scenario.ctx.tickPolicy.mode === "accumulate" &&
+        scenario.ctx.E.cmp(scenario.initial.wallet.bucket, scenario.ctx.E.zero()) !== 0) {
+        blocks.push("a pending accumulated bucket can flush into the wallet on the next tick");
+    }
+    if (scenario.ctx.E.comparisonIsExact !== true)
+        blocks.push(COMPARISON_BOUNDARY);
+    return blocks;
+}
+function baseEstimate(binding, status, extra = {}) {
+    return {
+        schemaVersion: 1,
+        algorithmVersion: ETA_ALGORITHM_VERSION,
+        goalId: binding.goal.id,
+        goalVersion: binding.goal.version,
+        metricId: binding.metricId,
+        meaning: binding.meaning,
+        timeAxis: "interval",
+        target: binding.target,
+        status,
+        seconds: extra.seconds ?? null,
+        assumptions: extra.assumptions ?? [],
+        warnings: extra.warnings ?? [],
+        ...(extra.method !== undefined ? { method: extra.method } : {}),
+        ...(extra.secondsDecimal !== undefined ? { secondsDecimal: extra.secondsDecimal } : {}),
+        ...(extra.observationResolutionSec !== undefined
+            ? { observationResolutionSec: extra.observationResolutionSec }
+            : {}),
+        ...(extra.bracket !== undefined ? { bracket: extra.bracket } : {}),
+        ...(extra.horizonSec !== undefined ? { horizonSec: extra.horizonSec } : {}),
+        ...(extra.compare !== undefined ? { compare: extra.compare } : {}),
+    };
+}
+function confidenceFor(estimate) {
+    if (estimate.status !== "ok")
+        return "low";
+    if (estimate.method === "exact")
+        return "high";
+    return "medium";
+}
+function legacyInfinity() {
+    return Number.POSITIVE_INFINITY;
+}
+function analyticEstimate(scenario, target) {
+    const { E } = scenario.ctx;
+    const binding = etaGoalForTarget(scenario, target);
+    const blocks = exactBlocks(scenario);
+    const proven = blocks.length === 0 && target.kind === "money";
+    const provenIncome = blocks.every((block) => block === COMPARISON_BOUNDARY) && target.kind === "money";
+    const evaluation = evaluateGoal(binding.goal, scenario.initial, scenario.ctx);
+    // cmp reads NaN as reached. A non-finite wallet or target falls through to the engine ratio, which is invalid.
+    const already = evaluation.reached === true &&
+        E.isFinite(binding.threshold) &&
+        E.isFinite(scenario.initial.wallet.money.amount);
+    if (target.kind === "netWorth" && scenario.model.netWorth) {
+        const current = scenario.model.netWorth(scenario.ctx, scenario.initial).amount;
+        // cmp reads NaN as already reached, so a non-finite side is checked first.
+        if (E.isFinite(current) && E.isFinite(binding.threshold) && E.cmp(current, binding.threshold) >= 0) {
+            return {
+                reached: true,
+                seconds: 0,
+                estimate: baseEstimate(binding, "ok", {
+                    seconds: 0,
+                    assumptions: [
+                        "target already reached at t=0",
+                        "net worth was read directly; money income is not its derivative",
+                    ],
+                }),
+            };
         }
-        const worth = args.scenario.model.netWorth?.(args.scenario.ctx, s) ?? s.wallet.money;
-        return args.scenario.ctx.E.cmp(worth.amount, threshold) >= 0;
+        const rate = scenario.model.income(scenario.ctx, scenario.initial).amount;
+        const local = etaSecondsFromEngineRatio(E, binding.threshold, current, rate, false);
+        return {
+            reached: local.seconds !== null,
+            seconds: local.seconds ?? legacyInfinity(),
+            estimate: baseEstimate(binding, "unsupported", {
+                assumptions: [
+                    "unsupported-local",
+                    "net worth has its own value, so money income is not its derivative",
+                    "legacy seconds keeps the old initial-income ratio and is not a net worth result",
+                    ...blocks,
+                ],
+                ...(local.secondsDecimal !== undefined ? { secondsDecimal: local.secondsDecimal } : {}),
+            }),
+        };
+    }
+    if (target.kind === "netWorth") {
+        const wallet = scenario.initial.wallet.money.amount;
+        const local = already
+            ? { status: "ok", seconds: 0 }
+            : etaSecondsFromEngineRatio(E, binding.threshold, wallet, scenario.model.income(scenario.ctx, scenario.initial).amount, false);
+        return {
+            reached: already,
+            seconds: local.seconds ?? legacyInfinity(),
+            estimate: baseEstimate(binding, "unsupported", {
+                assumptions: [
+                    "unsupported-local",
+                    "netWorth is absent; the legacy seconds field reuses wallet money and is not a net worth derivative",
+                    ...(evaluation.assumptions ?? []),
+                ],
+            }),
+        };
+    }
+    const current = scenario.initial.wallet.money.amount;
+    if (already) {
+        const method = proven ? "exact" : "analytic-local";
+        return {
+            reached: true,
+            seconds: 0,
+            estimate: baseEstimate(binding, "ok", {
+                method,
+                seconds: 0,
+                assumptions: ["target already reached at t=0", ...blocks],
+            }),
+        };
+    }
+    const income = scenario.model.income(scenario.ctx, scenario.initial);
+    if (income.unit.code !== scenario.initial.wallet.money.unit.code ||
+        income.unit.code !== scenario.ctx.unit.code) {
+        return {
+            reached: false,
+            seconds: legacyInfinity(),
+            estimate: baseEstimate(binding, "invalid", {
+                assumptions: ["income unit differs from the wallet or target unit and cannot be settled"],
+            }),
+        };
+    }
+    const rate = income.amount;
+    const ratio = etaSecondsFromEngineRatio(E, binding.threshold, current, rate, provenIncome);
+    if (ratio.status !== "ok" || ratio.seconds === null) {
+        const assumptions = [
+            ratio.status === "unsupported"
+                ? "constant non-positive income does not reach a higher target; the estimate makes no reachability claim"
+                : ratio.status === "insufficient-data"
+                    ? "the local rate is not positive; that is not proof the target stays out of reach"
+                    : "the engine ratio is not a finite seconds count",
+            ...blocks,
+        ];
+        return {
+            reached: false,
+            seconds: legacyInfinity(),
+            estimate: baseEstimate(binding, ratio.status, {
+                assumptions,
+                ...(ratio.secondsDecimal !== undefined ? { secondsDecimal: ratio.secondsDecimal } : {}),
+            }),
+        };
+    }
+    const method = proven ? "exact" : "analytic-local";
+    return {
+        reached: true,
+        seconds: ratio.seconds,
+        estimate: baseEstimate(binding, "ok", {
+            method,
+            seconds: ratio.seconds,
+            assumptions: [
+                method === "exact"
+                    ? "constant money derivative with no purchase, reset, evolve, or policy boundary"
+                    : "analytic-local estimate from the initial rate only",
+                ...blocks,
+            ],
+        }),
     };
+}
+function bracketFor(continuous, observed) {
+    if (continuous === null || !Number.isFinite(observed))
+        return undefined;
+    const lower = Math.min(continuous, observed);
+    const upper = Math.max(continuous, observed);
+    return { lowerSec: lower, upperSec: upper };
+}
+export function etaSimulate(args) {
+    const binding = etaGoalForTarget(args.scenario, args.target);
+    const { E } = args.scenario.ctx;
+    const netWorthOf = args.target.kind === "netWorth" ? args.scenario.model.netWorth : undefined;
+    const observedAmount = (state) => netWorthOf ? netWorthOf(args.scenario.ctx, state).amount : state.wallet.money.amount;
+    // cmp reads NaN as reached, so a non-finite threshold or observed amount never ends the run as the goal.
+    const finiteAt = (state) => E.isFinite(binding.threshold) && E.isFinite(observedAmount(state));
+    const until = (state) => finiteAt(state) && binding.goal.met(state, args.scenario.ctx) === true;
     const scenario = {
         ...args.scenario,
         run: {
@@ -33,73 +893,111 @@ export function etaSimulate(args) {
     const run = runScenario(scenario);
     // A budget stop is neither the target nor maxDurationSec.
     assertHorizonReached(run, "etaSimulate");
-    const reached = targetReached(scenario, args.target.kind, threshold, run);
+    const reached = finiteAt(run.end) && evaluateGoal(binding.goal, run.end, scenario.ctx).reached === true;
+    const nonFinite = !reached && !finiteAt(run.end);
+    // Without model.netWorth the legacy goal reads wallet money. That is not a net worth observation.
+    const walletProxy = args.target.kind === "netWorth" && args.scenario.model.netWorth === undefined;
+    const observed = reached ? runElapsedSec(run) : args.maxDurationSec;
+    const resolution = args.scenario.run.stepSec;
+    const blocks = exactBlocks(args.scenario);
+    const monotonic = blocks.length === 0 && args.target.kind === "money";
+    const continuousSeconds = monotonic ? analyticEstimate(args.scenario, args.target).estimate.seconds : null;
+    const assumptions = [
+        "fixed-step first observation, not a continuous crossing",
+        ...(reached ? [] : ["horizon ended before the goal was observed"]),
+        ...blocks,
+    ];
+    const bracket = reached && continuousSeconds !== null ? bracketFor(continuousSeconds, observed) : undefined;
+    const estimate = nonFinite
+        ? baseEstimate(binding, "invalid", {
+            observationResolutionSec: resolution,
+            assumptions: [...assumptions, "the threshold or the observed amount is not finite, so the goal is not evaluated"],
+        })
+        : walletProxy
+            ? baseEstimate(binding, "unsupported", {
+                observationResolutionSec: resolution,
+                assumptions: [
+                    ...assumptions,
+                    "unsupported-local",
+                    "netWorth is absent; the legacy seconds field reuses wallet money and is not a net worth observation",
+                ],
+            })
+            : !reached
+                ? baseEstimate(binding, "censored", {
+                    horizonSec: args.maxDurationSec,
+                    observationResolutionSec: resolution,
+                    assumptions,
+                })
+                : baseEstimate(binding, "ok", {
+                    method: "fixed-step",
+                    seconds: observed,
+                    observationResolutionSec: resolution,
+                    ...(bracket !== undefined ? { bracket } : {}),
+                    assumptions: bracket
+                        ? assumptions
+                        : [...assumptions, "no reach bracket; a hidden crossing is not ruled out"],
+                });
     return {
         reached,
-        seconds: reached ? runElapsedSec(run) : args.maxDurationSec,
+        seconds: observed,
         mode: "simulate",
-        confidence: "high",
-        assumptions: ["Direct simulation over maxDurationSec"],
+        confidence: confidenceFor(estimate),
+        assumptions: ["Direct simulation over maxDurationSec", ...assumptions],
         run: args.includeRun ? run : undefined,
+        estimate,
     };
 }
-function analyticUnavailable(reason) {
+export function etaAnalytic(args) {
+    const local = analyticEstimate(args.scenario, args.target);
+    let estimate = local.estimate;
+    if (args.fallback) {
+        const stepped = etaSimulate({
+            scenario: args.scenario,
+            target: args.target,
+            maxDurationSec: args.fallback.maxDurationSec,
+        });
+        const localSec = local.estimate.status === "ok" ? local.estimate.seconds : null;
+        const fixedStepSec = stepped.estimate.status === "ok" ? stepped.estimate.seconds : null;
+        estimate = {
+            ...local.estimate,
+            compare: {
+                localMethod: local.estimate.method ?? null,
+                fixedStepMethod: "fixed-step",
+                localSec,
+                fixedStepSec,
+                diffSec: localSec !== null && fixedStepSec !== null ? fixedStepSec - localSec : null,
+            },
+        };
+    }
     return {
-        reached: false,
-        seconds: Number.POSITIVE_INFINITY,
+        reached: local.reached,
+        seconds: local.seconds,
         mode: "analytic",
-        confidence: "low",
-        assumptions: [reason],
+        confidence: confidenceFor(estimate),
+        assumptions: [...estimate.assumptions],
+        estimate,
     };
 }
-export function etaAnalytic(args) {
-    const { scenario } = args;
-    const { E } = scenario.ctx;
-    const currMoney = scenario.initial.wallet.money.amount;
-    const currWorth = (scenario.model.netWorth?.(scenario.ctx, scenario.initial) ?? scenario.initial.wallet.money)
-        .amount;
-    const rate = scenario.model.income(scenario.ctx, scenario.initial).amount;
-    // Same notation as etaSimulate. `E.from("1aa")` is NaN, and cmp reads NaN as already reached.
-    const threshold = parseMoney(E, args.target.value, {
-        unit: scenario.ctx.unit,
-        suffix: { kind: "alphaInfinite", minLen: 2 },
-    }).amount;
-    const current = args.target.kind === "money" ? currMoney : currWorth;
-    if (!E.isFinite(current) || !E.isFinite(threshold)) {
-        return analyticUnavailable("Current or target amount is not finite; analytic estimate unavailable");
+export function validateEtaEstimateSemantics(estimate) {
+    const issues = [];
+    if (estimate.status === "censored" && estimate.seconds !== null) {
+        issues.push("censored estimate carries seconds");
     }
-    if (E.cmp(current, threshold) >= 0) {
-        return {
-            reached: true,
-            seconds: 0,
-            mode: "analytic",
-            confidence: "high",
-            assumptions: ["Target already reached at t=0"],
-        };
+    else if (estimate.status !== "ok" && estimate.seconds !== null) {
+        issues.push(`${estimate.status} estimate carries seconds`);
     }
-    const r = E.toNumber(rate);
-    if (!Number.isFinite(r)) {
-        return analyticUnavailable("Initial income is not finite; analytic estimate unavailable");
+    if (estimate.status === "ok" && (estimate.seconds === null || !Number.isFinite(estimate.seconds))) {
+        issues.push("ok estimate has no finite seconds");
     }
-    if (!(r > 0)) {
-        return analyticUnavailable("Non-positive initial income; analytic estimate unavailable");
+    if (estimate.status === "ok" && estimate.seconds !== null && estimate.seconds < 0) {
+        issues.push("ok estimate has negative seconds");
     }
-    const diff = E.toNumber(E.sub(threshold, current));
-    const seconds = Math.max(0, diff / r);
-    if (!Number.isFinite(seconds)) {
-        return analyticUnavailable("Remaining amount does not fit a finite number; analytic estimate unavailable");
-    }
-    const hint = scenario.model.analytic?.(scenario.ctx, scenario.initial);
-    const confidence = hint?.incomeKind === "constant" ? "high" : "medium";
-    return {
-        reached: true,
-        seconds,
-        mode: "analytic",
-        confidence,
-        assumptions: [
-            "Income assumed near-constant in local interval",
-            hint ? `Model analytic hint: ${hint.incomeKind ?? "custom"}` : "No analytic hint provided",
-        ],
-    };
+    if (estimate.method === "exact" && estimate.status !== "ok")
+        issues.push("exact method is not ok");
+    if (estimate.bracket && estimate.status !== "ok")
+        issues.push("bracket on a non-ok estimate");
+    if (JSON.stringify(estimate).includes("unreachable"))
+        issues.push("estimate says unreachable");
+    return issues;
 }
 //# sourceMappingURL=eta.js.map