@fedify/vocab-tools 2.0.0-pr.458.1785

package/dist/mod.cjs

@@ -0,0 +1,1941 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+const node_fs_promises = __toESM(require("node:fs/promises"));
+const byte_encodings_base58 = __toESM(require("byte-encodings/base58"));
+const __cfworker_json_schema = __toESM(require("@cfworker/json-schema"));
+const node_path = __toESM(require("node:path"));
+const node_url = __toESM(require("node:url"));
+const yaml = __toESM(require("yaml"));
+const es_toolkit = __toESM(require("es-toolkit"));
+
+//#region deno.json
+var name = "@fedify/vocab-tools";
+var version = "2.0.0-pr.458.1785+f5e97597";
+var license = "MIT";
+var exports$1 = { ".": "./src/mod.ts" };
+var author = {
+	"name": "Hong Minhee",
+	"email": "hong@minhee.org",
+	"url": "https://hongminhee.org/"
+};
+var imports = {
+	"@cfworker/json-schema": "npm:@cfworker/json-schema@^4.1.1",
+	"byte-encodings": "npm:byte-encodings@^1.0.11",
+	"es-toolkit": "npm:es-toolkit@^1.39.10",
+	"yaml": "npm:yaml@^2.8.1"
+};
+var exclude = [
+	"dist",
+	"node_modules",
+	"src/schema.yaml"
+];
+var tasks = {
+	"check": "deno fmt --check && deno lint && deno check src/*.ts",
+	"test": "deno test -A"
+};
+var deno_default = {
+	name,
+	version,
+	license,
+	exports: exports$1,
+	author,
+	imports,
+	exclude,
+	tasks
+};
+
+//#endregion
+//#region src/type.ts
+const HEURISTICS_CONTEXTS = [
+	"https://www.w3.org/ns/activitystreams",
+	"https://w3id.org/security/v1",
+	"https://w3id.org/security/data-integrity/v1",
+	"https://www.w3.org/ns/did/v1",
+	"https://w3id.org/security/multikey/v1"
+];
+const scalarTypes = {
+	"http://www.w3.org/2001/XMLSchema#boolean": {
+		name: "boolean",
+		typeGuard(v) {
+			return `typeof ${v} === "boolean"`;
+		},
+		encoder(v) {
+			return `{ "@value": ${v} }`;
+		},
+		compactEncoder(v) {
+			return v;
+		},
+		dataCheck(v) {
+			return `typeof ${v} === "object" && "@value" in ${v}
+        && typeof ${v}["@value"] === "boolean"`;
+		},
+		decoder(v) {
+			return `${v}["@value"]`;
+		}
+	},
+	"http://www.w3.org/2001/XMLSchema#integer": {
+		name: "number",
+		typeGuard(v) {
+			return `typeof ${v} === "number" && Number.isInteger(${v})`;
+		},
+		encoder(v) {
+			return `{
+        "@type": "http://www.w3.org/2001/XMLSchema#integer",
+        "@value": ${v},
+      }`;
+		},
+		compactEncoder(v) {
+			return v;
+		},
+		dataCheck(v) {
+			return `typeof ${v} === "object" && "@type" in ${v}
+        && ${v}["@type"] === "http://www.w3.org/2001/XMLSchema#integer"
+        && "@value" in ${v} && typeof ${v}["@value"] === "number"`;
+		},
+		decoder(v) {
+			return `${v}["@value"] as number`;
+		}
+	},
+	"http://www.w3.org/2001/XMLSchema#nonNegativeInteger": {
+		name: "number",
+		typeGuard(v) {
+			return `typeof ${v} === "number" && Number.isInteger(${v}) && ${v} >= 0`;
+		},
+		encoder(v) {
+			return `{
+        "@type": "http://www.w3.org/2001/XMLSchema#nonNegativeInteger",
+        "@value": ${v},
+      }`;
+		},
+		compactEncoder(v) {
+			return v;
+		},
+		dataCheck(v) {
+			return `typeof ${v} === "object" && "@type" in ${v}
+        && ${v}["@type"] === "http://www.w3.org/2001/XMLSchema#nonNegativeInteger"
+        && "@value" in ${v} && typeof ${v}["@value"] === "number"`;
+		},
+		decoder(v) {
+			return `${v}["@value"]`;
+		}
+	},
+	"http://www.w3.org/2001/XMLSchema#float": {
+		name: "number",
+		typeGuard(v) {
+			return `typeof ${v} === "number" && !Number.isNaN(${v})`;
+		},
+		encoder(v) {
+			return `{
+        "@type": "http://www.w3.org/2001/XMLSchema#float",
+        "@value": ${v},
+      }`;
+		},
+		compactEncoder(v) {
+			return v;
+		},
+		dataCheck(v) {
+			return `typeof ${v} === "object" && "@type" in ${v}
+        && ${v}["@type"] === "http://www.w3.org/2001/XMLSchema#float"
+        && "@value" in ${v} && typeof ${v}["@value"] === "number"`;
+		},
+		decoder(v) {
+			return `${v}["@value"]`;
+		}
+	},
+	"http://www.w3.org/2001/XMLSchema#string": {
+		name: "string",
+		typeGuard(v) {
+			return `typeof ${v} === "string"`;
+		},
+		encoder(v) {
+			return `{ "@value": ${v} }`;
+		},
+		compactEncoder(v) {
+			return v;
+		},
+		dataCheck(v) {
+			return `typeof ${v} === "object" && "@value" in ${v}
+        && typeof ${v}["@value"] === "string" && !("@language" in ${v})`;
+		},
+		decoder(v) {
+			return `${v}["@value"]`;
+		}
+	},
+	"http://www.w3.org/2001/XMLSchema#anyURI": {
+		name: "URL",
+		typeGuard(v) {
+			return `${v} instanceof URL`;
+		},
+		encoder(v) {
+			return `{ "@id": ${v}.href }`;
+		},
+		compactEncoder(v) {
+			return `${v}.href`;
+		},
+		dataCheck(v) {
+			return `typeof ${v} === "object" && "@id" in ${v}
+        && typeof ${v}["@id"] === "string"
+        && ${v}["@id"] !== ""`;
+		},
+		decoder(v, baseUrlVar) {
+			return `${v}["@id"].startsWith("at://")
+        ? new URL("at://" +
+          encodeURIComponent(
+            ${v}["@id"].includes("/", 5)
+              ? ${v}["@id"].slice(5, ${v}["@id"].indexOf("/", 5))
+              : ${v}["@id"].slice(5)
+          ) +
+          (
+            ${v}["@id"].includes("/", 5)
+              ? ${v}["@id"].slice(${v}["@id"].indexOf("/", 5))
+              : ""
+          )
+        )
+        : URL.canParse(${v}["@id"]) && ${baseUrlVar}
+          ? new URL(${v}["@id"])
+          : new URL(${v}["@id"], ${baseUrlVar})`;
+		}
+	},
+	"http://www.w3.org/1999/02/22-rdf-syntax-ns#langString": {
+		name: "LanguageString",
+		typeGuard(v) {
+			return `${v} instanceof LanguageString`;
+		},
+		encoder(v) {
+			return `{
+        "@value": ${v}.toString(),
+        "@language": ${v}.locale.baseName,
+      }`;
+		},
+		dataCheck(v) {
+			return `typeof ${v} === "object" && "@language" in ${v} && "@value" in ${v}
+        && typeof ${v}["@language"] === "string"
+        && typeof ${v}["@value"] === "string"`;
+		},
+		decoder(v) {
+			return `new LanguageString(${v}["@value"], ${v}["@language"])`;
+		}
+	},
+	"http://www.w3.org/2001/XMLSchema#dateTime": {
+		name: "Temporal.Instant",
+		typeGuard(v) {
+			return `${v} instanceof Temporal.Instant`;
+		},
+		encoder(v) {
+			return `{
+        "@type": "http://www.w3.org/2001/XMLSchema#dateTime",
+        "@value": ${v}.toString(),
+      }`;
+		},
+		compactEncoder(v) {
+			return `${v}.toString()`;
+		},
+		dataCheck(v) {
+			return `typeof ${v} === "object" && "@type" in ${v}
+        && "@value" in ${v} && typeof ${v}["@value"] === "string"
+        && ${v}["@type"] === "http://www.w3.org/2001/XMLSchema#dateTime"
+        // Check if the value is a valid RFC 3339 date-time string
+        && new Date(${v}["@value"]).toString() !== "Invalid Date"
+        `;
+		},
+		decoder(v) {
+			return `Temporal.Instant.from(
+        ${v}["@value"].substring(19).match(/[Z+-]/)
+          ? ${v}["@value"]
+          : ${v}["@value"] + "Z"
+      )`;
+		}
+	},
+	"http://www.w3.org/2001/XMLSchema#duration": {
+		name: "Temporal.Duration",
+		typeGuard(v) {
+			return `${v} instanceof Temporal.Duration`;
+		},
+		encoder(v) {
+			return `{
+        "@type": "http://www.w3.org/2001/XMLSchema#duration",
+        "@value": ${v}.toString(),
+      }`;
+		},
+		compactEncoder(v) {
+			return `${v}.toString()`;
+		},
+		dataCheck(v) {
+			return `typeof ${v} === "object" && "@type" in ${v}
+        && "@value" in ${v} && typeof ${v}["@value"] === "string"
+        && ${v}["@type"] === "http://www.w3.org/2001/XMLSchema#duration"`;
+		},
+		decoder(v) {
+			return `Temporal.Duration.from(${v}["@value"])`;
+		}
+	},
+	"https://w3id.org/security#cryptosuiteString": {
+		name: "\"eddsa-jcs-2022\"",
+		typeGuard(v) {
+			return `${v} == "eddsa-jcs-2022"`;
+		},
+		encoder(v) {
+			return `{ "@value": ${v} }`;
+		},
+		compactEncoder(v) {
+			return v;
+		},
+		dataCheck(v) {
+			return `typeof ${v} === "object" && "@value" in ${v}
+        && !("@language" in ${v}) && ${v}["@value"] === "eddsa-jcs-2022"`;
+		},
+		decoder(v) {
+			return `${v}["@value"]`;
+		}
+	},
+	"https://w3id.org/security#multibase": {
+		name: "Uint8Array",
+		typeGuard(v) {
+			return `${v} instanceof Uint8Array`;
+		},
+		encoder(v) {
+			return `{
+        "@type": "https://w3id.org/security#multibase",
+        "@value": new TextDecoder().decode(encodeMultibase("base58btc", ${v})),
+      }`;
+		},
+		compactEncoder(v) {
+			return `new TextDecoder().decode(encodeMultibase("base58btc", ${v}))`;
+		},
+		dataCheck(v) {
+			return `typeof ${v} === "object" && "@value" in ${v}
+        && typeof ${v}["@value"] === "string"`;
+		},
+		decoder(v) {
+			return `decodeMultibase(${v}["@value"])`;
+		}
+	},
+	"fedify:langTag": {
+		name: "Intl.Locale",
+		typeGuard(v) {
+			return `${v} instanceof Intl.Locale`;
+		},
+		encoder(v) {
+			return `{ "@value": ${v}.baseName }`;
+		},
+		compactEncoder(v) {
+			return `${v}.baseName`;
+		},
+		dataCheck(v) {
+			return `typeof ${v} === "object" && "@value" in ${v}
+        && typeof ${v}["@value"] === "string" && !("@language" in ${v})`;
+		},
+		decoder(v) {
+			return `new Intl.Locale(${v}["@value"])`;
+		}
+	},
+	"fedify:url": {
+		name: "URL",
+		typeGuard(v) {
+			return `${v} instanceof URL`;
+		},
+		encoder(v) {
+			return `{ "@value": ${v}.href }`;
+		},
+		compactEncoder(v) {
+			return `${v}.href`;
+		},
+		dataCheck(v) {
+			return `typeof ${v} === "object" && "@value" in ${v}
+        && typeof ${v}["@value"] === "string"
+        && ${v}["@value"] !== "" && ${v}["@value"] !== "/"`;
+		},
+		decoder(v) {
+			return `new URL(${v}["@value"])`;
+		}
+	},
+	"fedify:publicKey": {
+		name: "CryptoKey",
+		typeGuard(v) {
+			return `
+        // @ts-ignore: CryptoKey exists in the global scope.
+        ${v} instanceof CryptoKey
+      `;
+		},
+		encoder(v) {
+			return `{ "@value": await exportSpki(${v}) }`;
+		},
+		compactEncoder(v) {
+			return `await exportSpki(${v})`;
+		},
+		dataCheck(v) {
+			return `typeof ${v} === "object" && "@value" in ${v}
+        && typeof ${v}["@value"] === "string"`;
+		},
+		decoder(v) {
+			return `await importPem(${v}["@value"])`;
+		}
+	},
+	"fedify:multibaseKey": {
+		name: "CryptoKey",
+		typeGuard(v) {
+			return `
+        // @ts-ignore: CryptoKey exists in the global scope.
+        ${v} instanceof CryptoKey
+      `;
+		},
+		encoder(v) {
+			return `{
+        "@type": "https://w3id.org/security#multibase",
+        "@value": await exportMultibaseKey(${v}),
+      }`;
+		},
+		compactEncoder(v) {
+			return `await exportMultibaseKey(${v})`;
+		},
+		dataCheck(v) {
+			return `typeof ${v} === "object" && "@value" in ${v}
+        && typeof ${v}["@value"] === "string"`;
+		},
+		decoder(v) {
+			return `await importMultibaseKey(${v}["@value"])`;
+		}
+	},
+	"fedify:proofPurpose": {
+		name: "\"assertionMethod\" | \"authentication\" | \"capabilityInvocation\" | \"capabilityDelegation\" | \"keyAgreement\"",
+		typeGuard(v) {
+			return `${v} === "assertionMethod" || ${v} === "authentication" ||
+        ${v} === "capabilityInvocation" || ${v} === "capabilityDelegation" ||
+        ${v} === "keyAgreement"`;
+		},
+		encoder(v) {
+			return `{
+        "@id": "https://w3id.org/security#" + ${v},
+      }`;
+		},
+		compactEncoder(v) {
+			return v;
+		},
+		dataCheck(v) {
+			return `typeof ${v} === "object" && "@id" in ${v}
+        && typeof ${v}["@id"] === "string"
+        && ${v}["@id"].startsWith("https://w3id.org/security#")
+        && [
+          "assertionMethod", "authentication", "capabilityInvocation",
+          "capabilityDelegation", "keyAgreement",
+        ].includes(${v}["@id"].substring(26))`;
+		},
+		decoder(v) {
+			return `${v}["@id"].substring(26)`;
+		}
+	},
+	"fedify:units": {
+		name: "\"cm\" | \"feet\" | \"inches\" | \"km\" | \"m\" | \"miles\"",
+		typeGuard(v) {
+			return `${v} == "cm" || ${v} == "feet" || ${v} == "inches" || ${v} == "km" || ${v} == "m" || ${v} == "miles"`;
+		},
+		encoder(v) {
+			return `{ "@value": ${v} }`;
+		},
+		compactEncoder(v) {
+			return v;
+		},
+		dataCheck(v) {
+			return `typeof ${v} === "object" && "@value" in ${v}
+      && (${v}["@value"] == "cm" || ${v}["@value"] == "feet" || ${v}["@value"] == "inches" || ${v}["@value"] == "km" || ${v}["@value"] == "m" || ${v}["@value"] == "miles")`;
+		},
+		decoder(v) {
+			return `${v}["@value"]`;
+		}
+	}
+};
+function getTypeName(typeUri, types) {
+	if (typeUri in types) return types[typeUri].name;
+	if (typeUri in scalarTypes) return scalarTypes[typeUri].name;
+	throw new Error(`Unknown type: ${typeUri}`);
+}
+function getTypeNames(typeUris, types, parentheses = false) {
+	if (typeUris.length < 1) return "never";
+	else if (typeUris.length === 1) return getTypeName(typeUris[0], types);
+	let typeNames = typeUris.map((typeUri) => getTypeName(typeUri, types));
+	typeNames = typeNames.filter((t$1, i) => typeNames.indexOf(t$1) === i);
+	const t = typeNames.join(" | ");
+	return parentheses && typeNames.length > 1 ? `(${t})` : t;
+}
+function isScalarType(typeUri, types) {
+	if (typeUri in scalarTypes) return true;
+	else if (typeUri in types) return !types[typeUri].entity;
+	throw new Error(`Unknown type: ${typeUri}`);
+}
+function areAllScalarTypes(typeUris, types) {
+	return typeUris.every((typeUri) => isScalarType(typeUri, types));
+}
+function isCompactableType(typeUri, types) {
+	if (typeUri in scalarTypes) return scalarTypes[typeUri].compactEncoder != null;
+	else if (typeUri in types) {
+		const type = types[typeUri];
+		if (type.compactName == null) return false;
+		else if (type.extends != null && !isCompactableType(type.extends, types)) return false;
+		const defaultContext = type.defaultContext;
+		return defaultContext != null && HEURISTICS_CONTEXTS.includes(defaultContext) || Array.isArray(defaultContext) && defaultContext.some(HEURISTICS_CONTEXTS.includes.bind(HEURISTICS_CONTEXTS));
+	}
+	throw new Error(`Unknown type: ${typeUri}`);
+}
+function getSubtypes(typeUri, types, excludeSelf = false) {
+	const subtypes = excludeSelf ? [] : [typeUri];
+	for (const uri in types) {
+		const type = types[uri];
+		if (type.extends === typeUri) subtypes.push(...getSubtypes(uri, types));
+	}
+	return subtypes.filter((t, i) => subtypes.indexOf(t) === i);
+}
+function getSupertypes(typeUri, types, excludeSelf = false) {
+	const supertypes = excludeSelf ? [] : [typeUri];
+	const type = types[typeUri];
+	if (type.extends) supertypes.push(...getSupertypes(type.extends, types));
+	return supertypes;
+}
+function* getAllProperties(typeUri, types, excludeSelf = false) {
+	for (const t of getSupertypes(typeUri, types, excludeSelf)) {
+		if (!(t in types)) continue;
+		for (const prop of types[t].properties) yield prop;
+	}
+}
+function getEncoder(typeUri, types, variable, optionsVariable, compact = false) {
+	if (typeUri in scalarTypes) return compact ? scalarTypes[typeUri].compactEncoder?.(variable) ?? scalarTypes[typeUri].encoder(variable) : scalarTypes[typeUri].encoder(variable);
+	if (typeUri in types) return compact ? `await ${variable}.toJsonLd({
+           ...(${optionsVariable}),
+           format: undefined,
+           context: undefined,
+         })` : `await ${variable}.toJsonLd(${optionsVariable})`;
+	throw new Error(`Unknown type: ${typeUri}`);
+}
+function getTypeGuard(typeUri, types, variable) {
+	if (typeUri in scalarTypes) return scalarTypes[typeUri].typeGuard(variable);
+	if (typeUri in types) return `${variable} instanceof ${types[typeUri].name}`;
+	throw new Error(`Unknown type: ${typeUri}`);
+}
+function getTypeGuards(typeUris, types, variable) {
+	return typeUris.map((t) => getTypeGuard(t, types, variable)).join(" || ");
+}
+function* getEncoders(typeUris, types, variable, optionsVariable, compact = false) {
+	let i = typeUris.length;
+	for (const typeUri of typeUris) {
+		if (--i > 0) {
+			yield getTypeGuard(typeUri, types, variable);
+			yield " ? ";
+		}
+		yield getEncoder(typeUri, types, variable, optionsVariable, compact);
+		if (i > 0) yield " : ";
+	}
+}
+function getDecoder(typeUri, types, variable, optionsVariable, baseUrlVariable) {
+	if (typeUri in scalarTypes) return scalarTypes[typeUri].decoder(variable, baseUrlVariable);
+	if (typeUri in types) return `await ${types[typeUri].name}.fromJsonLd(
+      ${variable},
+      { ...${optionsVariable}, baseUrl: ${baseUrlVariable} }
+    )`;
+	throw new Error(`Unknown type: ${typeUri}`);
+}
+function getDataCheck(typeUri, types, variable) {
+	if (typeUri in scalarTypes) return scalarTypes[typeUri].dataCheck(variable);
+	if (typeUri in types) {
+		const subtypes = getSubtypes(typeUri, types);
+		return `typeof ${variable} === "object" && "@type" in ${variable}
+      && Array.isArray(${variable}["@type"])` + (subtypes.length > 1 ? `&& ${JSON.stringify(subtypes)}.some(
+            t => ${variable}["@type"].includes(t))` : `&& ${variable}["@type"].includes(${JSON.stringify(typeUri)})`);
+	}
+	throw new Error(`Unknown type: ${typeUri}`);
+}
+function* getDecoders(typeUris, types, variable, optionsVariable, baseUrlVariable) {
+	for (const typeUri of typeUris) {
+		yield getDataCheck(typeUri, types, variable);
+		yield " ? ";
+		yield getDecoder(typeUri, types, variable, optionsVariable, baseUrlVariable);
+		yield " : ";
+	}
+	yield "undefined";
+}
+function emitOverride(typeUri, types) {
+	if (types[typeUri].extends == null) return "";
+	return "override";
+}
+
+//#endregion
+//#region src/field.ts
+async function getFieldName(propertyUri, prefix = "#") {
+	const hashedUri = await crypto.subtle.digest("SHA-1", new TextEncoder().encode(propertyUri));
+	const match = propertyUri.match(/#([A-Za-z0-9_]+)$/);
+	const suffix = match == null ? "" : `_${match[1]}`;
+	return `${prefix}_${(0, byte_encodings_base58.encodeBase58)(hashedUri)}${suffix}`;
+}
+async function generateField(property, types, prefix = "#") {
+	const fieldName = await getFieldName(property.uri, prefix);
+	if (areAllScalarTypes(property.range, types)) return `${fieldName}: (${getTypeNames(property.range, types, true)})[] = [];\n`;
+	else {
+		const typeNames = getTypeNames(property.range, types);
+		const trustFieldName = await getFieldName(property.uri, `${prefix}_trust`);
+		return `
+      ${fieldName}: (${typeNames} | URL)[] = [];
+      ${trustFieldName}: Set<number> = new Set();
+    `;
+	}
+}
+async function* generateFields(typeUri, types) {
+	const type = types[typeUri];
+	for (const property of type.properties) yield await generateField(property, types);
+}
+
+//#endregion
+//#region src/fs.ts
+/**
+* Recursively read a directory, yielding the paths of all files.  File paths
+* are relative to the directory, and directories are not yielded.
+* @param dir The directory to read.
+* @returns An async iterable of file paths.
+*/
+async function* readDirRecursive(dir) {
+	for (const entry of await (0, node_fs_promises.readdir)(dir, { withFileTypes: true })) if (entry.isDirectory()) {
+		const path = (0, node_path.join)(dir, entry.name);
+		for await (const subentry of readDirRecursive(path)) yield (0, node_path.join)(entry.name, subentry);
+	} else yield entry.name;
+}
+
+//#endregion
+//#region src/schema.ts
+/**
+* Type guard to check if a property is not functional (has pluralName).
+*/
+function isNonFunctionalProperty(property) {
+	return property.functional !== true;
+}
+/**
+* Type guard to check if a property has singular accessor.
+*/
+function hasSingularAccessor(property) {
+	if (property.functional === true) return true;
+	return isNonFunctionalProperty(property) && property.singularAccessor === true;
+}
+/**
+* An error that occurred while loading a schema file.
+*/
+var SchemaError = class extends Error {
+	/**
+	* The path of the schema file.
+	*/
+	path;
+	/**
+	* Constructs a new `SchemaError`.
+	* @param path The path of the schema file.
+	* @param message The error message.
+	*/
+	constructor(path, message) {
+		super(message);
+		this.path = path;
+	}
+};
+async function loadSchemaValidator() {
+	const thisFile = require("url").pathToFileURL(__filename).href;
+	const schemaFile = new URL(node_path.posix.join(node_path.posix.dirname(thisFile), "schema.yaml"));
+	let content;
+	if (schemaFile.protocol !== "file:") {
+		const response = await fetch(schemaFile);
+		content = await response.text();
+	} else content = await (0, node_fs_promises.readFile)((0, node_url.fileURLToPath)(schemaFile), { encoding: "utf-8" });
+	const schemaObject = (0, yaml.parse)(content);
+	return new __cfworker_json_schema.Validator(schemaObject);
+}
+let schemaValidator = void 0;
+async function loadSchema(path) {
+	const content = await (0, node_fs_promises.readFile)(path, { encoding: "utf-8" });
+	const schema = (0, yaml.parse)(content);
+	if (schemaValidator == null) schemaValidator = await loadSchemaValidator();
+	const result = schemaValidator.validate(schema);
+	const errors = [];
+	if (result.valid) return schema;
+	for (const e of result.errors) errors.push(new SchemaError(path, `${path}:${e.instanceLocation}: ${e.error}`));
+	throw new AggregateError(errors);
+}
+/**
+* Loads all schema files in the directory.
+* @param dir The path of the directory to load schema files from.
+* @returns A map from the qualified URI of a type to its {@link SchemaFile}.
+* @throws {@link AggregateError} if any schema file is invalid.  It contains
+*         all {@link SchemaError}s of the invalid schema files.
+*/
+async function loadSchemaFiles(dir) {
+	if (typeof dir !== "string") throw new TypeError("Expected a directory path in string");
+	const result = {};
+	const errors = [];
+	for await (const relPath of readDirRecursive(dir)) {
+		if (!relPath.match(/\.ya?ml$/i)) continue;
+		if (relPath.match(/(^|[/\\])schema.yaml$/i)) continue;
+		const path = (0, node_path.join)(dir, relPath);
+		let schema;
+		try {
+			schema = await loadSchema(path);
+		} catch (e) {
+			if (e instanceof AggregateError && e.errors.length > 0 && e.errors[0] instanceof SchemaError) {
+				errors.push(...e.errors);
+				continue;
+			}
+			throw e;
+		}
+		result[schema.uri] = schema;
+	}
+	if (errors.length > 0) throw new AggregateError(errors);
+	const entries = Object.entries(result);
+	entries.sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
+	return Object.fromEntries(entries);
+}
+
+//#endregion
+//#region src/codec.ts
+async function* generateEncoder(typeUri, types) {
+	const type = types[typeUri];
+	yield `
+  /**
+   * Converts this object to a JSON-LD structure.
+   * @param options The options to use.
+   *                - \`format\`: The format of the output: \`compact\` or
+                      \`expand\`.
+   *                - \`contextLoader\`: The loader for remote JSON-LD contexts.
+   *                - \`context\`: The JSON-LD context to use.  Not applicable
+                      when \`format\` is set to \`'expand'\`.
+   * @returns The JSON-LD representation of this object.
+   */
+  ${emitOverride(typeUri, types)} async toJsonLd(options: {
+    format?: "compact" | "expand",
+    contextLoader?: DocumentLoader,
+    context?: string | Record<string, string> | (string | Record<string, string>)[],
+  } = {}): Promise<unknown> {
+    if (options.format == null && this._cachedJsonLd != null) {
+      return this._cachedJsonLd;
+    }
+    if (options.format !== "compact" && options.context != null) {
+      throw new TypeError(
+        "The context option can only be used when the format option is set " +
+        "to 'compact'."
+      );
+    }
+    options = {
+      ...options,
+      contextLoader: options.contextLoader ?? getDocumentLoader(),
+    };
+  `;
+	if (isCompactableType(typeUri, types)) {
+		yield `
+    if (options.format == null && this.isCompactable()) {
+    `;
+		if (type.extends == null) yield "const result: Record<string, unknown> = {};";
+		else {
+			yield `
+      const result = await super.toJsonLd({
+        ...options,
+        format: undefined,
+        context: undefined,
+      }) as Record<string, unknown>;
+      `;
+			const selfProperties = type.properties.map((p) => p.uri);
+			for (const property of getAllProperties(typeUri, types, true)) {
+				if (!selfProperties.includes(property.uri)) continue;
+				yield `delete result[${JSON.stringify(property.compactName)}];`;
+			}
+		}
+		yield `
+      // deno-lint-ignore no-unused-vars
+      let compactItems: unknown[];
+    `;
+		for (const property of type.properties) {
+			yield `
+      compactItems = [];
+      for (const v of this.${await getFieldName(property.uri)}) {
+        const item = (
+      `;
+			if (!areAllScalarTypes(property.range, types)) yield "v instanceof URL ? v.href : ";
+			const encoders = getEncoders(property.range, types, "v", "options", true);
+			for (const code of encoders) yield code;
+			yield `
+        );
+        compactItems.push(item);
+      }
+      if (compactItems.length > 0) {
+      `;
+			if (property.functional || isNonFunctionalProperty(property) && property.container !== "list") {
+				yield `
+        result[${JSON.stringify(property.compactName)}]
+          = compactItems.length > 1
+          ? compactItems
+          : compactItems[0];
+        `;
+				if (property.functional && property.redundantProperties != null) for (const prop of property.redundantProperties) yield `
+            result[${JSON.stringify(prop.compactName)}]
+              = compactItems.length > 1
+              ? compactItems
+              : compactItems[0];
+            `;
+			} else yield `
+        result[${JSON.stringify(property.compactName)}] = compactItems;
+        `;
+			yield `
+      }
+      `;
+		}
+		yield `
+      result["type"] = ${JSON.stringify(type.compactName ?? type.uri)};
+      if (this.id != null) result["id"] = this.id.href;
+      result["@context"] = ${JSON.stringify(type.defaultContext)};
+      return result;
+    }
+    `;
+	}
+	yield `
+    // deno-lint-ignore no-unused-vars prefer-const
+    let array: unknown[];
+  `;
+	if (type.extends == null) yield "const values: Record<string, unknown[] | string> = {};";
+	else yield `
+    const baseValues = await super.toJsonLd({
+      ...options,
+      format: "expand",
+      context: undefined,
+    }) as unknown[];
+    const values = baseValues[0] as Record<
+      string,
+      unknown[] | { "@list": unknown[] } | string
+    >;
+    `;
+	for (const property of type.properties) {
+		yield `
+    array = [];
+    for (const v of this.${await getFieldName(property.uri)}) {
+      const element = (
+    `;
+		if (!areAllScalarTypes(property.range, types)) yield "v instanceof URL ? { \"@id\": v.href } : ";
+		for (const code of getEncoders(property.range, types, "v", "options")) yield code;
+		yield `
+      );
+    `;
+		if (isNonFunctionalProperty(property) && property.container === "graph") yield `array.push({ "@graph": element });`;
+		else yield `array.push(element);`;
+		yield `;
+    }
+    if (array.length > 0) {
+      const propValue = (
+    `;
+		if (isNonFunctionalProperty(property) && property.container === "list") yield `{ "@list": array }`;
+		else yield `array`;
+		yield `
+      );
+      values[${JSON.stringify(property.uri)}] = propValue;
+    `;
+		if (property.functional && property.redundantProperties != null) for (const prop of property.redundantProperties) yield `
+        values[${JSON.stringify(prop.uri)}] = propValue;
+        `;
+		yield `
+    }
+    `;
+	}
+	yield `
+    values["@type"] = [${JSON.stringify(type.uri)}];
+    if (this.id != null) values["@id"] = this.id.href;
+    if (options.format === "expand") {
+      return await jsonld.expand(
+        values,
+        { documentLoader: options.contextLoader },
+      );
+    }
+    const docContext = options.context ??
+      ${JSON.stringify(type.defaultContext)};
+    const compacted = await jsonld.compact(
+      values,
+      docContext,
+      { documentLoader: options.contextLoader },
+    );
+    if (docContext != null) {
+      // Embed context
+  `;
+	const supertypes = [];
+	for (let uri = typeUri; uri != null; uri = types[uri].extends) supertypes.push(uri);
+	for (const supertype of supertypes) for (const property of types[supertype].properties) {
+		if (property.embedContext == null) continue;
+		const compactName = property.embedContext.compactName;
+		yield `
+      if (${JSON.stringify(compactName)} in compacted &&
+          compacted.${compactName} != null) {
+        if (Array.isArray(compacted.${compactName})) {
+          for (const element of compacted.${compactName}) {
+            element["@context"] = docContext;
+          }
+        } else {
+         compacted.${compactName}["@context"] = docContext;
+        }
+      }
+      `;
+	}
+	yield `
+    }
+    return compacted;
+  }
+
+  protected ${emitOverride(typeUri, types)} isCompactable(): boolean {
+`;
+	for (const property of type.properties) if (!property.range.every((r) => isCompactableType(r, types))) yield `
+      if (
+        this.${await getFieldName(property.uri)} != null &&
+        this.${await getFieldName(property.uri)}.length > 0
+      ) return false;
+      `;
+	yield `
+    return ${type.extends == null ? "true" : "super.isCompactable()"};
+  }
+  `;
+}
+async function* generateDecoder(typeUri, types) {
+	const type = types[typeUri];
+	yield `
+  /**
+   * Converts a JSON-LD structure to an object of this type.
+   * @param json The JSON-LD structure to convert.
+   * @param options The options to use.
+   *                - \`documentLoader\`: The loader for remote JSON-LD documents.
+   *                - \`contextLoader\`: The loader for remote JSON-LD contexts.
+   *                - \`tracerProvider\`: The OpenTelemetry tracer provider to use.
+   *                  If omitted, the global tracer provider is used.
+   * @returns The object of this type.
+   * @throws {TypeError} If the given \`json\` is invalid.
+   */
+  static ${emitOverride(typeUri, types)} async fromJsonLd(
+    json: unknown,
+    options: {
+      documentLoader?: DocumentLoader,
+      contextLoader?: DocumentLoader,
+      tracerProvider?: TracerProvider,
+      baseUrl?: URL,
+    } = {},
+  ): Promise<${type.name}> {
+    const tracerProvider = options.tracerProvider ?? trace.getTracerProvider();
+    const tracer = tracerProvider.getTracer(
+      ${JSON.stringify(deno_default.name)},
+      ${JSON.stringify(deno_default.version)},
+    );
+    return await tracer.startActiveSpan(
+      "activitypub.parse_object",
+      async (span) => {
+        try {
+          const object = await this.__fromJsonLd__${type.name}__(
+            json, span, options);
+          if (object.id != null) {
+            span.setAttribute("activitypub.object.id", object.id.href);
+          }
+          return object;
+        } catch (error) {
+          span.setStatus({
+            code: SpanStatusCode.ERROR,
+            message: String(error),
+          });
+          throw error;
+        } finally {
+          span.end();
+        }
+      },
+    );
+  }
+
+  protected static async __fromJsonLd__${type.name}__(
+    json: unknown,
+    span: Span,
+    options: {
+      documentLoader?: DocumentLoader,
+      contextLoader?: DocumentLoader,
+      tracerProvider?: TracerProvider,
+      baseUrl?: URL,
+    } = {},
+  ): Promise<${type.name}> {
+    if (typeof json === "undefined") {
+      throw new TypeError("Invalid JSON-LD: undefined.");
+    }
+    else if (json === null) throw new TypeError("Invalid JSON-LD: null.");
+    options = {
+      ...options,
+      documentLoader: options.documentLoader ?? getDocumentLoader(),
+      contextLoader: options.contextLoader ?? getDocumentLoader(),
+      tracerProvider: options.tracerProvider ?? trace.getTracerProvider(),
+    };
+    // deno-lint-ignore no-explicit-any
+    let values: Record<string, any[]> & { "@id"?: string };
+    if (globalThis.Object.keys(json).length == 0) {
+      values = {};
+    } else {
+      const expanded = await jsonld.expand(json, {
+        documentLoader: options.contextLoader,
+        keepFreeFloatingNodes: true,
+      });
+      values =
+        // deno-lint-ignore no-explicit-any
+        (expanded[0] ?? {}) as (Record<string, any[]> & { "@id"?: string });
+    }
+    if (options.baseUrl == null && values["@id"] != null) {
+      options = { ...options, baseUrl: new URL(values["@id"]) };
+    }
+  `;
+	const subtypes = getSubtypes(typeUri, types, true);
+	yield `
+  if ("@type" in values) {
+    span.setAttribute("activitypub.object.type", values["@type"]);
+  }
+  if ("@type" in values &&
+      !values["@type"].every(t => t.startsWith("_:"))) {
+  `;
+	for (const subtypeUri of subtypes) yield `
+    if (values["@type"].includes(${JSON.stringify(subtypeUri)})) {
+      return await ${types[subtypeUri].name}.fromJsonLd(json, options);
+    }
+    `;
+	yield `
+    if (!values["@type"].includes(${JSON.stringify(typeUri)})) {
+      throw new TypeError("Invalid type: " + values["@type"]);
+    }
+  }
+  `;
+	if (type.extends == null) yield `
+    const instance = new this(
+      { id: "@id" in values ? new URL(values["@id"] as string) : undefined },
+      options,
+    );
+    `;
+	else yield `
+    delete values["@type"];
+    const instance = await super.fromJsonLd(values, {
+      ...options,
+      // @ts-ignore: an internal option
+      _fromSubclass: true,
+    });
+    if (!(instance instanceof ${type.name})) {
+      throw new TypeError("Unexpected type: " + instance.constructor.name);
+    }
+    `;
+	for (const property of type.properties) {
+		const variable = await getFieldName(property.uri, "");
+		yield await generateField(property, types, "const ");
+		const arrayVariable = `${variable}__array`;
+		yield `
+    let ${arrayVariable} = values[${JSON.stringify(property.uri)}];
+    `;
+		if (property.functional && property.redundantProperties != null) for (const prop of property.redundantProperties) yield `
+        if (${arrayVariable} == null || ${arrayVariable}.length < 1) {
+          ${arrayVariable} = values[${JSON.stringify(prop.uri)}];
+        }
+        `;
+		yield `
+    for (
+      const v of ${arrayVariable} == null
+        ? []
+        : ${arrayVariable}.length === 1 && "@list" in ${arrayVariable}[0]
+        ? ${arrayVariable}[0]["@list"]
+        : ${arrayVariable}
+    ) {
+      if (v == null) continue;
+    `;
+		if (!areAllScalarTypes(property.range, types)) yield `
+      if (typeof v === "object" && "@id" in v && !("@type" in v)
+          && globalThis.Object.keys(v).length === 1) {
+        ${variable}.push(
+          !URL.canParse(v["@id"]) && v["@id"].startsWith("at://")
+            ? new URL("at://" + encodeURIComponent(v["@id"].substring(5)))
+            : new URL(v["@id"])
+        );
+        continue;
+      }
+      `;
+		if (property.range.length == 1) yield `${variable}.push(${getDecoder(property.range[0], types, "v", "options", `(values["@id"] == null ? options.baseUrl : new URL(values["@id"]))`)})`;
+		else {
+			yield `
+      const decoded =
+      `;
+			const decoders = getDecoders(property.range, types, "v", "options", `(values["@id"] == null ? options.baseUrl : new URL(values["@id"]))`);
+			for (const code of decoders) yield code;
+			yield `
+      ;
+      if (typeof decoded === "undefined") continue;
+      ${variable}.push(decoded);
+      `;
+		}
+		yield `
+    }
+    instance.${await getFieldName(property.uri)} = ${variable};
+    `;
+	}
+	yield `
+    if (!("_fromSubclass" in options) || !options._fromSubclass) {
+      try {
+        instance._cachedJsonLd = structuredClone(json);
+      } catch {
+        getLogger(["fedify", "vocab"]).warn(
+          "Failed to cache JSON-LD: {json}",
+          { json },
+        );
+      }
+    }
+    return instance;
+  }
+  `;
+}
+
+//#endregion
+//#region src/constructor.ts
+function generateParameterType(property, types) {
+	const range = property.range;
+	const scalar = areAllScalarTypes(range, types);
+	const code = [];
+	if (hasSingularAccessor(property)) if (scalar) code.push(`${property.singularName}?: ${getTypeNames(range, types)} | null;`);
+	else code.push(`${property.singularName}?: ${getTypeNames(range, types)} | URL | null;`);
+	if (isNonFunctionalProperty(property)) if (scalar) code.push(`${property.pluralName}?: (${getTypeNames(range, types, true)})[];`);
+	else code.push(`${property.pluralName}?: (${getTypeNames(range, types)} | URL)[];`);
+	return code.join("\n");
+}
+async function* generateParametersType(typeUri, types, parentheses = true, excludeProperties = []) {
+	const type = types[typeUri];
+	if (parentheses) yield "{\n";
+	if (type.extends == null) yield `id?: URL | null;\n`;
+	else for await (const code of generateParametersType(type.extends, types, false, [...excludeProperties, ...type.properties.map((p) => p.singularName)])) yield code;
+	for (const property of type.properties) {
+		if (excludeProperties.includes(property.singularName)) continue;
+		yield generateParameterType(property, types);
+	}
+	if (parentheses) yield "}\n";
+}
+async function* generateConstructor(typeUri, types) {
+	const type = types[typeUri];
+	yield `
+  /**
+   * Constructs a new instance of ${type.name} with the given values.
+   * @param values The values to initialize the instance with.
+   * @param options The options to use for initialization.
+   */
+  constructor(
+    values:
+  `;
+	for await (const code of generateParametersType(typeUri, types)) yield code;
+	yield `,
+    options: {
+      documentLoader?: DocumentLoader,
+      contextLoader?: DocumentLoader,
+      tracerProvider?: TracerProvider,
+    } = {},
+  ) {
+  `;
+	if (type.extends == null) yield `
+    this.#documentLoader = options.documentLoader;
+    this.#contextLoader = options.contextLoader;
+    this.#tracerProvider = options.tracerProvider;
+    if ("$warning" in options) {
+      this.#warning = options.$warning as unknown as {
+        category: string[];
+        message: string;
+        values?: Record<string, unknown>;
+      };
+    }
+    if (values.id == null || values.id instanceof URL) {
+      this.id = values.id ?? null;
+    } else {
+      throw new TypeError("The id must be a URL.");
+    }
+    `;
+	else yield "super(values, options);";
+	for (const property of type.properties) {
+		const fieldName = await getFieldName(property.uri);
+		const trustFieldName = await getFieldName(property.uri, "#_trust");
+		const allScalarTypes = areAllScalarTypes(property.range, types);
+		if (hasSingularAccessor(property)) {
+			let typeGuards = getTypeGuards(property.range, types, `values.${property.singularName}`);
+			let typeNames = getTypeNames(property.range, types);
+			const scalar = areAllScalarTypes(property.range, types);
+			if (!scalar) {
+				typeGuards = `${typeGuards} || values.${property.singularName} instanceof URL`;
+				typeNames = `${typeNames} | URL`;
+			}
+			yield `
+        if ("${property.singularName}" in values && \
+            values.${property.singularName} != null) {
+          if (${typeGuards}) {
+            // @ts-ignore: type is checked above.
+            this.${fieldName} = [values.${property.singularName}];
+      `;
+			if (!allScalarTypes) yield `this.${trustFieldName}.add(0);`;
+			yield `
+          } else {
+            throw new TypeError(
+              "The ${property.singularName} must be of type " +
+              ${JSON.stringify(typeNames)} + ".",
+            );
+          }
+        }
+      `;
+		}
+		if (isNonFunctionalProperty(property)) {
+			let typeGuards = getTypeGuards(property.range, types, `v`);
+			let typeNames = getTypeNames(property.range, types);
+			const scalar = areAllScalarTypes(property.range, types);
+			if (!scalar) {
+				typeGuards = `${typeGuards} || v instanceof URL`;
+				typeNames = `${typeNames} | URL`;
+			}
+			yield `
+        if ("${property.pluralName}" in values && \
+            values.${property.pluralName} != null) {
+      `;
+			if (property && property.singularAccessor) yield `
+          if ("${property.singularName}" in values &&
+              values.${property.singularName} != null) {
+            throw new TypeError(
+              "Cannot initialize both ${property.singularName} and " +
+                "${property.pluralName} at the same time.",
+            );
+          }
+        `;
+			yield `
+          if (Array.isArray(values.${property.pluralName}) &&
+              values.${property.pluralName}.every(v => ${typeGuards})) {
+            // @ts-ignore: type is checked above.
+            this.${fieldName} = values.${property.pluralName};
+      `;
+			if (!allScalarTypes) yield `
+            for (let i = 0; i < values.${property.pluralName}.length; i++) {
+              this.${trustFieldName}.add(i);
+            }
+        `;
+			yield `
+          } else {
+            throw new TypeError(
+              "The ${property.pluralName} must be an array of type " +
+              ${JSON.stringify(typeNames)} + ".",
+            );
+          }
+        }
+      `;
+		}
+	}
+	yield "}\n";
+}
+async function* generateCloner(typeUri, types) {
+	const type = types[typeUri];
+	yield `
+  /**
+   * Clones this instance, optionally updating it with the given values.
+   * @param values The values to update the clone with.
+   * @options The options to use for cloning.
+   * @returns The cloned instance.
+   */
+  ${emitOverride(typeUri, types)} clone(
+    values:
+  `;
+	for await (const code of generateParametersType(typeUri, types)) yield code;
+	yield `
+    = {},
+    options: {
+      documentLoader?: DocumentLoader,
+      contextLoader?: DocumentLoader,
+    } = {}
+  ): ${type.name} {
+    if (this._warning != null) {
+      getLogger(this._warning.category).warn(
+        this._warning.message,
+        this._warning.values
+      );
+      // @ts-ignore: $warning is not recognized as a property, but it is.
+      options = { ...options, $warning: this._warning };
+    }
+  `;
+	if (type.extends == null) yield `
+    // @ts-ignore: this.constructor is not recognized as a constructor, but it is.
+    const clone: ${type.name} = new this.constructor(
+      { id: values.id ?? this.id },
+      options
+    );
+    `;
+	else yield `const clone = super.clone(values, options) as unknown as ${type.name};`;
+	for (const property of type.properties) {
+		const fieldName = await getFieldName(property.uri);
+		const trustFieldName = await getFieldName(property.uri, "#_trust");
+		const allScalarTypes = areAllScalarTypes(property.range, types);
+		yield `clone.${fieldName} = this.${fieldName};`;
+		if (!allScalarTypes) yield `clone.${trustFieldName} = new Set(this.${trustFieldName});`;
+		if (hasSingularAccessor(property)) {
+			let typeGuards = getTypeGuards(property.range, types, `values.${property.singularName}`);
+			let typeNames = getTypeNames(property.range, types);
+			const scalar = areAllScalarTypes(property.range, types);
+			if (!scalar) {
+				typeGuards = `${typeGuards} || values.${property.singularName} instanceof URL`;
+				typeNames = `${typeNames} | URL`;
+			}
+			yield `
+        if ("${property.singularName}" in values && \
+            values.${property.singularName} != null) {
+          if (${typeGuards}) {
+            // @ts-ignore: type is checked above.
+            clone.${fieldName} = [values.${property.singularName}];
+      `;
+			if (!allScalarTypes) yield `clone.${trustFieldName} = new Set([0]);`;
+			yield `
+          } else {
+            throw new TypeError(
+              "The ${property.singularName} must be of type " +
+              ${JSON.stringify(typeNames)} + ".",
+            );
+          }
+        }
+      `;
+		}
+		if (isNonFunctionalProperty(property)) {
+			let typeGuards = getTypeGuards(property.range, types, `v`);
+			let typeNames = getTypeNames(property.range, types);
+			const scalar = areAllScalarTypes(property.range, types);
+			if (!scalar) {
+				typeGuards = `${typeGuards} || v instanceof URL`;
+				typeNames = `${typeNames} | URL`;
+			}
+			yield `
+        if ("${property.pluralName}" in values && \
+            values.${property.pluralName} != null) {
+      `;
+			if (property.singularAccessor) yield `
+          if ("${property.singularName}" in values &&
+              values.${property.singularName} != null) {
+            throw new TypeError(
+              "Cannot update both ${property.singularName} and " +
+                "${property.pluralName} at the same time.",
+            );
+          }
+        `;
+			yield `
+          if (Array.isArray(values.${property.pluralName}) &&
+              values.${property.pluralName}.every(v => ${typeGuards})) {
+            // @ts-ignore: type is checked above.
+            clone.${fieldName} = values.${property.pluralName};
+      `;
+			if (!allScalarTypes) yield `
+            clone.${trustFieldName} = new Set();
+            for (let i = 0; i < values.${property.pluralName}.length; i++) {
+              clone.${trustFieldName}.add(i);
+            }
+        `;
+			yield `
+          } else {
+            throw new TypeError(
+              "The ${property.pluralName} must be an array of type " +
+              ${JSON.stringify(typeNames)} + ".",
+            );
+          }
+        }
+      `;
+		}
+	}
+	yield `
+    return clone;
+  }
+  `;
+}
+
+//#endregion
+//#region src/inspector.ts
+async function* generateInspector(typeUri, types) {
+	const type = types[typeUri];
+	yield `
+  protected ${emitOverride(typeUri, types)} _getCustomInspectProxy(): Record<string, unknown> {
+  `;
+	if (type.extends == null) yield `
+    const proxy: Record<string, unknown> = {};
+    if (this.id != null) {
+      proxy.id = {
+        [Symbol.for("Deno.customInspect")]: (
+          inspect: typeof Deno.inspect,
+          options: Deno.InspectOptions,
+        ): string => "URL " + inspect(this.id!.href, options),
+        [Symbol.for("nodejs.util.inspect.custom")]: (
+          _depth: number,
+          options: unknown,
+          inspect: (value: unknown, options: unknown) => string,
+        ): string => "URL " + inspect(this.id!.href, options),
+      };
+    }
+    `;
+	else yield "const proxy: Record<string, unknown> = super._getCustomInspectProxy();";
+	for (const property of type.properties) {
+		const fieldName = await getFieldName(property.uri);
+		const localName = await getFieldName(property.uri, "");
+		yield `
+      const ${localName} = this.${fieldName}
+        // deno-lint-ignore no-explicit-any
+        .map((v: any) => v instanceof URL
+          ? {
+              [Symbol.for("Deno.customInspect")]: (
+                inspect: typeof Deno.inspect,
+                options: Deno.InspectOptions,
+              ): string => "URL " + inspect(v.href, options),
+              [Symbol.for("nodejs.util.inspect.custom")]: (
+                _depth: number,
+                options: unknown,
+                inspect: (value: unknown, options: unknown) => string,
+              ): string => "URL " + inspect(v.href, options),
+            }
+          : v);
+    `;
+		if (hasSingularAccessor(property)) yield `
+      if (${localName}.length == 1) {
+        proxy.${property.singularName} = ${localName}[0];
+      }
+      `;
+		if (isNonFunctionalProperty(property)) yield `
+      if (${localName}.length > 1
+          || !(${JSON.stringify(property.singularName)} in proxy)
+          && ${localName}.length > 0) {
+        proxy.${property.pluralName} = ${localName};
+      }
+      `;
+	}
+	yield `
+    return proxy;
+  }
+
+  // @ts-ignore: suppressing TS4127
+  ${emitOverride(typeUri, types)} [Symbol.for("Deno.customInspect")](
+    inspect: typeof Deno.inspect,
+    options: Deno.InspectOptions,
+  ): string {
+    const proxy = this._getCustomInspectProxy();
+    return ${JSON.stringify(type.name + " ")} + inspect(proxy, options);
+  }
+
+  // @ts-ignore: suppressing TS4127
+  ${emitOverride(typeUri, types)} [Symbol.for("nodejs.util.inspect.custom")](
+    _depth: number,
+    options: unknown,
+    inspect: (value: unknown, options: unknown) => string,
+  ): string {
+    const proxy = this._getCustomInspectProxy();
+    return ${JSON.stringify(type.name + " ")} + inspect(proxy, options);
+  }
+  `;
+}
+
+//#endregion
+//#region src/property.ts
+function emitOverride$1(typeUri, types, property) {
+	const type = types[typeUri];
+	let supertypeUri = type.extends;
+	while (supertypeUri != null) {
+		const st = types[supertypeUri];
+		if (st.properties.find((p) => p.singularName === property.singularName)) return "override";
+		supertypeUri = st.extends;
+	}
+	return "";
+}
+async function* generateProperty(type, property, types) {
+	const override = emitOverride$1(type.uri, types, property);
+	const doc = `\n/** ${property.description.replaceAll("\n", "\n * ")}\n */\n`;
+	if (areAllScalarTypes(property.range, types)) {
+		if (hasSingularAccessor(property)) {
+			yield doc;
+			yield `${override} get ${property.singularName}(): (${getTypeNames(property.range, types)} | null) {
+        if (this._warning != null) {
+          getLogger(this._warning.category).warn(
+            this._warning.message,
+            this._warning.values
+          );
+        }
+        if (this.${await getFieldName(property.uri)}.length < 1) return null;
+        return this.${await getFieldName(property.uri)}[0];
+      }
+      `;
+		}
+		if (isNonFunctionalProperty(property)) {
+			yield doc;
+			yield `get ${property.pluralName}(): (${getTypeNames(property.range, types, true)})[] {
+        return this.${await getFieldName(property.uri)};
+      }
+      `;
+		}
+	} else {
+		yield `
+    async #fetch${(0, es_toolkit.pascalCase)(property.singularName)}(
+      url: URL,
+      options: {
+        documentLoader?: DocumentLoader,
+        contextLoader?: DocumentLoader,
+        suppressError?: boolean,
+        tracerProvider?: TracerProvider,
+        crossOrigin?: "ignore" | "throw" | "trust";
+      } = {},
+    ): Promise<${getTypeNames(property.range, types)} | null> {
+      const documentLoader =
+        options.documentLoader ?? this._documentLoader ?? getDocumentLoader();
+      const contextLoader =
+        options.contextLoader ?? this._contextLoader ?? getDocumentLoader();
+      const tracerProvider = options.tracerProvider ??
+        this._tracerProvider ?? trace.getTracerProvider();
+      const tracer = tracerProvider.getTracer(
+        ${JSON.stringify(deno_default.name)},
+        ${JSON.stringify(deno_default.version)},
+      );
+      return await tracer.startActiveSpan("activitypub.lookup_object", async (span) => {
+        let fetchResult: RemoteDocument;
+        try {
+          fetchResult = await documentLoader(url.href);
+        } catch (error) {
+          span.setStatus({
+            code: SpanStatusCode.ERROR,
+            message: String(error),
+          });
+          span.end();
+          if (options.suppressError) {
+            getLogger(["fedify", "vocab"]).error(
+              "Failed to fetch {url}: {error}",
+              { error, url: url.href }
+            );
+            return null;
+          }
+          throw error;
+        }
+        const { document, documentUrl } = fetchResult;
+        const baseUrl = new URL(documentUrl);
+        try {
+          const obj = await this.#${property.singularName}_fromJsonLd(
+            document,
+            { documentLoader, contextLoader, tracerProvider, baseUrl }
+          );
+          if (options.crossOrigin !== "trust" && obj?.id != null &&
+              obj.id.origin !== baseUrl.origin) {
+            if (options.crossOrigin === "throw") {
+              throw new Error(
+                "The object's @id (" + obj.id.href + ") has a different origin " +
+                "than the document URL (" + baseUrl.href + "); refusing to return " +
+                "the object.  If you want to bypass this check and are aware of" +
+                'the security implications, set the crossOrigin option to "trust".'
+              );
+            }
+            getLogger(["fedify", "vocab"]).warn(
+              "The object's @id ({objectId}) has a different origin than the document " +
+              "URL ({documentUrl}); refusing to return the object.  If you want to " +
+              "bypass this check and are aware of the security implications, " +
+              'set the crossOrigin option to "trust".',
+              { ...fetchResult, objectId: obj.id.href },
+            );
+            return null;
+          }
+          span.setAttribute("activitypub.object.id", (obj.id ?? url).href);
+          span.setAttribute(
+            "activitypub.object.type",
+            // @ts-ignore: obj.constructor always has a typeId.
+            obj.constructor.typeId.href
+          );
+          return obj;
+        } catch (e) {
+          if (options.suppressError) {
+            getLogger(["fedify", "vocab"]).error(
+              "Failed to parse {url}: {error}",
+              { error: e, url: url.href }
+            );
+            return null;
+          }
+          span.setStatus({
+            code: SpanStatusCode.ERROR,
+            message: String(e),
+          });
+          throw e;
+        } finally {
+          span.end();
+        }
+      });
+    }
+
+    async #${property.singularName}_fromJsonLd(
+      jsonLd: unknown,
+      options: {
+        documentLoader?: DocumentLoader,
+        contextLoader?: DocumentLoader,
+        tracerProvider?: TracerProvider,
+        baseUrl?: URL
+      }
+    ): Promise<${getTypeNames(property.range, types)}> {
+      const documentLoader =
+        options.documentLoader ?? this._documentLoader ?? getDocumentLoader();
+      const contextLoader =
+        options.contextLoader ?? this._contextLoader ?? getDocumentLoader();
+      const tracerProvider = options.tracerProvider ??
+        this._tracerProvider ?? trace.getTracerProvider();
+      const baseUrl = options.baseUrl;
+    `;
+		for (const range of property.range) {
+			if (!(range in types)) continue;
+			const rangeType = types[range];
+			yield `
+        try {
+          return await ${rangeType.name}.fromJsonLd(
+            jsonLd,
+            { documentLoader, contextLoader, tracerProvider, baseUrl },
+          );
+        } catch (e) {
+          if (!(e instanceof TypeError)) throw e;
+        }
+      `;
+		}
+		yield `
+      throw new TypeError("Expected an object of any type of: " +
+        ${JSON.stringify(property.range)}.join(", "));
+    }
+
+    `;
+		if (hasSingularAccessor(property)) {
+			yield `
+      /**
+       * Similar to
+       * {@link ${type.name}.get${(0, es_toolkit.pascalCase)(property.singularName)}},
+       * but returns its \`@id\` URL instead of the object itself.
+       */
+      ${override} get ${property.singularName}Id(): URL | null {
+        if (this._warning != null) {
+          getLogger(this._warning.category).warn(
+            this._warning.message,
+            this._warning.values
+          );
+        }
+        if (this.${await getFieldName(property.uri)}.length < 1) return null;
+        const v = this.${await getFieldName(property.uri)}[0];
+        if (v instanceof URL) return v;
+        return v.id;
+      }
+      `;
+			yield doc;
+			yield `
+      ${override} async get${(0, es_toolkit.pascalCase)(property.singularName)}(
+        options: {
+          documentLoader?: DocumentLoader,
+          contextLoader?: DocumentLoader,
+          suppressError?: boolean,
+          tracerProvider?: TracerProvider,
+          crossOrigin?: "ignore" | "throw" | "trust";
+        } = {}
+      ): Promise<${getTypeNames(property.range, types)} | null> {
+        if (this._warning != null) {
+          getLogger(this._warning.category).warn(
+            this._warning.message,
+            this._warning.values
+          );
+        }
+        if (this.${await getFieldName(property.uri)}.length < 1) return null;
+        let v = this.${await getFieldName(property.uri)}[0];
+        if (options.crossOrigin !== "trust" && !(v instanceof URL) &&
+            v.id != null && v.id.origin !== this.id?.origin &&
+            !this.${await getFieldName(property.uri, "#_trust")}.has(0)) {
+          v = v.id;
+        }
+        if (v instanceof URL) {
+          const fetched =
+            await this.#fetch${(0, es_toolkit.pascalCase)(property.singularName)}(v, options);
+          if (fetched == null) return null;
+          this.${await getFieldName(property.uri)}[0] = fetched;
+          this.${await getFieldName(property.uri, "#_trust")}.add(0);
+          this._cachedJsonLd = undefined;
+          return fetched;
+        }
+      `;
+			if (property.compactName != null) yield `
+        if (
+          this._cachedJsonLd != null &&
+          typeof this._cachedJsonLd === "object" &&
+          "@context" in this._cachedJsonLd &&
+          ${JSON.stringify(property.compactName)} in this._cachedJsonLd
+        ) {
+          const prop = this._cachedJsonLd[
+            ${JSON.stringify(property.compactName)}];
+          const doc = Array.isArray(prop) ? prop[0] : prop;
+          if (doc != null && typeof doc === "object" && "@context" in doc) {
+            v = await this.#${property.singularName}_fromJsonLd(doc, options);
+          }
+        }
+        `;
+			yield `
+        if (options.crossOrigin !== "trust" && v?.id != null &&
+            this.id != null && v.id.origin !== this.id.origin &&
+            !this.${await getFieldName(property.uri, "#_trust")}.has(0)) {
+          if (options.crossOrigin === "throw") {
+            throw new Error(
+              "The property object's @id (" + v.id.href + ") has a different " +
+              "origin than the property owner's @id (" + this.id.href + "); " +
+              "refusing to return the object.  If you want to bypass this " +
+              "check and are aware of the security implications, set the " +
+              'crossOrigin option to "trust".'
+            );
+          }
+          getLogger(["fedify", "vocab"]).warn(
+            "The property object's @id ({objectId}) has a different origin " +
+            "than the property owner's @id ({parentObjectId}); refusing to " +
+            "return the object.  If you want to bypass this check and are " +
+            "aware of the security implications, set the crossOrigin option " +
+            'to "trust".',
+            { objectId: v.id.href, parentObjectId: this.id.href },
+          );
+          return null;
+        }
+        return v;
+      }
+      `;
+		}
+		if (isNonFunctionalProperty(property)) {
+			yield `
+      /**
+       * Similar to
+       * {@link ${type.name}.get${(0, es_toolkit.pascalCase)(property.pluralName)}},
+       * but returns their \`@id\`s instead of the objects themselves.
+       */
+      ${override} get ${property.singularName}Ids(): URL[] {
+        if (this._warning != null) {
+          getLogger(this._warning.category).warn(
+            this._warning.message,
+            this._warning.values
+          );
+        }
+        return this.${await getFieldName(property.uri)}.map((v) =>
+          v instanceof URL ? v : v.id!
+        ).filter(id => id !== null);
+      }
+      `;
+			yield doc;
+			yield `
+      ${override} async* get${(0, es_toolkit.pascalCase)(property.pluralName)}(
+        options: {
+          documentLoader?: DocumentLoader,
+          contextLoader?: DocumentLoader,
+          suppressError?: boolean,
+          tracerProvider?: TracerProvider,
+          crossOrigin?: "ignore" | "throw" | "trust";
+        } = {}
+      ): AsyncIterable<${getTypeNames(property.range, types)}> {
+        if (this._warning != null) {
+          getLogger(this._warning.category).warn(
+            this._warning.message,
+            this._warning.values
+          );
+        }
+        const vs = this.${await getFieldName(property.uri)};
+        for (let i = 0; i < vs.length; i++) {
+          let v = vs[i];
+          if (options.crossOrigin !== "trust" && !(v instanceof URL) &&
+              v.id != null && v.id.origin !== this.id?.origin &&
+              !this.${await getFieldName(property.uri, "#_trust")}.has(i)) {
+            v = v.id;
+          }
+          if (v instanceof URL) {
+            const fetched =
+              await this.#fetch${(0, es_toolkit.pascalCase)(property.singularName)}(v, options);
+            if (fetched == null) continue;
+            vs[i] = fetched;
+            this.${await getFieldName(property.uri, "#_trust")}.add(i);
+            this._cachedJsonLd = undefined;
+            yield fetched;
+            continue;
+          }
+      `;
+			if (property.compactName != null) yield `
+          if (
+            this._cachedJsonLd != null &&
+            typeof this._cachedJsonLd === "object" &&
+            "@context" in this._cachedJsonLd &&
+            ${JSON.stringify(property.compactName)} in this._cachedJsonLd
+          ) {
+            const prop = this._cachedJsonLd[
+              ${JSON.stringify(property.compactName)}];
+            const obj = Array.isArray(prop) ? prop[i] : prop;
+            if (obj != null && typeof obj === "object" && "@context" in obj) {
+              v = await this.#${property.singularName}_fromJsonLd(obj, options);
+            }
+          }
+        `;
+			yield `
+          if (options.crossOrigin !== "trust" && v?.id != null &&
+              this.id != null && v.id.origin !== this.id.origin &&
+              !this.${await getFieldName(property.uri, "#_trust")}.has(0)) {
+            if (options.crossOrigin === "throw") {
+              throw new Error(
+                "The property object's @id (" + v.id.href + ") has a different " +
+                "origin than the property owner's @id (" + this.id.href + "); " +
+                "refusing to return the object.  If you want to bypass this " +
+                "check and are aware of the security implications, set the " +
+                'crossOrigin option to "trust".'
+              );
+            }
+            getLogger(["fedify", "vocab"]).warn(
+              "The property object's @id ({objectId}) has a different origin " +
+              "than the property owner's @id ({parentObjectId}); refusing to " +
+              "return the object.  If you want to bypass this check and are " +
+              "aware of the security implications, set the crossOrigin " +
+              'option to "trust".',
+              { objectId: v.id.href, parentObjectId: this.id.href },
+            );
+            continue;
+          }
+          yield v;
+        }
+      }
+      `;
+		}
+	}
+}
+async function* generateProperties(typeUri, types) {
+	const type = types[typeUri];
+	for (const property of type.properties) yield* generateProperty(type, property, types);
+}
+
+//#endregion
+//#region src/class.ts
+/**
+* Sorts the given types topologically so that the base types come before the
+* extended types.
+* @param types The types to sort.
+* @returns The sorted type URIs.
+*/
+function sortTopologically(types) {
+	const sorted = [];
+	const visited = /* @__PURE__ */ new Set();
+	const visiting = /* @__PURE__ */ new Set();
+	for (const node of Object.values(types)) visit(node);
+	return sorted;
+	function visit(node) {
+		if (visited.has(node.uri)) return;
+		if (visiting.has(node.uri)) throw new Error(`Detected cyclic inheritance: ${node.uri}`);
+		visiting.add(node.uri);
+		if (node.extends) visit(types[node.extends]);
+		visiting.delete(node.uri);
+		visited.add(node.uri);
+		sorted.push(node.uri);
+	}
+}
+async function* generateClass(typeUri, types) {
+	const type = types[typeUri];
+	yield `/** ${type.description.replaceAll("\n", "\n * ")}\n */\n`;
+	if (type.extends) {
+		const baseType = types[type.extends];
+		yield `export class ${type.name} extends ${baseType.name} {\n`;
+	} else yield `export class ${type.name} {\n`;
+	if (type.extends == null) yield `
+    readonly #documentLoader?: DocumentLoader;
+    readonly #contextLoader?: DocumentLoader;
+    readonly #tracerProvider?: TracerProvider;
+    readonly #warning?: {
+      category: string[];
+      message: string;
+      values?: Record<string, unknown>;
+    };
+    #cachedJsonLd?: unknown;
+    readonly id: URL | null;
+
+    protected get _documentLoader(): DocumentLoader | undefined {
+      return this.#documentLoader;
+    }
+
+    protected get _contextLoader(): DocumentLoader | undefined {
+      return this.#contextLoader;
+    }
+
+    protected get _tracerProvider(): TracerProvider | undefined {
+        return this.#tracerProvider;
+    }
+
+    protected get _warning(): {
+        category: string[];
+        message: string;
+        values?: Record<string, unknown>;
+      } | undefined {
+      return this.#warning;
+    }
+
+    protected get _cachedJsonLd(): unknown | undefined {
+      return this.#cachedJsonLd;
+    }
+
+    protected set _cachedJsonLd(value: unknown | undefined) {
+      this.#cachedJsonLd = value;
+    }
+    `;
+	yield `
+    /**
+     * The type URI of {@link ${type.name}}: \`${typeUri}\`.
+     */
+    static ${emitOverride(typeUri, types)} get typeId(): URL {
+      return new URL(${JSON.stringify(typeUri)});
+    }
+  `;
+	for await (const code of generateFields(typeUri, types)) yield code;
+	for await (const code of generateConstructor(typeUri, types)) yield code;
+	for await (const code of generateCloner(typeUri, types)) yield code;
+	for await (const code of generateProperties(typeUri, types)) yield code;
+	for await (const code of generateEncoder(typeUri, types)) yield code;
+	for await (const code of generateDecoder(typeUri, types)) yield code;
+	for await (const code of generateInspector(typeUri, types)) yield code;
+	yield "}\n\n";
+}
+/**
+* Generates the TypeScript classes from the given types.
+* @param types The types to generate classes from.
+* @returns The source code of the generated classes.
+*/
+async function* generateClasses(types) {
+	yield "// deno-lint-ignore-file ban-unused-ignore prefer-const\n";
+	yield "// @ts-ignore TS7016\n";
+	yield "import jsonld from \"jsonld\";\n";
+	yield "import { getLogger } from \"@logtape/logtape\";\n";
+	yield `import { type Span, SpanStatusCode, type TracerProvider, trace }
+    from "@opentelemetry/api";\n`;
+	yield `import {
+    decodeMultibase,
+    type DocumentLoader,
+    encodeMultibase,
+    exportMultibaseKey,
+    exportSpki,
+    getDocumentLoader,
+    importMultibaseKey,
+    importPem,
+    LanguageString,
+    type RemoteDocument,
+} from "@fedify/vocab-runtime";\n`;
+	yield "\n\n";
+	const sorted = sortTopologically(types);
+	for (const typeUri of sorted) for await (const code of generateClass(typeUri, types)) yield code;
+}
+
+//#endregion
+//#region src/generate.ts
+async function generateVocab(schemaDir, generatedPath) {
+	const types = await loadSchemaFiles(schemaDir);
+	const encoder = new TextEncoder();
+	const file = await (0, node_fs_promises.open)(generatedPath, "w");
+	const writer = file.createWriteStream();
+	for await (const code of generateClasses(types)) writer.write(encoder.encode(code));
+	await new Promise((resolve, reject) => {
+		writer.once("finish", () => file.close().then(resolve, reject));
+		writer.once("error", reject);
+		writer.end();
+	});
+}
+
+//#endregion
+exports.areAllScalarTypes = areAllScalarTypes;
+exports.generateVocab = generateVocab;
+exports.loadSchemaFiles = loadSchemaFiles;