@fedify/fedify 2.4.0-pr.936.41 → 2.5.0-dev.2271

package/dist/verification-Dpfcw8ml.mjs

@@ -0,0 +1,105 @@
+import "temporal-polyfill";
+import "urlpattern-polyfill";
+globalThis.addEventListener = () => {};
+import { CryptographicKey } from "@fedify/vocab";
+//#region src/sig/verification.ts
+const verificationObservation = Symbol("verificationObservation");
+function snapshotKey(key) {
+	if (key.publicKey == null) throw new TypeError("Verification key has no public key.");
+	const id = key.id == null ? null : new URL(key.id.href);
+	return key instanceof CryptographicKey ? {
+		type: "cryptographicKey",
+		id,
+		ownerId: key.ownerId == null ? null : new URL(key.ownerId.href),
+		publicKey: key.publicKey
+	} : {
+		type: "multikey",
+		id,
+		controllerId: key.controllerId == null ? null : new URL(key.controllerId.href),
+		publicKey: key.publicKey
+	};
+}
+function triedKey(options, key) {
+	const check = options[verificationObservation]?.check;
+	if (check != null) check.triedKeys.push(snapshotKey(key));
+}
+async function observeCheck(options, identity, declaredKeyId, operation) {
+	const observation = options[verificationObservation];
+	if (observation?.attempt == null) return await operation(observation ?? { attempts: [] });
+	const check = {
+		identity,
+		declaredKeyId,
+		triedKeys: []
+	};
+	const base = {
+		...identity,
+		declaredKeyId,
+		triedKeys: check.triedKeys
+	};
+	try {
+		const key = await operation({
+			...observation,
+			check
+		});
+		observation.attempt.checks.push(key == null ? {
+			...base,
+			status: "rejected",
+			reason: check.reason ?? { type: "invalidSignature" }
+		} : {
+			...base,
+			status: "verified",
+			key: check.triedKeys.at(-1) ?? snapshotKey(key)
+		});
+		return key;
+	} catch (error) {
+		observation.attempt.checks.push({
+			...base,
+			status: "error",
+			error
+		});
+		throw error;
+	}
+}
+async function observeAttempt(options, mechanism, operation, isVerified) {
+	const observation = options[verificationObservation];
+	if (observation == null) return await operation({ attempts: [] });
+	const attempt = { checks: [] };
+	const base = {
+		mechanism,
+		subject: observation.subject == null ? {
+			id: null,
+			pointer: ""
+		} : {
+			id: observation.subject.id == null ? null : new URL(observation.subject.id.href),
+			pointer: observation.subject.pointer
+		},
+		checks: attempt.checks
+	};
+	try {
+		const value = await operation({
+			...observation,
+			subject: base.subject,
+			attempt,
+			check: void 0
+		});
+		observation.attempts.push(isVerified(value) ? {
+			...base,
+			status: "verified",
+			signatures: attempt.checks.filter((check) => check.status === "verified")
+		} : {
+			...base,
+			status: "rejected",
+			reason: attempt.reason ?? { type: "signatureVerificationFailed" }
+		});
+		return value;
+	} catch (error) {
+		observation.attempts.push({
+			...base,
+			status: "error",
+			error
+		});
+		throw error;
+	}
+}
+//#endregion
+export { verificationObservation as a, triedKey as i, observeCheck as n, snapshotKey as r, observeAttempt as t };

package/dist/vocab/cjs.test.mjs

@@ -5,7 +5,7 @@ import { createRequire } from "node:module";
 import { strictEqual } from "node:assert";
 import { test } from "@fedify/fixture";
 //#region src/vocab/cjs.test.ts
