@stripe/extensibility-sdk 0.26.0 → 1.0.0

package/dist/stdlib/index.cjs

@@ -1,1754 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/stdlib/index.ts
-var stdlib_exports = {};
-__export(stdlib_exports, {
-  DEFAULT_DIV_PRECISION: () => DEFAULT_DIV_PRECISION,
-  Decimal: () => Decimal,
-  DecimalRoundingPresets: () => DecimalRoundingPresets,
-  Integer: () => Integer,
-  PositiveInteger: () => PositiveInteger,
-  Ref: () => Ref,
-  _ConfigEnum: () => _ConfigEnum,
-  _JsonWireToType: () => _JsonWireToType,
-  _ProtoEnum: () => _ProtoEnum,
-  _ProtoWireToType: () => _ProtoWireToType,
-  _ShapeDescriptor: () => _ShapeDescriptor,
-  _TypeToProtoWire: () => _TypeToProtoWire,
-  _UnionDescriptor: () => _UnionDescriptor,
-  _WireReadError: () => _WireReadError,
-  _WireWriteError: () => _WireWriteError,
-  _apply: () => _apply,
-  _applyConfig: () => _applyConfig,
-  _applyIncoming: () => _applyIncoming,
-  _applyOutgoing: () => _applyOutgoing,
-  _configAppContextFromContext: () => _configAppContextFromContext,
-  _identity: () => _identity,
-  _isPromiseLike: () => _isPromiseLike,
-  _required: () => _required,
-  _translateArray: () => _translateArray,
-  _translateDateTime: () => _translateDateTime,
-  _translateDecimal: () => _translateDecimal,
-  _translateEnum: () => _translateEnum,
-  _translateMap: () => _translateMap,
-  _translateShape: () => _translateShape,
-  _translateUnion: () => _translateUnion,
-  toConst: () => toConst
-});
-module.exports = __toCommonJS(stdlib_exports);
-
-// src/stdlib/scalars.ts
-var import_core = require("@formspec/core");
-
-// 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;
-function normalizeZero(value) {
-  return Object.is(value, -0) ? 0 : value;
-}
-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. Accepts any {@link DecimalLike} value.
-   * @returns A new {@link Decimal} equal to `this + other`.
-   *
-   * @public
-   */
-  add(other) {
-    const otherImpl = coerceToImpl(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. Accepts any {@link DecimalLike} value.
-   * @returns A new {@link Decimal} equal to `this - other`.
-   *
-   * @public
-   */
-  sub(other) {
-    const otherImpl = coerceToImpl(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. Accepts any {@link DecimalLike} value.
-   * @returns A new {@link Decimal} equal to `this × other`.
-   *
-   * @public
-   */
-  mul(other) {
-    const otherImpl = coerceToImpl(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. Accepts any {@link DecimalLike} value.
-   * @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 = coerceToImpl(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. Accepts any {@link DecimalLike} value.
-   * @returns `-1` if `this < other`, `0` if equal, `1` if `this > other`.
-   *
-   * @public
-   */
-  cmp(other) {
-    const otherImpl = coerceToImpl(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. Accepts any {@link DecimalLike} value.
-   * @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. Accepts any {@link DecimalLike} value.
-   * @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. Accepts any {@link DecimalLike} value.
-   * @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. Accepts any {@link DecimalLike} value.
-   * @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. Accepts any {@link DecimalLike} value.
-   * @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);
-    }
-  }
-  /**
-   * Convert this value to an {@link (Integer:type)} by rounding.
-   *
-   * @remarks
-   * The rounding direction is always required — no invisible defaults
-   * in financial code.
-   *
-   * @example
-   * ```ts
-   * Decimal.from('2.7').toInteger('floor');     // 2
-   * Decimal.from('2.5').toInteger('half-up');   // 3
-   * Decimal.from('2.5').toInteger('half-even'); // 2
-   * ```
-   *
-   * @param direction - How to round when the value is not a whole number.
-   * @returns A branded {@link (Integer:type)} value.
-   * @throws Error if the rounded value is too large to represent as
-   *   a JavaScript `number`.
-   *
-   * @public
-   */
-  toInteger(direction) {
-    const fixed = this.toFixed(0, direction);
-    const num = Number(fixed);
-    if (!Number.isFinite(num) || !Number.isSafeInteger(num)) {
-      throw new Error(
-        `Decimal value ${fixed} cannot be exactly represented as a JavaScript integer`
-      );
-    }
-    const normalized = normalizeZero(num);
-    return normalized;
-  }
-  /**
-   * 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 coerceToImpl(value) {
-  if (isDecimal(value)) {
-    return toImpl(value);
-  }
-  return toImpl(Decimal.from(value));
-}
-function toDecimal(impl) {
-  return impl;
-}
-function isDecimal(value) {
-  return typeof value === "object" && value !== null && DECIMAL_BRAND in value && // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- symbol key access requires cast
-  value[DECIMAL_BRAND] === true;
-}
-function assertIsDecimal(value) {
-  if (!isDecimal(value)) {
-    throw new Error(`Expected a Decimal, got ${typeof value}`);
-  }
-}
-var Decimal = {
-  /**
-   * Type guard that narrows an unknown value to {@link (Decimal:type)}.
-   *
-   * @example
-   * ```ts
-   * if (Decimal.is(value)) {
-   *   value.add(1); // value is Decimal
-   * }
-   * ```
-   * @public
-   */
-  is: isDecimal,
-  /**
-   * Assertion guard that throws if the value is not a {@link (Decimal:type)}.
-   *
-   * @example
-   * ```ts
-   * Decimal.assert(value);
-   * value.add(1); // value is Decimal
-   * ```
-   * @public
-   */
-  assert: assertIsDecimal,
-  /**
-   * Create a `Decimal` from a string, number, bigint, Integer, or Decimal.
-   *
-   * @remarks
-   * - **Decimal**: returned as-is (immutable passthrough).
-   * - **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** (including Integer): 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
-   * Decimal.from(d);        // Decimal passthrough
-   * ```
-   *
-   * @param value - The value to convert.
-   * @returns A new frozen `Decimal` instance (or the same instance if
-   *   already a Decimal).
-   * @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 (isDecimal(value)) {
-      return 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/scalars.ts
-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)}`);
-    }
-  }
-}
-function normalizeZero2(value) {
-  return Object.is(value, -0) ? 0 : value;
-}
-function assertIsInteger(value) {
-  if (!(typeof value === "number" && Number.isInteger(value))) {
-    throw new Error(
-      `Expected an integer, got ${typeof value === "number" ? String(value) : typeof value}`
-    );
-  }
-}
-function assertIsPositiveInteger(value) {
-  if (!(typeof value === "number" && Number.isInteger(value) && value >= 0)) {
-    throw new Error(
-      `Expected a non-negative integer, got ${typeof value === "number" ? String(value) : typeof value}`
-    );
-  }
-}
-function assertIntegerIsPositive(value) {
-  if (value < 0) {
-    throw new Error(`Expected a non-negative integer, got ${String(value)}`);
-  }
-}
-var Integer = {
-  /**
-   * The `Integer` value representing zero.
-   *
-   * @remarks
-   * Pre-allocated singleton — prefer `Integer.zero` over
-   * `Integer.from(0, 'floor')` to avoid an unnecessary call.
-   *
-   * @public
-   */
-  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions, @typescript-eslint/no-unsafe-type-assertion -- branded type construction: 0 is trivially an integer
-  zero: 0,
-  /**
-   * Type guard that narrows an unknown value to {@link (Integer:type)}.
-   *
-   * @example
-   * ```ts
-   * const n: unknown = getCount();
-   * if (Integer.is(n)) {
-   *   // n is Integer here
-   *   config.retryCount = n;
-   * }
-   * ```
-   * @public
-   */
-  is: (value) => typeof value === "number" && Number.isInteger(value),
-  /**
-   * Assertion guard that throws if the value is not an {@link (Integer:type)}.
-   *
-   * @example
-   * ```ts
-   * const n: unknown = getCount();
-   * Integer.assert(n);
-   * // n is Integer here
-   * ```
-   * @public
-   */
-  assert: assertIsInteger,
-  /**
-   * Coerces a value to an {@link (Integer:type)} by rounding.
-   *
-   * @remarks
-   * Accepts `number`, `string`, `Decimal`, or `Integer`. The rounding
-   * direction is always required — no invisible defaults.
-   *
-   * - **number** (including Integer): must be finite and round to a
-   *   safe integer (`Number.isSafeInteger`). IEEE 754 negative zero is
-   *   normalized to positive zero.
-   * - **string**: must be a valid numeric literal (not empty/whitespace).
-   *   Parsed via `Number()`, then rounded. The result must be a safe integer.
-   * - **Decimal**: delegated to {@link Decimal.toInteger | Decimal.toInteger()}.
-   *
-   * @example
-   * ```ts
-   * Integer.from(9.99, 'floor');              // 9
-   * Integer.from('1.5', 'ceil');              // 2
-   * Integer.from(Decimal.from('2.7'), 'half-up'); // 3
-   * ```
-   *
-   * @throws Error if the value is non-finite, an empty string, an
-   *   unparseable string, or rounds to a value outside the safe integer range.
-   *
-   * @public
-   */
-  from(value, rounding) {
-    if (typeof value === "number") {
-      if (!Number.isFinite(value)) {
-        throw new Error(`Cannot round non-finite value ${String(value)} to an integer`);
-      }
-      const rounded = normalizeZero2(roundToInteger(value, rounding));
-      if (!Number.isSafeInteger(rounded)) {
-        throw new Error(
-          `Value ${String(value)} rounds to ${String(rounded)}, which is outside the safe integer range`
-        );
-      }
-      return rounded;
-    }
-    if (typeof value === "string") {
-      if (value.trim() === "") {
-        throw new Error("Cannot parse empty string as an integer");
-      }
-      const num = Number(value);
-      if (!Number.isFinite(num)) {
-        throw new Error(
-          `Cannot parse "${value}" as a finite number for integer conversion`
-        );
-      }
-      const rounded = normalizeZero2(roundToInteger(num, rounding));
-      if (!Number.isSafeInteger(rounded)) {
-        throw new Error(
-          `Value "${value}" rounds to ${String(rounded)}, which is outside the safe integer range`
-        );
-      }
-      return rounded;
-    }
-    if (isDecimal(value)) {
-      return value.toInteger(rounding);
-    }
-    throw new Error(
-      `Cannot convert ${typeof value} to Integer; expected string, number, or Decimal`
-    );
-  },
-  /**
-   * Convert an {@link (Integer:type)} to a {@link (Decimal:type)}.
-   *
-   * @remarks
-   * This conversion is lossless — every JavaScript integer is exactly
-   * representable as a Decimal.
-   *
-   * @example
-   * ```ts
-   * const dec = Integer.toDecimal(Integer.from(42, 'floor'));
-   * dec.add(Decimal.from('0.5')); // 42.5
-   * ```
-   * @public
-   */
-  toDecimal(value) {
-    return Decimal.from(value);
-  },
-  /**
-   * Type guard that narrows an {@link (Integer:type)} to {@link (PositiveInteger:type)}.
-   *
-   * @example
-   * ```ts
-   * const n = Integer.from(count, 'floor');
-   * if (Integer.isPositive(n)) {
-   *   // n is PositiveInteger here
-   * }
-   * ```
-   * @public
-   */
-  isPositive: (value) => value >= 0,
-  /**
-   * Assertion guard that throws if an {@link (Integer:type)} is not a {@link (PositiveInteger:type)}.
-   *
-   * @example
-   * ```ts
-   * const n = Integer.from(count, 'floor');
-   * Integer.assertIsPositive(n);
-   * // n is PositiveInteger here
-   * ```
-   * @public
-   */
-  assertIsPositive: assertIntegerIsPositive
-};
-var PositiveInteger = {
-  /**
-   * Type guard that narrows an unknown value to {@link (PositiveInteger:type)}.
-   *
-   * @example
-   * ```ts
-   * const n: unknown = getRetryCount();
-   * if (PositiveInteger.is(n)) {
-   *   // n is PositiveInteger here
-   *   config.maxRetries = n;
-   * }
-   * ```
-   * @public
-   */
-  is: (value) => typeof value === "number" && Number.isInteger(value) && value >= 0,
-  /**
-   * Assertion guard that throws if the value is not a {@link (PositiveInteger:type)}.
-   *
-   * @example
-   * ```ts
-   * const n: unknown = getRetryCount();
-   * PositiveInteger.assert(n);
-   * // n is PositiveInteger here
-   * ```
-   * @public
-   */
-  assert: assertIsPositiveInteger,
-  /**
-   * Coerces a value to a {@link (PositiveInteger:type)} by rounding.
-   *
-   * @remarks
-   * Delegates to {@link (Integer:variable).from | Integer.from()} for
-   * rounding, then checks the result is non-negative. All error
-   * conditions from `Integer.from()` apply (non-finite, empty string,
-   * unsafe integer range), plus an additional check that the rounded
-   * result is ≥ 0. IEEE 754 negative zero is normalized to positive zero.
-   *
-   * @example
-   * ```ts
-   * PositiveInteger.from(2.7, 'floor');              // 2
-   * PositiveInteger.from('1.5', 'ceil');              // 2
-   * PositiveInteger.from(Decimal.from('3.2'), 'half-up'); // 3
-   * ```
-   *
-   * @throws Error if the value is non-finite, unparseable, outside the
-   *   safe integer range, or rounds to a negative number.
-   *
-   * @public
-   */
-  from(value, rounding) {
-    const rounded = Integer.from(value, rounding);
-    const normalized = normalizeZero2(rounded);
-    if (normalized < 0) {
-      throw new Error(
-        `Value ${String(value)} rounds to ${String(normalized)}, which is negative`
-      );
-    }
-    return normalized;
-  }
-};
-
-// src/stdlib/refs.ts
-var Ref = {
-  create: (step) => {
-    return {
-      type: step.object,
-      id: step.id
-    };
-  }
-};
-
-// 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);
-}
-
-// src/stdlib/to-const.ts
-function toConst(value) {
-  if (value === null || typeof value !== "object") {
-    return value;
-  }
-  if (Array.isArray(value)) {
-    for (const item of value) {
-      toConst(item);
-    }
-    return Object.freeze(value);
-  }
-  for (const key of Object.keys(value)) {
-    toConst(value[key]);
-  }
-  return Object.freeze(value);
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  DEFAULT_DIV_PRECISION,
-  Decimal,
-  DecimalRoundingPresets,
-  Integer,
-  PositiveInteger,
-  Ref,
-  _ConfigEnum,
-  _JsonWireToType,
-  _ProtoEnum,
-  _ProtoWireToType,
-  _ShapeDescriptor,
-  _TypeToProtoWire,
-  _UnionDescriptor,
-  _WireReadError,
-  _WireWriteError,
-  _apply,
-  _applyConfig,
-  _applyIncoming,
-  _applyOutgoing,
-  _configAppContextFromContext,
-  _identity,
-  _isPromiseLike,
-  _required,
-  _translateArray,
-  _translateDateTime,
-  _translateDecimal,
-  _translateEnum,
-  _translateMap,
-  _translateShape,
-  _translateUnion,
-  toConst
-});