@fedify/fedify 1.9.0-pr.428.1588 → 1.9.0-pr.431.1597

package/dist/vocab-Du8FV6H1.cjs

@@ -0,0 +1,282 @@
+
+          const { Temporal } = require("@js-temporal/polyfill");
+          const { URLPattern } = require("urlpattern-polyfill");
+        
+const require_chunk = require('./chunk-DqRYRqnO.cjs');
+const require_docloader = require('./docloader-eqgyMp7h.cjs');
+const require_actor = require('./actor-CfaqWvJb.cjs');
+const require_lookup = require('./lookup-D96ipStp.cjs');
+const __logtape_logtape = require_chunk.__toESM(require("@logtape/logtape"));
+const __opentelemetry_api = require_chunk.__toESM(require("@opentelemetry/api"));
+const es_toolkit = require_chunk.__toESM(require("es-toolkit"));
+
+//#region src/vocab/handle.ts
+/**
+* Regular expression to match a fediverse handle in the format `@user@server`
+* or `user@server`.  The `user` part can contain alphanumeric characters and
+* some special characters except `@`.  The `server` part is all characters
+* after the `@` symbol in the middle.
+*/
+const handleRegexp = /^@?((?:[-A-Za-z0-9._~!$&'()*+,;=]|%[A-Fa-f0-9]{2})+)@([^@]+)$/;
+/**
+* Parses a fediverse handle in the format `@user@server` or `user@server`.
+* The `user` part can contain alphanumeric characters and some special
+* characters except `@`.  The `server` part is all characters after the `@`
+* symbol in the middle.
+*
+* @example
+* ```typescript
+* const handle = parseFediverseHandle("@username@example.com");
+* console.log(handle?.username); // "username"
+* console.log(handle?.host);     // "example.com"
+* ```
+*
+* @param handle - The fediverse handle string to parse.
+* @returns A {@link FediverseHandle} object with `username` and `host`
+*          if the input is valid; otherwise `null`.
+* @since 1.8.0
+*/
+function parseFediverseHandle(handle) {
+	const match = handleRegexp.exec(handle);
+	if (match) return {
+		username: match[1],
+		host: match[2]
+	};
+	return null;
+}
+/**
+* Checks if a string is a valid fediverse handle in the format `@user@server`
+* or `user@server`.  The `user` part can contain alphanumeric characters and
+* some special characters except `@`.  The `server` part is all characters
+* after the `@` symbol in the middle.
+*
+* @example
+* ```typescript
+* console.log(isFediverseHandle("@username@example.com")); // true
+* console.log(isFediverseHandle("username@example.com"));  // true
+* console.log(isFediverseHandle("@username@"));            // false
+* ```
+*
+* @param handle - The string to test as a fediverse handle.
+* @returns `true` if the string matches the fediverse handle pattern;
+*          otherwise `false`.
+* @since 1.8.0
+*/
+function isFediverseHandle(handle) {
+	return handleRegexp.test(handle);
+}
+/**
+* Converts a fediverse handle in the format `@user@server` or `user@server`
+* to an `acct:` URI, which is a URL-like identifier for ActivityPub actors.
+*
+* @example
+* ```typescript
+* const identifier = toAcctUrl("@username@example.com");
+* console.log(identifier?.href); // "acct:username@example.com"
+* ```
+*
+* @param handle - The fediverse handle string to convert.
+* @returns A `URL` object representing the `acct:` URI if conversion succeeds;
+*          otherwise `null`.
+* @since 1.8.0
+*/
+function toAcctUrl(handle) {
+	const parsed = parseFediverseHandle(handle);
+	if (!parsed) return null;
+	const identifier = new URL(`acct:${parsed.username}@${parsed.host}`);
+	return identifier;
+}
+
+//#endregion
+//#region src/vocab/lookup.ts
+const logger = (0, __logtape_logtape.getLogger)([
+	"fedify",
+	"vocab",
+	"lookup"
+]);
+/**
+* Looks up an ActivityStreams object by its URI (including `acct:` URIs)
+* or a fediverse handle (e.g., `@user@server` or `user@server`).
+*
+* @example
+* ``` typescript
+* // Look up an actor by its fediverse handle:
+* await lookupObject("@hongminhee@fosstodon.org");
+* // returning a `Person` object.
+*
+* // A fediverse handle can omit the leading '@':
+* await lookupObject("hongminhee@fosstodon.org");
+* // returning a `Person` object.
+*
+* // A `acct:` URI can be used as well:
+* await lookupObject("acct:hongminhee@fosstodon.org");
+* // returning a `Person` object.
+*
+* // Look up an object by its URI:
+* await lookupObject("https://todon.eu/@hongminhee/112060633798771581");
+* // returning a `Note` object.
+*
+* // It can be a `URL` object as well:
+* await lookupObject(new URL("https://todon.eu/@hongminhee/112060633798771581"));
+* // returning a `Note` object.
+* ```
+*
+* @param identifier The URI or fediverse handle to look up.
+* @param options Lookup options.
+* @returns The object, or `null` if not found.
+* @since 0.2.0
+*/
+async function lookupObject(identifier, options = {}) {
+	const tracerProvider = options.tracerProvider ?? __opentelemetry_api.trace.getTracerProvider();
+	const tracer = tracerProvider.getTracer(require_docloader.deno_default.name, require_docloader.deno_default.version);
+	return await tracer.startActiveSpan("activitypub.lookup_object", async (span) => {
+		try {
+			const result = await lookupObjectInternal(identifier, options);
+			if (result == null) span.setStatus({ code: __opentelemetry_api.SpanStatusCode.ERROR });
+			else {
+				if (result.id != null) span.setAttribute("activitypub.object.id", result.id.href);
+				span.setAttribute("activitypub.object.type", require_actor.getTypeId(result).href);
+				if (result.replyTargetIds.length > 0) span.setAttribute("activitypub.object.in_reply_to", result.replyTargetIds.map((id) => id.href));
+			}
+			return result;
+		} catch (error) {
+			span.setStatus({
+				code: __opentelemetry_api.SpanStatusCode.ERROR,
+				message: String(error)
+			});
+			throw error;
+		} finally {
+			span.end();
+		}
+	});
+}
+async function lookupObjectInternal(identifier, options = {}) {
+	const documentLoader = options.documentLoader ?? require_docloader.getDocumentLoader({ userAgent: options.userAgent });
+	if (typeof identifier === "string") identifier = toAcctUrl(identifier) ?? new URL(identifier);
+	let document = null;
+	if (identifier.protocol === "http:" || identifier.protocol === "https:") try {
+		const remoteDoc = await documentLoader(identifier.href, { signal: options.signal });
+		document = remoteDoc.document;
+	} catch (error) {
+		logger.debug("Failed to fetch remote document:\n{error}", { error });
+	}
+	if (document == null) {
+		const jrd = await require_lookup.lookupWebFinger(identifier, {
+			userAgent: options.userAgent,
+			tracerProvider: options.tracerProvider,
+			allowPrivateAddress: "allowPrivateAddress" in options && options.allowPrivateAddress === true,
+			signal: options.signal
+		});
+		if (jrd?.links == null) return null;
+		for (const l of jrd.links) {
+			if (l.type !== "application/activity+json" && !l.type?.match(/application\/ld\+json;\s*profile="https:\/\/www.w3.org\/ns\/activitystreams"/) || l.rel !== "self" || l.href == null) continue;
+			try {
+				const remoteDoc = await documentLoader(l.href, { signal: options.signal });
+				document = remoteDoc.document;
+				break;
+			} catch (error) {
+				logger.debug("Failed to fetch remote document:\n{error}", { error });
+				continue;
+			}
+		}
+	}
+	if (document == null) return null;
+	try {
+		return await require_actor.Object.fromJsonLd(document, {
+			documentLoader,
+			contextLoader: options.contextLoader,
+			tracerProvider: options.tracerProvider
+		});
+	} catch (error) {
+		if (error instanceof TypeError) {
+			logger.debug("Failed to parse JSON-LD document: {error}\n{document}", {
+				error,
+				document
+			});
+			return null;
+		}
+		throw error;
+	}
+}
+/**
+* Traverses a collection, yielding each item in the collection.
+* If the collection is paginated, it will fetch the next page
+* automatically.
+*
+* @example
+* ``` typescript
+* const collection = await lookupObject(collectionUrl);
+* if (collection instanceof Collection) {
+*   for await (const item of traverseCollection(collection)) {
+*     console.log(item.id?.href);
+*   }
+* }
+* ```
+*
+* @param collection The collection to traverse.
+* @param options Options for traversing the collection.
+* @returns An async iterable of each item in the collection.
+* @since 1.1.0
+*/
+async function* traverseCollection(collection, options = {}) {
+	if (collection.firstId == null) for await (const item of collection.getItems(options)) yield item;
+	else {
+		const interval = Temporal.Duration.from(options.interval ?? { seconds: 0 }).total("millisecond");
+		let page = await collection.getFirst(options);
+		while (page != null) {
+			for await (const item of page.getItems(options)) yield item;
+			if (interval > 0) await (0, es_toolkit.delay)(interval);
+			page = await page.getNext(options);
+		}
+	}
+}
+
+//#endregion
+//#region src/vocab/constants.ts
+/**
+* The special public collection for [public addressing].  *Do not mutate this
+* object.*
+*
+* [public addressing]: https://www.w3.org/TR/activitypub/#public-addressing
+*
+* @since 0.7.0
+*/
+const PUBLIC_COLLECTION = new URL("https://www.w3.org/ns/activitystreams#Public");
+
+//#endregion
+Object.defineProperty(exports, 'PUBLIC_COLLECTION', {
+  enumerable: true,
+  get: function () {
+    return PUBLIC_COLLECTION;
+  }
+});
+Object.defineProperty(exports, 'isFediverseHandle', {
+  enumerable: true,
+  get: function () {
+    return isFediverseHandle;
+  }
+});
+Object.defineProperty(exports, 'lookupObject', {
+  enumerable: true,
+  get: function () {
+    return lookupObject;
+  }
+});
+Object.defineProperty(exports, 'parseFediverseHandle', {
+  enumerable: true,
+  get: function () {
+    return parseFediverseHandle;
+  }
+});
+Object.defineProperty(exports, 'toAcctUrl', {
+  enumerable: true,
+  get: function () {
+    return toAcctUrl;
+  }
+});
+Object.defineProperty(exports, 'traverseCollection', {
+  enumerable: true,
+  get: function () {
+    return traverseCollection;
+  }
+});

package/dist/webfinger/handler.test.js

@@ -3,30 +3,30 @@
       import { URLPattern } from "urlpattern-polyfill";
       globalThis.addEventListener = () => {};
     
-import { Image, Link, Person } from "../type-DDwsy8fI.js";
+import { Image, Link, Person } from "../type-DF9yoIpt.js";
 import { assertEquals } from "../assert_equals-DSbWqCm3.js";
 import "../assert-MZs1qjMx.js";
 import "../assert_instance_of-DHz7EHNU.js";
 import { MemoryKvStore } from "../kv-CRZrzyXm.js";
-import { createFederation, handleWebFinger } from "../middleware-D5JRdsEc.js";
+import { createFederation, handleWebFinger } from "../middleware-CuTcPjfP.js";
 import "../semver-dArNLkR9.js";
-import "../client-DB8N2RwI.js";
-import "../lookup-CXaZBmuy.js";
+import "../client-DgRjF0ha.js";
+import "../lookup-DdxOle8f.js";
 import "../types-BIgY6c-l.js";
-import "../actor-ByOSf9n9.js";
-import "../key-feGm-IP3.js";
-import "../http-B_bBrm6N.js";
-import "../authdocloader-CfP6lfxM.js";
-import "../ld-DJCemZO2.js";
-import "../owner-i9FkgZwa.js";
-import "../proof-Bvtdd-Ul.js";
-import "../inbox-B4k2JQpE.js";
-import "../builder-mfXmda-W.js";
+import "../actor-Dw7av4Zk.js";
+import "../key-Jrnr66vx.js";
+import "../http-C5XLveZw.js";
+import "../authdocloader-ZlLoXSxM.js";
+import "../ld-BSE4jnyK.js";
+import "../owner-DJtc8evi.js";
+import "../proof-9OMp0o4n.js";
+import "../inbox-sVXiVBbT.js";
+import "../builder-BbKfqPmR.js";
 import "../collection-CSzG2j1P.js";
-import "../keycache-b7FYgzB9.js";
+import "../keycache-ogQInQck.js";
 import "../retry-D4GJ670a.js";
-import "../send-Cuw-wTCx.js";
-import { createRequestContext, test } from "../testing-DUFWSgSt.js";
+import "../send-cXerEJm9.js";
+import { createRequestContext, test } from "../testing-BX6IA3LR.js";
 import "../std__assert-X-_kMxKM.js";
 import "../assert_rejects-DiIiJbZn.js";
 import "../assert_is_error-BPGph1Jx.js";

package/dist/webfinger/lookup.test.js

@@ -3,18 +3,18 @@
       import { URLPattern } from "urlpattern-polyfill";
       globalThis.addEventListener = () => {};
     
-import { lookupWebFinger } from "../type-DDwsy8fI.js";
+import { lookupWebFinger } from "../type-DF9yoIpt.js";
 import { assertEquals } from "../assert_equals-DSbWqCm3.js";
 import "../assert-MZs1qjMx.js";
 import "../assert_instance_of-DHz7EHNU.js";
-import "../lookup-CXaZBmuy.js";
-import { test } from "../testing-DUFWSgSt.js";
+import "../lookup-DdxOle8f.js";
+import { test } from "../testing-BX6IA3LR.js";
 import "../std__assert-X-_kMxKM.js";
 import "../assert_rejects-DiIiJbZn.js";
 import "../assert_is_error-BPGph1Jx.js";
 import "../assert_not_equals-f3m3epl3.js";
 import "../assert_throws-BOO88avQ.js";
-import { esm_default } from "../esm-BVYQVacR.js";
+import { esm_default } from "../esm-B_ZjJ1sB.js";
 import { withTimeout } from "es-toolkit";
 
 //#region src/webfinger/lookup.test.ts

package/dist/webfinger/mod.cjs

@@ -0,0 +1,9 @@
+
+          const { Temporal } = require("@js-temporal/polyfill");
+          const { URLPattern } = require("urlpattern-polyfill");
+        
+require('../docloader-eqgyMp7h.cjs');
+const require_lookup = require('../lookup-D96ipStp.cjs');
+require('../webfinger-BjOEdFPs.cjs');
+
+exports.lookupWebFinger = require_lookup.lookupWebFinger;

package/dist/webfinger/mod.d.cts

@@ -0,0 +1,4 @@
+import "../kv-63Cil1MD.cjs";
+import "../docloader-D-MrRyHl.cjs";
+import { Link, LookupWebFingerOptions, ResourceDescriptor, lookupWebFinger } from "../mod-jQ4OODsl.cjs";
+export { Link, LookupWebFingerOptions, ResourceDescriptor, lookupWebFinger };

package/dist/webfinger/mod.js

@@ -1,9 +1,9 @@
 
-      import { Temporal } from "@js-temporal/polyfill";
-      import { URLPattern } from "urlpattern-polyfill";
-    
-import "../docloader-XJzCMWY-.js";
-import { lookupWebFinger } from "../lookup-CIsbr_Qi.js";
-import "../webfinger-C3GIyXIg.js";
+          import { Temporal } from "@js-temporal/polyfill";
+          import { URLPattern } from "urlpattern-polyfill";
+        
+import "../docloader-BKf9RWX4.js";
+import { lookupWebFinger } from "../lookup-D_-F1hLw.js";
+import "../webfinger-De_bU0iE.js";
 
 export { lookupWebFinger };

package/dist/webfinger-BjOEdFPs.cjs

@@ -0,0 +1,4 @@
+
+          const { Temporal } = require("@js-temporal/polyfill");
+          const { URLPattern } = require("urlpattern-polyfill");
+        

package/dist/webfinger-De_bU0iE.js

@@ -0,0 +1,4 @@
+
+          import { Temporal } from "@js-temporal/polyfill";
+          import { URLPattern } from "urlpattern-polyfill";
+        

package/dist/x/cfworkers.cjs

@@ -0,0 +1,100 @@
+
+          const { Temporal } = require("@js-temporal/polyfill");
+          const { URLPattern } = require("urlpattern-polyfill");
+        
+const require_chunk = require('../chunk-DqRYRqnO.cjs');
+const __logtape_logtape = require_chunk.__toESM(require("@logtape/logtape"));
+
+//#region src/x/cfworkers.ts
+/**
+* Implementation of the {@link KvStore} interface for Cloudflare Workers KV
+* binding.  This class provides a wrapper around Cloudflare's KV namespace to
+* store and retrieve JSON-serializable values using structured keys.
+*
+* Note that this implementation does not support the {@link KvStore.cas}
+* operation, as Cloudflare Workers KV does not support atomic compare-and-swap
+* operations.  If you need this functionality, consider using a different
+* key–value store that supports atomic operations.
+*
+* @deprecated This class has been moved to `@fedify/cfworkers` package.
+*             Import `WorkersKvStore` from `@fedify/cfworkers` instead.
+*             This class will be removed in Fedify v2.0.
+* @since 1.6.0
+*/
+var WorkersKvStore = class {
+	#namespace;
+	constructor(namespace) {
+		const logger = (0, __logtape_logtape.getLogger)(["fedify", "cfworkers"]);
+		logger.warn("The `@fedify/fedify/x/cfworkers` module is deprecated; use `WorkersKvStore` from `@fedify/cfworkers` package instead.");
+		this.#namespace = namespace;
+	}
+	#encodeKey(key) {
+		return JSON.stringify(key);
+	}
+	async get(key) {
+		const encodedKey = this.#encodeKey(key);
+		const { value, metadata } = await this.#namespace.getWithMetadata(encodedKey, "json");
+		return metadata == null || metadata.expires < Date.now() ? void 0 : value;
+	}
+	async set(key, value, options) {
+		const encodedKey = this.#encodeKey(key);
+		const metadata = options?.ttl == null ? {} : { expires: Date.now() + options.ttl.total("milliseconds") };
+		await this.#namespace.put(encodedKey, JSON.stringify(value), options?.ttl == null ? { metadata } : {
+			expirationTtl: Math.max(options.ttl.total("seconds"), 60),
+			metadata
+		});
+	}
+	delete(key) {
+		return this.#namespace.delete(this.#encodeKey(key));
+	}
+};
+/**
+* Implementation of the {@link MessageQueue} interface for Cloudflare
+* Workers Queues binding.  This class provides a wrapper around Cloudflare's
+* Queues to send messages to a queue.
+*
+* Note that this implementation does not support the `listen()` method,
+* as Cloudflare Workers Queues do not support message consumption in the same
+* way as other message queue systems.  Instead, you should use
+* the {@link Federation.processQueuedTask} method to process messages
+* passed to the queue.
+*
+* @deprecated This class has been moved to `@fedify/cfworkers` package.
+*             Import `WorkersMessageQueue` from `@fedify/cfworkers` instead.
+*             This class will be removed in Fedify v2.0.
+* @since 1.6.0
+*/
+var WorkersMessageQueue = class {
+	#queue;
+	/**
+	* Cloudflare Queues provide automatic retry with exponential backoff
+	* and Dead Letter Queues.
+	* @since 1.7.0
+	*/
+	nativeRetrial = true;
+	constructor(queue) {
+		const logger = (0, __logtape_logtape.getLogger)(["fedify", "cfworkers"]);
+		logger.warn("The `@fedify/fedify/x/cfworkers` module is deprecated; use `WorkersMessageQueue` from `@fedify/cfworkers` package instead.");
+		this.#queue = queue;
+	}
+	enqueue(message, options) {
+		return this.#queue.send(message, {
+			contentType: "json",
+			delaySeconds: options?.delay?.total("seconds") ?? 0
+		});
+	}
+	enqueueMany(messages, options) {
+		const requests = messages.map((msg) => ({
+			body: msg,
+			contentType: "json"
+		}));
+		return this.#queue.sendBatch(requests, { delaySeconds: options?.delay?.total("seconds") ?? 0 });
+	}
+	listen(_handler, _options) {
+		throw new TypeError("WorkersMessageQueue does not support listen().  Use Federation.processQueuedTask() method instead.");
+	}
+};
+
+//#endregion
+exports.WorkersKvStore = WorkersKvStore;
+exports.WorkersMessageQueue = WorkersMessageQueue;

