@brashkie/signalis-core 0.3.1 → 0.4.0

package/CHANGELOG.md

@@ -5,6 +5,94 @@ All notable changes to `@brashkie/signalis-core` are documented here.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.4.0] — 2026-07-08
+
+### ✨ Added — Encoding helpers + Android x86_64
+
+v0.4.0 introduces native encoding helpers (Base64, Hex, UTF-8) and adds
+Android x86_64 to the supported platform list. Fully backwards compatible
+with v0.3.x.
+
+#### 🆕 Encoding namespaces (Rust-side implementations)
+
+Three new namespaces exported from the top level, backed by the new
+`sc-encoding` crate. All operations are audited RustCrypto ecosystem
+routines with strict validation (no lossy conversions).
+
+- **`Base64`**
+  - `encode(bytes) → string` — RFC 4648 standard (with `=` padding)
+  - `decode(string) → Buffer` — throws on invalid input
+  - `encodeUrlSafe(bytes) → string` — `-` and `_` alphabet, no padding
+  - `decodeUrlSafe(string) → Buffer`
+
+- **`Hex`**
+  - `encode(bytes) → string` — lowercase output
+  - `encodeUpper(bytes) → string` — uppercase output
+  - `decode(string) → Buffer` — case-insensitive
+  - `isValid(string) → boolean` — cheap format check
+
+- **`Utf8`**
+  - `encode(string) → Buffer` — UTF-8 bytes
+  - `decode(bytes) → string` — **strict** validation, throws on invalid
+    UTF-8 (unlike `Buffer.toString('utf-8')` which silently substitutes U+FFFD)
+  - `isValid(bytes) → boolean`
+
+Quick example:
+
+```typescript
+import { Base64, Hex, Utf8 } from '@brashkie/signalis-core';
+
+const bytes = Utf8.encode('Hola 🦀');
+const b64 = Base64.encode(bytes);          // 'SG9sYSDwn6aA'
+const hex = Hex.encode(bytes);             // '486f6c6120f09fa680'
+const back = Utf8.decode(Base64.decode(b64)); // 'Hola 🦀'
+```
+
+#### 🆕 New crate: `sc-encoding`
+
+A dedicated Rust crate for encoding routines, separated from `sc-utils`
+to keep encoding logic isolated from cryptographic utilities. This makes
+the codebase easier to audit and lets adopters pull in just what they need.
+
+Dependencies (all RustCrypto ecosystem):
+- `base64` v0.22 — RFC 4648 encoder/decoder
+- `hex` v0.4 — Base16 encoder/decoder
+- Rust standard library for UTF-8 validation
+
+#### 🆕 Android x86_64 support
+
+New sub-package `@brashkie/signalis-core-android-x64` published to npm.
+Primary use cases:
+- **Android Emulator** — runs x86_64, so devs testing apps in Android
+  Studio's emulator now get native binaries automatically
+- **Termux on x86 tablets / Chromebooks** — install via
+  `pkg install nodejs && npm install @brashkie/signalis-core`
+
+Total platforms supported: **10** (was 9 in v0.3.1).
+
+### 🔄 Changed
+- `VERSION` bumped to `'0.4.0'`
+- `Cargo.toml` workspace: version 0.3.x → 0.4.0
+- `sc-node`: 10 new `#[napi]` exports for the encoding functions
+- `optionalDependencies` in `package.json`: adds `android-x64` (10 sub-packages total)
+- `napi.triples.additional`: adds `x86_64-linux-android`
+- `.github/workflows/release.yml`: adds `x86_64-linux-android` build job
+- `scripts/create-npm-dirs.js`: adds `android-x64` to `PLATFORMS` array
+
+### ✅ Compatibility
+**100% backwards compatible with v0.3.x.** No API changes. No breaking
+behavior. Existing code continues to work; the encoding namespaces are
+purely additive.
+
+### 📋 What's next (v0.5.0 candidates)
+- Buffer / ByteArray utility helpers (`sc-encoding` extension)
+- XChaCha20-Poly1305 (extended-nonce AEAD)
+- Argon2id password hashing
+- PBKDF2-SHA256
+- HKDF-SHA512
+
+---
+
 ## [0.3.0] — 2026-06-17
 
 ### ✨ Added — Multi-Platform Expansion + New Primitives

