@polyester/sdk 0.0.0

package/dist/utils/evm.js

@@ -0,0 +1,53 @@
+import { ConfigurationError } from "../shared/errors.js";
+import { bytesToHex, hexToBytes, utf8ToBytes } from "@noble/hashes/utils.js";
+import { keccak_256 } from "@noble/hashes/sha3.js";
+//#region src/utils/evm.ts
+const ADDRESS_RE = /^0x[0-9a-fA-F]{40}$/;
+/** Format-only address check (viem `isAddress(value, { strict: false })`). */
+function isEvmAddress(value) {
+	return ADDRESS_RE.test(value);
+}
+/**
+* viem `isAddress(value)` default-mode parity: format check plus EIP-55
+* checksum validation for any address that is not all-lowercase.
+*/
+function isEvmAddressStrict(value) {
+	if (!isEvmAddress(value)) return false;
+	const body = value.slice(2);
+	if (body === body.toLowerCase()) return true;
+	return checksumEvmAddress(value) === value;
+}
+/** EIP-55 checksummed address (viem `getAddress`); throws on invalid input. */
+function checksumEvmAddress(value) {
+	if (!isEvmAddress(value)) throw new ConfigurationError(`Invalid EVM address: ${value}`);
+	const lower = value.slice(2).toLowerCase();
+	const hash = keccak_256(utf8ToBytes(lower));
+	let out = "0x";
+	for (let i = 0; i < 40; i++) {
+		const char = lower[i];
+		const nibble = hash[i >> 1] >> (i % 2 === 0 ? 4 : 0) & 15;
+		out += nibble >= 8 ? char.toUpperCase() : char;
+	}
+	return out;
+}
+/** keccak-256 of raw bytes, hex-encoded (viem `keccak256(bytes)`). */
+function keccak256Hex(bytes) {
+	return `0x${bytesToHex(keccak_256(bytes))}`;
+}
+/** UTF-8 encode (viem `stringToBytes`). */
+function evmUtf8ToBytes(value) {
+	return utf8ToBytes(value);
+}
+/** UTF-8 string to 0x-prefixed hex (viem `stringToHex`). */
+function evmUtf8ToHex(value) {
+	return `0x${bytesToHex(utf8ToBytes(value))}`;
+}
+/** 0x-prefixed hex to bytes (viem `hexToBytes`); throws on malformed input. */
+function evmHexToBytes(value) {
+	if (!/^0x(?:[0-9a-fA-F]{2})*$/.test(value)) throw new ConfigurationError(`Invalid hex value: ${value}`);
+	return hexToBytes(value.slice(2).toLowerCase());
+}
+//#endregion
+export { checksumEvmAddress, evmHexToBytes, evmUtf8ToBytes, evmUtf8ToHex, isEvmAddress, isEvmAddressStrict, keccak256Hex };
+
+//# sourceMappingURL=evm.js.map

package/dist/utils/evm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"evm.js","names":["nobleHexToBytes"],"sources":["../../src/utils/evm.ts"],"sourcesContent":["import { keccak_256 } from \"@noble/hashes/sha3.js\";\nimport { bytesToHex, hexToBytes as nobleHexToBytes, utf8ToBytes } from \"@noble/hashes/utils.js\";\nimport { ConfigurationError } from \"../shared/errors.js\";\n\n/**\n * Minimal EVM helpers backed by @noble/hashes.\n *\n * The SDK core previously imported these five utilities from viem. Rolldown\n * groups all shared viem modules into a single chunk, so those tiny static\n * imports forced viem's entire abi/actions graph (~270 KB emitted) into the\n * app shell and the server's eager exec path, even though everything heavy is\n * loaded lazily. Semantics mirror the viem calls they replaced:\n * `isAddress(x, { strict: false })`, `getAddress`, `keccak256`,\n * `stringToBytes`, `hexToBytes`.\n */\n\nexport type EvmHex = `0x${string}`;\n\nconst ADDRESS_RE = /^0x[0-9a-fA-F]{40}$/;\n\n/** Format-only address check (viem `isAddress(value, { strict: false })`). */\nexport function isEvmAddress(value: string): value is EvmHex {\n    return ADDRESS_RE.test(value);\n}\n\n/**\n * viem `isAddress(value)` default-mode parity: format check plus EIP-55\n * checksum validation for any address that is not all-lowercase.\n */\nexport function isEvmAddressStrict(value: string): value is EvmHex {\n    if (!isEvmAddress(value)) return false;\n    const body = value.slice(2);\n    // viem only exempts all-lowercase addresses from checksum validation.\n    if (body === body.toLowerCase()) return true;\n    return checksumEvmAddress(value) === value;\n}\n\n/** EIP-55 checksummed address (viem `getAddress`); throws on invalid input. */\nexport function checksumEvmAddress(value: string): EvmHex {\n    if (!isEvmAddress(value)) {\n        throw new ConfigurationError(`Invalid EVM address: ${value}`);\n    }\n    const lower = value.slice(2).toLowerCase();\n    const hash = keccak_256(utf8ToBytes(lower));\n    let out = \"0x\";\n    for (let i = 0; i < 40; i++) {\n        const char = lower[i]!;\n        // Each hash byte covers two nibbles of the address.\n        const nibble = (hash[i >> 1]! >> (i % 2 === 0 ? 4 : 0)) & 0x0f;\n        out += nibble >= 8 ? char.toUpperCase() : char;\n    }\n    return out as EvmHex;\n}\n\n/** keccak-256 of raw bytes, hex-encoded (viem `keccak256(bytes)`). */\nexport function keccak256Hex(bytes: Uint8Array): EvmHex {\n    return `0x${bytesToHex(keccak_256(bytes))}`;\n}\n\n/** UTF-8 encode (viem `stringToBytes`). */\nexport function evmUtf8ToBytes(value: string): Uint8Array {\n    return utf8ToBytes(value);\n}\n\n/** UTF-8 string to 0x-prefixed hex (viem `stringToHex`). */\nexport function evmUtf8ToHex(value: string): EvmHex {\n    return `0x${bytesToHex(utf8ToBytes(value))}`;\n}\n\n/** 0x-prefixed hex to bytes (viem `hexToBytes`); throws on malformed input. */\nexport function evmHexToBytes(value: string): Uint8Array {\n    if (!/^0x(?:[0-9a-fA-F]{2})*$/.test(value)) {\n        throw new ConfigurationError(`Invalid hex value: ${value}`);\n    }\n    return nobleHexToBytes(value.slice(2).toLowerCase());\n}\n"],"mappings":";;;;AAkBA,MAAM,aAAa;;AAGnB,SAAgB,aAAa,OAAgC;CACzD,OAAO,WAAW,KAAK,KAAK;AAChC;;;;;AAMA,SAAgB,mBAAmB,OAAgC;CAC/D,IAAI,CAAC,aAAa,KAAK,GAAG,OAAO;CACjC,MAAM,OAAO,MAAM,MAAM,CAAC;CAE1B,IAAI,SAAS,KAAK,YAAY,GAAG,OAAO;CACxC,OAAO,mBAAmB,KAAK,MAAM;AACzC;;AAGA,SAAgB,mBAAmB,OAAuB;CACtD,IAAI,CAAC,aAAa,KAAK,GACnB,MAAM,IAAI,mBAAmB,wBAAwB,OAAO;CAEhE,MAAM,QAAQ,MAAM,MAAM,CAAC,CAAC,CAAC,YAAY;CACzC,MAAM,OAAO,WAAW,YAAY,KAAK,CAAC;CAC1C,IAAI,MAAM;CACV,KAAK,IAAI,IAAI,GAAG,IAAI,IAAI,KAAK;EACzB,MAAM,OAAO,MAAM;EAEnB,MAAM,SAAU,KAAK,KAAK,OAAQ,IAAI,MAAM,IAAI,IAAI,KAAM;EAC1D,OAAO,UAAU,IAAI,KAAK,YAAY,IAAI;CAC9C;CACA,OAAO;AACX;;AAGA,SAAgB,aAAa,OAA2B;CACpD,OAAO,KAAK,WAAW,WAAW,KAAK,CAAC;AAC5C;;AAGA,SAAgB,eAAe,OAA2B;CACtD,OAAO,YAAY,KAAK;AAC5B;;AAGA,SAAgB,aAAa,OAAuB;CAChD,OAAO,KAAK,WAAW,YAAY,KAAK,CAAC;AAC7C;;AAGA,SAAgB,cAAc,OAA2B;CACrD,IAAI,CAAC,0BAA0B,KAAK,KAAK,GACrC,MAAM,IAAI,mBAAmB,sBAAsB,OAAO;CAE9D,OAAOA,WAAgB,MAAM,MAAM,CAAC,CAAC,CAAC,YAAY,CAAC;AACvD"}

