voltaire-effect 0.2.23 → 0.2.24

package/src/primitives/Address/index.ts

@@ -1,6 +1,6 @@
 /**
  * @module Address
- * @description Effect Schemas for Ethereum addresses with EIP-55 checksum support.
+ * @description Effect Schemas and functions for Ethereum addresses with EIP-55 checksum support.
  *
  * ## Type Declarations
  *
@@ -20,70 +20,134 @@
  * | `Address.Checksummed` | checksummed string | AddressType | Validates checksum on decode, requires KeccakService for encode |
  * | `Address.Bytes` | Uint8Array | AddressType | 20-byte array conversion |
  *
- * ## Usage
+ * ## Constructors (Effect-wrapped)
  *
  * ```typescript
- * import * as Address from 'voltaire-effect/primitives/Address'
- * import * as S from 'effect/Schema'
- *
- * // Decode (parse input)
- * const addr = S.decodeSync(Address.Hex)('0x742d35Cc6634C0532925a3b844Bc9e7595f251e3')
- *
- * // Encode (format output)
- * const hex = S.encodeSync(Address.Hex)(addr)
- * // "0x742d35cc6634c0532925a3b844bc9e7595f251e3"
+ * Address.from(value)           // Effect<AddressType, AddressError>
+ * Address.fromHex(hex)          // Effect<AddressType, HexError>
+ * Address.fromBytes(bytes)      // Effect<AddressType, LengthError>
+ * Address.fromNumber(n)         // Effect<AddressType, ValueError>
+ * Address.fromBase64(str)       // Effect<AddressType, LengthError>
+ * Address.fromAbiEncoded(bytes) // Effect<AddressType, AbiError>
+ * Address.fromPublicKey(pk)     // Effect<AddressType, ValueError>
+ * Address.fromPrivateKey(sk)    // Effect<AddressType, ValueError>
+ * Address.zero()                // AddressType (pure)
+ * ```
  *
- * // Checksummed encoding (requires KeccakService)
- * import * as Effect from 'effect/Effect'
- * import { KeccakLive } from 'voltaire-effect/crypto/Keccak256'
+ * ## Pure Functions
  *
- * const program = S.encode(Address.Checksummed)(addr)
- * const checksummed = await Effect.runPromise(program.pipe(Effect.provide(KeccakLive)))
- * // "0x742d35Cc6634C0532925a3b844Bc9e7595f251e3"
+ * ```typescript
+ * Address.equals(a, b)          // boolean
+ * Address.compare(a, b)         // -1 | 0 | 1
+ * Address.isZero(addr)          // boolean
+ * Address.lessThan(a, b)        // boolean
+ * Address.greaterThan(a, b)     // boolean
+ * Address.isValid(value)        // boolean
+ * Address.isValidChecksum(str)  // boolean
+ * Address.isAddress(value)      // boolean
+ * Address.is(value)             // type guard
+ * Address.clone(addr)           // AddressType
+ * Address.toBytes(addr)         // Uint8Array
+ * Address.toHex(addr)           // string
+ * Address.toU256(addr)          // Uint256Type
+ * Address.toShortHex(addr)      // string
+ * Address.toLowercase(addr)     // string
+ * Address.toUppercase(addr)     // string
+ * Address.toAbiEncoded(addr)    // Uint8Array
+ * Address.sortAddresses(arr)    // AddressType[]
+ * Address.deduplicateAddresses(arr) // AddressType[]
  * ```
  *
- * ## Pure Functions
+ * ## Effectful Functions
  *
  * ```typescript
- * Address.equals(a, b)     // boolean
- * Address.compare(a, b)    // -1 | 0 | 1
- * Address.isZero(addr)     // boolean
- * Address.lessThan(a, b)   // boolean
- * Address.greaterThan(a, b) // boolean
- * Address.isValid(value)   // boolean
- * Address.isValidChecksum(str) // boolean
- * Address.clone(addr)      // AddressType
- * Address.toBytes(addr)    // Uint8Array
- * Address.toU256(addr)     // Uint256Type (U256)
- * Address.toShortHex(addr) // string (e.g., "0x742d...51e3")
- * Address.toLowercase(addr) // Lowercase address hex
- * Address.toUppercase(addr) // Uppercase address hex
- * Address.toAbiEncoded(addr) // Uint8Array (32 bytes)
+ * Address.toChecksummed(addr)   // Effect<string, never, KeccakService>
+ * Address.assert(value, opts)   // Effect<void, AssertError, KeccakService>
+ * Address.assertBasic(value)    // Effect<void, InvalidAddressError>
+ * Address.calculateCreateAddress(addr, nonce) // Effect<AddressType, ValueError>
+ * Address.calculateCreate2Address(addr, salt, initCode) // Effect<AddressType, Error>
  * ```
  *
  * @since 0.1.0
  */
 
