@fedify/fedify 2.0.8 → 2.0.10

package/dist/otel/mod.js

@@ -1,10 +1,7 @@
-
-          import { Temporal } from "@js-temporal/polyfill";
-          import { URLPattern } from "urlpattern-polyfill";
-        
+import "@js-temporal/polyfill";
+import "urlpattern-polyfill";
 import { getLogger } from "@logtape/logtape";
 import { ExportResultCode } from "@opentelemetry/core";
-
 //#region src/otel/exporter.ts
 /**
 * A SpanExporter that persists ActivityPub activity traces to a
@@ -89,8 +86,7 @@ var FedifySpanExporter = class {
 			const records = this.#extractRecords(span);
 			for (const record of records) storeOperations.push(this.#storeRecord(record));
 		}
-		const results = await Promise.allSettled(storeOperations);
-		const rejected = results.filter((r) => r.status === "rejected");
+		const rejected = (await Promise.allSettled(storeOperations)).filter((r) => r.status === "rejected");
 		if (rejected.length > 0) throw new AggregateError(rejected.map((r) => r.reason), "Failed to store one or more trace activity records.");
 	}
 	#extractRecords(span) {
@@ -189,12 +185,11 @@ var FedifySpanExporter = class {
 	}
 	async #setWithCasRetry(key, transform, options) {
 		if (this.#kv.cas != null) for (let attempt = 0; attempt < 3; attempt++) {
-			const existing$1 = await this.#kv.get(key);
-			const newValue$1 = transform(existing$1);
-			if (await this.#kv.cas(key, existing$1, newValue$1, options)) return;
+			const existing = await this.#kv.get(key);
+			const newValue = transform(existing);
+			if (await this.#kv.cas(key, existing, newValue, options)) return;
 		}
-		const existing = await this.#kv.get(key);
-		const newValue = transform(existing);
+		const newValue = transform(await this.#kv.get(key));
 		await this.#kv.set(key, newValue, options);
 	}
 	async #updateTraceSummary(record, options) {
@@ -250,6 +245,5 @@ var FedifySpanExporter = class {
 	*/
 	async shutdown() {}
 };
-
 //#endregion
-export { FedifySpanExporter };
+export { FedifySpanExporter };

package/dist/{owner-gd0Q9FuU.d.ts → owner-74ARJ5TL.d.ts}

