@bcts/uniform-resources 1.0.0-alpha.8 → 1.0.0-beta.0

package/dist/index.d.mts

@@ -1,7 +1,11 @@
-import { Cbor } from "@bcts/dcbor";
+import { Cbor, CborTaggedDecodable, CborTaggedEncodable } from "@bcts/dcbor";
 
 //#region src/error.d.ts
 /**
+ * Copyright © 2023-2026 Blockchain Commons, LLC
+ * Copyright © 2025-2026 Parity Technologies
+ *
+ *
  * Error type for UR encoding/decoding operations.
  */
 declare class URError extends Error {
@@ -9,18 +13,24 @@ declare class URError extends Error {
 }
 /**
  * Error type for invalid UR schemes.
+ *
+ * Message matches Rust bc-ur-rust/src/error.rs: `invalid UR scheme`.
  */
 declare class InvalidSchemeError extends URError {
   constructor();
 }
 /**
  * Error type for unspecified UR types.
+ *
+ * Message matches Rust bc-ur-rust/src/error.rs: `no UR type specified`.
  */
 declare class TypeUnspecifiedError extends URError {
   constructor();
 }
 /**
  * Error type for invalid UR types.
+ *
+ * Message matches Rust bc-ur-rust/src/error.rs: `invalid UR type`.
  */
 declare class InvalidTypeError extends URError {
   constructor();
@@ -33,22 +43,36 @@ declare class NotSinglePartError extends URError {
 }
 /**
  * Error type for unexpected UR types.
+ *
+ * Message matches Rust bc-ur-rust/src/error.rs:
+ * `expected UR type {expected}, but found {found}`.
  */
 declare class UnexpectedTypeError extends URError {
   constructor(expected: string, found: string);
 }
 /**
  * Error type for Bytewords encoding/decoding errors.
+ *
+ * Message matches Rust bc-ur-rust/src/error.rs: `Bytewords error ({0})`.
  */
 declare class BytewordsError extends URError {
   constructor(message: string);
 }
 /**
  * Error type for CBOR encoding/decoding errors.
+ *
+ * Message matches Rust bc-ur-rust/src/error.rs: `CBOR error ({0})`.
  */
 declare class CBORError extends URError {
   constructor(message: string);
 }
+/**
+ * Error type for UR decoder errors.
+ * Matches Rust's Error::UR(String) variant.
+ */
+declare class URDecodeError extends URError {
+  constructor(message: string);
+}
 type Result<T> = T | Error;
 /**
  * Helper function to check if a result is an error.
@@ -108,12 +132,36 @@ declare class URType {
    */
   static from(value: string): 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
-   */
-  static tryFrom(value: string): URType | InvalidTypeError;
+   * @returns A typed Result: `{ ok: true; value: URType }` on success,
+   *   `{ ok: false; error: InvalidTypeError }` on failure.
+   */
+  static tryFrom(value: string): {
+    ok: true;
+    value: URType;
+  } | {
+    ok: false;
+    error: InvalidTypeError;
+  };
 }
 //#endregion
 //#region src/ur.d.ts
@@ -159,11 +207,26 @@ declare 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
@@ -200,6 +263,12 @@ declare class UR {
   qrString(): string;
   /**
    * 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;
   /**
@@ -215,6 +284,12 @@ declare class UR {
   toString(): string;
   /**
    * 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;
 }
@@ -226,17 +301,27 @@ declare class UR {
  * 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); }
  * }
  * ```
  */
@@ -250,6 +335,26 @@ 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.
+ */
+declare function urFromEncodable(encodable: CborTaggedEncodable): UR;
+/**
+ * Concrete equivalent of Rust's default `UREncodable::ur_string` impl
+ * (`bc-ur-rust/src/ur_encodable.rs:21`): `self.ur().string()`.
+ */
+declare function urStringFromEncodable(encodable: CborTaggedEncodable): string;
 /**
  * Helper function to check if an object implements UREncodable.
  */
@@ -262,17 +367,26 @@ declare function isUREncodable(obj: unknown): obj is UREncodable;
  * 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); }
  * }
  * ```
  */
@@ -297,6 +411,26 @@ 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.
+ */
+declare function decodableFromUR<T>(decodable: CborTaggedDecodable<T>, ur: UR): T;
+/**
+ * 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)?)`.
+ */
+declare function decodableFromURString<T>(decodable: CborTaggedDecodable<T>, urString: string): T;
 /**
  * Helper function to check if an object implements URDecodable.
  */
