@demlik/tea 0.13.0 → 0.15.0

package/dist/run-pAcmBpah.d.ts

@@ -1,713 +0,0 @@
-import { C as Cmd, c as Reducer } from './core-Co0LWkIA.js';
-import { Parts } from './chart/index.js';
-import { E as EventName, c as StateName, C as Chart, d as Strict, T as Total, e as CellEdgeKey, f as InitialState, g as Ty, h as SuccessFinal, i as ErrorFinal, S as StateOf, a as CmdOf, M as MsgOf, j as MsgIn } from './graph-B3L5e0N1.js';
-import { I as ImportedLane, a as ImportedChart, P as PhaseStanding } from './fold-BJPdjc9w.js';
-
-/** The shape a lane task's chart has at EITHER door. */
-interface LaneRegion {
-    readonly events: Readonly<Record<string, unknown>>;
-    readonly states: Readonly<Record<string, Readonly<Record<string, unknown>>>>;
-}
-/**
- * A lane, as an author writes it.
- *
- * The nesting IS the structure: `phases` is an ordered record of phase name →
- * the tasks running concurrently in that phase → the chart each of those tasks
- * is an instance of. Nothing states the phase order (it is the key order),
- * nothing states a phase's task set (it is the keys), and nothing states which
- * finals are which (the charts say).
- */
-interface LaneSpec {
-    /** The lane's own id — what a report titles itself with. */
-    readonly id?: string;
-    /** What fires this lane, when something does. */
-    readonly trigger?: string;
-    /** Phase name → task id → the chart that task runs. IN ORDER. */
-    readonly phases: Readonly<Record<string, Readonly<Record<string, LaneRegion>>>>;
-    /** The lane's two endings. `tripped` is where an error final lands it. */
-    readonly terminals: {
-        readonly complete: string;
-        readonly tripped: string;
-    };
-    /**
-     * The retry budget, per task, where it is not {@link RETRY_BUDGET}.
-     *
-     * SUPPLIED, not derived, and the one thing on this interface that is. The
-     * guarded edge's predicate is `retries < maxRetries` and no chart declares
-     * the right-hand side — it is a property of the RUN, which is why fabrika
-     * keeps it in the document's `context` rather than in the machine.
-     */
-    readonly retries?: Readonly<Record<string, number>>;
-    /** Anything else the lane carries per task, passed through untouched. */
-    readonly extras?: Readonly<Record<string, Readonly<Record<string, unknown>>>>;
-}
-type Key<K> = K extends string | number ? `${K}` : never;
-type Keyed<R> = {
-    [K in keyof R as Key<K>]: R[K];
-};
-type TaskIdsIn<P> = {
-    [K in keyof P]: Key<keyof P[K]>;
-}[keyof P];
-/**
- * Task ids declared under more than one phase.
- *
- * DEGENERACY-GUARDED, and not for tidiness: `Omit<P, K>` over a `P` with an
- * index signature is `P` again, so at a computed-key phase record this reads
- * every task as declared twice and accuses the author of a duplicate they did
- * not write. {@link LaneLiteralAlphabets} is what actually went wrong there,
- * and it is ordered ahead of this so it is what the author is told.
- */
-type DuplicateTasks<P> = [IsDegenerate$1<TaskIdsIn<P>>] extends [true] ? never : {
-    [K in keyof P]: Extract<Key<keyof P[K]>, TaskIdsIn<Omit<P, K>>>;
-}[keyof P];
-/** Phases whose task record is empty — a phase that completes on arrival. */
-type EmptyPhases<P> = {
-    [K in keyof P]: [keyof P[K]] extends [never] ? Key<K> : never;
-}[keyof P];
-/** The three alphabets a lane derives, each refused where it degenerated. */
-type LaneLiteralAlphabets<S> = ([IsDegenerate$1<Key<keyof PhasesOf<S>>>] extends [
-    true
-] ? {
-    readonly __lanePhaseNamesMustBeLiteralsAddAsConst: true;
-} : unknown) & ([IsDegenerate$1<TaskIdsIn<PhasesOf<S>>>] extends [true] ? {
-    readonly __laneTaskIdsMustBeLiteralsAddAsConst: true;
-} : unknown) & ([IsDegenerate$1<TerminalsOf<S>>] extends [true] ? {
-    readonly __laneTerminalsMustBeLiteralsAddAsConst: true;
-} : unknown);
-/**
- * Task ids, or event names, carrying a dot.
- *
- * `${task}.${event}` IS the lane's wire key — `runLane` compiles each region
- * under `ns = taskId` and `foldLane` splits an incoming name at the FIRST dot —
- * so a dot on either side re-partitions the key space. Task `a` + event `b.GO`
- * and task `a.b` + event `GO` both register `"a.b.GO"`: last writer wins, one
- * task's event is unreachable forever, and a message addressed to `a` moves
- * `a.b`. And task `epic.issue_1` emits a log line the splitter can never route
- * back. Banning the dot makes the collision unrepresentable for every pairing
- * at once, which is the same move `graph.ts` makes for a foreign event name and
- * for a state name.
- */
-type DottedTaskIds<P> = Extract<TaskIdsIn<P>, `${string}.${string}`>;
-type DottedEventTasks<P> = {
-    [K in keyof P]: {
-        [T in keyof P[K]]: [IsDegenerate$1<EventName<P[K][T]>>] extends [true] ? never : [Extract<EventName<P[K][T]>, `${string}.${string}`>] extends [never] ? never : Key<T>;
-    }[keyof P[K]];
-}[keyof P];
-/**
- * Task ids whose chart hands a transition to a hand-written cell.
- *
- * Degeneracy-guarded like its two siblings below: `CellEdgeKey` over an
- * imported chart is `never` for the same reason it is `never` over a chart with
- * no cell edge, and reading the first as the second is how a check that cannot
- * be asked pretends to have been answered. It happens to be the SAFE direction
- * here — the answer is "no cell", which is what the imported door always
- * says — but a check that is right by luck is a check that stops being right.
- */
-type CellDelegatingTasks<P> = {
-    [K in keyof P]: {
-        [T in keyof P[K]]: [IsDegenerate$1<StateName<P[K][T]>>] extends [true] ? never : [CellEdgeKey<P[K][T]>] extends [never] ? never : Key<T>;
-    }[keyof P[K]];
-}[keyof P];
-/** Task ids whose chart marks no `initial: true` — the fold has no zero. */
-type NoInitialTasks<P> = {
-    [K in keyof P]: {
-        [T in keyof P[K]]: [IsDegenerate$1<StateName<P[K][T]>>] extends [true] ? never : [InitialState<P[K][T]>] extends [never] ? Key<T> : never;
-    }[keyof P[K]];
-}[keyof P];
-/**
- * Task ids whose chart marks MORE THAN ONE `initial: true`.
- *
- * Zero and two are both wrong and only zero was caught. Two is the worse of
- * the pair, because it does not fail — it splits: `laneShape` walked the states
- * and kept the LAST one it saw, `initialOf` (and therefore the fold, and
- * therefore every report) takes the FIRST, so the report printed a start state
- * the fold never booted into. `graph.ts` refuses the same thing on a single
- * chart with `__chartDeclaresManyInitialStates`; the lane door had dropped it,
- * because a lane region's entry is per-INSTANCE (`boot()`) and the check that
- * used to sit on the chart's own `InitialData` went with it.
- */
-type ManyInitialTasks<P> = {
-    [K in keyof P]: {
-        [T in keyof P[K]]: [IsDegenerate$1<StateName<P[K][T]>>] extends [true] ? never : [IsUnion<InitialState<P[K][T]>>] extends [true] ? Key<T> : never;
-    }[keyof P[K]];
-}[keyof P];
-/** Task ids whose chart declares no final — its phase could never complete. */
-type NoFinalTasks<P> = {
-    [K in keyof P]: {
-        [T in keyof P[K]]: [IsDegenerate$1<StateName<P[K][T]>>] extends [true] ? never : [SuccessFinal<P[K][T]> | ErrorFinal<P[K][T]>] extends [never] ? Key<T> : never;
-    }[keyof P[K]];
-}[keyof P];
-/** `graph.ts`'s own union test — a `T` that is not a single member. */
-type IsUnion<T, U = T> = T extends unknown ? [U] extends [T] ? false : true : never;
-/** A chart's `ctx`, as declared — the `Ty<…>` payload, unwrapped. */
-type LaneCtxOf<C> = C extends {
-    readonly ctx: Ty<infer T>;
-} ? T : unknown;
-/** Does any of `C`'s edges carry a `when`? */
-type HasGuardedEdge<C> = C extends {
-    readonly states: infer G;
-} ? {
-    [P in keyof G]: {
-        [S in keyof G[P]]: G[P][S] extends {
-            readonly on: infer O;
-        } ? {
-            [E in keyof O]: O[E] extends {
-                readonly when: string;
-            } ? true : never;
-        }[keyof O] : never;
-    }[keyof G[P]];
-}[keyof G] : never;
-/** The budget the fold's guarded arm reads, and the only shape it can read. */
-type RetryBudgetCtx = {
-    readonly retries: number;
-    readonly maxRetries: number;
-};
-/** Task ids that guard an edge on something the fold cannot evaluate. */
-type GuardsOffTheBudgetTasks<P> = {
-    [K in keyof P]: {
-        [T in keyof P[K]]: [IsDegenerate$1<StateName<P[K][T]>>] extends [true] ? never : [HasGuardedEdge<P[K][T]>] extends [never] ? never : LaneCtxOf<P[K][T]> extends RetryBudgetCtx ? never : Key<T>;
-    }[keyof P[K]];
-}[keyof P];
-/**
- * Task ids whose region never went through `defineChart`.
- *
- * `LaneRegion` is the structural minimum BOTH doors satisfy, which is what lets
- * one type parameter carry either — and it is also a hole: a hand-written
- * object of that shape passes it, so `Strict` and `Total` never run, a typo'd
- * target is never checked, and the fold lands the task in a state that does not
- * exist and leaves it there forever with no diagnostic. A brand stamped by
- * `defineChart` would be the tighter fix; it is not available from here, since
- * that would change `defineChart`'s own return type. So the region is put
- * through the checking door FROM here instead: a chart that satisfies its own
- * F-bounded constraint plus `Strict` and `Total` is a chart `defineChart` would
- * have accepted, whatever produced it, and one that does not is refused by the
- * name of the door it skipped.
- *
- * Stands down at the imported door, where `Chart<C>` is not a question an
- * `ImportedChart` can be asked.
- */
-type UncheckedRegionTasks<P> = {
-    [K in keyof P]: {
-        [T in keyof P[K]]: [IsDegenerate$1<StateName<P[K][T]>>] extends [true] ? never : [P[K][T]] extends [Chart<P[K][T]> & Strict<P[K][T]> & Total<P[K][T]>] ? never : Key<T>;
-    }[keyof P[K]];
-}[keyof P];
-type PhasesOf<S> = S extends {
-    readonly phases: infer P;
-} ? P : never;
-type TerminalsOf<S> = S extends {
-    readonly terminals: {
-        readonly complete: infer C;
-        readonly tripped: infer T;
-    };
-} ? C | T : never;
-type RetryKeysOf<S> = S extends {
-    readonly retries: infer R;
-} ? Key<keyof R> : never;
-/**
- * The authoring mistakes assignability can catch — the lane's own shape, and
- * the charts it was handed.
- *
- * THE ORDER IS LOAD-BEARING. {@link LaneLiteralAlphabets} comes first because
- * every check under it is a question about a union of literals, and at a
- * degenerate alphabet those questions do not merely go unanswered — they answer
- * WRONGLY. With two phases and a computed task key the old order accused the
- * author of `__taskDeclaredInTwoPhases` for a task declared exactly once, which
- * is a diagnostic that sends them looking in the one place the mistake is not.
- * A check that cannot be asked stands down; a check that would lie is ordered
- * behind the one that names the real cause.
- *
- * The chart-shaped ones stand down at the imported door, where the answer would
- * be a guess rather than a fact, and {@link defineLane}'s runtime checks catch
- * what they can there instead. Where a guarantee cannot be had, it is thrown
- * for rather than pretended.
- */
-type LaneChecks<S> = LaneLiteralAlphabets<S> & ([DuplicateTasks<PhasesOf<S>>] extends [never] ? unknown : {
-    readonly __taskDeclaredInTwoPhases: DuplicateTasks<PhasesOf<S>>;
-}) & ([EmptyPhases<PhasesOf<S>>] extends [never] ? unknown : {
-    readonly __phaseDeclaresNoTasks: EmptyPhases<PhasesOf<S>>;
-}) & ([Extract<TerminalsOf<S>, Key<keyof PhasesOf<S>>>] extends [never] ? unknown : {
-    readonly __terminalCollidesWithAPhase: Extract<TerminalsOf<S>, Key<keyof PhasesOf<S>>>;
-}) & ([Exclude<RetryKeysOf<S>, TaskIdsIn<PhasesOf<S>>>] extends [never] ? unknown : {
-    readonly __retryBudgetNamesAnUnknownTask: Exclude<RetryKeysOf<S>, TaskIdsIn<PhasesOf<S>>>;
-}) & ([DottedTaskIds<PhasesOf<S>>] extends [never] ? unknown : {
-    readonly __laneTaskIdCannotContainADot: DottedTaskIds<PhasesOf<S>>;
-}) & ([DottedEventTasks<PhasesOf<S>>] extends [never] ? unknown : {
-    readonly __laneRegionEventNameCannotContainADot: DottedEventTasks<PhasesOf<S>>;
-}) & ([UncheckedRegionTasks<PhasesOf<S>>] extends [never] ? unknown : {
-    readonly __laneRegionDidNotComeThroughDefineChart: UncheckedRegionTasks<PhasesOf<S>>;
-}) & ([CellDelegatingTasks<PhasesOf<S>>] extends [never] ? unknown : {
-    readonly __laneTaskChartDelegatesToACell: CellDelegatingTasks<PhasesOf<S>>;
-}) & ([NoInitialTasks<PhasesOf<S>>] extends [never] ? unknown : {
-    readonly __laneTaskChartMarksNoInitialState: NoInitialTasks<PhasesOf<S>>;
-}) & ([ManyInitialTasks<PhasesOf<S>>] extends [never] ? unknown : {
-    readonly __laneTaskChartMarksManyInitialStates: ManyInitialTasks<PhasesOf<S>>;
-}) & ([GuardsOffTheBudgetTasks<PhasesOf<S>>] extends [never] ? unknown : {
-    readonly __laneRegionGuardsOnSomethingOtherThanTheRetryBudget: GuardsOffTheBudgetTasks<PhasesOf<S>>;
-}) & ([NoFinalTasks<PhasesOf<S>>] extends [never] ? unknown : {
-    readonly __laneTaskChartDeclaresNoFinal: NoFinalTasks<PhasesOf<S>>;
-});
-/** The self-referential constraint `defineLane` binds its argument with. */
-type LaneOf<S> = LaneSpec & LaneChecks<S>;
-/** The lane does not hold together — with every defect named, never a half-lane. */
-declare class LaneShapeError extends Error {
-    readonly defects: readonly string[];
-    readonly name = "LaneShapeError";
-    readonly _tag: "LaneShapeError";
-    constructor(defects: readonly string[]);
-}
-/**
- * An authored lane: the {@link ImportedLane} every reader takes, plus the spec
- * it was authored from.
- *
- * `spec` is the whole typed door. It is DATA, not a phantom — the lane keeps
- * the charts it was handed, so `LaneState<L>` and `LaneMsg<L>` read the literal
- * types straight off it and nothing has to be re-declared beside the lane. An
- * imported lane simply has no `spec`, which is exactly what makes it read back
- * as `Chart<unknown>` through the same derivations: one formula, two doors.
- */
-interface Lane<S> extends ImportedLane {
-    /** The spec this lane was authored from — where the literal types live. */
-    readonly spec: S;
-}
-/**
- * A lane, from phases of charts.
- *
- * The result is an {@link ImportedLane} and nothing more — the SAME value
- * `chartFromWorkflow` returns for a `workflow.json`, so `foldLane`,
- * `deriveLaneStatus`, `laneReport` and `inspectLane` all take it without a
- * second code path. There is exactly one lane representation in this module and
- * two ways to obtain it.
- *
- * ```ts
- * const lane = defineLane({
- *   id: "epic-5728",
- *   phases: {
- *     phase1: { issue_5729: coderChart, issue_5730: coderChart },
- *     phase2: { issue_5731: coderChart },
- *   },
- *   terminals: { complete: "complete", tripped: "tripped" },
- * });
- * ```
- *
- * @throws {LaneShapeError} for the defects the type layer cannot see — a chart
- *   with no `initial: true`, a chart with no final at all (its phase could
- *   never complete, so the lane could never advance), and two terminals spelled
- *   the same way.
- */
-declare function defineLane<const S extends LaneOf<S>>(spec: S): Lane<S>;
-/** What an `ImportedLane` reads back as: every alphabet the bare `string`. */
-interface ImportedSpec {
-    readonly phases: Readonly<Record<string, Readonly<Record<string, ImportedChart>>>>;
-    readonly terminals: {
-        readonly complete: string;
-        readonly tripped: string;
-    };
-}
-/** The spec a lane was authored from — an imported lane carries none. */
-type SpecOf<L> = L extends {
-    readonly spec: infer S;
-} ? S : ImportedSpec;
-/**
- * The lane's phases, keyed the way every other layer keys them: by strings.
- *
- * A phase or a task written as a number (`{ 5729: coder }` — and fabrika's task
- * ids ARE GitHub issue numbers) is a key like any other; it is only `keyof`
- * that hands it back as a number. Normalising here, ONCE, is what lets every
- * derivation below stay the plain formula it was.
- */
-type Phases<L> = Keyed<PhasesOf<SpecOf<L>>>;
-/** The tasks of phase `P`, keyed by string for the same reason. */
-type TasksOf<L, P extends LanePhaseName<L>> = Keyed<Phases<L>[P]>;
-/**
- * `[string] extends [N]` — the alphabet stopped being a union of literals.
- *
- * The same guard `graph.ts` uses to catch a computed string key, here for the
- * opposite reason: an imported chart is DELIBERATELY degenerate, and a subset
- * derived off it (`InitialState`, `SuccessFinal`, `CellEdgeKey`) collapses to
- * `never` rather than to `string`. `never` would be a lie — the imported door
- * knows nothing about those states, it does not know there are none — so every
- * derived subset below is read through {@link StateSubset}, which hands back
- * `string` where the chart cannot be asked.
- */
-type IsDegenerate$1<N> = [string] extends [N] ? true : false;
-/** A derived subset of a chart's states — `string` where the chart is imported. */
-type StateSubset<C, T> = [IsDegenerate$1<StateName<C>>] extends [true] ? string : T;
-/** Every phase name, as a union. The ORDER is the value's, not the type's. */
-type LanePhaseName<L> = Extract<keyof Phases<L>, string>;
-/** The task ids declared in phase `P`. */
-type LaneTasksIn<L, P extends LanePhaseName<L>> = Extract<keyof TasksOf<L, P>, string>;
-/** Every task id in the lane, whatever phase it runs in. */
-type LaneTaskId<L> = {
-    [P in LanePhaseName<L>]: LaneTasksIn<L, P>;
-}[LanePhaseName<L>];
-/** The chart task `T` runs — ITS chart, not a union over the lane's charts. */
-type LaneTaskChart<L, T extends LaneTaskId<L>> = {
-    [P in LanePhaseName<L>]: T extends keyof TasksOf<L, P> ? TasksOf<L, P>[T] : never;
-}[LanePhaseName<L>];
-/** The phase task `T` runs in. `defineLane` refuses a task with two. */
-type LanePhaseOf<L, T extends LaneTaskId<L>> = {
-    [P in LanePhaseName<L>]: T extends keyof TasksOf<L, P> ? P : never;
-}[LanePhaseName<L>];
-/** The tasks running BESIDE `T` — its phase's set, minus itself. */
-type LaneSiblings<L, T extends LaneTaskId<L>> = Exclude<LaneTasksIn<L, LanePhaseOf<L, T> & LanePhaseName<L>>, T>;
-/** Where task `T`'s fold starts — `initial: true`, off its own chart. */
-type LaneInitial<L, T extends LaneTaskId<L>> = StateSubset<LaneTaskChart<L, T>, InitialState<LaneTaskChart<L, T>>>;
-/** `end: true` on task `T`'s chart — the endings that let its phase complete. */
-type LaneSuccessFinals<L, T extends LaneTaskId<L>> = StateSubset<LaneTaskChart<L, T>, SuccessFinal<LaneTaskChart<L, T>>>;
-/** `end: "error"` on task `T`'s chart — the endings that trip the lane. */
-type LaneErrorFinals<L, T extends LaneTaskId<L>> = StateSubset<LaneTaskChart<L, T>, ErrorFinal<LaneTaskChart<L, T>>>;
-/** The lane's two endings, as a union of the two literals. */
-type LaneTerminal<L> = TerminalsOf<SpecOf<L>>;
-/**
- * A phase that is not carrying task states.
- *
- * ONE TYPE, TWO NAMES, and it used to be two types with ONE name: this and
- * `report/fold.ts`'s {@link PhaseStanding} were both exported as
- * `PhaseStanding` from two entry points with different members, so which one a
- * reader got depended on which module they happened to import. It is a
- * SUBSET, so it is spelled as one — the phase standings minus the one reading
- * in which the phase IS its tasks' states, which is exactly why `LaneState`'s
- * phase leaf cannot hold `"active"`: while a phase is active there is a task
- * map there instead.
- */
-type PhaseAtRest = Exclude<PhaseStanding, "active">;
-/**
- * The compound state of a whole lane.
- *
- * A lane is not one machine and its state is not one state:
- *
- * ```ts
- * const s: LaneState<typeof lane> = {
- *   phases: {
- *     phase1: { issue_5729: { type: "build", retries: 0, maxRetries: 2 } },
- *     phase2: "waiting",
- *   },
- *   lane: "running",
- * };
- * ```
- *
- * Every leaf is that task's OWN `StateOf<chart>`, narrowed — `issue_5729` may
- * only stand in a state its own chart declares, carrying its own `ctx`. At an
- * imported lane the same formula reads back with `string` throughout.
- */
-type LaneState<L> = {
-    readonly phases: {
-        readonly [P in LanePhaseName<L>]: PhaseAtRest | {
-            readonly [T in LaneTasksIn<L, P>]: StateOf<TasksOf<L, P>[T]>;
-        };
-    };
-    /** `running`, or the terminal it ended on. */
-    readonly lane: "running" | LaneTerminal<L>;
-};
-/**
- * One message, addressed to one task of the lane.
- *
- * The union is built PER TASK, not as one alphabet across the lane: the event
- * is narrowed to the events that task's own chart declares, so a message
- * carrying a real event to the wrong task is as much a compile error as one
- * carrying an event nothing declares. A lane of two different chart templates
- * is where that stops being a technicality.
- */
-type LaneMsg<L> = {
-    [P in LanePhaseName<L>]: {
-        [T in LaneTasksIn<L, P>]: {
-            readonly task: T;
-            readonly event: EventName<TasksOf<L, P>[T]>;
-        };
-    }[LaneTasksIn<L, P>];
-}[LanePhaseName<L>];
-/** One task of a lane, with everything about it that is derivable. */
-interface LaneTaskShape {
-    readonly id: string;
-    /** The phase it runs in. */
-    readonly phase: string;
-    /** That phase's position in the sequence. */
-    readonly phaseIndex: number;
-    /** Where its fold starts — `initial: true`, read off the chart. */
-    readonly initial: string;
-    /** The right-hand side of the guarded edge's `retries < maxRetries`. */
-    readonly maxRetries: number;
-    /** `end: true` — the endings that let the phase complete. */
-    readonly successFinals: readonly string[];
-    /** `end: "error"` — the endings that trip the lane. */
-    readonly errorFinals: readonly string[];
-    /** The tasks running BESIDE this one, in the same phase. */
-    readonly siblings: readonly string[];
-}
-/** One phase, and the tasks that run concurrently inside it. */
-interface LanePhaseShape {
-    readonly name: string;
-    readonly index: number;
-    readonly tasks: readonly string[];
-    /** The phase this one's `onDone` advances to, or the lane's ending. */
-    readonly next: string;
-}
-/**
- * A whole lane, read as data. Nothing here is supplied — every field is a
- * derivation over the phases and the charts they hold.
- */
-interface LaneShape {
-    readonly id?: string;
-    readonly trigger?: string;
-    readonly phases: readonly LanePhaseShape[];
-    /** Every task, in phase order then declaration order. */
-    readonly tasks: readonly LaneTaskShape[];
-    readonly terminals: {
-        readonly complete: string;
-        readonly tripped: string;
-    };
-    /**
-     * Tasks whose chart declares NO error final.
-     *
-     * Not a defect — a lane may legitimately hold a task that cannot fail. It is
-     * reported because it is invisible otherwise and it changes what the lane can
-     * do: no run of that task can ever reach the `tripped` terminal.
-     */
-    readonly cannotTrip: readonly string[];
-}
-/**
- * Read a lane — imported or authored — into its {@link LaneShape}.
- *
- * Pure and total. It executes nothing, it validates nothing, and it refuses
- * nothing: it is the reader half, and a lane that is odd (a task with no error
- * final, say) comes back described rather than rejected. {@link defineLane} is
- * where an authoring mistake is refused; this is where any lane is read.
- */
-declare function laneShape(lane: ImportedLane): LaneShape;
-
-/**
- * Every region's leaf state, keyed by task.
- *
- * This is `LaneState`'s information with the phase dimension left out, and the
- * omission is the point: `LaneState` is the READING shape (what is running
- * beside what, which phases are waiting), and every one of those facts is
- * derived from the leaves plus the lane's phase order. A run that stored the
- * phase standing beside the leaves would be storing a derived fact, which is
- * exactly the mistake `laneShape` exists not to make. `deriveLaneStatus(lane,
- * state.regions)` produces the compound reading whenever it is wanted.
- */
-type LaneRegions<L> = {
-    readonly [T in LaneTaskId<L>]: StateOf<LaneTaskChart<L, T>>;
-};
-/**
- * The state of a lane in flight: every region's leaf, plus which of the three
- * things the lane itself is doing.
- *
- * `lane` is DERIVED after every step — it is `laneTerminalReached` over the
- * leaves — and it is stored because it is what a host reads to know the run is
- * over. It can never disagree with the leaves: nothing else writes it.
- */
-type LaneRunState<L> = {
-    readonly regions: LaneRegions<L>;
-    readonly lane: "running" | LaneTerminal<L>;
-};
-/**
- * The message union a running lane consumes: `{ task, event }`, on the wire.
- *
- * `MsgIn<C, NS>` is the chart module's own answer to "how does the compiled
- * table key event E under namespace NS", so instantiating it per task at
- * `NS = T` gives `${task}.${event}` with the payload that event declares — the
- * addressing pair of `LaneMsg<L>` and the key `keyOf` builds from it, which are
- * the same fact spelled for a reader and for a dispatcher.
- */
-type LaneRunMsg<L> = {
-    [T in LaneTaskId<L>]: MsgIn<LaneTaskChart<L, T>, T> & {
-        readonly type: string;
-    };
-}[LaneTaskId<L>];
-/** One region cmd, wearing the task that emitted it. */
-type Tagged<T extends string, K> = K extends {
-    readonly type: infer N extends string;
-} ? // the same witness `LaneRunMsg` carries, for the same reason: `Cmd` is
-Omit<K, "type" | "lane"> & {
-    readonly type: `${T}.${N}`;
-    readonly lane: {
-        readonly task: T;
-    };
-} & Cmd : never;
-/**
- * The cmd union a running lane emits — each region's own `CmdOf<chart>`, under
- * the SAME `${task}.${name}` namespace the messages arrive in.
- *
- * The task id is carried as well as spelled into the type, because the two
- * readers differ: an interpreter's handler map is keyed by `cmd.type` (so the
- * namespace has to be in the name), while the code that routes the reply back
- * wants the task id without parsing it out of a string.
- *
- * IT IS NESTED, and `lane` is the one key a region's cmd may not use — which
- * {@link LaneRunChecks} refuses at the typed door. The tag used to be a flat
- * `task`, spread OVER the payload, and `task` is an entirely ordinary field for
- * a cmd in a work lane to carry: the author's value was replaced by the lane's
- * task id, and `Tagged` narrowed the author's field to that literal, so there
- * was no type error either. One nested key is a smaller surface than every key
- * a chart might plausibly name.
- */
-type LaneCmd<L> = {
-    [T in LaneTaskId<L>]: Tagged<T, CmdOf<LaneTaskChart<L, T>>>;
-}[LaneTaskId<L>];
-/**
- * One task's half of the run.
- *
- * Both halves are typed to THAT task's chart — `parts` against its edges, its
- * guards and its cmds; `boot` against its states. Neither is a union across the
- * lane's charts, which is what makes a lane of two different templates safe to
- * hand code to.
- */
-interface LaneHand<C> {
-    /** The code the chart cannot hold — assigns, guards, cmd builders, cells. */
-    readonly parts: Parts<C, StateOf<C>, MsgOf<C>>;
-    /**
-     * Where THIS instance starts. An emitted epic boots each child where its
-     * sub-issue actually is, so two instances of one chart start in two different
-     * states and the chart's `initial: true` is the default rather than the law.
-     *
-     * Typed to THAT task's own chart, both ways: the return type is what makes
-     * `() => ({ type: "queued", … })` infer the literal instead of widening to
-     * `string`, and {@link LaneRunChecks} asks the same question a second time so
-     * the diagnostic names the task rather than pointing at a state union.
-     */
-    readonly boot: () => StateOf<C>;
-}
-/** Every task's hand — one per region, none missing, none invented. */
-type LaneHands<L> = {
-    readonly [T in LaneTaskId<L>]: LaneHand<LaneTaskChart<L, T>>;
-};
-/** `[string] extends [N]` — an imported chart's alphabet, which cannot be asked. */
-type IsDegenerate<N> = [string] extends [N] ? true : false;
-/** What `boot()` says it returns, for the task keyed `T` however it was spelled. */
-type BootOf<H, T> = Keyed<H>[T & keyof Keyed<H>] extends {
-    readonly boot: () => infer B;
-} ? B : never;
-/**
- * Tasks whose `boot()` returns a state whose `type` is no longer a LITERAL.
- *
- * Hoisting the hands to a variable is what every author does the moment a lane
- * is assembled by a helper, and without a `satisfies` it widens `boot()`'s
- * `type` from `"queued"` to `string`. The check below then cannot answer its
- * question, and used to answer a DIFFERENT one — it named a task whose boot
- * state was entirely correct and sent the author to look at the one thing that
- * was right.
- *
- * So this is asked FIRST and says what actually happened. It is the hands' half
- * of `__laneTerminalsMustBeLiteralsAddAsConst` on the spec side: the same
- * mistake, the same shape of answer.
- */
-type BootLostItsLiterals<L, H> = {
-    [T in LaneTaskId<L>]: [IsDegenerate<StateName<LaneTaskChart<L, T>>>] extends [
-        true
-    ] ? never : [BootOf<H, T>] extends [never] ? never : [
-        IsDegenerate<BootOf<H, T> extends {
-            readonly type: infer S;
-        } ? S : never>
-    ] extends [true] ? T : never;
-}[LaneTaskId<L>];
-/** Tasks whose `boot()` returns something that is not a state of THEIR chart. */
-type BootsOutsideItsChart<L, H> = {
-    [T in LaneTaskId<L>]: [IsDegenerate<StateName<LaneTaskChart<L, T>>>] extends [
-        true
-    ] ? never : [BootOf<H, T>] extends [never] ? never : [
-        IsDegenerate<BootOf<H, T> extends {
-            readonly type: infer S;
-        } ? S : never>
-    ] extends [true] ? never : [BootOf<H, T>] extends [StateOf<LaneTaskChart<L, T>>] ? never : T;
-}[LaneTaskId<L>];
-/**
- * Tasks whose chart declares a FOREIGN event.
- *
- * `keyOf` leaves a foreign event's name bare under a namespace — on purpose:
- * `deadline_exceeded` is the same event for every instance of a chart, and the
- * name was never the author's to rename. A lane cannot hold that: a lane
- * message is addressed to ONE region, and a bare event names none of them.
- * Refused rather than broadcast, because "this event went to every region at
- * once" is a different machine than the one the phases describe.
- */
-type DeclaresAForeignEvent<L> = {
-    [T in LaneTaskId<L>]: [IsDegenerate<EventName<LaneTaskChart<L, T>>>] extends [
-        true
-    ] ? never : [ForeignOf<LaneTaskChart<L, T>>] extends [never] ? never : T;
-}[LaneTaskId<L>];
-type ForeignOf<C> = C extends {
-    readonly events: infer E;
-} ? {
-    [K in keyof E]: E[K] extends {
-        readonly foreign: true;
-    } ? K : never;
-}[keyof E] : never;
-/**
- * Tasks whose chart declares a cmd carrying `lane` — the one reserved key.
- *
- * {@link LaneCmd} nests the task id under `lane` and a nested tag can still be
- * shadowed by a payload that spells the same key. It is refused rather than
- * silently overwritten, because "the field you declared is not the field your
- * interpreter receives" is the exact defect nesting was introduced to end.
- */
-type CmdCarriesTheLaneTag<L> = {
-    [T in LaneTaskId<L>]: [
-        Extract<CmdOf<LaneTaskChart<L, T>>, {
-            readonly lane: unknown;
-        }>
-    ] extends [never] ? never : T;
-}[LaneTaskId<L>];
-/** The five authoring mistakes a RUN can make that a drawing cannot. */
-type LaneRunChecks<L, H> = ([
-    Exclude<Key<keyof H>, LaneTaskId<L>>
-] extends [never] ? unknown : {
-    readonly __laneHandNamesAnUnknownTask: Exclude<Key<keyof H>, LaneTaskId<L>>;
-}) & ([BootLostItsLiterals<L, H>] extends [never] ? unknown : {
-    readonly __laneHandsLostTheirLiteralTypesAddSatisfiesLaneHands: BootLostItsLiterals<L, H>;
-}) & ([BootsOutsideItsChart<L, H>] extends [never] ? unknown : {
-    readonly __laneTaskBootsIntoAStateItsChartDoesNotDeclare: BootsOutsideItsChart<L, H>;
-}) & ([DeclaresAForeignEvent<L>] extends [never] ? unknown : {
-    readonly __laneRegionChartDeclaresAForeignEvent: DeclaresAForeignEvent<L>;
-}) & ([CmdCarriesTheLaneTag<L>] extends [never] ? unknown : {
-    readonly __laneRegionCmdDeclaresTheReservedLaneField: CmdCarriesTheLaneTag<L>;
-});
-/**
- * The self-referential constraint `runLane` binds its hands with.
- *
- * The CHECKS come first in the intersection, and the order is load-bearing for
- * the diagnostic rather than for the semantics: tsc reports the first
- * constituent that fails, so a hands object that boots a task into the wrong
- * state is told which RULE it broke and which TASK broke it, instead of being
- * handed that task's whole state union to compare by eye.
- */
-type LaneHandsOf<L, H> = LaneRunChecks<L, H> & LaneHands<L>;
-/**
- * A lane's `init` and `update` — the two halves of a `Machine` a lane can
- * derive, and exactly the two.
- */
-interface LaneRuntime<L> {
-    readonly init: (loaded: LaneRunState<L> | null) => readonly [LaneRunState<L>, readonly LaneCmd<L>[]];
-    readonly update: Reducer<LaneRunState<L>, LaneRunMsg<L>, LaneCmd<L>>;
-}
-/** What `runLane` reads off the spec: the charts, still carrying their types. */
-type RunnableSpec = {
-    readonly phases: Readonly<Record<string, Readonly<Record<string, LaneRegion>>>>;
-};
-/**
- * Run a lane: one compiled region per task, one dispatch surface, one derived
- * lane standing.
- *
- * ```ts
- * const epic = defineLane({
- *   phases: { phase1: { issue_5729: coder, issue_5730: coder } },
- *   terminals: { complete: "complete", tripped: "tripped" },
- * });
- *
- * const machine = defineMachine({
- *   ...runLane(epic, {
- *     issue_5729: { parts, boot: () => ({ type: "queued", retries: 0, maxRetries: 2 }) },
- *     // this one is already merged on GitHub — it boots where it IS.
- *     issue_5730: { parts, boot: () => ({ type: "shipped", retries: 0, maxRetries: 2 }) },
- *   }),
- *   interpret,
- * });
- * ```
- *
- * @throws {LaneShapeError} for the run-time half of what the markers say: a
- *   task with no chart on the spec, a region declaring a foreign event, and a
- *   `boot()` landing on a state its chart does not declare.
- */
-declare function runLane<L extends Lane<RunnableSpec>, const H extends LaneHandsOf<L, H>>(lane: L, hands: H): LaneRuntime<L>;
-
-export { type LaneTaskShape as A, type LaneTasksIn as B, type LaneTerminal as C, defineLane as D, laneShape as E, runLane as F, type LaneTaskId as L, type PhaseAtRest as P, type LaneTaskChart as a, type LaneHandsOf as b, type Lane as c, type LaneChecks as d, type LaneCmd as e, type LaneErrorFinals as f, type LaneHand as g, type LaneHands as h, type LaneInitial as i, type LaneMsg as j, type LaneOf as k, type LanePhaseName as l, type LanePhaseOf as m, type LanePhaseShape as n, type LaneRegion as o, type LaneRegions as p, type LaneRunChecks as q, type LaneRunMsg as r, type LaneRunState as s, type LaneRuntime as t, type LaneShape as u, LaneShapeError as v, type LaneSiblings as w, type LaneSpec as x, type LaneState as y, type LaneSuccessFinals as z };