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

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../src/error.ts","../src/ur-type.ts","../src/ur.ts","../src/ur-encodable.ts","../src/ur-decodable.ts","../src/ur-codable.ts","../src/multipart-encoder.ts","../src/multipart-decoder.ts","../src/fountain.ts","../src/xoshiro.ts","../src/utils.ts"],"sourcesContent":[],"mappings":"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"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/error.ts","../src/ur-type.ts","../src/ur.ts","../src/ur-encodable.ts","../src/ur-decodable.ts","../src/ur-codable.ts","../src/multipart-encoder.ts","../src/multipart-decoder.ts","../src/utils.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/index.iife.js

@@ -1,4 +1,4 @@
-var bctsUniformResources = (function(exports) {
+var bctsUniformResources = (function(exports, _bcts_crypto) {
 
 
 //#region ../dcbor/dist/index.mjs
@@ -4900,7 +4900,13 @@ var bctsUniformResources = (function(exports) {
 		/**
 		* Insert a tag into the registry.
 		*
-		* @param tag - The tag to register
+		* Matches Rust's TagsStore::insert() behavior:
+		* - Throws if the tag name is undefined or empty
+		* - Throws if a tag with the same value exists with a different name
+		* - Allows re-registering the same tag value with the same name
+		*
+		* @param tag - The tag to register (must have a non-empty name)
+		* @throws Error if tag has no name, empty name, or conflicts with existing registration
 		*
 		* @example
 		* ```typescript
@@ -4909,9 +4915,13 @@ var bctsUniformResources = (function(exports) {
 		* ```
 		*/
 		insert(tag) {
+			const name = tag.name;
+			if (name === void 0 || name === "") throw new Error(`Tag ${tag.value} must have a non-empty name`);
 			const key = this.#valueKey(tag.value);
+			const existing = this.#tagsByValue.get(key);
+			if (existing?.name !== void 0 && existing.name !== name) throw new Error(`Attempt to register tag: ${tag.value} '${existing.name}' with different name: '${name}'`);
 			this.#tagsByValue.set(key, tag);
-			if (tag.name !== void 0) this.#tagsByName.set(tag.name, tag);
+			this.#tagsByName.set(name, tag);
 		}
 		/**
 		* Insert multiple tags into the registry.
@@ -4949,21 +4959,6 @@ var bctsUniformResources = (function(exports) {
 			const key = this.#valueKey(tagValue$1);
 			this.#summarizers.set(key, summarizer);
 		}
-		/**
-		* Remove a tag from the registry.
-		*
-		* @param tagValue - The numeric tag value to remove
-		* @returns true if a tag was removed, false otherwise
-		*/
-		remove(tagValue$1) {
-			const key = this.#valueKey(tagValue$1);
-			const tag = this.#tagsByValue.get(key);
-			if (tag === void 0) return false;
-			this.#tagsByValue.delete(key);
-			if (tag.name !== void 0) this.#tagsByName.delete(tag.name);
-			this.#summarizers.delete(key);
-			return true;
-		}
 		assignedNameForTag(tag) {
 			const key = this.#valueKey(tag.value);
 			return this.#tagsByValue.get(key)?.name;
@@ -4987,30 +4982,6 @@ var bctsUniformResources = (function(exports) {
 			return this.#summarizers.get(key);
 		}
 		/**
-		* Get all registered tags.
-		*
-		* @returns Array of all registered tags
-		*/
-		getAllTags() {
-			return Array.from(this.#tagsByValue.values());
-		}
-		/**
-		* Clear all registered tags and summarizers.
-		*/
-		clear() {
-			this.#tagsByValue.clear();
-			this.#tagsByName.clear();
-			this.#summarizers.clear();
-		}
-		/**
-		* Get the number of registered tags.
-		*
-		* @returns Number of tags in the registry
-		*/
-		get size() {
-			return this.#tagsByValue.size;
-		}
-		/**
 		* Create a string key for a numeric tag value.
 		* Handles both number and bigint types.
 		*
@@ -5373,11 +5344,17 @@ var bctsUniformResources = (function(exports) {
 	}
 	/**
 	* Format tagged value.
+	*
+	* Matches Rust's diag_item() for Tagged case.
 	*/
 	function formatTagged(tag, content, opts) {
 		if (opts.summarize === true) {
 			const summarizer = resolveTagsStore(opts.tags)?.summarizer(tag);
-			if (summarizer !== void 0) return summarizer(content, opts.flat ?? false);
+			if (summarizer !== void 0) {
+				const result$1 = summarizer(content, opts.flat ?? false);
+				if (result$1.ok) return result$1.value;
+				else return `<error: ${result$1.error.type === "Custom" ? result$1.error.message : result$1.error.type === "WrongTag" ? `expected CBOR tag ${result$1.error.expected.value}, but got ${result$1.error.actual.value}` : result$1.error.type}>`;
+			}
 		}
 		let comment;
 		if (opts.annotate === true) {
@@ -6008,21 +5985,20 @@ var bctsUniformResources = (function(exports) {
 	* @param cbor - The CBOR value to traverse
 	* @param initialState - Initial state value
 	* @param visitor - Function to call for each element
-	* @returns Final state after traversal
 	*
 	* @example
 	* ```typescript
-	* // Count all text strings in a structure
-	* interface CountState { count: number }
+	* // Count all text strings in a structure using RefCell-like pattern
+	* const count = { value: 0 };
 	*
 	* const structure = cbor({ name: 'Alice', tags: ['urgent', 'draft'] });
-	* const result = walk(structure, { count: 0 }, (element, level, edge, state) => {
+	* walk(structure, null, (element, level, edge, state) => {
 	*   if (element.type === 'single' && element.cbor.type === MajorType.Text) {
-	*     return [{ count: state.count + 1 }, false];
+	*     count.value++;
 	*   }
 	*   return [state, false];
 	* });
-	* console.log(result.count); // 3 (name, urgent, draft)
+	* console.log(count.value); // 3 (name, urgent, draft)
 	* ```
 	*
 	* @example
@@ -6031,7 +6007,7 @@ var bctsUniformResources = (function(exports) {
 	* const structure = cbor([1, 2, 3, 'found', 5, 6]);
 	* let found = false;
 	*
-	* walk(structure, null, (element, level, edge) => {
+	* walk(structure, null, (element, level, edge, state) => {
 	*   if (element.type === 'single' &&
 	*       element.cbor.type === MajorType.Text &&
 	*       element.cbor.value === 'found') {
@@ -6043,7 +6019,7 @@ var bctsUniformResources = (function(exports) {
 	* ```
 	*/
 	const walk = (cbor$1, initialState, visitor) => {
-		return walkInternal(cbor$1, 0, { type: EdgeType.None }, initialState, visitor);
+		walkInternal(cbor$1, 0, { type: EdgeType.None }, initialState, visitor);
 	};
 	/**
 	* Internal recursive walk implementation.
@@ -6527,7 +6503,7 @@ var bctsUniformResources = (function(exports) {
 				return this.value;
 			},
 			walk(initialState, visitor) {
-				return walk(this, initialState, visitor);
+				walk(this, initialState, visitor);
 			},
 			validateTag(expectedTags) {
 				if (this.type !== MajorType.Tagged) throw new CborError({ type: "WrongType" });
@@ -6663,6 +6639,16 @@ var bctsUniformResources = (function(exports) {
 		}
 	};
 	/**
+	* Error type for UR decoder errors.
+	* Matches Rust's Error::UR(String) variant.
+	*/
+	var URDecodeError = class extends URError {
+		constructor(message) {
+			super(`UR decoder error (${message})`);
+			this.name = "URDecodeError";
+		}
+	};
+	/**
 	* Helper function to check if a result is an error.
 	*/
 	function isError(result) {
@@ -6691,13 +6677,6 @@ var bctsUniformResources = (function(exports) {
 		return Array.from(urType).every((char) => isURTypeChar(char));
 	}
 	/**
-	* Validates and returns a UR type, or throws an error if invalid.
-	*/
-	function validateURType(urType) {
-		if (!isValidURType(urType)) throw new InvalidTypeError();
-		return urType;
-	}
-	/**
 	* Bytewords for encoding/decoding bytes as words.
 	* See: https://github.com/BlockchainCommons/Research/blob/master/papers/bcr-2020-004-bytewords.md
 	*/
@@ -7268,7 +7247,7 @@ var bctsUniformResources = (function(exports) {
 	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";
@@ -7344,7 +7323,7 @@ var bctsUniformResources = (function(exports) {
 		}
 		switch (style) {
 			case BytewordsStyle.Standard: return words.join(" ");
-			case BytewordsStyle.Uri:
+			case BytewordsStyle.Uri: return words.join("-");
 			case BytewordsStyle.Minimal: return words.join("");
 		}
 	}
@@ -7364,14 +7343,11 @@ var bctsUniformResources = (function(exports) {
 				});
 				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");
@@ -7676,6 +7652,7 @@ var bctsUniformResources = (function(exports) {
 	* 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");
 	/**
@@ -7695,21 +7672,28 @@ var bctsUniformResources = (function(exports) {
 	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.
@@ -7726,33 +7710,6 @@ var bctsUniformResources = (function(exports) {
 			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() {
@@ -7768,17 +7725,19 @@ var bctsUniformResources = (function(exports) {
 		}
 		/**
 		* 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].
@@ -7794,24 +7753,102 @@ var bctsUniformResources = (function(exports) {
 			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
@@ -7858,6 +7895,11 @@ var bctsUniformResources = (function(exports) {
 	* 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
@@ -7866,26 +7908,10 @@ var bctsUniformResources = (function(exports) {
 	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.
@@ -8125,14 +8151,6 @@ var bctsUniformResources = (function(exports) {
 			this._fountainEncoder = new FountainEncoder(ur.cbor().toData(), maxFragmentLen);
 		}
 		/**
-		* Returns whether the message fits in a single part.
-		*
-		* For single-part messages, consider using UR.string() directly.
-		*/
-		isSinglePart() {
-			return this._fountainEncoder.isSinglePart();
-		}
-		/**
 		* Gets the next part of the encoding.
 		*
 		* Parts 1 through seqLen are "pure" fragments containing one piece each.
@@ -8160,20 +8178,17 @@ var bctsUniformResources = (function(exports) {
 			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.
@@ -8190,22 +8205,6 @@ var bctsUniformResources = (function(exports) {
 		partsCount() {
 			return this._fountainEncoder.seqLen;
 		}
-		/**
-		* Checks if all pure parts have been emitted.
-		*
-		* Even after this returns true, you can continue calling nextPart()
-		* to generate additional rateless parts for redundancy.
-		*/
-		isComplete() {
-			return this._fountainEncoder.isComplete();
-		}
-		/**
-		* Resets the encoder to start from the beginning.
-		*/
-		reset() {
-			this._currentIndex = 0;
-			this._fountainEncoder.reset();
-		}
 	};
 
 //#endregion
@@ -8287,16 +8286,23 @@ var bctsUniformResources = (function(exports) {
 		}
 		/**
 		* 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
@@ -8316,48 +8322,25 @@ var bctsUniformResources = (function(exports) {
 		message() {
 			return this._decodedMessage;
 		}
-		/**
-		* Returns the decoding progress as a fraction (0 to 1).
-		*/
-		progress() {
-			if (this._decodedMessage !== null) return 1;
-			if (this._fountainDecoder === null) return 0;
-			return this._fountainDecoder.progress();
-		}
-		/**
-		* Resets the decoder to receive a new message.
-		*/
-		reset() {
-			this._urType = null;
-			this._fountainDecoder = null;
-			this._decodedMessage = null;
-		}
 	};
 
 //#endregion
 exports.BYTEMOJIS = BYTEMOJIS;
 exports.BYTEWORDS = BYTEWORDS;
-exports.BYTEWORDS_MAP = BYTEWORDS_MAP;
 exports.BytewordsError = BytewordsError;
 exports.BytewordsStyle = BytewordsStyle;
 exports.CBORError = CBORError;
-exports.FountainDecoder = FountainDecoder;
-exports.FountainEncoder = FountainEncoder;
 exports.InvalidSchemeError = InvalidSchemeError;
 exports.InvalidTypeError = InvalidTypeError;
-exports.MINIMAL_BYTEWORDS_MAP = MINIMAL_BYTEWORDS_MAP;
 exports.MultipartDecoder = MultipartDecoder;
 exports.MultipartEncoder = MultipartEncoder;
 exports.NotSinglePartError = NotSinglePartError;
 exports.TypeUnspecifiedError = TypeUnspecifiedError;
 exports.UR = UR;
+exports.URDecodeError = URDecodeError;
 exports.URError = URError;
 exports.URType = URType;
 exports.UnexpectedTypeError = UnexpectedTypeError;
-exports.Xoshiro256 = Xoshiro256;
-exports.chooseFragments = chooseFragments;
-exports.crc32 = crc32;
-exports.createSeed = createSeed;
 exports.decodeBytewords = decodeBytewords;
 exports.encodeBytemojisIdentifier = encodeBytemojisIdentifier;
 exports.encodeBytewords = encodeBytewords;
@@ -8366,12 +8349,6 @@ exports.isError = isError;
 exports.isURCodable = isURCodable;
 exports.isURDecodable = isURDecodable;
 exports.isUREncodable = isUREncodable;
-exports.isURTypeChar = isURTypeChar;
-exports.isValidURType = isValidURType;
-exports.mixFragments = mixFragments;
-exports.splitMessage = splitMessage;
-exports.validateURType = validateURType;
-exports.xorBytes = xorBytes;
 return exports;
-})({});
+})({}, bctsCrypto);
 //# sourceMappingURL=index.iife.js.map