{"version":3,"file":"mission-state.d.ts","sourceRoot":"","sources":["../../../src/core/mission-domain/mission-state.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAMH;;;;GAIG;AACH,MAAM,MAAM,YAAY,GACrB,SAAS,GACT,QAAQ,GACR,WAAW,GACX,SAAS,GACT,SAAS,GACT,SAAS,GACT,UAAU,GACV,aAAa,GACb,WAAW,GACX,SAAS,GACT,QAAQ,GACR,WAAW,GACX,WAAW,GACX,SAAS,CAAC;AAEb;;;;GAIG;AACH,eAAO,MAAM,cAAc,EAAE,WAAW,CAAC,YAAY,CAenD,CAAC;AAEH,uDAAuD;AACvD,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,YAAY,CAEpE;AAED;;GAEG;AACH,eAAO,MAAM,wBAAwB,EAAE,WAAW,CAAC,YAAY,CAS7D,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,uBAAuB,EAAE,WAAW,CAAC,YAAY,CAO5D,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,sBAAsB,EAAE,WAAW,CAAC,YAAY,CAAwC,CAAC;AA4CtG,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAEnE;AAED,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAEpE;AAED,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAElE;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,YAAY,EAAE,EAAE,EAAE,YAAY,GAAG,OAAO,CAIvF;AAMD,MAAM,WAAW,uBAAuB;IACvC,EAAE,EAAE,OAAO,CAAC;IACZ,KAAK,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,YAAY,EAAE,EAAE,EAAE,YAAY,GAAG,uBAAuB,CAWrG;AAED;;;;GAIG;AACH,qBAAa,mBAAmB;IAC/B,OAAO,CAAC,MAAM,CAAe;IAE7B,YAAY,OAAO,GAAE,YAAwB,EAE5C;IAED,IAAI,KAAK,IAAI,YAAY,CAExB;IAED,UAAU,CAAC,EAAE,EAAE,YAAY,GAAG,uBAAuB,CAKpD;CACD","sourcesContent":["/**\n * First-Class Mission state machine (2.3.0).\n *\n * This is the canonical lifecycle vocabulary for a single *delegated unit of\n * work* — a mission — independent of any executor. It is intentionally separate\n * from:\n *\n *   - `MissionExecutionState` (long-horizon): the inner execution/verification\n *     lifecycle of one reliability-governed MissionRuntime contract.\n *   - `MissionStatus` (durable mission graph): the durable multi-repo graph\n *     status, a different orchestration layer.\n *   - `DelegatedStatus` (delegated-work): an ephemeral UI/display state.\n *\n * Those layers remain authoritative for their own concerns; this machine owns\n * the *mission* lifecycle (created → queued → running → terminal). No state in\n * this file may be reached from a raw process exit code alone: SUCCEEDED is a\n * mission-level claim that must be supported by verified completion (see the\n * Reliability Kernel's Completion Gate).\n *\n * `INTERRUPTED` (added in 2.4.0) is a NON-terminal, recoverable state meaning:\n * \"the mission is not terminal, but Jensen lost authoritative ownership of the\n * previous execution attempt and recovery is required.\" It is reached only from\n * an active non-terminal state (QUEUED/RUNNING/WAITING/BLOCKED/RETRYING) during\n * restart reconciliation, never from a raw process exit code, and it is never a\n * success or a failure signal.\n *\n * `LAUNCHING` (added in 2.4.0) is a NON-terminal state meaning \"execution\n * initiation has begun (a durable attempt identity exists) but authoritative\n * runtime ownership (the executor's execution id) has not yet been confirmed.\"\n * It is the durable bridge between QUEUED and RUNNING that closes the\n * launch-persistence crash window: an attempt intent is persisted BEFORE the\n * executor is invoked, so a crash immediately after launch can never erase the\n * fact that an attempt may have started. It is entered only from QUEUED and\n * exits to RUNNING (ownership confirmed), FAILED (executor rejected launch), or\n * INTERRUPTED (restart reconciliation). It is never a success or failure.\n */\n\n// =============================================================================\n// State vocabulary\n// =============================================================================\n\n/**\n * Canonical mission lifecycle states.\n *\n * Closed union. Adding a state is a breaking change for exhaustive consumers.\n */\nexport type MissionState =\n\t| \"CREATED\"\n\t| \"QUEUED\"\n\t| \"LAUNCHING\"\n\t| \"RUNNING\"\n\t| \"WAITING\"\n\t| \"BLOCKED\"\n\t| \"RETRYING\"\n\t| \"INTERRUPTED\"\n\t| \"SUCCEEDED\"\n\t| \"PARTIAL\"\n\t| \"FAILED\"\n\t| \"CANCELLED\"\n\t| \"TIMED_OUT\"\n\t| \"CRASHED\";\n\n/**\n * All canonical mission states. Used for runtime validation of untrusted\n * (durable) state values so a persisted record can never smuggle in a made-up\n * state string.\n */\nexport const MISSION_STATES: ReadonlySet<MissionState> = new Set<MissionState>([\n\t\"CREATED\",\n\t\"QUEUED\",\n\t\"LAUNCHING\",\n\t\"RUNNING\",\n\t\"WAITING\",\n\t\"BLOCKED\",\n\t\"RETRYING\",\n\t\"INTERRUPTED\",\n\t\"SUCCEEDED\",\n\t\"PARTIAL\",\n\t\"FAILED\",\n\t\"CANCELLED\",\n\t\"TIMED_OUT\",\n\t\"CRASHED\",\n]);\n\n/** Runtime type guard for a canonical MissionState. */\nexport function isMissionState(value: unknown): value is MissionState {\n\treturn typeof value === \"string\" && (MISSION_STATES as ReadonlySet<string>).has(value);\n}\n\n/**\n * States from which a mission can continue (i.e. not terminal).\n */\nexport const MISSION_RESUMABLE_STATES: ReadonlySet<MissionState> = new Set<MissionState>([\n\t\"CREATED\",\n\t\"QUEUED\",\n\t\"LAUNCHING\",\n\t\"RUNNING\",\n\t\"WAITING\",\n\t\"BLOCKED\",\n\t\"RETRYING\",\n\t\"INTERRUPTED\",\n]);\n\n/**\n * Terminal states: no outgoing transitions are legal.\n */\nexport const MISSION_TERMINAL_STATES: ReadonlySet<MissionState> = new Set<MissionState>([\n\t\"SUCCEEDED\",\n\t\"PARTIAL\",\n\t\"FAILED\",\n\t\"CANCELLED\",\n\t\"TIMED_OUT\",\n\t\"CRASHED\",\n]);\n\n/**\n * States that represent mission-level success. Only SUCCEEDED is clean success;\n * PARTIAL is terminal but is *not* a clean success.\n */\nexport const MISSION_SUCCESS_STATES: ReadonlySet<MissionState> = new Set<MissionState>([\"SUCCEEDED\"]);\n\n// =============================================================================\n// Transition graph\n// =============================================================================\n\nconst MISSION_TRANSITIONS: ReadonlyMap<MissionState, ReadonlySet<MissionState>> = new Map<\n\tMissionState,\n\tReadonlySet<MissionState>\n>([\n\t[\"CREATED\", new Set<MissionState>([\"QUEUED\", \"CANCELLED\"])],\n\t[\"QUEUED\", new Set<MissionState>([\"LAUNCHING\", \"RUNNING\", \"CANCELLED\", \"FAILED\", \"INTERRUPTED\"])],\n\t[\"LAUNCHING\", new Set<MissionState>([\"RUNNING\", \"FAILED\", \"INTERRUPTED\"])],\n\t[\n\t\t\"RUNNING\",\n\t\tnew Set<MissionState>([\n\t\t\t\"WAITING\",\n\t\t\t\"BLOCKED\",\n\t\t\t\"RETRYING\",\n\t\t\t\"INTERRUPTED\",\n\t\t\t\"SUCCEEDED\",\n\t\t\t\"PARTIAL\",\n\t\t\t\"FAILED\",\n\t\t\t\"CANCELLED\",\n\t\t\t\"TIMED_OUT\",\n\t\t\t\"CRASHED\",\n\t\t]),\n\t],\n\t[\"WAITING\", new Set<MissionState>([\"RUNNING\", \"BLOCKED\", \"CANCELLED\", \"FAILED\", \"TIMED_OUT\", \"INTERRUPTED\"])],\n\t[\"BLOCKED\", new Set<MissionState>([\"RUNNING\", \"WAITING\", \"RETRYING\", \"FAILED\", \"CANCELLED\", \"INTERRUPTED\"])],\n\t[\"RETRYING\", new Set<MissionState>([\"RUNNING\", \"BLOCKED\", \"FAILED\", \"CANCELLED\", \"TIMED_OUT\", \"INTERRUPTED\"])],\n\t[\"INTERRUPTED\", new Set<MissionState>([\"QUEUED\", \"FAILED\", \"CANCELLED\"])],\n\t[\"SUCCEEDED\", new Set<MissionState>()],\n\t[\"PARTIAL\", new Set<MissionState>()],\n\t[\"FAILED\", new Set<MissionState>()],\n\t[\"CANCELLED\", new Set<MissionState>()],\n\t[\"TIMED_OUT\", new Set<MissionState>()],\n\t[\"CRASHED\", new Set<MissionState>()],\n]);\n\n// =============================================================================\n// Predicates\n// =============================================================================\n\nexport function isTerminalMissionState(state: MissionState): boolean {\n\treturn MISSION_TERMINAL_STATES.has(state);\n}\n\nexport function isResumableMissionState(state: MissionState): boolean {\n\treturn MISSION_RESUMABLE_STATES.has(state);\n}\n\nexport function isMissionSuccessState(state: MissionState): boolean {\n\treturn MISSION_SUCCESS_STATES.has(state);\n}\n\n/**\n * Whether a transition is legal. Terminal states admit no outgoing transition.\n */\nexport function canTransitionMissionState(from: MissionState, to: MissionState): boolean {\n\tif (isTerminalMissionState(from)) return false;\n\tconst destinations = MISSION_TRANSITIONS.get(from);\n\treturn destinations?.has(to) ?? false;\n}\n\n// =============================================================================\n// Transition API\n// =============================================================================\n\nexport interface MissionTransitionResult {\n\tok: boolean;\n\terror?: string;\n}\n\n/**\n * Assert that `from -> to` is a legal transition. Terminal states admit no\n * outgoing transition; self-transitions are rejected.\n */\nexport function assertMissionTransition(from: MissionState, to: MissionState): MissionTransitionResult {\n\tif (from === to) {\n\t\treturn { ok: false, error: `SELF_TRANSITION: cannot transition from \"${from}\" to itself` };\n\t}\n\tif (!canTransitionMissionState(from, to)) {\n\t\treturn {\n\t\t\tok: false,\n\t\t\terror: `ILLEGAL_TRANSITION: cannot transition from \"${from}\" to \"${to}\"`,\n\t\t};\n\t}\n\treturn { ok: true };\n}\n\n/**\n * Mutable tracker that enforces legal transitions through the canonical API.\n * Executors own a tracker internally; the public MissionHandle exposes a\n * read-only snapshot of its state.\n */\nexport class MissionStateTracker {\n\tprivate _state: MissionState;\n\n\tconstructor(initial: MissionState = \"CREATED\") {\n\t\tthis._state = initial;\n\t}\n\n\tget state(): MissionState {\n\t\treturn this._state;\n\t}\n\n\ttransition(to: MissionState): MissionTransitionResult {\n\t\tconst result = assertMissionTransition(this._state, to);\n\t\tif (!result.ok) return result;\n\t\tthis._state = to;\n\t\treturn { ok: true };\n\t}\n}\n"]}