@openmbee/opensysml 0.9.1 → 0.10.0

package/dist/core/values.js

@@ -1,8 +1,9 @@
 // Values, quantities and verdicts as discriminated unions: a caller switches on
 // `kind` and the compiler checks the switch is exhaustive.
 import { create } from "@bufbuild/protobuf";
-import { ArraySchema, ComplexSchema, EnumLiteralSchema, FailureReason, FunctionSchema, MeasurementRefSchema, MetaobjectSchema, QuantitySchema, TensorQuantitySchema, UnitFactorSchema, UnitTermSchema, ValueSchema, ValueSequenceSchema, ValueSetSchema, VectorQuantitySchema, VectorSchema, } from "../generated/sysml_pb.js";
-import { MalformedValueError } from "./errors.js";
+import { ArraySchema, ComplexSchema, EnumLiteralSchema, FailureReason, FunctionSchema, MeasurementRefSchema, MetaobjectSchema, QuantitySchema, RationalSchema, TensorQuantitySchema, UnitFactorSchema, UnitTermSchema, ValueSchema, ValueSequenceSchema, ValueSetSchema, VectorQuantitySchema, VectorSchema, } from "../generated/sysml_pb.js";
+import { CAPABILITY_BIG_INT_VALUES, CAPABILITY_COMPLEX_VALUES, CAPABILITY_FUNCTION_VALUES, CAPABILITY_INFINITY_VALUE, CAPABILITY_MEASUREMENT_REFS, CAPABILITY_METAOBJECT_VALUES, CAPABILITY_RATIONAL_VALUES, CAPABILITY_SET_VALUES, CAPABILITY_STRUCTURED_VALUES, CAPABILITY_TENSOR_VALUES, requireCapability, upgradeRemedy, } from "./capabilities.js";
+import { MalformedValueError, UnsupportedValueError } from "./errors.js";
 /**
  * Decodes a `sysml.Value` into the union.
  *
@@ -22,6 +23,10 @@ export function decodeValue(value) {
     switch (kind.case) {
         case "intValue":
             return { kind: "int", value: kind.value };
+        case "bigIntValue":
+            return { kind: "int", value: decodeBigInteger(kind.value) };
+        case "rationalValue":
+            return { kind: "rational", ...decodeRational(kind.value) };
         case "realValue":
             return { kind: "real", value: kind.value };
         case "complex":
@@ -85,7 +90,8 @@ export function decodeValue(value) {
 export function encodeValue(value) {
     switch (value.kind) {
         case "int":
-            return create(ValueSchema, { kind: { case: "intValue", value: value.value } });
+        case "rational":
+            return encodeMagnitude(value);
         case "real":
             return create(ValueSchema, { kind: { case: "realValue", value: value.value } });
         case "complex":
@@ -180,15 +186,23 @@ export function encodeValue(value) {
     }
 }
 /** Decodes a `sysml.Verdict` into the union. */
