@bcts/hubert 1.0.0-alpha.17

package/dist/kv-BAmhmMOo.cjs

@@ -0,0 +1,425 @@
+const require_chunk = require('./chunk-CbDLau6x.cjs');
+const require_logging = require('./logging-qc9uMgil.cjs');
+const require_arid_derivation = require('./arid-derivation-1CJuU-kZ.cjs');
+let _bcts_envelope = require("@bcts/envelope");
+let node_crypto = require("node:crypto");
+node_crypto = require_chunk.__toESM(node_crypto);
+let bittorrent_dht = require("bittorrent-dht");
+bittorrent_dht = require_chunk.__toESM(bittorrent_dht);
+let _noble_curves_ed25519_js = require("@noble/curves/ed25519.js");
+
+//#region src/mainline/error.ts
+/**
+* Mainline DHT-specific errors.
+*
+* Port of mainline/error.rs from hubert-rust.
+*
+* @module
+*/
+/**
+* Base class for Mainline DHT-specific errors.
+*
+* @category Mainline
+*/
+var MainlineError = class extends require_logging.HubertError {
+	constructor(message) {
+		super(message);
+		this.name = "MainlineError";
+	}
+};
+/**
+* Value size exceeds DHT limit.
+*
+* Port of `Error::ValueTooLarge { size }` from mainline/error.rs line 4-5.
+*
+* @category Mainline
+*/
+var ValueTooLargeError = class extends MainlineError {
+	size;
+	constructor(size) {
+		super(`Value size ${size} exceeds DHT limit of 1000 bytes`);
+		this.name = "ValueTooLargeError";
+		this.size = size;
+	}
+};
+/**
+* DHT operation error.
+*
+* Port of `Error::DhtError` from mainline/error.rs line 7-8.
+*
+* @category Mainline
+*/
+var DhtError = class extends MainlineError {
+	constructor(message) {
+		super(`DHT operation error: ${message}`);
+		this.name = "DhtError";
+	}
+};
+/**
+* Put query error.
+*
+* Port of `Error::PutQueryError` from mainline/error.rs line 10-11.
+*
+* @category Mainline
+*/
+var PutQueryError = class extends MainlineError {
+	constructor(message) {
+		super(`Put query error: ${message}`);
+		this.name = "PutQueryError";
+	}
+};
+/**
+* Decode ID error.
+*
+* Port of `Error::DecodeIdError` from mainline/error.rs line 13-14.
+*
+* @category Mainline
+*/
+var DecodeIdError = class extends MainlineError {
+	constructor(message) {
+		super(`Decode ID error: ${message}`);
+		this.name = "DecodeIdError";
+	}
+};
+/**
+* Put mutable error.
+*
+* Port of `Error::PutMutableError` from mainline/error.rs line 16-17.
+*
+* @category Mainline
+*/
+var PutMutableError = class extends MainlineError {
+	constructor(message) {
+		super(`Put mutable error: ${message}`);
+		this.name = "PutMutableError";
+	}
+};
+/**
+* I/O error.
+*
+* Port of `Error::Io` from mainline/error.rs line 19-20.
+*
+* @category Mainline
+*/
+var MainlineIoError = class extends MainlineError {
+	constructor(message) {
+		super(`IO error: ${message}`);
+		this.name = "MainlineIoError";
+	}
+};
+
+//#endregion
+//#region src/mainline/kv.ts
+/**
+* Mainline DHT-backed key-value store using ARID-based addressing.
+*
+* Port of mainline/kv.rs from hubert-rust.
+*
+* @module
+*/
+/**
+* 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);
+* ```
+*/
+var MainlineDhtKv = class MainlineDhtKv {
+	dht;
+	maxValueSize;
+	salt;
+	_isBootstrapped;
+	/**
+	* Private constructor - use `create()` factory method.
+	*/
+	constructor(dht) {
+		this.dht = dht;
+		this.maxValueSize = 1e3;
+		this.salt = void 0;
+		this._isBootstrapped = false;
+	}
+	/**
+	* Check if the DHT is bootstrapped.
+	*/
+	get isBootstrapped() {
+		return this._isBootstrapped;
+	}
+	/**
+	* Create a new Mainline DHT KV store with default settings.
+	*
+	* Port of `MainlineDhtKv::new()` from mainline/kv.rs lines 68-79.
+	*/
+	static async create() {
+		const dht = new bittorrent_dht.default();
+		const instance = new MainlineDhtKv(dht);
+		await new Promise((resolve, reject) => {
+			const timeout = setTimeout(() => {
+				reject(new DhtError("Bootstrap timeout"));
+			}, 3e4);
+			dht.on("ready", () => {
+				clearTimeout(timeout);
+				instance._isBootstrapped = true;
+				resolve();
+			});
+			dht.on("error", (err) => {
+				clearTimeout(timeout);
+				reject(new DhtError(err.message));
+			});
+		});
+		return instance;
+	}
+	/**
+	* 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) {
+		this.maxValueSize = size;
+		return 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) {
+		this.salt = salt;
+		return 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
+	*/
+	static deriveSigningKey(arid) {
+		const keyBytes = require_arid_derivation.deriveMainlineKey(arid);
+		const seed = new Uint8Array(32);
+		seed.set(keyBytes.slice(0, 20));
+		for (let i = 20; i < 32; i++) seed[i] = keyBytes[i % 20] * i & 255;
+		return {
+			privateKey: seed,
+			publicKey: _noble_curves_ed25519_js.ed25519.getPublicKey(seed)
+		};
+	}
+	/**
+	* Get mutable item from DHT.
+	*
+	* @internal
+	*/
+	getMutable(publicKey, salt) {
+		return new Promise((resolve) => {
+			const target = this.computeTarget(publicKey, salt);
+			this.dht.get(target, (err, res) => {
+				if (err || !res?.v) resolve(null);
+				else resolve(res.v);
+			});
+		});
+	}
+	/**
+	* Put mutable item to DHT.
+	*
+	* @internal
+	*/
+	putMutable(privateKey, publicKey, value, seq, salt) {
+		return new Promise((resolve, reject) => {
+			const opts = {
+				k: Buffer.from(publicKey),
+				v: Buffer.from(value),
+				seq,
+				sign: (buf) => {
+					return Buffer.from(_noble_curves_ed25519_js.ed25519.sign(buf, privateKey));
+				}
+			};
+			if (salt) opts.salt = Buffer.from(salt);
+			this.dht.put(opts, (err) => {
+				if (err) reject(new PutMutableError(err.message));
+				else resolve();
+			});
+		});
+	}
+	/**
+	* Compute DHT target hash from public key and optional salt.
+	*
+	* @internal
+	*/
+	computeTarget(publicKey, salt) {
+		const hash = node_crypto.default.createHash("sha1");
+		hash.update(publicKey);
+		if (salt) hash.update(salt);
+		return hash.digest();
+	}
+	/**
+	* Store an envelope at the given ARID.
+	*
+	* Port of `KvStore::put()` implementation from mainline/kv.rs lines 144-220.
+	*/
+	async put(arid, envelope, _ttlSeconds, verbose) {
+		if (verbose) require_logging.verbosePrintln("Starting Mainline DHT put operation");
+		const bytes = envelope.taggedCborData();
+		if (verbose) require_logging.verbosePrintln(`Envelope size: ${bytes.length} bytes`);
+		const obfuscated = require_arid_derivation.obfuscateWithArid(arid, bytes);
+		if (obfuscated.length > this.maxValueSize) throw new ValueTooLargeError(obfuscated.length);
+		if (verbose) require_logging.verbosePrintln("Obfuscated envelope data");
+		if (verbose) require_logging.verbosePrintln("Deriving DHT signing key from ARID");
+		const { privateKey, publicKey } = MainlineDhtKv.deriveSigningKey(arid);
+		if (verbose) require_logging.verbosePrintln("Checking for existing value (write-once check)");
+		if (await this.getMutable(publicKey, this.salt) !== null) throw new require_logging.AlreadyExistsError(arid.urString());
+		if (verbose) require_logging.verbosePrintln("Creating mutable DHT item");
+		if (verbose) require_logging.verbosePrintln("Putting value to DHT");
+		await this.putMutable(privateKey, publicKey, obfuscated, 1, this.salt);
+		if (verbose) require_logging.verbosePrintln("Mainline DHT put operation completed");
+		return `dht://${Buffer.from(publicKey).toString("hex")}`;
+	}
+	/**
+	* Retrieve an envelope for the given ARID.
+	*
+	* Port of `KvStore::get()` implementation from mainline/kv.rs lines 223-303.
+	*/
+	async get(arid, timeoutSeconds, verbose) {
+		if (verbose) require_logging.verbosePrintln("Starting Mainline DHT get operation");
+		if (verbose) require_logging.verbosePrintln("Deriving DHT public key from ARID");
+		const { publicKey } = MainlineDhtKv.deriveSigningKey(arid);
+		const timeout = (timeoutSeconds ?? 30) * 1e3;
+		const deadline = Date.now() + timeout;
+		const pollInterval = 1e3;
+		if (verbose) require_logging.verbosePrintln("Polling DHT for value");
+		while (true) {
+			const item = await this.getMutable(publicKey, this.salt);
+			if (item !== null) {
+				if (verbose) {
+					require_logging.verboseNewline();
+					require_logging.verbosePrintln("Value found in DHT");
+				}
+				const deobfuscated = require_arid_derivation.obfuscateWithArid(arid, new Uint8Array(item));
+				if (verbose) require_logging.verbosePrintln("Deobfuscated envelope data");
+				const envelope = _bcts_envelope.EnvelopeDecoder.tryFromCborData(deobfuscated);
+				if (verbose) require_logging.verbosePrintln("Mainline DHT get operation completed");
+				return envelope;
+			}
+			if (Date.now() >= deadline) {
+				if (verbose) {
+					require_logging.verboseNewline();
+					require_logging.verbosePrintln("Timeout reached, value not found");
+				}
+				return null;
+			}
+			if (verbose) require_logging.verbosePrintDot();
+			await new Promise((resolve) => setTimeout(resolve, pollInterval));
+		}
+	}
+	/**
+	* Check if an envelope exists at the given ARID.
+	*
+	* Port of `KvStore::exists()` implementation from mainline/kv.rs lines 306-314.
+	*/
+	async exists(arid) {
+		const { publicKey } = MainlineDhtKv.deriveSigningKey(arid);
+		return await this.getMutable(publicKey, this.salt) !== null;
+	}
+	/**
+	* Destroy the DHT client and release resources.
+	*/
+	destroy() {
+		return new Promise((resolve) => {
+			this.dht.destroy(() => {
+				resolve();
+			});
+		});
+	}
+};
+
+//#endregion
+Object.defineProperty(exports, 'DecodeIdError', {
+  enumerable: true,
+  get: function () {
+    return DecodeIdError;
+  }
+});
+Object.defineProperty(exports, 'DhtError', {
+  enumerable: true,
+  get: function () {
+    return DhtError;
+  }
+});
+Object.defineProperty(exports, 'MainlineDhtKv', {
+  enumerable: true,
+  get: function () {
+    return MainlineDhtKv;
+  }
+});
+Object.defineProperty(exports, 'MainlineError', {
+  enumerable: true,
+  get: function () {
+    return MainlineError;
+  }
+});
+Object.defineProperty(exports, 'MainlineIoError', {
+  enumerable: true,
+  get: function () {
+    return MainlineIoError;
+  }
+});
+Object.defineProperty(exports, 'PutMutableError', {
+  enumerable: true,
+  get: function () {
+    return PutMutableError;
+  }
+});
+Object.defineProperty(exports, 'PutQueryError', {
+  enumerable: true,
+  get: function () {
+    return PutQueryError;
+  }
+});
+Object.defineProperty(exports, 'ValueTooLargeError', {
+  enumerable: true,
+  get: function () {
+    return ValueTooLargeError;
+  }
+});
+//# sourceMappingURL=kv-BAmhmMOo.cjs.map

