@bcts/hubert 1.0.0-alpha.17

package/dist/index-jyzuOhFB.d.cts

@@ -0,0 +1,210 @@
+import { r as HubertError, t as KvStore } from "./kv-store-ww-AUyLd.cjs";
+import { ARID } from "@bcts/components";
+import { Envelope } from "@bcts/envelope";
+
+//#region src/mainline/error.d.ts
+/**
+ * Base class for Mainline DHT-specific errors.
+ *
+ * @category Mainline
+ */
+declare class MainlineError extends HubertError {
+  constructor(message: string);
+}
+/**
+ * Value size exceeds DHT limit.
+ *
+ * Port of `Error::ValueTooLarge { size }` from mainline/error.rs line 4-5.
+ *
+ * @category Mainline
+ */
+declare class ValueTooLargeError extends MainlineError {
+  readonly size: number;
+  constructor(size: number);
+}
+/**
+ * DHT operation error.
+ *
+ * Port of `Error::DhtError` from mainline/error.rs line 7-8.
+ *
+ * @category Mainline
+ */
+declare class DhtError extends MainlineError {
+  constructor(message: string);
+}
+/**
+ * Put query error.
+ *
+ * Port of `Error::PutQueryError` from mainline/error.rs line 10-11.
+ *
+ * @category Mainline
+ */
+declare class PutQueryError extends MainlineError {
+  constructor(message: string);
+}
+/**
+ * Decode ID error.
+ *
+ * Port of `Error::DecodeIdError` from mainline/error.rs line 13-14.
+ *
+ * @category Mainline
+ */
+declare class DecodeIdError extends MainlineError {
+  constructor(message: string);
+}
+/**
+ * Put mutable error.
+ *
+ * Port of `Error::PutMutableError` from mainline/error.rs line 16-17.
+ *
+ * @category Mainline
+ */
+declare class PutMutableError extends MainlineError {
+  constructor(message: string);
+}
+/**
+ * I/O error.
+ *
+ * Port of `Error::Io` from mainline/error.rs line 19-20.
+ *
+ * @category Mainline
+ */
+declare class MainlineIoError extends MainlineError {
+  constructor(message: string);
+}
+//#endregion
+//#region src/mainline/kv.d.ts
+/**
+ * Mainline DHT-backed key-value store using ARID-based addressing.
+ *
+ * This implementation uses:
+ * - ARID → ed25519 signing key derivation (deterministic)
+ * - BEP-44 mutable storage (fixed location based on pubkey)
+ * - Mainline DHT (BitTorrent DHT) for decentralized storage
+ * - Write-once semantics (seq=1, put fails if already exists)
+ * - Maximum value size: 1000 bytes (DHT protocol limit)
+ *
+ * Port of `struct MainlineDhtKv` from mainline/kv.rs lines 60-64.
+ *
+ * # Storage Model
+ *
+ * Uses BEP-44 mutable items where:
+ * - Public key derived from ARID (deterministic ed25519)
+ * - Sequence number starts at 1 (write-once)
+ * - Optional salt for namespace separation
+ * - Location fixed by pubkey (not content hash)
+ *
+ * # Requirements
+ *
+ * No external daemon required - the DHT client runs embedded.
+ *
+ * # Size Limits
+ *
+ * The Mainline DHT has a practical limit of ~1KB per value. For larger
+ * envelopes, use `IpfsKv` or `HybridKv` instead.
+ *
+ * @category Mainline Backend
+ *
+ * @example
+ * ```typescript
+ * const store = await MainlineDhtKv.create();
+ * const arid = ARID.new();
+ * const envelope = Envelope.new("Small message");
+ *
+ * // Put envelope (write-once)
+ * await store.put(arid, envelope);
+ *
+ * // Get envelope with verbose logging
+ * const retrieved = await store.get(arid, undefined, true);
+ * ```
+ */
+declare class MainlineDhtKv implements KvStore {
+  private readonly dht;
+  private maxValueSize;
+  private salt;
+  private _isBootstrapped;
+  /**
+   * Private constructor - use `create()` factory method.
+   */
+  private constructor();
+  /**
+   * Check if the DHT is bootstrapped.
+   */
+  get isBootstrapped(): boolean;
+  /**
+   * Create a new Mainline DHT KV store with default settings.
+   *
+   * Port of `MainlineDhtKv::new()` from mainline/kv.rs lines 68-79.
+   */
+  static create(): Promise<MainlineDhtKv>;
+  /**
+   * Set the maximum value size (default: 1000 bytes).
+   *
+   * Note: Values larger than ~1KB may not be reliably stored in the DHT.
+   *
+   * Port of `MainlineDhtKv::with_max_size()` from mainline/kv.rs lines 84-87.
+   */
+  withMaxSize(size: number): this;
+  /**
+   * Set a salt for namespace separation.
+   *
+   * Different salts will create separate namespaces for the same ARID.
+   *
+   * Port of `MainlineDhtKv::with_salt()` from mainline/kv.rs lines 92-95.
+   */
+  withSalt(salt: Uint8Array): this;
+  /**
+   * Derive an ed25519 signing key from an ARID.
+   *
+   * Uses the ARID-derived key material extended to 32 bytes for ed25519.
+   *
+   * Port of `MainlineDhtKv::derive_signing_key()` from mainline/kv.rs lines 100-112.
+   *
+   * @internal
+   */
+  private static deriveSigningKey;
+  /**
+   * Get mutable item from DHT.
+   *
+   * @internal
+   */
+  private getMutable;
+  /**
+   * Put mutable item to DHT.
+   *
+   * @internal
+   */
+  private putMutable;
+  /**
+   * Compute DHT target hash from public key and optional salt.
+   *
+   * @internal
+   */
+  private computeTarget;
+  /**
+   * Store an envelope at the given ARID.
+   *
+   * Port of `KvStore::put()` implementation from mainline/kv.rs lines 144-220.
+   */
+  put(arid: ARID, envelope: Envelope, _ttlSeconds?: number, // Ignored - DHT has no TTL support
+  verbose?: boolean): Promise<string>;
+  /**
+   * Retrieve an envelope for the given ARID.
+   *
+   * Port of `KvStore::get()` implementation from mainline/kv.rs lines 223-303.
+   */
+  get(arid: ARID, timeoutSeconds?: number, verbose?: boolean): Promise<Envelope | null>;
+  /**
+   * Check if an envelope exists at the given ARID.
+   *
+   * Port of `KvStore::exists()` implementation from mainline/kv.rs lines 306-314.
+   */
+  exists(arid: ARID): Promise<boolean>;
+  /**
+   * Destroy the DHT client and release resources.
+   */
+  destroy(): Promise<void>;
+}
+//#endregion
+export { MainlineIoError as a, ValueTooLargeError as c, MainlineError as i, DecodeIdError as n, PutMutableError as o, DhtError as r, PutQueryError as s, MainlineDhtKv as t };
+//# sourceMappingURL=index-jyzuOhFB.d.cts.map

