@pkcprotocol/pkc-js 0.0.56 → 0.0.58

package/dist/bundled/chunks/{rpc-local-community-OVRYzYQ3.js → rpc-local-community-XVq4w0ZG.js}

@@ -1,10 +1,13 @@
-import { $ as pubsubTopicToDhtKey, $n as create, $t as CommunityEditOptionsSchema, A as extractNetworkErrorDetails, An as CreateCommentOptionsWithRefinementSchema, At as trackStartedCommunity, B as isIpfsCid, Bn as CreateCommentEditOptionsWithRefinementSchema, Ct as findUpdatingCommunity, D as deepMergeRuntimeFields, Dn as CommentUpdateSignedPropertyNames, Dr as __require, E as createAbortError, En as CommentUpdateSchema, Er as __exportAll, Et as listUpdatingCommunities, Ft as untrackUpdatingCommunity, Gn as CidPathSchema, Gt as CommentModerationPubsubMessagePublicationSchema, H as isIpns, Hn as AuthorCommentIpfsReservedFields, Ht as CommunityEditPubsubMessagePublicationSchema, I as getPostUpdateTimestampRange, In as CommentEditPubsubMessagePublicationWithFlexibleAuthorSchema, It as require_sha256$1, Jn as CommunityAuthorChallengeReservedFieldNames, Jt as CommentModerationsTableRowSchema, Kn as CidStringSchema, L as hideClassPrivateProps, Mn as ModQueuePageIpfsSchema, Mt as trackUpdatingCommunity, Nn as PageIpfsSchema, Nt as untrackStartedCommunity, O as derivePublicationFromChallengeRequest, Or as __toESM, Ot as refreshTrackedCommunityAliases, Pn as CommentEditChallengeRequestToEncryptSchema, Q as isStringDomain, Qn as CID$1, Qt as CommunityChallengeSettingSchema, R as ipnsNameToIpnsOverPubsubTopic, Rn as CommentEditSignedPropertyNames, Rt as pTimeout, Sn as CommentUpdateChallengeReservedFieldNames, St as findUpdatingComment, Tn as CommentUpdateReservedFields, Tr as __commonJSMin, U as isIpnsPath, Ut as CreateCommunityEditPublicationOptionsWithRefinementSchema, V as isIpfsPath, Vn as AuthorAddressSchema, Vt as CommunityEditPublicationSignedPropertyNames, Wn as ChallengeAnswersSchema, Wt as CommentModerationChallengeRequestToEncryptSchema, X as isRequestPubsubPublicationOfPost, Xn as require_commonjs$4, Xt as ChallengeFileFactorySchema, Yn as CreateSignerSchema, Yt as CreateCommentModerationOptionsWithRefinementSchema, Z as isRequestPubsubPublicationOfReply, Zn as require_retry$1, Zt as ChallengeFileSchema, _ as PKCUserOptionBaseSchema, _n as CommentIpfsReservedFields, _r as number, _t as timestamp, an as CreateRemoteCommunityFunctionArgumentSchema, ar as FailedToFetchPageIpfsFromGatewaysError, b as areEquivalentCommunityAddresses, bn as CommentPubsubMessageWithFlexibleAuthorRefinementSchema, br as string, c as ChallengeVerificationMessageSignedPropertyNames, cr as logger_default, ct as resolveWhenPredicateIsTrue, dn as VoteChallengeRequestToEncryptSchema, en as CommunityExportRecordsSchema, er as all, f as DecryptedChallengeSchema, fn as VotePubsubMessagePublicationSchema, fr as _enum, ft as shortifyAddress, g as PKCParsedOptionsSchema, gn as CommentChallengeRequestToEncryptSchema, gr as literal, gt as throwIfAbortSignalAborted, h as NameResolverSerializedSchema, hr as custom, i as ChallengeMessageSignedPropertyNames, in as CreateNewLocalCommunityUserOptionsSchema, ir as FailedToFetchGenericIpfsFromGatewaysError, it as removeNullUndefinedEmptyObjectsValuesRecursively, j as fetchAndValidateIpnsRecordFromGateway, jn as GetPageParamSchema, k as doesDomainAddressHaveCapitalLetter, l as DecryptedChallengeAnswerSchema, ln as RpcRemoteCommunityUpdateEventResultSchema, lr as require_supports_color, m as NameResolveCacheOptionsSchema, mn as VoteSignedPropertyNames, mr as boolean, mt as sleepUntilTimeoutOrAbort, n as ChallengeAnswerMessageSignedPropertyNames, nn as CommunityIpfsSchema, nr as FailedToFetchCommentUpdateFromGatewaysError, o as ChallengeRequestMessageSignedPropertyNames, on as CreateRpcCommunityFunctionArgumentSchema, or as PKCError, p as DecryptedChallengeVerificationSchema, pr as array, pt as shortifyCid, qn as CommunityAddressSchema, qt as CommentModerationSignedPropertyNames, rn as CommunitySignedPropertyNames, rr as FailedToFetchCommunityFromGatewaysError, sn as ExportCommunityModLogsOptionsSchema, sr as messages, tn as CommunityIpfsReservedFields, tr as FailedToFetchCommentIpfsFromGatewaysError, tt as raceAgainstAbort, un as CreateVoteUserOptionsWithRefinementSchema, ur as require_ms$1, v as PKCUserOptionsSchema, vn as CommentIpfsSchema, vr as object, vt as waitForUpdateInCommunityInstanceWithErrorAndTimeout, wn as CommentUpdateForChallengeVerificationSignedPropertyNames, wt as listStartedCommunities, x as calculateIpfsCidV0, xn as CommentSignedPropertyNames, xt as findStartedCommunity, yr as record, z as isAbortError, zt as CommunityEditPublicationChallengeRequestToEncryptSchema } from "./schema-lNZ3-tdE.js";
+import { $ as pubsubTopicToDhtKey, $n as create, $t as CommunityEditOptionsSchema, A as extractNetworkErrorDetails, An as CreateCommentOptionsWithRefinementSchema, At as trackStartedCommunity, B as isIpfsCid, Bn as CreateCommentEditOptionsWithRefinementSchema, Ct as findUpdatingCommunity, D as deepMergeRuntimeFields, Dn as CommentUpdateSignedPropertyNames, Dr as __require, E as createAbortError, En as CommentUpdateSchema, Er as __exportAll, Et as listUpdatingCommunities, Ft as untrackUpdatingCommunity, Gn as CidPathSchema, Gt as CommentModerationPubsubMessagePublicationSchema, H as isIpns, Hn as AuthorCommentIpfsReservedFields, Ht as CommunityEditPubsubMessagePublicationSchema, I as getPostUpdateTimestampRange, In as CommentEditPubsubMessagePublicationWithFlexibleAuthorSchema, It as require_sha256$1, Jn as CommunityAuthorChallengeReservedFieldNames, Jt as CommentModerationsTableRowSchema, Kn as CidStringSchema, L as hideClassPrivateProps, Mn as ModQueuePageIpfsSchema, Mt as trackUpdatingCommunity, Nn as PageIpfsSchema, Nt as untrackStartedCommunity, O as derivePublicationFromChallengeRequest, Or as __toESM, Ot as refreshTrackedCommunityAliases, Pn as CommentEditChallengeRequestToEncryptSchema, Q as isStringDomain, Qn as CID$1, Qt as CommunityChallengeSettingSchema, R as ipnsNameToIpnsOverPubsubTopic, Rn as CommentEditSignedPropertyNames, Rt as pTimeout, Sn as CommentUpdateChallengeReservedFieldNames, St as findUpdatingComment, Tn as CommentUpdateReservedFields, Tr as __commonJSMin, U as isIpnsPath, Ut as CreateCommunityEditPublicationOptionsWithRefinementSchema, V as isIpfsPath, Vn as AuthorAddressSchema, Vt as CommunityEditPublicationSignedPropertyNames, Wn as ChallengeAnswersSchema, Wt as CommentModerationChallengeRequestToEncryptSchema, X as isRequestPubsubPublicationOfPost, Xn as require_commonjs$4, Xt as ChallengeFileFactorySchema, Yn as CreateSignerSchema, Yt as CreateCommentModerationOptionsWithRefinementSchema, Z as isRequestPubsubPublicationOfReply, Zn as require_retry$1, Zt as ChallengeFileSchema, _ as PKCUserOptionBaseSchema, _n as CommentIpfsReservedFields, _r as number, _t as timestamp, an as CreateRemoteCommunityFunctionArgumentSchema, ar as FailedToFetchPageIpfsFromGatewaysError, b as areEquivalentCommunityAddresses, bn as CommentPubsubMessageWithFlexibleAuthorRefinementSchema, br as string, c as ChallengeVerificationMessageSignedPropertyNames, cr as logger_default, ct as resolveWhenPredicateIsTrue, dn as VoteChallengeRequestToEncryptSchema, en as CommunityExportRecordsSchema, er as all, f as DecryptedChallengeSchema, fn as VotePubsubMessagePublicationSchema, fr as _enum, ft as shortifyAddress, g as PKCParsedOptionsSchema, gn as CommentChallengeRequestToEncryptSchema, gr as literal, gt as throwIfAbortSignalAborted, h as NameResolverSerializedSchema, hr as custom, i as ChallengeMessageSignedPropertyNames, in as CreateNewLocalCommunityUserOptionsSchema, ir as FailedToFetchGenericIpfsFromGatewaysError, it as removeNullUndefinedEmptyObjectsValuesRecursively, j as fetchAndValidateIpnsRecordFromGateway, jn as GetPageParamSchema, k as doesDomainAddressHaveCapitalLetter, l as DecryptedChallengeAnswerSchema, ln as RpcRemoteCommunityUpdateEventResultSchema, lr as require_supports_color, m as NameResolveCacheOptionsSchema, mn as VoteSignedPropertyNames, mr as boolean, mt as sleepUntilTimeoutOrAbort, n as ChallengeAnswerMessageSignedPropertyNames, nn as CommunityIpfsSchema, nr as FailedToFetchCommentUpdateFromGatewaysError, o as ChallengeRequestMessageSignedPropertyNames, on as CreateRpcCommunityFunctionArgumentSchema, or as PKCError, p as DecryptedChallengeVerificationSchema, pr as array, pt as shortifyCid, qn as CommunityAddressSchema, qt as CommentModerationSignedPropertyNames, rn as CommunitySignedPropertyNames, rr as FailedToFetchCommunityFromGatewaysError, sn as ExportCommunityModLogsOptionsSchema, sr as messages, tn as CommunityIpfsReservedFields, tr as FailedToFetchCommentIpfsFromGatewaysError, tt as raceAgainstAbort, un as CreateVoteUserOptionsWithRefinementSchema, ur as require_ms$1, v as PKCUserOptionsSchema, vn as CommentIpfsSchema, vr as object, vt as waitForUpdateInCommunityInstanceWithErrorAndTimeout, wn as CommentUpdateForChallengeVerificationSignedPropertyNames, wt as listStartedCommunities, x as calculateIpfsCidV0, xn as CommentSignedPropertyNames, xt as findStartedCommunity, yr as record, z as isAbortError, zt as CommunityEditPublicationChallengeRequestToEncryptSchema } from "./schema-C03N0i5R.js";
+import http from "node:http";
 import { createHash } from "node:crypto";
 import { pathToFileURL } from "node:url";