package/dist/utils/is-dev.js

@@ -0,0 +1,57 @@
+//#region src/utils/is-dev.ts
+/**
+* Checks if the current environment is development.
+* Uses local-only hostnames to determine if the current environment is development.
+* If the current environment is not a browser environment, it returns false.
+* If the current environment is a browser environment, it checks if the hostname is localhost or loopback.
+* If any of the conditions are true, it returns true.
+* Otherwise, it returns false.
+*
+* @returns true if the current environment is development
+*/
+function parseIpv4(hostname) {
+	const parts = hostname.split(".");
+	if (parts.length !== 4) return null;
+	const octets = [];
+	for (const part of parts) {
+		if (!/^\d{1,3}$/.test(part)) return null;
+		const octet = Number(part);
+		if (octet > 255) return null;
+		octets.push(octet);
+	}
+	return octets;
+}
+function isLoopbackIpv4(hostname) {
+	return parseIpv4(hostname)?.[0] === 127;
+}
+/** RFC 1918 private IPv4 ranges: 10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16. */
+function isPrivateIpv4(hostname) {
+	const octets = parseIpv4(hostname);
+	if (!octets) return false;
+	const [first, second] = octets;
+	return first === 10 || first === 192 && second === 168 || first === 172 && second >= 16 && second <= 31;
+}
+function isLocalhostName(hostname) {
+	return hostname === "localhost" || hostname.endsWith(".localhost") || hostname === "::1" || hostname === "[::1]" || isLoopbackIpv4(hostname);
+}
+/**
+* Checks whether the current runtime appears to be a development environment.
+*/
+function isDev() {
+	if (typeof window === "undefined") return false;
+	return isLocalhostName(window.location.hostname.toLowerCase());
+}
+/**
+* True for hostnames only reachable on a developer's machine or local network:
+* everything `isDev()` accepts plus RFC 1918 private IPv4 addresses, which is
+* how phones reach a dev server over LAN. Production hostnames are public
+* domains and never match.
+*/
+function isLocalNetworkHost(hostname) {
+	const lowered = hostname.toLowerCase();
+	return isLocalhostName(lowered) || isPrivateIpv4(lowered);
+}
+//#endregion
+export { isDev, isLocalNetworkHost };
+
+//# sourceMappingURL=is-dev.js.map

package/dist/utils/is-dev.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-dev.js","names":[],"sources":["../../src/utils/is-dev.ts"],"sourcesContent":["/**\n * Checks if the current environment is development.\n * Uses local-only hostnames to determine if the current environment is development.\n * If the current environment is not a browser environment, it returns false.\n * If the current environment is a browser environment, it checks if the hostname is localhost or loopback.\n * If any of the conditions are true, it returns true.\n * Otherwise, it returns false.\n *\n * @returns true if the current environment is development\n */\nfunction parseIpv4(hostname: string): number[] | null {\n    const parts = hostname.split(\".\");\n    if (parts.length !== 4) return null;\n\n    const octets: number[] = [];\n    for (const part of parts) {\n        if (!/^\\d{1,3}$/.test(part)) return null;\n        const octet = Number(part);\n        if (octet > 255) return null;\n        octets.push(octet);\n    }\n    return octets;\n}\n\nfunction isLoopbackIpv4(hostname: string): boolean {\n    return parseIpv4(hostname)?.[0] === 127;\n}\n\n/** RFC 1918 private IPv4 ranges: 10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16. */\nfunction isPrivateIpv4(hostname: string): boolean {\n    const octets = parseIpv4(hostname);\n    if (!octets) return false;\n    const [first, second] = octets as [number, number, number, number];\n    return (\n        first === 10 ||\n        (first === 192 && second === 168) ||\n        (first === 172 && second >= 16 && second <= 31)\n    );\n}\n\nfunction isLocalhostName(hostname: string): boolean {\n    return (\n        hostname === \"localhost\" ||\n        hostname.endsWith(\".localhost\") ||\n        hostname === \"::1\" ||\n        hostname === \"[::1]\" ||\n        isLoopbackIpv4(hostname)\n    );\n}\n\n/**\n * Checks whether the current runtime appears to be a development environment.\n */\nexport function isDev(): boolean {\n    if (typeof window === \"undefined\") return false;\n    return isLocalhostName(window.location.hostname.toLowerCase());\n}\n\n/**\n * True for hostnames only reachable on a developer's machine or local network:\n * everything `isDev()` accepts plus RFC 1918 private IPv4 addresses, which is\n * how phones reach a dev server over LAN. Production hostnames are public\n * domains and never match.\n */\nexport function isLocalNetworkHost(hostname: string): boolean {\n    const lowered = hostname.toLowerCase();\n    return isLocalhostName(lowered) || isPrivateIpv4(lowered);\n}\n"],"mappings":";;;;;;;;;;;AAUA,SAAS,UAAU,UAAmC;CAClD,MAAM,QAAQ,SAAS,MAAM,GAAG;CAChC,IAAI,MAAM,WAAW,GAAG,OAAO;CAE/B,MAAM,SAAmB,CAAC;CAC1B,KAAK,MAAM,QAAQ,OAAO;EACtB,IAAI,CAAC,YAAY,KAAK,IAAI,GAAG,OAAO;EACpC,MAAM,QAAQ,OAAO,IAAI;EACzB,IAAI,QAAQ,KAAK,OAAO;EACxB,OAAO,KAAK,KAAK;CACrB;CACA,OAAO;AACX;AAEA,SAAS,eAAe,UAA2B;CAC/C,OAAO,UAAU,QAAQ,CAAC,GAAG,OAAO;AACxC;;AAGA,SAAS,cAAc,UAA2B;CAC9C,MAAM,SAAS,UAAU,QAAQ;CACjC,IAAI,CAAC,QAAQ,OAAO;CACpB,MAAM,CAAC,OAAO,UAAU;CACxB,OACI,UAAU,MACT,UAAU,OAAO,WAAW,OAC5B,UAAU,OAAO,UAAU,MAAM,UAAU;AAEpD;AAEA,SAAS,gBAAgB,UAA2B;CAChD,OACI,aAAa,eACb,SAAS,SAAS,YAAY,KAC9B,aAAa,SACb,aAAa,WACb,eAAe,QAAQ;AAE/B;;;;AAKA,SAAgB,QAAiB;CAC7B,IAAI,OAAO,WAAW,aAAa,OAAO;CAC1C,OAAO,gBAAgB,OAAO,SAAS,SAAS,YAAY,CAAC;AACjE;;;;;;;AAQA,SAAgB,mBAAmB,UAA2B;CAC1D,MAAM,UAAU,SAAS,YAAY;CACrC,OAAO,gBAAgB,OAAO,KAAK,cAAc,OAAO;AAC5D"}

package/dist/utils/jwt.d.ts

@@ -0,0 +1,8 @@
+//#region src/utils/jwt.d.ts
+/**
+ * Checks whether a JWT is present, well formed, and not expired.
+ */
+declare function isJwtValid(token: string | null): token is string;
+//#endregion
+export { isJwtValid };
+//# sourceMappingURL=jwt.d.ts.map

package/dist/utils/jwt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jwt.d.ts","names":[],"sources":["../../src/utils/jwt.ts"],"mappings":";;;;iBA6DgB,WAAW,uBAAuB"}

package/dist/utils/jwt.js

