@fedify/fedify 2.4.0-dev.2054 → 2.4.0-dev.2063

package/dist/sig-dut4BzEW.cjs

@@ -0,0 +1,405 @@
+const { URLPattern } = require("urlpattern-polyfill");
+const require_http = require("./http-CVjwUCCu.cjs");
+const require_owner = require("./owner-CHBQ0sSj.cjs");
+let _logtape_logtape = require("@logtape/logtape");
+let _fedify_vocab = require("@fedify/vocab");
+let _opentelemetry_api = require("@opentelemetry/api");
+let _fedify_vocab_runtime = require("@fedify/vocab-runtime");
+let _fedify_vocab_runtime_internal_portable_dereference = require("@fedify/vocab-runtime/internal/portable-dereference");
+//#region src/sig/portable-collection.ts
+const logger = (0, _logtape_logtape.getLogger)([
+	"fedify",
+	"sig",
+	"proof"
+]);
+const AS_NAMESPACE = "https://www.w3.org/ns/activitystreams#";
+const AS_ATTRIBUTED_TO = `${AS_NAMESPACE}attributedTo`;
+const AS_PART_OF = `${AS_NAMESPACE}partOf`;
+/**
+* The properties through which a collection refers to its pages, and a page
+* to other pages of the same collection.
+*/
+const PAGING_PROPERTIES = new Set([
+	"first",
+	"last",
+	"current",
+	"next",
+	"prev"
+].map((p) => AS_NAMESPACE + p));
+/**
+* The properties through which an actor refers to its own collections.
+*/
+const ACTOR_COLLECTION_PROPERTIES = /* @__PURE__ */ new Set([
+	"http://www.w3.org/ns/ldp#inbox",
+	`${AS_NAMESPACE}outbox`,
+	`${AS_NAMESPACE}followers`,
+	`${AS_NAMESPACE}following`,
+	`${AS_NAMESPACE}liked`
+]);
+const contextStates = /* @__PURE__ */ new WeakMap();
+function createContext(state) {
+	const token = Object.freeze(Object.create(null));
+	contextStates.set(token, state);
+	return token;
+}
+function getContextState(context) {
+	if (context == null || typeof context !== "object") return void 0;
+	return contextStates.get(context);
+}
+function canonicalize(id) {
+	try {
+		return (0, _fedify_vocab_runtime.canonicalizePortableUri)(typeof id === "string" ? id : (0, _fedify_vocab_runtime.formatIri)(id));
+	} catch (error) {
+		if (error instanceof TypeError) return null;
+		throw error;
+	}
+}
+function toUrl(canonicalId) {
+	return (0, _fedify_vocab_runtime.parseIri)(canonicalId);
+}
+function canonicalizeAll(ids) {
+	const result = [];
+	for (const id of ids) {
+		const canonical = canonicalize(id);
+		if (canonical == null) return null;
+		result.push(canonical);
+	}
+	return result;
+}
+function getExpandedIds(node, property) {
+	const values = node[property];
+	if (values == null) return [];
+	if (!Array.isArray(values)) return null;
+	const ids = [];
+	for (const value of values) {
+		if (value == null || typeof value !== "object" || Array.isArray(value) || typeof value["@id"] !== "string") return null;
+		ids.push(value["@id"]);
+	}
+	return ids;
+}
+function parseAll(ids) {
+	const result = [];
+	for (const id of ids) try {
+		result.push((0, _fedify_vocab_runtime.parseIri)(id));
+	} catch (error) {
+		if (error instanceof TypeError) return null;
+		throw error;
+	}
+	return result;
+}
+function describeRoot(root) {
+	const rawId = root["@id"];
+	if (typeof rawId !== "string") return null;
+	const id = canonicalize(rawId);
+	if (id == null) return null;
+	const partOf = getExpandedIds(root, AS_PART_OF);
+	const attributedTo = getExpandedIds(root, AS_ATTRIBUTED_TO);
+	return {
+		id,
+		url: toUrl(id),
+		origin: (0, _fedify_vocab_runtime.getFe34Origin)(id),
+		partOf: partOf == null ? null : canonicalizeAll(partOf),
+		attributedTo: attributedTo == null ? null : canonicalizeAll(attributedTo),
+		attributedToUrls: attributedTo == null ? null : parseAll(attributedTo)
+	};
+}
+function describeObject(object) {
+	if (!(object instanceof _fedify_vocab.Object) || object.id == null) return null;
+	const id = canonicalize(object.id);
+	if (id == null) return null;
+	const partOfId = object instanceof _fedify_vocab.CollectionPage ? object.partOfId : null;
+	return {
+		id,
+		url: toUrl(id),
+		origin: (0, _fedify_vocab_runtime.getFe34Origin)(id),
+		partOf: canonicalizeAll(partOfId == null ? [] : [partOfId]),
+		attributedTo: canonicalizeAll(object.attributionIds),
+		attributedToUrls: object.attributionIds
+	};
+}
+function fail(reason) {
+	return {
+		verified: false,
+		reason
+	};
+}
+/**
+* Walks the referrer chain of a collection or page to find the root
+* collection and its owner candidate, checking every page on the way.
+*/
+function resolveChain(node, referrer) {
+	const pages = [];
+	let top = node;
+	let link = referrer;
+	let state;
+	while (link != null && PAGING_PROPERTIES.has(link.property)) {
+		pages.push(top);
+		state = getContextState(link.collectionContext);
+		if (state != null) break;
+		const parent = describeObject(link.object);
+		if (parent == null || link.truncated) return fail({ type: "unknownCollectionOwner" });
+		top = parent;
+		link = link.referrer;
+	}
+	let rootId;
+	let rootOrigin;
+	let candidate;
+	if (state != null) {
+		rootId = state.rootId;
+		rootOrigin = state.rootOrigin;
+		const ownerCandidate = state.owner == null ? state.ownerCandidate : { id: canonicalize(state.owner.id) };
+		if (ownerCandidate == null) return fail({ type: "unknownCollectionOwner" });
+		candidate = ownerCandidate;
+	} else {
+		rootId = top.id;
+		rootOrigin = top.origin;
+		const attributedTo = top.attributedTo;
+		if (attributedTo == null) return fail({ type: "unknownCollectionOwner" });
+		if (link != null && ACTOR_COLLECTION_PROPERTIES.has(link.property)) {
+			const id = link.id == null ? null : canonicalize(link.id);
+			if (id == null) return fail({ type: "unknownCollectionOwner" });
+			candidate = {
+				id,
+				object: link.object,
+				acceptance: link.acceptance
+			};
+		} else if (attributedTo.length === 1) candidate = {
+			id: attributedTo[0],
+			url: top.attributedToUrls?.[0]
+		};
+		else if (attributedTo.length > 1) return fail({
+			type: "conflictingCollectionOwners",
+			candidates: attributedTo.map(toUrl)
+		});
+		else return fail({ type: "unknownCollectionOwner" });
+		const conflict = attributedTo.find((id) => id !== candidate.id);
+		if (conflict != null) return fail({
+			type: "conflictingCollectionOwners",
+			candidates: [toUrl(candidate.id), toUrl(conflict)]
+		});
+	}
+	if ((0, _fedify_vocab_runtime.getFe34Origin)(candidate.id) !== rootOrigin) return fail({ type: "unknownCollectionOwner" });
+	for (const page of pages) {
+		if (page.origin !== rootOrigin) return fail({
+			type: "collectionPageMismatch",
+			pageId: page.url,
+			collectionId: toUrl(rootId),
+			partOf: null
+		});
+		if (page.partOf == null) return fail({ type: "unknownCollectionOwner" });
+		const partOf = page.partOf.find((id) => id !== rootId);
+		if (partOf != null) return fail({
+			type: "collectionPageMismatch",
+			pageId: page.url,
+			collectionId: toUrl(rootId),
+			partOf: toUrl(partOf)
+		});
+		if (page.attributedTo == null) return fail({ type: "unknownCollectionOwner" });
+		const conflict = page.attributedTo.find((id) => id !== candidate.id);
+		if (conflict != null) return fail({
+			type: "conflictingCollectionOwners",
+			candidates: [toUrl(candidate.id), toUrl(conflict)]
+		});
+	}
+	return {
+		rootId,
+		rootOrigin,
+		owner: state?.owner ?? null,
+		candidate
+	};
+}
+function getActorCollectionIds(actor) {
+	const ids = [];
+	for (const id of [
+		actor.inboxId,
+		actor.outboxId,
+		actor.followersId,
+		actor.followingId,
+		actor.likedId
+	]) {
+		if (id == null) continue;
+		const canonical = canonicalize(id);
+		if (canonical != null) ids.push(canonical);
+	}
+	return ids;
+}
+async function fetchOwner(candidate, options) {
+	const documentLoader = options.documentLoader ?? (0, _fedify_vocab_runtime.getDocumentLoader)();
+	const contextLoader = options.contextLoader ?? (0, _fedify_vocab_runtime.getDocumentLoader)();
+	const tracerProvider = options.tracerProvider ?? _opentelemetry_api.trace.getTracerProvider();
+	const tracer = tracerProvider.getTracer(require_http.name, require_http.version);
+	const gateways = options.gateways ?? ((0, _fedify_vocab_runtime_internal_portable_dereference.getPortableGatewayCandidates)(candidate).length > 0 ? void 0 : options.gatewayHints);
+	const span = tracer.startSpan("activitypub.lookup_object");
+	try {
+		const object = await (0, _fedify_vocab_runtime_internal_portable_dereference.dereferencePortableIri)(candidate, {
+			documentLoader,
+			contextLoader,
+			tracerProvider,
+			gateways,
+			verifyPortableObject: (document, verifierOptions) => require_owner.verifyPortableObjectProof(document, {
+				...options,
+				...verifierOptions
+			}),
+			suppressError: true,
+			span,
+			parse: (document, parseOptions) => _fedify_vocab.Object.fromJsonLd(document, {
+				documentLoader,
+				contextLoader: parseOptions.contextLoader,
+				tracerProvider,
+				baseUrl: parseOptions.baseUrl
+			})
+		});
+		return (0, _fedify_vocab.isActor)(object) ? object : null;
+	} catch (error) {
+		logger.debug("Failed to fetch the owner {owner} of a portable collection: {error}", {
+			owner: (0, _fedify_vocab_runtime.formatIri)(candidate),
+			error
+		});
+		return null;
+	} finally {
+		span.end();
+	}
+}
+async function resolveOwner(chain, options) {
+	if (chain.owner != null) return chain.owner;
+	const { candidate } = chain;
+	const candidateUrl = toUrl(candidate.id);
+	let actor = null;
+	if (candidate.acceptance === "verified" && (0, _fedify_vocab.isActor)(candidate.object) && candidate.object.id != null && canonicalize(candidate.object.id) === candidate.id) actor = candidate.object;
+	else actor = await fetchOwner(candidate.url ?? (candidate.object instanceof _fedify_vocab.Object && candidate.object.id != null ? candidate.object.id : candidateUrl), options);
+	if (actor == null || actor.id == null) return fail({
+		type: "collectionOwnerUnavailable",
+		owner: candidateUrl
+	});
+	const gateways = actor.gateways;
+	if (gateways.length < 1) return fail({
+		type: "collectionOwnerUnavailable",
+		owner: candidateUrl
+	});
+	if (!getActorCollectionIds(actor).includes(chain.rootId)) return fail({
+		type: "collectionNotListedByOwner",
+		owner: candidateUrl,
+		collectionId: toUrl(chain.rootId)
+	});
+	return {
+		id: candidateUrl,
+		gateways
+	};
+}
+function getSourceGateway(node, documentUrl) {
+	if (documentUrl == null || documentUrl.protocol !== "http:" && documentUrl.protocol !== "https:") return null;
+	let portableId;
+	try {
+		portableId = (0, _fedify_vocab_runtime.fromCompatibleEf61Id)(documentUrl);
+	} catch (error) {
+		if (error instanceof TypeError) return null;
+		throw error;
+	}
+	if (portableId == null || canonicalize(portableId) !== node.id) return null;
+	return new URL(documentUrl.origin);
+}
+/**
+* Applies the [FEP-ef61] trust policy to a portable object fetched through
+* a gateway.
+*
+* Portable actors, activities, objects, and collections with proofs are
+* verified by {@link verifyPortableObjectProof}.  A portable collection or
+* collection page without a proof is accepted only if all of the following
+* hold:
+*
+*  -  It was retrieved from a gateway: its final URL (`documentUrl`) is
+*     a compatible identifier for the same portable collection.
+*  -  Its owner is determined unambiguously: the actor whose `inbox`,
+*     `outbox`, `followers`, `following`, or `liked` property referred to
+*     the collection, or the single actor in its `attributedTo`.  A page
+*     inherits the owner of the collection it was reached from through
+*     `first`, `last`, `current`, `next`, or `prev`, and must not name
+*     another collection in `partOf`.
+*  -  The owner's actor document is verified by its proof and lists the
+*     collection as its `inbox`, `outbox`, `followers`, `following`, or
+*     `liked`.
+*  -  The gateway that served the collection is in the owner's `gateways`.
+*
+* Where the document came from and which object referred to it are passed
+* by property accessors when this function is used as their
+* `verifyPortableObject` option.  Objects embedded in an unsecured
+* collection accepted this way are not trusted: accessors dereference and
+* verify them one by one.
+*
+* Note that acceptance through the gateway policy does not verify anything
+* cryptographically; it only means that the owner trusts the gateway.
+*
+* [FEP-ef61]: https://w3id.org/fep/ef61
+*
+* @param jsonLd The JSON-LD document to verify.
+* @param options Additional options.  See also
+*                {@link VerifyPortableObjectOptions}.
+* @returns The detailed result.
+* @throws {TypeError} If the input is not a single JSON-LD object or has a
+*                     malformed portable ID.
+* @since 2.4.0
+*/
+async function verifyPortableObject(jsonLd, options = {}) {
+	const { result, root, objectType } = await require_owner.verifyPortableObjectProofWithRoot(jsonLd, options);
+	if (result.verified) {
+		const node = objectType === "collection" && root != null ? describeRoot(root) : null;
+		const chain = node == null ? null : resolveChain(node, options.referrer);
+		if (chain == null || !("rootId" in chain)) return {
+			verified: true,
+			method: "proof",
+			keys: result.keys
+		};
+		return {
+			verified: true,
+			method: "proof",
+			keys: result.keys,
+			collectionContext: createContext({
+				rootId: chain.rootId,
+				rootOrigin: chain.rootOrigin,
+				owner: chain.owner,
+				ownerCandidate: chain.candidate
+			})
+		};
+	}
+	if (result.reason.type !== "unsecuredCollection") return {
+		verified: false,
+		reason: result.reason
+	};
+	const node = root == null ? null : describeRoot(root);
+	if (node == null) return fail({ type: "unknownCollectionOwner" });
+	const gateway = getSourceGateway(node, options.documentUrl);
+	if (gateway == null) return fail({
+		type: "unknownCollectionSource",
+		documentUrl: options.documentUrl ?? null
+	});
+	const chain = resolveChain(node, options.referrer);
+	if (!("rootId" in chain)) return chain;
+	const owner = await resolveOwner(chain, options);
+	if (!("gateways" in owner)) return owner;
+	if (!owner.gateways.some((g) => g.origin === gateway.origin)) return fail({
+		type: "untrustedGateway",
+		owner: owner.id,
+		gateway,
+		gateways: owner.gateways
+	});
+	return {
+		verified: true,
+		method: "gateway",
+		unsecured: true,
+		owner: owner.id,
+		gateway,
+		collectionContext: createContext({
+			rootId: chain.rootId,
+			rootOrigin: chain.rootOrigin,
+			owner,
+			ownerCandidate: null
+		})
+	};
+}
+//#endregion
+Object.defineProperty(exports, "verifyPortableObject", {
+	enumerable: true,
+	get: function() {
+		return verifyPortableObject;
+	}
+});

