@ksp-gonogo/sitrep-sdk 0.0.1 → 0.2.0-rc.12

package/dist/spine/own-craft-vantage.js

@@ -0,0 +1,136 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEffect } from "react";
+import { useTelemetryClientOptional } from "./context.js";
+import { useSelectedVantage } from "./use-selected-vantage.js";
+import { useStream } from "./use-stream.js";
+/**
+ * Whether a session observing from `selectedVantage` is standing on the very
+ * craft it is watching, which is the one case the mod delivers at zero delay.
+ *
+ * Both arguments are ids in the `commandCentre.roster` vocabulary
+ * (`"vessel:<guid>"` / `"ground:<name>"`), so the comparison is a plain string
+ * equality and never a format this file restates. `subjectId` is the active
+ * craft's own id as the orbit sample names it; a vantage that equals it is a
+ * crewed centre aboard that craft.
+ *
+ * The empty string is not a vantage. `Meta.Vantage` is `""` while the
+ * connection sits at no command centre because none is active, and an absent
+ * subject arrives the same way, so a bare `===` would call two unknowns a
+ * match and hand a ground operator a zero-delay clock on a craft they are
+ * nowhere near.
+ */
+export function isOwnCraftVantage(selectedVantage, subjectId) {
+    if (!selectedVantage || !subjectId)
+        return false;
+    return selectedVantage === subjectId;
+}
+/**
+ * The craft the samples are about, held through a quiet link: which craft that
+ * is does not change because its telemetry stopped arriving.
+ *
+ * Read off the orbit PAYLOAD's own `meta.source`, `"vessel:<guid>"` as
+ * `Sitrep.Host.VesselViewProvider.BuildMeta` stamps it. Never the envelope's
+ * `meta.source`: that is the Courier node, the literal `"system"` for every
+ * non-fleet topic, which no roster id can equal. Optional-chained because a
+ * recording or golden fixture can carry no payload meta at all, and then the
+ * subject is unknown.
+ */
+function subjectOf(reading) {
+    return reading.state === "observed" || reading.state === "held"
+        ? reading.value.meta?.source
+        : undefined;
+}
+/**
+ * Whether THIS session's selected vantage is the craft its own telemetry is
+ * about: true for a pilot strapped into the active craft, false for a ground
+ * operator whatever centre they picked.
+ *
+ * Gated on the SELECTED vantage, never the observed one. Observed lags a whole
+ * light-time behind the request that moved it, so a clock keyed on it would
+ * stay ground-delayed for exactly as long as the delay it is meant to remove,
+ * and `PilotVantage` (which sets the vantage) keys on selected for the same
+ * reason. The cost is a transient at the moment of the request: `setVantage`
+ * tracks optimistically, so between asking and the mod agreeing the clock
+ * reads zero while frames are still arriving ground-delayed. That window is
+ * bounded by one round trip and errs towards the live reading, where the
+ * inverse (holding the ground's light-time over live frames) blanks the page
+ * outright once the delay exceeds the timeline's retention.
+ *
+ * Screen-independent on purpose. The mod's zero row is written for whichever
+ * centre IS the active craft (`AuthorityMatrixPass.PopulateActiveVessel`), not
+ * for a route, so a main-screen operator who selects the active craft's own
+ * vantage is reading live frames too and must be told so.
+ */
+export function useOwnCraftVantage() {
+    const client = useTelemetryClientOptional();
+    const selectedVantage = useSelectedVantage();
+    const subjectId = subjectOf(useStream("vessel.orbit"));
+    // No client means no session to be at a vantage at all, which is neither the pilot case nor a lie about one: fall through to the wire's own delay.
+    if (!client)
+        return false;
+    return isOwnCraftVantage(selectedVantage, subjectId);
+}
+/**
+ * Keeps the auto-built clock's `DelayAuthority` told whether this session is
+ * watching the craft it is standing on, which is the one case the mod streams
+ * at no delay (see `DelayAuthority.setOwnCraftVantage`).
+ *
+ * A component rather than a hook call in the provider body because
+ * `useOwnCraftVantage` reads `vessel.orbit`, and every stream read re-renders
+ * its caller on EVERY frame the store mints. In the provider body
+ * that would re-render the whole application tree at frame rate; here it
+ * re-renders one leaf that draws nothing. Rendered only alongside an
+ * auto-built authority: a caller who supplied their own `store` owns its
+ * clock's delay wiring whole, the same exemption the `comms.delay`
+ * subscription effect above makes.
+ *
+ * Written from an effect rather than during render so the render stays pure
+ * and a StrictMode double-render cannot write twice. The frame of lag that
+ * costs is immaterial: the value changes when an operator picks a vantage,
+ * not per frame, and the clock re-reads `delaySeconds()` on every one.
+ *
+ * Split in two so that reading (and so subscribing) `vessel.orbit` happens
+ * ONLY once a vantage has been chosen.
+ * A session that has chosen none sits wherever the mod put it, which is never
+ * the craft's own centre, so the answer is already false and the subject is
+ * not worth a subscription. Reading it unconditionally is not a free
+ * convenience: it puts `vessel.orbit` on the wire for every session, and the
+ * host relay is contractually meant to pull a topic because a screen asked for
+ * it and for no other reason (`SitrepPeerRelay.test.tsx` pins exactly that,
+ * and caught this).
+ *
+ * The deferral costs nothing where it matters. `PilotVantage` reads
+ * `vessel.orbit` itself before it ever calls `setVantage`, so on a pilot's
+ * screen the subject is already subscribed and already known at the instant
+ * the vantage changes. Anywhere else the gate simply stays false for the frame
+ * or two the first orbit sample takes, which errs towards the wire's own
+ * delay: the safe direction, since a wrongly-zero clock is the failure.
+ */
+export function OwnCraftDelayGate({ authority, }) {
+    const selectedVantage = useSelectedVantage();
+    return selectedVantage === undefined ? (_jsx(OwnCraftDelayIdle, { authority: authority })) : (_jsx(OwnCraftDelayWatch, { authority: authority, selectedVantage: selectedVantage }));
+}
+/** No vantage chosen, so nothing to read and nothing to subscribe: hold the wire's own delay. */
+function OwnCraftDelayIdle({ authority }) {
+    useEffect(() => {
+        authority.setOwnCraftVantage(false);
+        return () => authority.setOwnCraftVantage(false);
+    }, [authority]);
+    return null;
+}
+/** A vantage is chosen: watch the subject the samples are about and answer whether they are the same craft. */
+function OwnCraftDelayWatch({ authority, selectedVantage, }) {
+    const subjectId = subjectOf(useStream("vessel.orbit"));
+    const ownCraftVantage = isOwnCraftVantage(selectedVantage, subjectId);
+    useEffect(() => {
+        authority.setOwnCraftVantage(ownCraftVantage);
+        /*
+         * Releasing on unmount matters: the provider swaps this for the idle half
+         * whenever the vantage is cleared, and a zero left behind would outlive
+         * the vantage that earned it.
+         */
+        return () => authority.setOwnCraftVantage(false);
+    }, [authority, ownCraftVantage]);
+    return null;
+}
+//# sourceMappingURL=own-craft-vantage.js.map