package/README.es.md

@@ -32,6 +32,71 @@ Construida con **Rust** para seguridad y velocidad, expuesta a Node.js mediante
 
 ---
 
+## 🎉 Novedades en v0.4.0
+
+**v0.4.0 introduce helpers nativos de encoding (Base64, Hex, UTF-8) + soporte para Android x86_64 — totalmente retrocompatible con v0.3.x.**
+
+| Nuevo | Descripción |
+|-------|-------------|
+| 🆕 **Namespace `Base64`** | RFC 4648 estándar + variante URL-safe (sin padding), implementación Rust |
+| 🆕 **Namespace `Hex`** | Encode minúsculas/mayúsculas, decode case-insensitive, `isValid()` chequeo rápido |
+| 🆕 **Namespace `Utf8`** | Validación UTF-8 **estricta** — tira error en bytes malformados (a diferencia de `Buffer.toString('utf-8')` que sustituye silenciosamente por U+FFFD) |
+| 🆕 **Android x86_64** | Binario nativo para el Android Emulator + Chromebooks + tablets x86 |
+| 🆕 **Crate `sc-encoding`** | Crate Rust dedicado — separa la lógica de encoding de la criptografía para facilitar auditoría |
+
+### Ejemplo rápido: Base64 / Hex / Utf8
+
+```ts
+import { Base64, Hex, Utf8 } from '@brashkie/signalis-core';
+
+// UTF-8 con validación estricta
+const bytes = Utf8.encode('Hola 🦀');           // Buffer <48 6f 6c 61 20 f0 9f a6 80>
+const roundTrip = Utf8.decode(bytes);            // "Hola 🦀"
+
+// Base64 estándar (con padding)
+const b64 = Base64.encode(bytes);                // "SG9sYSDwn6aA"
+const decoded = Base64.decode(b64);              // coincide con el original
+
+// Base64 URL-safe (sin padding, sin + ni /)
+const urlSafe = Base64.encodeUrlSafe(bytes);     // seguro en URLs, filenames, JWTs
+
+// Hex
+const hex = Hex.encode(bytes);                   // "486f6c6120f09fa680"
+const hexUpper = Hex.encodeUpper(bytes);         // "486F6C6120F09FA680"
+const back = Hex.decode('DEADBEEF');             // case-insensitive
+Hex.isValid('deadbeef');                          // true
+Hex.isValid('nope!');                             // false
+
+// Validación UTF-8 (barata, sin allocation)
+Utf8.isValid(Buffer.from([0xff]));                // false (0xff nunca es UTF-8 válido)
+```
+
+### ¿Por qué importa la validación UTF-8 estricta?
+
+El `Buffer.toString('utf-8')` nativo de Node **sustituye silenciosamente por U+FFFD** (el carácter de reemplazo) cuando encuentra bytes inválidos. Para código de aplicación normal está bien. Pero cuando estás procesando mensajes firmados, verificando MACs, o manejando input de un atacante potencial, **querés saber** si los bytes están malformados en lugar de continuar con datos silenciosamente corruptos.
+
+```ts
+const badBytes = Buffer.from([0xff, 0xfe]);
+
+// Node built-in: no error, produce "\uFFFD\uFFFD"
+badBytes.toString('utf-8');
+
+// signalis-core: tira error
+Utf8.decode(badBytes);  // → RangeError
+```
+
+### Casos de uso de Android x86_64
+
+- **Android Emulator** (Android Studio) — el emulador corre x86_64, así que devs testeando apps ahora obtienen binarios nativos automáticamente
+- **Termux en Chromebooks / tablets x86** — `pkg install nodejs && npm install @brashkie/signalis-core`
+- **NodeJS-on-Android** con device farms x86
+
+**Total de plataformas soportadas ahora: 10** (era 9 en v0.3.1).
+
+Ver [CHANGELOG.md](./CHANGELOG.md) para todos los detalles.
+
+---
+
 ## 🎉 Novedades en v0.3.0
 
 **v0.3.0 trae soporte Android + ChaCha20-Poly1305 — totalmente retrocompatible con v0.2.0.**