package/dist/x/cfworkers.d.cts

@@ -0,0 +1,59 @@
+import { KvKey, KvStore, KvStoreSetOptions } from "../kv-63Cil1MD.cjs";
+import { MessageQueue, MessageQueueEnqueueOptions, MessageQueueListenOptions } from "../mq-B7R1Q-M5.cjs";
+import { KVNamespace, Queue } from "@cloudflare/workers-types/experimental";
+
+//#region src/x/cfworkers.d.ts
+
+/**
+ * Implementation of the {@link KvStore} interface for Cloudflare Workers KV
+ * binding.  This class provides a wrapper around Cloudflare's KV namespace to
+ * store and retrieve JSON-serializable values using structured keys.
+ *
+ * Note that this implementation does not support the {@link KvStore.cas}
+ * operation, as Cloudflare Workers KV does not support atomic compare-and-swap
+ * operations.  If you need this functionality, consider using a different
+ * key–value store that supports atomic operations.
+ *
+ * @deprecated This class has been moved to `@fedify/cfworkers` package.
+ *             Import `WorkersKvStore` from `@fedify/cfworkers` instead.
+ *             This class will be removed in Fedify v2.0.
+ * @since 1.6.0
+ */
+declare class WorkersKvStore implements KvStore {
+  #private;
+  constructor(namespace: KVNamespace<string>);
+  get<T = unknown>(key: KvKey): Promise<T | undefined>;
+  set(key: KvKey, value: unknown, options?: KvStoreSetOptions): Promise<void>;
+  delete(key: KvKey): Promise<void>;
+}
+/**
+ * Implementation of the {@link MessageQueue} interface for Cloudflare
+ * Workers Queues binding.  This class provides a wrapper around Cloudflare's
+ * Queues to send messages to a queue.
+ *
+ * Note that this implementation does not support the `listen()` method,
+ * as Cloudflare Workers Queues do not support message consumption in the same
+ * way as other message queue systems.  Instead, you should use
+ * the {@link Federation.processQueuedTask} method to process messages
+ * passed to the queue.
+ *
+ * @deprecated This class has been moved to `@fedify/cfworkers` package.
+ *             Import `WorkersMessageQueue` from `@fedify/cfworkers` instead.
+ *             This class will be removed in Fedify v2.0.
+ * @since 1.6.0
+ */
+declare class WorkersMessageQueue implements MessageQueue {
+  #private;
+  /**
+   * Cloudflare Queues provide automatic retry with exponential backoff
+   * and Dead Letter Queues.
+   * @since 1.7.0
+   */
+  readonly nativeRetrial = true;
+  constructor(queue: Queue);
+  enqueue(message: any, options?: MessageQueueEnqueueOptions): Promise<void>;
+  enqueueMany(messages: any[], options?: MessageQueueEnqueueOptions): Promise<void>;
+  listen(_handler: (message: any) => Promise<void> | void, _options?: MessageQueueListenOptions): Promise<void>;
+}
+//#endregion
+export { WorkersKvStore, WorkersMessageQueue };

