@bcts/uniform-resources 1.0.0-alpha.9 → 1.0.0-beta.1

package/src/multipart-decoder.ts

@@ -1,4 +1,10 @@
-import { decodeCbor } from "@bcts/dcbor";
+/**
+ * Copyright © 2023-2026 Blockchain Commons, LLC
+ * Copyright © 2025-2026 Parity Technologies
+ *
+ */
+
+import { decodeCbor, MajorType, type Cbor } from "@bcts/dcbor";
 import { InvalidSchemeError, InvalidTypeError, UnexpectedTypeError, URError } from "./error.js";
 import { UR } from "./ur.js";
 import { URType } from "./ur-type.js";
@@ -118,27 +124,43 @@ export class MultipartDecoder {
 
   /**
    * Decodes a multipart UR's fountain part data.
+   *
+   * The multipart body is a CBOR array: [seqNum, seqLen, messageLen, checksum, data]
    */
   private _decodeFountainPart(partInfo: MultipartInfo): FountainPart {
-    // Decode bytewords
-    const rawData = decodeBytewords(partInfo.encodedData, BytewordsStyle.Minimal);
+    // Decode bytewords to get CBOR data
+    const cborData = decodeBytewords(partInfo.encodedData, BytewordsStyle.Minimal);
 
-    if (rawData.length < 8) {
-      throw new URError("Invalid multipart data: too short");
-    }
+    // Decode the CBOR array
+    const decoded = decodeCbor(cborData);
 
-    // Extract metadata
-    const messageLen =
-      ((rawData[0] << 24) | (rawData[1] << 16) | (rawData[2] << 8) | rawData[3]) >>> 0;
+    // The decoded value should be an array with 5 elements
+    if (decoded.type !== MajorType.Array) {
+      throw new URError("Invalid multipart data: expected CBOR array");
+    }
 
-    const checksum =
-      ((rawData[4] << 24) | (rawData[5] << 16) | (rawData[6] << 8) | rawData[7]) >>> 0;
+    const items = decoded.value as Cbor[];
+    if (items.length !== 5) {
+      throw new URError(`Invalid multipart data: expected 5 elements, got ${items.length}`);
+    }
 
-    const data = rawData.slice(8);
+    // Extract the fields: [seqNum, seqLen, messageLen, checksum, data]
+    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 as Uint8Array;
+
+    // Verify seqNum and seqLen match the URL path values
+    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,
@@ -160,28 +182,6 @@ export class MultipartDecoder {
   message(): UR | null {
     return this._decodedMessage;
   }
-
-  /**
-   * Returns the decoding progress as a fraction (0 to 1).
-   */
-  progress(): number {
-    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(): void {
-    this._urType = null;
-    this._fountainDecoder = null;
-    this._decodedMessage = null;
-  }
 }
 
 /**

package/src/multipart-encoder.ts

@@ -1,7 +1,14 @@
+/**
+ * Copyright © 2023-2026 Blockchain Commons, LLC
+ * Copyright © 2025-2026 Parity Technologies
+ *
+ */
+
 import type { UR } from "./ur.js";
 import { URError } from "./error.js";
 import { FountainEncoder, type FountainPart } from "./fountain.js";
 import { encodeBytewords, BytewordsStyle } from "./utils.js";
+import { cbor } from "@bcts/dcbor";
 
 /**
  * Encodes a UR as multiple parts using fountain codes.
@@ -58,15 +65,6 @@ export class MultipartEncoder {
     this._fountainEncoder = new FountainEncoder(cborData, maxFragmentLen);
   }
 
-  /**
-   * Returns whether the message fits in a single part.
-   *
-   * For single-part messages, consider using UR.string() directly.
-   */
-  isSinglePart(): boolean {
-    return this._fountainEncoder.isSinglePart();
-  }
-
   /**
    * Gets the next part of the encoding.
    *
@@ -89,44 +87,28 @@ export class MultipartEncoder {
 
   /**
    * Encodes a fountain part as a UR string.
+   *
+   * Always emits the multipart `ur:<type>/<seqNum>-<seqLen>/<bytewords>`
+   * format — including for single-part messages (`1-1/...`). This mirrors
+   * Rust's `bc_ur::MultipartEncoder::next_part`, which never short-circuits
+   * to plain UR. Callers that want plain UR for tiny payloads should use
+   * `UR.string()` directly instead of constructing a `MultipartEncoder`.
    */
   private _encodePart(part: FountainPart): string {
-    // For single-part messages, use simple format
-    if (part.seqLen === 1) {
-      return this._ur.string();
-    }
-
-    // Encode the part data as CBOR: [seqNum, seqLen, messageLen, checksum, data]
-    // Using a simple format: seqNum-seqLen prefix followed by bytewords-encoded part
     const partData = this._encodePartData(part);
     const encoded = encodeBytewords(partData, BytewordsStyle.Minimal);
-
     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]
    */
   private _encodePartData(part: FountainPart): Uint8Array {
-    // Simple encoding: messageLen (4 bytes) + checksum (4 bytes) + data
-    const result = new Uint8Array(8 + part.data.length);
+    // Create CBOR array with 5 elements: [seqNum, seqLen, messageLen, checksum, data]
+    const cborArray = cbor([part.seqNum, part.seqLen, part.messageLen, part.checksum, part.data]);
 
-    // Message length (big-endian)
-    result[0] = (part.messageLen >>> 24) & 0xff;
-    result[1] = (part.messageLen >>> 16) & 0xff;
-    result[2] = (part.messageLen >>> 8) & 0xff;
-    result[3] = part.messageLen & 0xff;
-
-    // Checksum (big-endian)
-    result[4] = (part.checksum >>> 24) & 0xff;
-    result[5] = (part.checksum >>> 16) & 0xff;
-    result[6] = (part.checksum >>> 8) & 0xff;
-    result[7] = part.checksum & 0xff;
-
-    // Fragment data
-    result.set(part.data, 8);
-
-    return result;
+    return cborArray.toData();
   }
 
   /**
@@ -145,22 +127,4 @@ export class MultipartEncoder {
   partsCount(): number {
     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(): boolean {
-    return this._fountainEncoder.isComplete();
-  }
-
-  /**
-   * Resets the encoder to start from the beginning.
-   */
-  reset(): void {
-    this._currentIndex = 0;
-    this._fountainEncoder.reset();
-  }
 }

package/src/ur-codable.ts

@@ -1,3 +1,9 @@
+/**
+ * Copyright © 2023-2026 Blockchain Commons, LLC
+ * Copyright © 2025-2026 Parity Technologies
+ *
+ */
+
 import type { UREncodable } from "./ur-encodable.js";
 import type { URDecodable } from "./ur-decodable.js";
 

package/src/ur-decodable.ts

@@ -1,4 +1,12 @@
-import type { UR } from "./ur.js";
+/**
+ * Copyright © 2023-2026 Blockchain Commons, LLC
+ * Copyright © 2025-2026 Parity Technologies
+ *
+ */
+
+import type { CborTaggedDecodable } from "@bcts/dcbor";
+
+import { UR } from "./ur.js";
 
 /**
  * A type that can be decoded from a UR (Uniform Resource).
@@ -6,17 +14,26 @@ import type { UR } from "./ur.js";
  * Types implementing this interface should be able to create themselves
  * from a UR containing their data.
  *
+ * Mirrors Rust's `URDecodable` trait (`bc-ur-rust/src/ur_decodable.rs`),
+ * which has a blanket impl `impl<T> URDecodable for T where T:
+ * CBORTaggedDecodable`. TypeScript has no equivalent of blanket impls, so
+ * implementers either write `fromUR()` directly *or* — for a type that
+ * already implements `CborTaggedDecodable` — call the helper functions
+ * {@link decodableFromUR} / {@link decodableFromURString} below to get the
+ * same auto-derivation that Rust provides for free.
+ *
  * @example
  * ```typescript
- * class MyType implements URDecodable {
- *   fromUR(ur: UR): MyType {
- *     const cbor = ur.cbor();
- *     // Decode from CBOR and return MyType instance
+ * class MyType implements URDecodable, CborTaggedDecodable<MyType> {
+ *   cborTags(): Tag[] {
+ *     return [createTag(40000, "mytype")];
  *   }
+ *   fromUntaggedCbor(cbor: Cbor): MyType { ... }
+ *   fromTaggedCbor(cbor: Cbor): MyType { ... }
  *
- *   fromURString(urString: string): MyType {
- *     return this.fromUR(UR.fromURString(urString));
- *   }
+ *   // Auto-derived from the first cbor tag's name, matching Rust.
+ *   fromUR(ur: UR): MyType { return decodableFromUR(this, ur); }
+ *   fromURString(s: string): MyType { return decodableFromURString(this, s); }
  * }
  * ```
  */
@@ -43,6 +60,41 @@ export interface URDecodable {
   fromURString?(urString: string): unknown;
 }
 
+/**
+ * Concrete equivalent of Rust's default `URDecodable::from_ur` impl
+ * (`bc-ur-rust/src/ur_decodable.rs:7-15`):
+ *
+ *   1. Read the first tag returned by `decodable.cborTags()`.
+ *   2. Verify the UR's type matches that tag's name via `UR#checkType`
+ *      (this is what Rust's `ur.check_type(...)` does — surface
+ *      `UnexpectedTypeError` on mismatch).
+ *   3. Delegate to `decodable.fromUntaggedCbor(ur.cbor())`.
+ *
+ * Use from a class implementing both `URDecodable` and
+ * `CborTaggedDecodable<T>` to skip the type-check / delegate boilerplate.
+ */
+export function decodableFromUR<T>(decodable: CborTaggedDecodable<T>, ur: UR): T {
+  const tags = decodable.cborTags();
+  const tag = tags[0];
+  if (tag === undefined) {
+    throw new Error("URDecodable: cborTags() returned no tags");
+  }
+  if (tag.name === undefined) {
+    throw new Error(`CBOR tag ${tag.value} must have a name. Did you call register_tags()?`);
+  }
+  ur.checkType(tag.name);
+  return decodable.fromUntaggedCbor(ur.cbor());
+}
+
+/**
+ * Concrete equivalent of Rust's default `URDecodable::from_ur_string` impl
+ * (`bc-ur-rust/src/ur_decodable.rs:17-22`):
+ * `Self::from_ur(UR::from_ur_string(s)?)`.
+ */
+export function decodableFromURString<T>(decodable: CborTaggedDecodable<T>, urString: string): T {
+  return decodableFromUR(decodable, UR.fromURString(urString));
+}
+
 /**
  * Helper function to check if an object implements URDecodable.
  */

package/src/ur-encodable.ts

@@ -1,4 +1,12 @@
-import type { UR } from "./ur.js";
+/**
+ * Copyright © 2023-2026 Blockchain Commons, LLC
+ * Copyright © 2025-2026 Parity Technologies
+ *
+ */
+
+import type { CborTaggedEncodable } from "@bcts/dcbor";
+
+import { UR } from "./ur.js";
 
 /**
  * A type that can be encoded to a UR (Uniform Resource).
@@ -6,17 +14,27 @@ import type { UR } from "./ur.js";
  * Types implementing this interface should be able to convert themselves
  * to CBOR data and associate that with a UR type identifier.
  *
+ * Mirrors Rust's `UREncodable` trait (`bc-ur-rust/src/ur_encodable.rs`),
+ * which has a blanket impl `impl<T> UREncodable for T where T:
+ * CBORTaggedEncodable`. TypeScript has no equivalent of blanket impls, so
+ * implementers either write `ur()` / `urString()` directly *or* — for a
+ * type that already implements `CborTaggedEncodable` — call the helper
+ * functions {@link urFromEncodable} / {@link urStringFromEncodable} below
+ * to get the same auto-derivation that Rust provides for free.
+ *
  * @example
  * ```typescript
- * class MyType implements UREncodable {
- *   toCBOR(): CBOR {
- *     // Convert to CBOR
+ * class MyType implements UREncodable, CborTaggedEncodable {
+ *   cborTags(): Tag[] {
+ *     return [createTag(40000, "mytype")];
  *   }
  *
- *   ur(): UR {
- *     const cbor = this.toCBOR();
- *     return UR.new('mytype', cbor);
- *   }
+ *   untaggedCbor(): Cbor { ... }
+ *   taggedCbor(): Cbor { return createTaggedCbor(this); }
+ *
+ *   // Auto-derived from the first cbor tag's name, just like Rust.
+ *   ur(): UR { return urFromEncodable(this); }
+ *   urString(): string { return urStringFromEncodable(this); }
  * }
  * ```
  */
@@ -32,6 +50,40 @@ export interface UREncodable {
   urString(): string;
 }
 
+/**
+ * Concrete equivalent of Rust's default `UREncodable::ur` impl
+ * (`bc-ur-rust/src/ur_encodable.rs:8-18`):
+ *
+ * - Reads the first tag returned by `encodable.cborTags()`.
+ * - Uses that tag's `name` as the UR type, throwing if no name is set —
+ *   matching Rust's `panic!("CBOR tag {} must have a name. Did you call
+ *   `register_tags()`?", tag.value())`.
+ * - Wraps the encodable's `untaggedCbor()` in a fresh {@link UR} bound to
+ *   that type.
+ *
+ * Use from a class implementing both `UREncodable` and
+ * `CborTaggedEncodable` to skip writing the boilerplate yourself.
+ */
+export function urFromEncodable(encodable: CborTaggedEncodable): UR {
+  const tags = encodable.cborTags();
+  const tag = tags[0];
+  if (tag === undefined) {
+    throw new Error("UREncodable: cborTags() returned no tags");
+  }
+  if (tag.name === undefined) {
+    throw new Error(`CBOR tag ${tag.value} must have a name. Did you call register_tags()?`);
+  }
+  return UR.new(tag.name, encodable.untaggedCbor());
+}
+
+/**
+ * Concrete equivalent of Rust's default `UREncodable::ur_string` impl
+ * (`bc-ur-rust/src/ur_encodable.rs:21`): `self.ur().string()`.
+ */
+export function urStringFromEncodable(encodable: CborTaggedEncodable): string {
+  return urFromEncodable(encodable).string();
+}
+
 /**
  * Helper function to check if an object implements UREncodable.
  */

package/src/ur-type.ts

@@ -1,3 +1,9 @@
+/**
+ * Copyright © 2023-2026 Blockchain Commons, LLC
+ * Copyright © 2025-2026 Parity Technologies
+ *
+ */
+
 import { InvalidTypeError } from "./error";
 import { isValidURType } from "./utils";
 
@@ -72,16 +78,36 @@ export class URType {
   }
 
   /**
-   * Safely creates a URType, returning an error if invalid.
+   * Safely creates a URType, returning a typed `Result`-shaped
+   * discriminated union instead of throwing.
+   *
+   * Mirrors Rust `impl TryFrom<&str> for URType` /
+   * `impl TryFrom<String> for URType` (`bc-ur-rust/src/ur_type.rs`),
+   * which return `Result<URType, Error>`. The TS shape is the
+   * idiomatic discriminated form so callers can branch on `ok`
+   * without `instanceof`:
+   *
+   * @example
+   * ```typescript
+   * const r = URType.tryFrom("test");
+   * if (r.ok) {
+   *   console.log(r.value.string()); // "test"
+   * } else {
+   *   console.error(r.error.message);
+   * }
+   * ```
    *
    * @param value - The UR type string
-   * @returns Either a URType or an error
+   * @returns A typed Result: `{ ok: true; value: URType }` on success,
+   *   `{ ok: false; error: InvalidTypeError }` on failure.
    */
-  static tryFrom(value: string): URType | InvalidTypeError {
+  static tryFrom(
+    value: string,
+  ): { ok: true; value: URType } | { ok: false; error: InvalidTypeError } {
     try {
-      return new URType(value);
+      return { ok: true, value: new URType(value) };
     } catch (error) {
-      return error as InvalidTypeError;
+      return { ok: false, error: error as InvalidTypeError };
     }
   }
 }

package/src/ur.ts

@@ -1,6 +1,20 @@
+/**
+ * Copyright © 2023-2026 Blockchain Commons, LLC
+ * Copyright © 2025-2026 Parity Technologies
+ *
+ */
+
 import type { Cbor } from "@bcts/dcbor";
 import { decodeCbor } from "@bcts/dcbor";
-import { InvalidSchemeError, TypeUnspecifiedError, UnexpectedTypeError, URError } from "./error.js";
+import {
+  BytewordsError,
+  CBORError,
+  InvalidSchemeError,
+  NotSinglePartError,
+  TypeUnspecifiedError,
+  UnexpectedTypeError,
+  URDecodeError,
+} from "./error.js";
 import { URType } from "./ur-type.js";
 import { encodeBytewords, decodeBytewords, BytewordsStyle } from "./utils.js";
 
@@ -51,11 +65,26 @@ export class UR {
   /**
    * Creates a new UR from a UR string.
    *
+   * Mirrors Rust's `UR::from_ur_string` (`bc-ur-rust/src/ur.rs:25-38`):
+   * 1. lowercase the entire string.
+   * 2. strip the `"ur:"` prefix → {@link InvalidSchemeError} if absent.
+   * 3. split on the first `/` → {@link TypeUnspecifiedError} if absent.
+   * 4. validate the type via {@link URType} → {@link InvalidTypeError}.
+   * 5. delegate the data section to the upstream-style decoder, which
+   *    classifies the UR as single- or multi-part. Multi-part input is
+   *    rejected with {@link NotSinglePartError}.
+   * 6. decode the bytewords payload (CRC32 + minimal mapping) →
+   *    {@link BytewordsError} on failure.
+   * 7. parse the resulting bytes as CBOR → {@link CBORError} on failure.
+   *
    * @param urString - A UR string like "ur:test/..."
    * @throws {InvalidSchemeError} If the string doesn't start with "ur:"
-   * @throws {TypeUnspecifiedError} If no type is specified
+   * @throws {TypeUnspecifiedError} If no `/` separator is present
+   * @throws {InvalidTypeError} If the type contains invalid characters
    * @throws {NotSinglePartError} If the UR is multi-part
-   * @throws {URError} If decoding fails
+   * @throws {URDecodeError} For upstream-decoder errors (invalid indices, etc.)
+   * @throws {BytewordsError} If bytewords decoding fails
+   * @throws {CBORError} If CBOR parsing fails
    *
    * @example
    * ```typescript
@@ -63,13 +92,8 @@ export class UR {
    * ```
    */
   static fromURString(urString: string): UR {
-    // Decode the UR string to get the type and CBOR data
-    const decodedUR = URStringDecoder.decode(urString);
-    if (decodedUR === null || decodedUR === undefined) {
-      throw new URError("Failed to decode UR string");
-    }
-    const { urType, cbor } = decodedUR;
-    return new UR(new URType(urType), cbor);
+    const { urType, cbor } = URStringDecoder.decode(urString);
+    return new UR(urType, cbor);
   }
 
   private constructor(urType: URType, cbor: Cbor) {
@@ -121,15 +145,15 @@ export class UR {
 
   /**
    * Returns the QR data as bytes (uppercase UR string as UTF-8).
+   *
+   * Mirrors Rust's `UR::qr_data` (`ur.rs:52`) which does
+   * `self.qr_string().as_bytes().to_vec()` — the string's UTF-8 byte
+   * representation. We use `TextEncoder` rather than per-codepoint
+   * truncation so the behaviour stays correct if the QR string ever
+   * contains non-ASCII characters.
    */
   qrData(): Uint8Array {
-    // Use a helper to convert string to bytes across platforms
-    const str = this.qrString();
-    const bytes = new Uint8Array(str.length);
-    for (let i = 0; i < str.length; i++) {
-      bytes[i] = str.charCodeAt(i);
-    }
-    return bytes;
+    return new TextEncoder().encode(this.qrString());
   }
 
   /**
@@ -154,12 +178,22 @@ export class UR {
 
   /**
    * Checks equality with another UR.
+   *
+   * Mirrors Rust's derived `PartialEq for UR` which compares the inner
+   * `ur_type` and the inner `cbor` field directly. We compare CBOR
+   * bytewise — `Uint8Array` equality, not `Array#toString` (which would
+   * coerce to a comma-joined string and could collide on pathological
+   * inputs).
    */
   equals(other: UR): boolean {
-    return (
-      this._urType.equals(other._urType) &&
-      this._cbor.toData().toString() === other._cbor.toData().toString()
-    );
+    if (!this._urType.equals(other._urType)) return false;
+    const a = this._cbor.toData();
+    const b = other._cbor.toData();
+    if (a.length !== b.length) return false;
+    for (let i = 0; i < a.length; i++) {
+      if (a[i] !== b[i]) return false;
+    }
+    return true;
   }
 }
 
@@ -177,39 +211,95 @@ class URStringEncoder {
 
 /**
  * Decodes a UR string back to its components.
+ *
+ * Mirrors the validation pipeline of Rust's `UR::from_ur_string`
+ * (`bc-ur-rust/src/ur.rs:25-38`) plus the upstream `ur::decode`
+ * (`ur-0.4.1/src/ur.rs:238-266`):
+ *
+ *   1. lowercase
+ *   2. strip `"ur:"`               → {@link InvalidSchemeError}
+ *   3. find `/`                     → {@link TypeUnspecifiedError}
+ *   4. validate the type            → {@link InvalidTypeError}
+ *   5. classify single- vs multi-part by looking at the data section
+ *   6. multi-part                   → {@link NotSinglePartError}
+ *   7. invalid multi-part indices   → {@link URDecodeError("Invalid indices")}
+ *   8. minimal bytewords decode     → {@link BytewordsError}
+ *   9. CBOR parse                   → {@link CBORError}
  */
 class URStringDecoder {
-  static decode(urString: string): { urType: string; cbor: Cbor } | null {
+  static decode(urString: string): { urType: URType; cbor: Cbor } {
     const lowercased = urString.toLowerCase();
 
-    // Check scheme
+    // Step 2: strip the scheme.
     if (!lowercased.startsWith("ur:")) {
       throw new InvalidSchemeError();
     }
-
-    // Strip scheme
     const afterScheme = lowercased.substring(3);
 
-    // Split into type and data
-    const [urType, ...dataParts] = afterScheme.split("/");
-
-    if (urType === "" || urType === undefined) {
+    // Step 3: locate the first `/`. Matches Rust's `split_once('/')`.
+    const slashIdx = afterScheme.indexOf("/");
+    if (slashIdx === -1) {
       throw new TypeUnspecifiedError();
     }
+    const typeStr = afterScheme.substring(0, slashIdx);
+    const dataSection = afterScheme.substring(slashIdx + 1);
 
-    const data = dataParts.join("/");
-    if (data === "" || data === undefined) {
-      throw new TypeUnspecifiedError();
+    // Step 4: validate the type *before* any bytewords/CBOR work, so that a
+    // malformed payload with an invalid type surfaces InvalidTypeError
+    // rather than a downstream BytewordsError. Mirrors `ur.rs:31`.
+    const urType = new URType(typeStr);
+
+    // Step 5/6/7: classify the data section, the way `ur::decode` does
+    // (`ur-0.4.1/src/ur.rs:249-265`). If the data section contains a `/`,
+    // the prefix is the multi-part `<seqNum>-<seqLen>` indices.
+    const lastSlash = dataSection.lastIndexOf("/");
+    if (lastSlash !== -1) {
+      const indices = dataSection.substring(0, lastSlash);
+      const dashIdx = indices.indexOf("-");
+      if (dashIdx === -1) {
+        throw new URDecodeError("Invalid indices");
+      }
+      const seqNumStr = indices.substring(0, dashIdx);
+      const seqLenStr = indices.substring(dashIdx + 1);
+      // Rust uses `parse::<u16>()`; accept non-empty strings of digits only.
+      // (parseInt on `"1a"` returns 1, so we have to be strict about chars.)
+      if (!/^\d+$/.test(seqNumStr) || !/^\d+$/.test(seqLenStr)) {
+        throw new URDecodeError("Invalid indices");
+      }
+      const seqNum = Number(seqNumStr);
+      const seqLen = Number(seqLenStr);
+      if (seqNum > 0xffff || seqLen > 0xffff) {
+        throw new URDecodeError("Invalid indices");
+      }
+      // Successfully parsed as multi-part — but `from_ur_string` only
+      // accepts single-part input. Mirrors `ur.rs:33-35`.
+      throw new NotSinglePartError();
     }
 
+    // Step 8: minimal bytewords decode (CRC32 + minimal mapping).
+    let cborData: Uint8Array;
     try {
-      // Decode the bytewords-encoded data (validates CRC32 checksum)
-      const cborData = decodeBytewords(data, BytewordsStyle.Minimal);
-      const cbor = decodeCbor(cborData);
-      return { urType, cbor };
+      cborData = decodeBytewords(dataSection, BytewordsStyle.Minimal);
     } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      throw new URError(`Failed to decode UR: ${errorMessage}`);
+      if (error instanceof BytewordsError) {
+        throw error;
+      }
+      const message = error instanceof Error ? error.message : String(error);
+      throw new BytewordsError(message);
     }
+
+    // Step 9: CBOR parse.
+    let cbor: Cbor;
+    try {
+      cbor = decodeCbor(cborData);
+    } catch (error) {
+      if (error instanceof CBORError) {
+        throw error;
+      }
+      const message = error instanceof Error ? error.message : String(error);
+      throw new CBORError(message);
+    }
+
+    return { urType, cbor };
   }
 }