package/dist/spine/own-craft-vantage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"own-craft-vantage.js","sourceRoot":"","sources":["../../src/spine/own-craft-vantage.tsx"],"names":[],"mappings":";AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAGlC,OAAO,EAAE,0BAA0B,EAAE,MAAM,WAAW,CAAC;AAEvD,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAC5D,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAEzC;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,iBAAiB,CAC/B,eAAmC,EACnC,SAA6B;IAE7B,IAAI,CAAC,eAAe,IAAI,CAAC,SAAS;QAAE,OAAO,KAAK,CAAC;IACjD,OAAO,eAAe,KAAK,SAAS,CAAC;AACvC,CAAC;AAED;;;;;;;;;;GAUG;AACH,SAAS,SAAS,CAAC,OAAkC;IACnD,OAAO,OAAO,CAAC,KAAK,KAAK,UAAU,IAAI,OAAO,CAAC,KAAK,KAAK,MAAM;QAC7D,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,EAAE,MAAM;QAC5B,CAAC,CAAC,SAAS,CAAC;AAChB,CAAC;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,UAAU,kBAAkB;IAChC,MAAM,MAAM,GAAG,0BAA0B,EAAE,CAAC;IAC5C,MAAM,eAAe,GAAG,kBAAkB,EAAE,CAAC;IAC7C,MAAM,SAAS,GAAG,SAAS,CAAC,SAAS,CAAc,cAAc,CAAC,CAAC,CAAC;IACpE,mJAAmJ;IACnJ,IAAI,CAAC,MAAM;QAAE,OAAO,KAAK,CAAC;IAC1B,OAAO,iBAAiB,CAAC,eAAe,EAAE,SAAS,CAAC,CAAC;AACvD,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,MAAM,UAAU,iBAAiB,CAAC,EAChC,SAAS,GAGV;IACC,MAAM,eAAe,GAAG,kBAAkB,EAAE,CAAC;IAC7C,OAAO,eAAe,KAAK,SAAS,CAAC,CAAC,CAAC,CACrC,KAAC,iBAAiB,IAAC,SAAS,EAAE,SAAS,GAAI,CAC5C,CAAC,CAAC,CAAC,CACF,KAAC,kBAAkB,IACjB,SAAS,EAAE,SAAS,EACpB,eAAe,EAAE,eAAe,GAChC,CACH,CAAC;AACJ,CAAC;AAED,iGAAiG;AACjG,SAAS,iBAAiB,CAAC,EAAE,SAAS,EAAiC;IACrE,SAAS,CAAC,GAAG,EAAE;QACb,SAAS,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAC;QACpC,OAAO,GAAG,EAAE,CAAC,SAAS,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAC;IACnD,CAAC,EAAE,CAAC,SAAS,CAAC,CAAC,CAAC;IAChB,OAAO,IAAI,CAAC;AACd,CAAC;AAED,+GAA+G;AAC/G,SAAS,kBAAkB,CAAC,EAC1B,SAAS,EACT,eAAe,GAIhB;IACC,MAAM,SAAS,GAAG,SAAS,CAAC,SAAS,CAAc,cAAc,CAAC,CAAC,CAAC;IACpE,MAAM,eAAe,GAAG,iBAAiB,CAAC,eAAe,EAAE,SAAS,CAAC,CAAC;IACtE,SAAS,CAAC,GAAG,EAAE;QACb,SAAS,CAAC,kBAAkB,CAAC,eAAe,CAAC,CAAC;QAC9C;;;;WAIG;QACH,OAAO,GAAG,EAAE,CAAC,SAAS,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAC;IACnD,CAAC,EAAE,CAAC,SAAS,EAAE,eAAe,CAAC,CAAC,CAAC;IACjC,OAAO,IAAI,CAAC;AACd,CAAC"}

