@stripe/extensibility-sdk 0.22.4

package/dist/stdlib/index.js

@@ -0,0 +1,1460 @@
+// src/stdlib/scalars.ts
+import "@formspec/core";
+function roundToInteger(value, direction) {
+  switch (direction) {
+    case "ceil":
+      return Math.ceil(value);
+    case "floor":
+      return Math.floor(value);
+    case "round-down":
+      return Math.trunc(value);
+    case "round-up":
+      return value >= 0 ? Math.ceil(value) : Math.floor(value);
+    case "half-up":
+      return value >= 0 ? Math.floor(value + 0.5) : Math.ceil(value - 0.5);
+    default: {
+      const _exhaustive = direction;
+      throw new Error(`Unknown rounding direction: ${String(_exhaustive)}`);
+    }
+  }
+}
+var Integer = {
+  /**
+   * Type guard that narrows a `number` to {@link (Integer:type)}.
+   *
+   * @example
+   * ```ts
+   * const n: number = getCount();
+   * if (Integer.is(n)) {
+   *   // n is Integer here
+   *   config.retryCount = n;
+   * }
+   * ```
+   * @public
+   */
+  is: (value) => Number.isInteger(value),
+  /**
+   * Coerces a number to an {@link (Integer:type)} by rounding.
+   * Throws if the value is not finite.
+   *
+   * @example
+   * ```ts
+   * const price = 9.99;
+   * const rounded = Integer.from(price, 'floor'); // 9
+   * const ceiled = Integer.from(price, 'ceil');   // 10
+   * ```
+   * @public
+   */
+  from: (value, rounding) => {
+    if (!Number.isFinite(value)) {
+      throw new Error(`Cannot round non-finite value ${String(value)} to an integer`);
+    }
+    return roundToInteger(value, rounding);
+  }
+};
+var PositiveInteger = {
+  /**
+   * Type guard that narrows a `number` to {@link (PositiveInteger:type)}.
+   *
+   * @example
+   * ```ts
+   * const n: number = getRetryCount();
+   * if (PositiveInteger.is(n)) {
+   *   // n is PositiveInteger here
+   *   config.maxRetries = n;
+   * }
+   * ```
+   * @public
+   */
+  is: (value) => Number.isInteger(value) && value >= 0,
+  /**
+   * Coerces a number to a {@link (PositiveInteger:type)} by rounding.
+   * Throws if the value is not finite or the rounded result is negative.
+   *
+   * @example
+   * ```ts
+   * const ratio = 2.7;
+   * const count = PositiveInteger.from(ratio, 'floor'); // 2
+   * ```
+   * @public
+   */
+  from: (value, rounding) => {
+    if (!Number.isFinite(value)) {
+      throw new Error(`Cannot round non-finite value ${String(value)} to an integer`);
+    }
+    const rounded = roundToInteger(value, rounding) || 0;
+    if (rounded < 0) {
+      throw new Error(
+        `Value ${String(value)} rounds to ${String(rounded)}, which is negative`
+      );
+    }
+    return rounded;
+  }
+};
+var StreetAddress = {
+  create: (address) => {
+    return address;
+  }
+};
+var Timestamp = {
+  create: (value) => {
+    return value;
+  }
+};
+
+// src/stdlib/refs.ts
+var Ref = {
+  create: (step) => {
+    return {
+      type: step.object,
+      id: step.id
+    };
+  }
+};
+
+// src/stdlib/decimal.ts
+var PLAIN_NOTATION_DIGIT_LIMIT = 30;
+var DecimalRoundingPresets = Object.freeze({
+  "ubb-usage-count": Object.freeze({
+    mode: "significant-figures",
+    value: 15
+  }),
+  "v1-api": Object.freeze({
+    mode: "decimal-places",
+    value: 12
+  })
+});
+var DEFAULT_DIV_PRECISION = 34;
+var IMPLICIT_DECIMAL_COERCION_ERROR = "Implicit Decimal coercion is not allowed; use .add(), .sub(), .mul(), .div(), .toString(), or .toNumber() explicitly.";
+var MAX_EXPONENT = Number.MAX_SAFE_INTEGER;
+var DECIMAL_BRAND = /* @__PURE__ */ Symbol.for(
+  "stripe.apps-extensibility-sdk.Decimal"
+);
+var DecimalImpl = class _DecimalImpl {
+  /** @internal */
+  [DECIMAL_BRAND] = true;
+  /** @internal */
+  #coefficient;
+  /** @internal */
+  #exponent;
+  /**
+   * Construct and normalise a decimal value.
+   *
+   * @param coefficient - The unscaled integer value.
+   * @param exponent - The power-of-ten scale factor.
+   *
+   * @internal
+   */
+  constructor(coefficient, exponent) {
+    const [normalizedCoef, normalizedExp] = _DecimalImpl.normalize(coefficient, exponent);
+    this.#coefficient = normalizedCoef;
+    this.#exponent = normalizedExp;
+    Object.freeze(this);
+  }
+  /**
+   * Strip trailing zeros from `coefficient`, incrementing `exponent`
+   * for each zero removed. Zero always normalises to `(0n, 0)`.
+   *
+   * @param coefficient - Raw coefficient before normalisation.
+   * @param exponent - Raw exponent before normalisation.
+   * @returns A `[coefficient, exponent]` tuple with trailing zeros removed.
+   *
+   * @internal
+   */
+  static normalize(coefficient, exponent) {
+    if (coefficient === 0n) {
+      return [0n, 0];
+    }
+    let coef = coefficient;
+    let exp = exponent;
+    while (coef !== 0n && coef % 10n === 0n) {
+      coef = coef / 10n;
+      exp++;
+    }
+    return [coef, exp];
+  }
+  /**
+   * Apply rounding to the result of an integer division.
+   *
+   * @remarks
+   * BigInt division truncates toward zero. This helper inspects the
+   * `remainder` to decide whether to adjust the truncated `quotient`
+   * by ±1 according to the chosen {@link RoundDirection}.
+   *
+   * The rounding direction is derived from the signs of `remainder`
+   * and `divisor`: when they agree the exact fractional part is
+   * positive (the truncation point is below the true value, so +1
+   * rounds to nearest); when they disagree the fractional part is
+   * negative (−1 rounds to nearest).
+   *
+   * @param quotient - Truncated integer quotient (`dividend / divisor`).
+   * @param remainder - Division remainder (`dividend % divisor`).
+   * @param divisor - The divisor used in the division.
+   * @param direction - The rounding strategy to apply.
+   * @returns The rounded quotient.
+   *
+   * @internal
+   */
+  static roundDivision(quotient, remainder, divisor, direction) {
+    if (remainder === 0n) {
+      return quotient;
+    }
+    if (direction === "round-down") {
+      return quotient;
+    }
+    const roundDir = remainder > 0n === divisor > 0n ? 1n : -1n;
+    if (direction === "round-up") {
+      return quotient + roundDir;
+    }
+    if (direction === "ceil") {
+      return roundDir === 1n ? quotient + 1n : quotient;
+    }
+    if (direction === "floor") {
+      return roundDir === -1n ? quotient - 1n : quotient;
+    }
+    const absRemainder = remainder < 0n ? -remainder : remainder;
+    const absDivisor = divisor < 0n ? -divisor : divisor;
+    const doubled = absRemainder * 2n;
+    const cmp = doubled === absDivisor ? 0 : doubled < absDivisor ? -1 : 1;
+    if (cmp < 0) {
+      return quotient;
+    }
+    if (cmp > 0) {
+      return quotient + roundDir;
+    }
+    if (direction === "half-up") {
+      return quotient + roundDir;
+    }
+    if (direction === "half-down") {
+      return quotient;
+    }
+    if (quotient % 2n === 0n) {
+      return quotient;
+    } else {
+      return quotient + roundDir;
+    }
+  }
+  // -------------------------------------------------------------------
+  // Arithmetic
+  // -------------------------------------------------------------------
+  /**
+   * Return the sum of this value and `other`.
+   *
+   * @param other - The addend.
+   * @returns A new {@link Decimal} equal to `this + other`.
+   *
+   * @public
+   */
+  add(other) {
+    const otherImpl = toImpl(other);
+    if (this.#exponent === otherImpl.#exponent) {
+      return toDecimal(
+        new _DecimalImpl(this.#coefficient + otherImpl.#coefficient, this.#exponent)
+      );
+    }
+    if (this.#exponent < otherImpl.#exponent) {
+      const scale = 10n ** BigInt(otherImpl.#exponent - this.#exponent);
+      return toDecimal(
+        new _DecimalImpl(
+          this.#coefficient + otherImpl.#coefficient * scale,
+          this.#exponent
+        )
+      );
+    } else {
+      const scale = 10n ** BigInt(this.#exponent - otherImpl.#exponent);
+      return toDecimal(
+        new _DecimalImpl(
+          this.#coefficient * scale + otherImpl.#coefficient,
+          otherImpl.#exponent
+        )
+      );
+    }
+  }
+  /**
+   * Return the difference of this value and `other`.
+   *
+   * @param other - The subtrahend.
+   * @returns A new {@link Decimal} equal to `this - other`.
+   *
+   * @public
+   */
+  sub(other) {
+    const otherImpl = toImpl(other);
+    if (this.#exponent === otherImpl.#exponent) {
+      return toDecimal(
+        new _DecimalImpl(this.#coefficient - otherImpl.#coefficient, this.#exponent)
+      );
+    }
+    if (this.#exponent < otherImpl.#exponent) {
+      const scale = 10n ** BigInt(otherImpl.#exponent - this.#exponent);
+      return toDecimal(
+        new _DecimalImpl(
+          this.#coefficient - otherImpl.#coefficient * scale,
+          this.#exponent
+        )
+      );
+    } else {
+      const scale = 10n ** BigInt(this.#exponent - otherImpl.#exponent);
+      return toDecimal(
+        new _DecimalImpl(
+          this.#coefficient * scale - otherImpl.#coefficient,
+          otherImpl.#exponent
+        )
+      );
+    }
+  }
+  /**
+   * Return the product of this value and `other`.
+   *
+   * @param other - The multiplicand.
+   * @returns A new {@link Decimal} equal to `this × other`.
+   *
+   * @public
+   */
+  mul(other) {
+    const otherImpl = toImpl(other);
+    return toDecimal(
+      new _DecimalImpl(
+        this.#coefficient * otherImpl.#coefficient,
+        this.#exponent + otherImpl.#exponent
+      )
+    );
+  }
+  /**
+   * Return the quotient of this value divided by `other`.
+   *
+   * @remarks
+   * Division scales the dividend to produce `precision` decimal digits
+   * in the result, then applies integer division and rounds the
+   * remainder according to `direction`.
+   *
+   * Division requires explicit rounding control — no invisible defaults
+   * in financial code. For full precision use {@link DEFAULT_DIV_PRECISION}
+   * (34, matching the IEEE 754 decimal128 coefficient size).
+   *
+   * @example
+   * ```ts
+   * Decimal.from('1').div(Decimal.from('3'), 5, 'half-up');   // "0.33333"
+   * Decimal.from('5').div(Decimal.from('2'), 0, 'half-up');   // "3"
+   * Decimal.from('5').div(Decimal.from('2'), 0, 'half-even'); // "2"
+   * ```
+   *
+   * @param other - The divisor. Must not be zero.
+   * @param precision - Maximum number of decimal digits in the result.
+   * @param direction - How to round when the exact quotient cannot
+   *   be represented at the requested precision.
+   * @returns A new {@link Decimal} equal to `this ÷ other`, rounded to
+   *   `precision` decimal places.
+   * @throws Error if `other` is zero.
+   * @throws Error if `precision` is negative or non-integer.
+   *
+   * @public
+   */
+  div(other, precision, direction) {
+    if (precision < 0 || !Number.isInteger(precision)) {
+      throw new Error("precision must be a non-negative integer");
+    }
+    const otherImpl = toImpl(other);
+    if (otherImpl.#coefficient === 0n) {
+      throw new Error("Division by zero");
+    }
+    const scale = this.#exponent - otherImpl.#exponent + precision;
+    let quotient;
+    let remainder;
+    let roundingDivisor;
+    if (scale >= 0) {
+      const scaledDividend = this.#coefficient * 10n ** BigInt(scale);
+      quotient = scaledDividend / otherImpl.#coefficient;
+      remainder = scaledDividend % otherImpl.#coefficient;
+      roundingDivisor = otherImpl.#coefficient;
+    } else {
+      const scaledDivisor = otherImpl.#coefficient * 10n ** BigInt(-scale);
+      quotient = this.#coefficient / scaledDivisor;
+      remainder = this.#coefficient % scaledDivisor;
+      roundingDivisor = scaledDivisor;
+    }
+    const roundedQuotient = _DecimalImpl.roundDivision(
+      quotient,
+      remainder,
+      roundingDivisor,
+      direction
+    );
+    return toDecimal(new _DecimalImpl(roundedQuotient, -precision));
+  }
+  // -------------------------------------------------------------------
+  // Comparison
+  // -------------------------------------------------------------------
+  /**
+   * Three-way comparison of this value with `other`.
+   *
+   * @example
+   * ```ts
+   * const a = Decimal.from('1.5');
+   * const b = Decimal.from('2');
+   * a.cmp(b); // -1
+   * b.cmp(a); //  1
+   * a.cmp(a); //  0
+   * ```
+   *
+   * @param other - The value to compare against.
+   * @returns `-1` if `this < other`, `0` if equal, `1` if `this > other`.
+   *
+   * @public
+   */
+  cmp(other) {
+    const otherImpl = toImpl(other);
+    if (this.#exponent === otherImpl.#exponent) {
+      if (this.#coefficient < otherImpl.#coefficient) return -1;
+      if (this.#coefficient > otherImpl.#coefficient) return 1;
+      return 0;
+    }
+    if (this.#exponent < otherImpl.#exponent) {
+      const scale = 10n ** BigInt(otherImpl.#exponent - this.#exponent);
+      const scaledOther = otherImpl.#coefficient * scale;
+      if (this.#coefficient < scaledOther) return -1;
+      if (this.#coefficient > scaledOther) return 1;
+      return 0;
+    } else {
+      const scale = 10n ** BigInt(this.#exponent - otherImpl.#exponent);
+      const scaledThis = this.#coefficient * scale;
+      if (scaledThis < otherImpl.#coefficient) return -1;
+      if (scaledThis > otherImpl.#coefficient) return 1;
+      return 0;
+    }
+  }
+  /**
+   * Return `true` if this value is numerically equal to `other`.
+   *
+   * @param other - The value to compare against.
+   * @returns `true` if `this === other` in value, `false` otherwise.
+   *
+   * @public
+   */
+  eq(other) {
+    return this.cmp(other) === 0;
+  }
+  /**
+   * Return `true` if this value is strictly less than `other`.
+   *
+   * @param other - The value to compare against.
+   * @returns `true` if `this < other`, `false` otherwise.
+   *
+   * @public
+   */
+  lt(other) {
+    return this.cmp(other) === -1;
+  }
+  /**
+   * Return `true` if this value is less than or equal to `other`.
+   *
+   * @param other - The value to compare against.
+   * @returns `true` if `this ≤ other`, `false` otherwise.
+   *
+   * @public
+   */
+  lte(other) {
+    return this.cmp(other) <= 0;
+  }
+  /**
+   * Return `true` if this value is strictly greater than `other`.
+   *
+   * @param other - The value to compare against.
+   * @returns `true` if `this > other`, `false` otherwise.
+   *
+   * @public
+   */
+  gt(other) {
+    return this.cmp(other) === 1;
+  }
+  /**
+   * Return `true` if this value is greater than or equal to `other`.
+   *
+   * @param other - The value to compare against.
+   * @returns `true` if `this ≥ other`, `false` otherwise.
+   *
+   * @public
+   */
+  gte(other) {
+    return this.cmp(other) >= 0;
+  }
+  // -------------------------------------------------------------------
+  // Predicates
+  // -------------------------------------------------------------------
+  /**
+   * Return `true` if this value is exactly zero.
+   *
+   * @returns `true` if the value is zero, `false` otherwise.
+   *
+   * @public
+   */
+  isZero() {
+    return this.#coefficient === 0n;
+  }
+  /**
+   * Return `true` if this value is strictly less than zero.
+   *
+   * @returns `true` if negative, `false` if zero or positive.
+   *
+   * @public
+   */
+  isNegative() {
+    return this.#coefficient < 0n;
+  }
+  /**
+   * Return `true` if this value is strictly greater than zero.
+   *
+   * @returns `true` if positive, `false` if zero or negative.
+   *
+   * @public
+   */
+  isPositive() {
+    return this.#coefficient > 0n;
+  }
+  // -------------------------------------------------------------------
+  // Unary operations
+  // -------------------------------------------------------------------
+  /**
+   * Return the additive inverse of this value.
+   *
+   * @returns A new {@link Decimal} equal to `-this`.
+   *
+   * @public
+   */
+  neg() {
+    return toDecimal(new _DecimalImpl(-this.#coefficient, this.#exponent));
+  }
+  /**
+   * Return the absolute value.
+   *
+   * @returns A new {@link Decimal} equal to `|this|`. If this value is
+   *   already non-negative, returns `this` (no allocation).
+   *
+   * @public
+   */
+  abs() {
+    if (this.#coefficient < 0n) {
+      return toDecimal(new _DecimalImpl(-this.#coefficient, this.#exponent));
+    }
+    return toDecimal(this);
+  }
+  // -------------------------------------------------------------------
+  // Rounding
+  // -------------------------------------------------------------------
+  /**
+   * Round this value to a specified precision.
+   *
+   * @remarks
+   * **Rounding directions** (IEEE 754-2019 §4.3):
+   *
+   * | Direction      | Behavior                                       |
+   * | -------------- | ---------------------------------------------- |
+   * | `'ceil'`       |  1.1→2, -1.1→-1, 1.0→1 (toward +∞)             |
+   * | `'floor'`      |  1.9→1, -1.1→-2, 1.0→1 (toward -∞)             |
+   * | `'round-down'` |  1.9→1, -1.9→-1 (toward zero / truncate)       |
+   * | `'round-up'`   |  1.1→2, -1.1→-2 (away from zero)               |
+   * | `'half-up'`    |  0.5→1, 1.5→2, -0.5→-1 (ties away from zero)   |
+   * | `'half-down'`  |  0.5→0, 1.5→1, -0.5→0 (ties toward zero)       |
+   * | `'half-even'`  |  0.5→0, 1.5→2, 2.5→2, 3.5→4 (ties to even)     |
+   *
+   * **Precision** is specified as a {@link DecimalRoundingOptions} object
+   * or a built-in preset name from {@link DecimalRoundingPresets}:
+   *
+   * @example
+   * ```ts
+   * // Using a preset
+   * amount.round('half-even', 'v1-api');
+   *
+   * // Using explicit options
+   * amount.round('half-even', { mode: 'decimal-places', value: 2 });
+   * amount.round('half-up', { mode: 'significant-figures', value: 4 });
+   * ```
+   *
+   * @param direction - How to round.
+   * @param options - A {@link DecimalRoundingOptions} object or key of `typeof DecimalRoundingPresets`.
+   * @returns A new {@link Decimal} rounded to the specified precision.
+   * @throws Error if `options.value` is negative or non-integer.
+   * @throws Error if the preset name is not recognized.
+   *
+   * @public
+   */
+  round(direction, options) {
+    if (typeof options === "string") {
+      if (!Object.hasOwn(DecimalRoundingPresets, options)) {
+        throw new Error(`Unknown rounding preset: "${options}"`);
+      }
+      return this.#roundWithOptions(direction, DecimalRoundingPresets[options]);
+    }
+    return this.#roundWithOptions(direction, options);
+  }
+  /**
+   * Apply resolved {@link DecimalRoundingOptions} to this value.
+   *
+   * @param direction - How to round.
+   * @param resolved - Already-resolved options (never a preset name).
+   * @returns A new {@link Decimal} rounded to the specified precision.
+   *
+   * @internal
+   */
+  #roundWithOptions(direction, resolved) {
+    if (resolved.value < 0 || !Number.isInteger(resolved.value)) {
+      throw new Error("DecimalRoundingOptions.value must be a non-negative integer");
+    }
+    if (resolved.mode === "decimal-places") {
+      const fixed = this.toFixed(resolved.value, direction);
+      return Decimal.from(fixed);
+    }
+    if (this.#coefficient === 0n) {
+      return toDecimal(this);
+    }
+    const coeffStr = this.#coefficient < 0n ? (-this.#coefficient).toString() : this.#coefficient.toString();
+    const currentSigFigs = coeffStr.length;
+    if (resolved.value === 0) {
+      return Decimal.zero;
+    }
+    if (currentSigFigs <= resolved.value) {
+      return toDecimal(this);
+    }
+    const digitsToTrim = currentSigFigs - resolved.value;
+    const divisor = 10n ** BigInt(digitsToTrim);
+    const quotient = this.#coefficient / divisor;
+    const remainder = this.#coefficient % divisor;
+    const rounded = _DecimalImpl.roundDivision(quotient, remainder, divisor, direction);
+    return toDecimal(new _DecimalImpl(rounded, this.#exponent + digitsToTrim));
+  }
+  // -------------------------------------------------------------------
+  // Conversion / serialisation
+  // -------------------------------------------------------------------
+  /**
+   * Return a human-readable string representation.
+   *
+   * @remarks
+   * Plain notation for values whose digit count is at most 30, and
+   * scientific notation (`1.23E+40`) for larger values. Trailing zeros
+   * are never present because the internal representation is normalised.
+   *
+   * @public
+   */
+  toString() {
+    if (this.#coefficient === 0n) {
+      return "0";
+    }
+    const coeffStr = this.#coefficient.toString();
+    const isNeg = coeffStr.startsWith("-");
+    const absCoeffStr = isNeg ? coeffStr.slice(1) : coeffStr;
+    if (this.#exponent < 0) {
+      const decimalPlaces = -this.#exponent;
+      const leadingZeroCount = decimalPlaces >= absCoeffStr.length ? decimalPlaces - absCoeffStr.length : 0;
+      if (leadingZeroCount > PLAIN_NOTATION_DIGIT_LIMIT) {
+        if (absCoeffStr.length === 1) {
+          return `${coeffStr}E${String(this.#exponent)}`;
+        }
+        const intPart = absCoeffStr[0] ?? "";
+        const fracPart = absCoeffStr.slice(1);
+        const adjustedExp = this.#exponent + absCoeffStr.length - 1;
+        return `${isNeg ? "-" : ""}${intPart}.${fracPart}E${String(adjustedExp)}`;
+      }
+      if (decimalPlaces >= absCoeffStr.length) {
+        const leadingZeros = "0".repeat(decimalPlaces - absCoeffStr.length);
+        return `${isNeg ? "-" : ""}0.${leadingZeros}${absCoeffStr}`;
+      } else {
+        const integerPart = absCoeffStr.slice(0, absCoeffStr.length - decimalPlaces);
+        const fractionalPart = absCoeffStr.slice(absCoeffStr.length - decimalPlaces);
+        return `${isNeg ? "-" : ""}${integerPart}.${fractionalPart}`;
+      }
+    }
+    const plainLength = absCoeffStr.length + this.#exponent;
+    if (plainLength <= PLAIN_NOTATION_DIGIT_LIMIT) {
+      if (this.#exponent === 0) {
+        return coeffStr;
+      }
+      const trailingZeros = "0".repeat(this.#exponent);
+      return `${isNeg ? "-" : ""}${absCoeffStr}${trailingZeros}`;
+    } else {
+      if (absCoeffStr.length === 1) {
+        return `${coeffStr}E+${String(this.#exponent)}`;
+      }
+      const integerPart = absCoeffStr[0] ?? "";
+      const fractionalPart = absCoeffStr.slice(1);
+      const adjustedExponent = this.#exponent + absCoeffStr.length - 1;
+      return `${isNeg ? "-" : ""}${integerPart}.${fractionalPart}E+${String(adjustedExponent)}`;
+    }
+  }
+  /**
+   * Return the JSON-serialisable representation.
+   *
+   * @remarks
+   * Returns a plain string matching the Stripe API convention where
+   * decimal values are serialised as strings in JSON. Called
+   * automatically by `JSON.stringify`.
+   *
+   * @public
+   */
+  toJSON() {
+    return this.toString();
+  }
+  /**
+   * Convert to a JavaScript `number`.
+   *
+   * @remarks
+   * This is an explicit, intentionally lossy conversion. Use it only
+   * when you need a numeric value for display or interop with APIs
+   * that require `number`. Prefer {@link Decimal.toString | toString}
+   * or {@link Decimal.toFixed | toFixed} for lossless output.
+   *
+   * @public
+   */
+  toNumber() {
+    return Number(this.toString());
+  }
+  /**
+   * Format this value as a fixed-point string with exactly
+   * `decimalPlaces` digits after the decimal point.
+   *
+   * @remarks
+   * Values are rounded according to `direction` when the internal
+   * precision exceeds the requested number of decimal places.
+   * The rounding direction is always required — no invisible defaults
+   * in financial code.
+   *
+   * @example
+   * ```ts
+   * Decimal.from('1.235').toFixed(2, 'half-up');   // "1.24"
+   * Decimal.from('1.225').toFixed(2, 'half-even'); // "1.22"
+   * Decimal.from('42').toFixed(3, 'half-up');      // "42.000"
+   * ```
+   *
+   * @param decimalPlaces - Number of digits after the decimal point.
+   *   Must be a non-negative integer.
+   * @param direction - How to round when truncating excess digits.
+   * @returns A string with exactly `decimalPlaces` fractional digits.
+   * @throws Error if `decimalPlaces` is negative or non-integer.
+   *
+   * @public
+   */
+  toFixed(decimalPlaces, direction) {
+    if (decimalPlaces < 0 || !Number.isInteger(decimalPlaces)) {
+      throw new Error("decimalPlaces must be a non-negative integer");
+    }
+    const formatFixed = (coef) => {
+      const coeffStr = coef.toString();
+      const isNeg = coeffStr.startsWith("-");
+      const absCoeffStr = isNeg ? coeffStr.slice(1) : coeffStr;
+      if (decimalPlaces === 0) {
+        return coeffStr;
+      }
+      if (decimalPlaces >= absCoeffStr.length) {
+        const leadingZeros = "0".repeat(decimalPlaces - absCoeffStr.length);
+        return `${isNeg ? "-" : ""}0.${leadingZeros}${absCoeffStr}`;
+      } else {
+        const integerPart = absCoeffStr.slice(0, absCoeffStr.length - decimalPlaces);
+        const fractionalPart = absCoeffStr.slice(absCoeffStr.length - decimalPlaces);
+        return `${isNeg ? "-" : ""}${integerPart}.${fractionalPart}`;
+      }
+    };
+    const targetExponent = -decimalPlaces;
+    if (this.#exponent === targetExponent) {
+      return formatFixed(this.#coefficient);
+    }
+    if (this.#exponent < targetExponent) {
+      const scaleDiff = targetExponent - this.#exponent;
+      const divisor = 10n ** BigInt(scaleDiff);
+      const quotient = this.#coefficient / divisor;
+      const remainder = this.#coefficient % divisor;
+      const rounded = _DecimalImpl.roundDivision(quotient, remainder, divisor, direction);
+      return formatFixed(rounded);
+    } else {
+      const scaleDiff = this.#exponent - targetExponent;
+      const scaled = this.#coefficient * 10n ** BigInt(scaleDiff);
+      return formatFixed(scaled);
+    }
+  }
+  /**
+   * Reject implicit arithmetic-style coercion while preserving explicit
+   * stringification.
+   *
+   * @remarks
+   * JavaScript cannot overload `+` to perform exact decimal arithmetic.
+   * The runtime only allows coercion hooks to return primitive values,
+   * which would either concatenate strings or lose precision by forcing
+   * the Decimal through IEEE 754 `number`. In financial code, that is
+   * less safe than rejecting the operation outright.
+   *
+   * `String(decimal)` and template-string interpolation still work
+   * because the string hint returns the canonical decimal string.
+   *
+   * @public
+   */
+  [Symbol.toPrimitive](hint) {
+    if (hint === "string") {
+      return this.toString();
+    }
+    throw new Error(IMPLICIT_DECIMAL_COERCION_ERROR);
+  }
+  /**
+   * Return the canonical string representation when called directly.
+   *
+   * @remarks
+   * JavaScript implicit coercion uses
+   * {@link Decimal.[Symbol.toPrimitive] | [Symbol.toPrimitive]} first, so
+   * this method is only reached via explicit direct calls such as
+   * `decimal.valueOf()`.
+   *
+   * @public
+   */
+  valueOf() {
+    return this.toString();
+  }
+};
+function toImpl(d) {
+  return d;
+}
+function toDecimal(impl) {
+  return impl;
+}
+function isDecimal(value) {
+  return typeof value === "object" && value !== null && DECIMAL_BRAND in value;
+}
+var Decimal = {
+  /**
+   * Create a `Decimal` from a string, number, or bigint.
+   *
+   * @remarks
+   * - **string**: Parsed as a decimal literal. Accepts an optional sign,
+   *   integer digits, an optional fractional part, and an optional `e`/`E`
+   *   exponent. Leading/trailing whitespace is trimmed.
+   * - **number**: Must be finite. Converted via `Number.prototype.toString()`
+   *   then parsed, so `Decimal.from(0.1)` produces `"0.1"` (not the
+   *   53-bit binary approximation).
+   * - **bigint**: Treated as an integer with exponent 0.
+   *
+   * @example
+   * ```ts
+   * Decimal.from('1.23');   // string
+   * Decimal.from(42);       // number
+   * Decimal.from(100n);     // bigint
+   * Decimal.from('1.5e3');  // scientific notation → 1500
+   * ```
+   *
+   * @param value - The value to convert.
+   * @returns A new frozen `Decimal` instance.
+   * @throws Error if `value` is a non-finite number, an empty
+   *   string, or a string that does not match the decimal literal grammar.
+   *
+   * @public
+   */
+  from(value) {
+    if (typeof value === "bigint") {
+      return toDecimal(new DecimalImpl(value, 0));
+    }
+    if (typeof value === "number") {
+      if (!Number.isFinite(value)) {
+        throw new Error("Number must be finite");
+      }
+      return Decimal.from(value.toString());
+    }
+    const trimmed = value.trim();
+    if (trimmed === "") {
+      throw new Error("Cannot parse empty string as Decimal");
+    }
+    const match = /^([+-]?)(\d+)(?:\.(\d+))?(?:[eE]([+-]?\d+))?$/.exec(trimmed);
+    if (!match) {
+      throw new Error(`Invalid decimal string: ${value}`);
+    }
+    const sign = match[1] === "-" ? -1n : 1n;
+    const integerPart = match[2] ?? "";
+    const fractionalPart = match[3] ?? "";
+    const exponentPart = match[4] ? Number(match[4]) : 0;
+    if (!Number.isSafeInteger(exponentPart) || exponentPart > MAX_EXPONENT || exponentPart < -MAX_EXPONENT) {
+      throw new Error(
+        `Exponent out of range: ${String(match[4])} exceeds safe integer bounds`
+      );
+    }
+    const coefficientStr = integerPart + fractionalPart;
+    const coefficient = sign * BigInt(coefficientStr);
+    const exponent = exponentPart - fractionalPart.length;
+    if (!Number.isSafeInteger(exponent) || exponent > MAX_EXPONENT || exponent < -MAX_EXPONENT) {
+      throw new Error(
+        `Computed exponent out of range: ${String(exponent)} exceeds safe integer bounds`
+      );
+    }
+    return toDecimal(new DecimalImpl(coefficient, exponent));
+  },
+  /**
+   * The `Decimal` value representing zero.
+   *
+   * @remarks
+   * Pre-allocated singleton — prefer `Decimal.zero` over
+   * `Decimal.from(0)` to avoid an unnecessary allocation.
+   *
+   * @public
+   */
+  zero: toDecimal(new DecimalImpl(0n, 0))
+};
+
+// src/stdlib/types.ts
+var WireReadError = class extends Error {
+  /**
+   * Error class name for `instanceof`-free identification.
+   * @internal
+   */
+  name = "WireReadError";
+};
+var WireWriteError = class extends Error {
+  /**
+   * Error class name for `instanceof`-free identification.
+   * @internal
+   */
+  name = "WireWriteError";
+};
+var WireParseError = class extends Error {
+  name = "WireParseError";
+};
+var _ProtoEnum = class {
+  _from;
+  _to;
+  constructor(fromProto) {
+    this._from = new Map(Object.entries(fromProto));
+    const to = /* @__PURE__ */ new Map();
+    for (const [wire, sdk] of this._from) {
+      if (to.has(sdk)) {
+        throw new Error(`_ProtoEnum: duplicate SDK value '${sdk}' in fromProto map`);
+      }
+      to.set(sdk, wire);
+    }
+    this._to = to;
+  }
+  /**
+   * Convert a proto wire value to an SDK value, or `null` if unknown.
+   * @internal
+   */
+  fromWire(value) {
+    return this._from.get(value) ?? null;
+  }
+  /**
+   * Convert an SDK value to a proto wire value, or `null` if unknown.
+   * @internal
+   */
+  toWire(value) {
+    return this._to.get(value) ?? null;
+  }
+};
+var _ConfigEnum = class {
+  _values;
+  constructor(values) {
+    this._values = new Set(values);
+  }
+  /**
+   * Validate and return the wire value unchanged, or `null` if unknown.
+   * @internal
+   */
+  fromWire(value) {
+    return this._values.has(value) ? value : null;
+  }
+  /**
+   * Validate and return the SDK value unchanged, or `null` if unknown.
+   * @internal
+   */
+  toWire(value) {
+    return this._values.has(value) ? value : null;
+  }
+};
+var _ShapeDescriptor = class {
+  /** The type name, used in error messages. */
+  typeName;
+  /** The field descriptors for this shape. */
+  fields;
+  /** Optional oneof field descriptors (mixed messages with regular + oneof fields). */
+  oneofFields;
+  constructor(typeName, fields, oneofFields) {
+    this.typeName = typeName;
+    this.fields = fields;
+    if (oneofFields) {
+      this.oneofFields = oneofFields;
+    }
+  }
+};
+var _UnionDescriptor = class {
+  /** The type name, used in error messages. */
+  typeName;
+  /** The SDK-side discriminant field name (e.g. `'value'`, `'kind'`). */
+  discriminantFieldName;
+  /** The branch descriptors for this union. */
+  branches;
+  constructor(typeName, discriminantFieldName, branches) {
+    this.typeName = typeName;
+    this.discriminantFieldName = discriminantFieldName;
+    this.branches = branches;
+  }
+};
+function otherFieldNameFor(discriminantFieldName) {
+  return "other" + discriminantFieldName.charAt(0).toUpperCase() + discriminantFieldName.slice(1);
+}
+function _isPromiseLike(value) {
+  if (value !== null && (typeof value === "object" || typeof value === "function")) {
+    if ("then" in value) {
+      return typeof value.then === "function";
+    }
+  }
+  return false;
+}
+
+// src/stdlib/transforms.ts
+function _apply(descriptor, strategy, inputObject, typeName = descriptor.typeName) {
+  if (inputObject === null || inputObject === void 0) {
+    const loc = typeName || "object";
+    const received = inputObject === null ? "null" : "undefined";
+    throw strategy.createNotObjectError(loc, received);
+  }
+  if (typeof inputObject !== "object") {
+    const loc = typeName || "object";
+    throw strategy.createNotObjectError(loc, typeof inputObject);
+  }
+  const input = inputObject;
+  const result = {};
+  for (const desc of descriptor.fields) {
+    const [key, value] = strategy.applyField(typeName, desc, input, strategy);
+    if (value !== void 0) result[key] = value;
+  }
+  if (descriptor.oneofFields) {
+    const regularWireKeys = descriptor.fields.map((f) => f.wire ?? f.type);
+    const allOneofBranchKeys = descriptor.oneofFields.flatMap(
+      (o) => o.branches.map((b) => b.wireKey)
+    );
+    const excludeKeys = /* @__PURE__ */ new Set([...regularWireKeys, ...allOneofBranchKeys]);
+    for (const oneof of descriptor.oneofFields) {
+      strategy.applyOneofField(typeName, oneof, input, strategy, result, excludeKeys);
+      const otherField = otherFieldNameFor(oneof.discriminant);
+      if (result[oneof.discriminant] === "other" && typeof result[otherField] === "string") {
+        excludeKeys.add(result[otherField]);
+      }
+    }
+  }
+  return result;
+}
+var _identity = (_strategy, value) => value;
+function _required(fn = _identity) {
+  return (strategy, value) => {
+    const result = fn(strategy, value);
+    if (result === null || result === void 0) {
+      throw new WireParseError("Required field is missing");
+    }
+    return result;
+  };
+}
+var _translateDecimal = (strategy, value) => strategy.translateDecimal(value);
+var _translateDateTime = (strategy, value) => strategy.translateDateTime(value);
+function _translateEnum(spec) {
+  return (strategy, value) => strategy.translateEnum(spec, value);
+}
+function _translateShape(getDesc) {
+  return (strategy, value) => {
+    if (value === null || value === void 0) return void 0;
+    return _apply(getDesc(), strategy, value);
+  };
+}
+function _translateUnion(getDesc) {
+  return (strategy, value) => {
+    if (value === null || value === void 0) return void 0;
+    return strategy.applyUnion(getDesc(), value);
+  };
+}
+function _translateArray(elementFn) {
+  return (strategy, value) => {
+    if (value === null || value === void 0) return void 0;
+    if (!Array.isArray(value)) {
+      throw new WireParseError(`Expected array but received: ${typeof value}`);
+    }
+    return value.map((v) => elementFn(strategy, v));
+  };
+}
+function _translateMap(keyFn, valueFn) {
+  return (strategy, value) => {
+    if (value === null || value === void 0) return void 0;
+    if (typeof value !== "object" || Array.isArray(value)) {
+      throw new WireParseError(
+        `Expected object for translateMap but received: ${typeof value}`
+      );
+    }
+    const entries = Object.entries(value);
+    return Object.fromEntries(
+      entries.map(([k, v]) => {
+        const mappedKey = keyFn(strategy, k);
+        if (typeof mappedKey !== "string") {
+          throw new WireParseError(
+            `translateMap: key transform returned ${typeof mappedKey} instead of string`
+          );
+        }
+        return [mappedKey, valueFn(strategy, v)];
+      })
+    );
+  };
+}
+
+// src/stdlib/transform-strategies.ts
+function parseDateString(value) {
+  const date = new Date(value);
+  if (isNaN(date.getTime())) {
+    throw new WireParseError(`Cannot parse '${value}' as Date`);
+  }
+  return date;
+}
+function enumLookup(spec, value, direction) {
+  if (typeof value !== "string") {
+    throw new WireParseError(`Expected string enum value but received ${typeof value}`);
+  }
+  const result = spec[direction](value);
+  if (result === null) {
+    throw new WireParseError(`Unknown enum value '${value}'`);
+  }
+  return result;
+}
+var _ProtoWireToType = {
+  _brand: "ProtoWireToType",
+  createNotObjectError(loc, received) {
+    return new WireReadError(`${loc}: Expected an object but received ${received}`);
+  },
+  applyField(typeName, desc, input, strategy) {
+    const from = desc.wire ?? desc.type;
+    const to = desc.type;
+    const raw = Object.hasOwn(input, from) ? input[from] : void 0;
+    try {
+      return [to, (desc.transform ?? _identity)(strategy, raw)];
+    } catch (e) {
+      if (e instanceof WireParseError)
+        throw new WireReadError(`${typeName}.${desc.type}: ${e.message}`);
+      throw e;
+    }
+  },
+  translateDecimal(value) {
+    if (value === null || value === void 0) return void 0;
+    if (typeof value !== "object" || !("value" in value)) {
+      throw new WireParseError(
+        `Cannot parse ${typeof value} as Decimal \u2014 expected {value: string}`
+      );
+    }
+    const raw = String(value.value);
+    try {
+      return Decimal.from(raw);
+    } catch {
+      throw new WireParseError(`Cannot parse '${raw}' as Decimal`);
+    }
+  },
+  translateDateTime(value) {
+    if (value === null || value === void 0) return void 0;
+    if (typeof value !== "string") {
+      throw new WireParseError(`Cannot parse ${typeof value} as Date \u2014 expected string`);
+    }
+    return parseDateString(value);
+  },
+  translateEnum(spec, value) {
+    if (value === null || value === void 0) return void 0;
+    return enumLookup(spec, value, "fromWire");
+  },
+  applyUnion(descriptor, input) {
+    if (input === null || input === void 0) {
+      throw this.createNotObjectError(descriptor.typeName || "union", String(input));
+    }
+    if (typeof input !== "object") {
+      throw this.createNotObjectError(descriptor.typeName || "union", typeof input);
+    }
+    const wire = input;
+    for (const branch of descriptor.branches) {
+      if (Object.hasOwn(wire, branch.wireKey) && wire[branch.wireKey] !== null && wire[branch.wireKey] !== void 0) {
+        const branchData = _apply(
+          new _ShapeDescriptor(descriptor.typeName, branch.shape),
+          this,
+          wire[branch.wireKey]
+        );
+        return { [descriptor.discriminantFieldName]: branch.typeKey, ...branchData };
+      }
+    }
+    const knownWireKeys = new Set(descriptor.branches.map((b) => b.wireKey));
+    for (const key of Object.keys(wire)) {
+      if (!knownWireKeys.has(key) && wire[key] !== null && wire[key] !== void 0) {
+        const otherFieldName = otherFieldNameFor(descriptor.discriminantFieldName);
+        return { [descriptor.discriminantFieldName]: "other", [otherFieldName]: key };
+      }
+    }
+    const loc = descriptor.typeName || "union";
+    throw new WireReadError(`${loc}: No variant set`);
+  },
+  applyOneofField(typeName, oneof, input, strategy, result, excludeWireKeys) {
+    applyOneofFieldIncoming(typeName, oneof, input, strategy, result, excludeWireKeys);
+  }
+};
+var _TypeToProtoWire = {
+  _brand: "TypeToProtoWire",
+  createNotObjectError(loc, received) {
+    return new WireWriteError(`${loc}: Expected an object but received ${received}`);
+  },
+  applyField(typeName, desc, input, strategy) {
+    const from = desc.type;
+    const to = desc.wire ?? desc.type;
+    const raw = Object.hasOwn(input, from) ? input[from] : void 0;
+    try {
+      return [to, (desc.transform ?? _identity)(strategy, raw)];
+    } catch (e) {
+      if (e instanceof WireParseError)
+        throw new WireWriteError(`${typeName}.${desc.type}: ${e.message}`);
+      throw e;
+    }
+  },
+  translateDecimal(value) {
+    if (value === null || value === void 0) return void 0;
+    if (!isDecimal(value)) {
+      throw new WireParseError(
+        `Cannot serialize ${typeof value} as Decimal \u2014 expected Decimal instance`
+      );
+    }
+    return { value: value.toString() };
+  },
+  translateDateTime(value) {
+    if (value === null || value === void 0) return void 0;
+    if (!(value instanceof Date)) {
+      throw new WireParseError(
+        `Cannot serialize ${typeof value} as Date \u2014 expected Date instance`
+      );
+    }
+    if (isNaN(value.getTime())) {
+      throw new WireParseError(`Cannot serialize invalid Date (NaN time value)`);
+    }
+    return value.toISOString();
+  },
+  translateEnum(spec, value) {
+    if (value === null || value === void 0) return void 0;
+    return enumLookup(spec, value, "toWire");
+  },
+  applyUnion(descriptor, input) {
+    if (input === null || input === void 0) {
+      throw this.createNotObjectError(descriptor.typeName || "union", String(input));
+    }
+    if (typeof input !== "object") {
+      throw this.createNotObjectError(descriptor.typeName || "union", typeof input);
+    }
+    const sdk = input;
+    const discriminant = sdk[descriptor.discriminantFieldName];
+    if (typeof discriminant !== "string") {
+      const loc = descriptor.typeName || "union";
+      throw new WireWriteError(
+        `${loc}: Expected a string '${descriptor.discriminantFieldName}' discriminant but received ${discriminant === void 0 ? "undefined" : typeof discriminant}`
+      );
+    }
+    if (discriminant === "other") {
+      const loc = descriptor.typeName || "union";
+      throw new WireWriteError(
+        `${loc}: Cannot serialize 'other' variant back to wire format`
+      );
+    }
+    const branch = descriptor.branches.find((b) => b.typeKey === discriminant);
+    if (!branch) {
+      const loc = descriptor.typeName || "union";
+      throw new WireWriteError(`${loc}: Unknown variant '${discriminant}'`);
+    }
+    const branchData = _apply(
+      new _ShapeDescriptor(descriptor.typeName, branch.shape),
+      this,
+      sdk
+    );
+    return { [branch.wireKey]: branchData };
+  },
+  applyOneofField(typeName, oneof, input, strategy, result, _excludeWireKeys) {
+    applyOneofFieldOutgoing(typeName, oneof, input, strategy, result);
+  }
+};
+function _configAppContextFromContext(ctx) {
+  if (typeof ctx !== "object" || ctx === null || !("clockTime" in ctx)) {
+    return {};
+  }
+  const raw = ctx.clockTime;
+  if (raw === void 0 || raw === null) return {};
+  if (typeof raw !== "string") {
+    throw new WireParseError(
+      `Expected clockTime to be a string but received ${typeof raw}`
+    );
+  }
+  return { clockTime: raw };
+}
+var _JsonWireToType = {
+  _brand: "JsonWireToType",
+  createNotObjectError(loc, received) {
+    return new WireReadError(`${loc}: Expected an object but received ${received}`);
+  },
+  applyField(typeName, desc, input, strategy) {
+    const key = desc.type;
+    const raw = Object.hasOwn(input, key) ? input[key] : void 0;
+    try {
+      return [key, (desc.transform ?? _identity)(strategy, raw)];
+    } catch (e) {
+      if (e instanceof WireParseError)
+        throw new WireReadError(`${typeName}.${desc.type}: ${e.message}`);
+      throw e;
+    }
+  },
+  translateDecimal(value) {
+    if (value === null || value === void 0) return void 0;
+    if (typeof value === "string") {
+      try {
+        return Decimal.from(value);
+      } catch {
+        throw new WireParseError(`Cannot parse '${value}' as Decimal`);
+      }
+    }
+    if (typeof value === "number") {
+      if (!isFinite(value)) {
+        throw new WireParseError(
+          `Expected a string or finite number but received ${typeof value}`
+        );
+      }
+      return Decimal.from(value);
+    }
+    throw new WireParseError(
+      `Expected a string or finite number but received ${typeof value}`
+    );
+  },
+  translateDateTime(value) {
+    if (value === null || value === void 0) return void 0;
+    if (typeof value !== "string") {
+      throw new WireParseError(`Cannot parse ${typeof value} as Date \u2014 expected string`);
+    }
+    return parseDateString(value);
+  },
+  translateEnum(spec, value) {
+    if (value === null || value === void 0) return void 0;
+    return enumLookup(spec, value, "fromWire");
+  },
+  applyUnion() {
+    throw new Error("applyUnion is not supported for JsonWireToType");
+  },
+  applyOneofField() {
+    throw new Error("applyOneofField is not supported for JsonWireToType");
+  }
+};
+function applyOneofFieldIncoming(typeName, oneof, input, strategy, result, excludeWireKeys) {
+  for (const branch of oneof.branches) {
+    const raw = Object.hasOwn(input, branch.wireKey) ? input[branch.wireKey] : void 0;
+    if (raw !== null && raw !== void 0) {
+      result[oneof.discriminant] = branch.typeKey;
+      try {
+        const transformed = branch.transform ? branch.transform(strategy, raw) : raw;
+        if (transformed !== void 0) {
+          result[branch.typeKey] = transformed;
+        }
+      } catch (e) {
+        if (e instanceof WireParseError) {
+          throw new WireReadError(
+            `${typeName}.${oneof.discriminant}(${branch.typeKey}): ${e.message}`
+          );
+        }
+        throw e;
+      }
+      return;
+    }
+  }
+  const knownWireKeys = new Set(oneof.branches.map((b) => b.wireKey));
+  for (const key of Object.keys(input)) {
+    if (!knownWireKeys.has(key) && !excludeWireKeys.has(key) && input[key] !== null && input[key] !== void 0) {
+      result[oneof.discriminant] = "other";
+      result[otherFieldNameFor(oneof.discriminant)] = key;
+      return;
+    }
+  }
+  if (!oneof.optional) {
+    throw new WireReadError(`${typeName}.${oneof.discriminant}: no variant set`);
+  }
+}
+function applyOneofFieldOutgoing(typeName, oneof, input, strategy, result) {
+  const discriminant = Object.hasOwn(input, oneof.discriminant) ? input[oneof.discriminant] : void 0;
+  if (discriminant === void 0 || discriminant === null) {
+    if (!oneof.optional) {
+      throw new WireWriteError(`${typeName}.${oneof.discriminant}: no variant set`);
+    }
+    return;
+  }
+  if (typeof discriminant !== "string") {
+    throw new WireWriteError(
+      `${typeName}.${oneof.discriminant}: expected string discriminant but received ${typeof discriminant}`
+    );
+  }
+  if (discriminant === "other") {
+    throw new WireWriteError(
+      `${typeName}.${oneof.discriminant}: cannot serialize 'other' variant back to wire format`
+    );
+  }
+  const branch = oneof.branches.find((b) => b.typeKey === discriminant);
+  if (!branch) {
+    throw new WireWriteError(
+      `${typeName}.${oneof.discriminant}: unknown variant '${discriminant}'`
+    );
+  }
+  const raw = Object.hasOwn(input, branch.typeKey) ? input[branch.typeKey] : void 0;
+  try {
+    const transformed = branch.transform ? branch.transform(strategy, raw) : raw;
+    result[branch.wireKey] = transformed ?? {};
+  } catch (e) {
+    if (e instanceof WireParseError) {
+      throw new WireWriteError(
+        `${typeName}.${oneof.discriminant}(${branch.typeKey}): ${e.message}`
+      );
+    }
+    throw e;
+  }
+}
+function createJsonWireToType(appCtx) {
+  return {
+    ..._JsonWireToType,
+    translateDateTime(value) {
+      if (value === null || value === void 0) {
+        if (appCtx.clockTime !== void 0) {
+          return parseDateString(appCtx.clockTime);
+        }
+        return void 0;
+      }
+      return _JsonWireToType.translateDateTime(value);
+    }
+  };
+}
+function _applyIncoming(descriptor, inputObject) {
+  return _apply(descriptor, _ProtoWireToType, inputObject);
+}
+function _applyOutgoing(descriptor, inputObject) {
+  return _apply(descriptor, _TypeToProtoWire, inputObject);
+}
+function _applyConfig(descriptor, inputObject, appCtx) {
+  const strategy = appCtx?.clockTime !== void 0 ? createJsonWireToType(appCtx) : _JsonWireToType;
+  return _apply(descriptor, strategy, inputObject);
+}
+export {
+  DEFAULT_DIV_PRECISION,
+  Decimal,
+  DecimalRoundingPresets,
+  Integer,
+  PositiveInteger,
+  Ref,
+  StreetAddress,
+  Timestamp,
+  WireReadError,
+  WireWriteError,
+  _ConfigEnum,
+  _JsonWireToType,
+  _ProtoEnum,
+  _ProtoWireToType,
+  _ShapeDescriptor,
+  _TypeToProtoWire,
+  _UnionDescriptor,
+  _apply,
+  _applyConfig,
+  _applyIncoming,
+  _applyOutgoing,
+  _configAppContextFromContext,
+  _identity,
+  _isPromiseLike,
+  _required,
+  _translateArray,
+  _translateDateTime,
+  _translateDecimal,
+  _translateEnum,
+  _translateMap,
+  _translateShape,
+  _translateUnion,
+  isDecimal
+};