@pkcprotocol/pkc-js 0.0.56 → 0.0.58

package/dist/bundled/chunks/{node-DNJqRHLq.js → node-OomQx4kQ.js}

@@ -1,13 +1,9 @@
-import { B as isIpfsCid, Cn as CommentUpdateForChallengeVerificationSchema, Cr as parsedType, Ct as findUpdatingCommunity, D as deepMergeRuntimeFields, Dr as __require, Dt as refreshTrackedCommentAliases, E as createAbortError, En as CommentUpdateSchema, Et as listUpdatingCommunities, It as require_sha256, L as hideClassPrivateProps, Lt as TimeoutError, Or as __toESM, Pt as untrackUpdatingComment, Q as isStringDomain, Qn as CID, Rt as pTimeout, Sr as joinValues, St as findUpdatingComment, Tr as __commonJSMin, Tt as listUpdatingComments, Xn as require_commonjs, Zn as require_retry, _t as timestamp, a as ChallengeRequestMessageSchema, b as areEquivalentCommunityAddresses, cn as PubsubTopicSchema, cr as logger_default, ct as resolveWhenPredicateIsTrue, dr as setErrorMap, ft as shortifyAddress, jt as trackUpdatingComment, k as doesDomainAddressHaveCapitalLetter, lr as require_supports_color, mt as sleepUntilTimeoutOrAbort, nn as CommunityIpfsSchema, or as PKCError, ot as removeUndefinedValuesRecursively, pt as shortifyCid, r as ChallengeMessageSchema, s as ChallengeVerificationMessageSchema, sr as messages, st as replaceXWithY, t as ChallengeAnswerMessageSchema, tr as FailedToFetchCommentIpfsFromGatewaysError, ut as retryKuboIpfsAdd, vn as CommentIpfsSchema, vt as waitForUpdateInCommunityInstanceWithErrorAndTimeout, wr as stringifyPrimitive, wt as listStartedCommunities, xt as findStartedCommunity, y as version_default, z as isAbortError } from "./schema-lNZ3-tdE.js";
-import { $ as PKCClientsManager, An as RpcCommunityIdentifierParamSchema, At as buildRuntimeAuthor, B as CommentClientsManager, Bn as RpcResolveAuthorNameResultSchema, Bt as decode, Cn as parseSetNewSettingsPKCWsServerSchemaWithPKCErrorIfItFails, Ct as verifyCommentIpfs, Dn as RpcCancelExportParamSchema, En as RpcAuthorNameParamSchema, Et as verifyCommentUpdate, F as monitorCommunitiesDirectory, Fn as RpcExportCommunityParamSchema, Ft as buildRuntimeCommunityFields, Hn as RpcSuccessResultSchema, Ht as getBufferedPKCAddressFromPublicKey, In as RpcExportCommunityResultSchema, It as getCommunityAddressFromRecord, J as findCommentInPageInstanceRecursively, Jn as require_undici, Jt as parseCidStringSchemaWithPKCErrorIfItFails, Ln as RpcFetchCidParamSchema, Lt as getCommunityNameFromWire, Mn as RpcEditCommunityParamSchema, Mt as getAuthorNameFromRuntime, Nn as RpcExportCommunityModLogsParamSchema, On as RpcCidParamSchema, Ot as verifyCommunityEdit, P as listCommunitiesSync, Pn as RpcExportCommunityModLogsResultSchema, Pt as normalizeCreatePublicationAuthor, Q as PublicationClientsManager, Qt as parseCommentIpfsSchemaWithPKCErrorIfItFails, R as setNativeFunctions$1, Rn as RpcFetchCidResultSchema, Rt as getCommunityPublicKeyFromWire, Sn as parseRpcCommentUpdateEventWithPKCErrorIfItFails, St as verifyCommentEdit, T as createKuboRpcClient, Tn as parseVotePubsubMessagePublicationSchemaWithPKCErrorIfItFails, Tt as verifyCommentPubsubMessage, Un as RpcUnsubscribeParamSchema, Vn as RpcSubscriptionIdResultSchema, X as parseRawPages, Z as RepliesPages, Zt as parseCommentEditPubsubMessagePublicationSchemaWithPKCErrorIfItFails, _ as decryptEd25519AesGcm, _n as parseDecryptedChallengeVerification, _t as signVote, a as pkcJsChallenges, an as parseCommunityEditPubsubMessagePublicationSchemaWithPKCErrorIfItFails, at as cleanUpBeforePublishing, bn as parsePKCUserOptionsSchemaWithPKCErrorIfItFails, c as RemoteCommunity, cn as parseCreateCommentModerationOptionsSchemaWithPKCErrorIfItFails, ct as signChallengeRequest, d as decodeRpcChallengeAnswerPubsubMsg, dt as signCommentEdit, en as parseCommentModerationPubsubMessagePublicationSchemaWithPKCErrorIfItFails, et as InflightFetchManager, f as decodeRpcChallengePubsubMsg, ft as signCommentModeration, g as createSigner, gn as parseDecryptedChallengeAnswerWithPKCErrorIfItFails, gt as signCommunityEdit, hn as parseCreateVoteOptionsSchemaWithPKCErrorIfItFails, it as require_lib$1, j as getDefaultDataPath, jn as RpcCommunityPageParamSchema, jt as cleanWireAuthor, kn as RpcCommentRepliesPageParamSchema, kt as verifyVote, ln as parseCreateCommentOptionsSchemaWithPKCErrorIfItFails, m as decodeRpcChallengeVerificationPubsubMsg, mn as parseCreateRpcCommunityFunctionArgumentSchemaWithPKCErrorIfItFails, n as RpcRemoteCommunity, nn as parseCommunityAddressWithPKCErrorIfItFails, o as TrackedInstanceRegistry, ot as signChallengeAnswer, p as decodeRpcChallengeRequestPubsubMsg, pn as parseCreateRemoteCommunityFunctionArgumentSchemaWithPKCErrorIfItFails, q as extractCommunityRuntimeFieldsFromParsedPages, qn as nativeFunctions$2, rt as PKCTypedEmitter, s as LRUCache, sn as parseCreateCommentEditOptionsSchemaWithPKCErrorIfItFails, t as RpcLocalCommunity, tn as parseCommentPubsubMessagePublicationWithPKCErrorIfItFails, u as KeyvBetterSqlite3, un as parseCreateCommunityEditPublicationOptionsSchemaWithPKCErrorIfItFails, ut as signComment, vn as parseDecryptedChallengeWithPKCErrorIfItFails, wt as verifyCommentModeration, xn as parseRpcCommentEventWithPKCErrorIfItFails, xt as verifyChallengeVerification, y as encryptEd25519AesGcm, yn as parseJsonWithPKCErrorIfFails, yt as verifyChallengeMessage, z as tryToDeleteCommunitiesThatFailedToBeDeletedBefore, zn as RpcPublishChallengeAnswersParamSchema, zt as normalizeCommunityInputFromCommunity } from "./rpc-local-community-OVRYzYQ3.js";
-import { n as getHeliaDebugContext } from "./util-MtD9fpa8.js";
-import http from "node:http";
-import fs from "node:fs/promises";
-import path from "node:path";
-import path$1 from "path";
+import { B as isIpfsCid, Cn as CommentUpdateForChallengeVerificationSchema, Cr as parsedType, Ct as findUpdatingCommunity, D as deepMergeRuntimeFields, Dr as __require, Dt as refreshTrackedCommentAliases, E as createAbortError, En as CommentUpdateSchema, Et as listUpdatingCommunities, It as require_sha256, L as hideClassPrivateProps, Lt as TimeoutError, Or as __toESM, Pt as untrackUpdatingComment, Q as isStringDomain, Qn as CID, Rt as pTimeout, Sr as joinValues, St as findUpdatingComment, Tr as __commonJSMin, Tt as listUpdatingComments, Xn as require_commonjs, Zn as require_retry, _t as timestamp, a as ChallengeRequestMessageSchema, b as areEquivalentCommunityAddresses, cn as PubsubTopicSchema, cr as logger_default, ct as resolveWhenPredicateIsTrue, dr as setErrorMap, ft as shortifyAddress, jt as trackUpdatingComment, k as doesDomainAddressHaveCapitalLetter, lr as require_supports_color, mt as sleepUntilTimeoutOrAbort, nn as CommunityIpfsSchema, or as PKCError, ot as removeUndefinedValuesRecursively, pt as shortifyCid, r as ChallengeMessageSchema, s as ChallengeVerificationMessageSchema, sr as messages, st as replaceXWithY, t as ChallengeAnswerMessageSchema, tr as FailedToFetchCommentIpfsFromGatewaysError, ut as retryKuboIpfsAdd, vn as CommentIpfsSchema, vt as waitForUpdateInCommunityInstanceWithErrorAndTimeout, wr as stringifyPrimitive, wt as listStartedCommunities, xt as findStartedCommunity, y as version_default, z as isAbortError } from "./schema-C03N0i5R.js";
+import { $ as RepliesPages, $t as parseCommentEditPubsubMessagePublicationSchemaWithPKCErrorIfItFails, An as RpcCidParamSchema, At as verifyCommunityEdit, B as setNativeFunctions$1, Bn as RpcFetchCidResultSchema, Bt as getCommunityPublicKeyFromWire, Cn as parseRpcCommentEventWithPKCErrorIfItFails, Ct as verifyChallengeVerification, D as createKuboRpcClient, Dn as parseVotePubsubMessagePublicationSchemaWithPKCErrorIfItFails, Dt as verifyCommentPubsubMessage, Et as verifyCommentModeration, Fn as RpcExportCommunityModLogsParamSchema, Gn as RpcUnsubscribeParamSchema, H as CommentClientsManager, Hn as RpcResolveAuthorNameResultSchema, Ht as decode, I as listCommunitiesSync, In as RpcExportCommunityModLogsResultSchema, It as normalizeCreatePublicationAuthor, L as monitorCommunitiesDirectory, Ln as RpcExportCommunityParamSchema, Lt as buildRuntimeCommunityFields, Mn as RpcCommunityIdentifierParamSchema, Mt as buildRuntimeAuthor, N as getDefaultDataPath, Nn as RpcCommunityPageParamSchema, Nt as cleanWireAuthor, On as RpcAuthorNameParamSchema, Ot as verifyCommentUpdate, Pn as RpcEditCommunityParamSchema, Pt as getAuthorNameFromRuntime, Q as parseRawPages, Rn as RpcExportCommunityResultSchema, Rt as getCommunityAddressFromRecord, Sn as parsePKCUserOptionsSchemaWithPKCErrorIfItFails, Tn as parseSetNewSettingsPKCWsServerSchemaWithPKCErrorIfItFails, Tt as verifyCommentIpfs, Un as RpcSubscriptionIdResultSchema, V as tryToDeleteCommunitiesThatFailedToBeDeletedBefore, Vn as RpcPublishChallengeAnswersParamSchema, Vt as normalizeCommunityInputFromCommunity, Wn as RpcSuccessResultSchema, Wt as getBufferedPKCAddressFromPublicKey, X as findCommentInPageInstanceRecursively, Xn as require_undici, Xt as parseCidStringSchemaWithPKCErrorIfItFails, Y as extractCommunityRuntimeFieldsFromParsedPages, Yn as nativeFunctions$2, _n as parseCreateVoteOptionsSchemaWithPKCErrorIfItFails, a as pkcJsChallenges, at as PKCTypedEmitter, bn as parseDecryptedChallengeWithPKCErrorIfItFails, c as AddressesRewriterProxyServer, ct as signChallengeAnswer, dn as parseCreateCommentOptionsSchemaWithPKCErrorIfItFails, en as parseCommentIpfsSchemaWithPKCErrorIfItFails, et as PublicationClientsManager, f as KeyvBetterSqlite3, fn as parseCreateCommunityEditPublicationOptionsSchemaWithPKCErrorIfItFails, ft as signComment, g as decodeRpcChallengeVerificationPubsubMsg, gn as parseCreateRpcCommunityFunctionArgumentSchemaWithPKCErrorIfItFails, h as decodeRpcChallengeRequestPubsubMsg, hn as parseCreateRemoteCommunityFunctionArgumentSchemaWithPKCErrorIfItFails, in as parseCommunityAddressWithPKCErrorIfItFails, jn as RpcCommentRepliesPageParamSchema, jt as verifyVote, kn as RpcCancelExportParamSchema, ln as parseCreateCommentEditOptionsSchemaWithPKCErrorIfItFails, m as decodeRpcChallengePubsubMsg, mt as signCommentModeration, n as RpcRemoteCommunity, nn as parseCommentModerationPubsubMessagePublicationSchemaWithPKCErrorIfItFails, nt as InflightFetchManager, o as TrackedInstanceRegistry, ot as require_lib$1, p as decodeRpcChallengeAnswerPubsubMsg, pt as signCommentEdit, rn as parseCommentPubsubMessagePublicationWithPKCErrorIfItFails, s as LRUCache, sn as parseCommunityEditPubsubMessagePublicationSchemaWithPKCErrorIfItFails, st as cleanUpBeforePublishing, t as RpcLocalCommunity, tt as PKCClientsManager, u as RemoteCommunity, un as parseCreateCommentModerationOptionsSchemaWithPKCErrorIfItFails, ut as signChallengeRequest, v as createSigner, vn as parseDecryptedChallengeAnswerWithPKCErrorIfItFails, vt as signCommunityEdit, wn as parseRpcCommentUpdateEventWithPKCErrorIfItFails, wt as verifyCommentEdit, x as encryptEd25519AesGcm, xn as parseJsonWithPKCErrorIfFails, xt as verifyChallengeMessage, y as decryptEd25519AesGcm, yn as parseDecryptedChallengeVerification, yt as signVote, zn as RpcFetchCidParamSchema, zt as getCommunityNameFromWire } from "./rpc-local-community-XVq4w0ZG.js";
+import { n as getHeliaDebugContext } from "./util-DFDVE6vH.js";
+import path from "path";
 import assert from "assert";