-// Re-export AddressType from voltaire
-export type { AddressType } from "@tevm/voltaire/Address";
+// Re-export types from voltaire
+export type { AddressType, BrandedAddress } from "@tevm/voltaire/Address";
 export { AddressTypeSchema } from "./AddressSchema.js";
+
+// Re-export constants from voltaire
+export {
+	SIZE,
+	HEX_SIZE,
+	ZERO_ADDRESS,
+	NATIVE_ASSET_ADDRESS,
+} from "@tevm/voltaire/Address";
+
+// Re-export errors from voltaire
+export {
+	InvalidAddressError,
+	InvalidAddressLengthError,
+	InvalidAbiEncodedPaddingError,
+	InvalidChecksumError,
+	InvalidHexFormatError,
+	InvalidHexStringError,
+	InvalidValueError,
+	NotImplementedError,
+} from "@tevm/voltaire/Address";
+
+// Re-export DI factory functions for advanced use cases
+// These accept crypto services as parameters for dependency injection
+import { Address as AddressNamespace } from "@tevm/voltaire/functional";
+export const Assert = AddressNamespace.Assert;
+export const CalculateCreate2Address = AddressNamespace.CalculateCreate2Address;
+export const CalculateCreateAddress = AddressNamespace.CalculateCreateAddress;
+export const From = AddressNamespace.From;
+export const FromPrivateKey = AddressNamespace.FromPrivateKey;
+export const FromPublicKey = AddressNamespace.FromPublicKey;
+export const IsContract = AddressNamespace.IsContract;
+export const IsValid = AddressNamespace.IsValid;
+export const IsValidChecksum = AddressNamespace.IsValidChecksum;
+export const ToChecksummed = AddressNamespace.ToChecksummed;
+
 // Schemas
 export { Bytes } from "./Bytes.js";
 export { Checksummed } from "./Checksummed.js";
+export { Hex } from "./Hex.js";
+
+// Constructors (Effect-wrapped)
+export { from } from "./from.js";
+export { fromAbiEncoded } from "./fromAbiEncoded.js";
+export { fromBase64 } from "./fromBase64.js";
+export { fromBytes } from "./fromBytes.js";
+export { fromHex } from "./fromHex.js";
+export { fromNumber } from "./fromNumber.js";
+export { fromPrivateKey } from "./fromPrivateKey.js";
+export { fromPublicKey } from "./fromPublicKey.js";
+export { zero } from "./zero.js";
 
 // Pure functions
 export { clone } from "./clone.js";
 export { compare } from "./compare.js";
+export { deduplicateAddresses } from "./deduplicateAddresses.js";
 export { equals } from "./equals.js";
 export { greaterThan } from "./greaterThan.js";
-export { Hex } from "./Hex.js";
+export { is } from "./is.js";
+export { isAddress } from "./isAddress.js";
 export { isValid } from "./isValid.js";
 export { isValidChecksum } from "./isValidChecksum.js";
 export { isZero } from "./isZero.js";
 export { lessThan } from "./lessThan.js";
+export { sortAddresses } from "./sortAddresses.js";
 export { toAbiEncoded } from "./toAbiEncoded.js";
 export { toBytes } from "./toBytes.js";
+export { toHex } from "./toHex.js";
 export { toLowercase } from "./toLowercase.js";
 export { toShortHex } from "./toShortHex.js";
 export { toU256 } from "./toU256.js";
 export { toUppercase } from "./toUppercase.js";
+
+// Effectful functions
+export { assert, assertBasic } from "./assert.js";
+export { calculateCreate2Address } from "./calculateCreate2Address.js";
+export { calculateCreateAddress } from "./calculateCreateAddress.js";
+export { toChecksummed } from "./toChecksummed.js";

package/src/primitives/Address/is.ts

@@ -0,0 +1,20 @@
+/**
+ * @module is
+ * @description Type guard to check if value is an AddressType
+ * @since 0.1.0
+ */
+import { Address, type AddressType } from "@tevm/voltaire/Address";
+
+/**
+ * Type guard: check if value is an AddressType
+ *
+ * @param value - Value to check
+ * @returns True if value is AddressType
+ * @example
+ * ```typescript
+ * if (Address.is(value)) {
+ *   // value is AddressType
+ * }
+ * ```
+ */
+export const is = (value: unknown): value is AddressType => Address.is(value);

