@bcts/uniform-resources 1.0.0-alpha.13 → 1.0.0-alpha.14

package/dist/index.cjs

@@ -1,3 +1,4 @@
+let _bcts_crypto = require("@bcts/crypto");
 
 //#region ../dcbor/dist/index.mjs
 var __create = Object.create;
@@ -7245,7 +7246,7 @@ function encodeBytemojisIdentifier(data) {
 let BytewordsStyle = /* @__PURE__ */ function(BytewordsStyle$1) {
 	/** Full 4-letter words separated by spaces */
 	BytewordsStyle$1["Standard"] = "standard";
-	/** Full 4-letter words without separators */
+	/** Full 4-letter words separated by hyphens (URI-safe) */
 	BytewordsStyle$1["Uri"] = "uri";
 	/** First and last character only (minimal) - used by UR encoding */
 	BytewordsStyle$1["Minimal"] = "minimal";
@@ -7321,7 +7322,7 @@ function encodeBytewords(data, style = BytewordsStyle.Minimal) {
 	}
 	switch (style) {
 		case BytewordsStyle.Standard: return words.join(" ");
-		case BytewordsStyle.Uri:
+		case BytewordsStyle.Uri: return words.join("-");
 		case BytewordsStyle.Minimal: return words.join("");
 	}
 }
@@ -7341,14 +7342,11 @@ function decodeBytewords(encoded, style = BytewordsStyle.Minimal) {
 			});
 			break;
 		case BytewordsStyle.Uri:
-			if (lowercased.length % 4 !== 0) throw new Error("Invalid URI bytewords length");
-			bytes = [];
-			for (let i = 0; i < lowercased.length; i += 4) {
-				const word = lowercased.slice(i, i + 4);
+			bytes = lowercased.split("-").map((word) => {
 				const index = BYTEWORDS_MAP.get(word);
 				if (index === void 0) throw new Error(`Invalid byteword: ${word}`);
-				bytes.push(index);
-			}
+				return index;
+			});
 			break;
 		case BytewordsStyle.Minimal:
 			if (lowercased.length % 2 !== 0) throw new Error("Invalid minimal bytewords length");
