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

package/dist/__generated__/error-codes.d.ts

@@ -0,0 +1,376 @@
+/**
+ * One declared error code, as a client reads it.
+ *
+ * @category Error codes
+ */
+export interface ErrorCodeDeclaration {
+    /** The camelCase id: one segment for a root or a fault, `owner.name` for a refinement. */
+    readonly id: string;
+    /** `refusal`: the game ran the command and said no. `fault`: nothing was decided, the request could not be carried. */
+    readonly kind: "refusal" | "fault";
+    /** The root a refinement refines; `null` on a root and on every fault. */
+    readonly refines: string | null;
+    /** Where a fault is minted; `null` on a refusal. */
+    readonly origin: "mod" | "client" | null;
+    /** What an operator reads after "refused:" or "failed:", lower case and without a full stop. */
+    readonly sentence: string;
+    /** What the code means, from its declaration's doc comment. Empty when that is not to hand. */
+    readonly meaning: string;
+}
+/**
+ * The root refusals: the closed set every client can switch on. Each says what
+ * kind of refusal it was, and so whether waiting, changing the craft, or doing
+ * something in the game is what makes a retry worthwhile.
+ *
+ * A producer that can say more names a refinement of one of these (see
+ * `RefusalCode.Refine`); the root still travels, so nothing a client does with
+ * a root depends on knowing the refinement.
+ *
+ * @category Error codes
+ */
+export declare const CommandErrorCode: {
+    /**
+     * There is no active vessel to act on.
+     */
+    readonly NoVessel: "noVessel";
+    /**
+     * The requested mode or state is not available, and the game gave no more
+     * specific reason.
+     */
+    readonly ModeUnavailable: "modeUnavailable";
+    /**
+     * An argument was out of its valid range.
+     */
+    readonly Range: "range";
+    /**
+     * The referenced entity (a node id, a vessel or body target, a craft name) did
+     * not resolve.
+     */
+    readonly NotFound: "notFound";
+    /**
+     * The maneuver plan is owned by a planner other than stock's
+     * `patchedConicSolver`, so a node written there would never be used.
+     *
+     * Refused rather than attempted: an n-body planner clears stock's node list
+     * every frame and writes its own guidance node into it, so a written node
+     * would show on the board and do nothing. The owning planner is on the wire as
+     * `VesselManeuver.Planner`.
+     */
+    readonly PlanNotOwned: "planNotOwned";
+    /**
+     * A capacity is full: the Astronaut Complex holds its cap of active crew, a
+     * facility holds its cap of anything else countable.
+     *
+     * A retry succeeds only once something changes, such as freeing a slot.
+     *
+     * `CommandResult.breach` carries the numbers, so a client can say "16 of 16".
+     */
+    readonly LimitReached: "limitReached";
+    /**
+     * Already at the top of an upgradeable scale, so there is nothing above this
+     * to move to. The Launch Pad at tier 3 of 3.
+     *
+     * Not `CommandErrorCode.LimitReached`: a cap that is full can be freed; a
+     * maximum tier cannot be exceeded by any action at all.
+     */
+    readonly AlreadyAtMaximum: "alreadyAtMaximum";
+    /**
+     * The command costs more than the funds on hand.
+     *
+     * `CommandResult.breach` carries the cost as `Actual` against the balance as
+     * `Limit`, so the client can say how short and in the operator's own currency
+     * rendering.
+     */
+    readonly InsufficientFunds: "insufficientFunds";
+    /**
+     * The command costs more science than is banked. Separate from
+     * `CommandErrorCode.InsufficientFunds`, as the game keeps science and funds
+     * separate currencies.
+     *
+     * Authority: `CurrencyModifierQuery.RunQuery(reason,
+     * ...).CanAfford(Currency.Science)`, which is what `RDTech.ResearchTech`
+     * checks, modifiers included.
+     */
+    readonly InsufficientScience: "insufficientScience";
+    /**
+     * The save is not a career save, so this command's whole subsystem does not
+     * exist here.
+     *
+     * Authority: `HighLogic.CurrentGame.Mode`, and in practice the null `Instance`
+     * of the `ScenarioModule` that would have served it (`Funding`,
+     * `ContractSystem`, `StrategySystem`, `ResearchAndDevelopment`,
+     * `ScenarioUpgradeableFacilities`).
+     *
+     * A permanent property of the save, not a state that may change, so a client
+     * can hide the control rather than show it refused.
+     */
+    readonly CareerModeRequired: "careerModeRequired";
+    /**
+     * The game is in a scene this command cannot run from.
+     *
+     * Authority: `HighLogic.LoadedScene` (`GameScenes`). `CommandResult.detail`
+     * names the scene when the producer had one.
+     */
+    readonly WrongScene: "wrongScene";
+    /**
+     * The entity is not in a state this transition applies to: an already-active
+     * strategy asked to activate, an already-researched node asked to unlock, a
+     * contract asked to accept when it is not offered, an assigned kerbal asked to
+     * be sacked, a spent experiment asked to deploy.
+     *
+     * Authority: the entity's own state enum. `Strategies.Strategy.IsActive`,
+     * `RDTech.State`, `Contract.State`, `ProtoCrewMember.RosterStatus`,
+     * `ModuleScienceExperiment.Deployed`/`Inoperable`. Every one of those is
+     * `[Description]`-tagged or otherwise nameable, so `CommandResult.detail` can
+     * carry the state in the game's own words.
+     */
+    readonly WrongState: "wrongState";
+    /**
+     * Right command, wrong moment: the flight is not in a state that permits it
+     * yet, and will be later.
+     *
+     * Authority: `FlightGlobals.ClearToSave()`, which returns one of five refusals
+     * (in atmosphere, under acceleration, moving over the surface, about to crash,
+     * on a ladder), plus `FlightDriver.CanRevertToPostInit`/`CanRevertToPrelaunch`
+     * and the `GameParameters` flags for leaving to the space center and to the
+     * tracking station. The game's reason is on `CommandResult.detail`.
+     *
+     * Also returned by the SCET alarm command for a vantage it cannot check
+     * because no command centre is known to the simulation yet: the main menu, and
+     * the ticks before the first capture. A vantage that is known and inactive is
+     * `CommandErrorCode.Range` instead, because that one does not resolve by
+     * waiting.
+     *
+     * Distinct from `CommandErrorCode.WrongState`, which is about the entity and
+     * does not resolve by waiting.
+     */
+    readonly NotClearToProceed: "notClearToProceed";
+    /**
+     * The part or vessel does not have the capability this command needs: a rotor
+     * asked for a target angle, an unmotorised servo asked to drive, a part with
+     * no such action, an action present but inert, an autopilot mode this craft
+     * cannot hold.
+     *
+     * Authority: the part's own module list and fields
+     * (`ModuleRoboticServoRotor`/`Hinge`/`Piston`, `servoIsMotorized`,
+     * `BaseEvent.active`, `BaseEvent.EventIsDisabledByVariant`) and
+     * `VesselAutopilot.CanSetMode`.
+     *
+     * Nothing an operator waits for. The craft would have to be different for this
+     * to work, which is why it is not `CommandErrorCode.NotClearToProceed` and not
+     * `CommandErrorCode.WrongState`.
+     */
+    readonly CapabilityMismatch: "capabilityMismatch";
+    /**
+     * There is no usable link for what this command needs to send.
+     *
+     * Authority: `ScienceUtil.GetBestTransmitter(Vessel)` and
+     * `IScienceDataTransmitter.CanTransmit()`: the vessel has no antenna that can
+     * carry the payload. This is not the comms-loss refusal that stops a command
+     * before it reaches the vessel.
+     */
+    readonly NoConnection: "noConnection";
+    /**
+     * The capability exists in the game but this save has not unlocked it: fuel
+     * transfer, custom action groups, flight planning, EVA, the maneuver tool.
+     *
+     * Authority: `GameVariables.UnlockedFuelTransfer`,
+     * `UnlockedActionGroupsStock`/`Custom`, `UnlockedFlightPlanning`,
+     * `UnlockedEVA`/`Flags`/`Clamber`, `ManeuverToolAvailable`, each read at the
+     * owning facility's normalised level.
+     *
+     * Distinct from `CommandErrorCode.LimitReached`, which is a number against a
+     * number. This is a switch that is off, and the fix is an upgrade rather than
+     * freeing a slot.
+     */
+    readonly NotUnlocked: "notUnlocked";
+    /**
+     * Another vessel is on the launch site.
+     *
+     * Authority: `PreFlightTests.LaunchSiteClear`, whose
+     * `GetWarningTitle()`/`GetWarningDescription()` are the game's own words for
+     * it and ride on `CommandResult.detail`.
+     */
+    readonly SiteOccupied: "siteOccupied";
+    /**
+     * The facility this command needs is destroyed or damaged.
+     *
+     * Authority: `PreFlightTests.FacilityOperational`, over
+     * `PSystemSetup.Instance.GetSpaceCenterFacility(name).GetFacilityDamage()`.
+     */
+    readonly FacilityDamaged: "facilityDamaged";
+    /**
+     * The command consumes a countable ITEM and there are not enough of them
+     * aboard.
+     *
+     * Authority: the provider's own charge, which it should also state wherever it
+     * shows the cost, so the cost shown and the cost taken agree. The item is the
+     * provider's to name: this code says only that there were too few, never which
+     * item.
+     *
+     * Separate from `CommandErrorCode.InsufficientFunds` and
+     * `CommandErrorCode.InsufficientScience`: a physical item cannot be bought.
+     *
+     * Not `CommandErrorCode.LimitReached`, which is a capacity that is full. This
+     * is a store that is empty.
+     */
+    readonly InsufficientResource: "insufficientResource";
+    /**
+     * The provider was asked and could not read the state it needed. Nothing about
+     * the craft, the save or the moment was established, so the one fact this
+     * refusal carries is that the question went unresolved.
+     *
+     * Not `CommandErrorCode.CapabilityMismatch`, which is an established fact
+     * about the craft (a genuine omni antenna asked to aim). Not
+     * `CommandErrorCode.NotFound`, which says the craft carries nothing this
+     * command could act on. Not `CommandErrorCode.NotClearToProceed`, which
+     * resolves by waiting; this does not, and a retry is a second attempt at the
+     * same question.
+     *
+     * `CommandResult.detail` names what could not be read when the producer had a
+     * name for it, and never says what the result would have been. Nothing was
+     * learned about the vehicle, so offering the command again is the only sound
+     * next move.
+     */
+    readonly Unreadable: "unreadable";
+    /**
+     * The command acts at a PLACE, and the command centre it was sent from has no
+     * authority there: a launch from a pad in another planet's system.
+     *
+     * Authority, never delay. The command itself is still instant; what this
+     * refuses is the sender, not the moment, so no amount of waiting makes it
+     * succeed. Sending from a centre in the place's own system does.
+     *
+     * `CommandResult.detail` names the centre and the place, and the system each
+     * is in, so an operator learns which seat to move to rather than seeing a
+     * control that simply does nothing.
+     *
+     * Distinct from `CommandErrorCode.NoConnection`, which is a link that cannot
+     * carry the command. A centre may be perfectly linked to the place and still
+     * have no authority over it.
+     */
+    readonly OutOfReach: "outOfReach";
+};
+export type CommandErrorCode = (typeof CommandErrorCode)[keyof typeof CommandErrorCode];
+/**
+ * Why a command, or any other request, could not be carried: nothing about the
+ * game was decided. The refused/failed split is the kind of code, not a
+ * judgement a client makes: a `RefusalCode` says the game said no, this says
+ * the machinery did not get that far, and a retry may work.
+ *
+ * Closed, and declared only here. An Uplink never declares a fault: a handler
+ * that throws already becomes `FaultCode.CommandUnavailable`, and
+ * `CommandFaultException` is how a handler raises one of these deliberately.
+ *
+ * @category Error codes
+ */
+export declare const FaultCode: {
+    /**
+     * A frame of a known type that could not be read, including a
+     * `command-request` whose `args` do not fit the command. Only that call is
+     * refused; the command stays available.
+     */
+    readonly InvalidEnvelope: "invalidEnvelope";
+    /**
+     * A frame whose `type` this build does not recognise.
+     */
+    readonly UnknownEnvelopeType: "unknownEnvelopeType";
+    /**
+     * A frame that parsed as a type this build has nothing to do with.
+     */
+    readonly UnhandledEnvelope: "unhandledEnvelope";
+    /**
+     * A binary frame sent up the socket, which nothing accepts.
+     */
+    readonly BinaryFrameNotAccepted: "binaryFrameNotAccepted";
+    /**
+     * A command that is unknown or unavailable, or whose handler threw. A handler
+     * that threw leaves its command unavailable for the session.
+     */
+    readonly CommandUnavailable: "commandUnavailable";
+    /**
+     * A command the host could not run in time: it was handed to the game's main
+     * thread and the game did not take it before the host stopped waiting, as
+     * during a scene load. Nothing was decided, and the command may still run
+     * later.
+     */
+    readonly MainThreadTimeout: "mainThreadTimeout";
+    /**
+     * A command that ran and whose result could not be written.
+     */
+    readonly ResultSerializationError: "resultSerializationError";
+    /**
+     * A subscription to a topic nothing declares.
+     */
+    readonly UnknownTopic: "unknownTopic";
+    /**
+     * A topic whose payload could not be written.
+     */
+    readonly PayloadSerializationError: "payloadSerializationError";
+    /**
+     * A `set-vantage`, or a command's `vantage`, naming a command centre that is
+     * not active.
+     */
+    readonly UnknownVantage: "unknownVantage";
+    /**
+     * A held command reached its expiry, or its place on the lane passed, before
+     * it could run.
+     */
+    readonly CommandExpired: "commandExpired";
+    /**
+     * A cancel stopped the command before it ran.
+     */
+    readonly CommandCancelled: "commandCancelled";
+    /**
+     * A game load started a new timeline while the command was on its way, and the
+     * save it loaded does not carry the command, so it will not run. A quickload
+     * to before the command was sent is the common case. A command the loaded save
+     * does carry stays on its way and is answered as usual.
+     */
+    readonly UndoneByLoad: "undoneByLoad";
+    /**
+     * A continuous input, a throttle or a control axis, was dropped at a node
+     * where it would have had to wait on its way to the craft. Held and sent on
+     * later it would arrive as a run of out-of-date values, so a node that cannot
+     * send it on at once drops it. It was accepted with a warning when it was
+     * sent, and this is the news of its loss, arriving when a report from that
+     * node could have reached the sending centre.
+     */
+    readonly ContinuousInputWouldWait: "continuousInputWouldWait";
+    /**
+     * The transport held the command for a link that never came back, and has
+     * stopped retrying. It never left this machine.
+     */
+    readonly Undelivered: "undelivered";
+    /**
+     * The client was shut down while the command waited for an answer.
+     */
+    readonly Disposed: "disposed";
+    /**
+     * The transport's queue of commands waiting for a link is full, so this one
+     * was not queued.
+     */
+    readonly SendQueueFull: "sendQueueFull";
+    /**
+     * A station's link to the main screen dropped while the command was on it.
+     */
+    readonly PeerDisconnected: "peerDisconnected";
+    /**
+     * The main screen had no connection to the mod to relay a station's command
+     * over.
+     */
+    readonly NoClient: "noClient";
+    /**
+     * A rejection that carried no code a client could read, such as a throw from
+     * inside a handler on the client.
+     */
+    readonly Unclassified: "unclassified";
+};
+export type FaultCode = (typeof FaultCode)[keyof typeof FaultCode];
+/**
+ * Every code declared here, with the sentence an operator reads for it.
+ *
+ * @category Error codes
+ */
+export declare const CORE_ERROR_CODES: readonly ErrorCodeDeclaration[];
+//# sourceMappingURL=error-codes.d.ts.map