-export function decodeVerdict(verdict) {
+export function decodeVerdict(verdict, verifications = []) {
     const subject = {
         kind: verdict.kind,
         elementId: verdict.elementId,
         element: verdict.element,
         ...(verdict.instanceId === 0n ? {} : { instanceId: verdict.instanceId }),
         ...(verdict.instanceTypeId === "" ? {} : { instanceTypeId: verdict.instanceTypeId }),
+        ...(verdict.requirementId === "" ? {} : { requirementId: verdict.requirementId }),
+        ...(verdict.instancePath === "" ? {} : { instancePath: verdict.instancePath }),
     };
     const standing = decodeStanding(verdict);
+    const witness = verdict.witness.map((assignment) => ({
+        feature: assignment.feature,
+        value: decodeValue(assignment.value),
+        unit: assignment.unit,
+        exact: assignment.exact,
+    }));
     if (verdict.error !== "") {
         return {
             kind: "undecided",
@@ -196,18 +210,42 @@ export function decodeVerdict(verdict) {
             error: verdict.error,
             cause: failureCause(verdict.failureReason),
             standing,
+            question: verdict.question,
+            status: verdict.status,
+            witness,
+            verifications: [...verifications],
         };
     }
     return verdict.holds
-        ? { kind: "holds", subject, standing }
-        : { kind: "fails", subject, condition: verdict.condition, standing };
+        ? {
+            kind: "holds",
+            subject,
+            standing,
+            question: verdict.question,
+            status: verdict.status,
+            witness,
+            verifications: [...verifications],
+        }
+        : {
+            kind: "fails",
+            subject,
+            condition: verdict.condition,
+            standing,
+            question: verdict.question,
+            status: verdict.status,
+            witness,
+            verifications: [...verifications],
+        };
 }
 /** Reads the standing fields the `engines` capability adds to a verdict. */
 export function decodeStanding(verdict) {
+    const bounds = verdict.bounds.map((b) => ({ name: b.name, limit: b.limit, reached: b.reached }));
     return {
         engine: verdict.engine,
         strength: verdict.strength,
-        bounds: verdict.bounds.map((b) => ({ name: b.name, limit: b.limit, reached: b.reached })),
+        bounds,
+        reported: verdict.strength !== "",
+        reached: bounds.filter((bound) => bound.reached),
     };
 }
 /** Names the enum the service reports for a failure it could not answer through. */
@@ -230,6 +268,8 @@ export function formatValue(value) {
     switch (value.kind) {
         case "int":
             return value.value.toString();
+        case "rational":
+            return formatRational(value);
         case "real":
             return formatReal(value.value);
         case "complex":
@@ -280,7 +320,37 @@ function formatReal(value) {
     return Number.isInteger(value) ? value.toFixed(1) : value.toString();
 }
 function formatMagnitude(magnitude) {
-    return magnitude.kind === "int" ? magnitude.value.toString() : formatReal(magnitude.value);
+    switch (magnitude.kind) {
+        case "int":
+            return magnitude.value.toString();
+        case "rational":
+            return formatRational(magnitude);
+        case "real":
+            return formatReal(magnitude.value);
+    }
+}
+/** A terminating Rational as its decimal, `0.1`; any other as `numerator/denominator`, `1/3`. */
+export function formatRational(value) {
+    let twos = 0;
+    let fives = 0;
+    let rest = value.denominator;
+    while (rest % 2n === 0n) {
+        rest /= 2n;
+        twos++;
+    }
+    while (rest % 5n === 0n) {
+        rest /= 5n;
+        fives++;
+    }
+    if (rest !== 1n) {
+        return `${value.numerator.toString()}/${value.denominator.toString()}`;
+    }
+    const places = Math.max(twos, fives, 1);
+    const scaled = (value.numerator * 10n ** BigInt(places)) / value.denominator;
+    const negative = scaled < 0n;
+    const digits = (negative ? -scaled : scaled).toString().padStart(places + 1, "0");
+    const point = digits.length - places;
+    return `${negative ? "-" : ""}${digits.slice(0, point)}.${digits.slice(point)}`;
 }
 /** `Tensor(2, 2, 2)[1.0, …, 8.0][Pa]` when every component shares a unit; else each with its own. */
 function formatTensorQuantity(tensor) {
@@ -304,9 +374,15 @@ function decodeQuantity(quantity) {
         case "intMagnitude":
             magnitude = { kind: "int", value: quantity.magnitude.value };
             break;
+        case "bigIntMagnitude":
+            magnitude = { kind: "int", value: decodeBigInteger(quantity.magnitude.value) };
+            break;
         case "realMagnitude":
             magnitude = { kind: "real", value: quantity.magnitude.value };
             break;
+        case "rationalMagnitude":
+            magnitude = { kind: "rational", ...decodeRational(quantity.magnitude.value) };
+            break;
         default:
             throw new MalformedValueError(`a quantity in [${quantity.unit}] has no magnitude`);
     }
@@ -319,9 +395,7 @@ function decodeQuantity(quantity) {
 }
 function encodeQuantity(quantity) {
     return create(QuantitySchema, {
-        magnitude: quantity.magnitude.kind === "int"
-            ? { case: "intMagnitude", value: quantity.magnitude.value }
-            : { case: "realMagnitude", value: quantity.magnitude.value },
+        magnitude: encodeQuantityMagnitude(quantity.magnitude),
         unit: quantity.unit,
         ...(quantity.unitTerm === undefined ? {} : { unitTerm: encodeUnitTerm(quantity.unitTerm) }),
     });
@@ -388,10 +462,191 @@ function formatUnitTerm(term) {
     }
     return parts.length === 0 ? "1" : parts.join("·");
 }
+/** A quantity magnitude as the wire's `Quantity.magnitude` oneof writes it. */
+export function encodeQuantityMagnitude(magnitude) {
+    switch (magnitude.kind) {
+        case "real":
+            return { case: "realMagnitude", value: magnitude.value };
+        case "rational": {
+            return { case: "rationalMagnitude", value: encodeRational(magnitude) };
+        }
+        case "int":
+            return fitsInt64(magnitude.value)
+                ? { case: "intMagnitude", value: magnitude.value }
+                : { case: "bigIntMagnitude", value: magnitude.value.toString() };
+    }
+}
 function encodeMagnitude(magnitude) {
-    return magnitude.kind === "int"
+    if (magnitude.kind === "real") {
+        return create(ValueSchema, { kind: { case: "realValue", value: magnitude.value } });
+    }
+    if (magnitude.kind === "rational") {
+        return create(ValueSchema, { kind: { case: "rationalValue", value: encodeRational(magnitude) } });
+    }
+    return fitsInt64(magnitude.value)
         ? create(ValueSchema, { kind: { case: "intValue", value: magnitude.value } })
-        : create(ValueSchema, { kind: { case: "realValue", value: magnitude.value } });
+        : create(ValueSchema, { kind: { case: "bigIntValue", value: magnitude.value.toString() } });
+}
+const INT64_MIN = -(2n ** 63n);
+const INT64_MAX = 2n ** 63n - 1n;
+/** Whether an Integer travels as `int_value`; one beyond int64 travels as `big_int_value`. */
+export function fitsInt64(value) {
+    return value >= INT64_MIN && value <= INT64_MAX;
+}
+/** Reads the decimal of a `big_int_value` or `big_int_magnitude`. */
+export function decodeBigInteger(text) {
+    if (!/^-?\d+$/.test(text)) {
+        throw new MalformedValueError(`a big Integer ${JSON.stringify(text)} is not decimal`);
+    }
+    return BigInt(text);
+}
+/**
+ * Rewrites in place each Rational arm of a wire value a double holds exactly as
+ * that double: the form a service without `rational_values` reads. A Rational
+ * no double holds is left as it is; a collection's elements are values of their own.
+ */
+export function rationalsAsReals(value) {
+    switch (value.kind.case) {
+        case "rationalValue": {
+            const double = wireRationalAsDouble(value.kind.value);
+            if (double !== undefined) {
+                value.kind = { case: "realValue", value: double };
+            }
+            return;
+        }
+        case "quantity":
+            quantityRationalAsReal(value.kind.value);
+            return;
+        case "vector":
+            value.kind.value.components.forEach(rationalsAsReals);
+            return;
+        case "vectorQuantity":
+            value.kind.value.components.forEach(quantityRationalAsReal);
+            return;
+        case "tensorQuantity":
+            value.kind.value.components.forEach(quantityRationalAsReal);
+            return;
+        default:
+            return;
+    }
+}
+/** Rewrites a quantity's Rational magnitude a double holds exactly as `real_magnitude`. */
+export function quantityRationalAsReal(quantity) {
+    if (quantity.magnitude.case === "rationalMagnitude") {
+        const double = wireRationalAsDouble(quantity.magnitude.value);
+        if (double !== undefined) {
+            quantity.magnitude = { case: "realMagnitude", value: double };
+        }
+    }
+}
+function wireRationalAsDouble(wire) {
+    return rationalAsDouble({ numerator: BigInt(wire.numerator), denominator: BigInt(wire.denominator) });
+}
+/** The `Rational` message of an exact Rational, numerator and denominator in full. */
+export function encodeRational(value) {
+    return create(RationalSchema, {
+        numerator: value.numerator.toString(),
+        denominator: value.denominator.toString(),
+    });
+}
+/**
+ * Reads a `rational_value` or `rational_magnitude`.
+ *
+ * @throws {MalformedValueError} for one not in lowest terms over a positive
+ *   denominator, or one a double holds, which travels as `real_value`.
+ */
+export function decodeRational(rational) {
+    const numerator = decodeBigInteger(rational.numerator);
+    const denominator = decodeBigInteger(rational.denominator);
+    const text = `${rational.numerator}/${rational.denominator}`;
+    if (denominator <= 0n || gcd(numerator, denominator) !== 1n) {
+        throw new MalformedValueError(`a Rational ${text} is not in lowest terms over a positive denominator`);
+    }
+    if (rationalAsDouble({ numerator, denominator }) !== undefined) {
+        throw new MalformedValueError(`a Rational ${text} is a double, which travels as real_value`);
+    }
+    return { numerator, denominator };
+}
+/** The exact Rational `numerator/denominator`, reduced; throws a RangeError over a zero denominator. */
+export function rational(numerator, denominator = 1n) {
+    if (denominator === 0n) {
+        throw new RangeError("a Rational's denominator is not zero");
+    }
+    const sign = denominator < 0n ? -1n : 1n;
+    const divisor = gcd(numerator, denominator);
+    return { kind: "rational", numerator: (sign * numerator) / divisor, denominator: (sign * denominator) / divisor };
+}
+function gcd(a, b) {
+    a = a < 0n ? -a : a;
+    b = b < 0n ? -b : b;
+    while (b !== 0n) {
+        [a, b] = [b, a % b];
+    }
+    return a;
+}
+function bitLength(n) {
+    return n === 0n ? 0 : (n < 0n ? -n : n).toString(2).length;
+}
+/** The exact Rational a finite double holds. */
+export function rationalOfDouble(x) {
+    if (!Number.isFinite(x)) {
+        throw new RangeError(`${x} is no Rational`);
+    }
+    let whole = x;
+    let denominator = 1n;
+    while (!Number.isInteger(whole)) {
+        whole *= 2;
+        denominator *= 2n;
+    }
+    return rational(BigInt(whole), denominator);
+}
+/** The double that holds a reduced Rational exactly, or undefined where none does. */
+export function rationalAsDouble(value) {
+    const { numerator, denominator } = value;
+    if ((denominator & (denominator - 1n)) !== 0n) {
+        return undefined;
+    }
+    const shift = bitLength(denominator) - 1;
+    let odd = numerator;
+    let zeros = 0;
+    while (odd !== 0n && odd % 2n === 0n) {
+        odd /= 2n;
+        zeros++;
+    }
+    if (bitLength(odd) > 53 || zeros - shift < -1074 || bitLength(numerator) - shift > 1024) {
+        return undefined;
+    }
+    return scaleByPowerOfTwo(Number(odd), zeros - shift);
+}
+/** The double nearest the Rational: how a Real reads one. */
+export function rationalToNumber(value) {
+    const exact = rationalAsDouble(value);
+    if (exact !== undefined) {
+        return exact;
+    }
+    const negative = value.numerator < 0n;
+    const magnitude = negative ? -value.numerator : value.numerator;
+    // A quotient of at least 55 bits, its last bit sticky, rounds once to 53.
+    const shift = 55 - (bitLength(magnitude) - bitLength(value.denominator));
+    const num = shift >= 0 ? magnitude << BigInt(shift) : magnitude;
+    const den = shift >= 0 ? value.denominator : value.denominator << BigInt(-shift);
+    let quotient = num / den;
+    if (num % den !== 0n) {
+        quotient |= 1n;
+    }
+    const result = scaleByPowerOfTwo(Number(quotient), -shift);
+    return negative ? -result : result;
+}
+function scaleByPowerOfTwo(x, exponent) {
+    while (exponent > 1000) {
+        x *= 2 ** 1000;
+        exponent -= 1000;
+    }
+    while (exponent < -1000) {
+        x *= 2 ** -1000;
+        exponent += 1000;
+    }
+    return x * 2 ** exponent;
 }
 /** The flattened size the dimensions demand, refusing a dimension that is not positive. */
 function checkShape(what, dimensions, elementCount) {
@@ -441,6 +696,7 @@ export function valuesEqual(a, b) {
     }
     switch (a.kind) {
         case "int":
+        case "rational":
         case "real":
         case "complex":
             return numbersEqual(a, b);
@@ -531,18 +787,40 @@ function numbersEqual(a, b) {
         }
         b = { kind: "real", value: b.value.real };
     }
-    if (a.kind === "int") {
-        if (b.kind === "int")
-            return a.value === b.value;
-        return b.kind === "real" && realIsInt(b.value, a.value);
+    if (a.kind === "real" && b.kind === "real") {
+        return a.value === b.value;
     }
-    if (b.kind === "int")
-        return realIsInt(a.value, b.value);
-    return b.kind === "real" && a.value === b.value;
+    // A Rational meets a Real at Real precision, as the service compares them.
+    if (a.kind === "rational" && b.kind === "real") {
+        return rationalToNumber(a) === b.value;
+    }
+    if (a.kind === "real" && b.kind === "rational") {
+        return a.value === rationalToNumber(b);
+    }
+    const x = exactOf(a);
+    const y = exactOf(b);
+    return x !== undefined && y !== undefined && x.numerator * y.denominator === y.numerator * x.denominator;
 }
-// Whether r is exactly the integer n, never rounding n.
-function realIsInt(r, n) {
-    return Number.isInteger(r) && r >= -(2 ** 63) && r < 2 ** 63 && BigInt(r) === n;
+// The exact number a value holds, a finite Real's double included, never rounding.
+function exactOf(value) {
+    switch (value.kind) {
+        case "int":
+            return { numerator: value.value, denominator: 1n };
+        case "rational":
+            return value;
+        case "real":
+            return Number.isFinite(value.value) ? doubleAsRational(value.value) : undefined;
+        default:
+            return undefined;
+    }
+}
+function doubleAsRational(x) {
+    let denominator = 1n;
+    while (!Number.isInteger(x)) {
+        x *= 2;
+        denominator *= 2n;
+    }
+    return { numerator: BigInt(x), denominator };
 }
 function magnitudesEqual(a, b) {
     return a.length === b.length && a.every((m, i) => numbersEqual(m, b[i]));
@@ -564,18 +842,18 @@ function quantitiesEqual(a, b) {
         zeroScale(b.unitTerm)) {
         return false;
     }
-    if (a.magnitude.kind === "int" &&
-        b.magnitude.kind === "int" &&
-        wholeScale(a.unitTerm) &&
-        wholeScale(b.unitTerm)) {
+    const x = a.magnitude.kind === "real" ? undefined : exactOf(a.magnitude);
+    const y = b.magnitude.kind === "real" ? undefined : exactOf(b.magnitude);
+    if (x !== undefined && y !== undefined && wholeScale(a.unitTerm) && wholeScale(b.unitTerm)) {
         // m₁·n₁/d₁ = m₂·n₂/d₂ exactly, cross-multiplied in bigint.
-        return (a.magnitude.value * BigInt(a.unitTerm.scaleNum) * BigInt(b.unitTerm.scaleDen) ===
-            b.magnitude.value * BigInt(b.unitTerm.scaleNum) * BigInt(a.unitTerm.scaleDen));
+        return (x.numerator * y.denominator * BigInt(a.unitTerm.scaleNum) * BigInt(b.unitTerm.scaleDen) ===
+            y.numerator * x.denominator * BigInt(b.unitTerm.scaleNum) * BigInt(a.unitTerm.scaleDen));
     }
     return baseMagnitude(a.magnitude, a.unitTerm) === baseMagnitude(b.magnitude, b.unitTerm);
 }
 function baseMagnitude(magnitude, term) {
-    return (Number(magnitude.value) * term.scaleNum) / term.scaleDen;
+    const value = magnitude.kind === "rational" ? rationalToNumber(magnitude) : Number(magnitude.value);
+    return (value * term.scaleNum) / term.scaleDen;
 }
 // The reduction as base unit → exponent, repeated base units summed and
 // cancelled ones dropped, so two reductions compare however they are listed.
@@ -639,8 +917,12 @@ function decodeVector(vector) {
         switch (component.kind.case) {
             case "intValue":
                 return { kind: "int", value: component.kind.value };
+            case "bigIntValue":
+                return { kind: "int", value: decodeBigInteger(component.kind.value) };
             case "realValue":
                 return { kind: "real", value: component.kind.value };
+            case "rationalValue":
+                return { kind: "rational", ...decodeRational(component.kind.value) };
             default:
                 throw new MalformedValueError(`a vector component is ${component.kind.case ?? "empty"}, not a number`);
         }
@@ -685,3 +967,227 @@ function encodeEnumLiteral(literal) {
         value: literal.value === undefined ? undefined : encodeValue(literal.value),
     });
 }
+/** Refuses an instance or `self` id outside int64, the width of the wire's id fields. */
+function checkInt64(value) {
+    if (!fitsInt64(value)) {
+        throw new RangeError(`value out of range: ${value.toString()}`);
+    }
+}
+/**
+ * Encodes a caller-facing value for the wire, requiring of `info` each
+ * capability a value kind needs before the call is sent — exactly the checks
+ * Python's `Connection._python_to_value` makes. A `SysMLValue` encodes as
+ * itself; a boolean, string, bigint and number encode as the scalar arms; a
+ * JavaScript array and `Set` encode as a sequence and a set.
+ */
+export function toValue(input, info) {
+    const probe = input;
+    if (typeof probe === "object" && probe !== null && "$typeName" in probe) {
+        return probe;
+    }
+    return encodeInput(normalizeInput(input), info);
+}
+/** The `SysMLValue` one input names, collection elements converted the same way. */
+function normalizeInput(input) {
+    switch (typeof input) {
+        case "boolean":
+            return { kind: "boolean", value: input };
+        case "bigint":
+            return { kind: "int", value: input };
+        case "number":
+            return { kind: "real", value: input };
+        case "string":
+            return { kind: "string", value: input };
+        case "undefined":
+            throw new RangeError("unsupported input type: undefined");
+        case "function":
+        case "symbol":
+        case "object":
+            break;
+    }
+    if (input === null) {
+        return { kind: "null", reason: "" };
+    }
+    if (Array.isArray(input)) {
+        return { kind: "sequence", elements: input.map(normalizeInput) };
+    }
+    if (input instanceof Set) {
+        return { kind: "set", elements: [...input].map(normalizeInput) };
+    }
+    const value = input;
+    switch (value.kind) {
+        case "sequence":
+            return { kind: "sequence", elements: value.elements.map(normalizeInput) };
+        case "set":
+            return { kind: "set", elements: value.elements.map(normalizeInput) };
+        case "array":
+            return {
+                kind: "array",
+                dimensions: value.dimensions,
+                elements: value.elements.map(normalizeInput),
+            };
+        case "enum":
+            return value.value.value === undefined
+                ? value
+                : { kind: "enum", value: { ...value.value, value: normalizeInput(value.value.value) } };
+        case "unset":
+            throw new RangeError("an unset value cannot be sent as an input; it is a value the service answers, not one it takes");
+        default:
+            if (typeof value.kind === "string") {
+                return value;
+            }
+            throw new RangeError(`unsupported input type: ${typeof input}`);
+    }
+}
+function encodeInput(value, info) {
+    requireInput(value, info);
+    switch (value.kind) {
+        case "sequence":
+            return create(ValueSchema, {
+                kind: {
+                    case: "sequence",
+                    value: create(ValueSequenceSchema, {
+                        elements: value.elements.map((element) => encodeInput(element, info)),
+                    }),
+                },
+            });
+        case "array":
+            checkShape("an array", value.dimensions, value.elements.length);
+            return create(ValueSchema, {
+                kind: {
+                    case: "array",
+                    value: create(ArraySchema, {
+                        dimensions: value.dimensions,
+                        elements: value.elements.map((element) => encodeInput(element, info)),
+                    }),
+                },
+            });
+        case "set":
+            return create(ValueSchema, {
+                kind: {
+                    case: "set",
+                    value: create(ValueSetSchema, {
+                        elements: uniqueMembers(value.elements).map((element) => encodeInput(element, info)),
+                    }),
+                },
+            });
+        default: {
+            const wire = encodeValue(value);
+            if (!info.has(CAPABILITY_RATIONAL_VALUES)) {
+                rationalsAsReals(wire);
+            }
+            return wire;
+        }
+    }
+}
+/** The capabilities one input value needs of the service that will decode it. */
+export function requireInput(value, info) {
+    const require = (capability) => {
+        requireCapability(info, capability, upgradeRemedy(capability));
+    };
+    const requireMagnitudes = (magnitudes) => {
+        if (magnitudes.some((magnitude) => magnitude.kind === "int" && !fitsInt64(magnitude.value))) {
+            require(CAPABILITY_BIG_INT_VALUES);
+        }
+        if (magnitudes.some((magnitude) => magnitude.kind === "rational" && rationalAsDouble(magnitude) === undefined)) {
+            require(CAPABILITY_RATIONAL_VALUES);
+        }
+    };
+    switch (value.kind) {
+        case "int":
+        case "rational":
+            requireMagnitudes([value]);
+            return;
+        case "complex":
+            require(CAPABILITY_COMPLEX_VALUES);
+            return;
+        case "quantity":
+            requireMagnitudes([value.magnitude]);
+            checkReduction(`quantity in [${value.unit}]`, value.unit, value.unitTerm);
+            return;
+        case "measurementRef": {
+            require(CAPABILITY_MEASUREMENT_REFS);
+            const unitTerm = value.unitTerm;
+            if (value.unit === "" && (value.unitId ?? "") === "" && unitTerm === undefined) {
+                throw new UnsupportedValueError("measurement reference naming no unit");
+            }
+            // The wire needs the reduction on every reference, id-only ones too;
+            // encodeMeasurementRef reads unitTerm unconditionally.
+            if (unitTerm === undefined) {
+                throw new UnsupportedValueError(`measurement reference ${value.unit || value.unitId} carries no reduction to base units, so the service cannot tell what it ` +
+                    "measures: build it from a unit the service sent, or from one the model declares");
+            }
+            return;
+        }
+        case "instance":
+            checkInt64(value.id);
+            return;
+        case "unset":
+            throw new RangeError("an unset value cannot be sent as an input; it is a value the service answers, not one it takes");
+        case "function":
+            require(CAPABILITY_FUNCTION_VALUES);
+            if (value.selfId !== undefined) {
+                checkInt64(value.selfId);
+            }
+            return;
+        case "metaobject":
+            require(CAPABILITY_METAOBJECT_VALUES);
+            return;
+        case "array":
+            require(CAPABILITY_STRUCTURED_VALUES);
+            value.elements.forEach((element) => {
+                requireInput(element, info);
+            });
+            return;
+        case "vector":
+            require(CAPABILITY_STRUCTURED_VALUES);
+            requireMagnitudes(value.components);
+            return;
+        case "vectorQuantity":
+            require(CAPABILITY_STRUCTURED_VALUES);
+            requireMagnitudes(value.components.map((component) => component.magnitude));
+            value.components.forEach((component) => {
+                checkReduction(`quantity in [${component.unit}]`, component.unit, component.unitTerm);
+            });
+            return;
+        case "set":
+            require(CAPABILITY_SET_VALUES);
+            value.elements.forEach((element) => {
+                requireInput(element, info);
+            });
+            return;
+        case "tensorQuantity":
+            require(CAPABILITY_TENSOR_VALUES);
+            requireMagnitudes(value.components.map((component) => component.magnitude));
+            value.components.forEach((component) => {
+                checkReduction(`quantity in [${component.unit}]`, component.unit, component.unitTerm);
+            });
+            return;
+        case "infinity":
+            require(CAPABILITY_INFINITY_VALUE);
+            return;
+        case "enum":
+            if (value.value.value !== undefined) {
+                requireInput(value.value.value, info);
+            }
+            return;
+        case "sequence":
+            value.elements.forEach((element) => {
+                requireInput(element, info);
+            });
+            return;
+        default:
+            return;
+    }
+}
+/**
+ * Refuses a unit named without its reduction to base units — the service
+ * decides commensurability over the reduction and rejects a unit sent without
+ * one; an unnamed unit means dimension one and carries none.
+ */
+function checkReduction(what, unit, unitTerm) {
+    if (unit !== "" && unitTerm === undefined) {
+        throw new UnsupportedValueError(`${what} carries no reduction to base units, so the service cannot tell what it ` +
+            "measures: build it from a unit the service sent, or from one the model declares");
+    }
+}