package/dist/index-jyzuOhFB.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-jyzuOhFB.d.cts","names":[],"sources":["../src/mainline/error.ts","../src/mainline/kv.ts"],"mappings":";;;;;;;;;;cAea,aAAA,SAAsB,WAAA;cACrB,OAAA;AAAA;;;;;;;;cAaD,kBAAA,SAA2B,aAAA;EAAA,SAC7B,IAAA;cAEG,IAAA;AAAA;;;;;;;AA4Bd;cAda,QAAA,SAAiB,aAAA;cAChB,OAAA;AAAA;;;;;;AA2Bd;;cAda,aAAA,SAAsB,aAAA;cACrB,OAAA;AAAA;;;;;AA2Bd;;;cAda,aAAA,SAAsB,aAAA;cACrB,OAAA;AAAA;;;;AA2Bd;;;;cAda,eAAA,SAAwB,aAAA;cACvB,OAAA;AAAA;;;;;;ACxBd;;cDqCa,eAAA,SAAwB,aAAA;cACvB,OAAA;AAAA;;;;;;;AA1Ed;;;;;;;;;;AAiBA;;;;;;;;;AAcA;;;;;;;;;AAcA;;;;;;;;;AAcA;;;cCvBa,aAAA,YAAyB,OAAA;EAAA,iBACnB,GAAA;EAAA,QACT,YAAA;EAAA,QACA,IAAA;EAAA,QACA,eAAA;EDoBmB;AAa7B;;EAb6B,QCfpB,WAAA,CAAA;ED4ByC;;;EAAA,IClB5C,cAAA,CAAA;EDmBuB;;;;;EAAA,OCVd,MAAA,CAAA,GAAU,OAAA,CAAQ,aAAA;EA5BN;;;;;;;EA6DzB,WAAA,CAAY,IAAA;EAiMI;;;;;;;EArLhB,QAAA,CAAS,IAAA,EAAM,UAAA;EAzE4B;;;;;;;;;EAAA,eAuF5B,gBAAA;EA3DgB;;;;;EAAA,QAiFvB,UAAA;EAtBO;;;;;EAAA,QAyCP,UAAA;EA4DN;;;;;EAAA,QAlBM,aAAA;EAoFF;;;;;EAnEA,GAAA,CACJ,IAAA,EAAM,IAAA,EACN,QAAA,EAAU,QAAA,EACV,WAAA;EACA,OAAA,aACC,OAAA;EAuIG;;;;;EAzEA,GAAA,CAAI,IAAA,EAAM,IAAA,EAAM,cAAA,WAAyB,OAAA,aAAoB,OAAA,CAAQ,QAAA;EAoFzD;;;;;EAXZ,MAAA,CAAO,IAAA,EAAM,IAAA,GAAO,OAAA;;;;EAW1B,OAAA,CAAA,GAAW,OAAA;AAAA"}