@@ -0,0 +1,74 @@
+//#region src/utils/jwt.ts
+/**
+* Checks whether a string has the shape of a JWT.
+*/
+function isJwt(token) {
+	const parts = token.split(".");
+	return parts.length === 3 && !!parts[0] && !!parts[1] && !!parts[2];
+}
+let textDecoder;
+/**
+* Gets a TextDecoder instance.
+*/
+function getTextDecoder() {
+	textDecoder ??= new TextDecoder("utf-8", { fatal: true });
+	return textDecoder;
+}
+function decodeBase64Url(value) {
+	const remainder = value.length % 4;
+	if (remainder === 1) return null;
+	const base64 = value.replace(/-/g, "+").replace(/_/g, "/");
+	const paddedBase64 = remainder === 0 ? base64 : base64.padEnd(base64.length + 4 - remainder, "=");
+	const binary = atob(paddedBase64);
+	const bytes = Uint8Array.from(binary, (character) => character.charCodeAt(0));
+	return getTextDecoder().decode(bytes);
+}
+/**
+* Reads a JWT expiration timestamp when present.
+*/
+function getJwtExpiration(token) {
+	try {
+		const [_, rawPayload] = token.split(".");
+		if (!rawPayload) return null;
+		const decodedPayload = decodeBase64Url(rawPayload);
+		if (!decodedPayload) return null;
+		const payload = JSON.parse(decodedPayload);
+		if (typeof payload !== "object" || payload === null) return null;
+		const exp = payload.exp;
+		return typeof exp === "number" ? exp : null;
+	} catch {
+		return null;
+	}
+}
+/**
+* Checks whether a JWT is expired.
+*/
+function isJwtExpired(token) {
+	const exp = getJwtExpiration(token);
+	if (exp === null) return true;
+	return exp < Math.floor(Date.now() / 1e3);
+}
+/**
+* Checks whether a JWT is present, well formed, and not expired.
+*/
+function isJwtValid(token) {
+	if (!token) return false;
+	if (!isJwt(token)) return false;
+	if (isJwtExpired(token)) return false;
+	return true;
+}
+/**
+* Returns the number of milliseconds until the JWT expires.
+* Returns 0 if already expired or invalid.
+*/
+function getJwtTimeToExpiry(token) {
+	const exp = getJwtExpiration(token);
+	if (exp === null) return 0;
+	const nowMs = Date.now();
+	const expiresAtMs = exp * 1e3;
+	return Math.max(0, expiresAtMs - nowMs);
+}
+//#endregion
+export { getJwtExpiration, getJwtTimeToExpiry, isJwt, isJwtExpired, isJwtValid };
+
+//# sourceMappingURL=jwt.js.map

package/dist/utils/jwt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"jwt.js","names":[],"sources":["../../src/utils/jwt.ts"],"sourcesContent":["/**\n * Checks whether a string has the shape of a JWT.\n */\nexport function isJwt(token: string): boolean {\n    const parts = token.split(\".\");\n    return parts.length === 3 && !!parts[0] && !!parts[1] && !!parts[2];\n}\n\nlet textDecoder: TextDecoder | undefined;\n\n/**\n * Gets a TextDecoder instance.\n */\nfunction getTextDecoder(): TextDecoder {\n    textDecoder ??= new TextDecoder(\"utf-8\", { fatal: true });\n    return textDecoder;\n}\n\nfunction decodeBase64Url(value: string): string | null {\n    const remainder = value.length % 4;\n    if (remainder === 1) return null;\n\n    const base64 = value.replace(/-/g, \"+\").replace(/_/g, \"/\");\n    const paddedBase64 =\n        remainder === 0 ? base64 : base64.padEnd(base64.length + 4 - remainder, \"=\");\n    const binary = atob(paddedBase64);\n    const bytes = Uint8Array.from(binary, (character) => character.charCodeAt(0));\n    return getTextDecoder().decode(bytes);\n}\n\n/**\n * Reads a JWT expiration timestamp when present.\n */\nexport function getJwtExpiration(token: string): number | null {\n    try {\n        const [_, rawPayload] = token.split(\".\");\n        if (!rawPayload) return null;\n        const decodedPayload = decodeBase64Url(rawPayload);\n        if (!decodedPayload) return null;\n        const payload: unknown = JSON.parse(decodedPayload);\n        if (typeof payload !== \"object\" || payload === null) return null;\n        const exp = (payload as { exp?: unknown }).exp;\n        return typeof exp === \"number\" ? exp : null;\n    } catch {\n        return null;\n    }\n}\n\n/**\n * Checks whether a JWT is expired.\n */\nexport function isJwtExpired(token: string): boolean {\n    const exp = getJwtExpiration(token);\n    if (exp === null) return true;\n    const currentTime = Math.floor(Date.now() / 1000);\n    return exp < currentTime;\n}\n\n/**\n * Checks whether a JWT is present, well formed, and not expired.\n */\nexport function isJwtValid(token: string | null): token is string {\n    if (!token) return false;\n    if (!isJwt(token)) return false;\n    if (isJwtExpired(token)) return false;\n    return true;\n}\n\n/**\n * Returns the number of milliseconds until the JWT expires.\n * Returns 0 if already expired or invalid.\n */\nexport function getJwtTimeToExpiry(token: string): number {\n    const exp = getJwtExpiration(token);\n    if (exp === null) return 0;\n    const nowMs = Date.now();\n    const expiresAtMs = exp * 1000;\n    return Math.max(0, expiresAtMs - nowMs);\n}\n"],"mappings":";;;;AAGA,SAAgB,MAAM,OAAwB;CAC1C,MAAM,QAAQ,MAAM,MAAM,GAAG;CAC7B,OAAO,MAAM,WAAW,KAAK,CAAC,CAAC,MAAM,MAAM,CAAC,CAAC,MAAM,MAAM,CAAC,CAAC,MAAM;AACrE;AAEA,IAAI;;;;AAKJ,SAAS,iBAA8B;CACnC,gBAAgB,IAAI,YAAY,SAAS,EAAE,OAAO,KAAK,CAAC;CACxD,OAAO;AACX;AAEA,SAAS,gBAAgB,OAA8B;CACnD,MAAM,YAAY,MAAM,SAAS;CACjC,IAAI,cAAc,GAAG,OAAO;CAE5B,MAAM,SAAS,MAAM,QAAQ,MAAM,GAAG,CAAC,CAAC,QAAQ,MAAM,GAAG;CACzD,MAAM,eACF,cAAc,IAAI,SAAS,OAAO,OAAO,OAAO,SAAS,IAAI,WAAW,GAAG;CAC/E,MAAM,SAAS,KAAK,YAAY;CAChC,MAAM,QAAQ,WAAW,KAAK,SAAS,cAAc,UAAU,WAAW,CAAC,CAAC;CAC5E,OAAO,eAAe,CAAC,CAAC,OAAO,KAAK;AACxC;;;;AAKA,SAAgB,iBAAiB,OAA8B;CAC3D,IAAI;EACA,MAAM,CAAC,GAAG,cAAc,MAAM,MAAM,GAAG;EACvC,IAAI,CAAC,YAAY,OAAO;EACxB,MAAM,iBAAiB,gBAAgB,UAAU;EACjD,IAAI,CAAC,gBAAgB,OAAO;EAC5B,MAAM,UAAmB,KAAK,MAAM,cAAc;EAClD,IAAI,OAAO,YAAY,YAAY,YAAY,MAAM,OAAO;EAC5D,MAAM,MAAO,QAA8B;EAC3C,OAAO,OAAO,QAAQ,WAAW,MAAM;CAC3C,QAAQ;EACJ,OAAO;CACX;AACJ;;;;AAKA,SAAgB,aAAa,OAAwB;CACjD,MAAM,MAAM,iBAAiB,KAAK;CAClC,IAAI,QAAQ,MAAM,OAAO;CAEzB,OAAO,MADa,KAAK,MAAM,KAAK,IAAI,IAAI,GACrB;AAC3B;;;;AAKA,SAAgB,WAAW,OAAuC;CAC9D,IAAI,CAAC,OAAO,OAAO;CACnB,IAAI,CAAC,MAAM,KAAK,GAAG,OAAO;CAC1B,IAAI,aAAa,KAAK,GAAG,OAAO;CAChC,OAAO;AACX;;;;;AAMA,SAAgB,mBAAmB,OAAuB;CACtD,MAAM,MAAM,iBAAiB,KAAK;CAClC,IAAI,QAAQ,MAAM,OAAO;CACzB,MAAM,QAAQ,KAAK,IAAI;CACvB,MAAM,cAAc,MAAM;CAC1B,OAAO,KAAK,IAAI,GAAG,cAAc,KAAK;AAC1C"}

package/dist/utils/numbers.js