package/src/primitives/Address/isAddress.ts

@@ -0,0 +1,22 @@
+/**
+ * @module isAddress
+ * @description Check if value is a valid address (string or bytes)
+ * @since 0.1.0
+ */
+import { Address } from "@tevm/voltaire/Address";
+
+/**
+ * Check if value is a valid Ethereum address
+ *
+ * Alias for isValid - checks if string or bytes is valid address format.
+ *
+ * @param value - Value to check
+ * @returns True if valid address format
+ * @example
+ * ```typescript
+ * Address.isAddress('0x742d35cc6634c0532925a3b844bc9e7595f251e3') // true
+ * Address.isAddress('invalid') // false
+ * ```
+ */
+export const isAddress = (value: string | Uint8Array): boolean =>
+  Address.isValid(value);

package/src/primitives/Address/sortAddresses.ts

@@ -0,0 +1,19 @@
+/**
+ * @module sortAddresses
+ * @description Sort array of addresses lexicographically
+ * @since 0.1.0
+ */
+import { sortAddresses as voltaireSortAddresses, type AddressType } from "@tevm/voltaire/Address";
+
+/**
+ * Sort array of addresses lexicographically
+ *
+ * @param addresses - Array of addresses to sort
+ * @returns New sorted array
+ * @example
+ * ```typescript
+ * const sorted = Address.sortAddresses([addr1, addr2, addr3])
+ * ```
+ */
+export const sortAddresses = (addresses: AddressType[]): AddressType[] =>
+  voltaireSortAddresses(addresses);

package/src/primitives/Address/toChecksummed.ts

@@ -0,0 +1,32 @@
+/**
+ * @module toChecksummed
+ * @description Convert Address to EIP-55 checksummed hex string (requires KeccakService)
+ * @since 0.1.0
+ */
+import { Effect } from "effect";
+import { Address, type AddressType } from "@tevm/voltaire/Address";
+import { KeccakService } from "../../crypto/Keccak256/index.js";
+
+/**
+ * Convert Address to EIP-55 checksummed hex string
+ *
+ * Requires KeccakService to be provided.
+ *
+ * @param addr - Address to convert
+ * @returns Effect yielding checksummed hex string
+ * @example
+ * ```typescript
+ * import { KeccakLive } from 'voltaire-effect/crypto/Keccak256'
+ *
+ * const program = Address.toChecksummed(addr)
+ * const checksummed = await Effect.runPromise(program.pipe(Effect.provide(KeccakLive)))
+ * // "0x742d35Cc6634C0532925a3b844Bc9e7595f251e3"
+ * ```
+ */
+export const toChecksummed = (
+  addr: AddressType,
+): Effect.Effect<string, never, KeccakService> =>
+  Effect.gen(function* () {
+    yield* KeccakService;
+    return Address.toChecksummed(addr);
+  });

package/src/primitives/Address/toHex.ts

@@ -0,0 +1,18 @@
+/**
+ * @module toHex
+ * @description Convert Address to lowercase hex string
+ * @since 0.1.0
+ */
+import { Address, type AddressType } from "@tevm/voltaire/Address";
+
+/**
+ * Convert Address to lowercase hex string
+ *
+ * @param addr - Address to convert
+ * @returns Lowercase hex string with 0x prefix
+ * @example
+ * ```typescript
+ * Address.toHex(addr) // "0x742d35cc6634c0532925a3b844bc9e7595f251e3"
+ * ```
+ */
+export const toHex = (addr: AddressType): string => Address.toHex(addr);

package/src/primitives/Address/zero.ts

@@ -0,0 +1,18 @@
+/**
+ * @module zero
+ * @description Create the zero address (0x0000...0000)
+ * @since 0.1.0
+ */
+import { Address, type AddressType } from "@tevm/voltaire/Address";
+
+/**
+ * Create zero address (0x0000...0000)
+ *
+ * @returns AddressType with all bytes set to 0
+ * @example
+ * ```typescript
+ * const zeroAddr = Address.zero()
+ * Address.isZero(zeroAddr) // true
+ * ```
+ */
+export const zero = (): AddressType => Address.zero();

package/src/primitives/Base64/Base64.test.ts