package/dist/x/cfworkers.js

@@ -1,7 +1,7 @@
 
-      import { Temporal } from "@js-temporal/polyfill";
-      import { URLPattern } from "urlpattern-polyfill";
-    
+          import { Temporal } from "@js-temporal/polyfill";
+          import { URLPattern } from "urlpattern-polyfill";
+        
 import { getLogger } from "@logtape/logtape";
 
 //#region src/x/cfworkers.ts

package/dist/x/cfworkers.test.js

@@ -3,12 +3,12 @@
       import { URLPattern } from "urlpattern-polyfill";
       globalThis.addEventListener = () => {};
     
-import "../type-DDwsy8fI.js";
+import "../type-DF9yoIpt.js";
 import { assertEquals } from "../assert_equals-DSbWqCm3.js";
 import "../assert-MZs1qjMx.js";
 import "../assert_instance_of-DHz7EHNU.js";
-import "../lookup-CXaZBmuy.js";
-import { test } from "../testing-DUFWSgSt.js";
+import "../lookup-DdxOle8f.js";
+import { test } from "../testing-BX6IA3LR.js";
 import "../std__assert-X-_kMxKM.js";
 import "../assert_rejects-DiIiJbZn.js";
 import "../assert_is_error-BPGph1Jx.js";

package/dist/x/hono.cjs