@@ -0,0 +1,60 @@
+//#region src/utils/numbers.ts
+/**
+* Parse an optional uint64 encoded as a base-10 string into bigint.
+* Empty values are omitted, but supplied invalid values are rejected.
+*/
+function parseOptionalUint64DecimalStrict(raw, fieldName) {
+	const s = (raw ?? "").trim();
+	if (!s) return;
+	if (!/^[0-9]+$/.test(s)) throw new Error(`${fieldName} must be a positive integer`);
+	return BigInt(s);
+}
+/**
+* Parse an optional positive integer-ish value (string/number) into a number, or undefined on invalid/empty.
+* Useful for common "limit" fields coming from UI inputs.
+*/
+function parseOptionalPositiveIntLike(value) {
+	if (value === void 0 || value === null) return void 0;
+	const n = typeof value === "string" ? Number(value.trim()) : value;
+	return Number.isInteger(n) && n > 0 ? n : void 0;
+}
+/**
+* Coerce optional UI number into non-negative bigint (e.g. caps, limits).
+* @param value - The value to coerce.
+* @returns The coerced bigint.
+*/
+function toBigIntOrZero(value) {
+	if (value == null || Number.isNaN(value)) return 0n;
+	return BigInt(Math.max(0, Math.trunc(value)));
+}
+/**
+* Coerce optional UI number into non-negative integer.
+* @param value - The value to coerce.
+* @returns The coerced integer.
+*/
+function toIntOrZero(value) {
+	if (value == null || Number.isNaN(value)) return 0;
+	return Math.max(0, Math.trunc(value));
+}
+/**
+* Coerce optional UI percentage into non-negative basis points integer.
+* @param value - The value to coerce.
+* @returns The coerced integer.
+*/
+function toBpsOrZero(value) {
+	if (value == null || Number.isNaN(value)) return 0;
+	return Math.max(0, Math.trunc(value * 100));
+}
+/**
+* Convert basis points to percentage.
+* @param value - The value to convert.
+* @returns The converted percentage.
+*/
+function bpsToPct(value) {
+	if (value == null || Number.isNaN(value)) return 0;
+	return value / 100;
+}
+//#endregion
+export { bpsToPct, parseOptionalPositiveIntLike, parseOptionalUint64DecimalStrict, toBigIntOrZero, toBpsOrZero, toIntOrZero };
+
+//# sourceMappingURL=numbers.js.map

package/dist/utils/numbers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"numbers.js","names":[],"sources":["../../src/utils/numbers.ts"],"sourcesContent":["// Shared numeric helpers for gRPC/Connect clients.\n\n/**\n * Parse a required uint64 encoded as a base-10 string into bigint.\n * @param raw - The raw string to parse.\n * @param fieldName - The name of the field to parse.\n * @returns The parsed bigint.\n * @throws An error if the field is required and not provided.\n * @throws An error if the field is not a positive integer.\n */\nexport function parseRequiredUint64Decimal(raw: string, fieldName: string): bigint {\n    const s = (raw ?? \"\").trim();\n    if (!s) throw new Error(`${fieldName} is required`);\n    if (!/^[0-9]+$/.test(s)) throw new Error(`${fieldName} must be a positive integer`);\n    return BigInt(s);\n}\n\n/**\n * Parse an optional uint64 encoded as a base-10 string into bigint, or undefined on invalid/empty.\n * @param raw - The raw string to parse.\n * @returns The parsed bigint, or undefined if the field is invalid or empty.\n */\nexport function parseOptionalUint64Decimal(raw: string | undefined): bigint | undefined {\n    const s = (raw ?? \"\").trim();\n    if (!s) return;\n    // For optional filters, treat invalid input as \"unset\" rather than surfacing an error.\n    if (!/^[0-9]+$/.test(s)) return;\n    return BigInt(s);\n}\n\n/**\n * Parse an optional uint64 encoded as a base-10 string into bigint.\n * Empty values are omitted, but supplied invalid values are rejected.\n */\nexport function parseOptionalUint64DecimalStrict(\n    raw: string | undefined,\n    fieldName: string,\n): bigint | undefined {\n    const s = (raw ?? \"\").trim();\n    if (!s) return;\n    if (!/^[0-9]+$/.test(s)) throw new Error(`${fieldName} must be a positive integer`);\n    return BigInt(s);\n}\n\n/**\n * Parse an optional uint64-ish value (string/number/bigint) into bigint, or undefined on invalid/empty.\n * Accepts base-10 strings, numeric inputs (truncated), and bigint inputs.\n */\nexport function parseOptionalUint64Like(\n    value: string | number | bigint | undefined | null,\n): bigint | undefined {\n    if (value === undefined || value === null) return undefined;\n    if (typeof value === \"bigint\") return value >= 0n ? value : undefined;\n    if (typeof value === \"number\") {\n        if (!Number.isFinite(value)) return undefined;\n        const n = Math.trunc(value);\n        return n >= 0 ? BigInt(n) : undefined;\n    }\n    return parseOptionalUint64Decimal(value);\n}\n\n/**\n * Parse an optional positive integer-ish value (string/number) into a number, or undefined on invalid/empty.\n * Useful for common \"limit\" fields coming from UI inputs.\n */\nexport function parseOptionalPositiveIntLike(\n    value: string | number | undefined | null,\n): number | undefined {\n    if (value === undefined || value === null) return undefined;\n    const n = typeof value === \"string\" ? Number(value.trim()) : value;\n    return Number.isInteger(n) && n > 0 ? n : undefined;\n}\n\n/**\n * Convert a decimal string into a scaled bigint (e.g. 18dp quantity, 6dp price).\n * @param raw - The raw string to parse.\n * @param scale - The scale of the number.\n * @param fieldName - The name of the field to parse.\n * @returns The parsed bigint.\n * @throws An error if the field is required and not provided.\n * @throws An error if the field is not a positive number.\n */\nexport function decimalToScaledInt(raw: string, scale: number, fieldName: string): bigint {\n    const s = (raw ?? \"\").trim();\n    if (!s) throw new Error(`${fieldName} is required`);\n    if (!/^[0-9]+(\\.[0-9]+)?$/.test(s)) throw new Error(`${fieldName} must be a positive number`);\n    const [intPartRaw, fracRaw = \"\"] = s.split(\".\");\n    if (fracRaw.length > scale) {\n        throw new Error(`${fieldName} supports at most ${scale} decimal places`);\n    }\n    const intPart = intPartRaw?.replace(/^0+/, \"\") ?? \"0\";\n    const fracPart = fracRaw.padEnd(scale, \"0\");\n    const combined = `${intPart}${fracPart}`;\n    return BigInt(combined ?? \"0\");\n}\n\n/**\n * Parse a quantity scaled to the given number of decimal places.\n * @param raw - The raw string to parse.\n * @param scale - The number of decimal places to scale to.\n * @param fieldName - The name of the field to parse.\n * @returns The parsed bigint.\n * @throws An error if the field is required and not provided.\n * @throws An error if the field is not a positive number.\n */\nexport function parseQtyScaled(raw: string, scale: number, fieldName: string): bigint {\n    return decimalToScaledInt(raw, scale, fieldName);\n}\n\n/**\n * Parse a price scaled to 6 decimal places.\n * @param raw - The raw string to parse.\n * @param fieldName - The name of the field to parse.\n * @returns The parsed bigint.\n * @throws An error if the field is required and not provided.\n * @throws An error if the field is not a positive number.\n */\nexport function parsePriceTicks(raw: string, fieldName: string): bigint {\n    return decimalToScaledInt(raw, 6, fieldName);\n}\n\n/**\n * Coerce optional UI number into non-negative bigint (e.g. caps, limits).\n * @param value - The value to coerce.\n * @returns The coerced bigint.\n */\nexport function toBigIntOrZero(value?: number | null): bigint {\n    if (value == null || Number.isNaN(value)) return 0n;\n    return BigInt(Math.max(0, Math.trunc(value)));\n}\n\n/**\n * Coerce optional UI number into non-negative integer.\n * @param value - The value to coerce.\n * @returns The coerced integer.\n */\nexport function toIntOrZero(value?: number | null): number {\n    if (value == null || Number.isNaN(value)) return 0;\n    return Math.max(0, Math.trunc(value));\n}\n\n/**\n * Coerce optional UI percentage into non-negative basis points integer.\n * @param value - The value to coerce.\n * @returns The coerced integer.\n */\nexport function toBpsOrZero(value?: number | null): number {\n    if (value == null || Number.isNaN(value)) return 0;\n    return Math.max(0, Math.trunc(value * 100));\n}\n\n/**\n * Convert basis points to percentage.\n * @param value - The value to convert.\n * @returns The converted percentage.\n */\nexport function bpsToPct(value?: number | null): number {\n    if (value == null || Number.isNaN(value)) return 0;\n    return value / 100;\n}\n"],"mappings":";;;;;AAkCA,SAAgB,iCACZ,KACA,WACkB;CAClB,MAAM,KAAK,OAAO,GAAA,CAAI,KAAK;CAC3B,IAAI,CAAC,GAAG;CACR,IAAI,CAAC,WAAW,KAAK,CAAC,GAAG,MAAM,IAAI,MAAM,GAAG,UAAU,4BAA4B;CAClF,OAAO,OAAO,CAAC;AACnB;;;;;AAuBA,SAAgB,6BACZ,OACkB;CAClB,IAAI,UAAU,KAAA,KAAa,UAAU,MAAM,OAAO,KAAA;CAClD,MAAM,IAAI,OAAO,UAAU,WAAW,OAAO,MAAM,KAAK,CAAC,IAAI;CAC7D,OAAO,OAAO,UAAU,CAAC,KAAK,IAAI,IAAI,IAAI,KAAA;AAC9C;;;;;;AAuDA,SAAgB,eAAe,OAA+B;CAC1D,IAAI,SAAS,QAAQ,OAAO,MAAM,KAAK,GAAG,OAAO;CACjD,OAAO,OAAO,KAAK,IAAI,GAAG,KAAK,MAAM,KAAK,CAAC,CAAC;AAChD;;;;;;AAOA,SAAgB,YAAY,OAA+B;CACvD,IAAI,SAAS,QAAQ,OAAO,MAAM,KAAK,GAAG,OAAO;CACjD,OAAO,KAAK,IAAI,GAAG,KAAK,MAAM,KAAK,CAAC;AACxC;;;;;;AAOA,SAAgB,YAAY,OAA+B;CACvD,IAAI,SAAS,QAAQ,OAAO,MAAM,KAAK,GAAG,OAAO;CACjD,OAAO,KAAK,IAAI,GAAG,KAAK,MAAM,QAAQ,GAAG,CAAC;AAC9C;;;;;;AAOA,SAAgB,SAAS,OAA+B;CACpD,IAAI,SAAS,QAAQ,OAAO,MAAM,KAAK,GAAG,OAAO;CACjD,OAAO,QAAQ;AACnB"}