package/dist/index.cjs

@@ -0,0 +1,60 @@
+const require_logging = require('./logging-qc9uMgil.cjs');
+const require_arid_derivation = require('./arid-derivation-1CJuU-kZ.cjs');
+const require_server = require('./server-BBNRZ30D.cjs');
+const require_kv = require('./kv-yjvQa_LH.cjs');
+require('./ipfs-CetOVQcO.cjs');
+const require_kv$1 = require('./kv-BAmhmMOo.cjs');
+require('./mainline-D_jfeFMh.cjs');
+const require_hybrid = require('./hybrid-dX5JLumO.cjs');
+
+exports.AlreadyExistsError = require_logging.AlreadyExistsError;
+exports.ContentNotFoundError = require_hybrid.ContentNotFoundError;
+exports.DecodeIdError = require_kv$1.DecodeIdError;
+exports.DhtError = require_kv$1.DhtError;
+exports.EnvelopeTooLargeError = require_kv.EnvelopeTooLargeError;
+exports.HubertError = require_logging.HubertError;
+exports.HybridError = require_hybrid.HybridError;
+exports.HybridKv = require_hybrid.HybridKv;
+exports.InvalidAridError = require_logging.InvalidAridError;
+exports.InvalidReferenceAridError = require_hybrid.InvalidReferenceAridError;
+exports.IoError = require_logging.IoError;
+exports.IpfsDaemonError = require_kv.IpfsDaemonError;
+exports.IpfsError = require_kv.IpfsError;
+exports.IpfsKv = require_kv.IpfsKv;
+exports.IpfsTimeoutError = require_kv.IpfsTimeoutError;
+exports.MainlineDhtKv = require_kv$1.MainlineDhtKv;
+exports.MainlineError = require_kv$1.MainlineError;
+exports.MainlineIoError = require_kv$1.MainlineIoError;
+exports.MemoryKv = require_server.MemoryKv;
+exports.NoIdAssertionError = require_hybrid.NoIdAssertionError;
+exports.NotFoundError = require_logging.NotFoundError;
+exports.NotReferenceEnvelopeError = require_hybrid.NotReferenceEnvelopeError;
+exports.PutMutableError = require_kv$1.PutMutableError;
+exports.PutQueryError = require_kv$1.PutQueryError;
+exports.Server = require_server.Server;
+exports.ServerError = require_server.ServerError;
+exports.ServerGeneralError = require_server.ServerGeneralError;
+exports.ServerKvClient = require_server.ServerKvClient;
+exports.ServerNetworkError = require_server.ServerNetworkError;
+exports.ServerParseError = require_server.ServerParseError;
+exports.SqliteError = require_server.SqliteError;
+exports.SqliteKv = require_server.SqliteKv;
+exports.UnexpectedIpnsPathFormatError = require_kv.UnexpectedIpnsPathFormatError;
+exports.ValueTooLargeError = require_kv$1.ValueTooLargeError;
+exports.addBytes = require_kv.addBytes;
+exports.catBytes = require_kv.catBytes;
+exports.createMemoryKv = require_server.createMemoryKv;
+exports.createReferenceEnvelope = require_hybrid.createReferenceEnvelope;
+exports.createSqliteKv = require_server.createSqliteKv;
+exports.defaultServerConfig = require_server.defaultServerConfig;
+exports.deriveIpfsKeyName = require_arid_derivation.deriveIpfsKeyName;
+exports.deriveKey = require_arid_derivation.deriveKey;
+exports.deriveMainlineKey = require_arid_derivation.deriveMainlineKey;
+exports.extractReferenceArid = require_hybrid.extractReferenceArid;
+exports.isReferenceEnvelope = require_hybrid.isReferenceEnvelope;
+exports.obfuscateWithArid = require_arid_derivation.obfuscateWithArid;
+exports.pinCid = require_kv.pinCid;
+exports.timestamp = require_logging.timestamp;
+exports.verboseNewline = require_logging.verboseNewline;
+exports.verbosePrintDot = require_logging.verbosePrintDot;
+exports.verbosePrintln = require_logging.verbosePrintln;

package/dist/index.d.cts

