@bcts/hubert 1.0.0-alpha.17

package/dist/hybrid-dX5JLumO.cjs

@@ -0,0 +1,410 @@
+const require_chunk = require('./chunk-CbDLau6x.cjs');
+const require_logging = require('./logging-qc9uMgil.cjs');
+const require_kv = require('./kv-yjvQa_LH.cjs');
+const require_kv$1 = require('./kv-BAmhmMOo.cjs');
+let _bcts_components = require("@bcts/components");
+let _bcts_envelope = require("@bcts/envelope");
+let _bcts_known_values = require("@bcts/known-values");
+
+//#region src/hybrid/error.ts
+/**
+* Hybrid-specific errors.
+*
+* Port of hybrid/error.rs from hubert-rust.
+*
+* @module
+*/
+/**
+* Base class for Hybrid-specific errors.
+*
+* @category Hybrid
+*/
+var HybridError = class extends require_logging.HubertError {
+	constructor(message) {
+		super(message);
+		this.name = "HybridError";
+	}
+};
+/**
+* Referenced IPFS content not found.
+*
+* Port of `Error::ContentNotFound` from hybrid/error.rs line 4-5.
+*
+* @category Hybrid
+*/
+var ContentNotFoundError = class extends HybridError {
+	constructor() {
+		super("Referenced IPFS content not found");
+		this.name = "ContentNotFoundError";
+	}
+};
+/**
+* Not a reference envelope.
+*
+* Port of `Error::NotReferenceEnvelope` from hybrid/error.rs line 7-8.
+*
+* @category Hybrid
+*/
+var NotReferenceEnvelopeError = class extends HybridError {
+	constructor() {
+		super("Not a reference envelope");
+		this.name = "NotReferenceEnvelopeError";
+	}
+};
+/**
+* Invalid ARID in reference envelope.
+*
+* Port of `Error::InvalidReferenceArid` from hybrid/error.rs line 10-11.
+*
+* @category Hybrid
+*/
+var InvalidReferenceAridError = class extends HybridError {
+	constructor() {
+		super("Invalid ARID in reference envelope");
+		this.name = "InvalidReferenceAridError";
+	}
+};
+/**
+* No id assertion found in reference envelope.
+*
+* Port of `Error::NoIdAssertion` from hybrid/error.rs line 13-14.
+*
+* @category Hybrid
+*/
+var NoIdAssertionError = class extends HybridError {
+	constructor() {
+		super("No id assertion found in reference envelope");
+		this.name = "NoIdAssertionError";
+	}
+};
+
+//#endregion
+//#region src/hybrid/reference.ts
+/**
+* Reference envelope utilities for hybrid storage.
+*
+* Port of hybrid/reference.rs from hubert-rust.
+*
+* @module
+*/
+/**
+* Known value for dereferenceVia predicate.
+* @internal
+*/
+const DEREFERENCE_VIA = new _bcts_known_values.KnownValue(8);
+/**
+* Known value for id predicate.
+* @internal
+*/
+const ID = new _bcts_known_values.KnownValue(2);
+/**
+* Creates a reference envelope that points to content stored in IPFS.
+*
+* Reference envelopes are small envelopes stored in the DHT that contain
+* a pointer to the actual envelope stored in IPFS. This allows the hybrid
+* storage layer to transparently handle large envelopes that exceed the
+* DHT size limit.
+*
+* Port of `create_reference_envelope()` from hybrid/reference.rs lines 31-39.
+*
+* # Format
+*
+* ```text
+* '' [
+*     'dereferenceVia': "ipfs",
+*     'id': <ARID>,
+*     "size": <number>
+* ]
+* ```
+*
+* @param referenceArid - The ARID used to look up the actual envelope in IPFS
+* @param actualSize - Size of the actual envelope in bytes (for diagnostics)
+* @returns A reference envelope that can be stored in the DHT
+*
+* @category Hybrid
+*/
+function createReferenceEnvelope(referenceArid, actualSize) {
+	return _bcts_envelope.Envelope.unit().addAssertion(DEREFERENCE_VIA, "ipfs").addAssertion(ID, referenceArid).addAssertion("size", actualSize);
+}
+/**
+* Checks if an envelope is a reference envelope.
+*
+* A reference envelope contains `dereferenceVia: "ipfs"` and an `id` assertion.
+*
+* Port of `is_reference_envelope()` from hybrid/reference.rs lines 53-91.
+*
+* @param envelope - The envelope to check
+* @returns `true` if this is a reference envelope, `false` otherwise
+*
+* @category Hybrid
+*/
+function isReferenceEnvelope(envelope) {
+	if (!envelope.isSubjectUnit) return false;
+	const assertions = envelope.assertions();
+	let hasDereferenceVia = false;
+	let hasId = false;
+	for (const assertion of assertions) try {
+		const predicateSubject = assertion.predicate().subject();
+		if (predicateSubject instanceof _bcts_known_values.KnownValue) {
+			const kv = predicateSubject;
+			if (kv.value === DEREFERENCE_VIA.value) {
+				const objectSubject = assertion.object().subject();
+				if (typeof objectSubject === "string" && objectSubject === "ipfs") hasDereferenceVia = true;
+			}
+			if (kv.value === ID.value) hasId = true;
+		}
+	} catch {
+		continue;
+	}
+	return hasDereferenceVia && hasId;
+}
+/**
+* Extracts the reference ARID from a reference envelope.
+*
+* Port of `extract_reference_arid()` from hybrid/reference.rs lines 104-129.
+*
+* @param envelope - The reference envelope
+* @returns The reference ARID
+* @throws {NotReferenceEnvelopeError} If the envelope is not a reference envelope
+* @throws {InvalidReferenceAridError} If the ARID cannot be extracted
+* @throws {NoIdAssertionError} If no id assertion is found
+*
+* @category Hybrid
+*/
+function extractReferenceArid(envelope) {
+	if (!isReferenceEnvelope(envelope)) throw new NotReferenceEnvelopeError();
+	const assertions = envelope.assertions();
+	for (const assertion of assertions) try {
+		const predicateSubject = assertion.predicate().subject();
+		if (predicateSubject instanceof _bcts_known_values.KnownValue) {
+			if (predicateSubject.value === ID.value) {
+				const objectSubject = assertion.object().subject();
+				if (objectSubject instanceof _bcts_components.ARID) return objectSubject;
+				throw new InvalidReferenceAridError();
+			}
+		}
+	} catch (error) {
+		if (error instanceof NotReferenceEnvelopeError || error instanceof InvalidReferenceAridError || error instanceof NoIdAssertionError) throw error;
+		continue;
+	}
+	throw new NoIdAssertionError();
+}
+
+//#endregion
+//#region src/hybrid/kv.ts
+/**
+* Hybrid storage layer combining Mainline DHT and IPFS.
+*
+* Port of hybrid/kv.rs from hubert-rust.
+*
+* @module
+*/
+/**
+* Hybrid storage layer combining Mainline DHT and IPFS.
+*
+* Automatically optimizes storage based on envelope size:
+* - **Small envelopes (≤1000 bytes)**: Stored directly in DHT
+* - **Large envelopes (>1000 bytes)**: Reference in DHT → actual envelope in IPFS
+*
+* This provides the best of both worlds:
+* - Fast lookups for small messages via DHT
+* - Large capacity for big messages via IPFS
+* - Transparent indirection handled automatically
+*
+* Port of `struct HybridKv` from hybrid/kv.rs lines 59-63.
+*
+* # Requirements
+*
+* - No external daemon for DHT (embedded client)
+* - Requires Kubo daemon for IPFS (http://127.0.0.1:5001)
+*
+* @category Hybrid Backend
+*
+* @example
+* ```typescript
+* const store = await HybridKv.create("http://127.0.0.1:5001");
+*
+* // Small envelope → DHT only
+* const arid1 = ARID.new();
+* const small = Envelope.new("Small message");
+* await store.put(arid1, small);
+*
+* // Large envelope → DHT reference + IPFS
+* const arid2 = ARID.new();
+* const large = Envelope.new("x".repeat(2000));
+* await store.put(arid2, large);
+*
+* // Get works the same for both
+* const retrieved1 = await store.get(arid1);
+* const retrieved2 = await store.get(arid2);
+* ```
+*/
+var HybridKv = class HybridKv {
+	dht;
+	ipfs;
+	dhtSizeLimit;
+	/**
+	* Private constructor - use `create()` factory method.
+	*/
+	constructor(dht, ipfs) {
+		this.dht = dht;
+		this.ipfs = ipfs;
+		this.dhtSizeLimit = 1e3;
+	}
+	/**
+	* Create a new Hybrid KV store with default settings.
+	*
+	* Port of `HybridKv::new()` from hybrid/kv.rs lines 75-84.
+	*
+	* @param ipfsRpcUrl - IPFS RPC endpoint (e.g., "http://127.0.0.1:5001")
+	*/
+	static async create(ipfsRpcUrl) {
+		return new HybridKv(await require_kv$1.MainlineDhtKv.create(), new require_kv.IpfsKv(ipfsRpcUrl));
+	}
+	/**
+	* Set custom DHT size limit (default: 1000 bytes).
+	*
+	* Envelopes larger than this will use IPFS indirection.
+	*
+	* Port of `HybridKv::with_dht_size_limit()` from hybrid/kv.rs lines 89-92.
+	*/
+	withDhtSizeLimit(limit) {
+		this.dhtSizeLimit = limit;
+		return this;
+	}
+	/**
+	* Set whether to pin content in IPFS (default: false).
+	*
+	* Only affects envelopes stored in IPFS (when larger than DHT limit).
+	*
+	* Port of `HybridKv::with_pin_content()` from hybrid/kv.rs lines 97-100.
+	*/
+	withPinContent(pin) {
+		this.ipfs = this.ipfs.withPinContent(pin);
+		return this;
+	}
+	/**
+	* Check if an envelope fits in the DHT.
+	*
+	* Port of `HybridKv::fits_in_dht()` from hybrid/kv.rs lines 103-106.
+	*
+	* @internal
+	*/
+	fitsInDht(envelope) {
+		return envelope.taggedCborData.length <= this.dhtSizeLimit;
+	}
+	/**
+	* Store an envelope at the given ARID.
+	*
+	* Port of `KvStore::put()` implementation from hybrid/kv.rs lines 109-168.
+	*/
+	async put(arid, envelope, ttlSeconds, verbose) {
+		if (this.fitsInDht(envelope)) {
+			if (verbose) require_logging.verbosePrintln(`Storing envelope in DHT (size ≤ ${this.dhtSizeLimit} bytes)`);
+			await this.dht.put(arid, envelope, ttlSeconds, verbose);
+			return `Stored in DHT at ARID: ${arid.urString()}`;
+		} else {
+			if (verbose) require_logging.verbosePrintln("Envelope too large for DHT, using IPFS indirection");
+			const referenceArid = _bcts_components.ARID.new();
+			if (verbose) require_logging.verbosePrintln(`Storing actual envelope in IPFS with reference ARID: ${referenceArid.urString()}`);
+			await this.ipfs.put(referenceArid, envelope, ttlSeconds, verbose);
+			const envelopeSize = envelope.taggedCborData.length;
+			const reference = createReferenceEnvelope(referenceArid, envelopeSize);
+			if (verbose) require_logging.verbosePrintln("Storing reference envelope in DHT at original ARID");
+			await this.dht.put(arid, reference, ttlSeconds, verbose);
+			return `Stored in IPFS (ref: ${referenceArid.urString()}) via DHT at ARID: ${arid.urString()}`;
+		}
+	}
+	/**
+	* Retrieve an envelope for the given ARID.
+	*
+	* Port of `KvStore::get()` implementation from hybrid/kv.rs lines 171-230.
+	*/
+	async get(arid, timeoutSeconds, verbose) {
+		const dhtEnvelope = await this.dht.get(arid, timeoutSeconds, verbose);
+		if (dhtEnvelope === null) return null;
+		if (isReferenceEnvelope(dhtEnvelope)) {
+			if (verbose) require_logging.verbosePrintln("Found reference envelope, fetching actual envelope from IPFS");
+			const referenceArid = extractReferenceArid(dhtEnvelope);
+			if (verbose) require_logging.verbosePrintln(`Reference ARID: ${referenceArid.urString()}`);
+			const ipfsEnvelope = await this.ipfs.get(referenceArid, timeoutSeconds, verbose);
+			if (ipfsEnvelope === null) throw new ContentNotFoundError();
+			if (verbose) require_logging.verbosePrintln("Successfully retrieved actual envelope from IPFS");
+			return ipfsEnvelope;
+		} else {
+			if (verbose) require_logging.verbosePrintln("Envelope is not a reference, treating as direct payload");
+			return dhtEnvelope;
+		}
+	}
+	/**
+	* Check if an envelope exists at the given ARID.
+	*
+	* Port of `KvStore::exists()` implementation from hybrid/kv.rs lines 254-257.
+	*/
+	async exists(arid) {
+		return await this.dht.exists(arid);
+	}
+	/**
+	* Destroy the hybrid store and release resources.
+	*/
+	async destroy() {
+		await this.dht.destroy();
+	}
+};
+
+//#endregion
+Object.defineProperty(exports, 'ContentNotFoundError', {
+  enumerable: true,
+  get: function () {
+    return ContentNotFoundError;
+  }
+});
+Object.defineProperty(exports, 'HybridError', {
+  enumerable: true,
+  get: function () {
+    return HybridError;
+  }
+});
+Object.defineProperty(exports, 'HybridKv', {
+  enumerable: true,
+  get: function () {
+    return HybridKv;
+  }
+});
+Object.defineProperty(exports, 'InvalidReferenceAridError', {
+  enumerable: true,
+  get: function () {
+    return InvalidReferenceAridError;
+  }
+});
+Object.defineProperty(exports, 'NoIdAssertionError', {
+  enumerable: true,
+  get: function () {
+    return NoIdAssertionError;
+  }
+});
+Object.defineProperty(exports, 'NotReferenceEnvelopeError', {
+  enumerable: true,
+  get: function () {
+    return NotReferenceEnvelopeError;
+  }
+});
+Object.defineProperty(exports, 'createReferenceEnvelope', {
+  enumerable: true,
+  get: function () {
+    return createReferenceEnvelope;
+  }
+});
+Object.defineProperty(exports, 'extractReferenceArid', {
+  enumerable: true,
+  get: function () {
+    return extractReferenceArid;
+  }
+});
+Object.defineProperty(exports, 'isReferenceEnvelope', {
+  enumerable: true,
+  get: function () {
+    return isReferenceEnvelope;
+  }
+});
+//# sourceMappingURL=hybrid-dX5JLumO.cjs.map