@@ -83,7 +148,7 @@ Ver [MIGRATION.md](./MIGRATION.md) para detalles de upgrade (es un drop-in repla
 
 ## 🌍 Plataformas Soportadas
 
-`@brashkie/signalis-core` envía binarios nativos pre-compilados para **9 plataformas** vía `optionalDependencies` de npm. El binario correcto se descarga automáticamente según tu sistema operativo + arquitectura.
+`@brashkie/signalis-core` envía binarios nativos pre-compilados para **10 plataformas** vía `optionalDependencies` de npm. El binario correcto se descarga automáticamente según tu sistema operativo + arquitectura.
 
 | SO | Arquitectura | Sub-paquete | Estado |
 |----|--------------|-------------|--------|
@@ -96,13 +161,16 @@ Ver [MIGRATION.md](./MIGRATION.md) para detalles de upgrade (es un drop-in repla
 | 🪟 Windows | arm64 | `signalis-core-win32-arm64-msvc` | ✅ |
 | 🤖 Android | arm64-v8a | `signalis-core-android-arm64` | 🆕 v0.3.0 |
 | 🤖 Android | armv7 | `signalis-core-android-arm-eabi` | 🆕 v0.3.0 |
+| 🤖 Android | x86_64 | `signalis-core-android-x64` | 🆕 v0.4.0 |
 
-Próximas plataformas en v0.4.0: **iOS arm64**, **WASM (navegadores)**, **FreeBSD x64**.
+Próximas plataformas: **WASM (navegadores)**, **iOS arm64**, **FreeBSD x64**, **RISC-V**.
 
 ### Instalación en Android
 
 El mismo `npm install` funciona en cualquier entorno Node.js corriendo en Android, incluyendo:
 - **Termux** en celulares Android (`pkg install nodejs`)
+- **Termux en Chromebooks / tablets x86** → usa el binario `android-x64` automáticamente
+- **Android Emulator** (Android Studio) → host x86_64, usa el binario `android-x64`
 - **React Native** con target Android
 - Apps con **NodeJS-Mobile**
 - Builds personalizados de Node embebido para IoT
@@ -111,7 +179,7 @@ El mismo `npm install` funciona en cualquier entorno Node.js corriendo en Androi
 # En Android (Termux por ejemplo):
 pkg install nodejs
 npm install @brashkie/signalis-core
-# → npm descarga automáticamente signalis-core-android-arm64
+# → npm descarga automáticamente el sub-paquete correcto para tu arquitectura
 ```
 
 ---
@@ -148,7 +216,7 @@ npm install @brashkie/signalis-core
 | 📦 **Paquete Dual** | Funciona en proyectos CommonJS, ESM y TypeScript |
 | 🎯 **Tipado Estricto** | Definiciones TypeScript completas con tipos branded y clases de error |
 | ✅ **Vectores de Test** | Validado contra RFC 5869, RFC 7748, RFC 8032, RFC 4231 y vectores NIST |
-| 🌍 **Multi-Plataforma** | Binarios pre-compilados para Windows, macOS, Linux (x64, ARM) + **Android arm64/armv7** |
+| 🌍 **Multi-Plataforma** | Binarios pre-compilados para Windows, macOS, Linux (x64, ARM) + **Android arm64/armv7/x86_64** |
 | 🔒 **Tiempo Constante** | Comparaciones resistentes a side-channel via crate `subtle` |
 | 🧹 **Auto-Borrado** | Secretos se borran de memoria automáticamente |
 | 📊 **Cobertura 99%+** | Suite de tests con 269+ aserciones |
@@ -498,6 +566,44 @@ ChaCha20Poly1305.TAG_SIZE;     // 16 (anexado al ciphertext)
 
 **Seguridad:** ChaCha20-Poly1305 y AES-GCM tienen propiedades de seguridad equivalentes. La decisión es puramente sobre rendimiento en tu target.
 
+### Base64 / Hex / UTF-8 🆕
+
+Helpers nativos (Rust-side) de codificación introducidos en v0.4.0. Respaldados por el crate `sc-encoding`, que usa el ecosistema RustCrypto auditado (crates `base64` y `hex`) más la validación UTF-8 estricta integrada de Rust.
+
+**¿Por qué no simplemente usar `Buffer.toString('base64')` de Node?**
+- `Buffer.toString('utf-8')` sustituye silenciosamente `U+FFFD` en bytes inválidos. El nuestro tira error — mejor para verificación de firmas, parsing forense, input adversarial.
+- Superficie de error consistente en toda la librería (mismo shape de `RangeError` que las primitivas criptográficas).
+- Misma superficie de auditoría — un crate para revisar, no "lo que sea que Node envíe".
+
+```typescript
+import { Base64, Hex, Utf8 } from '@brashkie/signalis-core';
+
+// ─── Base64 (estándar, RFC 4648) ───────────────────────────────────
+Base64.encode(Buffer.from('hola'));            // "aG9sYQ=="
+Base64.decode('aG9sYQ==');                     // <Buffer 68 6f 6c 61>
+
+// ─── Base64 URL-safe (sin padding, sin + ni /) ─────────────────────
+Base64.encodeUrlSafe(Buffer.from('hola'));     // "aG9sYQ"
+Base64.decodeUrlSafe('aG9sYQ');
+
+// ─── Hex ────────────────────────────────────────────────────────────
+Hex.encode(Buffer.from([0xde, 0xad]));         // "dead"
+Hex.encodeUpper(Buffer.from([0xde, 0xad]));    // "DEAD"
+Hex.decode('DEADBEEF');                        // case-insensitive
+Hex.isValid('deadbeef');                        // true
+Hex.isValid('nope');                            // false — chars inválidos
+
+// ─── UTF-8 (estricto) ───────────────────────────────────────────────
+Utf8.encode('Hola 🦀');                        // Buffer con 9 bytes
+Utf8.decode(Buffer.from([0xc3, 0xb1]));        // "ñ"
+Utf8.decode(Buffer.from([0xff]));              // → tira RangeError
+Utf8.isValid(Buffer.from([0xff]));             // false (no throw)
+```
+
+**Errores:** Cada operación de decode tira `RangeError` (subclase de `Error`) con mensaje descriptivo. Caracteres inválidos, longitudes incorrectas, padding malformado y secuencias UTF-8 inválidas siguen el mismo patrón.
+
+**Rendimiento:** Estas funciones tienen un hop NAPI cada una. Para strings chicos el overhead es despreciable; para hot loops (millones de ops/seg en inputs pequeños) preferí `Buffer.toString()` del built-in de Node y recurrí a `Utf8.decode` solo cuando necesitás validación estricta.
+
 ### HMAC-SHA256
 
 Autenticación de mensajes.

package/README.md

@@ -32,6 +32,71 @@ Built with **Rust** for safety and speed, exposed to Node.js via [napi-rs](https
 
 ---
 
+## 🎉 What's New in v0.4.0
+
+**v0.4.0 ships native encoding helpers (Base64, Hex, UTF-8) + Android x86_64 target — fully backwards compatible with v0.3.x.**
+
+| New | Description |
+|-----|-------------|
+| 🆕 **`Base64` namespace** | RFC 4648 standard + URL-safe variant (no padding), Rust-side implementation |
+| 🆕 **`Hex` namespace** | Lowercase/uppercase encode, case-insensitive decode, `isValid()` cheap check |
+| 🆕 **`Utf8` namespace** | **Strict** UTF-8 validation — throws on malformed bytes (unlike `Buffer.toString('utf-8')` which silently substitutes U+FFFD) |
+| 🆕 **Android x86_64** | Native binary for the Android Emulator + Chromebooks + x86 tablets |
+| 🆕 **`sc-encoding` crate** | Dedicated Rust crate — separates encoding logic from crypto for easier audit |
+
+### Quick Example: Base64 / Hex / Utf8
+
+```ts
+import { Base64, Hex, Utf8 } from '@brashkie/signalis-core';
+
+// UTF-8 with strict validation
+const bytes = Utf8.encode('Hola 🦀');           // Buffer <48 6f 6c 61 20 f0 9f a6 80>
+const roundTrip = Utf8.decode(bytes);            // "Hola 🦀"
+
+// Base64 standard (with padding)
+const b64 = Base64.encode(bytes);                // "SG9sYSDwn6aA"
+const decoded = Base64.decode(b64);              // matches original
+
+// Base64 URL-safe (no padding, no + or /)
+const urlSafe = Base64.encodeUrlSafe(bytes);     // safe in URLs, filenames, JWTs
+
+// Hex
+const hex = Hex.encode(bytes);                   // "486f6c6120f09fa680"
+const hexUpper = Hex.encodeUpper(bytes);         // "486F6C6120F09FA680"
+const back = Hex.decode('DEADBEEF');             // case-insensitive
+Hex.isValid('deadbeef');                          // true
+Hex.isValid('nope!');                             // false
+
+// UTF-8 validation (cheap, no allocation)
+Utf8.isValid(Buffer.from([0xff]));                // false (0xff is never valid UTF-8)
+```
+
+### Why Strict UTF-8 Validation Matters
+
+Node's built-in `Buffer.toString('utf-8')` **silently substitutes U+FFFD** (the replacement character) when it encounters invalid bytes. For most app code that's fine. But when you're processing signed messages, verifying MACs, or handling attacker-supplied input, **you want to know** if bytes are malformed rather than continue with silently-corrupted data.
+
+```ts
+const badBytes = Buffer.from([0xff, 0xfe]);
+
+// Node's built-in: no error, produces "\uFFFD\uFFFD"
+badBytes.toString('utf-8');
+
+// signalis-core: throws
+Utf8.decode(badBytes);  // → RangeError
+```
+
+### Android x86_64 Use Cases
+
+- **Android Emulator** (Android Studio) — emulator runs x86_64, so devs testing apps now get native binaries automatically
+- **Termux on Chromebooks / x86 tablets** — `pkg install nodejs && npm install @brashkie/signalis-core`
+- **NodeJS-on-Android** with x86 device farms
+
+**Total platforms supported now: 10** (was 9 in v0.3.1).
+
+See [CHANGELOG.md](./CHANGELOG.md) for full details.
+
+---
+
 ## 🎉 What's New in v0.3.0
 
 **v0.3.0 ships Android support + ChaCha20-Poly1305 — fully backwards compatible with v0.2.0.**
@@ -83,7 +148,7 @@ See [MIGRATION.md](./MIGRATION.md) for upgrade details (it's a drop-in replaceme
 
 ## 🌍 Supported Platforms
 
-`@brashkie/signalis-core` ships prebuilt native binaries for **9 platforms** via npm `optionalDependencies`. The right binary downloads automatically based on your host OS + arch.
+`@brashkie/signalis-core` ships prebuilt native binaries for **10 platforms** via npm `optionalDependencies`. The right binary downloads automatically based on your host OS + arch.
 
 | OS | Architecture | Sub-package | Status |
 |----|--------------|-------------|--------|
@@ -96,13 +161,16 @@ See [MIGRATION.md](./MIGRATION.md) for upgrade details (it's a drop-in replaceme
 | 🪟 Windows | arm64 | `signalis-core-win32-arm64-msvc` | ✅ |
 | 🤖 Android | arm64-v8a | `signalis-core-android-arm64` | 🆕 v0.3.0 |
 | 🤖 Android | armv7 | `signalis-core-android-arm-eabi` | 🆕 v0.3.0 |
+| 🤖 Android | x86_64 | `signalis-core-android-x64` | 🆕 v0.4.0 |
 
-Coming in v0.4.0: **iOS arm64**, **WASM (browsers)**, **FreeBSD x64**.
+Coming in future releases: **WASM (browsers)**, **iOS arm64**, **FreeBSD x64**, **RISC-V**.
 
 ### Android Installation
 
 Same `npm install` works in any Node.js environment running on Android, including:
 - **Termux** on Android phones (`pkg install nodejs`)
+- **Termux on Chromebooks / x86 tablets** → uses `android-x64` binary automatically
+- **Android Emulator** (Android Studio) → x86_64 host, uses `android-x64` binary
 - **React Native** with Android target
 - **NodeJS-Mobile** apps
 - Custom embedded Node builds for IoT
@@ -111,7 +179,7 @@ Same `npm install` works in any Node.js environment running on Android, includin
 # On Android (Termux for example):
 pkg install nodejs
 npm install @brashkie/signalis-core
-# → npm automatically downloads signalis-core-android-arm64 sub-package
+# → npm automatically downloads the right sub-package for your arch
 ```
 
 ---
@@ -120,6 +188,7 @@ npm install @brashkie/signalis-core
 
 - [🔐 Signalis Core](#-signalis-core)
   - [✨ What is Signalis Core?](#-what-is-signalis-core)
+  - [🎉 What's New in v0.4.0](#-whats-new-in-v040)
   - [🎉 What's New in v0.3.0](#-whats-new-in-v030)
   - [🌍 Supported Platforms](#-supported-platforms)
   - [📋 Table of Contents](#-table-of-contents)
@@ -178,7 +247,7 @@ npm install @brashkie/signalis-core
 | 📦 **Dual Package** | Works in CommonJS, ESM, and TypeScript projects |
 | 🎯 **Type-Safe** | Full TypeScript definitions with branded types and rich error classes |
 | ✅ **Test Vectors** | Validated against RFC 5869, RFC 7748, RFC 8032, RFC 4231, and NIST vectors |
-| 🌍 **Cross-Platform** | Prebuilt binaries for Windows, macOS, Linux (x64, ARM) + **Android arm64/armv7** |
+| 🌍 **Cross-Platform** | Prebuilt binaries for Windows, macOS, Linux (x64, ARM) + **Android arm64/armv7/x86_64** |
 | 🔒 **Constant-Time** | Side-channel resistant comparisons via `subtle` crate |
 | 🧹 **Auto-Zeroization** | Secrets are wiped from memory automatically |
 | 📊 **99%+ Coverage** | Comprehensive test suite with 269+ assertions |
@@ -532,6 +601,44 @@ ChaCha20Poly1305.TAG_SIZE;     // 16 (appended to ciphertext)
 
 **Security:** ChaCha20-Poly1305 and AES-GCM have equivalent security properties. The choice is purely about performance on your target.
 
+### Base64 / Hex / UTF-8 🆕
+
+Native (Rust-side) encoding helpers introduced in v0.4.0. Backed by the `sc-encoding` crate, which uses the audited RustCrypto ecosystem (`base64` and `hex` crates) plus Rust's built-in strict UTF-8 validation.
+
+**Why not just use Node's `Buffer.toString('base64')`?**
+- `Buffer.toString('utf-8')` silently substitutes `U+FFFD` for invalid bytes. Ours throws — better for signature verification, forensic parsing, adversarial input.
+- Consistent error surface across the whole library (same `RangeError` shape as the crypto primitives).
+- Same audit surface — one crate to review, not "whatever Node happens to ship".
+
+```typescript
+import { Base64, Hex, Utf8 } from '@brashkie/signalis-core';
+
+// ─── Base64 (standard, RFC 4648) ───────────────────────────────────
+Base64.encode(Buffer.from('hello'));          // "aGVsbG8="
+Base64.decode('aGVsbG8=');                     // <Buffer 68 65 6c 6c 6f>
+
+// ─── Base64 URL-safe (no padding, no + or /) ───────────────────────
+Base64.encodeUrlSafe(Buffer.from('hello'));    // "aGVsbG8"
+Base64.decodeUrlSafe('aGVsbG8');
+
+// ─── Hex ────────────────────────────────────────────────────────────
+Hex.encode(Buffer.from([0xde, 0xad]));         // "dead"
+Hex.encodeUpper(Buffer.from([0xde, 0xad]));    // "DEAD"
+Hex.decode('DEADBEEF');                        // case-insensitive
+Hex.isValid('deadbeef');                        // true
+Hex.isValid('nope');                            // false — invalid chars
+
+// ─── UTF-8 (strict) ─────────────────────────────────────────────────
+Utf8.encode('Hola 🦀');                        // Buffer with 9 bytes
+Utf8.decode(Buffer.from([0xc3, 0xb1]));        // "ñ"
+Utf8.decode(Buffer.from([0xff]));              // → throws RangeError
+Utf8.isValid(Buffer.from([0xff]));             // false (no throw)
+```
+
+**Errors:** Every decode operation throws `RangeError` (subclass of `Error`) with a descriptive message. Invalid characters, wrong lengths, malformed padding, and invalid UTF-8 sequences all follow the same pattern.
+
+**Performance:** These functions have one NAPI hop each. For small strings the overhead is negligible; for hot loops (millions of ops/sec on tiny inputs) prefer `Buffer.toString()` from Node's built-in and only reach for `Utf8.decode` when you need strict validation.
+
 ### HMAC-SHA256
 
 Message authentication.

package/dist/index.cjs

@@ -40,6 +40,7 @@ __export(index_exports, {
   AES_GCM_MAX_PLAINTEXT_SIZE: () => AES_GCM_MAX_PLAINTEXT_SIZE,
   AES_GCM_RECOMMENDED_MESSAGES_PER_KEY: () => AES_GCM_RECOMMENDED_MESSAGES_PER_KEY,
   AuthenticationError: () => AuthenticationError,
+  Base64: () => Base64,
   CHACHA20_POLY1305_KEY_SIZE: () => CHACHA20_POLY1305_KEY_SIZE,
   CHACHA20_POLY1305_NONCE_SIZE: () => CHACHA20_POLY1305_NONCE_SIZE,
   CHACHA20_POLY1305_TAG_SIZE: () => CHACHA20_POLY1305_TAG_SIZE,
@@ -59,6 +60,7 @@ __export(index_exports, {
   HKDF_PRK_SIZE: () => HKDF_PRK_SIZE,
   HMAC: () => HMAC,
   HMAC_SHA256_TAG_SIZE: () => HMAC_SHA256_TAG_SIZE,
+  Hex: () => Hex,
   KeyDerivationError: () => KeyDerivationError,
   LengthError: () => LengthError,
   SHA256: () => SHA256,
@@ -66,6 +68,7 @@ __export(index_exports, {
   SHA256_OUTPUT_SIZE: () => SHA256_OUTPUT_SIZE,
   SignalisError: () => SignalisError,
   SignatureError: () => SignatureError,
+  Utf8: () => Utf8,
   VERSION: () => VERSION,
   ValidationError: () => ValidationError,
   XED25519_PRIVATE_KEY_SIZE: () => XED25519_PRIVATE_KEY_SIZE,
@@ -833,6 +836,123 @@ function nativeSecureRandom(size) {
   }
   return native.secureRandom(size);
 }
+var Base64 = Object.freeze({
+  /**
+   * Encode bytes to standard Base64 (with `=` padding).
+   */
+  encode(input) {
+    if (!Buffer.isBuffer(input)) {
+      throw new TypeError("Base64.encode: input must be a Buffer");
+    }
+    return native.base64Encode(input);
+  },
+  /**
+   * Decode a standard Base64 string back to bytes.
+   *
+   * @throws {RangeError} on invalid characters, wrong length, or invalid padding.
+   */
+  decode(input) {
+    if (typeof input !== "string") {
+      throw new TypeError("Base64.decode: input must be a string");
+    }
+    return native.base64Decode(input);
+  },
+  /**
+   * Encode bytes to URL-safe Base64 without padding.
+   * Uses `-` and `_` instead of `+` and `/`.
+   */
+  encodeUrlSafe(input) {
+    if (!Buffer.isBuffer(input)) {
+      throw new TypeError("Base64.encodeUrlSafe: input must be a Buffer");
+    }
+    return native.base64EncodeUrlSafe(input);
+  },
+  /**
+   * Decode a URL-safe Base64 string (no padding) back to bytes.
+   *
+   * @throws {RangeError} on invalid characters or wrong length.
+   */
+  decodeUrlSafe(input) {
+    if (typeof input !== "string") {
+      throw new TypeError("Base64.decodeUrlSafe: input must be a string");
+    }
+    return native.base64DecodeUrlSafe(input);
+  }
+});
+var Hex = Object.freeze({
+  /**
+   * Encode bytes to a lowercase hex string.
+   */
+  encode(input) {
+    if (!Buffer.isBuffer(input)) {
+      throw new TypeError("Hex.encode: input must be a Buffer");
+    }
+    return native.hexEncode(input);
+  },
+  /**
+   * Encode bytes to an uppercase hex string.
+   * (Rare, but included for legacy protocols.)
+   */
+  encodeUpper(input) {
+    if (!Buffer.isBuffer(input)) {
+      throw new TypeError("Hex.encodeUpper: input must be a Buffer");
+    }
+    return native.hexEncodeUpper(input);
+  },
+  /**
+   * Decode a hex string to bytes. Case-insensitive.
+   *
+   * @throws {RangeError} on odd-length input or non-hex characters.
+   */
+  decode(input) {
+    if (typeof input !== "string") {
+      throw new TypeError("Hex.decode: input must be a string");
+    }
+    return native.hexDecode(input);
+  },
+  /**
+   * Cheap validation: is this a well-formed hex string?
+   */
+  isValid(input) {
+    if (typeof input !== "string") {
+      throw new TypeError("Hex.isValid: input must be a string");
+    }
+    return native.hexIsValid(input);
+  }
+});
+var Utf8 = Object.freeze({
+  /**
+   * Encode a string to its UTF-8 byte representation.
+   */
+  encode(input) {
+    if (typeof input !== "string") {
+      throw new TypeError("Utf8.encode: input must be a string");
+    }
+    return native.utf8Encode(input);
+  },
+  /**
+   * Decode UTF-8 bytes to a string.
+   *
+   * @throws {RangeError} on invalid UTF-8 (truncated multi-byte, lone surrogate,
+   *   invalid start byte, etc.). Unlike `Buffer.toString('utf-8')`, this does
+   *   NOT silently substitute U+FFFD.
+   */
+  decode(input) {
+    if (!Buffer.isBuffer(input)) {
+      throw new TypeError("Utf8.decode: input must be a Buffer");
+    }
+    return native.utf8Decode(input);
+  },
+  /**
+   * Check whether the given bytes are valid UTF-8.
+   */
+  isValid(input) {
+    if (!Buffer.isBuffer(input)) {
+      throw new TypeError("Utf8.isValid: input must be a Buffer");
+    }
+    return native.utf8IsValid(input);
+  }
+});
 
 // src/types.ts
 function asPublicKey(buf) {
@@ -920,7 +1040,7 @@ function xor(a, b) {
 }
 
 // src/index.ts
-var VERSION = "0.2.0";
+var VERSION = "0.4.0";
 var SignalisCore = Object.freeze({
   // Crypto primitives
   Curve25519,
@@ -929,22 +1049,29 @@ var SignalisCore = Object.freeze({
   HKDF,
   AES_GCM,
   AES_CBC,
+  ChaCha20Poly1305,
   HMAC,
   SHA256,
   // Random
   secureRandom: secureRandom2,
+  nativeSecureRandom,
   randomNonce,
   randomIv,
   randomKey,
-  // Encoding
+  // Encoding (JS-side legacy helpers — use Base64/Hex/Utf8 for native)
   toHex,
   fromHex,
   toBase64,
   fromBase64,
+  // Encoding (NEW v0.4.0 — native, RFC-compliant)
+  Base64,
+  Hex,
+  Utf8,
   // Security
   constantTimeEqual,
+  constantTimeEq: constantTimeEq2,
   // Version
-  VERSION: "0.2.0",
+  VERSION,
   nativeVersion
 });
 var index_default = SignalisCore;
@@ -960,6 +1087,7 @@ var index_default = SignalisCore;
   AES_GCM_MAX_PLAINTEXT_SIZE,
   AES_GCM_RECOMMENDED_MESSAGES_PER_KEY,
   AuthenticationError,
+  Base64,
   CHACHA20_POLY1305_KEY_SIZE,
   CHACHA20_POLY1305_NONCE_SIZE,
   CHACHA20_POLY1305_TAG_SIZE,
@@ -979,6 +1107,7 @@ var index_default = SignalisCore;
   HKDF_PRK_SIZE,
   HMAC,
   HMAC_SHA256_TAG_SIZE,
+  Hex,
   KeyDerivationError,
   LengthError,
   SHA256,
@@ -986,6 +1115,7 @@ var index_default = SignalisCore;
   SHA256_OUTPUT_SIZE,
   SignalisError,
   SignatureError,
+  Utf8,
   VERSION,
   ValidationError,
   XED25519_PRIVATE_KEY_SIZE,