@@ -0,0 +1,161 @@
+import { a as IoError, i as InvalidAridError, n as AlreadyExistsError, o as NotFoundError, r as HubertError, t as KvStore } from "./kv-store-ww-AUyLd.cjs";
+import { a as ContentNotFoundError, c as NoIdAssertionError, i as isReferenceEnvelope, l as NotReferenceEnvelopeError, n as createReferenceEnvelope, o as HybridError, r as extractReferenceArid, s as InvalidReferenceAridError, t as HybridKv } from "./index-CY3TCzIm.cjs";
+import { a as ServerKv, c as SqliteKv, d as ServerGeneralError, f as ServerNetworkError, i as defaultServerConfig, l as MemoryKv, m as SqliteError, n as Server, o as createMemoryKv, p as ServerParseError, r as ServerConfig, s as createSqliteKv, t as ServerKvClient, u as ServerError } from "./index-CV6lZJqY.cjs";
+import { a as EnvelopeTooLargeError, c as IpfsTimeoutError, i as pinCid, l as UnexpectedIpnsPathFormatError, n as addBytes, o as IpfsDaemonError, r as catBytes, s as IpfsError, t as IpfsKv } from "./index-DEr4SR1J.cjs";
+import { a as MainlineIoError, c as ValueTooLargeError, i as MainlineError, n as DecodeIdError, o as PutMutableError, r as DhtError, s as PutQueryError, t as MainlineDhtKv } from "./index-jyzuOhFB.cjs";
+import { ARID } from "@bcts/components";
+
+//#region src/arid-derivation.d.ts
+/**
+ * Derive a deterministic key from an ARID using a specific salt.
+ *
+ * Uses HKDF to derive key material from the ARID, ensuring that:
+ * - Same ARID always produces same key for a given salt
+ * - Keys are cryptographically derived (not guessable)
+ * - Collision resistance inherited from ARID
+ * - No identifying information in the key (fully anonymized)
+ *
+ * Port of `derive_key()` from arid_derivation.rs lines 8-29.
+ *
+ * @param salt - Domain-specific salt to ensure different backends derive different keys
+ * @param arid - The ARID to derive from
+ * @param outputLen - Length of output in bytes (typically 20 or 32)
+ * @returns Derived key bytes
+ * @category ARID Derivation
+ *
+ * @example
+ * ```typescript
+ * const key = deriveKey(new TextEncoder().encode("my-salt"), arid, 32);
+ * ```
+ */
+declare function deriveKey(salt: Uint8Array, arid: ARID, outputLen: number): Uint8Array;
+/**
+ * Derive an IPNS key name from an ARID.
+ *
+ * Returns a 64-character hex string suitable for use as an IPFS key name.
+ *
+ * Port of `derive_ipfs_key_name()` from arid_derivation.rs lines 31-37.
+ *
+ * @param arid - The ARID to derive from
+ * @returns 64-character hex string
+ * @category ARID Derivation
+ *
+ * @example
+ * ```typescript
+ * const keyName = deriveIpfsKeyName(arid);
+ * // => "a1b2c3d4e5f6..." (64 hex characters)
+ * ```
+ */
+declare function deriveIpfsKeyName(arid: ARID): string;
+/**
+ * Derive Mainline DHT key material from an ARID.
+ *
+ * Returns 20 bytes of key material (SHA-1 compatible length).
+ *
+ * Port of `derive_mainline_key()` from arid_derivation.rs lines 39-45.
+ *
+ * @param arid - The ARID to derive from
+ * @returns 20 bytes of key material
+ * @category ARID Derivation
+ *
+ * @example
+ * ```typescript
+ * const key = deriveMainlineKey(arid);
+ * // => Uint8Array(20) [...]
+ * ```
+ */
+declare function deriveMainlineKey(arid: ARID): Uint8Array;
+/**
+ * Obfuscate or deobfuscate data using ChaCha20 with an ARID-derived key.
+ *
+ * This function uses ChaCha20 as a stream cipher to XOR the data with a
+ * keystream derived from the ARID. Since XOR is symmetric, the same function
+ * is used for both obfuscation and deobfuscation.
+ *
+ * The result appears as uniform random data to anyone who doesn't have the
+ * ARID, hiding both the structure and content of the reference envelope.
+ *
+ * Port of `obfuscate_with_arid()` from arid_derivation.rs lines 47-91.
+ *
+ * @param arid - The ARID used to derive the obfuscation key
+ * @param data - The data to obfuscate or deobfuscate
+ * @returns The obfuscated (or deobfuscated) data
+ * @category ARID Derivation
+ *
+ * @example
+ * ```typescript
+ * const obfuscated = obfuscateWithArid(arid, plaintext);
+ * const deobfuscated = obfuscateWithArid(arid, obfuscated);
+ * // deobfuscated === plaintext
+ * ```
+ */
+declare function obfuscateWithArid(arid: ARID, data: Uint8Array): Uint8Array;
+//#endregion
+//#region src/logging.d.ts
+/**
+ * Logging utilities for verbose output with timestamps.
+ *
+ * Port of logging.rs from hubert-rust.
+ *
+ * @module
+ */
+/**
+ * Format a timestamp in ISO-8601 Zulu format with fractional seconds.
+ *
+ * Port of `timestamp()` from logging.rs lines 6-71.
+ *
+ * @returns Timestamp string in format "YYYY-MM-DDTHH:MM:SS.mmmZ"
+ * @category Logging
+ *
+ * @example
+ * ```typescript
+ * timestamp() // => "2024-01-15T14:30:45.123Z"
+ * ```
+ */
+declare function timestamp(): string;
+/**
+ * Print a verbose message with timestamp prefix.
+ *
+ * Port of `verbose_println()` from logging.rs lines 74-78.
+ *
+ * @param message - The message to print
+ * @category Logging
+ *
+ * @example
+ * ```typescript
+ * verbosePrintln("Starting operation...");
+ * // Output: [2024-01-15T14:30:45.123Z] Starting operation...
+ * ```
+ */
+declare function verbosePrintln(message: string): void;
+/**
+ * Print a polling dot on the same line (no newline).
+ *
+ * Port of `verbose_print_dot()` from logging.rs lines 81-84.
+ *
+ * @category Logging
+ *
+ * @example
+ * ```typescript
+ * verbosePrintDot(); // Prints "." without newline
+ * ```
+ */
+declare function verbosePrintDot(): void;
+/**
+ * Print a newline after dots.
+ *
+ * Port of `verbose_newline()` from logging.rs lines 87-89.
+ *
+ * @category Logging
+ *
+ * @example
+ * ```typescript
+ * verbosePrintDot();
+ * verbosePrintDot();
+ * verboseNewline(); // Completes the line of dots
+ * ```
+ */
+declare function verboseNewline(): void;
+//#endregion
+export { AlreadyExistsError, ContentNotFoundError, DecodeIdError, DhtError, EnvelopeTooLargeError, HubertError, HybridError, HybridKv, InvalidAridError, InvalidReferenceAridError, IoError, IpfsDaemonError, IpfsError, IpfsKv, IpfsTimeoutError, type KvStore, MainlineDhtKv, MainlineError, MainlineIoError, MemoryKv, NoIdAssertionError, NotFoundError, NotReferenceEnvelopeError, PutMutableError, PutQueryError, Server, type ServerConfig, ServerError, ServerGeneralError, type ServerKv, ServerKvClient, ServerNetworkError, ServerParseError, SqliteError, SqliteKv, UnexpectedIpnsPathFormatError, ValueTooLargeError, addBytes, catBytes, createMemoryKv, createReferenceEnvelope, createSqliteKv, defaultServerConfig, deriveIpfsKeyName, deriveKey, deriveMainlineKey, extractReferenceArid, isReferenceEnvelope, obfuscateWithArid, pinCid, timestamp, verboseNewline, verbosePrintDot, verbosePrintln };
+//# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":[],"sources":["../src/arid-derivation.ts","../src/logging.ts"],"mappings":";;;;;;;;AAkCA;;;;;;;;;;;;;;;;AA0CA;;;;;AAsBA;AAhEA,iBAAgB,SAAA,CAAU,IAAA,EAAM,UAAA,EAAY,IAAA,EAAM,IAAA,EAAM,SAAA,WAAoB,UAAA;;;;;;;;AA4F5E;;;;;;;;;;iBAlDgB,iBAAA,CAAkB,IAAA,EAAM,IAAA;;;;;;;;ACvDxC;;;;;AA4BA;;;;;iBDiDgB,iBAAA,CAAkB,IAAA,EAAM,IAAA,GAAO,UAAA;;;;;ACb/C;;;;;;;;;;;;;;;;;;;;iBDyCgB,iBAAA,CAAkB,IAAA,EAAM,IAAA,EAAM,IAAA,EAAM,UAAA,GAAa,UAAA;;;;;;;;;;;AA5FjE;;;;;;;;;;;;iBCbgB,SAAA,CAAA;;;;ADuDhB;;;;;AAsBA;;;;;;iBCjDgB,cAAA,CAAe,OAAA;;;AD6E/B;;;;;;;;;;iBC3DgB,eAAA,CAAA;;;;;;;;AA9ChB;;;;;AA4BA;;iBAoCgB,cAAA,CAAA"}

