@coywolf/emdash 0.35.13 → 0.35.14

package/src/schema/graph.test.mjs

@@ -1,522 +0,0 @@
-// Unit tests for the Schema & Social graph builders.
-// Run: node --test src/schema/graph.test.mjs   (Node 22.6+ strips the types from graph.ts)
-import assert from "node:assert/strict";
-import { test } from "node:test";
-
-const g = await import("./graph.ts");
-
-const ORIGIN = "https://example.com";
-
-function page(overrides = {}) {
-	return {
-		url: `${ORIGIN}/my-post/`,
-		path: "/my-post/",
-		locale: null,
-		kind: "content",
-		pageType: "article",
-		title: "My Post | Example",
-		pageTitle: "My Post",
-		description: "About my post.",
-		canonical: `${ORIGIN}/my-post/`,
-		image: "/_emdash/api/media/file/01ABC.jpg",
-		content: { collection: "posts", id: "e1", slug: "my-post" },
-		seo: { ogImage: null, robots: null },
-		articleMeta: { publishedTime: "2026-01-02T03:04:05Z", modifiedTime: "2026-02-03T04:05:06Z", author: "Jon Henshaw" },
-		siteName: "Example",
-		...overrides,
-	};
-}
-
-function publisher(details = { publisherType: "organization", orgRows: [] }) {
-	return g.publisherNode({ details, origin: ORIGIN, siteName: "Example", siteLogo: { url: "/_emdash/api/media/file/logo.png", width: 512, height: 512 } });
-}
-
-function build(p, extra = {}) {
-	return g.buildGraph({
-		page: p,
-		origin: ORIGIN,
-		siteName: "Example",
-		tagline: "A site",
-		language: "en",
-		types: {},
-		override: null,
-		searchUrl: "/?s={search_term_string}",
-		publisher: publisher(),
-		authors: [],
-		image: { url: `${ORIGIN}/_emdash/api/media/file/01ABC.jpg`, width: 1200, height: 630, alt: "A cover" },
-		breadcrumbs: false,
-		...extra,
-	});
-}
-
-const nodes = (doc) => doc["@graph"];
-const byType = (doc, type) => nodes(doc).filter((n) => n["@type"] === type);
-const byId = (doc, id) => nodes(doc).find((n) => n["@id"] === id);
-
-function assertRefsResolve(doc) {
-	const ids = new Set(nodes(doc).map((n) => n["@id"]).filter(Boolean));
-	const walk = (value, top) => {
-		if (Array.isArray(value)) return value.forEach((v) => walk(v, false));
-		if (value && typeof value === "object") {
-			const keys = Object.keys(value);
-			if (!top && keys.length === 1 && keys[0] === "@id") assert.ok(ids.has(value["@id"]), `dangling reference ${value["@id"]}`);
-			for (const [k, v] of Object.entries(value)) if (k !== "@id") walk(v, false);
-		}
-	};
-	nodes(doc).forEach((n) => walk(n, true));
-	assert.equal(ids.size, nodes(doc).filter((n) => n["@id"]).length, "duplicate @id in graph");
-}
-
-test("article page: BlogPosting keeps everything core emits", () => {
-	const doc = build(page(), { authors: [{ "@type": "Person", "@id": `${ORIGIN}/author/jon/#person`, name: "Jon Henshaw" }] });
-	assert.equal(doc["@context"], "https://schema.org");
-	const [article] = byType(doc, "BlogPosting");
-	assert.ok(article, "BlogPosting node");
-	assert.equal(article.headline, "My Post");
-	assert.equal(article.description, "About my post.");
-	assert.equal(article.datePublished, "2026-01-02T03:04:05Z");
-	assert.equal(article.dateModified, "2026-02-03T04:05:06Z");
-	assert.deepEqual(article.mainEntityOfPage, { "@id": `${ORIGIN}/my-post/#webpage` });
-	assert.deepEqual(article.author, { "@id": `${ORIGIN}/author/jon/#person` });
-	assert.deepEqual(article.publisher, { "@id": `${ORIGIN}/#organization` });
-	assert.deepEqual(article.image, { "@id": `${ORIGIN}/my-post/#primaryimage` });
-	const image = byId(doc, `${ORIGIN}/my-post/#primaryimage`);
-	assert.equal(image.width, 1200);
-	assert.equal(image.caption, "A cover");
-	const [webpage] = byType(doc, "WebPage");
-	assert.equal(webpage.url, `${ORIGIN}/my-post/`);
-	assert.equal(webpage.inLanguage, "en");
-	const [website] = byType(doc, "WebSite");
-	assert.equal(website.potentialAction["@type"], "SearchAction");
-	assert.equal(website.potentialAction.target.urlTemplate, `${ORIGIN}/?s={search_term_string}`);
-	const org = byId(doc, `${ORIGIN}/#organization`);
-	assert.equal(org.name, "Example");
-	assert.equal(org.logo["@type"], "ImageObject");
-	assert.equal(org.logo.url, `${ORIGIN}/_emdash/api/media/file/logo.png`);
-	assert.equal(byType(doc, "BreadcrumbList").length, 0, "no breadcrumbs unless enabled");
-	assertRefsResolve(doc);
-});
-
-test("article page without bylines falls back to the articleMeta author name", () => {
-	const doc = build(page());
-	const [article] = byType(doc, "BlogPosting");
-	assert.deepEqual(article.author, { "@type": "Person", name: "Jon Henshaw" });
-});
-
-test("non-article content page: typed WebPage, no Article", () => {
-	const doc = build(page({ pageType: "website", content: { collection: "pages", id: "p1", slug: "about" }, path: "/about/", url: `${ORIGIN}/about/`, canonical: `${ORIGIN}/about/` }), {
-		types: { pages: { pageType: "AboutPage" } },
-	});
-	assert.equal(byType(doc, "AboutPage").length, 1);
-	assert.equal(nodes(doc).some((n) => /Article|Posting/.test(String(n["@type"]))), false);
-	assertRefsResolve(doc);
-});
-
-test("collection defaults choose the Article subtype", () => {
-	const doc = build(page(), { types: { posts: { pageType: "WebPage", articleType: "NewsArticle" } } });
-	assert.equal(byType(doc, "NewsArticle").length, 1);
-	assert.equal(byType(doc, "BlogPosting").length, 0);
-});
-
-test("entry override beats the collection default, and 'none' drops the Article", () => {
-	const types = { posts: { articleType: "NewsArticle" } };
-	let doc = build(page(), { types, override: { articleType: "TechArticle", pageType: "ItemPage" } });
-	assert.equal(byType(doc, "TechArticle").length, 1);
-	assert.equal(byType(doc, "ItemPage").length, 1);
-	doc = build(page(), { types, override: { articleType: "none" } });
-	assert.equal(nodes(doc).some((n) => /Article|Posting/.test(String(n["@type"]))), false);
-});
-
-test("home page: WebPage about the publisher, no Article, no breadcrumbs", () => {
-	const home = page({ kind: "custom", pageType: "website", content: undefined, path: "/", url: `${ORIGIN}/`, canonical: `${ORIGIN}/`, pageTitle: "Example", articleMeta: undefined, breadcrumbs: undefined });
-	const doc = build(home, { breadcrumbs: true });
-	const [webpage] = byType(doc, "WebPage");
-	assert.deepEqual(webpage.about, { "@id": `${ORIGIN}/#organization` });
-	assert.equal(byType(doc, "BreadcrumbList").length, 0);
-	assert.equal(nodes(doc).some((n) => /Article|Posting/.test(String(n["@type"]))), false);
-	assertRefsResolve(doc);
-});
-
-test("home page type comes from the _home key", () => {
-	const home = page({ kind: "custom", pageType: "website", content: undefined, path: "/", url: `${ORIGIN}/`, canonical: `${ORIGIN}/` });
-	const doc = build(home, { types: { [g.HOME_KEY]: { pageType: "CollectionPage" } } });
-	assert.equal(byType(doc, "CollectionPage").length, 1);
-});
-
-test("breadcrumbs: [] means none, undefined derives from the path, explicit trail is verbatim", () => {
-	let doc = build(page({ breadcrumbs: [] }), { breadcrumbs: true });
-	assert.equal(byType(doc, "BreadcrumbList").length, 0);
-	assert.equal(byType(doc, "WebPage")[0].breadcrumb, undefined);
-
-	doc = build(page({ path: "/guides/my-post/", url: `${ORIGIN}/guides/my-post/`, canonical: `${ORIGIN}/guides/my-post/` }), { breadcrumbs: true });
-	const [derived] = byType(doc, "BreadcrumbList");
-	assert.deepEqual(
-		derived.itemListElement.map((i) => [i.position, i.name, i.item]),
-		[
-			[1, "Home", `${ORIGIN}/`],
-			[2, "Guides", `${ORIGIN}/guides/`],
-			[3, "My Post", `${ORIGIN}/guides/my-post/`],
-		],
-	);
-	assert.deepEqual(byType(doc, "WebPage")[0].breadcrumb, { "@id": derived["@id"] });
-
-	doc = build(page({ breadcrumbs: [{ name: "Home", url: "/" }, { name: "Health", url: "/health/" }] }), { breadcrumbs: true });
-	const [explicit] = byType(doc, "BreadcrumbList");
-	assert.deepEqual(explicit.itemListElement.map((i) => i.item), [`${ORIGIN}/`, `${ORIGIN}/health/`]);
-	assertRefsResolve(doc);
-});
-
-test("standalone breadcrumb document when the graph is off", () => {
-	assert.equal(g.breadcrumbDocument(page({ breadcrumbs: [] }), ORIGIN), null);
-	const doc = g.breadcrumbDocument(page({ path: "/a/b/" }), ORIGIN);
-	assert.equal(doc["@type"], "BreadcrumbList");
-	assert.equal(doc["@context"], "https://schema.org");
-});
-
-test("graph has exactly one node per @id (no duplicate primary entities)", () => {
-	const author = { "@type": "Person", "@id": `${ORIGIN}/#person`, name: "Jon" };
-	const personPublisher = g.publisherNode({
-		details: { publisherType: "person", personBylineId: "b1", orgRows: [] },
-		origin: ORIGIN,
-		siteName: "Example",
-		person: { byline: { id: "b1", slug: "jon", displayName: "Jon" }, rows: null },
-	});
-	assert.equal(personPublisher["@type"], "Person");
-	assert.equal(personPublisher["@id"], `${ORIGIN}/#person`);
-	const doc = build(page(), { publisher: personPublisher, authors: [author] });
-	assert.equal(nodes(doc).filter((n) => n["@id"] === `${ORIGIN}/#person`).length, 1);
-	assert.equal(byType(doc, "WebSite").length, 1);
-	assert.equal(byType(doc, "BlogPosting").length, 1);
-	assertRefsResolve(doc);
-});
-
-test("person publisher without a byline still resolves", () => {
-	const node = g.publisherNode({ details: { publisherType: "person", orgRows: [] }, origin: ORIGIN, siteName: "Example", person: null });
-	assert.equal(node["@type"], "Organization");
-	assert.equal(node.name, "Example");
-});
-
-test("shapeRows: repeats become arrays, objects get types, relative URLs become absolute", () => {
-	const out = g.shapeRows(
-		[
-			{ prop: "@id", value: "/#org" },
-			{ prop: "@id", value: "/#ignored" },
-			{ prop: "name", value: "Coywolf" },
-			{ prop: "sameAs", value: "https://x.com/coywolf" },
-			{ prop: "sameAs", value: "https://github.com/coywolf" },
-			{ prop: "logo", value: "/_emdash/api/media/file/logo.png" },
-			{ prop: "founder", value: "Jon Henshaw" },
-			{ prop: "address", value: { addressLocality: "Austin", addressRegion: "TX", junk: "" } },
-			{ prop: "numberOfEmployees", value: "5" },
-			{ prop: "url", value: "javascript:alert(1)" },
-			{ prop: "description", value: "   " },
-		],
-		"Organization",
-		ORIGIN,
-	);
-	assert.equal(out["@id"], `${ORIGIN}/#org`);
-	assert.deepEqual(out.sameAs, ["https://x.com/coywolf", "https://github.com/coywolf"]);
-	assert.deepEqual(out.logo, { "@type": "ImageObject", url: `${ORIGIN}/_emdash/api/media/file/logo.png` });
-	assert.deepEqual(out.founder, { "@type": "Person", name: "Jon Henshaw" });
-	assert.deepEqual(out.address, { "@type": "PostalAddress", addressLocality: "Austin", addressRegion: "TX" });
-	assert.deepEqual(out.numberOfEmployees, { "@type": "QuantitativeValue", value: 5 });
-	assert.equal(out.url, undefined);
-	assert.equal(out.description, undefined);
-});
-
-test("personNode: rows win, byline fills gaps, author page anchors the id", () => {
-	const node = g.personNode({
-		byline: { id: "b1", slug: "jon", displayName: "Jon Henshaw", bio: "Writer.", websiteUrl: null, avatarUrl: "/_emdash/api/media/asset/m1/jon.jpg" },
-		rows: [
-			{ prop: "jobTitle", value: "Founder" },
-			{ prop: "sameAs", value: "https://henshaw.social/@jon" },
-		],
-		origin: ORIGIN,
-		defaultId: `${ORIGIN}/author/jon/#person`,
-		authorUrl: `${ORIGIN}/author/jon/`,
-	});
-	assert.equal(node["@id"], `${ORIGIN}/author/jon/#person`);
-	assert.equal(node.name, "Jon Henshaw");
-	assert.equal(node.jobTitle, "Founder");
-	assert.equal(node.url, `${ORIGIN}/author/jon/`);
-	assert.equal(node.description, "Writer.");
-	assert.equal(node.image, `${ORIGIN}/_emdash/api/media/asset/m1/jon.jpg`);
-	assert.equal(g.authorPath("/author/{slug}/", "jon"), "/author/jon/");
-	assert.equal(g.authorPath("", "jon"), null);
-});
-
-test("headline is capped at 110 characters", () => {
-	const doc = build(page({ pageTitle: "x".repeat(200) }));
-	assert.ok(byType(doc, "BlogPosting")[0].headline.length <= 110);
-});
-
-test("no SearchAction without a {search_term_string} template", () => {
-	const doc = build(page(), { searchUrl: "" });
-	assert.equal(byType(doc, "WebSite")[0].potentialAction, undefined);
-});
-
-test("robots: defaults, noindex merge, nofollow, explicit values kept", () => {
-	const defaults = { maxImagePreview: "large", maxSnippet: -1, maxVideoPreview: -1 };
-	assert.equal(g.robotsContent(null, defaults), "index, follow, max-image-preview:large, max-snippet:-1, max-video-preview:-1");
-	assert.equal(g.robotsContent("noindex, nofollow", defaults), "noindex, nofollow");
-	assert.equal(g.robotsContent(null, { ...defaults, nofollow: true }), "index, nofollow, max-image-preview:large, max-snippet:-1, max-video-preview:-1");
-	assert.equal(g.robotsContent("max-snippet:50", { maxImagePreview: "", maxSnippet: -1 }), "index, follow, max-snippet:50");
-	assert.equal(g.robotsContent("none", defaults), "noindex, nofollow");
-});
-
-test("og:locale", () => {
-	assert.equal(g.ogLocale("en"), "en_US");
-	assert.equal(g.ogLocale("en-GB"), "en_GB");
-	assert.equal(g.ogLocale("pt-br"), "pt_BR");
-	assert.equal(g.ogLocale("fr"), "fr_FR");
-	assert.equal(g.ogLocale("zh-Hant-TW"), "zh_TW");
-	assert.equal(g.ogLocale(""), null);
-});
-
-test("media URLs map to lookups; foreign or resized URLs don't", () => {
-	assert.deepEqual(g.mediaRefFromUrl("/_emdash/api/media/file/01ABC.jpg", ORIGIN), { by: "storage_key", value: "01ABC.jpg" });
-	assert.deepEqual(g.mediaRefFromUrl(`${ORIGIN}/_emdash/api/media/asset/m1/cover.jpg`, ORIGIN), { by: "id", value: "m1" });
-	assert.equal(g.mediaRefFromUrl("https://cdn.other.com/_emdash/api/media/file/01ABC.jpg", ORIGIN), null);
-	assert.equal(g.mediaRefFromUrl("/_emdash/api/media/file/01ABC.jpg?w=600", ORIGIN), null);
-	assert.equal(g.mediaRefFromUrl("/images/x.jpg", ORIGIN), null);
-});
-
-test("JSON-LD output is plain JSON with no undefined values", () => {
-	const doc = build(page({ description: null, articleMeta: {} }), { image: null, tagline: null, language: null });
-	const json = JSON.stringify(doc);
-	assert.equal(JSON.stringify(JSON.parse(json)), json);
-	assert.equal(json.includes("null"), false);
-});
-
-test("robots limits: blank or missing means -1, never 0", () => {
-	assert.equal(g.parseLimit(""), -1);
-	assert.equal(g.parseLimit("  "), -1);
-	assert.equal(g.parseLimit(undefined), -1);
-	assert.equal(g.parseLimit(null), -1);
-	assert.equal(g.parseLimit("abc"), -1);
-	assert.equal(g.parseLimit("160"), 160);
-	assert.equal(g.parseLimit(0), 0);
-	assert.equal(g.parseLimit(-5), -1);
-	const content = g.robotsContent(null, { maxImagePreview: "large", maxSnippet: g.parseLimit(""), maxVideoPreview: g.parseLimit("") });
-	assert.equal(content, "index, follow, max-image-preview:large, max-snippet:-1, max-video-preview:-1");
-	assert.equal(content.includes("max-snippet:0"), false);
-});
-
-test("publisher person who also authors is one Person node with merged properties", () => {
-	const details = { publisherType: "person", personBylineId: "b1", orgRows: [] };
-	const byline = { id: "b1", slug: "jon", displayName: "Jon Henshaw" };
-	const pub = g.publisherNode({ details, origin: ORIGIN, siteName: "Example", person: { byline, rows: null } });
-	const id = g.authorId({ bylineId: "b1", slug: "jon", origin: ORIGIN, authorUrl: `${ORIGIN}/author/jon/`, details });
-	assert.equal(id, pub["@id"]);
-	assert.equal(g.authorId({ bylineId: "b2", slug: "amy", origin: ORIGIN, authorUrl: `${ORIGIN}/author/amy/`, details }), `${ORIGIN}/author/amy/#person`);
-	assert.equal(g.authorId({ bylineId: "b2", slug: "amy", origin: ORIGIN, authorUrl: null, details }), `${ORIGIN}/#person-amy`);
-	const author = g.personNode({ byline, rows: [{ prop: "jobTitle", value: "Editor" }], origin: ORIGIN, defaultId: id });
-	const doc = build(page(), { publisher: pub, authors: [author] });
-	const people = byType(doc, "Person");
-	assert.equal(people.length, 1);
-	assert.equal(people[0]["@id"], pub["@id"]);
-	assert.equal(people[0].jobTitle, "Editor");
-	assert.deepEqual(byType(doc, "BlogPosting")[0].author, { "@id": pub["@id"] });
-	assert.equal(pub.jobTitle, undefined, "input publisher node isn't mutated");
-	assertRefsResolve(doc);
-});
-
-test("publisher uses the chosen organization type and policy URLs", () => {
-	const node = g.publisherNode({
-		details: {
-			publisherType: "organization",
-			organizationType: "NewsMediaOrganization",
-			orgRows: [
-				{ prop: "correctionsPolicy", value: "/policies-and-standards/" },
-				{ prop: "parentOrganization", value: { name: "Coywolf LLC", url: "https://coywolf.llc", "@id": "https://coywolf.llc#Organization" } },
-			],
-		},
-		origin: ORIGIN,
-		siteName: "Example",
-	});
-	assert.equal(node["@type"], "NewsMediaOrganization");
-	assert.equal(node.correctionsPolicy, `${ORIGIN}/policies-and-standards/`);
-	assert.deepEqual(node.parentOrganization, { "@type": "Organization", name: "Coywolf LLC", url: "https://coywolf.llc", "@id": "https://coywolf.llc#Organization" });
-});
-
-test("nested copies of graph entities become references; WebPage doesn't repeat the Article", () => {
-	const nodes = g.linkNestedEntities([
-		{ "@type": "Person", "@id": "https://example.com/author/jon/#person", name: "Jon", url: "https://coywolf.com/jon-henshaw/" },
-		{
-			"@type": "NewsMediaOrganization",
-			"@id": "https://example.com/#organization",
-			founder: { "@type": "Person", "@id": "https://coywolf.com/jon-henshaw/#Person", name: "Jon", url: "https://coywolf.com/jon-henshaw/" },
-			parentOrganization: { "@type": "Organization", name: "Coywolf LLC", url: "https://coywolf.llc" },
-		},
-	]);
-	assert.deepEqual(nodes[1].founder, { "@id": "https://example.com/author/jon/#person" });
-	assert.equal(nodes[1].parentOrganization.name, "Coywolf LLC");
-});
-
-test("theme videos become VideoObjects linked from the Article", () => {
-	const uid = "3161485099a6f1d5d0fd9e7165b87f37";
-	const graph = { "@graph": [
-		{ "@type": "WebPage", "@id": `${ORIGIN}/p/#webpage` },
-		{ "@type": "Article", "@id": `${ORIGIN}/p/#article` },
-	] };
-	const v = g.themeVideoNode({ name: "Chemex", description: "", thumbnailUrl: `https://customer-x.cloudflarestream.com/${uid}/thumbnails/thumbnail.jpg`, embedUrl: `https://customer-x.cloudflarestream.com/${uid}/iframe`, uploadDate: "2024-01-01T00:00:00Z", duration: "PT18S" }, ORIGIN);
-	assert.equal(v.description, "Chemex");
-	assert.equal(g.themeVideoNode({ name: "no urls" }, ORIGIN), null);
-	assert.equal(g.themeVideoNode({ embedUrl: "javascript:alert(1)" }, ORIGIN), null);
-	g.attachVideos(graph, [v, { ...v }]);
-	const videos = graph["@graph"].filter((n) => n["@type"] === "VideoObject");
-	assert.equal(videos.length, 1);
-	assert.equal(videos[0]["@id"], `${ORIGIN}/p/#video-${uid}`);
-	assert.deepEqual(graph["@graph"][1].video, { "@id": `${ORIGIN}/p/#video-${uid}` });
-});
-
-test("a guest byline (imported from Coywolf Guest Author) becomes the article's author Person with its website, bio and avatar", () => {
-	const byline = { id: "b1", slug: "david-rosenthal", displayName: "David Rosenthal", bio: "Computer scientist.", websiteUrl: "https://blog.dshr.org/", avatarUrl: "/_emdash/api/media/file/abc.jpg" };
-	const id = g.authorId({ bylineId: "b1", slug: byline.slug, origin: ORIGIN });
-	const node = g.personNode({ byline, origin: ORIGIN, defaultId: id });
-	assert.deepEqual(node, {
-		"@type": "Person",
-		"@id": `${ORIGIN}/#person-david-rosenthal`,
-		name: "David Rosenthal",
-		url: "https://blog.dshr.org/",
-		description: "Computer scientist.",
-		image: `${ORIGIN}/_emdash/api/media/file/abc.jpg`,
-	});
-});
-
-// ── Main subject (WebPage mainEntity) ────────────────────────────
-
-const jon = { id: "b1", slug: "jon-henshaw", displayName: "Jon Henshaw", bio: null, websiteUrl: null, avatarUrl: null };
-const jonId = `${ORIGIN}/jon-henshaw/#person`;
-const jonRows = [
-	{ prop: "name", value: "Jon Henshaw" },
-	{ prop: "jobTitle", value: "Editor" },
-	{ prop: "birthDate", value: "1973-09-09", profileOnly: true },
-	{ prop: "email", value: "jon@example.com", profileOnly: true },
-	{ prop: "birthPlace", value: "Whiteman AFB", profileOnly: true },
-	{ prop: "nationality", value: "US", profileOnly: true },
-	{ prop: "gender", value: "male", profileOnly: true },
-	{ prop: "sameAs", value: "https://henshaw.social/@jon" },
-];
-const jonNode = (profile) => g.personNode({ byline: jon, rows: jonRows, origin: ORIGIN, defaultId: jonId, authorUrl: `${ORIGIN}/jon-henshaw/`, profile });
-const profilePage = (overrides = {}) =>
-	page({
-		url: `${ORIGIN}/jon-henshaw/`,
-		path: "/jon-henshaw/",
-		canonical: `${ORIGIN}/jon-henshaw/`,
-		pageType: "website",
-		pageTitle: "Jon Henshaw",
-		content: { collection: "pages", id: "p1", slug: "jon-henshaw" },
-		...overrides,
-	});
-
-test("main subject byline: ProfilePage mainEntity is the Person, with profile-only properties", () => {
-	const doc = build(profilePage(), { override: { pageType: "ProfilePage", articleType: "none" }, mainEntity: jonNode(true) });
-	const [profile] = byType(doc, "ProfilePage");
-	assert.ok(profile, "ProfilePage node");
-	assert.deepEqual(profile.mainEntity, { "@id": jonId });
-	assert.equal(profile.dateCreated, "2026-01-02T03:04:05Z");
-	assert.equal(profile.dateModified, "2026-02-03T04:05:06Z");
-	const people = byType(doc, "Person");
-	assert.equal(people.length, 1);
-	const person = people[0];
-	assert.equal(person["@id"], jonId);
-	assert.equal(person.birthDate, "1973-09-09");
-	assert.equal(person.email, "jon@example.com");
-	assert.deepEqual(person.birthPlace, { "@type": "Place", name: "Whiteman AFB" });
-	assert.deepEqual(person.nationality, { "@type": "Country", name: "US" });
-	assert.equal(person.gender, "male");
-	assert.equal(person.jobTitle, "Editor");
-	assert.equal(byType(doc, "BlogPosting").length, 0);
-	assertRefsResolve(doc);
-});
-
-test("article authors never get profile-only properties", () => {
-	const author = jonNode(false);
-	for (const key of ["birthDate", "email", "birthPlace", "nationality", "gender"]) assert.equal(author[key], undefined, key);
-	assert.equal(author.jobTitle, "Editor");
-	assert.equal(author["@id"], jonId);
-	const doc = build(page(), { authors: [author] });
-	const person = byId(doc, jonId);
-	assert.equal(person.birthDate, undefined);
-	assert.equal(byType(doc, "BlogPosting")[0].author["@id"], jonId);
-	assert.equal(byType(doc, "WebPage")[0].mainEntity, undefined);
-});
-
-test("main subject who is also the credited author: one Person node, the fuller one", () => {
-	const doc = build(profilePage({ pageType: "article" }), { override: { pageType: "ProfilePage" }, authors: [jonNode(false)], mainEntity: jonNode(true) });
-	const people = byType(doc, "Person");
-	assert.equal(people.length, 1);
-	assert.equal(people[0].birthDate, "1973-09-09");
-	assert.deepEqual(byType(doc, "BlogPosting")[0].author, { "@id": jonId });
-	assert.equal(byType(doc, "ProfilePage")[0].dateCreated, undefined, "the Article carries the dates");
-	assertRefsResolve(doc);
-});
-
-test("main subject publisher: AboutPage mainEntity is the publisher Organization, no second node", () => {
-	const pub = publisher();
-	const doc = build(profilePage({ path: "/about/", url: `${ORIGIN}/about/`, canonical: `${ORIGIN}/about/` }), {
-		override: { pageType: "AboutPage", articleType: "none" },
-		publisher: pub,
-		mainEntity: pub,
-	});
-	const [about] = byType(doc, "AboutPage");
-	assert.deepEqual(about.mainEntity, { "@id": `${ORIGIN}/#organization` });
-	assert.equal(byType(doc, "Organization").length, 1);
-	assertRefsResolve(doc);
-});
-
-test("publisher person as main subject gets their profile-only properties on that page only", () => {
-	const details = { publisherType: "person", personBylineId: "b1", orgRows: [] };
-	const pub = g.publisherNode({ details, origin: ORIGIN, siteName: "Example", person: { byline: jon, rows: jonRows } });
-	assert.equal(pub.birthDate, undefined, "publisher node on every page has no profile-only properties");
-	const main = g.personNode({ byline: jon, rows: jonRows, origin: ORIGIN, defaultId: String(pub["@id"]), profile: true });
-	const doc = build(profilePage(), { override: { pageType: "ProfilePage", articleType: "none" }, publisher: pub, mainEntity: main });
-	const people = byType(doc, "Person");
-	assert.equal(people.length, 1);
-	assert.equal(people[0].birthDate, "1973-09-09");
-	assert.deepEqual(byType(doc, "ProfilePage")[0].mainEntity, { "@id": pub["@id"] });
-	assertRefsResolve(doc);
-});
-
-test("no main subject: output unchanged", () => {
-	const base = build(profilePage(), { override: { pageType: "ProfilePage", articleType: "none" } });
-	const same = build(profilePage(), { override: { pageType: "ProfilePage", articleType: "none" }, mainEntity: null });
-	assert.deepEqual(same, base);
-	assert.equal(byType(base, "ProfilePage")[0].mainEntity, undefined);
-	assert.equal(byType(base, "Person").length, 0);
-});
-
-test("main subject's nested founder/memberOf copies link to graph nodes (no duplicate entities)", () => {
-	const pub = g.publisherNode({
-		details: { publisherType: "organization", orgRows: [{ prop: "founder", value: { name: "Jon Henshaw", url: `${ORIGIN}/jon-henshaw/` } }] },
-		origin: ORIGIN,
-		siteName: "Example",
-	});
-	const main = g.personNode({
-		byline: jon,
-		rows: [...jonRows, { prop: "url", value: `${ORIGIN}/jon-henshaw/` }, { prop: "memberOf", value: { name: "Example", url: `${ORIGIN}/` } }],
-		origin: ORIGIN,
-		defaultId: jonId,
-		profile: true,
-	});
-	const doc = build(profilePage(), { override: { pageType: "ProfilePage", articleType: "none" }, publisher: pub, mainEntity: main });
-	assert.deepEqual(byId(doc, `${ORIGIN}/#organization`).founder, { "@id": jonId });
-	assert.deepEqual(byId(doc, jonId).memberOf, { "@id": `${ORIGIN}/#organization` });
-	assertRefsResolve(doc);
-});
-
-test("mainSubjectByline parses byline subjects only", () => {
-	assert.equal(g.mainSubjectByline("byline:abc"), "abc");
-	assert.equal(g.mainSubjectByline("publisher"), null);
-	assert.equal(g.mainSubjectByline("byline:"), null);
-	assert.equal(g.mainSubjectByline(undefined), null);
-});
-
-test("address country becomes a two-letter ISO code", async () => {
-	const out = g.shapeRows([{ prop: "address", value: { addressLocality: "Franklin", addressCountry: "USA" } }], "Organization", "https://example.com");
-	assert.equal(out.address.addressCountry, "US");
-	assert.equal(g.countryCode("United Kingdom"), "GB");
-	assert.equal(g.countryCode("de"), "DE");
-	assert.equal(g.countryCode("Narnia"), "Narnia");
-});