package/dist/utils/proto-patch.js

@@ -0,0 +1,29 @@
+//#region src/utils/proto-patch.ts
+/**
+* Define the public-to-proto mapping for every field in a PATCH input.
+*
+* Keeping the encoder and FieldMask path together prevents their presence checks from drifting.
+*/
+function defineProtoPatchFields() {
+	return (fields) => fields;
+}
+/** Build a proto PATCH value and FieldMask in one allocation-conscious pass. */
+function buildProtoPatch(input, fields) {
+	const patch = {};
+	const paths = [];
+	for (const key of Object.keys(fields)) {
+		const value = input[key];
+		if (value === void 0) continue;
+		const field = fields[key];
+		Object.assign(patch, field.encode(value));
+		paths.push(field.path);
+	}
+	return {
+		patch,
+		updateMask: { paths }
+	};
+}
+//#endregion
+export { buildProtoPatch, defineProtoPatchFields };
+
+//# sourceMappingURL=proto-patch.js.map

package/dist/utils/proto-patch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"proto-patch.js","names":[],"sources":["../../src/utils/proto-patch.ts"],"sourcesContent":["type ProtoPatchEncoder<Value> = (value: Value) => Record<string, unknown>;\n\nexport type ProtoPatchFieldMap<Input extends Record<string, unknown>> = {\n    [Key in keyof Input]-?: {\n        path: string;\n        encode: ProtoPatchEncoder<Exclude<Input[Key], undefined>>;\n    };\n};\n\ntype EncodedField<Fields> = Fields[keyof Fields] extends {\n    encode: (...args: never[]) => infer Encoded;\n}\n    ? Encoded\n    : never;\n\ntype UnionToIntersection<Union> = (Union extends unknown ? (value: Union) => void : never) extends (\n    value: infer Intersection,\n) => void\n    ? Intersection\n    : never;\n\ntype ProtoPatchValue<Fields> = Partial<UnionToIntersection<EncodedField<Fields>>>;\n\n/**\n * Define the public-to-proto mapping for every field in a PATCH input.\n *\n * Keeping the encoder and FieldMask path together prevents their presence checks from drifting.\n */\nexport function defineProtoPatchFields<Input extends Record<string, unknown>>() {\n    return <const Fields extends ProtoPatchFieldMap<Input>>(fields: Fields): Fields => fields;\n}\n\n/** Build a proto PATCH value and FieldMask in one allocation-conscious pass. */\nexport function buildProtoPatch<\n    Input extends Record<string, unknown>,\n    const Fields extends ProtoPatchFieldMap<Input>,\n>(\n    input: Input,\n    fields: Fields,\n): { patch: ProtoPatchValue<Fields>; updateMask: { paths: string[] } } {\n    const patch: Record<string, unknown> = {};\n    const paths: string[] = [];\n\n    for (const key of Object.keys(fields) as Array<keyof Fields>) {\n        const value = input[key as keyof Input];\n        if (value === undefined) continue;\n\n        const field = fields[key];\n        Object.assign(patch, field.encode(value as never));\n        paths.push(field.path);\n    }\n\n    return {\n        patch: patch as ProtoPatchValue<Fields>,\n        updateMask: { paths },\n    };\n}\n"],"mappings":";;;;;;AA4BA,SAAgB,yBAAgE;CAC5E,QAAwD,WAA2B;AACvF;;AAGA,SAAgB,gBAIZ,OACA,QACmE;CACnE,MAAM,QAAiC,CAAC;CACxC,MAAM,QAAkB,CAAC;CAEzB,KAAK,MAAM,OAAO,OAAO,KAAK,MAAM,GAA0B;EAC1D,MAAM,QAAQ,MAAM;EACpB,IAAI,UAAU,KAAA,GAAW;EAEzB,MAAM,QAAQ,OAAO;EACrB,OAAO,OAAO,OAAO,MAAM,OAAO,KAAc,CAAC;EACjD,MAAM,KAAK,MAAM,IAAI;CACzB;CAEA,OAAO;EACI;EACP,YAAY,EAAE,MAAM;CACxB;AACJ"}

package/dist/utils/remove-undefined.js

@@ -0,0 +1,12 @@
+//#region src/utils/remove-undefined.ts
+/**
+* Given an object, return a new object with all undefined values removed from it.
+* This is useful for removing undefined values from the object before sending it to the server.
+*/
+function removeUndefined(obj) {
+	return Object.fromEntries(Object.entries(obj).filter(([_, value]) => value !== void 0));
+}
+//#endregion
+export { removeUndefined };
+
+//# sourceMappingURL=remove-undefined.js.map

package/dist/utils/remove-undefined.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"remove-undefined.js","names":[],"sources":["../../src/utils/remove-undefined.ts"],"sourcesContent":["/**\n * Given an object, return a new object with all undefined values removed from it.\n * This is useful for removing undefined values from the object before sending it to the server.\n */\nexport function removeUndefined<T extends Record<string, unknown>>(obj: T): T {\n    return Object.fromEntries(Object.entries(obj).filter(([_, value]) => value !== undefined)) as T;\n}\n"],"mappings":";;;;;AAIA,SAAgB,gBAAmD,KAAW;CAC1E,OAAO,OAAO,YAAY,OAAO,QAAQ,GAAG,CAAC,CAAC,QAAQ,CAAC,GAAG,WAAW,UAAU,KAAA,CAAS,CAAC;AAC7F"}

package/dist/utils/streams.js

@@ -0,0 +1,19 @@
+import { fromBinary } from "@bufbuild/protobuf";
+//#region src/utils/streams.ts
+/**
+* Decode a proto frame from a WS payload.
+* @param schema - The schema to decode the frame into.
+* @param m - The message to decode.
+* @returns The decoded frame, or null if the frame is empty or unsupported.
+* @throws If a binary payload cannot be decoded as the requested schema.
+*/
+function decodeProtoFrame(schema, m) {
+	if (!m) return null;
+	if (m instanceof Uint8Array) return fromBinary(schema, m);
+	if (m && typeof m === "object") return m;
+	return null;
+}
+//#endregion
+export { decodeProtoFrame };
+
+//# sourceMappingURL=streams.js.map

package/dist/utils/streams.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"streams.js","names":[],"sources":["../../src/utils/streams.ts"],"sourcesContent":["import { type DescMessage, type MessageShape, fromBinary } from \"@bufbuild/protobuf\";\n\n/**\n * Decode a proto frame from a WS payload.\n * @param schema - The schema to decode the frame into.\n * @param m - The message to decode.\n * @returns The decoded frame, or null if the frame is empty or unsupported.\n * @throws If a binary payload cannot be decoded as the requested schema.\n */\nexport function decodeProtoFrame<T extends DescMessage>(\n    schema: T,\n    m: Uint8Array | MessageShape<T>,\n): MessageShape<T> | null {\n    if (!m) return null;\n\n    if (m instanceof Uint8Array) return fromBinary(schema, m);\n    if (m && typeof m === \"object\") return m;\n    return null;\n}\n"],"mappings":";;;;;;;;;AASA,SAAgB,iBACZ,QACA,GACsB;CACtB,IAAI,CAAC,GAAG,OAAO;CAEf,IAAI,aAAa,YAAY,OAAO,WAAW,QAAQ,CAAC;CACxD,IAAI,KAAK,OAAO,MAAM,UAAU,OAAO;CACvC,OAAO;AACX"}