+import fs from "node:fs/promises";
+import path from "node:path";
 import dns from "node:dns";
 import os from "os";
 import { closeSync, createReadStream, existsSync, openSync, promises, readSync, readdirSync, rm, watch } from "node:fs";
-import path from "path";
+import path$1 from "path";
 import assert from "assert";
 import { Agent } from "https";
 import { Agent as Agent$1 } from "http";
@@ -12,6 +15,7 @@ import { CID } from "multiformats/cid";
 import { bases } from "multiformats/basics";
 import { fromString } from "uint8arrays/from-string";
 import { peerIdFromMultihash, peerIdFromPrivateKey, peerIdFromPublicKey, peerIdFromString } from "@libp2p/peer-id";
+import https from "node:https";
 import { toString } from "uint8arrays/to-string";
 import { privateKeyFromProtobuf, privateKeyFromRaw, privateKeyToProtobuf, publicKeyFromRaw, publicKeyToProtobuf } from "@libp2p/crypto/keys";
 import Database from "better-sqlite3";
@@ -7637,7 +7641,7 @@ var require_client_h2 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 var require_client = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const assert$23 = __require("node:assert");
 	const net$2 = __require("node:net");
-	const http$3 = __require("node:http");
+	const http$4 = __require("node:http");
 	const util = require_util$6();
 	const { ClientStats } = require_stats();
 	const { channels } = require_diagnostics();