package/dist/{temporal-B6U3fEUW.mjs → temporal-CcRkOx3C.mjs}

@@ -1,7 +1,7 @@
 import { Temporal } from "temporal-polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
-import { c as getNormalizationContextLoader } from "./ld-OpXWt-80.mjs";
+import { c as getNormalizationContextLoader } from "./ld-BBVP8ock.mjs";
 import jsonld from "@fedify/vocab-runtime/jsonld";
 //#region src/federation/temporal.ts
 function isPlainObject(value) {

package/dist/testing/kv.test.mjs

@@ -6,7 +6,7 @@ import { t as MemoryKvStore } from "../kv-DCHkaJ9-.mjs";
 import { t as ManualClockKvStore } from "../kv-DBRWVx3Q.mjs";
 import { n as baseOptions, o as stringSchema, t as MockQueue } from "../tasks-dbCShlCb.mjs";
 import { t as assertEquals } from "../assert_equals-Z6IcEbWU.mjs";
-import { o as createFederation } from "../middleware-BtwW3G41.mjs";
+import { o as createFederation } from "../middleware-Cw8EWwAT.mjs";
 //#region src/testing/kv.test.ts
 test("ManualClockKvStore keeps an entry at its exact expiration instant", async () => {
 	const kv = new ManualClockKvStore();

package/dist/testing/mod.d.mts

@@ -463,6 +463,60 @@ type OutboxListener<TContextData, TActivity extends Activity> = (context: Outbox
  * @since 2.4.0
  */
 type MediaUploaderCallback<TContextData> = (context: RequestContext<TContextData>, identifier: string, file: File, object: Object$1) => Object$1 | URL | Promise<Object$1 | URL>;
+/**
+ * A request for a resource addressed by a hashlink, which an
+ * [FEP-ef61](https://w3id.org/fep/ef61) gateway serves at
+ * `/.well-known/apgateway/hl:<digestMultibase>`.
+ *
+ * Fedify validates the hashlink before creating this object, so the digest is
+ * always a well-formed SHA-256 multihash.
+ *
+ * @since 2.4.0
+ */
+interface HashlinkMediaRequest {
+  /**
+   * The requested hashlink, i.e., `hl:` followed by
+   * {@link HashlinkMediaRequest.digestMultibase}, after percent-decoding and
+   * with its scheme lowercased.
+   */
+  readonly hashlink: `hl:${string}`;
+  /**
+   * The multibase-encoded multihash as requested, which is the value that
+   * publishers put in the `digestMultibase` property.  The same digest can be
+   * encoded in several multibase encodings; use
+   * {@link HashlinkMediaRequest.digest} as a storage key to find a resource
+   * regardless of the encoding.
+   */
+  readonly digestMultibase: string;
+  /** The hash algorithm of the digest. */
+  readonly algorithm: "sha2-256";
+  /** The raw 32-byte SHA-256 digest of the resource. */
+  readonly digest: Uint8Array;
+  /**
+   * The multihash decoded from
+   * {@link HashlinkMediaRequest.digestMultibase}, i.e., the hash algorithm
+   * code and the digest length followed by the digest.
+   */
+  readonly multihash: Uint8Array;
+}
+/**
+ * A callback that serves a resource addressed by a hashlink through the
+ * [FEP-ef61](https://w3id.org/fep/ef61) gateway endpoint.
+ *
+ * The returned response is sent as is, so the callback can stream its body
+ * and set headers such as `Content-Type` and `Cache-Control`.  Fedify does not
+ * verify the response body against the digest, so the complete
+ * representation must be the exact bytes that hash to the requested digest.
+ *
+ * @template TContextData The context data to pass to the {@link Context}.
+ * @param context The request context.
+ * @param media The requested hashlink and its digest.
+ * @returns The response to send, or `null` if the resource is not stored on
+ *          this server, which results in `404 Not Found`.  It may be returned
+ *          synchronously or wrapped in a `Promise`.
+ * @since 2.4.0
+ */
+type HashlinkMediaDispatcher<TContextData> = (context: RequestContext<TContextData>, media: HashlinkMediaRequest) => Response | null | Promise<Response | null>;
 /**
  * The reason why an incoming activity could not be verified.
  *
@@ -1619,6 +1673,53 @@ interface Federatable<TContextData> extends TaskRegistry<TContextData> {
    * @since 2.4.0
    */
   setMediaUploader(path: `${string}${Rfc6570Expression<"identifier">}${string}`, callback: MediaUploaderCallback<TContextData>): MediaUploaderSetters<TContextData>;
+  /**
+   * Registers a dispatcher that serves resources addressed by hashlinks, such
+   * as media attached to portable objects, through the
+   * [FEP-ef61](https://w3id.org/fep/ef61) gateway endpoint, e.g.,
+   * `GET /.well-known/apgateway/hl:zQmdfTbBqBPQ7VNxZEYEj14VmRuZBkqFbiwReogJgS1zR1n`.
+   *
+   * Fedify responds with `400 Bad Request` without calling the dispatcher if
+   * the hashlink is malformed or its digest is not a SHA-256 multihash, and
+   * with `404 Not Found` if the dispatcher returns `null`.  Otherwise, the
+   * response returned by the dispatcher is sent as is.  Requests with methods
+   * other than `GET` and `HEAD` get `405 Method Not Allowed`.
+   *
+   * Fedify does not verify the served bytes against the digest, as that would
+   * require buffering the whole response body.  The dispatcher must serve only
+   * the resource whose complete representation hashes to the requested
+   * digest, e.g., by using the digest as the storage key.
+   *
+   * This is not the upload API of the ActivityPub Media Upload extension,
+   * which is registered through {@link Federatable.setMediaUploader}.
+   *
+   * @example
+   * ``` typescript
+   * federation.setHashlinkMediaDispatcher(async (ctx, media) => {
+   *   const file = await findPublicMedia(media.digest);
+   *   if (file == null) return null;
+   *   return new Response(
+   *     ctx.request.method === "HEAD" ? null : file.stream(),
+   *     {
+   *       headers: {
+   *         "Content-Type": file.mediaType,
+   *         "Content-Length": file.size.toString(),
+   *         "Cache-Control": "public, max-age=31536000, immutable",
+   *         "X-Content-Type-Options": "nosniff",
+   *       },
+   *     },
+   *   );
+   * });
+   * ```
+   *
+   * @param dispatcher A callback that returns the response serving the
+   *                   requested resource, or `null` if it is not stored on
+   *                   this server.
+   * @throws {RouterError} Thrown if a hashlink media dispatcher is already
+   *                       registered.
+   * @since 2.4.0
+   */
+  setHashlinkMediaDispatcher(dispatcher: HashlinkMediaDispatcher<TContextData>): void;
   /**
    * Registers a following collection dispatcher.
    * @param path The URI path pattern for the following collection.  The syntax

package/dist/utils/docloader.test.mjs

@@ -5,9 +5,9 @@ import { t as esm_default } from "../esm-BHXXx4Wx.mjs";
 import { t as assertEquals } from "../assert_equals-Z6IcEbWU.mjs";
 import "../std__assert-DvMDRPes.mjs";
 import { t as assertRejects } from "../assert_rejects-CTptdYck.mjs";
-import { l as verifyRequest } from "../http-Ty805y3A.mjs";
+import { l as verifyRequest } from "../http-znjq5j6a.mjs";
 import { i as rsaPrivateKey2 } from "../keys-DIJNHW-Y.mjs";
-import { t as getAuthenticatedDocumentLoader } from "../docloader-DS54zLD1.mjs";
+import { t as getAuthenticatedDocumentLoader } from "../docloader-DBb8z7_l.mjs";
 import { mockDocumentLoader, test } from "@fedify/fixture";
 import { FetchError, UrlError } from "@fedify/vocab-runtime";
 //#region src/utils/docloader.test.ts

package/dist/utils/kv-cache.test.mjs

@@ -1,7 +1,7 @@
 import { Temporal } from "temporal-polyfill";
 import { URLPattern } from "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
-import { n as kvCache, t as MockKvStore } from "../kv-cache-BhPPtHg7.mjs";
+import { n as kvCache, t as MockKvStore } from "../kv-cache--REpvHgG.mjs";
 import { deepStrictEqual, throws } from "node:assert";
 import { createTestMeterProvider, mockDocumentLoader, test } from "@fedify/fixture";
 import { preloadedContexts } from "@fedify/vocab-runtime";

package/dist/utils/mod.cjs

@@ -1,5 +1,5 @@
 const { URLPattern } = require("urlpattern-polyfill");
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_kv_cache = require("../kv-cache-CuaZnk6r.cjs");
+const require_kv_cache = require("../kv-cache-D2O0JspA.cjs");
 exports.getAuthenticatedDocumentLoader = require_kv_cache.getAuthenticatedDocumentLoader;
 exports.kvCache = require_kv_cache.kvCache;

package/dist/utils/mod.js

@@ -1,4 +1,4 @@
 import { Temporal } from "temporal-polyfill";
 import { URLPattern } from "urlpattern-polyfill";
-import { n as getAuthenticatedDocumentLoader, t as kvCache } from "../kv-cache-BcHCmrC8.js";
+import { n as getAuthenticatedDocumentLoader, t as kvCache } from "../kv-cache-aijDx_jN.js";
 export { getAuthenticatedDocumentLoader, kvCache };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fedify/fedify",
-  "version": "2.4.0-dev.2054+1756e190",
+  "version": "2.4.0-dev.2063+366c0362",
   "description": "An ActivityPub server framework",
   "keywords": [
     "ActivityPub",
@@ -151,10 +151,10 @@
     "structured-field-values": "^2.0.4",
     "temporal-polyfill": "^1.0.1",
     "urlpattern-polyfill": "^10.1.0",
-    "@fedify/uri-template": "2.4.0-dev.2054+1756e190",
-    "@fedify/vocab": "2.4.0-dev.2054+1756e190",
-    "@fedify/vocab-runtime": "2.4.0-dev.2054+1756e190",
-    "@fedify/webfinger": "2.4.0-dev.2054+1756e190"
+    "@fedify/uri-template": "2.4.0-dev.2063+366c0362",
+    "@fedify/vocab-runtime": "2.4.0-dev.2063+366c0362",
+    "@fedify/webfinger": "2.4.0-dev.2063+366c0362",
+    "@fedify/vocab": "2.4.0-dev.2063+366c0362"
   },
   "devDependencies": {
     "@std/assert": "npm:@jsr/std__assert@^0.226.0",
@@ -166,8 +166,8 @@
     "tsx": "^4.21.0",
     "typescript": "^6.0.0",
     "wrangler": "^4.17.0",
-    "@fedify/fixture": "2.0.0",
-    "@fedify/vocab-tools": "^2.4.0-dev.2054+1756e190"
+    "@fedify/vocab-tools": "^2.4.0-dev.2063+366c0362",
+    "@fedify/fixture": "2.0.0"
   },
   "scripts": {
     "build:self": "tsdown",