Extends Error
UNEXPECTED application-level malfunction — the Java-style Error half of the
error/exception split: "this should never have happened; something is broken".
The framework does NOT pattern-match this class anywhere — it adds no special
handling to gates, checks, or any other channel. It is the explicit counterpart
of GeneralExpectedError: where that class marks anticipated business
conditions the caller handles gracefully, this one marks genuine malfunctions
(отказ) — a bug, a broken invariant, a state that the code was written to make
impossible. Throw it where Java code would throw an Error / IllegalStateException:
Note the classification is asymmetric by design: an UNTYPED throw is already treated as a malfunction by the "everything not Expected is a failure" rule. This class therefore adds no new routing — it exists so a reader sees the intent spelled out at the throw site ("this branch is a broken invariant, not a forgotten classification"), mirroring how OrderTransientError makes the default verdict explicit in the order triad.
switch (position.side) {
case "long": return closeLong(position);
case "short": return closeShort(position);
default:
// Not a business outcome — a broken invariant. Deliberately unexpected.
throw new GeneralUnexpectedError(`unknown side: ${position.side}`);
}
OrderRejectedError, OrderDeletedError and OrderTransientError are CHANNEL-specific verdicts consumed by the framework's order machinery. GeneralUnexpectedError is channel-agnostic and framework-invisible: throwing it from a gate or check is treated like any other non-typed throw (the "transient" verdict). Use the triad inside broker adapters; use GeneralUnexpectedError in your own application layers.
__type__ === Symbol.for("GeneralUnexpectedError") brand via the static
guard — never by instanceof, so it survives duplicated module instances
across bundles. Subclasses inherit the brand, so the single guard catches the
whole family.message is diagnostic: it is written for the developer reading the log,
not for the user who triggered the operation — the opposite of
GeneralExpectedError, whose message is the user-facing payload.constructor(message: string);
__type__: symbol
Runtime brand (Symbol.for — survives duplicated module instances)
static isGeneralUnexpectedError(error: object): boolean;
Nominal type guard by the runtime brand. Use this instead of instanceof:
the check is based on Symbol.for, so it recognizes instances created by a
DIFFERENT copy of this module (duplicated bundles, linked packages), as well
as any subclass carrying the inherited brand.
static fromError(error: object): GeneralUnexpectedError;
Nominal constructor for a new GeneralUnexpectedError from any thrown object.
Use this instead of instanceof to recognize instances created by a DIFFERENT
copy of this module (duplicated bundles, linked packages).