@repost/client 0.1.0

package/dist/cjs/index.cjs

@@ -0,0 +1,1049 @@
+'use strict';
+
+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;
+
+/**
+ * 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.
+ */
+function serializeModel(models, modelName, data) {
+    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)) {
+        const got = data === null ? "null" : Array.isArray(data) ? "an array" : typeof data;
+        throw new Error(`@repost/client: expected an object for model \`${modelName}\`, got ${got}.`);
+    }
+    const input = data;
+    const payload = {};
+    for (const field of descriptor.fields) {
+        let value = input[field.name];
+        if (value === undefined) {
+            if (!field.default)
+                continue; // optional and absent — omitted from the wire
+            value = resolveDefault(field.default);
+        }
+        payload[field.wire ?? field.name] = serializeValue(models, field, value);
+    }
+    return payload;
+}
+function serializeValue(models, field, value) {
+    if (field.list && Array.isArray(value)) {
+        return value.map((item) => serializeItem(models, field, item));
+    }
+    return serializeItem(models, field, value);
+}
+function serializeItem(models, field, value) {
+    if (field.model) {
+        return serializeModel(models, field.model, value);
+    }
+    if (field.enum) {
+        const wire = field.enum[value];
+        return wire === undefined ? value : wire;
+    }
+    return value;
+}
+function resolveDefault(spec) {
+    switch (spec.kind) {
+        case "literal":
+            return spec.value;
+        case "now":
+            return new Date().toISOString();
+        case "uuid":
+            return crypto.randomUUID();
+        case "cuid":
+            return createId_1();
+    }
+}
+
+const DEFAULT_API_URL = "https://api.repost.sh";
+const RETRY_AFTER_CAP_MS = 60000;
+const DEFAULT_TIMEOUT_MS = 30000;
+/** The publish API's body cap (publish-api handler.go `MaxBodyBytes`). */
+const MAX_PAYLOAD_BYTES = 1 << 20;
+/** A publish rejected or failed by the Repost API. */
+class RepostPublishError extends Error {
+    constructor(message, status, body) {
+        super(message);
+        this.name = "RepostPublishError";
+        this.status = status;
+        this.body = body;
+    }
+}
+/**
+ * The HTTP transport against Repost's publish API (workstream A).
+ *
+ * One idempotency key is minted per send() and reused across internal
+ * retries, so retrying is always safe: the server deduplicates. Retryable
+ * outcomes are network errors, 5xx, 429, and 409 (a concurrent duplicate
+ * still in flight); Retry-After is honored when present.
+ */
+function createHttpTransport(options = {}) {
+    // Resolved per call, not bound at construction: the default `httpTransport`
+    // is a module-level singleton, and eager binding would freeze whatever
+    // `globalThis.fetch` was at import time — invisible to later patching
+    // (APM instrumentation, test stubs, polyfills).
+    const fetchImpl = options.fetch ?? ((input, init) => globalThis.fetch(input, init));
+    const maxRetries = options.maxRetries ?? 3;
+    const baseDelayMs = options.baseDelayMs ?? 250;
+    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    return {
+        async send(request) {
+            const base = (request.apiUrl ?? DEFAULT_API_URL).replace(/\/+$/, "");
+            const url = `${base}/v1/messages`;
+            const idempotencyKey = request.idempotencyKey ?? generateIdempotencyKey();
+            const body = JSON.stringify({
+                type: request.envelope.type,
+                customerId: request.customerId,
+                timestamp: request.envelope.timestamp,
+                data: request.envelope.data,
+            });
+            // The API rejects oversized bodies with a 413; failing before the first
+            // attempt gives the caller the byte count instead of burned retries.
+            const bodyBytes = new TextEncoder().encode(body).length;
+            if (bodyBytes > MAX_PAYLOAD_BYTES) {
+                throw new RepostPublishError(`publish body is ${bodyBytes} bytes, over the API's 1 MiB (${MAX_PAYLOAD_BYTES}-byte) limit`);
+            }
+            let lastError = new RepostPublishError("publish failed before any attempt");
+            let retryAfterMs;
+            for (let attempt = 0; attempt <= maxRetries; attempt++) {
+                if (attempt > 0) {
+                    await sleep(retryDelayMs(attempt, baseDelayMs, retryAfterMs));
+                }
+                // One timeout budget covers the attempt end to end — connect,
+                // response headers, and body reads — so a hung connection can never
+                // block send() past timeoutMs.
+                const signal = AbortSignal.timeout(timeoutMs);
+                let response;
+                try {
+                    response = await fetchImpl(url, {
+                        method: "POST",
+                        headers: {
+                            authorization: `Bearer ${request.token}`,
+                            "content-type": "application/json",
+                            "idempotency-key": idempotencyKey,
+                        },
+                        body,
+                        signal,
+                    });
+                }
+                catch (error) {
+                    lastError = new RepostPublishError(describeAttemptFailure(error, timeoutMs));
+                    continue;
+                }
+                if (response.ok) {
+                    try {
+                        return (await response.json());
+                    }
+                    catch (error) {
+                        lastError = new RepostPublishError(describeAttemptFailure(error, timeoutMs));
+                        continue;
+                    }
+                }
+                const errorBody = await response.json().catch(() => undefined);
+                retryAfterMs = parseRetryAfterMs(response.headers.get("retry-after"));
+                lastError = new RepostPublishError(`publish failed with status ${response.status}`, response.status, errorBody);
+                const retryable = response.status >= 500 || response.status === 429 || response.status === 409;
+                if (!retryable) {
+                    throw lastError;
+                }
+            }
+            throw lastError;
+        },
+    };
+}
+/** Render an attempt failure, distinguishing our own timeout abort. */
+function describeAttemptFailure(error, timeoutMs) {
+    // AbortSignal.timeout rejects with TimeoutError; some fetch mocks and older
+    // runtimes surface plain AbortError for an aborted signal.
+    if (error instanceof Error && (error.name === "TimeoutError" || error.name === "AbortError")) {
+        return `publish attempt timed out after ${timeoutMs}ms`;
+    }
+    return `publish request failed: ${String(error)}`;
+}
+/** The default transport: real HTTP against the publish API. */
+const httpTransport = createHttpTransport();
+function generateIdempotencyKey() {
+    const cryptoObj = globalThis.crypto;
+    if (typeof cryptoObj.randomUUID === "function") {
+        return cryptoObj.randomUUID();
+    }
+    return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}-${Math.random().toString(36).slice(2)}`;
+}
+function retryDelayMs(attempt, baseDelayMs, retryAfterMs) {
+    const backoff = baseDelayMs * 2 ** (attempt - 1) * (0.5 + Math.random() * 0.5);
+    if (retryAfterMs !== undefined && retryAfterMs > backoff) {
+        return Math.min(retryAfterMs, RETRY_AFTER_CAP_MS);
+    }
+    return backoff;
+}
+function parseRetryAfterMs(header) {
+    if (header === null)
+        return undefined;
+    const seconds = Number(header);
+    if (Number.isFinite(seconds) && seconds >= 0) {
+        return seconds * 1000;
+    }
+    return undefined;
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+/**
+ * No-network transport for tests: echoes the envelope identity as a typed
+ * `SendResult` with a fixed stub message id.
+ */
+const stubTransport = {
+    async send(request) {
+        return {
+            id: "msg_stub",
+            type: request.envelope.type,
+            customerId: request.customerId,
+            timestamp: request.envelope.timestamp,
+        };
+    },
+};
+/**
+ * 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) {
+    const tree = {};
+    for (const [group, members] of Object.entries(schema.webhooks)) {
+        const groupTree = {};
+        for (const [member, event] of Object.entries(members)) {
+            groupTree[member] = (input) => send(options, schema, event, input);
+        }
+        tree[group] = groupTree;
+    }
+    return tree;
+}
+async function send(options, schema, event, input) {
+    // Lazy configuration: resolved (and enforced) at send time, not construction.
+    // First defined value wins: the apiKey option, the deprecated token option,
+    // REPOST_SEND_API_KEY (the standard `.env` variable), then legacy REPOST_TOKEN.
+    const apiKey = options.apiKey ?? options.token ?? process.env.REPOST_SEND_API_KEY ?? process.env.REPOST_TOKEN;
+    if (!apiKey) {
+        throw new Error("@repost/client: missing API key. Pass `apiKey` to createRepostClient() or set the REPOST_SEND_API_KEY environment variable (scaffolded in `.env` by `repost schema init`; create a key with your environment in the dashboard).");
+    }
+    const apiUrl = options.apiUrl ?? process.env.REPOST_API_URL;
+    // The Standard Webhooks envelope: { type, timestamp, data }.
+    const envelope = {
+        type: event.type,
+        timestamp: new Date().toISOString(),
+        data: serializeModel(schema.models, event.model, input.data),
+    };
+    const transport = options.transport ?? httpTransport;
+    return transport.send({
+        token: apiKey,
+        apiUrl,
+        customerId: input.customerId,
+        idempotencyKey: input.idempotencyKey,
+        envelope,
+    });
+}
+
+exports.RepostPublishError = RepostPublishError;
+exports.buildWebhooks = buildWebhooks;
+exports.createHttpTransport = createHttpTransport;
+exports.httpTransport = httpTransport;
+exports.serializeModel = serializeModel;
+exports.stubTransport = stubTransport;
+//# sourceMappingURL=index.cjs.map