package/dist/index.d.mts

@@ -0,0 +1,161 @@
+import { a as IoError, i as InvalidAridError, n as AlreadyExistsError, o as NotFoundError, r as HubertError, t as KvStore } from "./kv-store-DmngWWuw.mjs";
+import { a as ContentNotFoundError, c as NoIdAssertionError, i as isReferenceEnvelope, l as NotReferenceEnvelopeError, n as createReferenceEnvelope, o as HybridError, r as extractReferenceArid, s as InvalidReferenceAridError, t as HybridKv } from "./index-T1LHanIb.mjs";
+import { a as ServerKv, c as SqliteKv, d as ServerGeneralError, f as ServerNetworkError, i as defaultServerConfig, l as MemoryKv, m as SqliteError, n as Server, o as createMemoryKv, p as ServerParseError, r as ServerConfig, s as createSqliteKv, t as ServerKvClient, u as ServerError } from "./index-BEzpUC7r.mjs";
+import { a as EnvelopeTooLargeError, c as IpfsTimeoutError, i as pinCid, l as UnexpectedIpnsPathFormatError, n as addBytes, o as IpfsDaemonError, r as catBytes, s as IpfsError, t as IpfsKv } from "./index-CUnDouMb.mjs";
+import { a as MainlineIoError, c as ValueTooLargeError, i as MainlineError, n as DecodeIdError, o as PutMutableError, r as DhtError, s as PutQueryError, t as MainlineDhtKv } from "./index-C2F6ugLL.mjs";
+import { ARID } from "@bcts/components";
+
+//#region src/arid-derivation.d.ts
+/**
+ * Derive a deterministic key from an ARID using a specific salt.
+ *
+ * Uses HKDF to derive key material from the ARID, ensuring that:
+ * - Same ARID always produces same key for a given salt
+ * - Keys are cryptographically derived (not guessable)
+ * - Collision resistance inherited from ARID
+ * - No identifying information in the key (fully anonymized)
+ *
+ * Port of `derive_key()` from arid_derivation.rs lines 8-29.
+ *
+ * @param salt - Domain-specific salt to ensure different backends derive different keys
+ * @param arid - The ARID to derive from
+ * @param outputLen - Length of output in bytes (typically 20 or 32)
+ * @returns Derived key bytes
+ * @category ARID Derivation
+ *
+ * @example
+ * ```typescript
+ * const key = deriveKey(new TextEncoder().encode("my-salt"), arid, 32);
+ * ```
+ */
+declare function deriveKey(salt: Uint8Array, arid: ARID, outputLen: number): Uint8Array;
+/**
+ * Derive an IPNS key name from an ARID.
+ *
+ * Returns a 64-character hex string suitable for use as an IPFS key name.
+ *
+ * Port of `derive_ipfs_key_name()` from arid_derivation.rs lines 31-37.
+ *
+ * @param arid - The ARID to derive from
+ * @returns 64-character hex string
+ * @category ARID Derivation
+ *
+ * @example
+ * ```typescript
+ * const keyName = deriveIpfsKeyName(arid);
+ * // => "a1b2c3d4e5f6..." (64 hex characters)
+ * ```
+ */
+declare function deriveIpfsKeyName(arid: ARID): string;
+/**
+ * Derive Mainline DHT key material from an ARID.
+ *
+ * Returns 20 bytes of key material (SHA-1 compatible length).
+ *
+ * Port of `derive_mainline_key()` from arid_derivation.rs lines 39-45.
+ *
+ * @param arid - The ARID to derive from
+ * @returns 20 bytes of key material
+ * @category ARID Derivation
+ *
+ * @example
+ * ```typescript
+ * const key = deriveMainlineKey(arid);
+ * // => Uint8Array(20) [...]
+ * ```
+ */
+declare function deriveMainlineKey(arid: ARID): Uint8Array;
+/**
+ * Obfuscate or deobfuscate data using ChaCha20 with an ARID-derived key.
+ *
+ * This function uses ChaCha20 as a stream cipher to XOR the data with a
+ * keystream derived from the ARID. Since XOR is symmetric, the same function
+ * is used for both obfuscation and deobfuscation.
+ *
+ * The result appears as uniform random data to anyone who doesn't have the
+ * ARID, hiding both the structure and content of the reference envelope.
+ *
+ * Port of `obfuscate_with_arid()` from arid_derivation.rs lines 47-91.
+ *
+ * @param arid - The ARID used to derive the obfuscation key
+ * @param data - The data to obfuscate or deobfuscate
+ * @returns The obfuscated (or deobfuscated) data
+ * @category ARID Derivation
+ *
+ * @example
+ * ```typescript
+ * const obfuscated = obfuscateWithArid(arid, plaintext);
+ * const deobfuscated = obfuscateWithArid(arid, obfuscated);
+ * // deobfuscated === plaintext
+ * ```
+ */
+declare function obfuscateWithArid(arid: ARID, data: Uint8Array): Uint8Array;
+//#endregion
+//#region src/logging.d.ts
+/**
+ * Logging utilities for verbose output with timestamps.
+ *
+ * Port of logging.rs from hubert-rust.
+ *
+ * @module
+ */
+/**
+ * Format a timestamp in ISO-8601 Zulu format with fractional seconds.
+ *
+ * Port of `timestamp()` from logging.rs lines 6-71.
+ *
+ * @returns Timestamp string in format "YYYY-MM-DDTHH:MM:SS.mmmZ"
+ * @category Logging
+ *
+ * @example
+ * ```typescript
+ * timestamp() // => "2024-01-15T14:30:45.123Z"
+ * ```
+ */
+declare function timestamp(): string;
+/**
+ * Print a verbose message with timestamp prefix.
+ *
+ * Port of `verbose_println()` from logging.rs lines 74-78.
+ *
+ * @param message - The message to print
+ * @category Logging
+ *
+ * @example
+ * ```typescript
+ * verbosePrintln("Starting operation...");
+ * // Output: [2024-01-15T14:30:45.123Z] Starting operation...
+ * ```
+ */
+declare function verbosePrintln(message: string): void;
+/**
+ * Print a polling dot on the same line (no newline).
+ *
+ * Port of `verbose_print_dot()` from logging.rs lines 81-84.
+ *
+ * @category Logging
+ *
+ * @example
+ * ```typescript
+ * verbosePrintDot(); // Prints "." without newline
+ * ```
+ */
+declare function verbosePrintDot(): void;
+/**
+ * Print a newline after dots.
+ *
+ * Port of `verbose_newline()` from logging.rs lines 87-89.
+ *
+ * @category Logging
+ *
+ * @example
+ * ```typescript
+ * verbosePrintDot();
+ * verbosePrintDot();
+ * verboseNewline(); // Completes the line of dots
+ * ```
+ */
+declare function verboseNewline(): void;
+//#endregion
+export { AlreadyExistsError, ContentNotFoundError, DecodeIdError, DhtError, EnvelopeTooLargeError, HubertError, HybridError, HybridKv, InvalidAridError, InvalidReferenceAridError, IoError, IpfsDaemonError, IpfsError, IpfsKv, IpfsTimeoutError, type KvStore, MainlineDhtKv, MainlineError, MainlineIoError, MemoryKv, NoIdAssertionError, NotFoundError, NotReferenceEnvelopeError, PutMutableError, PutQueryError, Server, type ServerConfig, ServerError, ServerGeneralError, type ServerKv, ServerKvClient, ServerNetworkError, ServerParseError, SqliteError, SqliteKv, UnexpectedIpnsPathFormatError, ValueTooLargeError, addBytes, catBytes, createMemoryKv, createReferenceEnvelope, createSqliteKv, defaultServerConfig, deriveIpfsKeyName, deriveKey, deriveMainlineKey, extractReferenceArid, isReferenceEnvelope, obfuscateWithArid, pinCid, timestamp, verboseNewline, verbosePrintDot, verbosePrintln };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/arid-derivation.ts","../src/logging.ts"],"mappings":";;;;;;;;AAkCA;;;;;;;;;;;;;;;;AA0CA;;;;;AAsBA;AAhEA,iBAAgB,SAAA,CAAU,IAAA,EAAM,UAAA,EAAY,IAAA,EAAM,IAAA,EAAM,SAAA,WAAoB,UAAA;;;;;;;;AA4F5E;;;;;;;;;;iBAlDgB,iBAAA,CAAkB,IAAA,EAAM,IAAA;;;;;;;;ACvDxC;;;;;AA4BA;;;;;iBDiDgB,iBAAA,CAAkB,IAAA,EAAM,IAAA,GAAO,UAAA;;;;;ACb/C;;;;;;;;;;;;;;;;;;;;iBDyCgB,iBAAA,CAAkB,IAAA,EAAM,IAAA,EAAM,IAAA,EAAM,UAAA,GAAa,UAAA;;;;;;;;;;;AA5FjE;;;;;;;;;;;;iBCbgB,SAAA,CAAA;;;;ADuDhB;;;;;AAsBA;;;;;;iBCjDgB,cAAA,CAAe,OAAA;;;AD6E/B;;;;;;;;;;iBC3DgB,eAAA,CAAA;;;;;;;;AA9ChB;;;;;AA4BA;;iBAoCgB,cAAA,CAAA"}