@@ -65,4 +65,4 @@ interface GetKeyOwnerOptions {
 */
 declare function getKeyOwner(keyId: URL | CryptographicKey, options: GetKeyOwnerOptions): Promise<Actor | null>;
 //#endregion
-export { DoesActorOwnKeyOptions, GetKeyOwnerOptions, doesActorOwnKey, getKeyOwner };
+export { getKeyOwner as i, GetKeyOwnerOptions as n, doesActorOwnKey as r, DoesActorOwnKeyOptions as t };

package/dist/{owner-CImU2dKz.js → owner-CRLqJlP_.mjs}

@@ -1,13 +1,11 @@
-
-      import { Temporal } from "@js-temporal/polyfill";
-      import { URLPattern } from "urlpattern-polyfill";
-      globalThis.addEventListener = () => {};
-    
-import { deno_default } from "./deno-4w047OFk.js";
+import "@js-temporal/polyfill";
+import "urlpattern-polyfill";
+globalThis.addEventListener = () => {};
+import { n as version, t as name } from "./deno-CrjRl2cm.mjs";
+import "./key-C9oV7wk8.mjs";
 import { CryptographicKey, Object as Object$1, isActor } from "@fedify/vocab";
-import { getDocumentLoader } from "@fedify/vocab-runtime";
 import { SpanKind, SpanStatusCode, trace } from "@opentelemetry/api";
-
+import { getDocumentLoader } from "@fedify/vocab-runtime";
 //#region src/sig/owner.ts
 /**
 * Checks if the actor of the given activity owns the specified key.
@@ -17,9 +15,7 @@ import { SpanKind, SpanStatusCode, trace } from "@opentelemetry/api";
 * @returns Whether the actor is the owner of the key.
 */
 async function doesActorOwnKey(activity, key, options) {
-	const tracerProvider = options.tracerProvider ?? trace.getTracerProvider();
-	const tracer = tracerProvider.getTracer(deno_default.name, deno_default.version);
-	return await tracer.startActiveSpan("activitypub.verify_key_ownership", {
+	return await (options.tracerProvider ?? trace.getTracerProvider()).getTracer(name, version).startActiveSpan("activitypub.verify_key_ownership", {
 		kind: SpanKind.INTERNAL,
 		attributes: {
 			"activitypub.actor.id": activity.actorId?.href ?? "",
@@ -100,9 +96,9 @@ async function getKeyOwner(keyId, options) {
 					contextLoader,
 					tracerProvider
 				});
-			} catch (e$1) {
-				if (e$1 instanceof TypeError) return null;
-				throw e$1;
+			} catch (e) {
+				if (e instanceof TypeError) return null;
+				throw e;
 			}
 		}
 	}
@@ -120,6 +116,5 @@ async function getKeyOwner(keyId, options) {
 	for (const kid of owner.publicKeyIds) if (kid.href === keyId.href) return owner;
 	return null;
 }
-
 //#endregion
-export { doesActorOwnKey, getKeyOwner };
+export { getKeyOwner as n, doesActorOwnKey as t };

package/dist/{owner-1AbPBOOZ.d.cts → owner-CptqhsOy.d.cts}

@@ -63,4 +63,4 @@ interface GetKeyOwnerOptions {
 */
 declare function getKeyOwner(keyId: URL | CryptographicKey, options: GetKeyOwnerOptions): Promise<Actor | null>;
 //#endregion
-export { DoesActorOwnKeyOptions, GetKeyOwnerOptions, doesActorOwnKey, getKeyOwner };
+export { getKeyOwner as i, GetKeyOwnerOptions as n, doesActorOwnKey as r, DoesActorOwnKeyOptions as t };

package/dist/{proof-DLL0MLmV.js → proof-9SGtq4tE.mjs}

@@ -1,16 +1,13 @@
-
-      import { Temporal } from "@js-temporal/polyfill";
-      import { URLPattern } from "urlpattern-polyfill";
-      globalThis.addEventListener = () => {};
-    
-import { deno_default } from "./deno-4w047OFk.js";
-import { fetchKey, validateCryptoKey } from "./key-D7Y_J9kt.js";
+import { Temporal } from "@js-temporal/polyfill";
+import "urlpattern-polyfill";
+globalThis.addEventListener = () => {};
+import { n as version, t as name } from "./deno-CrjRl2cm.mjs";
+import { a as validateCryptoKey, n as fetchKey } from "./key-C9oV7wk8.mjs";
 import { Activity, DataIntegrityProof, Multikey, getTypeId } from "@fedify/vocab";
-import { getLogger } from "@logtape/logtape";
 import { SpanStatusCode, trace } from "@opentelemetry/api";
+import { getLogger } from "@logtape/logtape";
 import { encodeHex } from "byte-encodings/hex";
 import serialize from "json-canon";
-
 //#region src/sig/proof.ts
 const logger = getLogger([
 	"fedify",
@@ -27,29 +24,27 @@ const logger = getLogger([
 * @throws {TypeError} If the private key is invalid or unsupported.
 * @since 0.10.0
 */
-async function createProof(object, privateKey, keyId, { contextLoader, context: context$1, created } = {}) {
+async function createProof(object, privateKey, keyId, { contextLoader, context, created } = {}) {
 	validateCryptoKey(privateKey, "private");
 	if (privateKey.algorithm.name !== "Ed25519") throw new TypeError("Unsupported algorithm: " + privateKey.algorithm.name);
-	const objectWithoutProofs = object.clone({ proofs: [] });
-	const compactMsg = await objectWithoutProofs.toJsonLd({
+	const compactMsg = await object.clone({ proofs: [] }).toJsonLd({
 		format: "compact",
 		contextLoader,
-		context: context$1
+		context
 	});
 	const msgCanon = serialize(compactMsg);
 	const encoder = new TextEncoder();
 	const msgBytes = encoder.encode(msgCanon);
 	const msgDigest = await crypto.subtle.digest("SHA-256", msgBytes);
 	created ??= Temporal.Now.instant();
-	const proofConfig = {
+	const proofCanon = serialize({
 		"@context": compactMsg["@context"],
 		type: "DataIntegrityProof",
 		cryptosuite: "eddsa-jcs-2022",
 		verificationMethod: keyId.href,
 		proofPurpose: "assertionMethod",
 		created: created.toString()
-	};
-	const proofCanon = serialize(proofConfig);
+	});
 	const proofBytes = encoder.encode(proofCanon);
 	const proofDigest = await crypto.subtle.digest("SHA-256", proofBytes);
 	const digest = new Uint8Array(proofDigest.byteLength + msgDigest.byteLength);
@@ -75,13 +70,11 @@ async function createProof(object, privateKey, keyId, { contextLoader, context:
 * @since 0.10.0
 */
 async function signObject(object, privateKey, keyId, options = {}) {
-	const tracerProvider = options.tracerProvider ?? trace.getTracerProvider();
-	const tracer = tracerProvider.getTracer(deno_default.name, deno_default.version);
-	return await tracer.startActiveSpan("object_integrity_proofs.sign", { attributes: { "activitypub.object.type": getTypeId(object).href } }, async (span) => {
+	return await (options.tracerProvider ?? trace.getTracerProvider()).getTracer(name, version).startActiveSpan("object_integrity_proofs.sign", { attributes: { "activitypub.object.type": getTypeId(object).href } }, async (span) => {
 		try {
 			if (object.id != null) span.setAttribute("activitypub.object.id", object.id.href);
 			const existingProofs = [];
-			for await (const proof$1 of object.getProofs(options)) existingProofs.push(proof$1);
+			for await (const proof of object.getProofs(options)) existingProofs.push(proof);
 			const proof = await createProof(object, privateKey, keyId, options);
 			if (span.isRecording()) {
 				if (proof.cryptosuite != null) span.setAttribute("object_integrity_proofs.cryptosuite", proof.cryptosuite);
@@ -111,9 +104,7 @@ async function signObject(object, privateKey, keyId, options = {}) {
 * @since 0.10.0
 */
 async function verifyProof(jsonLd, proof, options = {}) {
-	const tracerProvider = options.tracerProvider ?? trace.getTracerProvider();
-	const tracer = tracerProvider.getTracer(deno_default.name, deno_default.version);
-	return await tracer.startActiveSpan("object_integrity_proofs.verify", async (span) => {
+	return await (options.tracerProvider ?? trace.getTracerProvider()).getTracer(name, version).startActiveSpan("object_integrity_proofs.verify", async (span) => {
 		if (span.isRecording()) {
 			if (proof.cryptosuite != null) span.setAttribute("object_integrity_proofs.cryptosuite", proof.cryptosuite);
 			if (proof.verificationMethodId != null) span.setAttribute("object_integrity_proofs.key_id", proof.verificationMethodId.href);
@@ -137,15 +128,14 @@ async function verifyProof(jsonLd, proof, options = {}) {
 async function verifyProofInternal(jsonLd, proof, options) {
 	if (typeof jsonLd !== "object" || proof.cryptosuite !== "eddsa-jcs-2022" || proof.verificationMethodId == null || proof.proofPurpose !== "assertionMethod" || proof.proofValue == null || proof.created == null) return null;
 	const publicKeyPromise = fetchKey(proof.verificationMethodId, Multikey, options);
-	const proofConfig = {
+	const proofCanon = serialize({
 		"@context": jsonLd["@context"],
 		type: "DataIntegrityProof",
 		cryptosuite: proof.cryptosuite,
 		verificationMethod: proof.verificationMethodId.href,
 		proofPurpose: proof.proofPurpose,
 		created: proof.created.toString()
-	};
-	const proofCanon = serialize(proofConfig);
+	});
 	const encoder = new TextEncoder();
 	const proofBytes = encoder.encode(proofCanon);
 	const proofDigest = await crypto.subtle.digest("SHA-256", proofBytes);
@@ -196,8 +186,7 @@ async function verifyProofInternal(jsonLd, proof, options) {
 		});
 		return null;
 	}
-	const verified = await crypto.subtle.verify("Ed25519", publicKey.publicKey, proof.proofValue.slice(), digest);
-	if (!verified) {
+	if (!await crypto.subtle.verify("Ed25519", publicKey.publicKey, proof.proofValue.slice(), digest)) {
 		if (fetchedKey.cached) {
 			logger.debug("Failed to verify the proof with the cached key {keyId}; retrying with the freshly fetched key...", {
 				keyId: proof.verificationMethodId.href,
@@ -234,7 +223,7 @@ async function verifyProofInternal(jsonLd, proof, options) {
 * @since 0.10.0
 */
 async function verifyObject(cls, jsonLd, options = {}) {
-	const logger$1 = getLogger([
+	const logger = getLogger([
 		"fedify",
 		"sig",
 		"proof"
@@ -246,17 +235,16 @@ async function verifyObject(cls, jsonLd, options = {}) {
 		const key = await verifyProof(jsonLd, proof, options);
 		if (key === null) return null;
 		if (key.controllerId == null) {
-			logger$1.debug("Key {keyId} does not have a controller.", { keyId: key.id?.href });
+			logger.debug("Key {keyId} does not have a controller.", { keyId: key.id?.href });
 			continue;
 		}
 		attributions.delete(key.controllerId.href);
 	}
 	if (attributions.size > 0) {
-		logger$1.debug("Some attributions are not authenticated by the proofs: {attributions}.", { attributions: [...attributions] });
+		logger.debug("Some attributions are not authenticated by the proofs: {attributions}.", { attributions: [...attributions] });
 		return null;
 	}
 	return object;
 }
-
 //#endregion
-export { createProof, signObject, verifyObject, verifyProof };
+export { verifyProof as i, signObject as n, verifyObject as r, createProof as t };