package/dist/spine/past-track.d.ts

@@ -0,0 +1,46 @@
+import { type WireOrbitElements } from "./kepler-reckoning.js";
+import type { TrajectoryPoint } from "./orbit-trajectory.js";
+/** One `vessel.orbit` sample and the instant it was true; a `null` payload is a tombstone, the craft having no orbit then (on the pad). */
+export interface OrbitSample {
+    payload: (WireOrbitElements & {
+        referenceBodyIndex?: number;
+    }) | null;
+    validAt: number;
+}
+/**
+ * Where the craft HAS BEEN, from the samples that were true at the time.
+ *
+ * <p><b>Observed, not propagated backwards.</b> Each point is solved from the
+ * elements that arrived for that instant, so the trail is a record of what was
+ * reported rather than a model of what must have happened. Running the current
+ * elements backwards would be a different claim and a wrong one under an n-body
+ * force model, where the path does not retrace: the craft's real past is only
+ * recoverable from what was measured, and that is exactly what the store
+ * holds.</p>
+ *
+ * <p>This is why the forward arc and the trail must be drawn differently. One
+ * is a prediction and one is a record, and a single unbroken curve through the
+ * craft would assert the same confidence in both.</p>
+ *
+ * <p><b>Expressed in `frame`'s perifocal frame, and that argument is required
+ * for a reason.</b> Each point is SOLVED from its own sample, which is what
+ * makes the trail a record, and a solve hands back a body-centred inertial
+ * position. The arc it is drawn beside is in the perifocal frame of the elements
+ * the diagram was drawn from, so a trail left inertial is a curve of the right
+ * shape and the right size sitting rotated away from the path the craft is on by
+ * that orbit's own three angles, and out of its plane entirely once the orbit is
+ * tilted. Nothing about it looks wrong. Defaulting the frame would let the next
+ * caller inherit that silently, so there is no default: naming the elements the
+ * points are to be read against is part of asking for them.</p>
+ */
+export declare function pastTrack(samples: readonly OrbitSample[], options: {
+    /**
+     * The elements whose perifocal frame the points come back in. The same ones
+     * the diagram was drawn from, never the sample's own: osculating elements
+     * drift, and a point placed in the frame belonging to its own instant would
+     * put every point in a slightly different frame from its neighbour.
+     */
+    frame: WireOrbitElements;
+    centreBodyIndex?: number;
+}): TrajectoryPoint[];
+//# sourceMappingURL=past-track.d.ts.map