package/dist/utils/time.d.ts

@@ -0,0 +1,22 @@
+//#region src/utils/time.d.ts
+/**
+ * Converts a proto timestamp object to epoch milliseconds.
+ */
+type TimestampLike = {
+  seconds?: bigint;
+  nanos?: number;
+};
+type RequiredTimestampLike = {
+  seconds: bigint;
+  nanos?: number;
+};
+/**
+ * Converts a protobuf timestamp to an exact Unix-nanosecond decimal string.
+ * Use this representation for reconciliation fields where millisecond
+ * truncation could collapse two distinct updates.
+ */
+declare function tsObjToNsString(ts: RequiredTimestampLike): string;
+declare function tsObjToNsString(ts: TimestampLike | undefined): string | undefined;
+//#endregion
+export { tsObjToNsString };
+//# sourceMappingURL=time.d.ts.map

package/dist/utils/time.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"time.d.ts","names":[],"sources":["../../src/utils/time.ts"],"mappings":";;;;KA0DK;EAAkB;EAAkB;;KACpC;EAA0B;EAAiB;;;;;;;iBAgBhC,gBAAgB,IAAI;iBACpB,gBAAgB,IAAI"}

package/dist/utils/time.js

@@ -0,0 +1,71 @@
+//#region src/utils/time.ts
+/**
+* Convert epoch nanoseconds (bigint or number) to ISO8601 string for display.
+* @param ts - The timestamp to convert to ISO8601 string.
+* @returns The ISO8601 string.
+*/
+function tsNsToISO(ts) {
+	if (ts === void 0 || ts === null) return "";
+	if (typeof ts === "bigint") try {
+		return new Date(Number(ts / 1000000n)).toISOString();
+	} catch {
+		return ts.toString();
+	}
+	if (typeof ts === "number") {
+		const ms = ts > 0xe8d4a51000 ? Math.floor(ts / 1e6) : ts;
+		return new Date(ms).toISOString();
+	}
+	return "";
+}
+/**
+* Convert epoch nanoseconds (bigint or number) to milliseconds since epoch.
+* @param ts - The timestamp to convert to milliseconds since epoch.
+* @returns The milliseconds since epoch.
+*/
+function tsNsToMs(ts) {
+	if (ts === void 0 || ts === null) return 0;
+	if (typeof ts === "bigint") return Number(ts / 1000000n);
+	if (typeof ts === "number") return Math.floor(ts / 1e6);
+	return 0;
+}
+function tsObjToMs(ts) {
+	if (ts === void 0) return void 0;
+	if (ts.seconds === void 0) return void 0;
+	const nanos = ts.nanos ?? 0;
+	return Number(ts.seconds) * 1e3 + Math.floor(nanos / 1e6);
+}
+function tsObjToNsString(ts) {
+	if (ts?.seconds === void 0) return void 0;
+	return (ts.seconds * 1000000000n + BigInt(ts.nanos ?? 0)).toString();
+}
+/**
+* Normalize a timestamp to milliseconds since epoch.
+* @param input - The timestamp to normalize.
+* @returns The normalized timestamp in milliseconds since epoch.
+*/
+function normalizeToMillis(input) {
+	if (!Number.isFinite(input)) return Date.now();
+	if (input > 0x2386f26fc10000) return Math.floor(input / 1e6);
+	if (input > 0x9184e72a000) return Math.floor(input / 1e3);
+	return Math.floor(input);
+}
+const NS_WIRE_THRESHOLD = 10000000000000000n;
+const US_WIRE_THRESHOLD = 10000000000000n;
+/**
+* Normalizes a ledger-style uint64 wire timestamp to epoch milliseconds.
+* Handles nanoseconds, microseconds, and milliseconds so gRPC and websocket
+* payloads stay consistent even when the backend uses different units.
+*/
+function wireTimestampToMs(ts) {
+	if (ts === void 0 || ts === null) return 0;
+	if (typeof ts === "bigint") {
+		if (ts > NS_WIRE_THRESHOLD) return Number(ts / 1000000n);
+		if (ts > US_WIRE_THRESHOLD) return Number(ts / 1000n);
+		return Number(ts);
+	}
+	return normalizeToMillis(ts);
+}
+//#endregion
+export { normalizeToMillis, tsNsToISO, tsNsToMs, tsObjToMs, tsObjToNsString, wireTimestampToMs };
+
+//# sourceMappingURL=time.js.map