package/dist/index.mjs

@@ -0,0 +1,10 @@
+import { a as AlreadyExistsError, c as IoError, i as verbosePrintln, l as NotFoundError, n as verboseNewline, o as HubertError, r as verbosePrintDot, s as InvalidAridError, t as timestamp } from "./logging-hmzNzifq.mjs";
+import { i as obfuscateWithArid, n as deriveKey, r as deriveMainlineKey, t as deriveIpfsKeyName } from "./arid-derivation-CbqACjdg.mjs";
+import { a as createSqliteKv, c as ServerError, d as ServerParseError, f as SqliteError, i as createMemoryKv, l as ServerGeneralError, n as Server, o as SqliteKv, r as defaultServerConfig, s as MemoryKv, t as ServerKvClient, u as ServerNetworkError } from "./server-DVyk9gqU.mjs";
+import { a as EnvelopeTooLargeError, c as IpfsTimeoutError, i as pinCid, l as UnexpectedIpnsPathFormatError, n as addBytes, o as IpfsDaemonError, r as catBytes, s as IpfsError, t as IpfsKv } from "./kv-DJiKvypY.mjs";
+import "./ipfs-BRMMCBjv.mjs";
+import { a as MainlineIoError, c as ValueTooLargeError, i as MainlineError, n as DecodeIdError, o as PutMutableError, r as DhtError, s as PutQueryError, t as MainlineDhtKv } from "./kv-C-emxv0w.mjs";
+import "./mainline-cFIuXbo-.mjs";
+import { a as ContentNotFoundError, c as NoIdAssertionError, i as isReferenceEnvelope, l as NotReferenceEnvelopeError, n as createReferenceEnvelope, o as HybridError, r as extractReferenceArid, s as InvalidReferenceAridError, t as HybridKv } from "./hybrid-BZhumygj.mjs";
+
+export { AlreadyExistsError, ContentNotFoundError, DecodeIdError, DhtError, EnvelopeTooLargeError, HubertError, HybridError, HybridKv, InvalidAridError, InvalidReferenceAridError, IoError, IpfsDaemonError, IpfsError, IpfsKv, IpfsTimeoutError, MainlineDhtKv, MainlineError, MainlineIoError, MemoryKv, NoIdAssertionError, NotFoundError, NotReferenceEnvelopeError, PutMutableError, PutQueryError, Server, ServerError, ServerGeneralError, ServerKvClient, ServerNetworkError, ServerParseError, SqliteError, SqliteKv, UnexpectedIpnsPathFormatError, ValueTooLargeError, addBytes, catBytes, createMemoryKv, createReferenceEnvelope, createSqliteKv, defaultServerConfig, deriveIpfsKeyName, deriveKey, deriveMainlineKey, extractReferenceArid, isReferenceEnvelope, obfuscateWithArid, pinCid, timestamp, verboseNewline, verbosePrintDot, verbosePrintln };