@@ -0,0 +1,75 @@
+import { describe, expect, it } from "@effect/vitest";
+import { Effect } from "effect";
+import * as Schema from "effect/Schema";
+import * as Base64 from "./index.js";
+
+describe("Base64.Schema", () => {
+  it("validates standard Base64", () => {
+    const result = Schema.decodeSync(Base64.Schema)("SGVsbG8gV29ybGQ=");
+    expect(typeof result).toBe("string");
+  });
+
+  it("validates URL-safe Base64", () => {
+    const result = Schema.decodeSync(Base64.UrlSchema)("SGVsbG8tV29ybGQ_");
+    expect(typeof result).toBe("string");
+  });
+});
+
+describe("Base64.from", () => {
+  it("creates BrandedBase64 from string", async () => {
+    const result = await Effect.runPromise(Base64.from("SGVsbG8="));
+    expect(typeof result).toBe("string");
+  });
+
+  it("creates BrandedBase64Url from string", async () => {
+    // URL-safe Base64 doesn't use padding (=) and uses - and _ instead of + and /
+    const result = await Effect.runPromise(Base64.fromUrlSafe("SGVsbG8"));
+    expect(typeof result).toBe("string");
+  });
+});
+
+describe("Base64 encoding", () => {
+  it("encodes bytes to Base64", () => {
+    const bytes = new Uint8Array([72, 101, 108, 108, 111]); // "Hello"
+    const encoded = Base64.encode(bytes);
+    expect(encoded).toBe("SGVsbG8=");
+  });
+
+  it("encodes string to Base64", () => {
+    const encoded = Base64.encodeString("Hello");
+    expect(encoded).toBe("SGVsbG8=");
+  });
+});
+
+describe("Base64 decoding", () => {
+  it("decodes Base64 to bytes", async () => {
+    const bytes = await Effect.runPromise(Base64.decode("SGVsbG8="));
+    expect(bytes).toEqual(new Uint8Array([72, 101, 108, 108, 111]));
+  });
+
+  it("decodes Base64 to string", async () => {
+    const str = await Effect.runPromise(Base64.decodeToString("SGVsbG8="));
+    expect(str).toBe("Hello");
+  });
+});
+
+describe("Base64 validation", () => {
+  it("validates correct Base64", () => {
+    expect(Base64.isValid("SGVsbG8=")).toBe(true);
+  });
+
+  it("rejects invalid Base64", () => {
+    expect(Base64.isValid("!!!invalid!!!")).toBe(false);
+  });
+});
+
+describe("Base64 size calculation", () => {
+  it("calculates encoded size", () => {
+    expect(Base64.calcEncodedSize(5)).toBe(8);
+  });
+
+  it("calculates decoded size from length", () => {
+    // calcDecodedSize takes the length of the encoded string, not the string itself
+    expect(Base64.calcDecodedSize(8)).toBe(4); // 8 chars -> 4 bytes (accounting for padding)
+  });
+});

package/src/primitives/Base64/convert.ts

@@ -0,0 +1,37 @@
+/**
+ * @module convert
+ * @description Pure Base64 conversion functions
+ * @since 0.1.0
+ */
+import { Base64, type BrandedBase64, type BrandedBase64Url } from "@tevm/voltaire/Base64";
+
+/**
+ * Convert Base64 to bytes
+ */
+export const toBytes = (b64: BrandedBase64): Uint8Array => Base64.toBytes(b64);
+
+/**
+ * Convert URL-safe Base64 to bytes
+ */
+export const toBytesUrlSafe = (b64: BrandedBase64Url): Uint8Array => Base64.toBytesUrlSafe(b64);
+
+/**
+ * Convert Base64 to UTF-8 string
+ */
+// biome-ignore lint/suspicious/noShadowRestrictedNames: intentional API name
+export const toString = (b64: BrandedBase64): string => Base64.toString(b64);
+
+/**
+ * Convert URL-safe Base64 to UTF-8 string
+ */
+export const toStringUrlSafe = (b64: BrandedBase64Url): string => Base64.toStringUrlSafe(b64);
+
+/**
+ * Convert standard Base64 to URL-safe Base64
+ */
+export const toBase64Url = (value: BrandedBase64): BrandedBase64Url => Base64.toBase64Url(value);
+
+/**
+ * Convert URL-safe Base64 to standard Base64
+ */
+export const toBase64 = (value: BrandedBase64Url): BrandedBase64 => Base64.toBase64(value);

package/src/primitives/Base64/decode.ts