-import fs$1 from "fs";
-import https from "node:https";
+import fs from "fs";
 import Database from "better-sqlite3";
 import { of } from "typestub-ipfs-only-hash";
 import EventEmitter from "events";
@@ -2033,8 +2029,8 @@ var Storage = class {
 		let dbFilePath;
 		if (this._pkc.noData || !this._pkc.dataPath) dbFilePath = ":memory:";
 		else {
-			fs$1.mkdirSync(this._pkc.dataPath, { recursive: true });
-			dbFilePath = path$1.join(this._pkc.dataPath, "storage.db");
+			fs.mkdirSync(this._pkc.dataPath, { recursive: true });
+			dbFilePath = path.join(this._pkc.dataPath, "storage.db");
 		}
 		this._db = new Database(dbFilePath);
 		this._keyv = new KeyvBetterSqlite3(this._db);
@@ -6394,7 +6390,7 @@ var LRUStorage = class {
 	}
 	toJSON() {}
 	async init() {
-		const dbPath = this._opts.pkc.noData || !this._opts.pkc.dataPath ? `:memory:` : path$1.join(this._opts.pkc.dataPath, "lru-storage");
+		const dbPath = this._opts.pkc.noData || !this._opts.pkc.dataPath ? `:memory:` : path.join(this._opts.pkc.dataPath, "lru-storage");
 		this._cache = new SqliteCache({
 			database: dbPath,
 			cacheTableName: this._opts.cacheName,
@@ -6470,525 +6466,6 @@ var CommentModeration = class extends Publication {
 	}
 };
 //#endregion
-//#region dist/node/runtime/node/address-rewriter-db.js
-const debug$1 = logger_default("pkc-js:address-rewriter-db");
-var AddressRewriterDatabase = class {
-	constructor(dataPath, kuboConfig, proxyTarget) {
-		this._db = null;
-		this._dbPath = this._initializeDbPath(dataPath, kuboConfig, proxyTarget);
-	}
-	_initializeDbPath(dataPath, kuboConfig, proxyTarget) {
-		if (!dataPath) throw new Error("dataPath must be defined for request logging");
-		let kuboIdentifier = "unknown";
-		if (kuboConfig && typeof kuboConfig === "object" && "host" in kuboConfig && "port" in kuboConfig) kuboIdentifier = `${kuboConfig.host}_${kuboConfig.port}`;
-		const proxyIdentifier = `${proxyTarget.hostname}_${proxyTarget.port || (proxyTarget.protocol === "https:" ? "443" : "80")}`;
-		const fileName = `address_rewriter_${kuboIdentifier}_${proxyIdentifier}.db`;
-		return path.join(dataPath, ".address-rewriter", fileName);
-	}
-	async initialize() {
-		try {
-			const dbDir = path.dirname(this._dbPath);
-			await fs.mkdir(dbDir, { recursive: true });
-			this._db = new Database(this._dbPath);
-			this._db.exec(`
-                CREATE TABLE IF NOT EXISTS request_logs (
-                    id INTEGER PRIMARY KEY AUTOINCREMENT,
-                    keys TEXT NOT NULL,
-                    received_at INTEGER NOT NULL,
-                    transmitted_at INTEGER,
-                    success INTEGER NOT NULL,
-                    status_code INTEGER,
-                    method TEXT NOT NULL,
-                    url TEXT NOT NULL,
-                    error TEXT,
-                    retry_count INTEGER DEFAULT 0,
-                    body_preview TEXT,
-                    created_at DATETIME DEFAULT CURRENT_TIMESTAMP
-                )
-            `);
-			this._db.exec(`
-                CREATE TABLE IF NOT EXISTS reprovide_logs (
-                    id INTEGER PRIMARY KEY AUTOINCREMENT,
-                    key TEXT NOT NULL,
-                    timestamp INTEGER NOT NULL,
-                    success INTEGER NOT NULL,
-                    error TEXT,
-                    block_not_local INTEGER DEFAULT 0,
-                    created_at DATETIME DEFAULT CURRENT_TIMESTAMP
-                )
-            `);
-			this._db.exec(`
-                CREATE TABLE IF NOT EXISTS failed_keys (
-                    key TEXT PRIMARY KEY,
-                    added_at INTEGER NOT NULL,
-                    created_at DATETIME DEFAULT CURRENT_TIMESTAMP
-                )
-            `);
-			this._db.exec(`
-                CREATE INDEX IF NOT EXISTS idx_request_logs_received_at ON request_logs(received_at);
-                CREATE INDEX IF NOT EXISTS idx_reprovide_logs_timestamp ON reprovide_logs(timestamp);
-                CREATE INDEX IF NOT EXISTS idx_reprovide_logs_key ON reprovide_logs(key);
-            `);
-			try {
-				this._db.exec("ALTER TABLE request_logs ADD COLUMN body_preview TEXT");
-			} catch (error) {
-				if (!(error instanceof Error ? error.message : String(error)).toLowerCase().includes("duplicate column name")) throw error;
-			}
-			debug$1(`Initialized SQLite database at ${this._dbPath}`);
-		} catch (error) {
-			debug$1.error(`Failed to initialize database at ${this._dbPath}:`, error);
-			throw error;
-		}
-	}
-	close() {
-		if (this._db) {
-			this._db.close();
-			this._db = null;
-		}
-	}
-	insertRequestLogs(logs) {
-		if (!this._db) throw new Error("Database not initialized");
-		const insertStmt = this._db.prepare(`
-            INSERT INTO request_logs (
-                keys, received_at, transmitted_at, success, status_code, 
-                method, url, error, retry_count, body_preview
-            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-        `);
-		this._db.transaction(() => {
-			for (const log of logs) insertStmt.run(JSON.stringify(log.keys), log.receivedAt, log.transmittedAt || null, log.success ? 1 : 0, log.statusCode || null, log.method, log.url, log.error || null, log.retryCount || 0, log.bodyPreview || null);
-		})();
-	}
-	insertReprovideLog(key, success, error, blockNotLocal) {
-		if (!this._db) throw new Error("Database not initialized");
-		this._db.prepare(`
-            INSERT INTO reprovide_logs (key, timestamp, success, error, block_not_local)
-            VALUES (?, ?, ?, ?, ?)
-        `).run(key, Date.now(), success ? 1 : 0, error || null, blockNotLocal ? 1 : 0);
-	}
-	loadFailedKeys() {
-		if (!this._db) return [];
-		try {
-			return this._db.prepare("SELECT key FROM failed_keys").all().map((row) => row.key);
-		} catch (error) {
-			debug$1.error("Failed to load failed keys from database:", error);
-			return [];
-		}
-	}
-	saveFailedKeys(keys) {
-		if (!this._db) throw new Error("Database not initialized");
-		this._db.transaction(() => {
-			this._db.exec("DELETE FROM failed_keys");
-			if (keys.length > 0) {
-				const insertStmt = this._db.prepare("INSERT INTO failed_keys (key, added_at) VALUES (?, ?)");
-				const now = Date.now();
-				for (const key of keys) insertStmt.run(key, now);
-			}
-		})();
-	}
-};
-//#endregion
-//#region dist/node/runtime/node/addresses-rewriter-proxy-server.js
-const debug = logger_default("pkc-js:addresses-rewriter");
-const MAX_BODY_PREVIEW_BYTES = 4096;
-function normalizeSelfAddrsForProvider(addrs, peerId) {
-	const suffix = `/p2p/${peerId}`;
-	return import_commonjs.unique(addrs.map((addr) => addr.endsWith(suffix) ? addr.slice(0, -suffix.length) : addr));
-}
-var AddressesRewriterProxyServer = class {
-	constructor({ kuboClients: kuboClient, port, hostname, proxyTargetUrl, pkc }) {
-		this._requestLogBuffer = [];
-		this._isWritingLogs = false;
-		this._failedKeys = /* @__PURE__ */ new Set();
-		this._isRetrying = false;
-		this.addresses = {};
-		this.kuboClients = kuboClient;
-		this.port = port;
-		this.hostname = hostname || "127.0.0.1";
-		this.proxyTarget = new URL(proxyTargetUrl);
-		this.server = http.createServer((req, res) => this._proxyRequestRewrite(req, res));
-		this._storageKeyName = `httprouter_proxy_${proxyTargetUrl}`;
-		this._pkc = pkc;
-		const envValue = process.env.ENABLE_LOGGING_OF_ADDRESS_REWRITER_PROXY;
-		this._loggingEnabled = envValue === "1" || envValue?.toLowerCase() === "true";
-		if (this._loggingEnabled) {
-			const kuboConfig = this.kuboClients?.[0]?.getEndpointConfig();
-			this._db = new AddressRewriterDatabase(this._pkc.dataPath, kuboConfig, this.proxyTarget);
-		} else this._db = null;
-		this._httpAgent = new http.Agent({
-			keepAlive: true,
-			keepAliveMsecs: 3e4,
-			maxSockets: 50,
-			timeout: 1e4
-		});
-		this._httpsAgent = new https.Agent({
-			keepAlive: true,
-			keepAliveMsecs: 3e4,
-			maxSockets: 50,
-			timeout: 1e4
-		});
-		hideClassPrivateProps(this);
-	}
-	async listen(callback) {
-		if (this._loggingEnabled && this._db) {
-			await this._db.initialize();
-			debug("Request logging enabled for addresses rewriter proxy");
-		} else debug("Request logging disabled for addresses rewriter proxy");
-		await this._startUpdateAddressesLoop();
-		if (this._loggingEnabled) this._startRequestLogging();
-		await this._startFailedKeysRetry();
-		this.server.on("error", (err) => debug.error("Error with address rewriter proxy", this.server.address(), "Proxy target", this.proxyTarget, err));
-		this.server.listen(this.port, this.hostname, callback);
-		debug("Addresses rewriter proxy at", this.hostname + ":" + this.port, "started listening to forward requests to", this.proxyTarget.host, `- request logging ${this._loggingEnabled ? "enabled" : "disabled"}`);
-		await this._pkc._storage.setItem(this._storageKeyName, `http://${this.hostname}:${this.port}`);
-	}
-	async destroy() {
-		this.server.close();
-		if (this._updateAddressesInterval) clearInterval(this._updateAddressesInterval);
-		if (this._logWriteInterval) clearInterval(this._logWriteInterval);
-		if (this._retryInterval) clearInterval(this._retryInterval);
-		await this._writeRequestLogs();
-		this._db?.close();
-		this._httpAgent.destroy();
-		this._httpsAgent.destroy();
-		await this._pkc._storage.removeItem(this._storageKeyName);
-	}
-	_proxyRequestRewrite(req, res) {
-		let reqBody = "";
-		req.on("data", (chunk) => {
-			reqBody += chunk.toString();
-		});
-		req.on("end", () => {
-			const shouldRewrite = req.method === "PUT" || req.method === "POST";
-			let requestLogEntry = null;
-			if (shouldRewrite) {
-				const keys = this._extractKeysFromRequestBody(reqBody);
-				const shouldLogRequest = this._loggingEnabled;
-				if (keys.length > 0 || shouldLogRequest) {
-					requestLogEntry = {
-						keys,
-						receivedAt: Date.now(),
-						success: false,
-						method: req.method || "UNKNOWN",
-						url: req.url || "/",
-						retryCount: 0,
-						bodyPreview: shouldLogRequest ? this._createBodyPreview(reqBody) : void 0
-					};
-					if (shouldLogRequest) this._requestLogBuffer.push(requestLogEntry);
-				}
-			}
-			let rewrittenBody = reqBody;
-			if (shouldRewrite && rewrittenBody) try {
-				const json = JSON.parse(rewrittenBody);
-				if (json.Providers && Array.isArray(json.Providers)) {
-					for (const provider of json.Providers) {
-						const peerId = provider?.Payload?.ID;
-						if (peerId && this.addresses[peerId]) provider.Payload.Addrs = this.addresses[peerId];
-					}
-					rewrittenBody = JSON.stringify(json);
-				}
-			} catch (e) {
-				debug("proxy body rewrite error:", e, "body", rewrittenBody, req.url, req.method);
-			}
-			this._proxyRequest(req, res, rewrittenBody, requestLogEntry);
-		});
-		req.on("error", (err) => {
-			debug.trace("Request error:", req.url, req.method, req.headers, reqBody, err);
-			if (!res.headersSent) {
-				debug.trace("Request error:", req.url, req.method, req.headers, reqBody, err);
-				res.writeHead(500);
-				res.end("Internal Server Error");
-			}
-		});
-	}
-	_proxyRequest(req, res, rewrittenBody, requestLogEntry) {
-		if (requestLogEntry) {
-			requestLogEntry.retryCount = 0;
-			requestLogEntry.transmittedAt = Date.now();
-		}
-		const { request: httpRequest } = this.proxyTarget.protocol === "https:" ? https : http;
-		const agent = this.proxyTarget.protocol === "https:" ? this._httpsAgent : this._httpAgent;
-		const requestOptions = {
-			hostname: this.proxyTarget.hostname,
-			protocol: this.proxyTarget.protocol,
-			path: req.url,
-			method: req.method,
-			headers: {
-				...req.headers,
-				"content-length": Buffer.byteLength(rewrittenBody),
-				host: this.proxyTarget.host
-			},
-			agent,
-			timeout: 1e4
-		};
-		if (this.proxyTarget.port) requestOptions.port = this.proxyTarget.port;
-		const proxyReq = httpRequest(requestOptions);
-		proxyReq.setTimeout(1e4, () => {
-			debug.trace("Proxy request timed out", requestOptions);
-			if (requestLogEntry) {
-				requestLogEntry.success = false;
-				requestLogEntry.statusCode = 504;
-				requestLogEntry.error = "Request timeout";
-				requestLogEntry.completed = true;
-				if (requestLogEntry.keys) {
-					const sizeBefore = this._failedKeys.size;
-					requestLogEntry.keys.forEach((key) => this._failedKeys.add(key));
-					if (this._failedKeys.size > sizeBefore) this._saveFailedKeysToDatabase();
-				}
-			}
-			proxyReq.destroy();
-			if (!res.headersSent) {
-				res.writeHead(504);
-				res.end("Gateway Timeout");
-			}
-		});
-		proxyReq.on("error", (e) => {
-			proxyReq.destroy();
-			if (requestLogEntry) {
-				requestLogEntry.success = false;
-				requestLogEntry.statusCode = 500;
-				requestLogEntry.error = `Proxy error: ${e.message}`;
-				requestLogEntry.completed = true;
-				debug.trace(`Updated log entry with error for keys: ${requestLogEntry.keys.join(", ")}`);
-				if (requestLogEntry.keys) {
-					const sizeBefore = this._failedKeys.size;
-					requestLogEntry.keys.forEach((key) => this._failedKeys.add(key));
-					if (this._failedKeys.size > sizeBefore) this._saveFailedKeysToDatabase();
-				}
-			}
-			if (!res.headersSent) {
-				debug.trace("address rewriter proxy error:", e, "Request options", requestOptions);
-				res.writeHead(500);
-				res.end("Internal Server Error");
-			}
-		});
-		proxyReq.on("response", (proxyRes) => {
-			const statusCode = proxyRes.statusCode || 500;
-			const isSuccess = statusCode >= 200 && statusCode < 300;
-			if (requestLogEntry) {
-				requestLogEntry.success = isSuccess;
-				requestLogEntry.statusCode = statusCode;
-				requestLogEntry.completed = true;
-				if (!isSuccess) {
-					requestLogEntry.error = `HTTP ${statusCode}`;
-					if (requestLogEntry.keys) {
-						const sizeBefore = this._failedKeys.size;
-						requestLogEntry.keys.forEach((key) => this._failedKeys.add(key));
-						if (this._failedKeys.size > sizeBefore) this._saveFailedKeysToDatabase();
-					}
-				}
-			}
-			proxyRes.on("error", (err) => {
-				debug.trace("Proxy response error:", err);
-				if (!res.headersSent) {
-					res.writeHead(500);
-					res.end("Proxy Response Error");
-				}
-				if (requestLogEntry) {
-					requestLogEntry.success = false;
-					requestLogEntry.statusCode = 500;
-					requestLogEntry.error = `Proxy response error: ${err.message}`;
-					requestLogEntry.completed = true;
-				}
-				proxyRes.destroy(err);
-			});
-			if (!res.headersSent) {
-				res.writeHead(statusCode, proxyRes.headers);
-				proxyRes.pipe(res);
-			}
-			res.on("finish", () => {
-				proxyRes.resume();
-			});
-		});
-		proxyReq.write(rewrittenBody);
-		proxyReq.end();
-	}
-	async _startUpdateAddressesLoop() {
-		if (!this.kuboClients?.length) throw Error("should have a defined kubo rpc client option to start the address rewriter");
-		const isRetriableError = (error) => {
-			if (typeof error !== "object" || error === null) return false;
-			const err = error;
-			return err.response?.status === 500 || err.status === 500 || err.statusCode === 500;
-		};
-		const tryUpdateAddressesForClient = async (kuboClient) => {
-			return new Promise((resolve) => {
-				const operation = import_retry.operation({
-					retries: 3,
-					factor: 2,
-					minTimeout: 1e3,
-					maxTimeout: 8e3
-				});
-				operation.attempt(async (currentAttempt) => {
-					try {
-						const idRes = await kuboClient.id();
-						const swarmAddrsRes = await kuboClient.swarm.addrs();
-						const peerId = idRes.id.toString();
-						if (typeof peerId !== "string") throw Error("Failed to get Peer ID of kubo node");
-						const swarmListeningAddresses = swarmAddrsRes.filter((swarmAddr) => swarmAddr.id.toString() === peerId);
-						const addresses = normalizeSelfAddrsForProvider([...idRes.addresses.map((addr) => addr.toString()), ...import_commonjs.flatten(swarmListeningAddresses.map((swarmAddr) => swarmAddr.addrs.map((addr) => addr.toString())))], peerId);
-						if (addresses.length === 0) throw Error(`Failed to get any addresses for peer ${peerId}`);
-						this.addresses[peerId] = addresses;
-						resolve();
-					} catch (e) {
-						const error = e;
-						if (isRetriableError(error)) {
-							debug(`tryUpdateAddresses attempt ${currentAttempt}/4 failed with 500 error:`, error.message, { kuboConfig: kuboClient.getEndpointConfig() });
-							if (operation.retry(error)) return;
-						}
-						debug("tryUpdateAddresses error:", error.message, { kuboConfig: kuboClient.getEndpointConfig() });
-						resolve();
-					}
-				});
-			});
-		};
-		const tryUpdateAddresses = async () => {
-			const promises = this.kuboClients.map(tryUpdateAddressesForClient);
-			await Promise.allSettled(promises);
-		};
-		await tryUpdateAddresses();
-		this._updateAddressesInterval = setInterval(tryUpdateAddresses, 1e3 * 60);
-	}
-	_extractKeysFromRequestBody(body) {
-		try {
-			const json = JSON.parse(body);
-			const keys = [];
-			if (json.Providers && Array.isArray(json.Providers)) {
-				for (const provider of json.Providers) if (provider?.Payload?.Keys) keys.push(...provider.Payload.Keys);
-			}
-			return keys;
-		} catch {
-			return [];
-		}
-	}
-	_createBodyPreview(body) {
-		const buffer = Buffer.from(body, "utf8");
-		if (buffer.length <= MAX_BODY_PREVIEW_BYTES) return body;
-		return `${buffer.subarray(0, MAX_BODY_PREVIEW_BYTES).toString("utf8")}...[truncated ${buffer.length - MAX_BODY_PREVIEW_BYTES} bytes]`;
-	}
-	async _writeRequestLogs() {
-		if (!this._loggingEnabled || !this._db) return;
-		if (this._requestLogBuffer.length === 0 || this._isWritingLogs) return;
-		this._isWritingLogs = true;
-		const logsToWrite = this._requestLogBuffer.filter((entry) => entry.completed);
-		if (logsToWrite.length === 0) {
-			this._isWritingLogs = false;
-			return;
-		}
-		const inFlightLogs = this._requestLogBuffer.filter((entry) => !entry.completed);
-		this._requestLogBuffer = inFlightLogs;
-		try {
-			this._db.insertRequestLogs(logsToWrite);
-			debug.trace(`Wrote ${logsToWrite.length} new request log entries to SQLite database`);
-		} catch (error) {
-			debug.error(`Failed to write request logs to SQLite database:`, error);
-			this._requestLogBuffer.unshift(...logsToWrite);
-		} finally {
-			this._isWritingLogs = false;
-		}
-	}
-	_startRequestLogging() {
-		if (!this._loggingEnabled || !this._db) return;
-		const writeInterval = 5 * 1e3;
-		this._logWriteInterval = setInterval(async () => {
-			await this._writeRequestLogs();
-		}, writeInterval);
-	}
-	async _startFailedKeysRetry() {
-		this._loadFailedKeysFromDatabase();
-		const retryInterval = 120 * 1e3;
-		this._retryInterval = setInterval(async () => {
-			if (this._isRetrying) {
-				debug.trace("Previous failed-keys retry still running, skipping this tick");
-				return;
-			}
-			this._isRetrying = true;
-			try {
-				await this._retryFailedKeys();
-			} finally {
-				this._isRetrying = false;
-			}
-		}, retryInterval);
-		debug(`Started failed keys retry with ${this._failedKeys.size} keys from previous sessions`);
-	}
-	_loadFailedKeysFromDatabase() {
-		if (!this._loggingEnabled || !this._db) return;
-		try {
-			const keys = this._db.loadFailedKeys();
-			keys.forEach((key) => this._failedKeys.add(key));
-			debug(`Loaded ${keys.length} failed keys from database`);
-		} catch (error) {
-			debug.error("Failed to load failed keys from database:", error);
-			throw error;
-		}
-	}
-	_saveFailedKeysToDatabase() {
-		if (!this._loggingEnabled || !this._db) return;
-		try {
-			const keys = Array.from(this._failedKeys);
-			this._db.saveFailedKeys(keys);
-			if (keys.length === 0) debug.trace(`All keys successfully provided - no failed keys to save`);
-			else debug.trace(`Saved ${keys.length} failed keys to database`);
-		} catch (error) {
-			debug.error("Failed to save failed keys to database:", error);
-			throw error;
-		}
-	}
-	async _retryFailedKeys() {
-		if (this._failedKeys.size === 0) {
-			debug.trace(`No failed keys to retry - all keys successfully provided`);
-			return;
-		}
-		debug(`Retrying ${this._failedKeys.size} failed keys`);
-		const keysToRetry = Array.from(this._failedKeys);
-		const kuboClient = this.kuboClients?.[0];
-		if (!kuboClient) {
-			debug.error("No kubo client available for retry");
-			return;
-		}
-		const successfulKeys = [];
-		const stillFailedKeys = [];
-		const keysToDiscard = [];
-		for (const key of keysToRetry) try {
-			debug.trace(`Providing key to HTTP routers: ${key}`);
-			const events = [];
-			for await (const event of kuboClient.routing.provide(key, {
-				recursive: true,
-				verbose: true
-			})) {
-				events.push(event);
-				debug(`Routing provide event for ${key}:`, event);
-			}
-			successfulKeys.push(key);
-			debug.trace(`Successfully provided key: ${key}`);
-			this._logReprovideAttempt(key, true, void 0, false);
-		} catch (error) {
-			const errorMessage = error instanceof Error ? error.message : String(error);
-			const isBlockNotLocal = errorMessage.includes("block") && errorMessage.includes("not found locally");
-			this._logReprovideAttempt(key, false, errorMessage, isBlockNotLocal);
-			if (isBlockNotLocal) {
-				keysToDiscard.push(key);
-				debug.trace(`Discarding key ${key} - block not found locally, will not retry`);
-			} else {
-				stillFailedKeys.push(key);
-				debug.trace(`Failed to provide key ${key}:`, error);
-			}
-		}
-		successfulKeys.forEach((key) => this._failedKeys.delete(key));
-		keysToDiscard.forEach((key) => this._failedKeys.delete(key));
-		this._saveFailedKeysToDatabase();
-		debug.trace(`Retry completed: ${successfulKeys.length} successful, ${stillFailedKeys.length} still failed, ${keysToDiscard.length} discarded`);
-	}
-	_logReprovideAttempt(key, success, error, blockNotLocal) {
-		if (!this._loggingEnabled || !this._db) return;
-		try {
-			this._db.insertReprovideLog(key, success, error, blockNotLocal);
-			debug.trace(`Logged reprovide attempt for key ${key}: success=${success}, blockNotLocal=${blockNotLocal}`);
-		} catch (error) {
-			debug.error(`Failed to log reprovide attempt for key ${key}:`, error);
-			throw error;
-		}
-	}
-};
-//#endregion
 //#region node_modules/deep-is/index.js
 var require_deep_is = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	var pSlice = Array.prototype.slice;
@@ -9380,7 +8857,7 @@ var PKC$1 = class extends PKCTypedEmitter {
 		this.clients.libp2pJsClients = {};
 		if (!this.libp2pJsClientsOptions) return;
 		if (!this.httpRoutersOptions) throw Error("httpRoutersOptions is required for libp2pJsClient");
-		const { createLibp2pJsClientOrUseExistingOne } = await import("./helia-for-pkc-CcmiATPg.js");
+		const { createLibp2pJsClientOrUseExistingOne } = await import("./helia-for-pkc-Dy66yFBq.js");
 		for (const clientOptions of this.libp2pJsClientsOptions) {
 			const heliaNode = await createLibp2pJsClientOrUseExistingOne({
 				...clientOptions,
@@ -9626,7 +9103,7 @@ var PKC$1 = class extends PKCTypedEmitter {
 		const log = logger_default("pkc-js:pkc:createLocalCommunity");
 		log.trace("Received community options to create a local community instance:", options);
 		if (!this._canCreateNewLocalCommunity()) throw new PKCError("ERR_CAN_NOT_CREATE_A_LOCAL_COMMUNITY", { pkcOptions: this._userPKCOptions });
-		const { LocalCommunity, createNewLocalCommunityDb, updateInstancePropsWithStartedCommunityOrDb } = await import("./local-community-DzFaedmf.js");
+		const { LocalCommunity, createNewLocalCommunityDb, updateInstancePropsWithStartedCommunityOrDb } = await import("./local-community-CpqhUYOZ.js");
 		const isLocalCommunity = (await listCommunitiesSync(this)).includes(options.address);
 		const community = new LocalCommunity(this);
 		if (isLocalCommunity) {