-test("CommonJS vocab entry exports Object", { ignore: "Deno" in globalThis }, () => {
+test("CommonJS vocab entry exports Object", { ignore: "Deno" in globalThis || "navigator" in globalThis && navigator.userAgent === "Cloudflare-Workers" }, () => {
 	const vocab = createRequire(import.meta.url)("./mod.cjs");
 	strictEqual(typeof vocab.Object, "function");
 	strictEqual(typeof vocab.Update, "function");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fedify/fedify",
-  "version": "2.4.0-pr.936.41+59c7432c",
+  "version": "2.5.0-dev.2271+49d937e2",
   "description": "An ActivityPub server framework",
   "keywords": [
     "ActivityPub",
@@ -151,15 +151,15 @@
     "structured-field-values": "^2.0.4",
     "temporal-polyfill": "^1.0.1",
     "urlpattern-polyfill": "^10.1.0",
-    "@fedify/uri-template": "2.4.0-pr.936.41+59c7432c",
-    "@fedify/vocab-runtime": "2.4.0-pr.936.41+59c7432c",
-    "@fedify/webfinger": "2.4.0-pr.936.41+59c7432c",
-    "@fedify/vocab": "2.4.0-pr.936.41+59c7432c"
+    "@fedify/uri-template": "2.5.0-dev.2271+49d937e2",
+    "@fedify/webfinger": "2.5.0-dev.2271+49d937e2",
+    "@fedify/vocab-runtime": "2.5.0-dev.2271+49d937e2",
+    "@fedify/vocab": "2.5.0-dev.2271+49d937e2"
   },
   "devDependencies": {
     "@std/assert": "npm:@jsr/std__assert@^0.226.0",
     "@std/path": "npm:@jsr/std__path@^1.0.6",
-    "@types/node": "^24.2.1",
+    "@types/node": "^24.12.2",
     "fetch-mock": "^12.5.4",
     "miniflare": "^4.20250523.0",
     "tsdown": "^0.22.0",
@@ -167,7 +167,7 @@
     "typescript": "^6.0.0",
     "wrangler": "^4.17.0",
     "@fedify/fixture": "2.0.0",
-    "@fedify/vocab-tools": "^2.4.0-pr.936.41+59c7432c"
+    "@fedify/vocab-tools": "^2.5.0-dev.2271+49d937e2"
   },
   "scripts": {
     "build:self": "tsdown",
@@ -177,6 +177,6 @@
     "test": "cd dist/ && node --test",
     "pretest:bun": "pnpm build",
     "test:bun": "cd dist/ && bun test --timeout 60000",
-    "test:cfworkers": "deno task codegen && wrangler deploy --dry-run --outdir src/cfworkers && node --import=tsx src/cfworkers/client.ts"
+    "test:cfworkers": "deno task codegen && wrangler deploy --dry-run --outdir src/cfworkers && node --import=tsx scripts/check_cfworkers.ts && node --import=tsx src/cfworkers/client.ts"
   }
 }

package/dist/assert_rejects-EgstcQy5.mjs

@@ -1,82 +0,0 @@
-import "temporal-polyfill";
-import "urlpattern-polyfill";
-globalThis.addEventListener = () => {};
-import { l as AssertionError, s as format } from "./assert_equals-BV7oLMxm.mjs";
-import { n as assertIsError } from "./assert_throws-NiFfqbnH.mjs";
-//#region ../../node_modules/.pnpm/@jsr+std__assert@0.226.0/node_modules/@jsr/std__assert/assert_false.js
-/**
-* Make an assertion, error will be thrown if `expr` have truthy value.
-*
-* @example Usage
-* ```ts no-eval
-* import { assertFalse } from "@std/assert/assert-false";
-*
-* assertFalse(false); // Doesn't throw
-* assertFalse(true); // Throws
-* ```
-*
-* @param expr The expression to test.
-* @param msg The optional message to display if the assertion fails.
-*/ function assertFalse(expr, msg = "") {
-	if (expr) throw new AssertionError(msg);
-}
-//#endregion
-//#region ../../node_modules/.pnpm/@jsr+std__assert@0.226.0/node_modules/@jsr/std__assert/assert_greater_or_equal.js
-/**
-* Make an assertion that `actual` is greater than or equal to `expected`.
-* If not then throw.
-*
-* @example Usage
-* ```ts no-eval
-* import { assertGreaterOrEqual } from "@std/assert/assert-greater-or-equal";
-*
-* assertGreaterOrEqual(2, 1); // Doesn't throw
-* assertGreaterOrEqual(1, 1); // Doesn't throw
-* assertGreaterOrEqual(0, 1); // Throws
-* ```
-*
-* @typeParam T The type of the values to compare.
-* @param actual The actual value to compare.
-* @param expected The expected value to compare.
-* @param msg The optional message to display if the assertion fails.
-*/ function assertGreaterOrEqual(actual, expected, msg) {
-	if (actual >= expected) return;
-	const actualString = format(actual);
-	const expectedString = format(expected);
-	throw new AssertionError(msg ?? `Expect ${actualString} >= ${expectedString}`);
-}
-//#endregion
-//#region ../../node_modules/.pnpm/@jsr+std__assert@0.226.0/node_modules/@jsr/std__assert/assert_rejects.js
-async function assertRejects(fn, errorClassOrMsg, msgIncludesOrMsg, msg) {
-	let ErrorClass = void 0;
-	let msgIncludes = void 0;
-	let err;
-	if (typeof errorClassOrMsg !== "string") {
-		if (errorClassOrMsg === void 0 || errorClassOrMsg.prototype instanceof Error || errorClassOrMsg.prototype === Error.prototype) {
-			ErrorClass = errorClassOrMsg;
-			msgIncludes = msgIncludesOrMsg;
-		}
-	} else msg = errorClassOrMsg;
-	let doesThrow = false;
-	let isPromiseReturned = false;
-	const msgSuffix = msg ? `: ${msg}` : ".";
-	try {
-		const possiblePromise = fn();
-		if (possiblePromise && typeof possiblePromise === "object" && typeof possiblePromise.then === "function") {
-			isPromiseReturned = true;
-			await possiblePromise;
-		} else throw Error();
-	} catch (error) {
-		if (!isPromiseReturned) throw new AssertionError(`Function throws when expected to reject${msgSuffix}`);
-		if (ErrorClass) {
-			if (!(error instanceof Error)) throw new AssertionError(`A non-Error object was rejected${msgSuffix}`);
-			assertIsError(error, ErrorClass, msgIncludes, msg);
-		}
-		err = error;
-		doesThrow = true;
-	}
-	if (!doesThrow) throw new AssertionError(`Expected function to reject${msgSuffix}`);
-	return err;
-}
-//#endregion
-export { assertGreaterOrEqual as n, assertFalse as r, assertRejects as t };

package/dist/docloader-e1khNUKy.mjs

@@ -1,49 +0,0 @@
-import "temporal-polyfill";
-import "urlpattern-polyfill";
-globalThis.addEventListener = () => {};
-import { o as validateCryptoKey } from "./key-DfPsX8hv.mjs";
-import { n as doubleKnock } from "./http-CPVMUgsW.mjs";
-import { getLogger } from "@logtape/logtape";
-import { curry } from "es-toolkit";
-import { UrlError, createActivityPubRequest, getRemoteDocument, logRequest, validatePublicUrl } from "@fedify/vocab-runtime";
-//#region src/utils/docloader.ts
-const logger = getLogger([
-	"fedify",
-	"utils",
-	"docloader"
-]);
-/**
-* Gets an authenticated {@link DocumentLoader} for the given identity.
-* Note that an authenticated document loader intentionally does not cache
-* the fetched documents.
-* @param identity The identity to get the document loader for.
-*                 The actor's key pair.
-* @param options The options for the document loader.
-* @returns The authenticated document loader.
-* @throws {TypeError} If the key is invalid or unsupported.
-* @since 0.4.0
-*/
-function getAuthenticatedDocumentLoader(identity, { allowPrivateAddress, maxRedirection, userAgent, specDeterminer, tracerProvider } = {}) {
-	validateCryptoKey(identity.privateKey);
-	async function load(url, options) {
-		if (!allowPrivateAddress) try {
-			await validatePublicUrl(url);
-		} catch (error) {
-			if (error instanceof UrlError) logger.error("Disallowed private URL: {url}", {
-				url,
-				error
-			});
-			throw error;
-		}
-		return getRemoteDocument(url, await doubleKnock(createActivityPubRequest(url, { userAgent }), identity, {
-			maxRedirection,
-			specDeterminer,
-			log: curry(logRequest)(logger),
-			tracerProvider,
-			signal: options?.signal
-		}), load);
-	}
-	return load;
-}
-//#endregion
-export { getAuthenticatedDocumentLoader as t };