@repost/client 0.2.0 → 0.4.0

package/dist/esm/index-DRD5FBax.mjs

@@ -0,0 +1,2967 @@
+import { P as PACKAGE_VERSION } from './version-Dp5vd2nu.mjs';
+import { O as ObserverDispatcher } from './observer-Dns2X4wE.mjs';
+
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+var src = {};
+
+var sha3$1 = {};
+
+var _u64 = {};
+
+Object.defineProperty(_u64, "__esModule", { value: true });
+_u64.toBig = _u64.shrSL = _u64.shrSH = _u64.rotrSL = _u64.rotrSH = _u64.rotrBL = _u64.rotrBH = _u64.rotr32L = _u64.rotr32H = _u64.rotlSL = _u64.rotlSH = _u64.rotlBL = _u64.rotlBH = _u64.add5L = _u64.add5H = _u64.add4L = _u64.add4H = _u64.add3L = _u64.add3H = void 0;
+_u64.add = add;
+_u64.fromBig = fromBig;
+_u64.split = split;
+/**
+ * Internal helpers for u64. BigUint64Array is too slow as per 2025, so we implement it using Uint32Array.
+ * @todo re-check https://issues.chromium.org/issues/42212588
+ * @module
+ */
+const U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
+const _32n = /* @__PURE__ */ BigInt(32);
+function fromBig(n, le = false) {
+    if (le)
+        return { h: Number(n & U32_MASK64), l: Number((n >> _32n) & U32_MASK64) };
+    return { h: Number((n >> _32n) & U32_MASK64) | 0, l: Number(n & U32_MASK64) | 0 };
+}
+function split(lst, le = false) {
+    const len = lst.length;
+    let Ah = new Uint32Array(len);
+    let Al = new Uint32Array(len);
+    for (let i = 0; i < len; i++) {
+        const { h, l } = fromBig(lst[i], le);
+        [Ah[i], Al[i]] = [h, l];
+    }
+    return [Ah, Al];
+}
+const toBig = (h, l) => (BigInt(h >>> 0) << _32n) | BigInt(l >>> 0);
+_u64.toBig = toBig;
+// for Shift in [0, 32)
+const shrSH = (h, _l, s) => h >>> s;
+_u64.shrSH = shrSH;
+const shrSL = (h, l, s) => (h << (32 - s)) | (l >>> s);
+_u64.shrSL = shrSL;
+// Right rotate for Shift in [1, 32)
+const rotrSH = (h, l, s) => (h >>> s) | (l << (32 - s));
+_u64.rotrSH = rotrSH;
+const rotrSL = (h, l, s) => (h << (32 - s)) | (l >>> s);
+_u64.rotrSL = rotrSL;
+// Right rotate for Shift in (32, 64), NOTE: 32 is special case.
+const rotrBH = (h, l, s) => (h << (64 - s)) | (l >>> (s - 32));
+_u64.rotrBH = rotrBH;
+const rotrBL = (h, l, s) => (h >>> (s - 32)) | (l << (64 - s));
+_u64.rotrBL = rotrBL;
+// Right rotate for shift===32 (just swaps l&h)
+const rotr32H = (_h, l) => l;
+_u64.rotr32H = rotr32H;
+const rotr32L = (h, _l) => h;
+_u64.rotr32L = rotr32L;
+// Left rotate for Shift in [1, 32)
+const rotlSH = (h, l, s) => (h << s) | (l >>> (32 - s));
+_u64.rotlSH = rotlSH;
+const rotlSL = (h, l, s) => (l << s) | (h >>> (32 - s));
+_u64.rotlSL = rotlSL;
+// Left rotate for Shift in (32, 64), NOTE: 32 is special case.
+const rotlBH = (h, l, s) => (l << (s - 32)) | (h >>> (64 - s));
+_u64.rotlBH = rotlBH;
+const rotlBL = (h, l, s) => (h << (s - 32)) | (l >>> (64 - s));
+_u64.rotlBL = rotlBL;
+// JS uses 32-bit signed integers for bitwise operations which means we cannot
+// simple take carry out of low bit sum by shift, we need to use division.
+function add(Ah, Al, Bh, Bl) {
+    const l = (Al >>> 0) + (Bl >>> 0);
+    return { h: (Ah + Bh + ((l / 2 ** 32) | 0)) | 0, l: l | 0 };
+}
+// Addition with more than 2 elements
+const add3L = (Al, Bl, Cl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0);
+_u64.add3L = add3L;
+const add3H = (low, Ah, Bh, Ch) => (Ah + Bh + Ch + ((low / 2 ** 32) | 0)) | 0;
+_u64.add3H = add3H;
+const add4L = (Al, Bl, Cl, Dl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0);
+_u64.add4L = add4L;
+const add4H = (low, Ah, Bh, Ch, Dh) => (Ah + Bh + Ch + Dh + ((low / 2 ** 32) | 0)) | 0;
+_u64.add4H = add4H;
+const add5L = (Al, Bl, Cl, Dl, El) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0) + (El >>> 0);
+_u64.add5L = add5L;
+const add5H = (low, Ah, Bh, Ch, Dh, Eh) => (Ah + Bh + Ch + Dh + Eh + ((low / 2 ** 32) | 0)) | 0;
+_u64.add5H = add5H;
+// prettier-ignore
+const u64 = {
+    fromBig, split, toBig,
+    shrSH, shrSL,
+    rotrSH, rotrSL, rotrBH, rotrBL,
+    rotr32H, rotr32L,
+    rotlSH, rotlSL, rotlBH, rotlBL,
+    add, add3L, add3H, add4L, add4H, add5H, add5L,
+};
+_u64.default = u64;
+
+var utils = {};
+
+var crypto$1 = {};
+
+Object.defineProperty(crypto$1, "__esModule", { value: true });
+crypto$1.crypto = void 0;
+crypto$1.crypto = typeof globalThis === 'object' && 'crypto' in globalThis ? globalThis.crypto : undefined;
+
+(function (exports) {
+	/**
+	 * Utilities for hex, bytes, CSPRNG.
+	 * @module
+	 */
+	/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.wrapXOFConstructorWithOpts = exports.wrapConstructorWithOpts = exports.wrapConstructor = exports.Hash = exports.nextTick = exports.swap32IfBE = exports.byteSwapIfBE = exports.swap8IfBE = exports.isLE = void 0;
+	exports.isBytes = isBytes;
+	exports.anumber = anumber;
+	exports.abytes = abytes;
+	exports.ahash = ahash;
+	exports.aexists = aexists;
+	exports.aoutput = aoutput;
+	exports.u8 = u8;
+	exports.u32 = u32;
+	exports.clean = clean;
+	exports.createView = createView;
+	exports.rotr = rotr;
+	exports.rotl = rotl;
+	exports.byteSwap = byteSwap;
+	exports.byteSwap32 = byteSwap32;
+	exports.bytesToHex = bytesToHex;
+	exports.hexToBytes = hexToBytes;
+	exports.asyncLoop = asyncLoop;
+	exports.utf8ToBytes = utf8ToBytes;
+	exports.bytesToUtf8 = bytesToUtf8;
+	exports.toBytes = toBytes;
+	exports.kdfInputToBytes = kdfInputToBytes;
+	exports.concatBytes = concatBytes;
+	exports.checkOpts = checkOpts;
+	exports.createHasher = createHasher;
+	exports.createOptHasher = createOptHasher;
+	exports.createXOFer = createXOFer;
+	exports.randomBytes = randomBytes;
+	// We use WebCrypto aka globalThis.crypto, which exists in browsers and node.js 16+.
+	// node.js versions earlier than v19 don't declare it in global scope.
+	// For node.js, package.json#exports field mapping rewrites import
+	// from `crypto` to `cryptoNode`, which imports native module.
+	// Makes the utils un-importable in browsers without a bundler.
+	// Once node.js 18 is deprecated (2025-04-30), we can just drop the import.
+	const crypto_1 = crypto$1;
+	/** Checks if something is Uint8Array. Be careful: nodejs Buffer will return true. */
+	function isBytes(a) {
+	    return a instanceof Uint8Array || (ArrayBuffer.isView(a) && a.constructor.name === 'Uint8Array');
+	}
+	/** Asserts something is positive integer. */
+	function anumber(n) {
+	    if (!Number.isSafeInteger(n) || n < 0)
+	        throw new Error('positive integer expected, got ' + n);
+	}
+	/** Asserts something is Uint8Array. */
+	function abytes(b, ...lengths) {
+	    if (!isBytes(b))
+	        throw new Error('Uint8Array expected');
+	    if (lengths.length > 0 && !lengths.includes(b.length))
+	        throw new Error('Uint8Array expected of length ' + lengths + ', got length=' + b.length);
+	}
+	/** Asserts something is hash */
+	function ahash(h) {
+	    if (typeof h !== 'function' || typeof h.create !== 'function')
+	        throw new Error('Hash should be wrapped by utils.createHasher');
+	    anumber(h.outputLen);
+	    anumber(h.blockLen);
+	}
+	/** Asserts a hash instance has not been destroyed / finished */
+	function aexists(instance, checkFinished = true) {
+	    if (instance.destroyed)
+	        throw new Error('Hash instance has been destroyed');
+	    if (checkFinished && instance.finished)
+	        throw new Error('Hash#digest() has already been called');
+	}
+	/** Asserts output is properly-sized byte array */
+	function aoutput(out, instance) {
+	    abytes(out);
+	    const min = instance.outputLen;
+	    if (out.length < min) {
+	        throw new Error('digestInto() expects output buffer of length at least ' + min);
+	    }
+	}
+	/** Cast u8 / u16 / u32 to u8. */
+	function u8(arr) {
+	    return new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);
+	}
+	/** Cast u8 / u16 / u32 to u32. */
+	function u32(arr) {
+	    return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
+	}
+	/** Zeroize a byte array. Warning: JS provides no guarantees. */
+	function clean(...arrays) {
+	    for (let i = 0; i < arrays.length; i++) {
+	        arrays[i].fill(0);
+	    }
+	}
+	/** Create DataView of an array for easy byte-level manipulation. */
+	function createView(arr) {
+	    return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+	}
+	/** The rotate right (circular right shift) operation for uint32 */
+	function rotr(word, shift) {
+	    return (word << (32 - shift)) | (word >>> shift);
+	}
+	/** The rotate left (circular left shift) operation for uint32 */
+	function rotl(word, shift) {
+	    return (word << shift) | ((word >>> (32 - shift)) >>> 0);
+	}
+	/** Is current platform little-endian? Most are. Big-Endian platform: IBM */
+	exports.isLE = (() => new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44)();
+	/** The byte swap operation for uint32 */
+	function byteSwap(word) {
+	    return (((word << 24) & 0xff000000) |
+	        ((word << 8) & 0xff0000) |
+	        ((word >>> 8) & 0xff00) |
+	        ((word >>> 24) & 0xff));
+	}
+	/** Conditionally byte swap if on a big-endian platform */
+	exports.swap8IfBE = exports.isLE
+	    ? (n) => n
+	    : (n) => byteSwap(n);
+	/** @deprecated */
+	exports.byteSwapIfBE = exports.swap8IfBE;
+	/** In place byte swap for Uint32Array */
+	function byteSwap32(arr) {
+	    for (let i = 0; i < arr.length; i++) {
+	        arr[i] = byteSwap(arr[i]);
+	    }
+	    return arr;
+	}
+	exports.swap32IfBE = exports.isLE
+	    ? (u) => u
+	    : byteSwap32;
+	// Built-in hex conversion https://caniuse.com/mdn-javascript_builtins_uint8array_fromhex
+	const hasHexBuiltin = /* @__PURE__ */ (() => 
+	// @ts-ignore
+	typeof Uint8Array.from([]).toHex === 'function' && typeof Uint8Array.fromHex === 'function')();
+	// Array where index 0xf0 (240) is mapped to string 'f0'
+	const hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, '0'));
+	/**
+	 * Convert byte array to hex string. Uses built-in function, when available.
+	 * @example bytesToHex(Uint8Array.from([0xca, 0xfe, 0x01, 0x23])) // 'cafe0123'
+	 */
+	function bytesToHex(bytes) {
+	    abytes(bytes);
+	    // @ts-ignore
+	    if (hasHexBuiltin)
+	        return bytes.toHex();
+	    // pre-caching improves the speed 6x
+	    let hex = '';
+	    for (let i = 0; i < bytes.length; i++) {
+	        hex += hexes[bytes[i]];
+	    }
+	    return hex;
+	}
+	// We use optimized technique to convert hex string to byte array
+	const asciis = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 };
+	function asciiToBase16(ch) {
+	    if (ch >= asciis._0 && ch <= asciis._9)
+	        return ch - asciis._0; // '2' => 50-48
+	    if (ch >= asciis.A && ch <= asciis.F)
+	        return ch - (asciis.A - 10); // 'B' => 66-(65-10)
+	    if (ch >= asciis.a && ch <= asciis.f)
+	        return ch - (asciis.a - 10); // 'b' => 98-(97-10)
+	    return;
+	}
+	/**
+	 * Convert hex string to byte array. Uses built-in function, when available.
+	 * @example hexToBytes('cafe0123') // Uint8Array.from([0xca, 0xfe, 0x01, 0x23])
+	 */
+	function hexToBytes(hex) {
+	    if (typeof hex !== 'string')
+	        throw new Error('hex string expected, got ' + typeof hex);
+	    // @ts-ignore
+	    if (hasHexBuiltin)
+	        return Uint8Array.fromHex(hex);
+	    const hl = hex.length;
+	    const al = hl / 2;
+	    if (hl % 2)
+	        throw new Error('hex string expected, got unpadded hex of length ' + hl);
+	    const array = new Uint8Array(al);
+	    for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {
+	        const n1 = asciiToBase16(hex.charCodeAt(hi));
+	        const n2 = asciiToBase16(hex.charCodeAt(hi + 1));
+	        if (n1 === undefined || n2 === undefined) {
+	            const char = hex[hi] + hex[hi + 1];
+	            throw new Error('hex string expected, got non-hex character "' + char + '" at index ' + hi);
+	        }
+	        array[ai] = n1 * 16 + n2; // multiply first octet, e.g. 'a3' => 10*16+3 => 160 + 3 => 163
+	    }
+	    return array;
+	}
+	/**
+	 * There is no setImmediate in browser and setTimeout is slow.
+	 * Call of async fn will return Promise, which will be fullfiled only on
+	 * next scheduler queue processing step and this is exactly what we need.
+	 */
+	const nextTick = async () => { };
+	exports.nextTick = nextTick;
+	/** Returns control to thread each 'tick' ms to avoid blocking. */
+	async function asyncLoop(iters, tick, cb) {
+	    let ts = Date.now();
+	    for (let i = 0; i < iters; i++) {
+	        cb(i);
+	        // Date.now() is not monotonic, so in case if clock goes backwards we return return control too
+	        const diff = Date.now() - ts;
+	        if (diff >= 0 && diff < tick)
+	            continue;
+	        await (0, exports.nextTick)();
+	        ts += diff;
+	    }
+	}
+	/**
+	 * Converts string to bytes using UTF8 encoding.
+	 * @example utf8ToBytes('abc') // Uint8Array.from([97, 98, 99])
+	 */
+	function utf8ToBytes(str) {
+	    if (typeof str !== 'string')
+	        throw new Error('string expected');
+	    return new Uint8Array(new TextEncoder().encode(str)); // https://bugzil.la/1681809
+	}
+	/**
+	 * Converts bytes to string using UTF8 encoding.
+	 * @example bytesToUtf8(Uint8Array.from([97, 98, 99])) // 'abc'
+	 */
+	function bytesToUtf8(bytes) {
+	    return new TextDecoder().decode(bytes);
+	}
+	/**
+	 * Normalizes (non-hex) string or Uint8Array to Uint8Array.
+	 * Warning: when Uint8Array is passed, it would NOT get copied.
+	 * Keep in mind for future mutable operations.
+	 */
+	function toBytes(data) {
+	    if (typeof data === 'string')
+	        data = utf8ToBytes(data);
+	    abytes(data);
+	    return data;
+	}
+	/**
+	 * Helper for KDFs: consumes uint8array or string.
+	 * When string is passed, does utf8 decoding, using TextDecoder.
+	 */
+	function kdfInputToBytes(data) {
+	    if (typeof data === 'string')
+	        data = utf8ToBytes(data);
+	    abytes(data);
+	    return data;
+	}
+	/** Copies several Uint8Arrays into one. */
+	function concatBytes(...arrays) {
+	    let sum = 0;
+	    for (let i = 0; i < arrays.length; i++) {
+	        const a = arrays[i];
+	        abytes(a);
+	        sum += a.length;
+	    }
+	    const res = new Uint8Array(sum);
+	    for (let i = 0, pad = 0; i < arrays.length; i++) {
+	        const a = arrays[i];
+	        res.set(a, pad);
+	        pad += a.length;
+	    }
+	    return res;
+	}
+	function checkOpts(defaults, opts) {
+	    if (opts !== undefined && {}.toString.call(opts) !== '[object Object]')
+	        throw new Error('options should be object or undefined');
+	    const merged = Object.assign(defaults, opts);
+	    return merged;
+	}
+	/** For runtime check if class implements interface */
+	class Hash {
+	}
+	exports.Hash = Hash;
+	/** Wraps hash function, creating an interface on top of it */
+	function createHasher(hashCons) {
+	    const hashC = (msg) => hashCons().update(toBytes(msg)).digest();
+	    const tmp = hashCons();
+	    hashC.outputLen = tmp.outputLen;
+	    hashC.blockLen = tmp.blockLen;
+	    hashC.create = () => hashCons();
+	    return hashC;
+	}
+	function createOptHasher(hashCons) {
+	    const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();
+	    const tmp = hashCons({});
+	    hashC.outputLen = tmp.outputLen;
+	    hashC.blockLen = tmp.blockLen;
+	    hashC.create = (opts) => hashCons(opts);
+	    return hashC;
+	}
+	function createXOFer(hashCons) {
+	    const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();
+	    const tmp = hashCons({});
+	    hashC.outputLen = tmp.outputLen;
+	    hashC.blockLen = tmp.blockLen;
+	    hashC.create = (opts) => hashCons(opts);
+	    return hashC;
+	}
+	exports.wrapConstructor = createHasher;
+	exports.wrapConstructorWithOpts = createOptHasher;
+	exports.wrapXOFConstructorWithOpts = createXOFer;
+	/** Cryptographically secure PRNG. Uses internal OS-level `crypto.getRandomValues`. */
+	function randomBytes(bytesLength = 32) {
+	    if (crypto_1.crypto && typeof crypto_1.crypto.getRandomValues === 'function') {
+	        return crypto_1.crypto.getRandomValues(new Uint8Array(bytesLength));
+	    }
+	    // Legacy Node.js compatibility
+	    if (crypto_1.crypto && typeof crypto_1.crypto.randomBytes === 'function') {
+	        return Uint8Array.from(crypto_1.crypto.randomBytes(bytesLength));
+	    }
+	    throw new Error('crypto.getRandomValues must be defined');
+	}
+	
+} (utils));
+
+Object.defineProperty(sha3$1, "__esModule", { value: true });
+sha3$1.shake256 = sha3$1.shake128 = sha3$1.keccak_512 = sha3$1.keccak_384 = sha3$1.keccak_256 = sha3$1.keccak_224 = sha3$1.sha3_512 = sha3$1.sha3_384 = sha3$1.sha3_256 = sha3$1.sha3_224 = sha3$1.Keccak = void 0;
+sha3$1.keccakP = keccakP;
+/**
+ * SHA3 (keccak) hash function, based on a new "Sponge function" design.
+ * Different from older hashes, the internal state is bigger than output size.
+ *
+ * Check out [FIPS-202](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.202.pdf),
+ * [Website](https://keccak.team/keccak.html),
+ * [the differences between SHA-3 and Keccak](https://crypto.stackexchange.com/questions/15727/what-are-the-key-differences-between-the-draft-sha-3-standard-and-the-keccak-sub).
+ *
+ * Check out `sha3-addons` module for cSHAKE, k12, and others.
+ * @module
+ */
+const _u64_ts_1 = _u64;
+// prettier-ignore
+const utils_ts_1 = utils;
+// No __PURE__ annotations in sha3 header:
+// EVERYTHING is in fact used on every export.
+// Various per round constants calculations
+const _0n = BigInt(0);
+const _1n = BigInt(1);
+const _2n = BigInt(2);
+const _7n = BigInt(7);
+const _256n = BigInt(256);
+const _0x71n = BigInt(0x71);
+const SHA3_PI = [];
+const SHA3_ROTL = [];
+const _SHA3_IOTA = [];
+for (let round = 0, R = _1n, x = 1, y = 0; round < 24; round++) {
+    // Pi
+    [x, y] = [y, (2 * x + 3 * y) % 5];
+    SHA3_PI.push(2 * (5 * y + x));
+    // Rotational
+    SHA3_ROTL.push((((round + 1) * (round + 2)) / 2) % 64);
+    // Iota
+    let t = _0n;
+    for (let j = 0; j < 7; j++) {
+        R = ((R << _1n) ^ ((R >> _7n) * _0x71n)) % _256n;
+        if (R & _2n)
+            t ^= _1n << ((_1n << /* @__PURE__ */ BigInt(j)) - _1n);
+    }
+    _SHA3_IOTA.push(t);
+}
+const IOTAS = (0, _u64_ts_1.split)(_SHA3_IOTA, true);
+const SHA3_IOTA_H = IOTAS[0];
+const SHA3_IOTA_L = IOTAS[1];
+// Left rotation (without 0, 32, 64)
+const rotlH = (h, l, s) => (s > 32 ? (0, _u64_ts_1.rotlBH)(h, l, s) : (0, _u64_ts_1.rotlSH)(h, l, s));
+const rotlL = (h, l, s) => (s > 32 ? (0, _u64_ts_1.rotlBL)(h, l, s) : (0, _u64_ts_1.rotlSL)(h, l, s));
+/** `keccakf1600` internal function, additionally allows to adjust round count. */
+function keccakP(s, rounds = 24) {
+    const B = new Uint32Array(5 * 2);
+    // NOTE: all indices are x2 since we store state as u32 instead of u64 (bigints to slow in js)
+    for (let round = 24 - rounds; round < 24; round++) {
+        // Theta θ
+        for (let x = 0; x < 10; x++)
+            B[x] = s[x] ^ s[x + 10] ^ s[x + 20] ^ s[x + 30] ^ s[x + 40];
+        for (let x = 0; x < 10; x += 2) {
+            const idx1 = (x + 8) % 10;
+            const idx0 = (x + 2) % 10;
+            const B0 = B[idx0];
+            const B1 = B[idx0 + 1];
+            const Th = rotlH(B0, B1, 1) ^ B[idx1];
+            const Tl = rotlL(B0, B1, 1) ^ B[idx1 + 1];
+            for (let y = 0; y < 50; y += 10) {
+                s[x + y] ^= Th;
+                s[x + y + 1] ^= Tl;
+            }
+        }
+        // Rho (ρ) and Pi (π)
+        let curH = s[2];
+        let curL = s[3];
+        for (let t = 0; t < 24; t++) {
+            const shift = SHA3_ROTL[t];
+            const Th = rotlH(curH, curL, shift);
+            const Tl = rotlL(curH, curL, shift);
+            const PI = SHA3_PI[t];
+            curH = s[PI];
+            curL = s[PI + 1];
+            s[PI] = Th;
+            s[PI + 1] = Tl;
+        }
+        // Chi (χ)
+        for (let y = 0; y < 50; y += 10) {
+            for (let x = 0; x < 10; x++)
+                B[x] = s[y + x];
+            for (let x = 0; x < 10; x++)
+                s[y + x] ^= ~B[(x + 2) % 10] & B[(x + 4) % 10];
+        }
+        // Iota (ι)
+        s[0] ^= SHA3_IOTA_H[round];
+        s[1] ^= SHA3_IOTA_L[round];
+    }
+    (0, utils_ts_1.clean)(B);
+}
+/** Keccak sponge function. */
+class Keccak extends utils_ts_1.Hash {
+    // NOTE: we accept arguments in bytes instead of bits here.
+    constructor(blockLen, suffix, outputLen, enableXOF = false, rounds = 24) {
+        super();
+        this.pos = 0;
+        this.posOut = 0;
+        this.finished = false;
+        this.destroyed = false;
+        this.enableXOF = false;
+        this.blockLen = blockLen;
+        this.suffix = suffix;
+        this.outputLen = outputLen;
+        this.enableXOF = enableXOF;
+        this.rounds = rounds;
+        // Can be passed from user as dkLen
+        (0, utils_ts_1.anumber)(outputLen);
+        // 1600 = 5x5 matrix of 64bit.  1600 bits === 200 bytes
+        // 0 < blockLen < 200
+        if (!(0 < blockLen && blockLen < 200))
+            throw new Error('only keccak-f1600 function is supported');
+        this.state = new Uint8Array(200);
+        this.state32 = (0, utils_ts_1.u32)(this.state);
+    }
+    clone() {
+        return this._cloneInto();
+    }
+    keccak() {
+        (0, utils_ts_1.swap32IfBE)(this.state32);
+        keccakP(this.state32, this.rounds);
+        (0, utils_ts_1.swap32IfBE)(this.state32);
+        this.posOut = 0;
+        this.pos = 0;
+    }
+    update(data) {
+        (0, utils_ts_1.aexists)(this);
+        data = (0, utils_ts_1.toBytes)(data);
+        (0, utils_ts_1.abytes)(data);
+        const { blockLen, state } = this;
+        const len = data.length;
+        for (let pos = 0; pos < len;) {
+            const take = Math.min(blockLen - this.pos, len - pos);
+            for (let i = 0; i < take; i++)
+                state[this.pos++] ^= data[pos++];
+            if (this.pos === blockLen)
+                this.keccak();
+        }
+        return this;
+    }
+    finish() {
+        if (this.finished)
+            return;
+        this.finished = true;
+        const { state, suffix, pos, blockLen } = this;
+        // Do the padding
+        state[pos] ^= suffix;
+        if ((suffix & 0x80) !== 0 && pos === blockLen - 1)
+            this.keccak();
+        state[blockLen - 1] ^= 0x80;
+        this.keccak();
+    }
+    writeInto(out) {
+        (0, utils_ts_1.aexists)(this, false);
+        (0, utils_ts_1.abytes)(out);
+        this.finish();
+        const bufferOut = this.state;
+        const { blockLen } = this;
+        for (let pos = 0, len = out.length; pos < len;) {
+            if (this.posOut >= blockLen)
+                this.keccak();
+            const take = Math.min(blockLen - this.posOut, len - pos);
+            out.set(bufferOut.subarray(this.posOut, this.posOut + take), pos);
+            this.posOut += take;
+            pos += take;
+        }
+        return out;
+    }
+    xofInto(out) {
+        // Sha3/Keccak usage with XOF is probably mistake, only SHAKE instances can do XOF
+        if (!this.enableXOF)
+            throw new Error('XOF is not possible for this instance');
+        return this.writeInto(out);
+    }
+    xof(bytes) {
+        (0, utils_ts_1.anumber)(bytes);
+        return this.xofInto(new Uint8Array(bytes));
+    }
+    digestInto(out) {
+        (0, utils_ts_1.aoutput)(out, this);
+        if (this.finished)
+            throw new Error('digest() was already called');
+        this.writeInto(out);
+        this.destroy();
+        return out;
+    }
+    digest() {
+        return this.digestInto(new Uint8Array(this.outputLen));
+    }
+    destroy() {
+        this.destroyed = true;
+        (0, utils_ts_1.clean)(this.state);
+    }
+    _cloneInto(to) {
+        const { blockLen, suffix, outputLen, rounds, enableXOF } = this;
+        to || (to = new Keccak(blockLen, suffix, outputLen, enableXOF, rounds));
+        to.state32.set(this.state32);
+        to.pos = this.pos;
+        to.posOut = this.posOut;
+        to.finished = this.finished;
+        to.rounds = rounds;
+        // Suffix can change in cSHAKE
+        to.suffix = suffix;
+        to.outputLen = outputLen;
+        to.enableXOF = enableXOF;
+        to.destroyed = this.destroyed;
+        return to;
+    }
+}
+sha3$1.Keccak = Keccak;
+const gen = (suffix, blockLen, outputLen) => (0, utils_ts_1.createHasher)(() => new Keccak(blockLen, suffix, outputLen));
+/** SHA3-224 hash function. */
+sha3$1.sha3_224 = (() => gen(0x06, 144, 224 / 8))();
+/** SHA3-256 hash function. Different from keccak-256. */
+sha3$1.sha3_256 = (() => gen(0x06, 136, 256 / 8))();
+/** SHA3-384 hash function. */
+sha3$1.sha3_384 = (() => gen(0x06, 104, 384 / 8))();
+/** SHA3-512 hash function. */
+sha3$1.sha3_512 = (() => gen(0x06, 72, 512 / 8))();
+/** keccak-224 hash function. */
+sha3$1.keccak_224 = (() => gen(0x01, 144, 224 / 8))();
+/** keccak-256 hash function. Different from SHA3-256. */
+sha3$1.keccak_256 = (() => gen(0x01, 136, 256 / 8))();
+/** keccak-384 hash function. */
+sha3$1.keccak_384 = (() => gen(0x01, 104, 384 / 8))();
+/** keccak-512 hash function. */
+sha3$1.keccak_512 = (() => gen(0x01, 72, 512 / 8))();
+const genShake = (suffix, blockLen, outputLen) => (0, utils_ts_1.createXOFer)((opts = {}) => new Keccak(blockLen, suffix, opts.dkLen === undefined ? outputLen : opts.dkLen, true));
+/** SHAKE128 XOF with 128-bit security. */
+sha3$1.shake128 = (() => genShake(0x1f, 168, 128 / 8))();
+/** SHAKE256 XOF with 256-bit security. */
+sha3$1.shake256 = (() => genShake(0x1f, 136, 256 / 8))();
+
+/* global global, window, module */
+
+const { sha3_512: sha3 } = sha3$1;
+
+const defaultLength = 24;
+const bigLength = 32;
+
+const createEntropy = (length = 4, random = Math.random) => {
+  let entropy = "";
+
+  while (entropy.length < length) {
+    entropy = entropy + Math.floor(random() * 36).toString(36);
+  }
+  return entropy;
+};
+
+/*
+ * Adapted from https://github.com/juanelas/bigint-conversion
+ * MIT License Copyright (c) 2018 Juan Hernández Serrano
+ */
+function bufToBigInt(buf) {
+  let bits = 8n;
+
+  let value = 0n;
+  for (const i of buf.values()) {
+    const bi = BigInt(i);
+    value = (value << bits) + bi;
+  }
+  return value;
+}
+
+const hash = (input = "") => {
+  // Drop the first character because it will bias the histogram
+  // to the left.
+  return bufToBigInt(sha3(input)).toString(36).slice(1);
+};
+
+const alphabet = Array.from({ length: 26 }, (x, i) =>
+  String.fromCharCode(i + 97)
+);
+
+const randomLetter = (random) =>
+  alphabet[Math.floor(random() * alphabet.length)];
+
+/*
+This is a fingerprint of the host environment. It is used to help
+prevent collisions when generating ids in a distributed system.
+If no global object is available, you can pass in your own, or fall back
+on a random string.
+*/
+const createFingerprint = ({
+  globalObj = typeof commonjsGlobal !== "undefined"
+    ? commonjsGlobal
+    : typeof window !== "undefined"
+    ? window
+    : {},
+  random = Math.random,
+} = {}) => {
+  const globals = Object.keys(globalObj).toString();
+  const sourceString = globals.length
+    ? globals + createEntropy(bigLength, random)
+    : createEntropy(bigLength, random);
+
+  return hash(sourceString).substring(0, bigLength);
+};
+
+const createCounter = (count) => () => {
+  return count++;
+};
+
+// ~22k hosts before 50% chance of initial counter collision
+// with a remaining counter range of 9.0e+15 in JavaScript.
+const initialCountMax = 476782367;
+
+const init = ({
+  // Fallback if the user does not pass in a CSPRNG. This should be OK
+  // because we don't rely solely on the random number generator for entropy.
+  // We also use the host fingerprint, current time, and a session counter.
+  random = Math.random,
+  counter = createCounter(Math.floor(random() * initialCountMax)),
+  length = defaultLength,
+  fingerprint = createFingerprint({ random }),
+} = {}) => {
+  return function cuid2() {
+    const firstLetter = randomLetter(random);
+
+    // If we're lucky, the `.toString(36)` calls may reduce hashing rounds
+    // by shortening the input to the hash function a little.
+    const time = Date.now().toString(36);
+    const count = counter().toString(36);
+
+    // The salt should be long enough to be globally unique across the full
+    // length of the hash. For simplicity, we use the same length as the
+    // intended id output.
+    const salt = createEntropy(length, random);
+    const hashInput = `${time + salt + count + fingerprint}`;
+
+    return `${firstLetter + hash(hashInput).substring(1, length)}`;
+  };
+};
+
+const createId$1 = init();
+
+const isCuid = (id, { minLength = 2, maxLength = bigLength } = {}) => {
+  const length = id.length;
+  const regex = /^[0-9a-z]+$/;
+
+  try {
+    if (
+      typeof id === "string" &&
+      length >= minLength &&
+      length <= maxLength &&
+      regex.test(id)
+    )
+      return true;
+  } finally {
+  }
+
+  return false;
+};
+
+src.getConstants = () => ({ defaultLength, bigLength });
+src.init = init;
+src.createId = createId$1;
+src.bufToBigInt = bufToBigInt;
+src.createCounter = createCounter;
+src.createFingerprint = createFingerprint;
+src.isCuid = isCuid;
+
+const { createId} = src;
+
+var createId_1 = createId;
+
+const errorCatalog = Object.freeze({
+    CONFIGURATION: "Invalid transport configuration",
+    CLOSED: "Client is closed",
+    VALIDATION: "Message validation failed",
+    SERIALIZATION: "Message serialization failed",
+    REQUEST_TOO_LARGE: "Request exceeds the size limit",
+    DNS: "DNS resolution failed",
+    CONNECT: "Connection failed",
+    PROXY: "Proxy connection failed",
+    TLS: "TLS negotiation failed",
+    IO: "Transport I/O failed",
+    ATTEMPT_TIMEOUT: "Transport attempt timed out",
+    OPERATION_DEADLINE: "Operation deadline exceeded",
+    CANCELLED: "Operation cancelled",
+    OVERLOADED: "Transport is at capacity",
+    RATE_LIMITED: "Request was rate limited",
+    HTTP_REJECTED: "Request was rejected",
+    SERVER_FAILURE: "Server failed to process the request",
+    RESPONSE_TOO_LARGE: "Response exceeds the size limit",
+    RESPONSE_PROTOCOL: "Response protocol is invalid",
+    DESCRIPTOR_VERSION: "Descriptor version is not supported",
+});
+const REMEDIATION_ERROR_CODES = new Set([
+    "DNS",
+    "CONNECT",
+    "PROXY",
+    "TLS",
+    "IO",
+    "ATTEMPT_TIMEOUT",
+]);
+class RepostError extends Error {
+    constructor(details) {
+        super(errorCatalog[details.errorCode]);
+        this.name = new.target.name;
+        this.errorCode = details.errorCode;
+        this.deliveryState = details.deliveryState;
+        this.retryable = details.retryable ?? false;
+        this.operationId = details.operationId ?? null;
+        this.idempotencyKey = details.idempotencyKey ?? null;
+        this.attemptCount = details.attemptCount ?? 0;
+        this.httpStatus = details.httpStatus ?? null;
+        this.failureReason = details.failureReason ?? null;
+        this.causeCategory = details.causeCategory ?? null;
+        this.compressedBytes = details.compressedBytes ?? 0;
+        this.decompressedBytes = details.decompressedBytes ?? 0;
+        this.responseHeaderFields = details.responseHeaderFields ?? 0;
+        this.responseHeaderBytes = details.responseHeaderBytes ?? 0;
+        this.truncated = details.truncated ?? false;
+        this.validationIssues = Object.freeze([...(details.validationIssues ?? [])]);
+        this.configurationIssues = Object.freeze([...(details.configurationIssues ?? [])]);
+        this.closeFailureCount = details.closeFailureCount ?? 0;
+        this.closeFailureCategories = Object.freeze([...(details.closeFailureCategories ?? [])]);
+        this.issueCount = details.issueCount ?? this.validationIssues.length + this.configurationIssues.length;
+        this.issuesTruncated = details.issuesTruncated ?? false;
+        this.remediationKey = details.remediationKey ?? remediationKey(details.errorCode, this.failureReason);
+    }
+    isRetryable() { return this.retryable; }
+}
+function remediationKey(code, reason) {
+    if (!REMEDIATION_ERROR_CODES.has(code))
+        return null;
+    if (reason === "CONNECTION_RESET")
+        return "network.connection.reset";
+    if (reason === "TLS_UNTRUSTED")
+        return "network.tls.untrusted";
+    if (reason === "TLS_HOSTNAME_MISMATCH")
+        return "network.tls.hostname-mismatch";
+    if (reason === "TLS_NEGOTIATION")
+        return "network.tls.negotiation";
+    if (reason === "PROXY_AUTH_REQUIRED")
+        return "network.proxy.auth-required";
+    return reason === "UNKNOWN" ? "network.unknown" : null;
+}
+class RepostConfigurationError extends RepostError {
+}
+class RepostValidationError extends RepostError {
+}
+class RepostSerializationError extends RepostError {
+}
+class RepostTransportError extends RepostError {
+}
+class RepostPublishError extends RepostError {
+    constructor(detailsOrMessage, status, body) {
+        const details = typeof detailsOrMessage === "string"
+            ? legacyPublishDetails(status, body)
+            : detailsOrMessage;
+        super(details);
+        this.status = this.httpStatus ?? undefined;
+        this.body = details.body;
+    }
+}
+class RepostDescriptorVersionError extends RepostError {
+}
+function legacyPublishDetails(status, body) {
+    let errorCode = "HTTP_REJECTED";
+    if (status === undefined)
+        errorCode = "IO";
+    else if (status === 429)
+        errorCode = "RATE_LIMITED";
+    else if (status >= 500)
+        errorCode = "SERVER_FAILURE";
+    let deliveryState = "POSSIBLY_SENT";
+    if (status === undefined)
+        deliveryState = "NOT_SENT";
+    else if (status >= 400 && status < 500 && status !== 409 && status !== 429)
+        deliveryState = "REJECTED";
+    return {
+        errorCode,
+        deliveryState,
+        retryable: status === undefined || status === 409 || status === 429 || status >= 500,
+        httpStatus: status,
+        body,
+    };
+}
+
+const encoder$4 = new TextEncoder();
+const MAX_ISSUES = 32;
+const MAX_ISSUE_COUNT = 2147483647;
+const MAX_ISSUE_PATH_BYTES = 1024;
+const MAX_TOTAL_ISSUE_PATH_BYTES = 16384;
+const TRUNCATION_MARKER = ".<truncated>";
+/** Fill the runtime's injectable clock and ID generators with real defaults. */
+function resolveGenerators(generators) {
+    return {
+        now: generators?.now ?? (() => new Date().toISOString()),
+        uuid: generators?.uuid ?? (() => crypto.randomUUID()),
+        cuid: generators?.cuid ?? (() => createId_1()),
+    };
+}
+/**
+ * Serialize a send input into its wire payload, driven by the generated model
+ * descriptors: fields are emitted in declaration order under their `@map`'d
+ * wire names, absent fields with an `@default` are injected (literals
+ * verbatim, `now()`/`uuid()`/`cuid()` generated at send time), absent optional
+ * fields are omitted, nested models recurse, and enum members serialize to
+ * their (possibly `@map`'d) wire values. `generators` overrides the clock and
+ * id sources for deterministic tests (the conformance suite's seam).
+ */
+function serializeModel(models, modelName, data, generators, enums = {}) {
+    validateModelDescriptors(models, enums);
+    const collector = new ValidationCollector();
+    let payload = {};
+    try {
+        payload = serializeModelAt(models, modelName, data, generators, enums, "$", collector);
+    }
+    catch (error) {
+        if (!(error instanceof ValidationFault))
+            throw error;
+        collector.add(error);
+    }
+    collector.throwIfAny();
+    return payload;
+}
+function serializeModelAt(models, modelName, data, generators, enums, path, collector) {
+    const descriptor = models[modelName];
+    if (!descriptor) {
+        throw new Error(`@repost/client: no serialization descriptor for model \`${modelName}\`.`);
+    }
+    if (typeof data !== "object" || data === null || Array.isArray(data)) {
+        if (typeof data === "bigint" || typeof data === "symbol" || typeof data === "function") {
+            validationError("INVALID_JSON", path, "value is not representable as JSON");
+        }
+        let got = typeof data;
+        if (data === null)
+            got = "null";
+        else if (Array.isArray(data))
+            got = "an array";
+        throw new Error(`@repost/client: expected an object for model \`${modelName}\`, got ${got}.`);
+    }
+    const input = data;
+    const payload = {};
+    for (const field of descriptor.fields) {
+        try {
+            const schemaName = "schemaName" in field ? field.schemaName : field.name;
+            const fieldPath = appendPath(path, schemaName);
+            let value = input[schemaName];
+            if (value === undefined) {
+                if (field.default) {
+                    value = resolveDefault(field.default, generators);
+                }
+                else if ("requiredInInput" in field && field.requiredInInput) {
+                    validationError("REQUIRED", fieldPath, "required field is absent");
+                }
+                else {
+                    continue;
+                }
+            }
+            if (value === null && "nullableInInput" in field && !field.nullableInInput) {
+                validationError("NULL_NOT_ALLOWED", fieldPath, "null is not allowed");
+            }
+            const wireName = "wireName" in field ? field.wireName : field.wire ?? field.name;
+            payload[wireName] = serializeValue(models, field, value, generators, enums, fieldPath, collector);
+        }
+        catch (error) {
+            if (!(error instanceof ValidationFault))
+                throw error;
+            collector.add(error);
+        }
+    }
+    return payload;
+}
+function serializeValue(models, field, value, generators, enums, path, collector) {
+    if (value === null)
+        return null;
+    if (field.list) {
+        if (Array.isArray(value)) {
+            return value.map((item, index) => {
+                const itemPath = `${path}[${index}]`;
+                try {
+                    if (item === undefined)
+                        validationError("REQUIRED", itemPath, "required list element is absent");
+                    if (item === null && "scalarKind" in field) {
+                        validationError("NULL_NOT_ALLOWED", itemPath, "null list elements are not allowed");
+                    }
+                    return serializeItem(models, field, item, generators, enums, itemPath, collector);
+                }
+                catch (error) {
+                    if (!(error instanceof ValidationFault))
+                        throw error;
+                    collector.add(error);
+                    return undefined;
+                }
+            });
+        }
+        if ("scalarKind" in field) {
+            validationError("TYPE_MISMATCH", path, "expected a list");
+        }
+    }
+    return serializeItem(models, field, value, generators, enums, path, collector);
+}
+function serializeItem(models, field, value, generators, enums, path, collector) {
+    let model;
+    if ("scalarKind" in field && field.scalarKind === "model")
+        model = field.descriptorId;
+    else if ("model" in field)
+        model = field.model;
+    if (model) {
+        return serializeModelAt(models, model, value, generators, enums, path, collector);
+    }
+    let enumValues;
+    if ("scalarKind" in field && field.scalarKind === "enum") {
+        enumValues = enums[field.descriptorId ?? ""];
+    }
+    else if ("enum" in field) {
+        enumValues = field.enum;
+    }
+    if (enumValues) {
+        if (typeof value !== "string")
+            validationError("TYPE_MISMATCH", path, "expected an enum member");
+        const wire = enumValues[value];
+        if (wire === undefined) {
+            if (!("scalarKind" in field))
+                return value;
+            validationError("INVALID_ENUM", path, "unknown enum member");
+        }
+        return wire;
+    }
+    if ("scalarKind" in field) {
+        return validateScalar(field.scalarKind, value, path);
+    }
+    return value;
+}
+function validateScalar(kind, value, path) {
+    switch (kind) {
+        case "string":
+            if (typeof value !== "string")
+                validationError("TYPE_MISMATCH", path, "expected a string");
+            if (hasUnpairedSurrogate(value))
+                validationError("INVALID_UNICODE", path, "unpaired UTF-16 surrogates are not allowed");
+            return value;
+        case "boolean":
+            if (typeof value !== "boolean")
+                validationError("TYPE_MISMATCH", path, "expected a boolean");
+            return value;
+        case "int64":
+            if (typeof value !== "number")
+                validationError("TYPE_MISMATCH", path, "expected an integer");
+            if (!Number.isFinite(value))
+                validationError("NON_FINITE_NUMBER", path, "non-finite numbers are not allowed");
+            if (!Number.isSafeInteger(value))
+                validationError("OUT_OF_RANGE", path, "integer is outside the safe range");
+            return value;
+        case "float64":
+            if (typeof value !== "number")
+                validationError("TYPE_MISMATCH", path, "expected a number");
+            if (!Number.isFinite(value))
+                validationError("NON_FINITE_NUMBER", path, "non-finite numbers are not allowed");
+            return value;
+        case "datetime":
+            if (typeof value !== "string")
+                validationError("TYPE_MISMATCH", path, "expected a datetime string");
+            if (!/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/u.test(value)
+                || Number.isNaN(Date.parse(value))
+                || new Date(value).toISOString() !== value) {
+                validationError("INVALID_DATETIME", path, "expected an ISO-8601 UTC datetime");
+            }
+            return value;
+        case "json":
+            return canonicalJson(value, path, new Set());
+        default:
+            return value;
+    }
+}
+function canonicalJson(value, path, activeAncestors) {
+    if (typeof value === "number" && !Number.isFinite(value)) {
+        validationError("NON_FINITE_NUMBER", path, "non-finite numbers are not allowed");
+    }
+    if (typeof value === "string") {
+        if (hasUnpairedSurrogate(value))
+            validationError("INVALID_UNICODE", path, "unpaired UTF-16 surrogates are not allowed");
+        return value;
+    }
+    if (value === null || typeof value === "boolean" || typeof value === "number")
+        return value;
+    if (typeof value !== "object")
+        validationError("INVALID_JSON", path, "value is not representable as JSON");
+    if (activeAncestors.has(value)) {
+        validationError("INVALID_JSON", path, "cyclic JSON values are not allowed");
+    }
+    if (value instanceof Map) {
+        activeAncestors.add(value);
+        try {
+            const entries = [...value.entries()];
+            for (const [key] of entries) {
+                if (typeof key !== "string")
+                    validationError("INVALID_JSON", `${path}[{*}]`, "map keys must be strings");
+                if (hasUnpairedSurrogate(key))
+                    validationError("INVALID_UNICODE", `${path}[{*}]`, "map key contains an unpaired UTF-16 surrogate");
+            }
+            const result = {};
+            for (const [key, entry] of entries.sort(([left], [right]) => compareUtf8Bytes(left, right))) {
+                result[key] = canonicalJson(entry, `${path}[{*}]`, activeAncestors);
+            }
+            return result;
+        }
+        finally {
+            activeAncestors.delete(value);
+        }
+    }
+    activeAncestors.add(value);
+    try {
+        if (Array.isArray(value)) {
+            return value.map((item, index) => canonicalJson(item, `${path}[${index}]`, activeAncestors));
+        }
+        const record = value;
+        const result = {};
+        const keys = Object.keys(record);
+        if (keys.some(hasUnpairedSurrogate))
+            validationError("INVALID_UNICODE", `${path}[{*}]`, "map key contains an unpaired UTF-16 surrogate");
+        for (const key of keys.sort(compareUtf8Bytes)) {
+            result[key] = canonicalJson(record[key], `${path}[{*}]`, activeAncestors);
+        }
+        return result;
+    }
+    finally {
+        activeAncestors.delete(value);
+    }
+}
+function compareUtf8Bytes(left, right) {
+    const leftBytes = encoder$4.encode(left);
+    const rightBytes = encoder$4.encode(right);
+    const length = Math.min(leftBytes.length, rightBytes.length);
+    for (let index = 0; index < length; index += 1) {
+        const difference = (leftBytes[index] ?? 0) - (rightBytes[index] ?? 0);
+        if (difference !== 0)
+            return difference;
+    }
+    return leftBytes.length - rightBytes.length;
+}
+function hasUnpairedSurrogate(value) {
+    for (let index = 0; index < value.length; index += 1) {
+        const code = value.charCodeAt(index);
+        if (code >= 0xd800 && code <= 0xdbff) {
+            const next = value.charCodeAt(index + 1);
+            if (!(next >= 0xdc00 && next <= 0xdfff))
+                return true;
+            index += 1;
+        }
+        else if (code >= 0xdc00 && code <= 0xdfff) {
+            return true;
+        }
+    }
+    return false;
+}
+function compareUnicodeScalarValues(left, right) {
+    const leftScalars = Array.from(left, (value) => value.codePointAt(0) ?? 0);
+    const rightScalars = Array.from(right, (value) => value.codePointAt(0) ?? 0);
+    const length = Math.min(leftScalars.length, rightScalars.length);
+    for (let index = 0; index < length; index += 1) {
+        const difference = (leftScalars[index] ?? 0) - (rightScalars[index] ?? 0);
+        if (difference !== 0)
+            return difference;
+    }
+    return leftScalars.length - rightScalars.length;
+}
+const SCALAR_KINDS = new Set([
+    "string",
+    "boolean",
+    "int64",
+    "float64",
+    "datetime",
+    "json",
+    "enum",
+    "model",
+]);
+function validateModelDescriptors(models, enums) {
+    for (const modelName of Object.keys(models).sort(compareUnicodeScalarValues)) {
+        const model = models[modelName];
+        if (!model)
+            continue;
+        model.fields.forEach((field, index) => {
+            if (!("scalarKind" in field))
+                return;
+            const inputPath = appendPath("$", field.schemaName);
+            if (!SCALAR_KINDS.has(String(field.scalarKind))) {
+                descriptorError("UNKNOWN_SCALAR_KIND", inputPath, `unknown scalar kind '${String(field.scalarKind)}'`);
+            }
+            if (field.scalarKind !== "enum" && field.scalarKind !== "model")
+                return;
+            const referencePath = `${appendPath("$.models", modelName)}.fields[${index}].descriptorId`;
+            const registry = field.scalarKind === "enum" ? enums : models;
+            if (!field.descriptorId || !Object.prototype.hasOwnProperty.call(registry, field.descriptorId)) {
+                descriptorError("INVALID_DESCRIPTOR_REFERENCE", referencePath, `${field.scalarKind} descriptor '${field.descriptorId ?? ""}' does not exist`);
+            }
+        });
+    }
+}
+function descriptorError(code, path, message) {
+    throw new Error(`@repost/client: [${code}] ${path}: ${message}.`);
+}
+function appendPath(path, key) {
+    return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key)
+        ? `${path}.${key}`
+        : `${path}[${JSON.stringify(key)}]`;
+}
+function validationError(code, path, message) {
+    throw new ValidationFault(validationIssueCode(code), path, message);
+}
+class ValidationFault extends Error {
+    constructor(code, path, detail) {
+        super(`@repost/client: [${code}] ${path}: ${detail}.`);
+        this.code = code;
+        this.path = path;
+        this.detail = detail;
+    }
+}
+class ValidationCollector {
+    constructor() {
+        this.issues = [];
+        this.issueCount = 0;
+        this.retainedPathBytes = 0;
+    }
+    add(fault) {
+        this.issueCount = Math.min(this.issueCount + 1, MAX_ISSUE_COUNT);
+        if (this.issues.length >= MAX_ISSUES)
+            return;
+        const path = truncateIssuePath(fault.path);
+        const pathBytes = encoder$4.encode(path).length;
+        if (this.retainedPathBytes + pathBytes > MAX_TOTAL_ISSUE_PATH_BYTES)
+            return;
+        this.retainedPathBytes += pathBytes;
+        this.issues.push({ code: fault.code, path, message: fault.message });
+    }
+    throwIfAny() {
+        if (this.issueCount === 0)
+            return;
+        throw new RepostValidationError({
+            errorCode: "VALIDATION",
+            deliveryState: "NOT_SENT",
+            validationIssues: this.issues,
+            issueCount: this.issueCount,
+            issuesTruncated: this.issueCount !== this.issues.length,
+        });
+    }
+}
+function validationIssueCode(code) {
+    if (code === "REQUIRED_FIELD")
+        return "REQUIRED";
+    if (code === "NULL_LIST_ELEMENT")
+        return "NULL_NOT_ALLOWED";
+    if (code === "NON_FINITE_NUMBER")
+        return "NON_FINITE";
+    if (code === "UNKNOWN_SCALAR_KIND" || code === "INVALID_DESCRIPTOR_REFERENCE")
+        return "TYPE_MISMATCH";
+    return code;
+}
+function truncateIssuePath(path) {
+    if (encoder$4.encode(path).length <= MAX_ISSUE_PATH_BYTES)
+        return path;
+    let retained = "$";
+    const segments = path.slice(1).match(/(?:\.[A-Za-z_$][A-Za-z0-9_$]*|\[(?:0|[1-9][0-9]*)\]|\[\{\*\}\])/gu) ?? [];
+    for (const segment of segments) {
+        if (encoder$4.encode(retained + segment + TRUNCATION_MARKER).length > MAX_ISSUE_PATH_BYTES)
+            break;
+        retained += segment;
+    }
+    return retained + TRUNCATION_MARKER;
+}
+function resolveDefault(spec, generators) {
+    const resolved = resolveGenerators(generators);
+    switch (spec.kind) {
+        case "literal":
+            return spec.value;
+        case "now":
+            return resolved.now();
+        case "uuid":
+            return resolved.uuid();
+        case "cuid":
+            return resolved.cuid();
+    }
+}
+
+function classifyNetworkFailure(error, committed = false) {
+    const code = errorCode(error);
+    if (code === "ENOTFOUND" || code === "EAI_AGAIN") {
+        return { kind: "failure", code: "DNS", reason: code === "ENOTFOUND" ? "DNS_NOT_FOUND" : "DNS_TIMEOUT", committed: false };
+    }
+    if (code === "ECONNREFUSED" || code === "UND_ERR_CONNECT_TIMEOUT") {
+        return { kind: "failure", code: "CONNECT", reason: code === "ECONNREFUSED" ? "CONNECT_REFUSED" : "CONNECT_TIMEOUT", committed: false };
+    }
+    if (code === "CERT_HAS_EXPIRED")
+        return { kind: "failure", code: "TLS", reason: "TLS_CERTIFICATE_EXPIRED", committed };
+    if (code === "CERT_NOT_YET_VALID")
+        return { kind: "failure", code: "TLS", reason: "TLS_CERTIFICATE_NOT_YET_VALID", committed };
+    if (code === "ERR_TLS_CERT_ALTNAME_INVALID")
+        return { kind: "failure", code: "TLS", reason: "TLS_HOSTNAME_MISMATCH", committed };
+    if (code === "DEPTH_ZERO_SELF_SIGNED_CERT" || code === "UNABLE_TO_VERIFY_LEAF_SIGNATURE" || code === "SELF_SIGNED_CERT_IN_CHAIN") {
+        return { kind: "failure", code: "TLS", reason: "TLS_UNTRUSTED", committed };
+    }
+    if (code.startsWith("ERR_TLS") || code.startsWith("ERR_SSL")) {
+        return { kind: "failure", code: "TLS", reason: "TLS_NEGOTIATION", committed };
+    }
+    if (code === "REPOST_DNS_RESOLVER") {
+        return { kind: "failure", code: "DNS", reason: "UNKNOWN", committed: false, causeCategory: "DNS_RESOLVER", retryable: false };
+    }
+    if (code === "REPOST_PROXY_AUTH_REQUIRED") {
+        return { kind: "failure", code: "PROXY", reason: "PROXY_AUTH_REQUIRED", committed: false, retryable: false };
+    }
+    if (code === "REPOST_PROXY_CREDENTIAL_PROVIDER") {
+        return { kind: "failure", code: "PROXY", reason: "PROXY_AUTH_REQUIRED", committed: false, causeCategory: "PROXY_CREDENTIAL_PROVIDER", retryable: false };
+    }
+    if (code === "REPOST_PROXY_CONNECT_FAILED") {
+        return { kind: "failure", code: "PROXY", reason: "PROXY_CONNECT_FAILED", committed: false };
+    }
+    return null;
+}
+function errorCode(error) {
+    if (!error || typeof error !== "object")
+        return "";
+    const direct = error.code;
+    if (typeof direct === "string")
+        return direct;
+    const cause = error.cause;
+    return cause === error ? "" : errorCode(cause);
+}
+
+const RESPONSE_LIMIT_BYTES$1 = 1048576;
+/** Portable one-attempt fetch transport. Retry and deadlines belong to the runtime. */
+function createHttpTransport(options = {}) {
+    rejectRuntimeOptions(options);
+    return {
+        async send(request) {
+            const fetchImpl = options.fetch ?? ((input, init) => globalThis.fetch(input, init));
+            const requestHeaders = new Headers();
+            for (const [name, value] of request.headers)
+                requestHeaders.append(name, value);
+            request.commitTracker.markCommitted();
+            try {
+                const response = await fetchImpl(request.url, {
+                    method: "POST",
+                    headers: requestHeaders,
+                    body: Uint8Array.from(request.bodyBytes).buffer,
+                    redirect: "manual",
+                    signal: request.signal,
+                });
+                const headers = {};
+                response.headers.forEach((value, name) => {
+                    var _a;
+                    (headers[_a = name.toLowerCase()] ?? (headers[_a] = [])).push(value);
+                });
+                const { bytes, truncated } = await readBounded(response.body, RESPONSE_LIMIT_BYTES$1);
+                return {
+                    kind: "response",
+                    status: response.status,
+                    headers,
+                    bodyBytes: bytes,
+                    compressedBytes: bytes.length,
+                    decompressedBytes: bytes.length,
+                    truncated,
+                };
+            }
+            catch (error) {
+                return classifyFetchFailure(error, request.commitTracker.committed);
+            }
+        },
+    };
+}
+/** Explicit portable transport for edge/worker runtimes. */
+const createFetchTransport = createHttpTransport;
+/** Selects the production Node lane; the package supports Node 20 and newer. */
+function resolveDefaultTransport(options = {}) {
+    return createNodeTransport(options);
+}
+/** Production Node transport, loaded on first use so fetch-only bundles omit Undici. */
+function createNodeTransport(options = {}) {
+    rejectRuntimeOptions(options);
+    let loaded;
+    const load = () => loaded ?? (loaded = import('./node-BAJt_qhB.mjs').then((module) => module.createNodeTransport(options)));
+    return {
+        async send(request) {
+            return (await load()).send(request);
+        },
+        async close() {
+            if (loaded)
+                await (await loaded).close?.();
+        },
+    };
+}
+/** @deprecated Prefer the runtime-selected transport. */
+const httpTransport = createHttpTransport();
+function rejectRuntimeOptions(options) {
+    if (options.maxRetries === undefined && options.baseDelayMs === undefined && options.timeoutMs === undefined)
+        return;
+    throw new RepostConfigurationError({
+        errorCode: "CONFIGURATION",
+        deliveryState: "NOT_SENT",
+        configurationIssues: [{ code: "UNSUPPORTED", optionKeys: ["HTTP_TRANSPORT_OPTIONS"] }],
+    });
+}
+async function readBounded(stream, limit) {
+    if (!stream)
+        return { bytes: new Uint8Array(), truncated: false };
+    const reader = stream.getReader();
+    const chunks = [];
+    let total = 0;
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            if (!value)
+                continue;
+            const room = limit - total;
+            if (value.length > room) {
+                if (room > 0)
+                    chunks.push(value.slice(0, room));
+                total = limit;
+                await reader.cancel();
+                return { bytes: concatenate(chunks, total), truncated: true };
+            }
+            chunks.push(value);
+            total += value.length;
+        }
+        return { bytes: concatenate(chunks, total), truncated: false };
+    }
+    finally {
+        reader.releaseLock();
+    }
+}
+function concatenate(chunks, total) {
+    const bytes = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+        bytes.set(chunk, offset);
+        offset += chunk.length;
+    }
+    return bytes;
+}
+function classifyFetchFailure(error, committed) {
+    const classified = classifyNetworkFailure(error, committed);
+    if (classified)
+        return classified;
+    if (error instanceof Error && (error.name === "TimeoutError" || error.name === "AbortError")) {
+        return { kind: "failure", code: "ATTEMPT_TIMEOUT", reason: null, committed };
+    }
+    const code = errorCode(error);
+    let reason = "UNKNOWN";
+    if (code === "ECONNRESET")
+        reason = "CONNECTION_RESET";
+    else if (code === "UND_ERR_SOCKET")
+        reason = "CONNECTION_CLOSED";
+    return { kind: "failure", code: "IO", reason, committed };
+}
+
+const DEFAULT_API_URL = "https://api.repost.sh";
+const MAX_DURATION_MS = 9223372036854;
+const encoder$3 = new TextEncoder();
+function snapshotOptions(options) {
+    if (options.apiKey !== undefined && options.apiKeyProvider !== undefined) {
+        invalid("CONFLICT", ["API_KEY", "API_KEY_PROVIDER"]);
+    }
+    if (options.transport !== undefined && options.httpTransportOptions !== undefined) {
+        invalid("CONFLICT", ["HTTP_TRANSPORT_OPTIONS", "TRANSPORT"]);
+    }
+    const attemptTimeoutMs = duration(options.attemptTimeoutMs ?? options.httpTransportOptions?.timeoutMs ?? 30000, "ATTEMPT_TIMEOUT");
+    const operationTimeoutMs = duration(options.operationTimeoutMs ?? 120000, "OPERATION_TIMEOUT");
+    const connectTimeoutMs = duration(options.connectTimeoutMs ?? 10000, "CONNECT_TIMEOUT");
+    const retryBaseDelayMs = duration(options.retryBaseDelayMs ?? options.httpTransportOptions?.baseDelayMs ?? 250, "RETRY_BASE_DELAY");
+    const retryMaxDelayMs = duration(options.retryMaxDelayMs ?? 60000, "RETRY_MAX_DELAY");
+    if (options.retryBaseDelayMs !== undefined && options.retryMaxDelayMs !== undefined && retryBaseDelayMs > retryMaxDelayMs) {
+        invalid("CONFLICT", ["RETRY_BASE_DELAY", "RETRY_MAX_DELAY"]);
+    }
+    const maxAttempts = integerRange(options.maxAttempts ?? ((options.httpTransportOptions?.maxRetries ?? 3) + 1), 1, 10, "MAX_ATTEMPTS");
+    const maxInFlightOperations = integerRange(options.maxInFlightOperations ?? 256, 1, 65536, "MAX_IN_FLIGHT_OPERATIONS");
+    const maxBufferedBytes = integerRange(options.maxBufferedBytes ?? 67108864, 4194304, 1073741824, "MAX_BUFFERED_BYTES");
+    if (options.userAgentSuffix !== undefined && !/^[\x21-\x7e](?:[\x20-\x7e]{0,254}[\x21-\x7e])?$/.test(options.userAgentSuffix)) {
+        invalid("INVALID_VALUE", ["USER_AGENT_SUFFIX"]);
+    }
+    const fixedApiKey = options.apiKey ?? options.token;
+    if (fixedApiKey !== undefined && (!/^[\x20-\x7e]{1,4096}$/.test(fixedApiKey) || !/[^ ]/.test(fixedApiKey))) {
+        invalid("INVALID_VALUE", ["API_KEY"]);
+    }
+    const apiKey = fixedApiKey ?? process.env.REPOST_SEND_API_KEY ?? process.env.REPOST_TOKEN;
+    return Object.freeze({
+        apiKey,
+        apiKeyProvider: options.apiKeyProvider,
+        apiUrl: canonicalizeBaseUrl(options.apiUrl ?? process.env.REPOST_API_URL ?? DEFAULT_API_URL),
+        transport: options.transport,
+        httpTransportOptions: snapshotHttpTransportOptions(options.httpTransportOptions),
+        generators: options.generators && Object.freeze({ ...options.generators }),
+        attemptTimeoutMs,
+        operationTimeoutMs,
+        connectTimeoutMs,
+        maxAttempts,
+        retryBaseDelayMs,
+        retryMaxDelayMs,
+        maxInFlightOperations,
+        maxBufferedBytes,
+        idempotencyKeyGenerator: options.idempotencyKeyGenerator ?? (() => createId_1()),
+        retryEntropy: options.retryEntropy ?? cryptoRetryEntropy,
+        monotonicClock: options.monotonicClock ?? (() => performance.now()),
+        wallClock: options.wallClock ?? (() => Date.now()),
+        scheduler: options.scheduler ?? realScheduler,
+        userAgent: `repost-client-typescript/${PACKAGE_VERSION}${options.userAgentSuffix ? ` ${options.userAgentSuffix}` : ""}`,
+        observer: options.observer,
+        telemetry: options.telemetry,
+    });
+}
+function snapshotHttpTransportOptions(options) {
+    if (!options)
+        return undefined;
+    const { maxRetries: _maxRetries, baseDelayMs: _baseDelayMs, timeoutMs: _timeoutMs, ...transportOptions } = options;
+    return Object.freeze({
+        ...transportOptions,
+        tls: options.tls && Object.freeze({
+            ...options.tls,
+            caCertificates: options.tls.caCertificates && Object.freeze([...options.tls.caCertificates]),
+            ciphers: options.tls.ciphers && Object.freeze([...options.tls.ciphers]),
+            clientCertificate: options.tls.clientCertificate && Object.freeze({ ...options.tls.clientCertificate }),
+        }),
+        proxy: options.proxy && Object.freeze({ ...options.proxy }),
+    });
+}
+function canonicalizeBaseUrl(raw) {
+    if (encoder$3.encode(raw).length > 2048 || !/^[\x00-\x7f]+$/.test(raw))
+        invalid("INVALID_VALUE", ["BASE_URI"]);
+    const match = /^(https?):\/\/([^/?#]+)(\/[^?#]*)?$/.exec(raw);
+    if (!match)
+        invalid("INVALID_VALUE", ["BASE_URI"]);
+    const [, scheme, authority, rawPath = ""] = match;
+    if (authority.length === 0 || encoder$3.encode(authority).length > 512 || authority.includes("@"))
+        invalid("INVALID_VALUE", ["BASE_URI"]);
+    const { host, port } = parseAuthority(authority);
+    if (host !== host.toLowerCase() || !validHost(scheme, host))
+        invalid("INVALID_VALUE", ["BASE_URI"]);
+    if (port !== undefined) {
+        if (/^-?[0-9]+$/u.test(port) && (Number(port) < 1 || Number(port) > 65535))
+            invalid("OUT_OF_RANGE", ["BASE_URI"]);
+        if (!/^[1-9][0-9]*$/u.test(port))
+            invalid("INVALID_VALUE", ["BASE_URI"]);
+    }
+    if (encoder$3.encode(rawPath).length > 1536 || !validPath(rawPath))
+        invalid("INVALID_VALUE", ["BASE_URI"]);
+    const path = rawPath.replace(/\/+$/, "");
+    const base = `${scheme}://${authority}${path}`;
+    const endpoint = path.endsWith("/v1/messages") ? base : `${base}/v1/messages`;
+    if (encoder$3.encode(new URL(endpoint).pathname).length > 2048 || encoder$3.encode(endpoint).length > 4096)
+        invalid("INVALID_VALUE", ["BASE_URI"]);
+    return base;
+}
+function endpointUrl(base) {
+    return base.endsWith("/v1/messages") ? base : `${base}/v1/messages`;
+}
+function duration(value, key) {
+    if (!Number.isSafeInteger(value) || value < 1 || value > MAX_DURATION_MS)
+        invalid("OUT_OF_RANGE", [key]);
+    return value;
+}
+function integerRange(value, min, max, key) {
+    if (!Number.isSafeInteger(value) || value < min || value > max)
+        invalid("OUT_OF_RANGE", [key]);
+    return value;
+}
+function parseAuthority(authority) {
+    if (authority.startsWith("[")) {
+        const end = authority.indexOf("]");
+        if (end < 0)
+            invalid("INVALID_VALUE", ["BASE_URI"]);
+        const suffix = authority.slice(end + 1);
+        if (suffix !== "" && !suffix.startsWith(":"))
+            invalid("INVALID_VALUE", ["BASE_URI"]);
+        return { host: authority.slice(0, end + 1), port: suffix === "" ? undefined : suffix.slice(1) };
+    }
+    const colon = authority.lastIndexOf(":");
+    if (colon < 0)
+        return { host: authority };
+    if (authority.indexOf(":") !== colon)
+        invalid("INVALID_VALUE", ["BASE_URI"]);
+    return { host: authority.slice(0, colon), port: authority.slice(colon + 1) };
+}
+function validHost(scheme, host) {
+    if (scheme === "http") {
+        if (host === "localhost" || host === "[::1]")
+            return true;
+        const parts = host.split(".");
+        return parts.length === 4
+            && parts.every((part) => /^(0|[1-9][0-9]{0,2})$/.test(part) && Number(part) <= 255)
+            && parts[0] === "127";
+    }
+    if (host.startsWith("[")) {
+        try {
+            return new URL(`https://${host}`).hostname === host;
+        }
+        catch {
+            return false;
+        }
+    }
+    if (!/^[a-z0-9.-]+$/.test(host) || host.endsWith(".") || host.includes(".."))
+        return false;
+    const parts = host.split(".");
+    if (parts.every((part) => /^[0-9]+$/.test(part))) {
+        return parts.length === 4
+            && parts.every((part) => /^(0|[1-9][0-9]{0,2})$/.test(part) && Number(part) <= 255);
+    }
+    return parts.every((part) => /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/.test(part));
+}
+function validPath(path) {
+    if (!/^(?:[A-Za-z0-9._~!$&'()*+,;=:@/-]|%[0-9A-F]{2})*$/.test(path))
+        return false;
+    if (/%(?:2F|5C)/.test(path))
+        return false;
+    return !path.split("/").some((segment) => segment === "." || segment === "..");
+}
+function invalid(code, optionKeys) {
+    throw new RepostConfigurationError({
+        errorCode: "CONFIGURATION",
+        deliveryState: "NOT_SENT",
+        configurationIssues: [{ code, optionKeys }],
+    });
+}
+const cryptoRetryEntropy = {
+    nextInt(exclusiveBound) {
+        if (!Number.isSafeInteger(exclusiveBound) || exclusiveBound < 1 || exclusiveBound > 4294967296)
+            throw new RangeError("invalid entropy bound");
+        const limit = Math.floor(4294967296 / exclusiveBound) * exclusiveBound;
+        const sample = new Uint32Array(1);
+        do
+            crypto.getRandomValues(sample);
+        while ((sample[0] ?? 0) >= limit);
+        return (sample[0] ?? 0) % exclusiveBound;
+    },
+};
+const realScheduler = {
+    sleep(ms, signal) {
+        return new Promise((resolve, reject) => {
+            if (signal?.aborted)
+                return reject(signal.reason);
+            const timer = setTimeout(resolve, ms);
+            signal?.addEventListener("abort", () => {
+                clearTimeout(timer);
+                reject(signal.reason);
+            }, { once: true });
+        });
+    },
+};
+
+function observerEvent(kind, operationId, timestampMs, values = {}) {
+    return Object.freeze({
+        schemaVersion: 1,
+        kind,
+        operationId,
+        timestampMs,
+        attemptNumber: null,
+        durationMs: null,
+        outcome: null,
+        errorCode: null,
+        deliveryState: null,
+        httpStatusClass: null,
+        retryDelayMs: null,
+        operationStartedAtMs: null,
+        operationEndedAtMs: null,
+        attemptSummaries: Object.freeze([]),
+        ...values,
+    });
+}
+function attemptSummary(attemptNumber, outcome, error, attempt, durationMs) {
+    let httpStatusClass = null;
+    if (attempt.kind === "response")
+        httpStatusClass = statusClass(attempt.status);
+    else if (attempt.httpStatus !== undefined && attempt.httpStatus !== null) {
+        httpStatusClass = statusClass(attempt.httpStatus);
+    }
+    return Object.freeze({
+        attemptNumber,
+        outcome,
+        errorCode: error?.errorCode ?? null,
+        deliveryState: error?.deliveryState ?? (outcome === "ACCEPTED" ? "ACCEPTED" : null),
+        httpStatusClass,
+        durationMs: Math.max(0, durationMs),
+    });
+}
+function statusClass(status) {
+    if (status < 200)
+        return "INFORMATIONAL";
+    if (status < 300)
+        return "SUCCESS";
+    if (status < 400)
+        return "REDIRECT";
+    if (status < 500)
+        return "CLIENT_ERROR";
+    return "SERVER_ERROR";
+}
+function telemetryAttemptEnd(summary) {
+    return {
+        httpStatusClass: summary.httpStatusClass,
+        outcome: summary.outcome,
+        errorCode: summary.errorCode,
+        durationMs: summary.durationMs,
+    };
+}
+
+const encoder$2 = new TextEncoder();
+async function resolveCredential(config, operationId) {
+    let credential = config.apiKey;
+    if (config.apiKeyProvider) {
+        try {
+            credential = await config.apiKeyProvider();
+        }
+        catch {
+            throw new RepostConfigurationError({
+                errorCode: "CONFIGURATION", deliveryState: "NOT_SENT", operationId,
+                causeCategory: "API_KEY_PROVIDER",
+                configurationIssues: [{ code: "INVALID_VALUE", optionKeys: ["API_KEY_PROVIDER"] }],
+            });
+        }
+    }
+    if (credential === undefined) {
+        throw new RepostConfigurationError({
+            errorCode: "CONFIGURATION", deliveryState: "NOT_SENT", operationId,
+            configurationIssues: [{ code: "MISSING", optionKeys: ["API_KEY"] }],
+        });
+    }
+    if (typeof credential !== "string" || !/^[\x20-\x7e]{1,4096}$/.test(credential) || !/[^ ]/.test(credential)) {
+        throw new RepostConfigurationError({
+            errorCode: "CONFIGURATION", deliveryState: "NOT_SENT", operationId,
+            configurationIssues: [{ code: "INVALID_VALUE", optionKeys: [config.apiKeyProvider ? "API_KEY_PROVIDER" : "API_KEY"] }],
+        });
+    }
+    return credential;
+}
+function resolveIdempotencyKey(config, supplied, operationId) {
+    let key = supplied;
+    if (key === undefined) {
+        if (config.idempotencyKeyGenerator === false) {
+            throw new RepostConfigurationError({
+                errorCode: "CONFIGURATION", deliveryState: "NOT_SENT", operationId,
+                configurationIssues: [{ code: "CONFLICT", optionKeys: ["MAX_ATTEMPTS", "IDEMPOTENCY_KEY_GENERATOR"] }],
+            });
+        }
+        try {
+            key = config.idempotencyKeyGenerator();
+        }
+        catch {
+            throw new RepostConfigurationError({
+                errorCode: "CONFIGURATION", deliveryState: "NOT_SENT", operationId,
+                causeCategory: "IDEMPOTENCY_GENERATOR",
+                configurationIssues: [{ code: "INVALID_VALUE", optionKeys: ["IDEMPOTENCY_KEY_GENERATOR"] }],
+            });
+        }
+    }
+    if (typeof key !== "string" || !/^[\x21-\x7e](?:[\x20-\x7e]{0,253}[\x21-\x7e])?$/.test(key)) {
+        if (supplied !== undefined) {
+            throw new RepostValidationError({
+                errorCode: "VALIDATION",
+                deliveryState: "NOT_SENT",
+                operationId,
+                validationIssues: [{
+                        code: typeof key === "string" && encoder$2.encode(key).length > 255 ? "COLLECTION_LIMIT" : "INVALID_UNICODE",
+                        path: "$",
+                        message: "@repost/client: invalid idempotency key.",
+                    }],
+            });
+        }
+        throw new RepostConfigurationError({
+            errorCode: "CONFIGURATION", deliveryState: "NOT_SENT", operationId,
+            configurationIssues: [{ code: "INVALID_VALUE", optionKeys: ["IDEMPOTENCY_KEY_GENERATOR"] }],
+        });
+    }
+    return key;
+}
+function serializeForSend(schema, event, data, generators, operationId, idempotencyKey) {
+    try {
+        return serializeModel(schema.models, event.model, data, generators, schema.enums);
+    }
+    catch (error) {
+        if (error instanceof RepostValidationError) {
+            throw new RepostValidationError({
+                errorCode: "VALIDATION",
+                deliveryState: "NOT_SENT",
+                operationId,
+                idempotencyKey,
+                validationIssues: error.validationIssues,
+                issueCount: error.issueCount,
+                issuesTruncated: error.issuesTruncated,
+            });
+        }
+        if (error instanceof RepostError)
+            throw error;
+        const message = error instanceof Error ? error.message : "@repost/client: [TYPE_MISMATCH] $: invalid input.";
+        const match = /\[([A-Z_]+)] ([^:]+): (.+)/.exec(message);
+        throw new RepostValidationError({
+            errorCode: "VALIDATION", deliveryState: "NOT_SENT", operationId, idempotencyKey,
+            validationIssues: [{
+                    code: validationCode(match?.[1]),
+                    path: match?.[2] ?? "$",
+                    message,
+                }],
+        });
+    }
+}
+function validationCode(code) {
+    if (code === "REQUIRED_FIELD")
+        return "REQUIRED";
+    if (code === "NULL_NOT_ALLOWED" || code === "NULL_LIST_ELEMENT")
+        return "NULL_NOT_ALLOWED";
+    if (code === "NON_FINITE_NUMBER")
+        return "NON_FINITE";
+    if (code === "OUT_OF_RANGE")
+        return "OUT_OF_RANGE";
+    if (code === "INVALID_DATETIME")
+        return "INVALID_DATETIME";
+    if (code === "INVALID_ENUM")
+        return "INVALID_ENUM";
+    if (code === "INVALID_JSON")
+        return "INVALID_JSON";
+    if (code === "INVALID_UNICODE")
+        return "INVALID_UNICODE";
+    if (code === "COLLECTION_LIMIT")
+        return "COLLECTION_LIMIT";
+    if (code === "CYCLE")
+        return "CYCLE";
+    return "TYPE_MISMATCH";
+}
+
+const MAX_DEPTH = 32;
+const MAX_TOKENS = 10000;
+const MAX_FIELD_NAME_BYTES = 64;
+const MAX_STRING_BYTES = 8192;
+const MAX_STRING_CHARS = 8192;
+const MAX_NUMBER_CHARS = 128;
+const MAX_MEMBERS = 16;
+const encoder$1 = new TextEncoder();
+class StrictJsonSyntaxError extends Error {
+}
+class StrictJsonLimitError extends Error {
+}
+function parseStrictJson(bytes) {
+    if (bytes.length >= 3 && bytes[0] === 0xef && bytes[1] === 0xbb && bytes[2] === 0xbf) {
+        throw new StrictJsonSyntaxError("UTF-8 BOM is not allowed");
+    }
+    let text;
+    try {
+        text = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+    }
+    catch {
+        throw new StrictJsonSyntaxError("response is not scalar-valid UTF-8");
+    }
+    new Scanner(text).parse();
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        throw new StrictJsonSyntaxError("malformed JSON");
+    }
+}
+class Scanner {
+    constructor(text) {
+        this.text = text;
+        this.index = 0;
+        this.tokens = 0;
+    }
+    parse() {
+        this.whitespace();
+        this.value(0);
+        this.whitespace();
+        if (this.index !== this.text.length)
+            this.syntax();
+    }
+    value(depth) {
+        this.whitespace();
+        const char = this.text[this.index];
+        if (char === "{") {
+            this.object(depth + 1);
+            return;
+        }
+        if (char === "[") {
+            this.array(depth + 1);
+            return;
+        }
+        if (char === '"') {
+            this.token();
+            this.string(false);
+            return;
+        }
+        if (char === "t") {
+            this.scalar("true");
+            return;
+        }
+        if (char === "f") {
+            this.scalar("false");
+            return;
+        }
+        if (char === "n") {
+            this.scalar("null");
+            return;
+        }
+        this.number();
+    }
+    object(depth) {
+        this.depth(depth);
+        this.token();
+        this.index += 1;
+        this.whitespace();
+        if (this.text[this.index] === "}") {
+            this.index += 1;
+            this.token();
+            return;
+        }
+        const keys = new Set();
+        let members = 0;
+        while (this.index < this.text.length) {
+            this.whitespace();
+            if (this.text[this.index] !== '"')
+                this.syntax();
+            this.token();
+            const key = this.string(true);
+            if (keys.has(key))
+                throw new StrictJsonSyntaxError("duplicate object key");
+            keys.add(key);
+            members += 1;
+            if (members > MAX_MEMBERS)
+                this.limit("object members");
+            this.whitespace();
+            if (this.text[this.index] !== ":")
+                this.syntax();
+            this.index += 1;
+            this.value(depth);
+            this.whitespace();
+            if (this.text[this.index] === "}") {
+                this.index += 1;
+                this.token();
+                return;
+            }
+            if (this.text[this.index] !== ",")
+                this.syntax();
+            this.index += 1;
+        }
+        this.syntax();
+    }
+    array(depth) {
+        this.depth(depth);
+        this.token();
+        this.index += 1;
+        this.whitespace();
+        if (this.text[this.index] === "]") {
+            this.index += 1;
+            this.token();
+            return;
+        }
+        while (this.index < this.text.length) {
+            this.value(depth);
+            this.whitespace();
+            if (this.text[this.index] === "]") {
+                this.index += 1;
+                this.token();
+                return;
+            }
+            if (this.text[this.index] !== ",")
+                this.syntax();
+            this.index += 1;
+        }
+        this.syntax();
+    }
+    string(fieldName) {
+        const start = this.index;
+        this.index += 1;
+        while (this.index < this.text.length) {
+            const char = this.text[this.index];
+            if (char === "\\")
+                this.index += 2;
+            else if (char === '"') {
+                this.index += 1;
+                let value;
+                try {
+                    value = JSON.parse(this.text.slice(start, this.index));
+                }
+                catch {
+                    this.syntax();
+                }
+                let chars = 0;
+                for (let offset = 0; offset < value.length; offset += 1) {
+                    const unit = value.charCodeAt(offset);
+                    if (unit >= 0xd800 && unit <= 0xdbff) {
+                        const next = value.charCodeAt(offset + 1);
+                        if (!(next >= 0xdc00 && next <= 0xdfff))
+                            this.syntax();
+                        offset += 1;
+                    }
+                    else if (unit >= 0xdc00 && unit <= 0xdfff)
+                        this.syntax();
+                    chars += 1;
+                }
+                const byteLength = encoder$1.encode(value).length;
+                if (fieldName ? byteLength > MAX_FIELD_NAME_BYTES : byteLength > MAX_STRING_BYTES || chars > MAX_STRING_CHARS) {
+                    this.limit(fieldName ? "field name" : "string scalar");
+                }
+                return value;
+            }
+            else {
+                if ((char?.charCodeAt(0) ?? 0) < 0x20)
+                    this.syntax();
+                this.index += 1;
+            }
+        }
+        this.syntax();
+    }
+    scalar(value) {
+        this.token();
+        if (!this.text.startsWith(value, this.index))
+            this.syntax();
+        this.index += value.length;
+    }
+    number() {
+        const match = /^-?(?:0|[1-9][0-9]*)(?:\.[0-9]+)?(?:[eE][+-]?[0-9]+)?/u.exec(this.text.slice(this.index));
+        if (!match)
+            this.syntax();
+        this.token();
+        if (match[0].length > MAX_NUMBER_CHARS)
+            this.limit("number token");
+        this.index += match[0].length;
+    }
+    whitespace() {
+        while (/^[\x20\x09\x0a\x0d]$/u.test(this.text[this.index] ?? ""))
+            this.index += 1;
+    }
+    token() {
+        this.tokens += 1;
+        if (this.tokens > MAX_TOKENS)
+            this.limit("tokens");
+    }
+    depth(depth) {
+        if (depth > MAX_DEPTH)
+            this.limit("nesting depth");
+    }
+    syntax() { throw new StrictJsonSyntaxError("malformed JSON"); }
+    limit(name) { throw new StrictJsonLimitError(`JSON ${name} limit exceeded`); }
+}
+
+const RESPONSE_LIMIT_BYTES = 1048576;
+function classifyOutcome(outcome, priorPossible) {
+    if (outcome.kind === "failure") {
+        const retryable = outcome.retryable
+            ?? (outcome.code !== "TLS" && !(outcome.code === "PROXY" && outcome.reason === "PROXY_AUTH_REQUIRED"));
+        const possible = priorPossible || outcome.committed;
+        return { code: outcome.code, retryable, deliveryState: possible ? "POSSIBLY_SENT" : "NOT_SENT", reason: outcome.reason, acceptancePossible: possible };
+    }
+    if (outcome.protocolError) {
+        return { code: "RESPONSE_PROTOCOL", retryable: false, deliveryState: "POSSIBLY_SENT", reason: null, acceptancePossible: true };
+    }
+    if (outcome.proxyError) {
+        return { code: "PROXY", retryable: false, deliveryState: "NOT_SENT", reason: "UNKNOWN", acceptancePossible: false };
+    }
+    const status = outcome.status;
+    if (status >= 200 && status <= 299) {
+        if (outcome.truncated
+            || (!outcome.transportLimitsApplied && outcome.compressedBytes > RESPONSE_LIMIT_BYTES)
+            || (!outcome.transportLimitsApplied && outcome.decompressedBytes > RESPONSE_LIMIT_BYTES)
+            || outcome.limitExceeded
+            || (!outcome.transportLimitsApplied && outcome.compressedBytes > 0 && outcome.decompressedBytes > outcome.compressedBytes * 100)) {
+            return { code: "RESPONSE_TOO_LARGE", retryable: false, deliveryState: "POSSIBLY_SENT", reason: null, acceptancePossible: true };
+        }
+        return { code: "RESPONSE_PROTOCOL", retryable: true, deliveryState: "POSSIBLY_SENT", reason: null, acceptancePossible: true };
+    }
+    if (status === 429)
+        return { code: "RATE_LIMITED", retryable: !outcome.nonRetryable, deliveryState: priorPossible ? "POSSIBLY_SENT" : "REJECTED", reason: null, acceptancePossible: priorPossible };
+    if (status === 409)
+        return { code: "HTTP_REJECTED", retryable: !outcome.nonRetryable, deliveryState: "POSSIBLY_SENT", reason: null, acceptancePossible: true };
+    if (status >= 300 && status < 400)
+        return { code: "HTTP_REJECTED", retryable: false, deliveryState: "REJECTED", reason: null, acceptancePossible: priorPossible };
+    if (status >= 500)
+        return { code: "SERVER_FAILURE", retryable: !outcome.nonRetryable, deliveryState: "POSSIBLY_SENT", reason: null, acceptancePossible: true };
+    if (status >= 400)
+        return { code: "HTTP_REJECTED", retryable: false, deliveryState: "REJECTED", reason: null, acceptancePossible: priorPossible };
+    return { code: "RESPONSE_PROTOCOL", retryable: false, deliveryState: "POSSIBLY_SENT", reason: null, acceptancePossible: true };
+}
+function validateAcceptedResponse(outcome, envelope, customerId) {
+    if (outcome.bodyBytes.length > RESPONSE_LIMIT_BYTES
+        || (!outcome.transportLimitsApplied && outcome.compressedBytes > RESPONSE_LIMIT_BYTES)
+        || (!outcome.transportLimitsApplied && outcome.decompressedBytes > RESPONSE_LIMIT_BYTES))
+        return null;
+    const contentTypes = headerValues(outcome.headers, "content-type");
+    if (contentTypes.length !== 1
+        || !/^[\t ]*application\/json[\t ]*(?:;[\t ]*charset[\t ]*=[\t ]*(?:utf-8|"utf-8")[\t ]*)?$/i.test(contentTypes[0] ?? ""))
+        return null;
+    try {
+        const value = parseStrictJson(outcome.bodyBytes);
+        if (!value || typeof value !== "object" || Array.isArray(value))
+            return null;
+        if (typeof value.id !== "string" || !/^msg_[A-Za-z0-9_-]{1,124}$/.test(value.id))
+            return null;
+        if (value.type !== envelope.type || value.customerId !== customerId || value.timestamp !== envelope.timestamp)
+            return null;
+        return Object.freeze({ id: value.id, type: envelope.type, customerId, timestamp: envelope.timestamp });
+    }
+    catch (error) {
+        if (error instanceof StrictJsonLimitError)
+            return "LIMIT_EXCEEDED";
+        return null;
+    }
+}
+function headerValues(headers, name) {
+    const entry = Object.entries(headers).find(([key]) => key.toLowerCase() === name);
+    return entry?.[1] ?? [];
+}
+function parseRetryAfter(headers, wallNow) {
+    const values = headerValues(headers, "retry-after");
+    if (values.length === 0 || values.some((value) => value !== values[0]))
+        return null;
+    const value = values[0] ?? "";
+    if (/^[0-9]+$/.test(value)) {
+        const ms = Number(value) * 1000;
+        return Number.isSafeInteger(ms) ? ms : null;
+    }
+    const parsed = Date.parse(value);
+    return Number.isFinite(parsed) && parsed > wallNow ? parsed - wallNow : null;
+}
+function publicError(code, deliveryState, retryable, operationId, idempotencyKey, attemptCount, outcome, failureReason) {
+    let causeCategory = null;
+    if (outcome.kind === "failure")
+        causeCategory = outcome.causeCategory ?? null;
+    else if (outcome.proxyError)
+        causeCategory = "HTTP_RUNTIME";
+    const details = {
+        errorCode: code,
+        deliveryState,
+        retryable,
+        operationId,
+        idempotencyKey,
+        attemptCount,
+        ...responseDetails(outcome),
+        failureReason,
+        causeCategory,
+        body: publishBody(outcome),
+    };
+    if (code === "CONFIGURATION")
+        return new RepostConfigurationError(details);
+    switch (code) {
+        case "DNS":
+        case "CONNECT":
+        case "PROXY":
+        case "TLS":
+        case "IO":
+        case "ATTEMPT_TIMEOUT":
+        case "OPERATION_DEADLINE":
+        case "CANCELLED":
+        case "OVERLOADED":
+            return new RepostTransportError(details);
+        default:
+            return new RepostPublishError(details);
+    }
+}
+function publishBody(outcome) {
+    if (outcome.kind !== "response" || outcome.bodyBytes.length === 0)
+        return undefined;
+    try {
+        return JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(outcome.bodyBytes));
+    }
+    catch {
+        return undefined;
+    }
+}
+function cancelled(operationId, idempotencyKey, attemptCount, committed, outcome = null) {
+    return new RepostTransportError({
+        errorCode: "CANCELLED", deliveryState: committed ? "CANCELLED_UNKNOWN" : "NOT_SENT",
+        operationId, idempotencyKey, attemptCount,
+        ...responseDetails(outcome),
+    });
+}
+function closed(operationId, idempotencyKey, attemptCount, committed, outcome = null) {
+    return new RepostTransportError({
+        errorCode: "CLOSED", deliveryState: committed ? "CANCELLED_UNKNOWN" : "NOT_SENT",
+        operationId, idempotencyKey, attemptCount,
+        ...responseDetails(outcome),
+    });
+}
+function deadlineError(operationId, idempotencyKey, attemptCount, committed, outcome = null) {
+    return new RepostTransportError({
+        errorCode: "OPERATION_DEADLINE", deliveryState: committed ? "POSSIBLY_SENT" : "NOT_SENT",
+        operationId, idempotencyKey, attemptCount,
+        ...responseDetails(outcome),
+    });
+}
+function responseDetails(outcome) {
+    if (!outcome) {
+        return { httpStatus: null, compressedBytes: 0, decompressedBytes: 0, truncated: false, responseHeaderFields: 0, responseHeaderBytes: 0 };
+    }
+    const exposeHeaderLimit = outcome.kind === "response" && outcome.headerLimitExceeded;
+    return {
+        httpStatus: outcome.kind === "response" ? outcome.status : outcome.httpStatus ?? null,
+        compressedBytes: outcome.compressedBytes ?? 0,
+        decompressedBytes: outcome.decompressedBytes ?? 0,
+        truncated: outcome.truncated ?? false,
+        responseHeaderFields: exposeHeaderLimit ? outcome.responseHeaderFields ?? 0 : 0,
+        responseHeaderBytes: exposeHeaderLimit ? outcome.responseHeaderBytes ?? 0 : 0,
+    };
+}
+
+class TelemetryInvoker {
+    constructor(telemetry) {
+        this.telemetry = telemetry;
+    }
+    capture() {
+        if (!this.telemetry)
+            return null;
+        try {
+            return this.telemetry.captureContext();
+        }
+        catch {
+            return null;
+        }
+    }
+    startOperation(parent, start) {
+        if (!this.telemetry || parent === null)
+            return null;
+        try {
+            return this.telemetry.startOperation(parent, start);
+        }
+        catch {
+            return null;
+        }
+    }
+    startAttempt(operation, start) {
+        if (!operation)
+            return null;
+        try {
+            return operation.startAttempt(start);
+        }
+        catch {
+            return null;
+        }
+    }
+    headers(attempt) {
+        if (!attempt)
+            return [];
+        try {
+            const headers = attempt.propagationHeaders();
+            if (!headers?.traceparent)
+                return [];
+            return Object.freeze([
+                Object.freeze(["traceparent", headers.traceparent]),
+                ...(headers.tracestate ? [Object.freeze(["tracestate", headers.tracestate])] : []),
+            ]);
+        }
+        catch {
+            return [];
+        }
+    }
+    endAttempt(attempt, end) {
+        if (!attempt)
+            return;
+        try {
+            attempt.end(end);
+        }
+        catch { /* Telemetry must not affect delivery. */ }
+    }
+    endOperation(operation, end) {
+        if (!operation)
+            return;
+        try {
+            operation.end(end);
+        }
+        catch { /* Telemetry must not affect delivery. */ }
+    }
+}
+
+const REQUEST_LIMIT_BYTES = 1048576;
+const encoder = new TextEncoder();
+function createSendOperation(config, schema, state) {
+    const ownsTransport = config.transport === undefined;
+    const transport = config.transport ?? resolveDefaultTransport(config.httpTransportOptions);
+    const observers = new ObserverDispatcher(config.observer, state);
+    const telemetry = new TelemetryInvoker(config.telemetry);
+    let transportCloseStarted = false;
+    return {
+        send: (event, input) => createOperationPromise(config, schema, state, transport, observers, telemetry, event, input),
+        close() {
+            state.close();
+            if (!ownsTransport || transportCloseStarted)
+                return;
+            transportCloseStarted = true;
+            try {
+                const closing = transport.close?.();
+                if (closing)
+                    void Promise.resolve(closing).catch(() => undefined);
+            }
+            catch {
+                // Runtime closure is final even when an owned transport cannot close cleanly.
+            }
+        },
+    };
+}
+function createOperationPromise(config, schema, state, transport, observers, telemetry, event, input) {
+    const cancellation = new AbortController();
+    const signal = input.signal ? AbortSignal.any([input.signal, cancellation.signal]) : cancellation.signal;
+    const metadata = { operationId: null, idempotencyKey: null, attemptCount: 0, httpStatus: null };
+    const execution = send(config, schema, state, transport, observers, telemetry, event, { ...input, signal }, metadata);
+    const outcome = execution.then((result) => Object.freeze({
+        operationId: metadata.operationId,
+        code: "OK",
+        deliveryState: "ACCEPTED",
+        attemptCount: metadata.attemptCount,
+        httpStatus: metadata.httpStatus,
+        idempotencyKey: metadata.idempotencyKey,
+        result,
+        error: null,
+    }), (error) => {
+        const failure = error instanceof RepostError ? error : null;
+        return Object.freeze({
+            operationId: failure?.operationId ?? null,
+            code: failure?.errorCode ?? "IO",
+            deliveryState: failure?.deliveryState ?? "NOT_SENT",
+            attemptCount: failure?.attemptCount ?? 0,
+            httpStatus: failure?.httpStatus ?? metadata.httpStatus,
+            idempotencyKey: failure?.idempotencyKey ?? null,
+            result: null,
+            error: failure,
+        });
+    });
+    const primary = execution.catch((error) => {
+        if (error instanceof RepostError && error.errorCode === "CANCELLED" && signal.aborted)
+            throw signal.reason;
+        throw error;
+    });
+    Object.defineProperties(primary, {
+        outcome: { value: outcome, enumerable: false, writable: false, configurable: false },
+        cancel: {
+            value: () => cancellation.abort(new DOMException("This operation was aborted", "AbortError")),
+            enumerable: false,
+            writable: false,
+            configurable: false,
+        },
+    });
+    return primary;
+}
+async function send(config, schema, state, transport, observers, telemetry, event, input, metadata) {
+    const startedAt = config.monotonicClock();
+    const deadline = saturatingDeadline(startedAt, config.operationTimeoutMs);
+    const deadlineAuthority = operationDeadline(config.operationTimeoutMs);
+    if (state.isClosing())
+        throw closed(null, null, 0, false);
+    const operationId = `op_${crypto.randomUUID()}`;
+    metadata.operationId = operationId;
+    observers.emit(observerEvent("operation.start", operationId, startedAt));
+    const admission = state.admit();
+    if (!admission) {
+        if (state.isClosing())
+            throw closed(null, null, 0, false);
+        const error = new RepostTransportError({
+            errorCode: "OVERLOADED", deliveryState: "NOT_SENT", operationId,
+        });
+        const endedAt = config.monotonicClock();
+        observers.emit(observerEvent("operation.end", operationId, endedAt, {
+            durationMs: Math.max(0, endedAt - startedAt),
+            outcome: "FAILED",
+            errorCode: "OVERLOADED",
+            deliveryState: "NOT_SENT",
+        }));
+        throw error;
+    }
+    let idempotencyKey = null;
+    let attemptCount = 0;
+    let acceptancePossible = false;
+    let lastOutcome = null;
+    let terminal = null;
+    const summaries = [];
+    let telemetryOperation = null;
+    try {
+        const capturedContext = telemetry.capture();
+        telemetryOperation = telemetry.startOperation(capturedContext, { startedAtMs: startedAt });
+        let credential;
+        try {
+            credential = await interruptible(resolveCredential(config, operationId), [
+                admission.signal,
+                ...(input.signal && !input.signal.aborted ? [input.signal] : []),
+                deadlineAuthority.signal,
+            ]);
+        }
+        catch (error) {
+            if (admission.signal.aborted)
+                throw closed(operationId, null, 0, false);
+            if (input.signal?.aborted)
+                throw cancelled(operationId, null, 0, false);
+            if (deadlineAuthority.signal.aborted)
+                throw deadlineError(operationId, null, 0, false);
+            throw error;
+        }
+        idempotencyKey = resolveIdempotencyKey(config, input.idempotencyKey, operationId);
+        metadata.idempotencyKey = idempotencyKey;
+        const resolved = resolveGenerators(config.generators);
+        const operationNow = resolved.now();
+        const envelope = {
+            type: event.type,
+            timestamp: operationNow,
+            data: serializeForSend(schema, event, input.data, { ...resolved, now: () => operationNow }, operationId, idempotencyKey),
+        };
+        let bodyBytes;
+        try {
+            bodyBytes = encoder.encode(JSON.stringify({
+                type: envelope.type,
+                customerId: input.customerId,
+                timestamp: envelope.timestamp,
+                data: envelope.data,
+            }));
+        }
+        catch {
+            throw new RepostSerializationError({
+                errorCode: "SERIALIZATION", deliveryState: "NOT_SENT", operationId, idempotencyKey,
+            });
+        }
+        if (bodyBytes.length > REQUEST_LIMIT_BYTES) {
+            throw new RepostSerializationError({
+                errorCode: "REQUEST_TOO_LARGE", deliveryState: "NOT_SENT", operationId, idempotencyKey,
+            });
+        }
+        admission.retainSerializedRequest(bodyBytes.length);
+        if (input.signal?.aborted)
+            throw cancelled(operationId, idempotencyKey, 0, false);
+        for (let attemptNumber = 1; attemptNumber <= config.maxAttempts; attemptNumber += 1) {
+            const remaining = deadline - config.monotonicClock();
+            if (remaining <= 0)
+                throw deadlineError(operationId, idempotencyKey, attemptCount, acceptancePossible, lastOutcome);
+            attemptCount = attemptNumber;
+            metadata.attemptCount = attemptNumber;
+            let committed = false;
+            const attemptTimeoutMs = Math.min(config.attemptTimeoutMs, remaining);
+            const timeoutSignal = AbortSignal.timeout(Math.max(1, Math.ceil(attemptTimeoutMs)));
+            const signal = AbortSignal.any([
+                admission.signal,
+                deadlineAuthority.signal,
+                timeoutSignal,
+                ...(input.signal ? [input.signal] : []),
+            ]);
+            const headers = [
+                ["authorization", `Bearer ${credential}`],
+                ["content-type", "application/json"],
+                ["accept-encoding", "gzip"],
+                ["user-agent", config.userAgent],
+                ["idempotency-key", idempotencyKey],
+            ];
+            const attemptStartedAt = config.monotonicClock();
+            const telemetryAttempt = telemetry.startAttempt(telemetryOperation, { startedAtMs: attemptStartedAt, attemptNumber });
+            headers.push(...telemetry.headers(telemetryAttempt));
+            const request = {
+                url: endpointUrl(config.apiUrl),
+                headers,
+                bodyBytes,
+                attemptNumber,
+                connectTimeoutMs: Math.min(config.connectTimeoutMs, attemptTimeoutMs),
+                attemptTimeoutMs,
+                signal,
+                commitTracker: {
+                    get committed() { return committed; },
+                    markCommitted() { committed = true; },
+                },
+            };
+            observers.emit(observerEvent("attempt.start", operationId, attemptStartedAt, { attemptNumber }));
+            const outcome = await invokeTransport(transport, request, input.signal, timeoutSignal, config.transport !== undefined);
+            lastOutcome = outcome;
+            if (outcome.kind === "response")
+                metadata.httpStatus = outcome.status;
+            else if (outcome.httpStatus !== undefined && outcome.httpStatus !== null)
+                metadata.httpStatus = outcome.httpStatus;
+            if (outcome.kind === "response" && outcome.headerLimitExceeded)
+                state.responseHeaderLimitFailed();
+            if (admission.signal.aborted) {
+                closeResponse(outcome, state);
+                const error = closed(operationId, idempotencyKey, attemptCount, committed || acceptancePossible, outcome);
+                const endedAt = config.monotonicClock();
+                const summary = attemptSummary(attemptNumber, "CLOSED", error, outcome, endedAt - attemptStartedAt);
+                telemetry.endAttempt(telemetryAttempt, telemetryAttemptEnd(summary));
+                summaries.push(summary);
+                observers.emit(observerEvent("attempt.end", operationId, endedAt, summary));
+                throw error;
+            }
+            if (input.signal?.aborted) {
+                closeResponse(outcome, state);
+                const error = cancelled(operationId, idempotencyKey, attemptCount, committed || acceptancePossible, outcome);
+                const endedAt = config.monotonicClock();
+                const summary = attemptSummary(attemptNumber, "CANCELLED", error, outcome, endedAt - attemptStartedAt);
+                telemetry.endAttempt(telemetryAttempt, telemetryAttemptEnd(summary));
+                summaries.push(summary);
+                observers.emit(observerEvent("attempt.end", operationId, endedAt, summary));
+                throw error;
+            }
+            if (deadlineAuthority.signal.aborted || config.monotonicClock() >= deadline) {
+                closeResponse(outcome, state);
+                const error = deadlineError(operationId, idempotencyKey, attemptCount, committed || acceptancePossible, outcome);
+                const endedAt = config.monotonicClock();
+                const summary = attemptSummary(attemptNumber, "FAILED", error, outcome, endedAt - attemptStartedAt);
+                telemetry.endAttempt(telemetryAttempt, telemetryAttemptEnd(summary));
+                summaries.push(summary);
+                observers.emit(observerEvent("attempt.end", operationId, endedAt, summary));
+                throw error;
+            }
+            let classifiedOutcome = outcome;
+            if (outcome.kind === "response" && outcome.status >= 200 && outcome.status <= 299) {
+                const result = validateAcceptedResponse(outcome, envelope, input.customerId);
+                if (result === "LIMIT_EXCEEDED") {
+                    classifiedOutcome = { ...outcome, limitExceeded: true };
+                }
+                else if (result) {
+                    const endedAt = config.monotonicClock();
+                    const summary = attemptSummary(attemptNumber, "ACCEPTED", null, outcome, endedAt - attemptStartedAt);
+                    telemetry.endAttempt(telemetryAttempt, telemetryAttemptEnd(summary));
+                    summaries.push(summary);
+                    observers.emit(observerEvent("attempt.end", operationId, endedAt, summary));
+                    closeResponse(outcome, state);
+                    terminal = { outcome: "ACCEPTED", error: null, deliveryState: "ACCEPTED" };
+                    return result;
+                }
+            }
+            const failure = classifyOutcome(classifiedOutcome, acceptancePossible);
+            acceptancePossible || (acceptancePossible = failure.acceptancePossible);
+            const attemptError = publicError(failure.code, failure.deliveryState, failure.retryable, operationId, idempotencyKey, attemptNumber, classifiedOutcome, failure.reason);
+            const attemptEndedAt = config.monotonicClock();
+            let attemptObserverOutcome = "FAILED";
+            if (failure.retryable)
+                attemptObserverOutcome = "RETRYABLE_FAILURE";
+            else if (failure.deliveryState === "REJECTED")
+                attemptObserverOutcome = "REJECTED";
+            const summary = attemptSummary(attemptNumber, attemptObserverOutcome, attemptError, classifiedOutcome, attemptEndedAt - attemptStartedAt);
+            telemetry.endAttempt(telemetryAttempt, telemetryAttemptEnd(summary));
+            summaries.push(summary);
+            observers.emit(observerEvent("attempt.end", operationId, attemptEndedAt, summary));
+            closeResponse(classifiedOutcome, state);
+            if (!failure.retryable || attemptNumber === config.maxAttempts) {
+                if (failure.deliveryState === "REJECTED" && acceptancePossible) {
+                    throw publicError(failure.code, "POSSIBLY_SENT", failure.retryable, operationId, idempotencyKey, attemptNumber, classifiedOutcome, failure.reason);
+                }
+                throw attemptError;
+            }
+            const now = config.monotonicClock();
+            const retryRemaining = deadline - now;
+            if (retryRemaining <= 0)
+                throw deadlineError(operationId, idempotencyKey, attemptNumber, acceptancePossible, lastOutcome);
+            const exponential = Math.min(config.retryMaxDelayMs, config.retryBaseDelayMs * 2 ** Math.min(attemptNumber - 1, 52));
+            const cap = Math.max(0, Math.min(exponential, retryRemaining));
+            let jitter;
+            try {
+                jitter = config.retryEntropy.nextInt(Math.floor(cap) + 1);
+            }
+            catch {
+                throw new RepostConfigurationError({
+                    errorCode: "CONFIGURATION",
+                    deliveryState: acceptancePossible ? "POSSIBLY_SENT" : "NOT_SENT",
+                    operationId,
+                    idempotencyKey,
+                    attemptCount,
+                    causeCategory: "RETRY_ENTROPY",
+                    configurationIssues: [{ code: "INVALID_VALUE", optionKeys: ["RETRY_ENTROPY"] }],
+                    ...responseDetails(lastOutcome),
+                });
+            }
+            if (!Number.isInteger(jitter) || jitter < 0 || jitter > cap) {
+                throw new RepostConfigurationError({
+                    errorCode: "CONFIGURATION",
+                    deliveryState: acceptancePossible ? "POSSIBLY_SENT" : "NOT_SENT",
+                    operationId,
+                    idempotencyKey,
+                    attemptCount,
+                    configurationIssues: [{ code: "INVALID_VALUE", optionKeys: ["RETRY_ENTROPY"] }],
+                    ...responseDetails(lastOutcome),
+                });
+            }
+            let retryAfter = null;
+            if (classifiedOutcome.kind === "response") {
+                retryAfter = classifiedOutcome.retryAfterDelayMs
+                    ?? parseRetryAfter(classifiedOutcome.headers, config.wallClock());
+            }
+            const delay = retryAfter === null ? jitter : Math.max(jitter, Math.min(retryAfter, 60000, retryRemaining));
+            observers.emit(observerEvent("retry.delay", operationId, config.monotonicClock(), {
+                attemptNumber: attemptNumber + 1,
+                retryDelayMs: delay,
+                outcome: "RETRYABLE_FAILURE",
+                errorCode: failure.code,
+                deliveryState: failure.deliveryState,
+                httpStatusClass: classifiedOutcome.kind === "response" ? statusClass(classifiedOutcome.status) : null,
+            }));
+            try {
+                const sleepSignal = AbortSignal.any([
+                    admission.signal,
+                    deadlineAuthority.signal,
+                    ...(input.signal ? [input.signal] : []),
+                ]);
+                await config.scheduler.sleep(delay, sleepSignal);
+            }
+            catch {
+                if (admission.signal.aborted)
+                    throw closed(operationId, idempotencyKey, attemptCount, acceptancePossible, lastOutcome);
+                if (input.signal?.aborted)
+                    throw cancelled(operationId, idempotencyKey, attemptCount, acceptancePossible, lastOutcome);
+                if (deadlineAuthority.signal.aborted || config.monotonicClock() >= deadline) {
+                    throw deadlineError(operationId, idempotencyKey, attemptCount, acceptancePossible, lastOutcome);
+                }
+                throw new RepostTransportError({
+                    errorCode: "IO",
+                    deliveryState: acceptancePossible ? "POSSIBLY_SENT" : "NOT_SENT",
+                    operationId,
+                    idempotencyKey,
+                    attemptCount,
+                    causeCategory: "UNKNOWN",
+                    ...responseDetails(lastOutcome),
+                });
+            }
+        }
+        throw deadlineError(operationId, idempotencyKey, attemptCount, acceptancePossible, lastOutcome);
+    }
+    catch (error) {
+        const failure = error instanceof RepostError
+            ? error
+            : new RepostTransportError({
+                errorCode: "IO", deliveryState: acceptancePossible ? "POSSIBLY_SENT" : "NOT_SENT",
+                operationId, idempotencyKey, attemptCount, causeCategory: "UNKNOWN",
+            });
+        let terminalOutcome = "FAILED";
+        if (failure.errorCode === "CANCELLED")
+            terminalOutcome = "CANCELLED";
+        else if (failure.deliveryState === "REJECTED")
+            terminalOutcome = "REJECTED";
+        terminal = {
+            outcome: terminalOutcome,
+            error: failure,
+            deliveryState: failure.deliveryState,
+        };
+        if (failure.errorCode === "CANCELLED") {
+            observers.emit(observerEvent("operation.cancel", operationId, config.monotonicClock(), {
+                attemptNumber: attemptCount || null,
+                outcome: "CANCELLED",
+                errorCode: "CANCELLED",
+                deliveryState: failure.deliveryState,
+            }));
+        }
+        throw failure;
+    }
+    finally {
+        deadlineAuthority.clear();
+        admission.release();
+        if (terminal) {
+            const endedAt = config.monotonicClock();
+            let terminalHttpStatusClass = null;
+            if (terminal.error?.httpStatus)
+                terminalHttpStatusClass = statusClass(terminal.error.httpStatus);
+            else if (terminal.outcome === "ACCEPTED")
+                terminalHttpStatusClass = "SUCCESS";
+            telemetry.endOperation(telemetryOperation, {
+                outcome: terminal.outcome,
+                errorCode: terminal.error?.errorCode ?? null,
+                durationMs: Math.max(0, endedAt - startedAt),
+            });
+            observers.emit(observerEvent("operation.end", operationId, endedAt, {
+                durationMs: Math.max(0, endedAt - startedAt),
+                outcome: terminal.outcome,
+                errorCode: terminal.error?.errorCode ?? null,
+                deliveryState: terminal.deliveryState,
+                httpStatusClass: terminalHttpStatusClass,
+                operationStartedAtMs: startedAt,
+                operationEndedAtMs: endedAt,
+                attemptSummaries: Object.freeze([...summaries]),
+            }));
+        }
+    }
+}
+async function invokeTransport(transport, request, callerSignal, timeoutSignal, customTransport) {
+    try {
+        const outcome = await Promise.race([
+            transport.send(request),
+            new Promise((_, reject) => request.signal.addEventListener("abort", () => reject(request.signal.reason), { once: true })),
+        ]);
+        if (!outcome || (outcome.kind !== "response" && outcome.kind !== "failure"))
+            throw new TypeError("invalid custom transport outcome");
+        return outcome;
+    }
+    catch {
+        if (callerSignal?.aborted) {
+            return { kind: "failure", code: "IO", reason: "UNKNOWN", committed: request.commitTracker.committed };
+        }
+        if (timeoutSignal.aborted) {
+            return { kind: "failure", code: "ATTEMPT_TIMEOUT", reason: "UNKNOWN", committed: request.commitTracker.committed, causeCategory: "HTTP_RUNTIME" };
+        }
+        return {
+            kind: "failure",
+            code: "IO",
+            reason: "UNKNOWN",
+            committed: customTransport || request.commitTracker.committed,
+            causeCategory: customTransport ? "CUSTOM_TRANSPORT" : "HTTP_RUNTIME",
+            retryable: false,
+        };
+    }
+}
+function closeResponse(outcome, state) {
+    if (outcome.kind !== "response" || !outcome.close)
+        return;
+    try {
+        const closing = outcome.close();
+        if (closing)
+            void Promise.resolve(closing).catch(() => state.responseCloseFailed());
+    }
+    catch {
+        state.responseCloseFailed();
+    }
+}
+function saturatingDeadline(start, duration) {
+    const deadline = start + duration;
+    return Number.isFinite(deadline) ? Math.min(Number.MAX_SAFE_INTEGER, deadline) : Number.MAX_SAFE_INTEGER;
+}
+function operationDeadline(durationMs) {
+    const controller = new AbortController();
+    let timer;
+    let remaining = durationMs;
+    const arm = () => {
+        const delay = Math.min(remaining, 2147483647);
+        timer = setTimeout(() => {
+            remaining -= delay;
+            if (remaining <= 0)
+                controller.abort();
+            else
+                arm();
+        }, delay);
+    };
+    arm();
+    return { signal: controller.signal, clear: () => clearTimeout(timer) };
+}
+function interruptible(work, signals) {
+    return new Promise((resolve, reject) => {
+        const abort = (signal) => {
+            cleanup();
+            reject(signal.reason);
+        };
+        const listeners = signals.map((signal) => [signal, () => abort(signal)]);
+        const cleanup = () => listeners.forEach(([signal, listener]) => signal.removeEventListener("abort", listener));
+        for (const [signal, listener] of listeners) {
+            if (signal.aborted)
+                return abort(signal);
+            signal.addEventListener("abort", listener, { once: true });
+        }
+        work.then((value) => { cleanup(); resolve(value); }, (error) => { cleanup(); reject(error); });
+    });
+}
+
+const PORTABLE_OPERATION_WORKSPACE_BYTES = 2359296;
+const REQUEST_WORKSPACE_BYTES = 1048576;
+class RuntimeState {
+    constructor(maxInFlightOperations, maxBufferedBytes) {
+        this.maxInFlightOperations = maxInFlightOperations;
+        this.maxBufferedBytes = maxBufferedBytes;
+        this.inFlightOperations = 0;
+        this.bufferedBytes = 0;
+        this.concurrencyOverloadRejections = 0;
+        this.requestByteOverloadRejections = 0;
+        this.responseHeaderLimitFailures = 0;
+        this.responseCloseFailures = 0;
+        this.droppedObserverEvents = 0;
+        this.observerFailures = 0;
+        this.closing = false;
+        this.closed = false;
+        this.active = new Set();
+    }
+    admit() {
+        if (this.closing)
+            return null;
+        if (this.inFlightOperations >= this.maxInFlightOperations) {
+            this.concurrencyOverloadRejections = saturatingAdd(this.concurrencyOverloadRejections);
+            return null;
+        }
+        if (this.bufferedBytes + PORTABLE_OPERATION_WORKSPACE_BYTES > this.maxBufferedBytes) {
+            this.requestByteOverloadRejections = saturatingAdd(this.requestByteOverloadRejections);
+            return null;
+        }
+        const controller = new AbortController();
+        this.active.add(controller);
+        this.inFlightOperations += 1;
+        this.bufferedBytes += PORTABLE_OPERATION_WORKSPACE_BYTES;
+        let retained = PORTABLE_OPERATION_WORKSPACE_BYTES;
+        let released = false;
+        return {
+            signal: controller.signal,
+            retainSerializedRequest: (bodyBytes) => {
+                const releasedBytes = REQUEST_WORKSPACE_BYTES - bodyBytes;
+                if (releasedBytes > 0) {
+                    retained -= releasedBytes;
+                    this.bufferedBytes -= releasedBytes;
+                }
+            },
+            release: () => {
+                if (released)
+                    return;
+                released = true;
+                this.inFlightOperations -= 1;
+                this.bufferedBytes -= retained;
+                this.active.delete(controller);
+                if (this.closing && this.inFlightOperations === 0)
+                    this.closed = true;
+            },
+        };
+    }
+    isClosing() { return this.closing; }
+    close() {
+        if (this.closing)
+            return;
+        this.closing = true;
+        for (const controller of this.active)
+            controller.abort();
+        if (this.inFlightOperations === 0)
+            this.closed = true;
+    }
+    diagnostics() {
+        return Object.freeze({
+            inFlightOperations: this.inFlightOperations,
+            bufferedBytes: this.bufferedBytes,
+            concurrencyOverloadRejections: this.concurrencyOverloadRejections,
+            requestByteOverloadRejections: this.requestByteOverloadRejections,
+            responseByteOverloadRejections: 0,
+            responseHeaderLimitFailures: this.responseHeaderLimitFailures,
+            executorOverloadRejections: 0,
+            schedulerOverloadRejections: 0,
+            responseCloseFailures: this.responseCloseFailures,
+            droppedObserverEvents: this.droppedObserverEvents,
+            observerFailures: this.observerFailures,
+            closed: this.closed,
+        });
+    }
+    observerDropped() { this.droppedObserverEvents = saturatingAdd(this.droppedObserverEvents); }
+    observerFailed() { this.observerFailures = saturatingAdd(this.observerFailures); }
+    responseHeaderLimitFailed() { this.responseHeaderLimitFailures = saturatingAdd(this.responseHeaderLimitFailures); }
+    responseCloseFailed() { this.responseCloseFailures = saturatingAdd(this.responseCloseFailures); }
+    seedDiagnosticCounter(counter, value) {
+        if (!Number.isSafeInteger(value) || value < 0)
+            throw new TypeError("invalid diagnostics counter seed");
+        if (counter !== "concurrencyOverloadRejections")
+            throw new TypeError("invalid diagnostics counter");
+        this.concurrencyOverloadRejections = value;
+    }
+}
+function saturatingAdd(value) {
+    return Math.min(Number.MAX_SAFE_INTEGER, value + 1);
+}
+
+/**
+ * The descriptor-format version this runtime implements. Generated clients
+ * declare the version they were emitted for; [`buildWebhooks`] refuses a
+ * mismatch at construction — never silently at send time. Bumped only on a
+ * wire-breaking change to the descriptor contract (see
+ * sdk/conformance/CONTRACT.md and the conformance-vector freeze policy).
+ */
+const DESCRIPTOR_FORMAT_VERSION = 2;
+/** Warn-once latch for pre-versioning generated packages. */
+let warnedPreVersioning = false;
+/**
+ * No-network transport for tests: echoes the envelope identity as a typed
+ * `SendResult` with a fixed stub message id.
+ */
+const stubTransport = {
+    async send(request) {
+        request.commitTracker.markCommitted();
+        const sent = JSON.parse(new TextDecoder().decode(request.bodyBytes));
+        const bodyBytes = new TextEncoder().encode(JSON.stringify({ id: "msg_stub", ...sent }));
+        return {
+            kind: "response",
+            status: 202,
+            headers: { "content-type": ["application/json"] },
+            bodyBytes,
+            compressedBytes: bodyBytes.length,
+            decompressedBytes: bodyBytes.length,
+            truncated: false,
+        };
+    },
+};
+/**
+ * Build the webhooks method tree from the generated schema descriptor. The
+ * generated client instantiates this as its typed `Webhooks` interface — the
+ * tree shape is guaranteed by codegen, which emits interface and descriptors
+ * from the same catalog.
+ */
+function buildWebhooks(options, schema) {
+    return buildRuntime(options, schema).webhooks;
+}
+/** Build the generated webhooks tree and its credential-free diagnostics surface. */
+function buildClient(options, schema) {
+    const runtime = buildRuntime(options, schema);
+    return Object.freeze({
+        webhooks: runtime.webhooks,
+        diagnostics: () => runtime.state.diagnostics(),
+        close: runtime.close,
+        [Symbol.for("@repost/client diagnostics seed")]: (counter, value) => {
+            runtime.state.seedDiagnosticCounter(counter, value);
+        },
+    });
+}
+function buildRuntime(options, schema) {
+    assertDescriptorFormat(schema.descriptorFormatVersion);
+    if (schema.descriptorFormatVersion === DESCRIPTOR_FORMAT_VERSION) {
+        assertDescriptorShape(schema);
+    }
+    const snapshot = snapshotOptions(options);
+    const state = new RuntimeState(snapshot.maxInFlightOperations, snapshot.maxBufferedBytes);
+    const operations = createSendOperation(snapshot, schema, state);
+    const tree = {};
+    for (const [group, members] of Object.entries(schema.webhooks)) {
+        const groupTree = {};
+        for (const [member, event] of Object.entries(members)) {
+            groupTree[member] = (input) => operations.send(event, input);
+        }
+        tree[group] = groupTree;
+    }
+    return { webhooks: tree, state, close: operations.close };
+}
+function assertDescriptorShape(schema) {
+    validateModelDescriptors(schema.models, schema.enums);
+    for (const group of Object.keys(schema.webhooks).sort(compareUnicodeScalarValues)) {
+        const members = schema.webhooks[group];
+        if (!members)
+            continue;
+        for (const member of Object.keys(members).sort(compareUnicodeScalarValues)) {
+            const event = members[member];
+            if (event && !Object.prototype.hasOwnProperty.call(schema.models, event.model)) {
+                const path = `${appendPath(appendPath("$.webhooks", group), member)}.model`;
+                throw new Error(`@repost/client: [INVALID_DESCRIPTOR_REFERENCE] ${path}: model descriptor '${event.model}' does not exist.`);
+            }
+        }
+    }
+}
+/**
+ * Refuse a generated client whose descriptor format this runtime does not
+ * implement, with the concrete fix per direction. A package generated before
+ * versioning existed declares nothing — accepted with a one-time warning for
+ * one release.
+ */
+function assertDescriptorFormat(declared) {
+    if (declared === DESCRIPTOR_FORMAT_VERSION) {
+        return;
+    }
+    if (declared === undefined) {
+        if (!warnedPreVersioning) {
+            warnedPreVersioning = true;
+            console.warn("@repost/client: this generated client predates descriptor-format versioning; regenerate it with `repost schema generate`. Support for unversioned clients will be removed in a future release.");
+        }
+        return;
+    }
+    throw new RepostDescriptorVersionError({ errorCode: "DESCRIPTOR_VERSION", deliveryState: "NOT_SENT" });
+}
+
+export { DESCRIPTOR_FORMAT_VERSION as D, RepostPublishError as R, createFetchTransport as a, createHttpTransport as b, classifyNetworkFailure as c, createNodeTransport as d, errorCode as e, RepostConfigurationError as f, RepostDescriptorVersionError as g, httpTransport as h, RepostError as i, RepostSerializationError as j, RepostTransportError as k, RepostValidationError as l, errorCatalog as m, buildClient as n, buildWebhooks as o, stubTransport as p, serializeModel as s };
+//# sourceMappingURL=index-DRD5FBax.mjs.map