@@ -7653,6 +7651,7 @@ function isURCodable(obj) {
 * for deterministic fragment selection in fountain codes.
 *
 * Reference: https://prng.di.unimi.it/
+* BC-UR Reference: https://github.com/nicklockwood/fountain-codes
 */
 const MAX_UINT64 = BigInt("0xffffffffffffffff");
 /**
@@ -7672,21 +7671,28 @@ function rotl(x, k) {
 var Xoshiro256 = class Xoshiro256 {
 	s;
 	/**
-	* Creates a new Xoshiro256** instance from a seed.
+	* Creates a new Xoshiro256** instance from a 32-byte seed.
 	*
-	* The seed is hashed using SHA-256 to initialize the state.
-	* For consistent results across encoder/decoder, use the same seed.
+	* The seed must be exactly 32 bytes (256 bits). The bytes are interpreted
+	* using the BC-UR reference algorithm: each 8-byte chunk is read as
+	* big-endian then stored as little-endian for the state.
 	*
-	* @param seed - The seed bytes (any length)
+	* @param seed - The seed bytes (must be exactly 32 bytes)
 	*/
 	constructor(seed) {
-		const hash = this.hashSeed(seed);
-		this.s = [
-			this.bytesToBigInt(hash.slice(0, 8)),
-			this.bytesToBigInt(hash.slice(8, 16)),
-			this.bytesToBigInt(hash.slice(16, 24)),
-			this.bytesToBigInt(hash.slice(24, 32))
+		if (seed.length !== 32) throw new Error(`Seed must be 32 bytes, got ${seed.length}`);
+		const s = [
+			0n,
+			0n,
+			0n,
+			0n
 		];
+		for (let i = 0; i < 4; i++) {
+			let v = 0n;
+			for (let n = 0; n < 8; n++) v = v << 8n | BigInt(seed[8 * i + n] ?? 0);
+			s[i] = v;
+		}
+		this.s = s;
 	}
 	/**
 	* Creates a Xoshiro256** instance from raw state values.
@@ -7703,33 +7709,6 @@ var Xoshiro256 = class Xoshiro256 {
 		return instance;
 	}
 	/**
-	* Simple hash function for seeding.
-	* This is a basic implementation - in production use SHA-256.
-	*/
-	hashSeed(seed) {
-		const result = new Uint8Array(32);
-		if (seed.length === 0) return result;
-		for (let i = 0; i < 32; i++) {
-			let hash = 0;
-			for (const byte of seed) hash = hash * 31 + byte + i >>> 0;
-			hash ^= hash >>> 16;
-			hash = hash * 2246822507 >>> 0;
-			hash ^= hash >>> 13;
-			hash = hash * 3266489909 >>> 0;
-			hash ^= hash >>> 16;
-			result[i] = hash & 255;
-		}
-		return result;
-	}
-	/**
-	* Converts 8 bytes to a 64-bit BigInt (little-endian).
-	*/
-	bytesToBigInt(bytes) {
-		let result = 0n;
-		for (let i = 7; i >= 0; i--) result = result << 8n | BigInt(bytes[i] ?? 0);
-		return result;
-	}
-	/**
 	* Generates the next 64-bit random value.
 	*/
 	next() {
@@ -7745,17 +7724,19 @@ var Xoshiro256 = class Xoshiro256 {
 	}
 	/**
 	* Generates a random double in [0, 1).
+	* Matches BC-UR reference: self.next() as f64 / (u64::MAX as f64 + 1.0)
 	*/
 	nextDouble() {
 		const value = this.next();
-		return Number(value >> 11n) / Number(1n << 53n);
+		return Number(value) / 0x10000000000000000;
 	}
 	/**
-	* Generates a random integer in [low, high).
+	* Generates a random integer in [low, high] (inclusive).
+	* Matches BC-UR reference: (self.next_double() * ((high - low + 1) as f64)) as u64 + low
 	*/
 	nextInt(low, high) {
-		const range$1 = high - low;
-		return low + Math.floor(this.nextDouble() * range$1);
+		const range$1 = high - low + 1;
+		return Math.floor(this.nextDouble() * range$1) + low;
 	}
 	/**
 	* Generates a random byte [0, 255].
@@ -7771,24 +7752,102 @@ var Xoshiro256 = class Xoshiro256 {
 		for (let i = 0; i < count; i++) result[i] = this.nextByte();
 		return result;
 	}
+	/**
+	* Shuffles items by repeatedly picking random indices.
+	* Matches BC-UR reference implementation.
+	*/
+	shuffled(items) {
+		const source = [...items];
+		const shuffled = [];
+		while (source.length > 0) {
+			const index = this.nextInt(0, source.length - 1);
+			const item = source.splice(index, 1)[0];
+			if (item !== void 0) shuffled.push(item);
+		}
+		return shuffled;
+	}
+	/**
+	* Chooses the degree (number of fragments to mix) using a weighted sampler.
+	* Uses the robust soliton distribution with weights [1/1, 1/2, 1/3, ..., 1/n].
+	* Matches BC-UR reference implementation.
+	*/
+	chooseDegree(seqLen) {
+		const weights = [];
+		for (let i = 1; i <= seqLen; i++) weights.push(1 / i);
+		return new WeightedSampler(weights).next(this) + 1;
+	}
+};
+/**
+* Weighted sampler using Vose's alias method.
+* Allows O(1) sampling from a discrete probability distribution.
+*/
+var WeightedSampler = class {
+	aliases;
+	probs;
+	constructor(weights) {
+		const n = weights.length;
+		if (n === 0) throw new Error("Weights array cannot be empty");
+		const sum = weights.reduce((a, b) => a + b, 0);
+		if (sum <= 0) throw new Error("Weights must sum to a positive value");
+		const normalized = weights.map((w) => w * n / sum);
+		this.aliases = Array.from({ length: n }).fill(0);
+		this.probs = Array.from({ length: n }).fill(0);
+		const small = [];
+		const large = [];
+		for (let i = n - 1; i >= 0; i--) if (normalized[i] < 1) small.push(i);
+		else large.push(i);
+		while (small.length > 0 && large.length > 0) {
+			const a = small.pop();
+			const g = large.pop();
+			if (a === void 0 || g === void 0) break;
+			this.probs[a] = normalized[a] ?? 0;
+			this.aliases[a] = g;
+			normalized[g] = (normalized[g] ?? 0) + (normalized[a] ?? 0) - 1;
+			if (normalized[g] !== void 0 && normalized[g] < 1) small.push(g);
+			else large.push(g);
+		}
+		while (large.length > 0) {
+			const g = large.pop();
+			if (g === void 0) break;
+			this.probs[g] = 1;
+		}
+		while (small.length > 0) {
+			const a = small.pop();
+			if (a === void 0) break;
+			this.probs[a] = 1;
+		}
+	}
+	/**
+	* Sample from the distribution.
+	*/
+	next(rng) {
+		const r1 = rng.nextDouble();
+		const r2 = rng.nextDouble();
+		const n = this.probs.length;
+		const i = Math.floor(n * r1);
+		if (r2 < this.probs[i]) return i;
+		else return this.aliases[i];
+	}
 };
 /**
-* Creates a seed for the Xoshiro PRNG from message checksum and sequence number.
+* Creates a Xoshiro256 PRNG instance from message checksum and sequence number.
+*
+* This creates an 8-byte seed by concatenating seqNum and checksum (both in
+* big-endian), then hashes it with SHA-256 to get the 32-byte seed for Xoshiro.
 *
-* This ensures that both encoder and decoder produce the same random sequence
-* for a given message and part number.
+* This matches the BC-UR reference implementation.
 */
 function createSeed(checksum, seqNum) {
-	const seed = new Uint8Array(8);
-	seed[0] = checksum >>> 24 & 255;
-	seed[1] = checksum >>> 16 & 255;
-	seed[2] = checksum >>> 8 & 255;
-	seed[3] = checksum & 255;
-	seed[4] = seqNum >>> 24 & 255;
-	seed[5] = seqNum >>> 16 & 255;
-	seed[6] = seqNum >>> 8 & 255;
-	seed[7] = seqNum & 255;
-	return seed;
+	const seed8 = new Uint8Array(8);
+	seed8[0] = seqNum >>> 24 & 255;
+	seed8[1] = seqNum >>> 16 & 255;
+	seed8[2] = seqNum >>> 8 & 255;
+	seed8[3] = seqNum & 255;
+	seed8[4] = checksum >>> 24 & 255;
+	seed8[5] = checksum >>> 16 & 255;
+	seed8[6] = checksum >>> 8 & 255;
+	seed8[7] = checksum & 255;
+	return (0, _bcts_crypto.sha256)(seed8);
 }
 
 //#endregion
@@ -7835,6 +7894,11 @@ function xorBytes(a, b) {
 * This uses a seeded Xoshiro256** PRNG to deterministically select fragments,
 * ensuring encoder and decoder agree without explicit coordination.
 *
+* The algorithm matches the BC-UR reference implementation:
+* 1. For pure parts (seqNum <= seqLen), return single fragment index
+* 2. For mixed parts, use weighted sampling to choose degree
+* 3. Shuffle all indices and take the first 'degree' indices
+*
 * @param seqNum - The sequence number (1-based)
 * @param seqLen - Total number of pure fragments
 * @param checksum - CRC32 checksum of the message
@@ -7843,26 +7907,10 @@ function xorBytes(a, b) {
 function chooseFragments(seqNum, seqLen, checksum) {
 	if (seqNum <= seqLen) return [seqNum - 1];
 	const rng = new Xoshiro256(createSeed(checksum, seqNum));
-	const degree = chooseDegree(rng, seqLen);
-	const indices = /* @__PURE__ */ new Set();
-	while (indices.size < degree) {
-		const index = rng.nextInt(0, seqLen);
-		indices.add(index);
-	}
-	return Array.from(indices).sort((a, b) => a - b);
-}
-/**
-* Chooses the degree (number of fragments to mix) using a simplified
-* robust soliton distribution.
-*
-* This ensures good coverage of fragments for efficient decoding.
-*/
-function chooseDegree(rng, seqLen) {
-	const r = rng.nextDouble();
-	if (r < .5) return 1;
-	else if (r < .75) return 2;
-	else if (r < .9) return Math.min(3, seqLen);
-	else return Math.min(rng.nextInt(4, seqLen + 1), seqLen);
+	const degree = rng.chooseDegree(seqLen);
+	const allIndices = [];
+	for (let i = 0; i < seqLen; i++) allIndices.push(i);
+	return rng.shuffled(allIndices).slice(0, degree);
 }
 /**
 * Mixes the selected fragments using XOR.
@@ -8129,20 +8177,17 @@ var MultipartEncoder = class {
 		return `ur:${this._ur.urTypeStr()}/${part.seqNum}-${part.seqLen}/${encoded}`;
 	}
 	/**
-	* Encodes part metadata and data into bytes for bytewords encoding.
+	* Encodes part metadata and data as CBOR for bytewords encoding.
+	* Format: CBOR array [seqNum, seqLen, messageLen, checksum, data]
 	*/
 	_encodePartData(part) {
-		const result = new Uint8Array(8 + part.data.length);
-		result[0] = part.messageLen >>> 24 & 255;
-		result[1] = part.messageLen >>> 16 & 255;
-		result[2] = part.messageLen >>> 8 & 255;
-		result[3] = part.messageLen & 255;
-		result[4] = part.checksum >>> 24 & 255;
-		result[5] = part.checksum >>> 16 & 255;
-		result[6] = part.checksum >>> 8 & 255;
-		result[7] = part.checksum & 255;
-		result.set(part.data, 8);
-		return result;
+		return cbor([
+			part.seqNum,
+			part.seqLen,
+			part.messageLen,
+			part.checksum,
+			part.data
+		]).toData();
 	}
 	/**
 	* Gets the current part index.
@@ -8240,16 +8285,23 @@ var MultipartDecoder = class {
 	}
 	/**
 	* Decodes a multipart UR's fountain part data.
+	*
+	* The multipart body is a CBOR array: [seqNum, seqLen, messageLen, checksum, data]
 	*/
 	_decodeFountainPart(partInfo) {
-		const rawData = decodeBytewords(partInfo.encodedData, BytewordsStyle.Minimal);
-		if (rawData.length < 8) throw new URError("Invalid multipart data: too short");
-		const messageLen = (rawData[0] << 24 | rawData[1] << 16 | rawData[2] << 8 | rawData[3]) >>> 0;
-		const checksum = (rawData[4] << 24 | rawData[5] << 16 | rawData[6] << 8 | rawData[7]) >>> 0;
-		const data = rawData.slice(8);
+		const decoded = decodeCbor(decodeBytewords(partInfo.encodedData, BytewordsStyle.Minimal));
+		if (decoded.type !== MajorType.Array) throw new URError("Invalid multipart data: expected CBOR array");
+		const items = decoded.value;
+		if (items.length !== 5) throw new URError(`Invalid multipart data: expected 5 elements, got ${items.length}`);
+		const seqNum = Number(items[0].value);
+		const seqLen = Number(items[1].value);
+		const messageLen = Number(items[2].value);
+		const checksum = Number(items[3].value);
+		const data = items[4].value;
+		if (seqNum !== partInfo.seqNum || seqLen !== partInfo.seqLen) throw new URError(`Multipart metadata mismatch: URL says ${partInfo.seqNum}-${partInfo.seqLen}, CBOR says ${seqNum}-${seqLen}`);
 		return {
-			seqNum: partInfo.seqNum,
-			seqLen: partInfo.seqLen,
+			seqNum,
+			seqLen,
 			messageLen,
 			checksum,
 			data