package/dist/__generated__/error-codes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-codes.d.ts","sourceRoot":"","sources":["../../src/__generated__/error-codes.ts"],"names":[],"mappings":"AAKA;;;;GAIG;AACH,MAAM,WAAW,oBAAoB;IACnC,0FAA0F;IAC1F,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,uHAAuH;IACvH,QAAQ,CAAC,IAAI,EAAE,SAAS,GAAG,OAAO,CAAC;IACnC,0EAA0E;IAC1E,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,oDAAoD;IACpD,QAAQ,CAAC,MAAM,EAAE,KAAK,GAAG,QAAQ,GAAG,IAAI,CAAC;IACzC,gGAAgG;IAChG,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,+FAA+F;IAC/F,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,gBAAgB;IAC3B;;OAEG;;IAEH;;;OAGG;;IAEH;;OAEG;;IAEH;;;OAGG;;IAEH;;;;;;;;OAQG;;IAEH;;;;;;;OAOG;;IAEH;;;;;;OAMG;;IAEH;;;;;;OAMG;;IAEH;;;;;;;;OAQG;;IAEH;;;;;;;;;;;OAWG;;IAEH;;;;;OAKG;;IAEH;;;;;;;;;;;OAWG;;IAEH;;;;;;;;;;;;;;;;;;OAkBG;;IAEH;;;;;;;;;;;;;;OAcG;;IAEH;;;;;;;OAOG;;IAEH;;;;;;;;;;;;OAYG;;IAEH;;;;;;OAMG;;IAEH;;;;;OAKG;;IAEH;;;;;;;;;;;;;;OAcG;;IAEH;;;;;;;;;;;;;;;;OAgBG;;IAEH;;;;;;;;;;;;;;;OAeG;;CAEK,CAAC;AACX,MAAM,MAAM,gBAAgB,GAAG,CAAC,OAAO,gBAAgB,CAAC,CAAC,MAAM,OAAO,gBAAgB,CAAC,CAAC;AAExF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,SAAS;IACpB;;;;OAIG;;IAEH;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;IAEH;;;OAGG;;IAEH;;;;;OAKG;;IAEH;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;IAEH;;;OAGG;;IAEH;;;OAGG;;IAEH;;OAEG;;IAEH;;;;;OAKG;;IAEH;;;;;;;OAOG;;IAEH;;;OAGG;;IAEH;;OAEG;;IAEH;;;OAGG;;IAEH;;OAEG;;IAEH;;;OAGG;;IAEH;;;OAGG;;CAEK,CAAC;AACX,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,SAAS,CAAC,CAAC,MAAM,OAAO,SAAS,CAAC,CAAC;AAEnE;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,EAAE,SAAS,oBAAoB,EAyU3D,CAAC"}