package/dist/hybrid-dX5JLumO.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"hybrid-dX5JLumO.cjs","names":["HubertError","KnownValue","Envelope","ARID","MainlineDhtKv","IpfsKv","ARID"],"sources":["../src/hybrid/error.ts","../src/hybrid/reference.ts","../src/hybrid/kv.ts"],"sourcesContent":["/**\n * Hybrid-specific errors.\n *\n * Port of hybrid/error.rs from hubert-rust.\n *\n * @module\n */\n\nimport { HubertError } from \"../error.js\";\n\n/**\n * Base class for Hybrid-specific errors.\n *\n * @category Hybrid\n */\nexport class HybridError extends HubertError {\n  constructor(message: string) {\n    super(message);\n    this.name = \"HybridError\";\n  }\n}\n\n/**\n * Referenced IPFS content not found.\n *\n * Port of `Error::ContentNotFound` from hybrid/error.rs line 4-5.\n *\n * @category Hybrid\n */\nexport class ContentNotFoundError extends HybridError {\n  constructor() {\n    super(\"Referenced IPFS content not found\");\n    this.name = \"ContentNotFoundError\";\n  }\n}\n\n/**\n * Not a reference envelope.\n *\n * Port of `Error::NotReferenceEnvelope` from hybrid/error.rs line 7-8.\n *\n * @category Hybrid\n */\nexport class NotReferenceEnvelopeError extends HybridError {\n  constructor() {\n    super(\"Not a reference envelope\");\n    this.name = \"NotReferenceEnvelopeError\";\n  }\n}\n\n/**\n * Invalid ARID in reference envelope.\n *\n * Port of `Error::InvalidReferenceArid` from hybrid/error.rs line 10-11.\n *\n * @category Hybrid\n */\nexport class InvalidReferenceAridError extends HybridError {\n  constructor() {\n    super(\"Invalid ARID in reference envelope\");\n    this.name = \"InvalidReferenceAridError\";\n  }\n}\n\n/**\n * No id assertion found in reference envelope.\n *\n * Port of `Error::NoIdAssertion` from hybrid/error.rs line 13-14.\n *\n * @category Hybrid\n */\nexport class NoIdAssertionError extends HybridError {\n  constructor() {\n    super(\"No id assertion found in reference envelope\");\n    this.name = \"NoIdAssertionError\";\n  }\n}\n","/**\n * Reference envelope utilities for hybrid storage.\n *\n * Port of hybrid/reference.rs from hubert-rust.\n *\n * @module\n */\n\nimport { ARID } from \"@bcts/components\";\nimport { Envelope } from \"@bcts/envelope\";\nimport { KnownValue } from \"@bcts/known-values\";\n\nimport {\n  InvalidReferenceAridError,\n  NoIdAssertionError,\n  NotReferenceEnvelopeError,\n} from \"./error.js\";\n\n/**\n * Known value for dereferenceVia predicate.\n * @internal\n */\nconst DEREFERENCE_VIA = new KnownValue(8);\n\n/**\n * Known value for id predicate.\n * @internal\n */\nconst ID = new KnownValue(2);\n\n/**\n * Creates a reference envelope that points to content stored in IPFS.\n *\n * Reference envelopes are small envelopes stored in the DHT that contain\n * a pointer to the actual envelope stored in IPFS. This allows the hybrid\n * storage layer to transparently handle large envelopes that exceed the\n * DHT size limit.\n *\n * Port of `create_reference_envelope()` from hybrid/reference.rs lines 31-39.\n *\n * # Format\n *\n * ```text\n * '' [\n *     'dereferenceVia': \"ipfs\",\n *     'id': <ARID>,\n *     \"size\": <number>\n * ]\n * ```\n *\n * @param referenceArid - The ARID used to look up the actual envelope in IPFS\n * @param actualSize - Size of the actual envelope in bytes (for diagnostics)\n * @returns A reference envelope that can be stored in the DHT\n *\n * @category Hybrid\n */\nexport function createReferenceEnvelope(referenceArid: ARID, actualSize: number): Envelope {\n  return Envelope.unit()\n    .addAssertion(DEREFERENCE_VIA, \"ipfs\")\n    .addAssertion(ID, referenceArid)\n    .addAssertion(\"size\", actualSize);\n}\n\n/**\n * Checks if an envelope is a reference envelope.\n *\n * A reference envelope contains `dereferenceVia: \"ipfs\"` and an `id` assertion.\n *\n * Port of `is_reference_envelope()` from hybrid/reference.rs lines 53-91.\n *\n * @param envelope - The envelope to check\n * @returns `true` if this is a reference envelope, `false` otherwise\n *\n * @category Hybrid\n */\nexport function isReferenceEnvelope(envelope: Envelope): boolean {\n  // Check if subject is the unit value\n  if (!envelope.isSubjectUnit) {\n    return false;\n  }\n\n  const assertions = envelope.assertions();\n\n  // Check for dereferenceVia: \"ipfs\" assertion\n  let hasDereferenceVia = false;\n  let hasId = false;\n\n  for (const assertion of assertions) {\n    try {\n      const predicate = assertion.predicate();\n\n      // Check if predicate is a known value\n      const predicateSubject = predicate.subject();\n      if (predicateSubject instanceof KnownValue) {\n        const kv = predicateSubject;\n\n        // Check for dereferenceVia\n        if (kv.value === DEREFERENCE_VIA.value) {\n          const object = assertion.object();\n          const objectSubject = object.subject();\n          if (typeof objectSubject === \"string\" && objectSubject === \"ipfs\") {\n            hasDereferenceVia = true;\n          }\n        }\n\n        // Check for id\n        if (kv.value === ID.value) {\n          hasId = true;\n        }\n      }\n    } catch {\n      // Skip assertions that can't be parsed\n      continue;\n    }\n  }\n\n  return hasDereferenceVia && hasId;\n}\n\n/**\n * Extracts the reference ARID from a reference envelope.\n *\n * Port of `extract_reference_arid()` from hybrid/reference.rs lines 104-129.\n *\n * @param envelope - The reference envelope\n * @returns The reference ARID\n * @throws {NotReferenceEnvelopeError} If the envelope is not a reference envelope\n * @throws {InvalidReferenceAridError} If the ARID cannot be extracted\n * @throws {NoIdAssertionError} If no id assertion is found\n *\n * @category Hybrid\n */\nexport function extractReferenceArid(envelope: Envelope): ARID {\n  if (!isReferenceEnvelope(envelope)) {\n    throw new NotReferenceEnvelopeError();\n  }\n\n  const assertions = envelope.assertions();\n\n  // Find the id assertion and extract the ARID\n  for (const assertion of assertions) {\n    try {\n      const predicate = assertion.predicate();\n      const predicateSubject = predicate.subject();\n\n      if (predicateSubject instanceof KnownValue) {\n        const kv = predicateSubject;\n\n        // Check for id\n        if (kv.value === ID.value) {\n          const object = assertion.object();\n          const objectSubject = object.subject();\n\n          if (objectSubject instanceof ARID) {\n            return objectSubject;\n          }\n\n          // Try to extract ARID from CBOR\n          throw new InvalidReferenceAridError();\n        }\n      }\n    } catch (error) {\n      if (\n        error instanceof NotReferenceEnvelopeError ||\n        error instanceof InvalidReferenceAridError ||\n        error instanceof NoIdAssertionError\n      ) {\n        throw error;\n      }\n      // Continue searching\n      continue;\n    }\n  }\n\n  throw new NoIdAssertionError();\n}\n","/**\n * Hybrid storage layer combining Mainline DHT and IPFS.\n *\n * Port of hybrid/kv.rs from hubert-rust.\n *\n * @module\n */\n\nimport { ARID } from \"@bcts/components\";\nimport { type Envelope } from \"@bcts/envelope\";\n\nimport { type KvStore } from \"../kv-store.js\";\nimport { verbosePrintln } from \"../logging.js\";\nimport { IpfsKv } from \"../ipfs/kv.js\";\nimport { MainlineDhtKv } from \"../mainline/kv.js\";\nimport { ContentNotFoundError } from \"./error.js\";\nimport { createReferenceEnvelope, extractReferenceArid, isReferenceEnvelope } from \"./reference.js\";\n\n/**\n * Hybrid storage layer combining Mainline DHT and IPFS.\n *\n * Automatically optimizes storage based on envelope size:\n * - **Small envelopes (≤1000 bytes)**: Stored directly in DHT\n * - **Large envelopes (>1000 bytes)**: Reference in DHT → actual envelope in IPFS\n *\n * This provides the best of both worlds:\n * - Fast lookups for small messages via DHT\n * - Large capacity for big messages via IPFS\n * - Transparent indirection handled automatically\n *\n * Port of `struct HybridKv` from hybrid/kv.rs lines 59-63.\n *\n * # Requirements\n *\n * - No external daemon for DHT (embedded client)\n * - Requires Kubo daemon for IPFS (http://127.0.0.1:5001)\n *\n * @category Hybrid Backend\n *\n * @example\n * ```typescript\n * const store = await HybridKv.create(\"http://127.0.0.1:5001\");\n *\n * // Small envelope → DHT only\n * const arid1 = ARID.new();\n * const small = Envelope.new(\"Small message\");\n * await store.put(arid1, small);\n *\n * // Large envelope → DHT reference + IPFS\n * const arid2 = ARID.new();\n * const large = Envelope.new(\"x\".repeat(2000));\n * await store.put(arid2, large);\n *\n * // Get works the same for both\n * const retrieved1 = await store.get(arid1);\n * const retrieved2 = await store.get(arid2);\n * ```\n */\nexport class HybridKv implements KvStore {\n  private readonly dht: MainlineDhtKv;\n  private ipfs: IpfsKv;\n  private dhtSizeLimit: number;\n\n  /**\n   * Private constructor - use `create()` factory method.\n   */\n  private constructor(dht: MainlineDhtKv, ipfs: IpfsKv) {\n    this.dht = dht;\n    this.ipfs = ipfs;\n    this.dhtSizeLimit = 1000; // Conservative DHT limit\n  }\n\n  /**\n   * Create a new Hybrid KV store with default settings.\n   *\n   * Port of `HybridKv::new()` from hybrid/kv.rs lines 75-84.\n   *\n   * @param ipfsRpcUrl - IPFS RPC endpoint (e.g., \"http://127.0.0.1:5001\")\n   */\n  static async create(ipfsRpcUrl: string): Promise<HybridKv> {\n    const dht = await MainlineDhtKv.create();\n    const ipfs = new IpfsKv(ipfsRpcUrl);\n\n    return new HybridKv(dht, ipfs);\n  }\n\n  /**\n   * Set custom DHT size limit (default: 1000 bytes).\n   *\n   * Envelopes larger than this will use IPFS indirection.\n   *\n   * Port of `HybridKv::with_dht_size_limit()` from hybrid/kv.rs lines 89-92.\n   */\n  withDhtSizeLimit(limit: number): this {\n    this.dhtSizeLimit = limit;\n    return this;\n  }\n\n  /**\n   * Set whether to pin content in IPFS (default: false).\n   *\n   * Only affects envelopes stored in IPFS (when larger than DHT limit).\n   *\n   * Port of `HybridKv::with_pin_content()` from hybrid/kv.rs lines 97-100.\n   */\n  withPinContent(pin: boolean): this {\n    this.ipfs = this.ipfs.withPinContent(pin);\n    return this;\n  }\n\n  /**\n   * Check if an envelope fits in the DHT.\n   *\n   * Port of `HybridKv::fits_in_dht()` from hybrid/kv.rs lines 103-106.\n   *\n   * @internal\n   */\n  private fitsInDht(envelope: Envelope): boolean {\n    const serialized = envelope.taggedCborData;\n    return serialized.length <= this.dhtSizeLimit;\n  }\n\n  /**\n   * Store an envelope at the given ARID.\n   *\n   * Port of `KvStore::put()` implementation from hybrid/kv.rs lines 109-168.\n   */\n  async put(\n    arid: ARID,\n    envelope: Envelope,\n    ttlSeconds?: number,\n    verbose?: boolean,\n  ): Promise<string> {\n    // Check if it fits in DHT\n    if (this.fitsInDht(envelope)) {\n      // Store directly in DHT (DHT handles obfuscation)\n      if (verbose) {\n        verbosePrintln(`Storing envelope in DHT (size ≤ ${this.dhtSizeLimit} bytes)`);\n      }\n      await this.dht.put(arid, envelope, ttlSeconds, verbose);\n      return `Stored in DHT at ARID: ${arid.urString()}`;\n    } else {\n      // Use IPFS with DHT reference\n      if (verbose) {\n        verbosePrintln(\"Envelope too large for DHT, using IPFS indirection\");\n      }\n\n      // 1. Store actual envelope in IPFS with a new ARID\n      //    (IPFS handles obfuscation with reference_arid)\n      const referenceArid = ARID.new();\n      if (verbose) {\n        verbosePrintln(\n          `Storing actual envelope in IPFS with reference ARID: ${referenceArid.urString()}`,\n        );\n      }\n      await this.ipfs.put(referenceArid, envelope, ttlSeconds, verbose);\n\n      // 2. Create reference envelope\n      const envelopeSize = envelope.taggedCborData.length;\n      const reference = createReferenceEnvelope(referenceArid, envelopeSize);\n\n      // 3. Store reference envelope in DHT at original ARID\n      //    (DHT handles obfuscation with original arid)\n      if (verbose) {\n        verbosePrintln(\"Storing reference envelope in DHT at original ARID\");\n      }\n      await this.dht.put(arid, reference, ttlSeconds, verbose);\n\n      return `Stored in IPFS (ref: ${referenceArid.urString()}) via DHT at ARID: ${arid.urString()}`;\n    }\n  }\n\n  /**\n   * Retrieve an envelope for the given ARID.\n   *\n   * Port of `KvStore::get()` implementation from hybrid/kv.rs lines 171-230.\n   */\n  async get(arid: ARID, timeoutSeconds?: number, verbose?: boolean): Promise<Envelope | null> {\n    // 1. Try to get from DHT (DHT handles deobfuscation)\n    const dhtEnvelope = await this.dht.get(arid, timeoutSeconds, verbose);\n\n    if (dhtEnvelope === null) {\n      return null;\n    }\n\n    // 2. Check if the envelope is a reference envelope\n    if (isReferenceEnvelope(dhtEnvelope)) {\n      if (verbose) {\n        verbosePrintln(\"Found reference envelope, fetching actual envelope from IPFS\");\n      }\n\n      // 3. Extract reference ARID\n      const referenceArid = extractReferenceArid(dhtEnvelope);\n\n      if (verbose) {\n        verbosePrintln(`Reference ARID: ${referenceArid.urString()}`);\n      }\n\n      // 4. Retrieve actual envelope from IPFS\n      //    (IPFS handles deobfuscation with reference_arid)\n      const ipfsEnvelope = await this.ipfs.get(referenceArid, timeoutSeconds, verbose);\n\n      if (ipfsEnvelope === null) {\n        throw new ContentNotFoundError();\n      }\n\n      if (verbose) {\n        verbosePrintln(\"Successfully retrieved actual envelope from IPFS\");\n      }\n      return ipfsEnvelope;\n    } else {\n      // Not a reference envelope, return it directly\n      if (verbose) {\n        verbosePrintln(\"Envelope is not a reference, treating as direct payload\");\n      }\n      return dhtEnvelope;\n    }\n  }\n\n  /**\n   * Check if an envelope exists at the given ARID.\n   *\n   * Port of `KvStore::exists()` implementation from hybrid/kv.rs lines 254-257.\n   */\n  async exists(arid: ARID): Promise<boolean> {\n    // Check DHT only (references count as existing)\n    return await this.dht.exists(arid);\n  }\n\n  /**\n   * Destroy the hybrid store and release resources.\n   */\n  async destroy(): Promise<void> {\n    await this.dht.destroy();\n  }\n}\n"],"mappings":"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"}