@@ -7649,7 +7653,7 @@ var require_client = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const connectH1 = require_client_h1();
 	const connectH2 = require_client_h2();
 	const kClosedResolve = Symbol("kClosedResolve");
-	const getDefaultNodeMaxHeaderSize = http$3 && http$3.maxHeaderSize && Number.isInteger(http$3.maxHeaderSize) && http$3.maxHeaderSize > 0 ? () => http$3.maxHeaderSize : () => {
+	const getDefaultNodeMaxHeaderSize = http$4 && http$4.maxHeaderSize && Number.isInteger(http$4.maxHeaderSize) && http$4.maxHeaderSize > 0 ? () => http$4.maxHeaderSize : () => {
 		throw new InvalidArgumentError("http module not available or http.maxHeaderSize invalid");
 	};
 	const noop = () => {};
@@ -75526,10 +75530,10 @@ var require_esm = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 //#endregion
 //#region node_modules/hpagent/index.js
 var require_hpagent = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	const https$1 = __require("https");
-	const http$2 = __require("http");
+	const https$2 = __require("https");
+	const http$3 = __require("http");
 	const { URL: URL$2 } = __require("url");
-	var HttpProxyAgent = class extends http$2.Agent {
+	var HttpProxyAgent = class extends http$3.Agent {
 		constructor(options) {
 			const { proxy, proxyRequestOptions, ...opts } = options;
 			super(opts);
@@ -75557,7 +75561,7 @@ var require_hpagent = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 				requestOptions.headers["proxy-authorization"] = `Basic ${base64}`;
 			}
 			if (this.proxy.protocol === "https:") requestOptions.servername = this.proxy.hostname;
-			const request = (this.proxy.protocol === "http:" ? http$2 : https$1).request(requestOptions);
+			const request = (this.proxy.protocol === "http:" ? http$3 : https$2).request(requestOptions);
 			request.once("connect", (response, socket, head) => {
 				request.removeAllListeners();
 				socket.removeAllListeners();
@@ -75577,7 +75581,7 @@ var require_hpagent = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 			request.end();
 		}
 	};
-	var HttpsProxyAgent = class extends https$1.Agent {
+	var HttpsProxyAgent = class extends https$2.Agent {
 		constructor(options) {
 			const { proxy, proxyRequestOptions, ...opts } = options;
 			super(opts);
@@ -75605,7 +75609,7 @@ var require_hpagent = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 				requestOptions.headers["proxy-authorization"] = `Basic ${base64}`;
 			}
 			if (this.proxy.protocol === "https:") requestOptions.servername = this.proxy.hostname;
-			const request = (this.proxy.protocol === "http:" ? http$2 : https$1).request(requestOptions);
+			const request = (this.proxy.protocol === "http:" ? http$3 : https$2).request(requestOptions);
 			request.once("connect", (response, socket, head) => {
 				request.removeAllListeners();
 				socket.removeAllListeners();
@@ -88339,12 +88343,12 @@ var require_package$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 //#endregion
 //#region node_modules/needle/lib/needle.js
 var require_needle = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	var fs = __require("fs"), http$1 = __require("http"), https = __require("https"), url = __require("url"), stream = __require("stream"), debug = require_src()("needle"), stringify$1 = require_querystring().build, multipart = require_multipart(), auth = require_auth(), cookies = require_cookies(), parsers = require_parsers(), decoder = require_decoder();
+	var fs$1 = __require("fs"), http$2 = __require("http"), https$1 = __require("https"), url = __require("url"), stream = __require("stream"), debug$2 = require_src()("needle"), stringify$1 = require_querystring().build, multipart = require_multipart(), auth = require_auth(), cookies = require_cookies(), parsers = require_parsers(), decoder = require_decoder();
 	var version = require_package$1().version;
 	var user_agent = "Needle/" + version;
 	user_agent += " (Node.js " + process.version + "; " + process.platform + " " + process.arch + ")";
 	var tls_options = "agent pfx key passphrase cert ca ciphers rejectUnauthorized secureProtocol checkServerIdentity family";
-	var close_by_default = !http$1.Agent || http$1.Agent.defaultMaxSockets != Infinity;
+	var close_by_default = !http$2.Agent || http$2.Agent.defaultMaxSockets != Infinity;
 	var extend = Object.assign ? Object.assign : __require("util")._extend;
 	var redirect_codes = [
 		301,
@@ -88431,7 +88435,7 @@ var require_needle = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	function get_stream_length(stream, given_length, cb) {
 		if (given_length > 0) return cb(given_length);
 		if (stream.end !== void 0 && stream.end !== Infinity && stream.start !== void 0) return cb(stream.end + 1 - (stream.start || 0));
-		fs.stat(stream.path, function(err, stat) {
+		fs$1.stat(stream.path, function(err, stat) {
 			cb(stat ? stat.size - (stream.start || 0) : null);
 		});
 	}
@@ -88591,12 +88595,12 @@ var require_needle = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	Needle.prototype.send_request = function(count, method, uri, config, post_data, out, callback) {
 		if (typeof config.uri_modifier === "function") {
 			var modified_uri = config.uri_modifier(uri);
-			debug("Modifying request URI", uri + " => " + modified_uri);
+			debug$2("Modifying request URI", uri + " => " + modified_uri);
 			uri = modified_uri;
 		}
-		var request, timer, returned = 0, self = this, request_opts = this.get_request_opts(method, uri, config), protocol = request_opts.protocol == "https:" ? https : http$1;
+		var request, timer, returned = 0, self = this, request_opts = this.get_request_opts(method, uri, config), protocol = request_opts.protocol == "https:" ? https$1 : http$2;
 		function done(err, resp) {
-			if (returned++ > 0) return debug("Already finished, stopping here.");
+			if (returned++ > 0) return debug$2("Already finished, stopping here.");
 			if (timer) clearTimeout(timer);
 			request.removeListener("error", had_error);
 			out.done = true;
@@ -88609,7 +88613,7 @@ var require_needle = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 			});
 		}
 		function had_error(err) {
-			debug("Request error", err);
+			debug$2("Request error", err);
 			out.emit("err", err);
 			done(err || /* @__PURE__ */ new Error("Unknown error when making request."));
 		}
@@ -88628,15 +88632,15 @@ var require_needle = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 				had_error(/* @__PURE__ */ new Error("Remote end closed socket abruptly."));
 			}
 		}
-		debug("Making request #" + count, request_opts);
+		debug$2("Making request #" + count, request_opts);
 		request = protocol.request(request_opts, function(resp) {
 			var headers = resp.headers;
-			debug("Got response", resp.statusCode, headers);
+			debug$2("Got response", resp.statusCode, headers);
 			out.emit("response", resp);
 			set_timeout("read", config.read_timeout);
 			if (config.parse_cookies && (headers["set-cookie"] || config.previous_resp_cookies)) {
 				resp.cookies = extend(config.previous_resp_cookies || {}, cookies.read(headers["set-cookie"]));
-				debug("Got cookies", resp.cookies);
+				debug$2("Got cookies", resp.cookies);
 			}
 			if (redirect_codes.indexOf(resp.statusCode) !== -1 && self.should_follow(headers.location, config, uri)) {
 				clearTimeout(timer);
@@ -88652,13 +88656,13 @@ var require_needle = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 						config.previous_resp_cookies = resp.cookies;
 						if (Object.keys(request_cookies).length || Object.keys(resp.cookies || {}).length) config.headers["cookie"] = cookies.write(extend(request_cookies, resp.cookies));
 					} else if (config.headers["cookie"]) {
-						debug("Clearing original request cookie", config.headers["cookie"]);
+						debug$2("Clearing original request cookie", config.headers["cookie"]);
 						delete config.headers["cookie"];
 					}
 					if (config.follow_set_referer) config.headers["referer"] = encodeURI(uri);
 					config.headers["host"] = null;
 					var redirect_url = resolve_url(headers.location, uri);
-					debug("Redirecting to " + redirect_url.toString());
+					debug$2("Redirecting to " + redirect_url.toString());
 					return self.send_request(++count, method, redirect_url.toString(), config, post_data, out, callback);
 				} else if (config.follow_max > 0) return done(/* @__PURE__ */ new Error("Max redirects reached. Possible loop in: " + headers.location));
 			}
@@ -88690,11 +88694,11 @@ var require_needle = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 			} else if (text_response && config.decode_response && mime.charset) pipeline.push(decoder(mime.charset));
 			pipeline.push(out);
 			pump_streams([resp].concat(pipeline), function(err) {
-				if (err) debug(err);
+				if (err) debug$2(err);
 				if (err && err.message == "write after end") request.destroy();
 			});
 			if (config.output && resp.statusCode == 200) {
-				var file = fs.createWriteStream(config.output);
+				var file = fs$1.createWriteStream(config.output);
 				file.on("error", had_error);
 				out.on("end", function() {
 					if (file.writable) file.end();
@@ -88724,7 +88728,7 @@ var require_needle = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 					}
 				});
 				pump_streams([resp, clean_pipe], function(err) {
-					if (err) debug(err);
+					if (err) debug$2(err);
 				});
 				if (!config.output || resp.statusCode != 200) out.on("readable", function() {
 					var chunk;
@@ -88769,7 +88773,7 @@ var require_needle = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 			}
 		});
 		if (post_data) if (is_stream(post_data)) pump_streams([post_data, request], function(err) {
-			if (err) debug(err);
+			if (err) debug$2(err);
 		});
 		else {
 			request.write(post_data, config.encoding);
@@ -91406,6 +91410,7 @@ const configure = import_safe_stable_stringify.configure;
 const stringify = import_safe_stable_stringify.default;
 //#endregion
 //#region dist/node/clients/rpc-client/schema.js
+var import_retry = /* @__PURE__ */ __toESM(require_retry$1(), 1);
 var import_commonjs = /* @__PURE__ */ __toESM(require_commonjs$4(), 1);
 var import_sha256 = require_sha256$1();
 const SubscriptionIdSchema = number().positive().int();
@@ -97874,7 +97879,6 @@ var require_lib$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 //#endregion
 //#region dist/node/clients/pkc-typed-emitter.js
-var import_retry = /* @__PURE__ */ __toESM(require_retry$1(), 1);
 var import_lib$1 = require_lib$1();
 var PKCTypedEmitter = class extends import_lib$1.TypedEmitter {
 	constructor() {
@@ -101331,14 +101335,14 @@ var CommentClientsManager = class extends PublicationClientsManager {
 };
 //#endregion
 //#region dist/node/runtime/node/util.js
-const getDefaultDataPath = () => path.join(process.cwd(), ".pkc");
+const getDefaultDataPath = () => path$1.join(process.cwd(), ".pkc");
 const getDefaultCommunityDbConfig = async (communityAddress, pkc) => {
 	let filename;
 	if (pkc.noData) filename = ":memory:";
 	else {
 		assert(typeof pkc.dataPath === "string", "pkc.dataPath need to be defined to get default community db config");
-		filename = path.join(pkc.dataPath, "communities", communityAddress);
-		await promises.mkdir(path.dirname(filename), { recursive: true });
+		filename = path$1.join(pkc.dataPath, "communities", communityAddress);
+		await promises.mkdir(path$1.dirname(filename), { recursive: true });
 	}
 	return {
 		filename,
@@ -101437,7 +101441,7 @@ const setNativeFunctions = (newNativeFunctions) => {
 };
 const deleteOldCommunityInWindows = async (subPath, pkc) => {
 	const log = logger_default("pkc-js:community:deleteStaleCommunityInWindows");
-	const communityAddress = path.basename(subPath);
+	const communityAddress = path$1.basename(subPath);
 	await new Promise((resolve) => setTimeout(resolve, 1e4));
 	try {
 		await promises.rm(subPath, { force: true });
@@ -101461,7 +101465,7 @@ async function tryToDeleteCommunitiesThatFailedToBeDeletedBefore(pkc, log) {
 		}
 		const communitiesThatWereDeletedSuccessfully = [];
 		for (const communityAddress of deletedPersistentCommunities) {
-			const communityPath = path.join(pkc.dataPath, "communities", communityAddress);
+			const communityPath = path$1.join(pkc.dataPath, "communities", communityAddress);
 			try {
 				await promises.rm(communityPath, { force: true });
 				log(`Succeeded in deleting old db path (${communityAddress})`);
@@ -101485,7 +101489,7 @@ async function tryToDeleteCommunitiesThatFailedToBeDeletedBefore(pkc, log) {
 function listCommunitiesSync(pkc) {
 	logger_default("pkc-js:listCommunitiesSync");
 	if (typeof pkc.dataPath !== "string") throw Error("pkc.dataPath needs to be defined to listCommunities");
-	const communitiesPath = path.join(pkc.dataPath, "communities");
+	const communitiesPath = path$1.join(pkc.dataPath, "communities");
 	const files = readdirSync(communitiesPath, {
 		recursive: false,
 		withFileTypes: false
@@ -101493,7 +101497,7 @@ function listCommunitiesSync(pkc) {
 	const communityFilesWeDontNeedToCheck = pkc.communities ? files.filter((address) => pkc.communities.includes(address)) : [];
 	const sqliteFiles = files.filter((address) => !communityFilesWeDontNeedToCheck.includes(address)).filter((address) => {
 		try {
-			const filePath = path.join(communitiesPath, address);
+			const filePath = path$1.join(communitiesPath, address);
 			if (!existsSync(filePath)) return false;
 			const fd = openSync(filePath, "r");
 			const buffer = Buffer.alloc(16);
@@ -101574,7 +101578,7 @@ var BackupAbortError = class extends Error {
 async function backupCommunityDb(opts) {
 	const { sourcePath, destPath, includePrivateKey, onProgress, signal } = opts;
 	if (signal?.aborted) throw new BackupAbortError();
-	await promises.mkdir(path.dirname(destPath), { recursive: true });
+	await promises.mkdir(path$1.dirname(destPath), { recursive: true });
 	const partialPath = destPath + ".partial";
 	try {
 		await promises.unlink(partialPath);
@@ -101658,9 +101662,9 @@ async function statAndHashFile(filePath) {
 }
 async function moveCommunityDbToDeletedDirectory(communityAddress, pkc) {
 	if (typeof pkc.dataPath !== "string") throw Error("pkc.dataPath is not defined");
-	const oldPath = path.join(pkc.dataPath, "communities", communityAddress);
-	const newPath = path.join(pkc.dataPath, "communities", "deleted", communityAddress);
-	await promises.mkdir(path.join(pkc.dataPath, "communities", "deleted"), { recursive: true });
+	const oldPath = path$1.join(pkc.dataPath, "communities", communityAddress);
+	const newPath = path$1.join(pkc.dataPath, "communities", "deleted", communityAddress);
+	await promises.mkdir(path$1.join(pkc.dataPath, "communities", "deleted"), { recursive: true });
 	if (!existsSync(oldPath)) throw Error(`Source database ${oldPath} does not exist`);
 	try {
 		const sourceDb = new Database(oldPath, { fileMustExist: true });
@@ -101695,7 +101699,7 @@ function createKuboRpcClient(kuboRpcClientOptions) {
 }
 async function monitorCommunitiesDirectory(pkc) {
 	const watchAbortController = new AbortController();
-	const communitiesPath = path.join(pkc.dataPath, "communities");
+	const communitiesPath = path$1.join(pkc.dataPath, "communities");
 	await promises.mkdir(communitiesPath, { recursive: true });
 	const extensionsToIgnore = [
 		".lock",
@@ -125575,6 +125579,525 @@ var RemoteCommunity = class extends import_lib$1.TypedEmitter {
 	}
 };
 //#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/lru-cache/dist/esm/index.js
 /**
 * @module LRUCache
@@ -128930,4 +129453,4 @@ var RpcLocalCommunity = class extends RpcRemoteCommunity {
 	}
 };
 //#endregion
-export { PKCClientsManager as $, parseCommentModerationChallengeRequestToEncryptSchemaWithPKCErrorIfItFails as $t, getDefaultCommunityDbConfig as A, RpcCommunityIdentifierParamSchema as An, buildRuntimeAuthor as At, CommentClientsManager as B, RpcResolveAuthorNameResultSchema as Bn, decode as Bt, calculateExpectedSignatureSize as C, parseSetNewSettingsPKCWsServerSchemaWithPKCErrorIfItFails as Cn, verifyCommentIpfs as Ct, deriveCommentIpfsFromCommentTableRow as D, RpcCancelExportParamSchema as Dn, verifyCommunity as Dt, deleteOldCommunityInWindows as E, RpcAuthorNameParamSchema as En, verifyCommentUpdate as Et, monitorCommunitiesDirectory as F, RpcExportCommunityParamSchema as Fn, buildRuntimeCommunityFields as Ft, buildPageRuntimeFields as G, STORAGE_KEYS as Gn, getPKCAddressFromPublicKeySync as Gt, POST_REPLIES_SORT_TYPES as H, RpcSuccessResultSchema as Hn, getBufferedPKCAddressFromPublicKey as Ht, moveCommunityDbToDeletedDirectory as I, RpcExportCommunityResultSchema as In, getCommunityAddressFromRecord as It, findCommentInPageInstanceRecursively as J, require_undici as Jn, parseCidStringSchemaWithPKCErrorIfItFails as Jt, buildPagesRuntimeFields as K, require_lodash_merge as Kn, getPublicKeyFromPrivateKey as Kt, resolveDbPostsCidRefs as L, RpcFetchCidParamSchema as Ln, getCommunityNameFromWire$1 as Lt, getThumbnailPropsOfLink as M, RpcEditCommunityParamSchema as Mn, getAuthorNameFromRuntime as Mt, importSignerIntoKuboNode as N, RpcExportCommunityModLogsParamSchema as Nn, getAuthorNameFromWire as Nt, deriveDbPosts as O, RpcCidParamSchema as On, verifyCommunityEdit as Ot, listCommunitiesSync as P, RpcExportCommunityModLogsResultSchema as Pn, normalizeCreatePublicationAuthor as Pt, PublicationClientsManager as Q, parseCommentIpfsSchemaWithPKCErrorIfItFails as Qt, setNativeFunctions as R, RpcFetchCidResultSchema as Rn, getCommunityPublicKeyFromWire as Rt, backupCommunityDb as S, parseRpcCommentUpdateEventWithPKCErrorIfItFails as Sn, verifyCommentEdit as St, createKuboRpcClient as T, parseVotePubsubMessagePublicationSchemaWithPKCErrorIfItFails as Tn, verifyCommentPubsubMessage as Tt, REPLY_REPLIES_SORT_TYPES as U, RpcUnsubscribeParamSchema as Un, getIpfsKeyFromPrivateKey as Ut, POSTS_SORT_TYPES as V, RpcSubscriptionIdResultSchema as Vn, encode as Vt, TIMEFRAMES_TO_SECONDS as W, stringify as Wn, getPKCAddressFromPublicKey as Wt, parseRawPages as X, parseCommentEditChallengeRequestToEncryptSchemaWithPKCErrorIfItFails as Xt, iterateOverPageCidsToFindAllCids as Y, parseCommentChallengeRequestToEncryptSchemaWithPKCErrorIfItFails as Yt, RepliesPages as Z, parseCommentEditPubsubMessagePublicationSchemaWithPKCErrorIfItFails as Zt, decryptEd25519AesGcm as _, parseDecryptedChallengeVerification as _n, signVote as _t, pkcJsChallenges as a, parseCommunityEditPubsubMessagePublicationSchemaWithPKCErrorIfItFails as an, cleanUpBeforePublishing as at, encryptEd25519AesGcmPublicKeyBuffer as b, parsePKCUserOptionsSchemaWithPKCErrorIfItFails as bn, verifyChallengeRequest as bt, RemoteCommunity as c, parseCreateCommentModerationOptionsSchemaWithPKCErrorIfItFails as cn, signChallengeRequest as ct, decodeRpcChallengeAnswerPubsubMsg as d, parseCreateNewLocalCommunityUserOptionsSchemaWithPKCErrorIfItFails as dn, signCommentEdit as dt, parseCommentModerationPubsubMessagePublicationSchemaWithPKCErrorIfItFails as en, InflightFetchManager as et, decodeRpcChallengePubsubMsg as f, parseCreatePKCWsServerOptionsSchemaWithPKCErrorIfItFails as fn, signCommentModeration as ft, createSigner as g, parseDecryptedChallengeAnswerWithPKCErrorIfItFails as gn, signCommunityEdit as gt, SignerWithPublicKeyAddress as h, parseCreateVoteOptionsSchemaWithPKCErrorIfItFails as hn, signCommunity as ht, getCommunityChallengeFromCommunityChallengeSettings as i, parseCommunityEditOptionsSchemaWithPKCErrorIfItFails as in, require_lib$1 as it, getDefaultDataPath as j, RpcCommunityPageParamSchema as jn, cleanWireAuthor as jt, deriveDbReplies as k, RpcCommentRepliesPageParamSchema as kn, verifyVote as kt, MAX_FILE_SIZE_BYTES_FOR_COMMUNITY_IPFS as l, parseCreateCommentOptionsSchemaWithPKCErrorIfItFails as ln, signChallengeVerification as lt, decodeRpcChallengeVerificationPubsubMsg as m, parseCreateRpcCommunityFunctionArgumentSchemaWithPKCErrorIfItFails as mn, signCommentUpdateForChallengeVerification as mt, RpcRemoteCommunity as n, parseCommunityAddressWithPKCErrorIfItFails as nn, pLimit as nt, TrackedInstanceRegistry as o, parseCommunityIpfsSchemaPassthroughWithPKCErrorIfItFails as on, signChallengeAnswer as ot, decodeRpcChallengeRequestPubsubMsg as p, parseCreateRemoteCommunityFunctionArgumentSchemaWithPKCErrorIfItFails as pn, signCommentUpdate as pt, extractCommunityRuntimeFieldsFromParsedPages as q, nativeFunctions$1 as qn, createSchemaRowParser as qt, getChallengeVerification as r, parseCommunityEditChallengeRequestToEncryptSchemaWithPKCErrorIfItFails as rn, PKCTypedEmitter as rt, LRUCache as s, parseCreateCommentEditOptionsSchemaWithPKCErrorIfItFails as sn, signChallengeMessage as st, RpcLocalCommunity as t, parseCommentPubsubMessagePublicationWithPKCErrorIfItFails as tn, pRetry as tt, KeyvBetterSqlite3 as u, parseCreateCommunityEditPublicationOptionsSchemaWithPKCErrorIfItFails as un, signComment as ut, decryptEd25519AesGcmPublicKeyBuffer as v, parseDecryptedChallengeWithPKCErrorIfItFails as vn, verifyChallengeAnswer as vt, calculateInlineRepliesBudget as w, parseVoteChallengeRequestToEncryptSchemaWithPKCErrorIfItFails as wn, verifyCommentModeration as wt, BackupAbortError as x, parseRpcCommentEventWithPKCErrorIfItFails as xn, verifyChallengeVerification as xt, encryptEd25519AesGcm as y, parseJsonWithPKCErrorIfFails as yn, verifyChallengeMessage as yt, tryToDeleteCommunitiesThatFailedToBeDeletedBefore as z, RpcPublishChallengeAnswersParamSchema as zn, normalizeCommunityInputFromCommunity as zt };
+export { RepliesPages as $, parseCommentEditPubsubMessagePublicationSchemaWithPKCErrorIfItFails as $t, deriveDbPosts as A, RpcCidParamSchema as An, verifyCommunityEdit as At, setNativeFunctions as B, RpcFetchCidResultSchema as Bn, getCommunityPublicKeyFromWire as Bt, BackupAbortError as C, parseRpcCommentEventWithPKCErrorIfItFails as Cn, verifyChallengeVerification as Ct, createKuboRpcClient as D, parseVotePubsubMessagePublicationSchemaWithPKCErrorIfItFails as Dn, verifyCommentPubsubMessage as Dt, calculateInlineRepliesBudget as E, parseVoteChallengeRequestToEncryptSchemaWithPKCErrorIfItFails as En, verifyCommentModeration as Et, importSignerIntoKuboNode as F, RpcExportCommunityModLogsParamSchema as Fn, getAuthorNameFromWire as Ft, REPLY_REPLIES_SORT_TYPES as G, RpcUnsubscribeParamSchema as Gn, getIpfsKeyFromPrivateKey as Gt, CommentClientsManager as H, RpcResolveAuthorNameResultSchema as Hn, decode as Ht, listCommunitiesSync as I, RpcExportCommunityModLogsResultSchema as In, normalizeCreatePublicationAuthor as It, buildPagesRuntimeFields as J, require_lodash_merge as Jn, getPublicKeyFromPrivateKey as Jt, TIMEFRAMES_TO_SECONDS as K, stringify as Kn, getPKCAddressFromPublicKey as Kt, monitorCommunitiesDirectory as L, RpcExportCommunityParamSchema as Ln, buildRuntimeCommunityFields as Lt, getDefaultCommunityDbConfig as M, RpcCommunityIdentifierParamSchema as Mn, buildRuntimeAuthor as Mt, getDefaultDataPath as N, RpcCommunityPageParamSchema as Nn, cleanWireAuthor as Nt, deleteOldCommunityInWindows as O, RpcAuthorNameParamSchema as On, verifyCommentUpdate as Ot, getThumbnailPropsOfLink as P, RpcEditCommunityParamSchema as Pn, getAuthorNameFromRuntime as Pt, parseRawPages as Q, parseCommentEditChallengeRequestToEncryptSchemaWithPKCErrorIfItFails as Qt, moveCommunityDbToDeletedDirectory as R, RpcExportCommunityResultSchema as Rn, getCommunityAddressFromRecord as Rt, encryptEd25519AesGcmPublicKeyBuffer as S, parsePKCUserOptionsSchemaWithPKCErrorIfItFails as Sn, verifyChallengeRequest as St, calculateExpectedSignatureSize as T, parseSetNewSettingsPKCWsServerSchemaWithPKCErrorIfItFails as Tn, verifyCommentIpfs as Tt, POSTS_SORT_TYPES as U, RpcSubscriptionIdResultSchema as Un, encode as Ut, tryToDeleteCommunitiesThatFailedToBeDeletedBefore as V, RpcPublishChallengeAnswersParamSchema as Vn, normalizeCommunityInputFromCommunity as Vt, POST_REPLIES_SORT_TYPES as W, RpcSuccessResultSchema as Wn, getBufferedPKCAddressFromPublicKey as Wt, findCommentInPageInstanceRecursively as X, require_undici as Xn, parseCidStringSchemaWithPKCErrorIfItFails as Xt, extractCommunityRuntimeFieldsFromParsedPages as Y, nativeFunctions$1 as Yn, createSchemaRowParser as Yt, iterateOverPageCidsToFindAllCids as Z, parseCommentChallengeRequestToEncryptSchemaWithPKCErrorIfItFails as Zt, SignerWithPublicKeyAddress as _, parseCreateVoteOptionsSchemaWithPKCErrorIfItFails as _n, signCommunity as _t, pkcJsChallenges as a, parseCommunityEditChallengeRequestToEncryptSchemaWithPKCErrorIfItFails as an, PKCTypedEmitter as at, decryptEd25519AesGcmPublicKeyBuffer as b, parseDecryptedChallengeWithPKCErrorIfItFails as bn, verifyChallengeAnswer as bt, AddressesRewriterProxyServer as c, parseCommunityIpfsSchemaPassthroughWithPKCErrorIfItFails as cn, signChallengeAnswer as ct, MAX_FILE_SIZE_BYTES_FOR_COMMUNITY_IPFS as d, parseCreateCommentOptionsSchemaWithPKCErrorIfItFails as dn, signChallengeVerification as dt, parseCommentIpfsSchemaWithPKCErrorIfItFails as en, PublicationClientsManager as et, KeyvBetterSqlite3 as f, parseCreateCommunityEditPublicationOptionsSchemaWithPKCErrorIfItFails as fn, signComment as ft, decodeRpcChallengeVerificationPubsubMsg as g, parseCreateRpcCommunityFunctionArgumentSchemaWithPKCErrorIfItFails as gn, signCommentUpdateForChallengeVerification as gt, decodeRpcChallengeRequestPubsubMsg as h, parseCreateRemoteCommunityFunctionArgumentSchemaWithPKCErrorIfItFails as hn, signCommentUpdate as ht, getCommunityChallengeFromCommunityChallengeSettings as i, parseCommunityAddressWithPKCErrorIfItFails as in, pLimit as it, deriveDbReplies as j, RpcCommentRepliesPageParamSchema as jn, verifyVote as jt, deriveCommentIpfsFromCommentTableRow as k, RpcCancelExportParamSchema as kn, verifyCommunity as kt, normalizeSelfAddrsForProvider as l, parseCreateCommentEditOptionsSchemaWithPKCErrorIfItFails as ln, signChallengeMessage as lt, decodeRpcChallengePubsubMsg as m, parseCreatePKCWsServerOptionsSchemaWithPKCErrorIfItFails as mn, signCommentModeration as mt, RpcRemoteCommunity as n, parseCommentModerationPubsubMessagePublicationSchemaWithPKCErrorIfItFails as nn, InflightFetchManager as nt, TrackedInstanceRegistry as o, parseCommunityEditOptionsSchemaWithPKCErrorIfItFails as on, require_lib$1 as ot, decodeRpcChallengeAnswerPubsubMsg as p, parseCreateNewLocalCommunityUserOptionsSchemaWithPKCErrorIfItFails as pn, signCommentEdit as pt, buildPageRuntimeFields as q, STORAGE_KEYS as qn, getPKCAddressFromPublicKeySync as qt, getChallengeVerification as r, parseCommentPubsubMessagePublicationWithPKCErrorIfItFails as rn, pRetry as rt, LRUCache as s, parseCommunityEditPubsubMessagePublicationSchemaWithPKCErrorIfItFails as sn, cleanUpBeforePublishing as st, RpcLocalCommunity as t, parseCommentModerationChallengeRequestToEncryptSchemaWithPKCErrorIfItFails as tn, PKCClientsManager as tt, RemoteCommunity as u, parseCreateCommentModerationOptionsSchemaWithPKCErrorIfItFails as un, signChallengeRequest as ut, createSigner as v, parseDecryptedChallengeAnswerWithPKCErrorIfItFails as vn, signCommunityEdit as vt, backupCommunityDb as w, parseRpcCommentUpdateEventWithPKCErrorIfItFails as wn, verifyCommentEdit as wt, encryptEd25519AesGcm as x, parseJsonWithPKCErrorIfFails as xn, verifyChallengeMessage as xt, decryptEd25519AesGcm as y, parseDecryptedChallengeVerification as yn, signVote as yt, resolveDbPostsCidRefs as z, RpcFetchCidParamSchema as zn, getCommunityNameFromWire$1 as zt };