@@ -0,0 +1,59 @@
+/**
+ * @module decode
+ * @description Effect-wrapped Base64 decode operations
+ * @since 0.1.0
+ */
+import { Effect } from "effect";
+import { Base64 } from "@tevm/voltaire/Base64";
+
+/**
+ * Decode standard Base64 string to bytes
+ *
+ * @param encoded - Base64 encoded string
+ * @returns Effect yielding decoded Uint8Array
+ * @example
+ * ```typescript
+ * const bytes = await Effect.runPromise(Base64.decode('SGVsbG8='))
+ * ```
+ */
+export const decode = (encoded: string): Effect.Effect<Uint8Array, Error> =>
+  Effect.try({
+    try: () => Base64.decode(encoded),
+    catch: (e) => e as Error,
+  });
+
+/**
+ * Decode standard Base64 string to UTF-8 string
+ *
+ * @param encoded - Base64 encoded string
+ * @returns Effect yielding decoded string
+ */
+export const decodeToString = (encoded: string): Effect.Effect<string, Error> =>
+  Effect.try({
+    try: () => Base64.decodeToString(encoded),
+    catch: (e) => e as Error,
+  });
+
+/**
+ * Decode URL-safe Base64 string to bytes
+ *
+ * @param encoded - URL-safe Base64 encoded string
+ * @returns Effect yielding decoded Uint8Array
+ */
+export const decodeUrlSafe = (encoded: string): Effect.Effect<Uint8Array, Error> =>
+  Effect.try({
+    try: () => Base64.decodeUrlSafe(encoded),
+    catch: (e) => e as Error,
+  });
+
+/**
+ * Decode URL-safe Base64 string to UTF-8 string
+ *
+ * @param encoded - URL-safe Base64 encoded string
+ * @returns Effect yielding decoded string
+ */
+export const decodeUrlSafeToString = (encoded: string): Effect.Effect<string, Error> =>
+  Effect.try({
+    try: () => Base64.decodeUrlSafeToString(encoded),
+    catch: (e) => e as Error,
+  });

package/src/primitives/Base64/encode.ts

@@ -0,0 +1,42 @@
+/**
+ * @module encode
+ * @description Pure Base64 encode operations
+ * @since 0.1.0
+ */
+import { Base64, type BrandedBase64, type BrandedBase64Url } from "@tevm/voltaire/Base64";
+
+/**
+ * Encode bytes to standard Base64 string
+ *
+ * @param data - Bytes to encode
+ * @returns Base64 encoded string
+ * @example
+ * ```typescript
+ * const b64 = Base64.encode(new Uint8Array([72, 101, 108, 108, 111]))
+ * ```
+ */
+export const encode = (data: Uint8Array): BrandedBase64 => Base64.encode(data);
+
+/**
+ * Encode UTF-8 string to standard Base64
+ *
+ * @param str - String to encode
+ * @returns Base64 encoded string
+ */
+export const encodeString = (str: string): string => Base64.encodeString(str);
+
+/**
+ * Encode bytes to URL-safe Base64 string
+ *
+ * @param data - Bytes to encode
+ * @returns URL-safe Base64 encoded string
+ */
+export const encodeUrlSafe = (data: Uint8Array): BrandedBase64Url => Base64.encodeUrlSafe(data);
+
+/**
+ * Encode UTF-8 string to URL-safe Base64
+ *
+ * @param str - String to encode
+ * @returns URL-safe Base64 encoded string
+ */
+export const encodeStringUrlSafe = (str: string): BrandedBase64Url => Base64.encodeStringUrlSafe(str);

package/src/primitives/Base64/from.ts

@@ -0,0 +1,39 @@
+/**
+ * @module from
+ * @description Effect-wrapped Base64 constructors
+ * @since 0.1.0
+ */
+import { Effect } from "effect";
+import { Base64, type BrandedBase64, type BrandedBase64Url } from "@tevm/voltaire/Base64";
+
+/**
+ * Create validated standard Base64 string from input
+ *
+ * @param value - String or Uint8Array to convert
+ * @returns Effect yielding BrandedBase64
+ * @example
+ * ```typescript
+ * const b64 = await Effect.runPromise(Base64.from('SGVsbG8='))
+ * ```
+ */
+export const from = (
+  value: string | Uint8Array,
+): Effect.Effect<BrandedBase64, Error> =>
+  Effect.try({
+    try: () => Base64.from(value),
+    catch: (e) => e as Error,
+  });
+
+/**
+ * Create validated URL-safe Base64 string from input
+ *
+ * @param value - String or Uint8Array to convert
+ * @returns Effect yielding BrandedBase64Url
+ */
+export const fromUrlSafe = (
+  value: string | Uint8Array,
+): Effect.Effect<BrandedBase64Url, Error> =>
+  Effect.try({
+    try: () => Base64.fromUrlSafe(value),
+    catch: (e) => e as Error,
+  });