package/dist/spine/past-track.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"past-track.d.ts","sourceRoot":"","sources":["../../src/spine/past-track.ts"],"names":[],"mappings":"AACA,OAAO,EAAiB,KAAK,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAC3E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAE1D,2IAA2I;AAC3I,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,CAAC,iBAAiB,GAAG;QAAE,kBAAkB,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,GAAG,IAAI,CAAC;IACtE,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,SAAS,CACvB,OAAO,EAAE,SAAS,WAAW,EAAE,EAC/B,OAAO,EAAE;IACP;;;;;OAKG;IACH,KAAK,EAAE,iBAAiB,CAAC;IACzB,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B,GACA,eAAe,EAAE,CA4CnB"}

package/dist/spine/past-track.js

@@ -0,0 +1,62 @@
+import { rotateInertialToPerifocal, solve } from "./kepler.js";
+import { buildElements } from "./kepler-reckoning.js";
+/**
+ * Where the craft HAS BEEN, from the samples that were true at the time.
+ *
+ * <p><b>Observed, not propagated backwards.</b> Each point is solved from the
+ * elements that arrived for that instant, so the trail is a record of what was
+ * reported rather than a model of what must have happened. Running the current
+ * elements backwards would be a different claim and a wrong one under an n-body
+ * force model, where the path does not retrace: the craft's real past is only
+ * recoverable from what was measured, and that is exactly what the store
+ * holds.</p>
+ *
+ * <p>This is why the forward arc and the trail must be drawn differently. One
+ * is a prediction and one is a record, and a single unbroken curve through the
+ * craft would assert the same confidence in both.</p>
+ *
+ * <p><b>Expressed in `frame`'s perifocal frame, and that argument is required
+ * for a reason.</b> Each point is SOLVED from its own sample, which is what
+ * makes the trail a record, and a solve hands back a body-centred inertial
+ * position. The arc it is drawn beside is in the perifocal frame of the elements
+ * the diagram was drawn from, so a trail left inertial is a curve of the right
+ * shape and the right size sitting rotated away from the path the craft is on by
+ * that orbit's own three angles, and out of its plane entirely once the orbit is
+ * tilted. Nothing about it looks wrong. Defaulting the frame would let the next
+ * caller inherit that silently, so there is no default: naming the elements the
+ * points are to be read against is part of asking for them.</p>
+ */
+export function pastTrack(samples, options) {
+    const into = buildElements(options.frame);
+    const points = [];
+    for (const sample of samples) {
+        // A tombstone breaks the trail the way a change of body does: nothing joins across an instant with no orbit.
+        if (sample.payload === null) {
+            points.length = 0;
+            continue;
+        }
+        // A sample taken about a DIFFERENT body is a different frame, and joining
+        // the two would draw a line across the gap between them. A craft that
+        // changed sphere of influence has a trail that starts at the transition,
+        // which is the truth about what this frame can show.
+        if (options.centreBodyIndex !== undefined &&
+            sample.payload.referenceBodyIndex !== undefined &&
+            sample.payload.referenceBodyIndex !== options.centreBodyIndex) {
+            points.length = 0;
+            continue;
+        }
+        const elements = buildElements(sample.payload);
+        if (!(elements.ecc < 1) ||
+            !(elements.sma > 0) ||
+            !Number.isFinite(elements.mu)) {
+            // An escape trajectory has no closed solution here, and a sample that
+            // arrived incomplete cannot be placed. Dropping the point keeps the trail
+            // honest about which instants it can speak for.
+            continue;
+        }
+        const [x, y, z] = rotateInertialToPerifocal(solve(elements, sample.validAt).position, into.inc, into.lan, into.argPe);
+        points.push({ x, y, z, ut: sample.validAt });
+    }
+    return points;
+}
+//# sourceMappingURL=past-track.js.map