@@ -0,0 +1,61 @@
+
+          const { Temporal } = require("@js-temporal/polyfill");
+          const { URLPattern } = require("urlpattern-polyfill");
+        
+const require_chunk = require('../chunk-DqRYRqnO.cjs');
+const __logtape_logtape = require_chunk.__toESM(require("@logtape/logtape"));
+
+//#region src/x/hono.ts
+/**
+* Create a Hono middleware to integrate with the {@link Federation} object.
+*
+* @deprecated This function has been moved to `@fedify/hono` package.
+*             Import `federation` from `@fedify/hono` instead.
+*             This function will be removed in Fedify v2.0.
+*
+* @template TContextData A type of the context data for the {@link Federation}
+*                         object.
+* @template THonoContext A type of the Hono context.
+* @param federation A {@link Federation} object to integrate with Hono.
+* @param contextDataFactory A function to create a context data for the
+*                           {@link Federation} object.
+* @returns A Hono middleware.
+*/
+function federation(federation$1, contextDataFactory) {
+	const logger = (0, __logtape_logtape.getLogger)([
+		"fedify",
+		"federation",
+		"hono"
+	]);
+	logger.warn("The `@fedify/fedify/x/hono` module is deprecated; use `federation` from `@fedify/hono` package instead.");
+	return async (ctx, next) => {
+		let contextData = contextDataFactory(ctx);
+		if (contextData instanceof Promise) contextData = await contextData;
+		return await federation$1.fetch(ctx.req.raw, {
+			contextData,
+			...integrateFetchOptions(ctx, next)
+		});
+	};
+}
+function integrateFetchOptions(ctx, next) {
+	return {
+		async onNotFound(_req) {
+			await next();
+			return ctx.res;
+		},
+		async onNotAcceptable(_req) {
+			await next();
+			if (ctx.res.status !== 404) return ctx.res;
+			return new Response("Not acceptable", {
+				status: 406,
+				headers: {
+					"Content-Type": "text/plain",
+					Vary: "Accept"
+				}
+			});
+		}
+	};
+}
+
+//#endregion
+exports.federation = federation;