package/src/primitives/Base64/index.ts

@@ -1,6 +1,6 @@
 /**
  * @module Base64
- * @description Effect-based schemas for standard and URL-safe base64 encoding.
+ * @description Effect-based schemas and functions for standard and URL-safe base64 encoding.
  *
  * ## Type Declarations
  *
@@ -12,17 +12,97 @@
  * }
  * ```
  *
+ * ## Schemas
+ *
+ * | Schema | Input | Output |
+ * |--------|-------|--------|
+ * | `Base64.Schema` | string \| Uint8Array | BrandedBase64 |
+ * | `Base64.UrlSchema` | string \| Uint8Array | BrandedBase64Url |
+ *
+ * ## Constructors (Effect-wrapped)
+ *
+ * ```typescript
+ * Base64.from(value)        // Effect<BrandedBase64, Error>
+ * Base64.fromUrlSafe(value) // Effect<BrandedBase64Url, Error>
+ * ```
+ *
+ * ## Encoding (Pure)
+ *
+ * ```typescript
+ * Base64.encode(bytes)           // BrandedBase64
+ * Base64.encodeString(str)       // BrandedBase64
+ * Base64.encodeUrlSafe(bytes)    // BrandedBase64Url
+ * Base64.encodeStringUrlSafe(str) // BrandedBase64Url
+ * ```
+ *
+ * ## Decoding (Effect-wrapped)
+ *
+ * ```typescript
+ * Base64.decode(encoded)           // Effect<Uint8Array, Error>
+ * Base64.decodeToString(encoded)   // Effect<string, Error>
+ * Base64.decodeUrlSafe(encoded)    // Effect<Uint8Array, Error>
+ * Base64.decodeUrlSafeToString(encoded) // Effect<string, Error>
+ * ```
+ *
+ * ## Conversion (Pure)
+ *
+ * ```typescript
+ * Base64.toBytes(b64)        // Uint8Array
+ * Base64.toBytesUrlSafe(b64) // Uint8Array
+ * Base64.toString(b64)       // string
+ * Base64.toStringUrlSafe(b64) // string
+ * Base64.toBase64(bytes)     // BrandedBase64
+ * Base64.toBase64Url(bytes)  // BrandedBase64Url
+ * ```
+ *
+ * ## Validation (Pure)
+ *
+ * ```typescript
+ * Base64.isValid(str)        // boolean
+ * Base64.isValidUrlSafe(str) // boolean
+ * ```
+ *
+ * ## Size Calculation (Pure)
+ *
+ * ```typescript
+ * Base64.calcEncodedSize(byteCount) // number
+ * Base64.calcDecodedSize(encoded)   // number
+ * ```
+ *
  * @example
  * ```typescript
  * import * as Base64 from 'voltaire-effect/primitives/Base64'
  * import * as Schema from 'effect/Schema'
+ * import { Effect } from 'effect'
  *
  * const encoded = Schema.decodeSync(Base64.Schema)('SGVsbG8gV29ybGQ=')
+ * const decoded = await Effect.runPromise(Base64.decode('SGVsbG8='))
  * ```
  *
  * @since 0.0.1
  * @module
  */
 
+// Types
 export type { BrandedBase64, BrandedBase64Url } from "@tevm/voltaire/Base64";
+
+// Schemas
 export { Schema, UrlSchema } from "./Base64Schema.js";
+
+// Constructors (Effect-wrapped)
+export { from, fromUrlSafe } from "./from.js";
+
+// Encoding (Pure)
+export { encode, encodeString, encodeUrlSafe, encodeStringUrlSafe } from "./encode.js";
+
+// Decoding (Effect-wrapped)
+export { decode, decodeToString, decodeUrlSafe, decodeUrlSafeToString } from "./decode.js";
+
+// Conversion (Pure)
+export { toBytes, toBytesUrlSafe, toString, toStringUrlSafe, toBase64, toBase64Url } from "./convert.js";
+
+// Validation (Pure)
+export { isValid, isValidUrlSafe } from "./validation.js";
+
+// Size Calculation (Pure)
+export { calcEncodedSize, calcDecodedSize } from "./size.js";