package/dist/spine/past-track.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"past-track.js","sourceRoot":"","sources":["../../src/spine/past-track.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,yBAAyB,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AAC5D,OAAO,EAAE,aAAa,EAA0B,MAAM,oBAAoB,CAAC;AAS3E;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,UAAU,SAAS,CACvB,OAA+B,EAC/B,OASC;IAED,MAAM,IAAI,GAAG,aAAa,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;IAC1C,MAAM,MAAM,GAAsB,EAAE,CAAC;IACrC,KAAK,MAAM,MAAM,IAAI,OAAO,EAAE,CAAC;QAC7B,6GAA6G;QAC7G,IAAI,MAAM,CAAC,OAAO,KAAK,IAAI,EAAE,CAAC;YAC5B,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC;YAClB,SAAS;QACX,CAAC;QAED,0EAA0E;QAC1E,sEAAsE;QACtE,yEAAyE;QACzE,qDAAqD;QACrD,IACE,OAAO,CAAC,eAAe,KAAK,SAAS;YACrC,MAAM,CAAC,OAAO,CAAC,kBAAkB,KAAK,SAAS;YAC/C,MAAM,CAAC,OAAO,CAAC,kBAAkB,KAAK,OAAO,CAAC,eAAe,EAC7D,CAAC;YACD,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC;YAClB,SAAS;QACX,CAAC;QAED,MAAM,QAAQ,GAAG,aAAa,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;QAC/C,IACE,CAAC,CAAC,QAAQ,CAAC,GAAG,GAAG,CAAC,CAAC;YACnB,CAAC,CAAC,QAAQ,CAAC,GAAG,GAAG,CAAC,CAAC;YACnB,CAAC,MAAM,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC,EAC7B,CAAC;YACD,sEAAsE;YACtE,0EAA0E;YAC1E,gDAAgD;YAChD,SAAS;QACX,CAAC;QAED,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,GAAG,yBAAyB,CACzC,KAAK,CAAC,QAAQ,EAAE,MAAM,CAAC,OAAO,CAAC,CAAC,QAAQ,EACxC,IAAI,CAAC,GAAG,EACR,IAAI,CAAC,GAAG,EACR,IAAI,CAAC,KAAK,CACX,CAAC;QACF,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,OAAO,EAAE,CAAC,CAAC;IAC/C,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC"}