@@ -382,12 +516,6 @@ declare class MultipartEncoder {
    * ```
    */
   constructor(ur: UR, maxFragmentLen: number);
-  /**
-   * Returns whether the message fits in a single part.
-   *
-   * For single-part messages, consider using UR.string() directly.
-   */
-  isSinglePart(): boolean;
   /**
    * Gets the next part of the encoding.
    *
@@ -405,10 +533,17 @@ declare class MultipartEncoder {
   nextPart(): string;
   /**
    * 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;
   /**
-   * 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;
   /**
@@ -422,17 +557,6 @@ declare class MultipartEncoder {
    * for additional redundancy.
    */
   partsCount(): number;
-  /**
-   * 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;
-  /**
-   * Resets the encoder to start from the beginning.
-   */
-  reset(): void;
 }
 //#endregion
 //#region src/multipart-decoder.d.ts
@@ -473,6 +597,8 @@ declare class MultipartDecoder {
   private _parsePart;
   /**
    * Decodes a multipart UR's fountain part data.
+   *
+   * The multipart body is a CBOR array: [seqNum, seqLen, messageLen, checksum, data]
    */
   private _decodeFountainPart;
   /**
@@ -485,226 +611,29 @@ declare class MultipartDecoder {
    * @returns The decoded UR, or null if not yet complete
    */
   message(): UR | null;
-  /**
-   * Returns the decoding progress as a fraction (0 to 1).
-   */
-  progress(): number;
-  /**
-   * Resets the decoder to receive a new message.
-   */
-  reset(): void;
-}
-//#endregion
-//#region src/fountain.d.ts
-/**
- * Fountain code implementation for multipart URs.
- *
- * This implements a hybrid fixed-rate and rateless fountain code system
- * as specified in BCR-2020-005 and BCR-2024-001.
- *
- * Key concepts:
- * - Parts 1-seqLen are "pure" fragments (fixed-rate)
- * - Parts > seqLen are "mixed" fragments using XOR (rateless)
- * - Xoshiro256** PRNG ensures encoder/decoder agree on mixing
- */
-/**
- * Represents a fountain code part with metadata.
- */
-interface FountainPart {
-  /** Sequence number (1-based) */
-  seqNum: number;
-  /** Total number of pure fragments */
-  seqLen: number;
-  /** Length of original message */
-  messageLen: number;
-  /** CRC32 checksum of original message */
-  checksum: number;
-  /** Fragment data */
-  data: Uint8Array;
-}
-/**
- * Splits data into fragments of the specified size.
- */
-declare function splitMessage(message: Uint8Array, fragmentLen: number): Uint8Array[];
-/**
- * XOR two Uint8Arrays together.
- */
-declare function xorBytes(a: Uint8Array, b: Uint8Array): Uint8Array;
-/**
- * Chooses which fragments to mix for a given sequence number.
- *
- * This uses a seeded Xoshiro256** PRNG to deterministically select fragments,
- * ensuring encoder and decoder agree without explicit coordination.
- *
- * @param seqNum - The sequence number (1-based)
- * @param seqLen - Total number of pure fragments
- * @param checksum - CRC32 checksum of the message
- * @returns Array of fragment indices (0-based)
- */
-declare function chooseFragments(seqNum: number, seqLen: number, checksum: number): number[];
-/**
- * Mixes the selected fragments using XOR.
- */
-declare function mixFragments(fragments: Uint8Array[], indices: number[]): Uint8Array;
-/**
- * Fountain encoder for creating multipart URs.
- */
-declare class FountainEncoder {
-  private readonly fragments;
-  private readonly messageLen;
-  private readonly checksum;
-  private seqNum;
-  /**
-   * Creates a fountain encoder for the given message.
-   *
-   * @param message - The message to encode
-   * @param maxFragmentLen - Maximum length of each fragment
-   */
-  constructor(message: Uint8Array, maxFragmentLen: number);
-  /**
-   * Returns the number of pure fragments.
-   */
-  get seqLen(): number;
-  /**
-   * Returns whether the message fits in a single part.
-   */
-  isSinglePart(): boolean;
-  /**
-   * Returns whether all pure parts have been emitted.
-   */
-  isComplete(): boolean;
-  /**
-   * Generates the next fountain part.
-   */
-  nextPart(): FountainPart;
-  /**
-   * Returns the current sequence number.
-   */
-  currentSeqNum(): number;
-  /**
-   * Resets the encoder to start from the beginning.
-   */
-  reset(): void;
-}
-/**
- * Fountain decoder for reassembling multipart URs.
- */
-declare class FountainDecoder {
-  private seqLen;
-  private messageLen;
-  private checksum;
-  private readonly pureFragments;
-  private readonly mixedParts;
-  /**
-   * Receives a fountain part and attempts to decode.
-   *
-   * @param part - The fountain part to receive
-   * @returns true if the message is now complete
-   */
-  receive(part: FountainPart): boolean;
-  /**
-   * Attempts to extract pure fragments from mixed parts.
-   */
-  private reduceMixedParts;
-  /**
-   * Returns whether all fragments have been received.
-   */
-  isComplete(): boolean;
-  /**
-   * Reconstructs the original message.
-   *
-   * @returns The original message, or null if not yet complete
-   */
-  message(): Uint8Array | null;
-  /**
-   * Returns the progress as a fraction (0 to 1).
-   */
-  progress(): number;
-  /**
-   * Resets the decoder.
-   */
-  reset(): void;
 }
 //#endregion
-//#region src/xoshiro.d.ts
-/**
- * Xoshiro256** PRNG implementation.
- *
- * This is a high-quality, fast pseudo-random number generator used
- * for deterministic fragment selection in fountain codes.
- *
- * Reference: https://prng.di.unimi.it/
- */
-/**
- * Xoshiro256** pseudo-random number generator.
- *
- * This PRNG is used for deterministic mixing in fountain codes,
- * allowing both encoder and decoder to agree on which fragments
- * are combined without transmitting that information.
- */
-declare class Xoshiro256 {
-  private s;
-  /**
-   * Creates a new Xoshiro256** instance from a seed.
-   *
-   * The seed is hashed using SHA-256 to initialize the state.
-   * For consistent results across encoder/decoder, use the same seed.
-   *
-   * @param seed - The seed bytes (any length)
-   */
-  constructor(seed: Uint8Array);
-  /**
-   * Creates a Xoshiro256** instance from raw state values.
-   * Useful for seeding with specific values.
-   */
-  static fromState(s0: bigint, s1: bigint, s2: bigint, s3: bigint): Xoshiro256;
-  /**
-   * Simple hash function for seeding.
-   * This is a basic implementation - in production use SHA-256.
-   */
-  private hashSeed;
-  /**
-   * Converts 8 bytes to a 64-bit BigInt (little-endian).
-   */
-  private bytesToBigInt;
-  /**
-   * Generates the next 64-bit random value.
-   */
-  next(): bigint;
-  /**
-   * Generates a random double in [0, 1).
-   */
-  nextDouble(): number;
-  /**
-   * Generates a random integer in [low, high).
-   */
-  nextInt(low: number, high: number): number;
-  /**
-   * Generates a random byte [0, 255].
-   */
-  nextByte(): number;
-  /**
-   * Generates an array of random bytes.
-   */
-  nextData(count: number): Uint8Array;
-}
+//#region src/utils.d.ts
 /**
- * Creates a seed for the Xoshiro PRNG from message checksum and sequence number.
+ * Copyright © 2023-2026 Blockchain Commons, LLC
+ * Copyright © 2025-2026 Parity Technologies
  *
- * This ensures that both encoder and decoder produce the same random sequence
- * for a given message and part number.
  */
-declare function createSeed(checksum: number, seqNum: number): Uint8Array;
-//#endregion
-//#region src/utils.d.ts
 /**
  * Checks if a character is a valid UR type character.
- * Valid characters are lowercase letters, digits, and hyphens.
+ *
+ * Mirrors Rust's `URTypeChar::is_ur_type` (`bc-ur-rust/src/utils.rs:6-19`):
+ * lowercase a-z, digits 0-9, and the hyphen `-`.
  */
 declare function isURTypeChar(char: string): boolean;
 /**
  * Checks if a string is a valid UR type.
- * Valid UR types contain only lowercase letters, digits, and hyphens.
+ *
+ * Mirrors Rust's `URTypeString::is_ur_type` (`bc-ur-rust/src/utils.rs:26-32`)
+ * which is `self.chars().all(...)` — meaning **the empty string is accepted**
+ * (a vacuously-true `all` over no chars). We mirror that here so that
+ * `URType::new("")` succeeds in both ports; the round-trip then fails at
+ * decode-time with `TypeUnspecified`.
  */
 declare function isValidURType(urType: string): boolean;
 /**
@@ -716,36 +645,78 @@ declare function validateURType(urType: string): string;
  * See: https://github.com/BlockchainCommons/Research/blob/master/papers/bcr-2020-004-bytewords.md
  */
 declare const BYTEWORDS: string[];
-declare const BYTEWORDS_MAP: Map<string, number>;
 /**
  * Bytemojis for encoding/decoding bytes as emojis.
  * See: https://github.com/BlockchainCommons/Research/blob/master/papers/bcr-2024-008-bytemoji.md
  */
 declare const BYTEMOJIS: string[];
+/**
+ * Encodes an arbitrary byte slice as a string of space-separated bytewords.
+ *
+ * Mirrors `bytewords::encode_to_words` in `bc-ur-rust` (≥ v0.19.1). Does not
+ * add a CRC32 checksum — use {@link encodeBytewords} for UR-style encoding.
+ */
+declare function encodeToWords(data: Uint8Array): string;
+/**
+ * Encodes an arbitrary byte slice as a string of space-separated bytemojis.
+ *
+ * Mirrors `bytewords::encode_to_bytemojis` in `bc-ur-rust` (≥ v0.19.1).
+ */
+declare function encodeToBytemojis(data: Uint8Array): string;
+/**
+ * Encodes an arbitrary byte slice as minimal bytewords (first + last letter of
+ * each word, concatenated with no separator).
+ *
+ * Mirrors `bytewords::encode_to_minimal_bytewords` in `bc-ur-rust`
+ * (≥ v0.19.1). Does not add a CRC32 checksum.
+ */
+declare function encodeToMinimalBytewords(data: Uint8Array): string;
 /**
  * Encodes a 4-byte slice as a string of bytewords for identification.
+ *
+ * Thin wrapper over {@link encodeToWords} that enforces the 4-byte length
+ * contract historically used by `bc-ur-rust`'s `bytewords::identifier`.
  */
 declare function encodeBytewordsIdentifier(data: Uint8Array): string;
 /**
  * Encodes a 4-byte slice as a string of bytemojis for identification.
+ *
+ * Thin wrapper over {@link encodeToBytemojis} that enforces the 4-byte length
+ * contract historically used by `bc-ur-rust`'s `bytewords::bytemoji_identifier`.
  */
 declare function encodeBytemojisIdentifier(data: Uint8Array): string;
+/**
+ * Returns `true` if `emoji` is one of the 256 bytemojis.
+ *
+ * Mirrors `bytewords::is_valid_bytemoji` in `bc-ur-rust` (≥ v0.19.1).
+ */
+declare function isValidBytemoji(emoji: string): boolean;
+/**
+ * Canonicalises a byteword token (2–4 ASCII letters, case-insensitive) to its
+ * full 4-letter lowercase form. Returns `undefined` if the token is not a
+ * valid byteword or any of its short forms.
+ *
+ * Mirrors `bytewords::canonicalize_byteword` in `bc-ur-rust` (≥ v0.19.1).
+ *
+ * - 2-letter tokens are matched against the first + last letter of each
+ *   byteword (identical to the minimal bytewords encoding).
+ * - 3-letter tokens are matched against the first 3 and the last 3 letters of
+ *   each byteword; if both match different entries, the first-3 match wins
+ *   (matching rust's `or_else` priority).
+ * - 4-letter tokens must exactly match a full byteword (after lower-casing).
+ */
+declare function canonicalizeByteword(token: string): string | undefined;
 /**
  * Bytewords encoding style.
  */
 declare enum BytewordsStyle {
   /** Full 4-letter words separated by spaces */
   Standard = "standard",
-  /** Full 4-letter words without separators */
+  /** Full 4-letter words separated by hyphens (URI-safe) */
   Uri = "uri",
   /** First and last character only (minimal) - used by UR encoding */
-  Minimal = "minimal",
+  Minimal = "minimal"
 }
-declare const MINIMAL_BYTEWORDS_MAP: Map<string, number>;
-/**
- * Calculate CRC32 checksum of data.
- */
-declare function crc32(data: Uint8Array): number;
 /**
  * Encode data as bytewords with the specified style.
  * Includes CRC32 checksum.
@@ -754,8 +725,23 @@ declare function encodeBytewords(data: Uint8Array, style?: BytewordsStyle): stri
 /**
  * Decode bytewords string back to data.
  * Validates and removes CRC32 checksum.
+ *
+ * Errors mirror the upstream Rust `ur::bytewords::Error` enum
+ * (`ur-0.4.1/src/bytewords.rs`):
+ * - `NonAscii` — input contains non-ASCII characters (checked first).
+ * - `InvalidLength` — minimal-style input has odd length.
+ * - `InvalidWord` — a token does not map to a byteword index.
+ * - `InvalidChecksum` — the trailing 4-byte CRC32 does not match.
+ *
+ * All variants are surfaced as {@link BytewordsError} with the same default
+ * `Display` strings as Rust (e.g. "invalid checksum", "non-ASCII"), so
+ * callers can branch on the error class rather than the bare `Error`
+ * thrown by earlier revisions of this port.
  */
 declare function decodeBytewords(encoded: string, style?: BytewordsStyle): Uint8Array;
+declare namespace bytewords_namespace_d_exports {
+  export { BYTEMOJIS, BYTEWORDS, BytewordsStyle as Style, encodeBytemojisIdentifier as bytemojiIdentifier, canonicalizeByteword, decodeBytewords as decode, encodeBytewords as encode, encodeToBytemojis, encodeToMinimalBytewords, encodeToWords, encodeBytewordsIdentifier as identifier, isValidBytemoji };
+}
 //#endregion
-export { BYTEMOJIS, BYTEWORDS, BYTEWORDS_MAP, BytewordsError, BytewordsStyle, CBORError, FountainDecoder, FountainEncoder, type FountainPart, InvalidSchemeError, InvalidTypeError, MINIMAL_BYTEWORDS_MAP, MultipartDecoder, MultipartEncoder, NotSinglePartError, type Result, TypeUnspecifiedError, UR, type URCodable, type URDecodable, type UREncodable, URError, URType, UnexpectedTypeError, Xoshiro256, chooseFragments, crc32, createSeed, decodeBytewords, encodeBytemojisIdentifier, encodeBytewords, encodeBytewordsIdentifier, isError, isURCodable, isURDecodable, isUREncodable, isURTypeChar, isValidURType, mixFragments, splitMessage, validateURType, xorBytes };
+export { BYTEMOJIS, BYTEWORDS, BytewordsError, BytewordsStyle, CBORError, InvalidSchemeError, InvalidTypeError, MultipartDecoder, MultipartEncoder, NotSinglePartError, type Result, TypeUnspecifiedError, UR, type URCodable, type URDecodable, URDecodeError, type UREncodable, URError, URType, UnexpectedTypeError, bytewords_namespace_d_exports as bytewords, canonicalizeByteword, decodableFromUR, decodableFromURString, decodeBytewords, encodeBytemojisIdentifier, encodeBytewords, encodeBytewordsIdentifier, encodeToBytemojis, encodeToMinimalBytewords, encodeToWords, isError, isURCodable, isURDecodable, isUREncodable, isURTypeChar, isValidBytemoji, isValidURType, urFromEncodable, urStringFromEncodable, validateURType };
 //# sourceMappingURL=index.d.mts.map