package/dist/ipfs/index.cjs

@@ -0,0 +1,13 @@
+require('../arid-derivation-1CJuU-kZ.cjs');
+const require_kv = require('../kv-yjvQa_LH.cjs');
+require('../ipfs-CetOVQcO.cjs');
+
+exports.EnvelopeTooLargeError = require_kv.EnvelopeTooLargeError;
+exports.IpfsDaemonError = require_kv.IpfsDaemonError;
+exports.IpfsError = require_kv.IpfsError;
+exports.IpfsKv = require_kv.IpfsKv;
+exports.IpfsTimeoutError = require_kv.IpfsTimeoutError;
+exports.UnexpectedIpnsPathFormatError = require_kv.UnexpectedIpnsPathFormatError;
+exports.addBytes = require_kv.addBytes;
+exports.catBytes = require_kv.catBytes;
+exports.pinCid = require_kv.pinCid;

package/dist/ipfs/index.d.cts

@@ -0,0 +1,3 @@
+import "../kv-store-ww-AUyLd.cjs";
+import { a as EnvelopeTooLargeError, c as IpfsTimeoutError, i as pinCid, l as UnexpectedIpnsPathFormatError, n as addBytes, o as IpfsDaemonError, r as catBytes, s as IpfsError, t as IpfsKv } from "../index-DEr4SR1J.cjs";
+export { EnvelopeTooLargeError, IpfsDaemonError, IpfsError, IpfsKv, IpfsTimeoutError, UnexpectedIpnsPathFormatError, addBytes, catBytes, pinCid };