package/dist/utils/time.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"time.js","names":[],"sources":["../../src/utils/time.ts"],"sourcesContent":["// Time helpers for gRPC/Connect models.\n\n/**\n * Convert epoch nanoseconds (bigint or number) to ISO8601 string for display.\n * @param ts - The timestamp to convert to ISO8601 string.\n * @returns The ISO8601 string.\n */\nexport function tsNsToISO(ts: bigint | number | undefined): string {\n    if (ts === undefined || ts === null) return \"\";\n    if (typeof ts === \"bigint\") {\n        // Convert ns -> ms for JS Date; risk of overflow is acceptable for display\n        try {\n            return new Date(Number(ts / 1000000n)).toISOString();\n        } catch {\n            return ts.toString();\n        }\n    }\n    if (typeof ts === \"number\") {\n        // If value looks like ns, downscale to ms\n        const ms = ts > 1e12 ? Math.floor(ts / 1e6) : ts;\n        return new Date(ms).toISOString();\n    }\n    return \"\";\n}\n\n/**\n * Convert epoch nanoseconds (bigint or number) to milliseconds since epoch.\n * @param ts - The timestamp to convert to milliseconds since epoch.\n * @returns The milliseconds since epoch.\n */\nexport function tsNsToMs(ts: bigint | number | undefined): number {\n    if (ts === undefined || ts === null) return 0;\n    if (typeof ts === \"bigint\") return Number(ts / 1000000n);\n    if (typeof ts === \"number\") {\n        // Treat as ns for consistency with tsNsToISO.\n        return Math.floor(ts / 1e6);\n    }\n    return 0;\n}\n\n/**\n * Convert epoch nanoseconds (bigint or number) to whole seconds since epoch.\n * @param ts - The timestamp to convert to seconds since epoch.\n * @returns The seconds since epoch.\n */\nexport function tsNsToSeconds(ts: bigint | number | undefined): number {\n    if (ts === undefined || ts === null) return 0;\n    if (typeof ts === \"bigint\") return Number(ts / 1_000_000_000n);\n    if (typeof ts === \"number\") {\n        // Treat as ns for consistency with tsNsToISO.\n        return Math.floor(ts / 1e9);\n    }\n    return 0;\n}\n\n/**\n * Converts a proto timestamp object to epoch milliseconds.\n */\ntype TimestampLike = { seconds?: bigint; nanos?: number };\ntype RequiredTimestampLike = { seconds: bigint; nanos?: number };\n\nexport function tsObjToMs(ts: RequiredTimestampLike): number;\nexport function tsObjToMs(ts: TimestampLike | undefined): number | undefined;\nexport function tsObjToMs(ts?: TimestampLike): number | undefined {\n    if (ts === undefined) return undefined;\n    if (ts.seconds === undefined) return undefined;\n    const nanos = ts.nanos ?? 0;\n    return Number(ts.seconds) * 1000 + Math.floor(nanos / 1_000_000);\n}\n\n/**\n * Converts a protobuf timestamp to an exact Unix-nanosecond decimal string.\n * Use this representation for reconciliation fields where millisecond\n * truncation could collapse two distinct updates.\n */\nexport function tsObjToNsString(ts: RequiredTimestampLike): string;\nexport function tsObjToNsString(ts: TimestampLike | undefined): string | undefined;\nexport function tsObjToNsString(ts?: TimestampLike): string | undefined {\n    if (ts?.seconds === undefined) return undefined;\n    return (ts.seconds * 1_000_000_000n + BigInt(ts.nanos ?? 0)).toString();\n}\n\n/**\n * Convert epoch microseconds (bigint or number) to milliseconds since epoch.\n */\nexport function tsUsToMs(ts: bigint | number | undefined): number {\n    if (ts === undefined || ts === null) return 0;\n    if (typeof ts === \"bigint\") return Number(ts / 1_000n);\n    return Math.floor(ts / 1_000);\n}\n\n/**\n * Normalize a timestamp to milliseconds since epoch.\n * @param input - The timestamp to normalize.\n * @returns The normalized timestamp in milliseconds since epoch.\n */\nexport function normalizeToMillis(input: number): number {\n    if (!Number.isFinite(input)) return Date.now();\n    // Heuristics: ns -> /1e6, µs -> /1e3, ms -> as-is\n    if (input > 1e16) return Math.floor(input / 1e6);\n    if (input > 1e13) return Math.floor(input / 1e3);\n    return Math.floor(input);\n}\n\nconst NS_WIRE_THRESHOLD = 10_000_000_000_000_000n;\nconst US_WIRE_THRESHOLD = 10_000_000_000_000n;\n\n/**\n * Normalizes a ledger-style uint64 wire timestamp to epoch milliseconds.\n * Handles nanoseconds, microseconds, and milliseconds so gRPC and websocket\n * payloads stay consistent even when the backend uses different units.\n */\nexport function wireTimestampToMs(ts: bigint | number | undefined): number {\n    if (ts === undefined || ts === null) return 0;\n    if (typeof ts === \"bigint\") {\n        if (ts > NS_WIRE_THRESHOLD) return Number(ts / 1_000_000n);\n        if (ts > US_WIRE_THRESHOLD) return Number(ts / 1_000n);\n        return Number(ts);\n    }\n    return normalizeToMillis(ts);\n}\n"],"mappings":";;;;;;AAOA,SAAgB,UAAU,IAAyC;CAC/D,IAAI,OAAO,KAAA,KAAa,OAAO,MAAM,OAAO;CAC5C,IAAI,OAAO,OAAO,UAEd,IAAI;EACA,OAAO,IAAI,KAAK,OAAO,KAAK,QAAQ,CAAC,CAAC,CAAC,YAAY;CACvD,QAAQ;EACJ,OAAO,GAAG,SAAS;CACvB;CAEJ,IAAI,OAAO,OAAO,UAAU;EAExB,MAAM,KAAK,KAAK,eAAO,KAAK,MAAM,KAAK,GAAG,IAAI;EAC9C,OAAO,IAAI,KAAK,EAAE,CAAC,CAAC,YAAY;CACpC;CACA,OAAO;AACX;;;;;;AAOA,SAAgB,SAAS,IAAyC;CAC9D,IAAI,OAAO,KAAA,KAAa,OAAO,MAAM,OAAO;CAC5C,IAAI,OAAO,OAAO,UAAU,OAAO,OAAO,KAAK,QAAQ;CACvD,IAAI,OAAO,OAAO,UAEd,OAAO,KAAK,MAAM,KAAK,GAAG;CAE9B,OAAO;AACX;AAyBA,SAAgB,UAAU,IAAwC;CAC9D,IAAI,OAAO,KAAA,GAAW,OAAO,KAAA;CAC7B,IAAI,GAAG,YAAY,KAAA,GAAW,OAAO,KAAA;CACrC,MAAM,QAAQ,GAAG,SAAS;CAC1B,OAAO,OAAO,GAAG,OAAO,IAAI,MAAO,KAAK,MAAM,QAAQ,GAAS;AACnE;AASA,SAAgB,gBAAgB,IAAwC;CACpE,IAAI,IAAI,YAAY,KAAA,GAAW,OAAO,KAAA;CACtC,QAAQ,GAAG,UAAU,cAAiB,OAAO,GAAG,SAAS,CAAC,EAAA,CAAG,SAAS;AAC1E;;;;;;AAgBA,SAAgB,kBAAkB,OAAuB;CACrD,IAAI,CAAC,OAAO,SAAS,KAAK,GAAG,OAAO,KAAK,IAAI;CAE7C,IAAI,QAAQ,kBAAM,OAAO,KAAK,MAAM,QAAQ,GAAG;CAC/C,IAAI,QAAQ,eAAM,OAAO,KAAK,MAAM,QAAQ,GAAG;CAC/C,OAAO,KAAK,MAAM,KAAK;AAC3B;AAEA,MAAM,oBAAoB;AAC1B,MAAM,oBAAoB;;;;;;AAO1B,SAAgB,kBAAkB,IAAyC;CACvE,IAAI,OAAO,KAAA,KAAa,OAAO,MAAM,OAAO;CAC5C,IAAI,OAAO,OAAO,UAAU;EACxB,IAAI,KAAK,mBAAmB,OAAO,OAAO,KAAK,QAAU;EACzD,IAAI,KAAK,mBAAmB,OAAO,OAAO,KAAK,KAAM;EACrD,OAAO,OAAO,EAAE;CACpB;CACA,OAAO,kBAAkB,EAAE;AAC/B"}

package/dist/utils/timestamp.js

@@ -0,0 +1,52 @@
+//#region src/utils/timestamp.ts
+/**
+* Creates a proto Timestamp from seconds and nanos parts.
+*/
+function toTimestamp({ seconds, nanos }) {
+	return {
+		seconds,
+		nanos
+	};
+}
+/**
+* Converts epoch nanoseconds to a proto Timestamp.
+*/
+function tsNsToTimestamp(tsNs) {
+	if (tsNs === void 0) return void 0;
+	return toTimestamp({
+		seconds: tsNs / 1000000000n,
+		nanos: Number(tsNs % 1000000000n)
+	});
+}
+/**
+* Converts supported timestamp-like values to epoch milliseconds.
+*/
+function timestampToMs(value) {
+	if (value == null) return null;
+	if (value instanceof Date) {
+		const ms = value.getTime();
+		return Number.isFinite(ms) ? ms : null;
+	}
+	if (typeof value === "string") {
+		const ms = Date.parse(value);
+		return Number.isFinite(ms) ? ms : null;
+	}
+	if (typeof value !== "object") return null;
+	const timestamp = value;
+	const rawSeconds = timestamp.seconds;
+	const rawNanos = timestamp.nanos;
+	let seconds = null;
+	if (typeof rawSeconds === "bigint") seconds = Number(rawSeconds);
+	else if (typeof rawSeconds === "number") seconds = rawSeconds;
+	else if (typeof rawSeconds === "string" && rawSeconds.trim().length > 0) {
+		const parsed = Number(rawSeconds);
+		seconds = Number.isFinite(parsed) ? parsed : null;
+	}
+	if (seconds == null || !Number.isFinite(seconds)) return null;
+	const nanos = typeof rawNanos === "number" && Number.isFinite(rawNanos) ? rawNanos : 0;
+	return Math.trunc(seconds * 1e3 + nanos / 1e6);
+}
+//#endregion
+export { timestampToMs, toTimestamp, tsNsToTimestamp };
+
+//# sourceMappingURL=timestamp.js.map