package/dist/kv-BAmhmMOo.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"kv-BAmhmMOo.cjs","names":["HubertError","DHT","deriveMainlineKey","ed25519","crypto","obfuscateWithArid","AlreadyExistsError","EnvelopeDecoder"],"sources":["../src/mainline/error.ts","../src/mainline/kv.ts"],"sourcesContent":["/**\n * Mainline DHT-specific errors.\n *\n * Port of mainline/error.rs from hubert-rust.\n *\n * @module\n */\n\nimport { HubertError } from \"../error.js\";\n\n/**\n * Base class for Mainline DHT-specific errors.\n *\n * @category Mainline\n */\nexport class MainlineError extends HubertError {\n  constructor(message: string) {\n    super(message);\n    this.name = \"MainlineError\";\n  }\n}\n\n/**\n * Value size exceeds DHT limit.\n *\n * Port of `Error::ValueTooLarge { size }` from mainline/error.rs line 4-5.\n *\n * @category Mainline\n */\nexport class ValueTooLargeError extends MainlineError {\n  readonly size: number;\n\n  constructor(size: number) {\n    super(`Value size ${size} exceeds DHT limit of 1000 bytes`);\n    this.name = \"ValueTooLargeError\";\n    this.size = size;\n  }\n}\n\n/**\n * DHT operation error.\n *\n * Port of `Error::DhtError` from mainline/error.rs line 7-8.\n *\n * @category Mainline\n */\nexport class DhtError extends MainlineError {\n  constructor(message: string) {\n    super(`DHT operation error: ${message}`);\n    this.name = \"DhtError\";\n  }\n}\n\n/**\n * Put query error.\n *\n * Port of `Error::PutQueryError` from mainline/error.rs line 10-11.\n *\n * @category Mainline\n */\nexport class PutQueryError extends MainlineError {\n  constructor(message: string) {\n    super(`Put query error: ${message}`);\n    this.name = \"PutQueryError\";\n  }\n}\n\n/**\n * Decode ID error.\n *\n * Port of `Error::DecodeIdError` from mainline/error.rs line 13-14.\n *\n * @category Mainline\n */\nexport class DecodeIdError extends MainlineError {\n  constructor(message: string) {\n    super(`Decode ID error: ${message}`);\n    this.name = \"DecodeIdError\";\n  }\n}\n\n/**\n * Put mutable error.\n *\n * Port of `Error::PutMutableError` from mainline/error.rs line 16-17.\n *\n * @category Mainline\n */\nexport class PutMutableError extends MainlineError {\n  constructor(message: string) {\n    super(`Put mutable error: ${message}`);\n    this.name = \"PutMutableError\";\n  }\n}\n\n/**\n * I/O error.\n *\n * Port of `Error::Io` from mainline/error.rs line 19-20.\n *\n * @category Mainline\n */\nexport class MainlineIoError extends MainlineError {\n  constructor(message: string) {\n    super(`IO error: ${message}`);\n    this.name = \"MainlineIoError\";\n  }\n}\n","/**\n * Mainline DHT-backed key-value store using ARID-based addressing.\n *\n * Port of mainline/kv.rs from hubert-rust.\n *\n * @module\n */\n\nimport crypto from \"node:crypto\";\nimport { type ARID } from \"@bcts/components\";\nimport { type Envelope, EnvelopeDecoder } from \"@bcts/envelope\";\n// @ts-expect-error - bittorrent-dht has no type declarations\nimport DHT from \"bittorrent-dht\";\nimport { ed25519 } from \"@noble/curves/ed25519.js\";\n\nimport { AlreadyExistsError } from \"../error.js\";\nimport { type KvStore } from \"../kv-store.js\";\nimport { deriveMainlineKey, obfuscateWithArid } from \"../arid-derivation.js\";\nimport { verboseNewline, verbosePrintDot, verbosePrintln } from \"../logging.js\";\nimport { DhtError, PutMutableError, ValueTooLargeError } from \"./error.js\";\n\n/**\n * Mainline DHT-backed key-value store using ARID-based addressing.\n *\n * This implementation uses:\n * - ARID → ed25519 signing key derivation (deterministic)\n * - BEP-44 mutable storage (fixed location based on pubkey)\n * - Mainline DHT (BitTorrent DHT) for decentralized storage\n * - Write-once semantics (seq=1, put fails if already exists)\n * - Maximum value size: 1000 bytes (DHT protocol limit)\n *\n * Port of `struct MainlineDhtKv` from mainline/kv.rs lines 60-64.\n *\n * # Storage Model\n *\n * Uses BEP-44 mutable items where:\n * - Public key derived from ARID (deterministic ed25519)\n * - Sequence number starts at 1 (write-once)\n * - Optional salt for namespace separation\n * - Location fixed by pubkey (not content hash)\n *\n * # Requirements\n *\n * No external daemon required - the DHT client runs embedded.\n *\n * # Size Limits\n *\n * The Mainline DHT has a practical limit of ~1KB per value. For larger\n * envelopes, use `IpfsKv` or `HybridKv` instead.\n *\n * @category Mainline Backend\n *\n * @example\n * ```typescript\n * const store = await MainlineDhtKv.create();\n * const arid = ARID.new();\n * const envelope = Envelope.new(\"Small message\");\n *\n * // Put envelope (write-once)\n * await store.put(arid, envelope);\n *\n * // Get envelope with verbose logging\n * const retrieved = await store.get(arid, undefined, true);\n * ```\n */\nexport class MainlineDhtKv implements KvStore {\n  private readonly dht: DHT;\n  private maxValueSize: number;\n  private salt: Uint8Array | undefined;\n  private _isBootstrapped: boolean;\n\n  /**\n   * Private constructor - use `create()` factory method.\n   */\n  private constructor(dht: DHT) {\n    this.dht = dht;\n    this.maxValueSize = 1000; // DHT protocol limit\n    this.salt = undefined;\n    this._isBootstrapped = false;\n  }\n\n  /**\n   * Check if the DHT is bootstrapped.\n   */\n  get isBootstrapped(): boolean {\n    return this._isBootstrapped;\n  }\n\n  /**\n   * Create a new Mainline DHT KV store with default settings.\n   *\n   * Port of `MainlineDhtKv::new()` from mainline/kv.rs lines 68-79.\n   */\n  static async create(): Promise<MainlineDhtKv> {\n    const dht = new DHT();\n\n    const instance = new MainlineDhtKv(dht);\n\n    // Wait for bootstrap\n    await new Promise<void>((resolve, reject) => {\n      const timeout = setTimeout(() => {\n        reject(new DhtError(\"Bootstrap timeout\"));\n      }, 30000);\n\n      dht.on(\"ready\", () => {\n        clearTimeout(timeout);\n        instance._isBootstrapped = true;\n        resolve();\n      });\n\n      dht.on(\"error\", (err: Error) => {\n        clearTimeout(timeout);\n        reject(new DhtError(err.message));\n      });\n    });\n\n    return instance;\n  }\n\n  /**\n   * Set the maximum value size (default: 1000 bytes).\n   *\n   * Note: Values larger than ~1KB may not be reliably stored in the DHT.\n   *\n   * Port of `MainlineDhtKv::with_max_size()` from mainline/kv.rs lines 84-87.\n   */\n  withMaxSize(size: number): this {\n    this.maxValueSize = size;\n    return this;\n  }\n\n  /**\n   * Set a salt for namespace separation.\n   *\n   * Different salts will create separate namespaces for the same ARID.\n   *\n   * Port of `MainlineDhtKv::with_salt()` from mainline/kv.rs lines 92-95.\n   */\n  withSalt(salt: Uint8Array): this {\n    this.salt = salt;\n    return this;\n  }\n\n  /**\n   * Derive an ed25519 signing key from an ARID.\n   *\n   * Uses the ARID-derived key material extended to 32 bytes for ed25519.\n   *\n   * Port of `MainlineDhtKv::derive_signing_key()` from mainline/kv.rs lines 100-112.\n   *\n   * @internal\n   */\n  private static deriveSigningKey(arid: ARID): { privateKey: Uint8Array; publicKey: Uint8Array } {\n    const keyBytes = deriveMainlineKey(arid);\n\n    // Extend to 32 bytes if needed (ARID gives us 20, we need 32)\n    const seed = new Uint8Array(32);\n    seed.set(keyBytes.slice(0, 20));\n    // Use simple derivation for remaining 12 bytes\n    for (let i = 20; i < 32; i++) {\n      seed[i] = (keyBytes[i % 20] * i) & 0xff;\n    }\n\n    // Get public key from private key seed\n    const publicKey = ed25519.getPublicKey(seed);\n\n    return { privateKey: seed, publicKey };\n  }\n\n  /**\n   * Get mutable item from DHT.\n   *\n   * @internal\n   */\n  private getMutable(publicKey: Uint8Array, salt?: Uint8Array): Promise<Buffer | null> {\n    return new Promise((resolve) => {\n      const target = this.computeTarget(publicKey, salt);\n\n      this.dht.get(target, (err: Error | null, res: { v?: Buffer } | null) => {\n        if (err || !res?.v) {\n          resolve(null);\n        } else {\n          resolve(res.v);\n        }\n      });\n    });\n  }\n\n  /**\n   * Put mutable item to DHT.\n   *\n   * @internal\n   */\n  private putMutable(\n    privateKey: Uint8Array,\n    publicKey: Uint8Array,\n    value: Uint8Array,\n    seq: number,\n    salt?: Uint8Array,\n  ): Promise<void> {\n    return new Promise((resolve, reject) => {\n      const opts: {\n        k: Buffer;\n        v: Buffer;\n        seq: number;\n        sign: (buf: Buffer) => Buffer;\n        salt?: Buffer;\n      } = {\n        k: Buffer.from(publicKey),\n        v: Buffer.from(value),\n        seq,\n        sign: (buf: Buffer) => {\n          return Buffer.from(ed25519.sign(buf, privateKey));\n        },\n      };\n\n      if (salt) {\n        opts.salt = Buffer.from(salt);\n      }\n\n      this.dht.put(opts, (err: Error | null) => {\n        if (err) {\n          reject(new PutMutableError(err.message));\n        } else {\n          resolve();\n        }\n      });\n    });\n  }\n\n  /**\n   * Compute DHT target hash from public key and optional salt.\n   *\n   * @internal\n   */\n  private computeTarget(publicKey: Uint8Array, salt?: Uint8Array): Buffer {\n    // For BEP-44 mutable items, the target is sha1(publicKey + salt)\n    // The bittorrent-dht library handles this internally when using get/put with k/salt\n    // But for direct get() calls we need to compute it ourselves\n    const hash = crypto.createHash(\"sha1\");\n    hash.update(publicKey);\n    if (salt) {\n      hash.update(salt);\n    }\n    return hash.digest();\n  }\n\n  /**\n   * Store an envelope at the given ARID.\n   *\n   * Port of `KvStore::put()` implementation from mainline/kv.rs lines 144-220.\n   */\n  async put(\n    arid: ARID,\n    envelope: Envelope,\n    _ttlSeconds?: number, // Ignored - DHT has no TTL support\n    verbose?: boolean,\n  ): Promise<string> {\n    if (verbose) {\n      verbosePrintln(\"Starting Mainline DHT put operation\");\n    }\n\n    // Serialize envelope\n    const bytes = envelope.taggedCborData();\n\n    if (verbose) {\n      verbosePrintln(`Envelope size: ${bytes.length} bytes`);\n    }\n\n    // Obfuscate with ARID-derived key so it appears as random data\n    const obfuscated = obfuscateWithArid(arid, bytes);\n\n    // Check size after obfuscation (same size, but check anyway)\n    if (obfuscated.length > this.maxValueSize) {\n      throw new ValueTooLargeError(obfuscated.length);\n    }\n\n    if (verbose) {\n      verbosePrintln(\"Obfuscated envelope data\");\n    }\n\n    // Derive signing key from ARID\n    if (verbose) {\n      verbosePrintln(\"Deriving DHT signing key from ARID\");\n    }\n    const { privateKey, publicKey } = MainlineDhtKv.deriveSigningKey(arid);\n\n    // Check if already exists (write-once semantics)\n    if (verbose) {\n      verbosePrintln(\"Checking for existing value (write-once check)\");\n    }\n    const existing = await this.getMutable(publicKey, this.salt);\n    if (existing !== null) {\n      throw new AlreadyExistsError(arid.urString());\n    }\n\n    // Create mutable item with seq=1 (first write) using obfuscated data\n    if (verbose) {\n      verbosePrintln(\"Creating mutable DHT item\");\n    }\n\n    // Put to DHT\n    if (verbose) {\n      verbosePrintln(\"Putting value to DHT\");\n    }\n    await this.putMutable(privateKey, publicKey, obfuscated, 1, this.salt);\n\n    if (verbose) {\n      verbosePrintln(\"Mainline DHT put operation completed\");\n    }\n\n    return `dht://${Buffer.from(publicKey).toString(\"hex\")}`;\n  }\n\n  /**\n   * Retrieve an envelope for the given ARID.\n   *\n   * Port of `KvStore::get()` implementation from mainline/kv.rs lines 223-303.\n   */\n  async get(arid: ARID, timeoutSeconds?: number, verbose?: boolean): Promise<Envelope | null> {\n    if (verbose) {\n      verbosePrintln(\"Starting Mainline DHT get operation\");\n    }\n\n    // Derive public key from ARID\n    if (verbose) {\n      verbosePrintln(\"Deriving DHT public key from ARID\");\n    }\n    const { publicKey } = MainlineDhtKv.deriveSigningKey(arid);\n\n    const timeout = (timeoutSeconds ?? 30) * 1000; // Default 30 seconds\n    const deadline = Date.now() + timeout;\n    // Changed to 1000ms for verbose mode polling\n    const pollInterval = 1000;\n\n    if (verbose) {\n      verbosePrintln(\"Polling DHT for value\");\n    }\n\n    while (true) {\n      // Get mutable item\n      const item = await this.getMutable(publicKey, this.salt);\n\n      if (item !== null) {\n        if (verbose) {\n          verboseNewline();\n          verbosePrintln(\"Value found in DHT\");\n        }\n\n        // Deobfuscate the data using ARID-derived key\n        const obfuscatedBytes = new Uint8Array(item);\n        const deobfuscated = obfuscateWithArid(arid, obfuscatedBytes);\n\n        if (verbose) {\n          verbosePrintln(\"Deobfuscated envelope data\");\n        }\n\n        // Deserialize envelope from deobfuscated data\n        const envelope = EnvelopeDecoder.tryFromCborData(deobfuscated);\n\n        if (verbose) {\n          verbosePrintln(\"Mainline DHT get operation completed\");\n        }\n\n        return envelope;\n      }\n\n      // Not found yet - check if we should keep polling\n      if (Date.now() >= deadline) {\n        // Timeout reached\n        if (verbose) {\n          verboseNewline();\n          verbosePrintln(\"Timeout reached, value not found\");\n        }\n        return null;\n      }\n\n      // Print polling dot if verbose\n      if (verbose) {\n        verbosePrintDot();\n      }\n\n      // Wait before retrying (now 1000ms)\n      await new Promise((resolve) => setTimeout(resolve, pollInterval));\n    }\n  }\n\n  /**\n   * Check if an envelope exists at the given ARID.\n   *\n   * Port of `KvStore::exists()` implementation from mainline/kv.rs lines 306-314.\n   */\n  async exists(arid: ARID): Promise<boolean> {\n    const { publicKey } = MainlineDhtKv.deriveSigningKey(arid);\n\n    // Check if mutable item exists\n    const item = await this.getMutable(publicKey, this.salt);\n    return item !== null;\n  }\n\n  /**\n   * Destroy the DHT client and release resources.\n   */\n  destroy(): Promise<void> {\n    return new Promise((resolve) => {\n      this.dht.destroy(() => {\n        resolve();\n      });\n    });\n  }\n}\n"],"mappings":"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"}