package/dist/ipfs/index.d.mts

@@ -0,0 +1,3 @@
+import "../kv-store-DmngWWuw.mjs";
+import { a as EnvelopeTooLargeError, c as IpfsTimeoutError, i as pinCid, l as UnexpectedIpnsPathFormatError, n as addBytes, o as IpfsDaemonError, r as catBytes, s as IpfsError, t as IpfsKv } from "../index-CUnDouMb.mjs";
+export { EnvelopeTooLargeError, IpfsDaemonError, IpfsError, IpfsKv, IpfsTimeoutError, UnexpectedIpnsPathFormatError, addBytes, catBytes, pinCid };

package/dist/ipfs/index.mjs

@@ -0,0 +1,5 @@
+import "../arid-derivation-CbqACjdg.mjs";
+import { a as EnvelopeTooLargeError, c as IpfsTimeoutError, i as pinCid, l as UnexpectedIpnsPathFormatError, n as addBytes, o as IpfsDaemonError, r as catBytes, s as IpfsError, t as IpfsKv } from "../kv-DJiKvypY.mjs";
+import "../ipfs-BRMMCBjv.mjs";
+
+export { EnvelopeTooLargeError, IpfsDaemonError, IpfsError, IpfsKv, IpfsTimeoutError, UnexpectedIpnsPathFormatError, addBytes, catBytes, pinCid };

package/dist/ipfs-BRMMCBjv.mjs

@@ -0,0 +1 @@
+export {  };