package/dist/spine/powered-reckoning.d.ts

@@ -0,0 +1,164 @@
+import type { Quantityish } from "../magnitude.js";
+import type { ModelledField, ReckonedBands, ReckoningDecline } from "../reading.js";
+import type { TimelinePoint } from "../timeline.js";
+import { type Value } from "../unit-system/value.js";
+import { type OrbitElements, type StateVector } from "./kepler.js";
+import { type ConicBodiesInput, type ConicOrbitInput, type ConicPendingInput, type ConicThrustInput } from "./kepler-reckoning.js";
+/**
+ * The powered-flight model: a craft under thrust carried forward from its last
+ * observation, in the reference body's inertial frame, under point-mass gravity
+ * and a steady burn.
+ *
+ * ## What it assumes, and where each assumption ends
+ *
+ * Between the last observation and the instant asked about, the burn holds:
+ * the thrust the engines were making, along the direction they were last seen
+ * pushing, with the mass falling at the published mass flow. Each of those
+ * stops being true at a published instant, and the model withdraws there
+ * rather than carrying a guess past it:
+ *
+ * - a command in flight reaches the craft (it may move the throttle, the
+ *   attitude or the stage, and none of that is followed)
+ * - the firing stage runs out of propellant (staging is not modelled)
+ * - the burn carries the craft into the air or out of the body's sphere of
+ *   influence
+ * - the model's own uncertainty grows past one percent of the orbit's radius
+ *
+ * The coast that follows a cut-off is the conic's, not this model's: once
+ * `vessel.propulsion` reports the engines cold, the conic carries the craft
+ * and this model is never asked.
+ *
+ * ## What it does not know
+ *
+ * SAS modes and a pilot's hand. A craft holding prograde turns its thrust with
+ * its velocity, and a fixed direction drifts from it; the band carries that
+ * drift as the turn the burn was last measured making, and the horizon ends
+ * the model when the drift is too large to stand behind.
+ */
+/**
+ * The fields of `vessel.propulsion` the powered-flight model reads: those
+ * {@link ConicThrustInput} has, plus the craft's mass and how fast it falls.
+ *
+ * @category Reckoners
+ */
+export interface PoweredThrustInput extends ConicThrustInput {
+    /** The craft's total mass. */
+    totalMass: Quantityish;
+    /** How fast the mass falls while the engines fire. */
+    massFlow?: Quantityish | null;
+}
+/**
+ * What the powered-flight model needs beyond the craft's orbit: the engines'
+ * state, the fuel left in the firing stage, and the commands on their way.
+ * Build it with {@link poweredFlightEvidence}.
+ *
+ * @category Reckoners
+ */
+export interface PoweredFlightEvidence {
+    /** The engines' last stated condition, `undefined` where nothing has said. */
+    readonly thrust: PoweredThrustInput | undefined;
+    /** When `thrust` was observed. */
+    readonly thrustAtUt: number | undefined;
+    /** Tonnes of propellant left in the firing stage, `undefined` where unknown. */
+    readonly stageFuel: number | undefined;
+    /** The commands in flight, `undefined` where the queue has not arrived. */
+    readonly pending: ConicPendingInput | undefined;
+}
+interface ReadingLike<Payload> {
+    readonly state: string;
+    readonly value?: Payload;
+    readonly atUt?: Quantityish;
+    readonly asOfUt?: Quantityish;
+}
+/**
+ * Returns a {@link PoweredFlightEvidence} from the `vessel.propulsion`,
+ * `dv.stages`, `vessel.structure` and `system.uplink.pending` readings. The
+ * firing stage is the `dv.stages` entry for the structure's `currentStage`.
+ *
+ * @category Reckoners
+ */
+export declare function poweredFlightEvidence(thrust: ReadingLike<PoweredThrustInput>, stages: ReadingLike<readonly ({
+    stage?: number | null;
+    fuelMass?: Quantityish | null;
+} | null)[]>, structure: ReadingLike<{
+    currentStage: number;
+}>, pending: ReadingLike<ConicPendingInput>): PoweredFlightEvidence;
+/**
+ * Returns the orbital elements for a position and velocity relative to the
+ * body, the reverse of {@link solve}: `solve(elementsFromState(s, mu, t), t)`
+ * gives `s` back. Angles are in radians. Works for escape orbits as well as
+ * elliptical ones. On an equatorial or circular orbit, where the ascending node
+ * or periapsis does not exist, that angle is 0.
+ *
+ * @category Reckoners
+ */
+export declare function elementsFromState(state: StateVector, mu: number, epoch: number): OrbitElements;
+/**
+ * The orbital elements the powered-flight model moves, in the units
+ * `vessel.orbit` uses.
+ *
+ * @category Reckoners
+ */
+export interface PoweredOrbitProjection {
+    sma: Value<"m">;
+    ecc: Value<"1">;
+    inc: Value<"°">;
+    lan: Value<"°">;
+    argPe: Value<"°">;
+    meanAnomalyAtEpoch: Value<"rad">;
+    epoch: Value<"ut">;
+}
+/**
+ * The two `vessel.flight` fields the powered-flight model moves.
+ *
+ * @category Reckoners
+ */
+export interface PoweredFlightFields {
+    /** Height above sea level. */
+    altitudeAsl: Value<"m">;
+    /** Speed relative to the body's centre. */
+    orbitalSpeed: Value<"m/s">;
+}
+/**
+ * A burn carried forward: the craft's state at any instant up to the model's
+ * horizon, and how well it is known. {@link poweredFlight} returns one.
+ *
+ * @category Reckoners
+ */
+export interface PoweredFlight {
+    /** The paths the model moves. */
+    readonly modelled: readonly ModelledField[];
+    /** Position and velocity at `ut`, body-centred inertial. */
+    stateAt(ut: number): StateVector;
+    /**
+     * The state at `ut` of the expected burn first, then of each burn varied by
+     * its uncertainty, so a caller can put a band on a quantity of its own.
+     */
+    spreadAt(ut: number): readonly StateVector[];
+    /** The orbit the craft is on at `ut`, in the units `vessel.orbit` uses. */
+    elementsAt(ut: number): PoweredOrbitProjection;
+    /** One-sigma bands over every moved path, at `ut`. */
+    bandsAt(ut: number): ReckonedBands;
+    /**
+     * The craft's altitude above a sea level of `seaLevel` metres and its orbital
+     * speed at `ut`, as `vessel.flight` carries them.
+     */
+    flightAt(ut: number, seaLevel: number): PoweredFlightFields;
+    /** One-sigma bands over `altitudeAsl` and `orbitalSpeed`, from the same varied burns as `bandsAt`. */
+    flightBandsAt(ut: number, seaLevel: number): ReckonedBands;
+}
+/**
+ * Returns a {@link PoweredFlight} carrying a craft under thrust forward to
+ * `reckonUt`, or a decline with reason `"under-physics"` saying why it cannot.
+ * `history` is `vessel.orbit`'s recent samples, oldest first, ending with
+ * `point`.
+ *
+ * @category Reckoners
+ */
+export declare function poweredFlight(point: TimelinePoint<ConicOrbitInput>, history: readonly TimelinePoint<ConicOrbitInput>[], bodies: ConicBodiesInput | undefined, reckonUt: number, evidence: PoweredFlightEvidence): {
+    readonly flight: PoweredFlight;
+} | {
+    readonly declined: ReckoningDecline;
+};
+export {};
+//# sourceMappingURL=powered-reckoning.d.ts.map

package/dist/spine/powered-reckoning.d.ts.map

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