package/dist/utils/timestamp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"timestamp.js","names":[],"sources":["../../src/utils/timestamp.ts"],"sourcesContent":["import type { Timestamp } from \"@bufbuild/protobuf/wkt\";\n\n/**\n * Creates a proto Timestamp from seconds and nanos parts.\n */\nexport function toTimestamp({ seconds, nanos }: { seconds: bigint; nanos: number }): Timestamp {\n    return { seconds, nanos } as Timestamp;\n}\n\n/**\n * Converts epoch nanoseconds to a proto Timestamp.\n */\nexport function tsNsToTimestamp(tsNs: bigint | undefined): Timestamp | undefined {\n    if (tsNs === undefined) return undefined;\n    return toTimestamp({\n        seconds: tsNs / 1_000_000_000n,\n        nanos: Number(tsNs % 1_000_000_000n),\n    });\n}\n\n/**\n * Converts supported timestamp-like values to epoch milliseconds.\n */\nexport function timestampToMs(value: unknown): number | null {\n    if (value == null) return null;\n\n    if (value instanceof Date) {\n        const ms = value.getTime();\n        return Number.isFinite(ms) ? ms : null;\n    }\n\n    if (typeof value === \"string\") {\n        const ms = Date.parse(value);\n        return Number.isFinite(ms) ? ms : null;\n    }\n\n    if (typeof value !== \"object\") return null;\n    const timestamp = value as Record<string, unknown>;\n    const rawSeconds = timestamp.seconds;\n    const rawNanos = timestamp.nanos;\n\n    let seconds: number | null = null;\n    if (typeof rawSeconds === \"bigint\") {\n        seconds = Number(rawSeconds);\n    } else if (typeof rawSeconds === \"number\") {\n        seconds = rawSeconds;\n    } else if (typeof rawSeconds === \"string\" && rawSeconds.trim().length > 0) {\n        const parsed = Number(rawSeconds);\n        seconds = Number.isFinite(parsed) ? parsed : null;\n    }\n    if (seconds == null || !Number.isFinite(seconds)) return null;\n\n    const nanos = typeof rawNanos === \"number\" && Number.isFinite(rawNanos) ? rawNanos : 0;\n    return Math.trunc(seconds * 1000 + nanos / 1_000_000);\n}\n"],"mappings":";;;;AAKA,SAAgB,YAAY,EAAE,SAAS,SAAwD;CAC3F,OAAO;EAAE;EAAS;CAAM;AAC5B;;;;AAKA,SAAgB,gBAAgB,MAAiD;CAC7E,IAAI,SAAS,KAAA,GAAW,OAAO,KAAA;CAC/B,OAAO,YAAY;EACf,SAAS,OAAO;EAChB,OAAO,OAAO,OAAO,WAAc;CACvC,CAAC;AACL;;;;AAKA,SAAgB,cAAc,OAA+B;CACzD,IAAI,SAAS,MAAM,OAAO;CAE1B,IAAI,iBAAiB,MAAM;EACvB,MAAM,KAAK,MAAM,QAAQ;EACzB,OAAO,OAAO,SAAS,EAAE,IAAI,KAAK;CACtC;CAEA,IAAI,OAAO,UAAU,UAAU;EAC3B,MAAM,KAAK,KAAK,MAAM,KAAK;EAC3B,OAAO,OAAO,SAAS,EAAE,IAAI,KAAK;CACtC;CAEA,IAAI,OAAO,UAAU,UAAU,OAAO;CACtC,MAAM,YAAY;CAClB,MAAM,aAAa,UAAU;CAC7B,MAAM,WAAW,UAAU;CAE3B,IAAI,UAAyB;CAC7B,IAAI,OAAO,eAAe,UACtB,UAAU,OAAO,UAAU;MACxB,IAAI,OAAO,eAAe,UAC7B,UAAU;MACP,IAAI,OAAO,eAAe,YAAY,WAAW,KAAK,CAAC,CAAC,SAAS,GAAG;EACvE,MAAM,SAAS,OAAO,UAAU;EAChC,UAAU,OAAO,SAAS,MAAM,IAAI,SAAS;CACjD;CACA,IAAI,WAAW,QAAQ,CAAC,OAAO,SAAS,OAAO,GAAG,OAAO;CAEzD,MAAM,QAAQ,OAAO,aAAa,YAAY,OAAO,SAAS,QAAQ,IAAI,WAAW;CACrF,OAAO,KAAK,MAAM,UAAU,MAAO,QAAQ,GAAS;AACxD"}

package/dist/utils/types.d.ts

@@ -0,0 +1,6 @@
+//#region src/utils/types.d.ts
+type UnspecifiedEnumValue = "unspecified";
+type DecodedEnum<T> = T | UnspecifiedEnumValue;
+//#endregion
+export { DecodedEnum, UnspecifiedEnumValue };
+//# sourceMappingURL=types.d.ts.map

package/dist/utils/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../src/utils/types.ts"],"mappings":";KAAY;KACA,YAAY,KAAK,IAAI"}

package/dist/utils/u128.d.ts

@@ -0,0 +1,8 @@
+//#region src/utils/u128.d.ts
+type U128Value = {
+  hi: bigint;
+  lo: bigint;
+};
+//#endregion
+export { U128Value };
+//# sourceMappingURL=u128.d.ts.map

package/dist/utils/u128.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"u128.d.ts","names":[],"sources":["../../src/utils/u128.ts"],"mappings":";KAMY;EACR;EACA"}

package/dist/utils/u128.js

@@ -0,0 +1,43 @@
+//#region src/utils/u128.ts
+const U64_BITS = 64n;
+const U64_MASK = (1n << U64_BITS) - 1n;
+const U128_MAX = (1n << 128n) - 1n;
+/**
+* Convert a value to a bigint.
+* @param v - The value to convert to a bigint.
+* @returns The bigint.
+*/
+function toBig(v) {
+	if (v === void 0 || v === null) return 0n;
+	if (typeof v === "bigint") return v;
+	if (typeof v === "number") return BigInt(v);
+	if (typeof v === "string" && v.length > 0) try {
+		return BigInt(v);
+	} catch {
+		return 0n;
+	}
+	return 0n;
+}
+/**
+* Convert a {hi, lo} object (or compatible) into a single bigint.
+* @param u - The object to convert to a bigint.
+* @returns The bigint.
+*/
+function fromU128(u) {
+	if (!u) return 0n;
+	const hi = toBig(u.hi);
+	const lo = toBig(u.lo);
+	return (hi << U64_BITS) + lo;
+}
+/** Convert a non-negative bigint into the protobuf U128 hi/lo representation. */
+function toU128(value) {
+	if (value < 0n || value > U128_MAX) throw new RangeError("U128 value must be between 0 and 2^128 - 1.");
+	return {
+		hi: value >> U64_BITS,
+		lo: value & U64_MASK
+	};
+}
+//#endregion
+export { fromU128, toBig, toU128 };
+
+//# sourceMappingURL=u128.js.map

package/dist/utils/u128.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"u128.js","names":[],"sources":["../../src/utils/u128.ts"],"sourcesContent":["// Utility helpers for working with 128-bit unsigned integers encoded as hi/lo.\n\nconst U64_BITS = 64n;\nconst U64_MASK = (1n << U64_BITS) - 1n;\nconst U128_MAX = (1n << 128n) - 1n;\n\nexport type U128Value = {\n    hi: bigint;\n    lo: bigint;\n};\n\n/**\n * Convert a value to a bigint.\n * @param v - The value to convert to a bigint.\n * @returns The bigint.\n */\nexport function toBig(v: unknown): bigint {\n    if (v === undefined || v === null) return 0n;\n    if (typeof v === \"bigint\") return v;\n    if (typeof v === \"number\") return BigInt(v);\n    if (typeof v === \"string\" && v.length > 0) {\n        try {\n            return BigInt(v);\n        } catch {\n            return 0n;\n        }\n    }\n    return 0n;\n}\n\n/**\n * Convert a {hi, lo} object (or compatible) into a single bigint.\n * @param u - The object to convert to a bigint.\n * @returns The bigint.\n */\nexport function fromU128(u: U128Value | undefined): bigint {\n    if (!u) return 0n;\n    const hi = toBig(u.hi);\n    const lo = toBig(u.lo);\n    return (hi << U64_BITS) + lo;\n}\n\n/** Convert a non-negative bigint into the protobuf U128 hi/lo representation. */\nexport function toU128(value: bigint): U128Value {\n    if (value < 0n || value > U128_MAX) {\n        throw new RangeError(\"U128 value must be between 0 and 2^128 - 1.\");\n    }\n    return {\n        hi: value >> U64_BITS,\n        lo: value & U64_MASK,\n    };\n}\n\n/**\n * Convert a bigint and scale into a decimal string.\n * @param value - The value to convert to a decimal string.\n * @param scale - The scale to convert the value to.\n * @returns The decimal string.\n */\nexport function u128ToDecimal(value: bigint, scale: number): string {\n    if (scale <= 0) return value.toString();\n    const base = 10n ** BigInt(scale);\n    const i = value / base;\n    const f = value % base;\n    return `${i}.${f.toString().padStart(scale, \"0\")}`;\n}\n"],"mappings":";AAEA,MAAM,WAAW;AACjB,MAAM,YAAY,MAAM,YAAY;AACpC,MAAM,YAAY,MAAM,QAAQ;;;;;;AAYhC,SAAgB,MAAM,GAAoB;CACtC,IAAI,MAAM,KAAA,KAAa,MAAM,MAAM,OAAO;CAC1C,IAAI,OAAO,MAAM,UAAU,OAAO;CAClC,IAAI,OAAO,MAAM,UAAU,OAAO,OAAO,CAAC;CAC1C,IAAI,OAAO,MAAM,YAAY,EAAE,SAAS,GACpC,IAAI;EACA,OAAO,OAAO,CAAC;CACnB,QAAQ;EACJ,OAAO;CACX;CAEJ,OAAO;AACX;;;;;;AAOA,SAAgB,SAAS,GAAkC;CACvD,IAAI,CAAC,GAAG,OAAO;CACf,MAAM,KAAK,MAAM,EAAE,EAAE;CACrB,MAAM,KAAK,MAAM,EAAE,EAAE;CACrB,QAAQ,MAAM,YAAY;AAC9B;;AAGA,SAAgB,OAAO,OAA0B;CAC7C,IAAI,QAAQ,MAAM,QAAQ,UACtB,MAAM,IAAI,WAAW,6CAA6C;CAEtE,OAAO;EACH,IAAI,SAAS;EACb,IAAI,QAAQ;CAChB;AACJ"}