@tsdoctor/seo 0.1.0

package/Attribution.js

@@ -0,0 +1,99 @@
+import { licenseExpressionOf } from "@effected/package-json";
+import { SpdxExpression } from "@effected/spdx";
+import { Option } from "effect";
+
+//#region src/Attribution.ts
+/** The license half of the facts, or nothing when there is no SPDX to read. */
+function licenseFacts(license) {
+	if (license == null) return {
+		licenseIds: [],
+		licenseUrls: []
+	};
+	const parsed = Option.getOrUndefined(licenseExpressionOf(license));
+	if (parsed === void 0) return {
+		licenseIds: [],
+		licenseUrls: []
+	};
+	const entries = SpdxExpression.licensesOf(parsed);
+	const licenseIds = entries.map((entry) => entry.id);
+	const licenseUrls = entries.map((entry) => Option.getOrUndefined(entry.referenceUrl)).filter((url) => url !== void 0);
+	const primary = Option.getOrUndefined(SpdxExpression.primaryLicense(parsed));
+	if (primary === void 0) return {
+		licenseIds,
+		licenseUrls
+	};
+	const referenceUrl = Option.getOrUndefined(primary.referenceUrl);
+	return {
+		licenseIds,
+		licenseUrls,
+		primaryLicenseId: primary.id,
+		...referenceUrl !== void 0 ? { licenseUrl: referenceUrl } : {}
+	};
+}
+/**
+* Where this package lives, preferring the precise answer.
+*
+* @remarks
+* `browseUrl` ignores `directory`, so on a monorepo every member reports the
+* repository root — and that URL is exactly what a crawler uses to tell two
+* packages apart. `directoryUrl` is the monorepo-aware form and returns `None`
+* rather than fabricating a path convention for a host it does not recognize
+* (a self-hosted forge, say).
+*
+* The fallback to `browseUrl` on that `None` is deliberate: schema.org's
+* `codeRepository` denotes the REPOSITORY, not the subdirectory, so the root
+* is a *true* location for the package — merely one that does not distinguish
+* it from its siblings. That is precision loss, not a correctness bug, and it
+* beats omitting the field.
+*/
+const repositoryUrlOf = (repository) => Option.getOrUndefined(Option.orElse(repository.directoryUrl, () => repository.browseUrl));
+/**
+* Derive the attribution facts a documentation page can credit from a decoded
+* package manifest.
+*
+* @remarks
+* Total: a manifest carrying none of these fields yields empty arrays and no
+* optional properties, never a failure. Per-field degradation is the contract —
+* an unparseable license drops only the license facts, an unrecognized
+* repository reference drops only the repository URL.
+*
+* @param manifest - the decoded manifest to read
+* @returns the facts, with every underivable field absent
+*
+* @example
+* ```ts
+* import { PackageManifest } from "@effected/package-json";
+* import { attributionFacts } from "@tsdoctor/seo";
+* import { Effect } from "effect";
+*
+* const program = Effect.gen(function* () {
+*   const manifest = yield* PackageManifest.decode({
+*     name: "@scope/pkg",
+*     version: "1.0.0",
+*     license: "MIT",
+*     repository: { url: "github:owner/repo", directory: "packages/pkg" },
+*   });
+*   const facts = attributionFacts(manifest);
+*   console.log(facts.primaryLicenseId, facts.repositoryUrl);
+*   // => "MIT" "https://github.com/owner/repo/tree/HEAD/packages/pkg"
+* });
+* ```
+*
+* @public
+*/
+function attributionFacts(manifest) {
+	const author = manifest.author;
+	const repositoryUrl = manifest.repository === void 0 ? void 0 : repositoryUrlOf(manifest.repository);
+	return {
+		...author !== void 0 ? { authorName: author.name } : {},
+		...author?.url !== void 0 ? { authorUrl: author.url } : {},
+		maintainerNames: (manifest.maintainers ?? []).map((person) => person.name),
+		...repositoryUrl !== void 0 ? { repositoryUrl } : {},
+		...manifest.homepage !== void 0 ? { homepage: manifest.homepage } : {},
+		...licenseFacts(manifest.license),
+		keywords: [...manifest.keywords ?? []]
+	};
+}
+
+//#endregion
+export { attributionFacts };

package/Canonical.js

@@ -0,0 +1,99 @@
+//#region src/Canonical.ts
+/**
+* URL derivation for a documentation page: the site URL prefix, the canonical
+* page URL, absolute image URLs and image MIME mapping.
+*
+* @remarks
+* `imageMimeType`, `resolveUrl` and `deriveSiteUrl` moved here verbatim from
+* the RSPress adapter's `og-resolver.ts`. `resolveUrl` was `resolveOgUrl`
+* there; canonical links resolve through the same function, so the
+* OG-specific name no longer fits. Everything here is total and synchronous —
+* no Effect, no filesystem.
+*
+* @packageDocumentation
+*/
+/**
+* MIME type mappings for common image formats, used for `og:image:type`.
+*/
+const IMAGE_MIME_TYPES = {
+	jpg: "image/jpeg",
+	jpeg: "image/jpeg",
+	png: "image/png",
+	gif: "image/gif",
+	webp: "image/webp",
+	svg: "image/svg+xml"
+};
+/**
+* The `og:image:type` value for a detected image format, or `undefined` for a
+* format with no mapping.
+*
+* @public
+*/
+function imageMimeType(type) {
+	if (type == null) return void 0;
+	return IMAGE_MIME_TYPES[type.toLowerCase()];
+}
+/**
+* Turn a configured URL into an absolute one.
+*
+* @returns The absolute URL, or `undefined` when the input is neither an
+* absolute `http(s)` URL nor a site-root-relative path. A bare relative path
+* is deliberately rejected rather than guessed at — there is no base to
+* resolve it against that would not silently produce a broken link.
+*
+* @public
+*/
+function resolveUrl(siteUrl, url) {
+	if (url.startsWith("http://") || url.startsWith("https://")) return url;
+	if (url.startsWith("/")) return `${siteUrl}${url}`;
+}
+/**
+* Derive the site URL prefix from the framework's own config.
+*
+* @remarks
+* Replaces the RSPress plugin's former `siteUrl` option. RSPress already knows
+* where a site is deployed — {@link https://rspress.rs/api/config/config-basic#siteorigin | `siteOrigin`}
+* plus `base` — so asking for it a second time invited the two to disagree, and
+* a plugin-level answer that contradicted the site's own would silently emit
+* canonical and `og:url` tags pointing at a host the site is not served from.
+*
+* RSPress concatenates as `siteOrigin + base + routePath`, and **this follows
+* its documented fallback exactly**: with no `siteOrigin`, RSPress uses
+* `base + routePath`. So an unset origin yields a ROOT-RELATIVE prefix rather
+* than nothing.
+*
+* That fallback is what makes the tags inspectable in `rspress dev`, where the
+* site is served from `localhost` and no configured origin could be correct
+* anyway. A root-relative `/images/og.png` resolves against the page's own
+* origin in the browser; it is a *relative* path (`images/og.png`, no leading
+* slash) that has no base to resolve against, and this never emits one.
+*
+* @returns The prefix to put in front of a route that already begins with `/`.
+* `""` when the site declares neither `siteOrigin` nor a non-root `base`, which
+* leaves every URL root-relative. Never has a trailing slash, since every
+* caller appends a route starting with `/`.
+*
+* @public
+*/
+function deriveSiteUrl(siteOrigin, base) {
+	const origin = (siteOrigin ?? "").trim().replace(/\/+$/, "");
+	const path = (base ?? "/").trim();
+	return `${origin}${path === "" || path === "/" ? "" : `/${path.replace(/^\/+/, "").replace(/\/+$/, "")}`}`;
+}
+/**
+* The canonical URL for a page.
+*
+* @remarks
+* With no configured origin the prefix is `""`, so the result is
+* root-relative (`/api/class/foo`) rather than absent. That matches RSPress's
+* own documented `base + routePath` fallback and keeps the tag inspectable
+* under a dev server, where no configured origin could be correct.
+*
+* @public
+*/
+function canonicalUrl(siteUrl, pageRoute) {
+	return `${siteUrl.endsWith("/") ? siteUrl.slice(0, -1) : siteUrl}${pageRoute}`;
+}
+
+//#endregion
+export { canonicalUrl, deriveSiteUrl, imageMimeType, resolveUrl };

package/HeadTag.js

@@ -0,0 +1,69 @@
+//#region src/HeadTag.ts
+/**
+* Escape a JSON string so it cannot terminate the `<script>` element that
+* carries it.
+*
+* @remarks
+* Every string in a JSON-LD graph originates in author-written TSDoc, so a
+* summary containing the literal `<\/script>` would close the element early and
+* inject markup into the page. `JSON.stringify` does not escape it.
+*
+* Escaping both angle brackets as `<` / `>` is valid JSON that
+* parses back to the original characters, so the graph a consumer reads is
+* unchanged while the element becomes unclosable from inside.
+*
+* `&` is escaped for the same reason at a different layer: XHTML parses
+* script content as ordinary element content, where a bare `&` is a
+* well-formedness error. An HTML-parsed page tolerates it; an XHTML-served one
+* does not, and nothing in a docs pipeline guarantees which a consumer serves.
+*
+* The escape is idempotent — no escape sequence it emits contains `<`, `>` or
+* `&` — so a body that arrives already escaped by an upstream serializer
+* survives a second pass unchanged.
+*
+* @public
+*/
+function escapeScriptBody(json) {
+	return json.replaceAll("<", "\\u003C").replaceAll(">", "\\u003E").replaceAll("&", "\\u0026");
+}
+/** An Open Graph style `<meta property=… content=…>`. @public */
+function meta(property, content) {
+	return {
+		tag: "meta",
+		attrs: {
+			property,
+			content
+		}
+	};
+}
+/** A Twitter/standard style `<meta name=… content=…>`. @public */
+function metaNamed(name, content) {
+	return {
+		tag: "meta",
+		attrs: {
+			name,
+			content
+		}
+	};
+}
+/** A `<link rel=… href=…>`. @public */
+function link(rel, href) {
+	return {
+		tag: "link",
+		attrs: {
+			rel,
+			href
+		}
+	};
+}
+/** A `<script type="application/ld+json">` carrying an escaped body. @public */
+function jsonLd(json) {
+	return {
+		tag: "script",
+		attrs: { type: "application/ld+json" },
+		body: escapeScriptBody(json)
+	};
+}
+
+//#endregion
+export { escapeScriptBody, jsonLd, link, meta, metaNamed };

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 C. Spencer Beggs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/OpenGraph.js

@@ -0,0 +1,156 @@
+import { canonicalUrl } from "./Canonical.js";
+import { meta, metaNamed } from "./HeadTag.js";
+import { Schema } from "effect";
+
+//#region src/OpenGraph.ts
+/**
+* Open Graph and Twitter card vocabulary: the metadata schemas, the
+* page-metadata assembly and the two tag emitters.
+*
+* @remarks
+* The schemas and {@link createPageMetadata} / {@link ogAltText} moved here
+* verbatim from the RSPress adapter (`schemas/opengraph.ts` and
+* `og-resolver.ts`). {@link openGraphTags} is the tag-emission logic that was
+* inlined in the adapter's `generateFrontmatter`, lifted unchanged — same tag
+* order, same conditional emission of each optional image sub-tag — so that a
+* second adapter can reach the vocabulary rather than reimplement it.
+*
+* @packageDocumentation
+*/
+/**
+* Structured Open Graph image metadata (alternative to a plain URL string).
+*
+* @public
+*/
+const OpenGraphImageMetadata = Schema.Struct({
+	/** Absolute URL of the image. */
+	url: Schema.String,
+	/** HTTPS URL of the image (for secure contexts). */
+	secureUrl: Schema.optional(Schema.String),
+	/** MIME type of the image (e.g. `"image/png"`). */
+	type: Schema.optional(Schema.String),
+	/** Image width in pixels. */
+	width: Schema.optional(Schema.Number),
+	/** Image height in pixels. */
+	height: Schema.optional(Schema.Number),
+	/** Alt text for the image. */
+	alt: Schema.optional(Schema.String)
+});
+/**
+* Open Graph image: either a plain URL string or structured `OpenGraphImageMetadata`.
+*
+* @public
+*/
+const OpenGraphImageConfig = Schema.Union([Schema.String, OpenGraphImageMetadata]);
+/**
+* Resolved Open Graph metadata for one documentation page.
+*
+* @public
+*/
+const OpenGraphMetadata = Schema.Struct({
+	/** Canonical site base URL. */
+	siteUrl: Schema.String,
+	/** Page route path (e.g. `/api/classes/myclass`). */
+	pageRoute: Schema.String,
+	/** Page description for the `og:description` tag. */
+	description: Schema.String,
+	/** ISO 8601 date string for `article:published_time`. */
+	publishedTime: Schema.String,
+	/** ISO 8601 date string for `article:modified_time`. */
+	modifiedTime: Schema.String,
+	/** Article section label (e.g. `"API"`). */
+	section: Schema.String,
+	/** Article tag keywords. */
+	tags: Schema.mutable(Schema.Array(Schema.String)),
+	/** Optional structured image metadata. */
+	ogImage: Schema.optional(OpenGraphImageMetadata),
+	/** Open Graph object type (e.g. `"article"`). */
+	ogType: Schema.String
+});
+/**
+* Descriptive alt text for a package's (or one API's) OG image.
+*
+* @public
+*/
+function ogAltText(packageName, apiName) {
+	return apiName ? `${apiName} - ${packageName} API Documentation` : `${packageName} API Documentation`;
+}
+/**
+* Assemble the complete Open Graph metadata for one documentation page.
+*
+* @public
+*/
+function createPageMetadata(options) {
+	return {
+		siteUrl: options.siteUrl,
+		pageRoute: options.pageRoute,
+		description: options.description,
+		publishedTime: options.publishedTime,
+		modifiedTime: options.modifiedTime,
+		section: options.section,
+		tags: [
+			"TypeScript",
+			"API",
+			options.packageName
+		],
+		...options.ogImage != null ? { ogImage: options.ogImage } : {},
+		ogType: "article"
+	};
+}
+/**
+* The Open Graph block for a page.
+*
+* @remarks
+* Each optional image sub-tag is emitted only when the resolved image actually
+* carries it — an `og:image:width` with no width is a tag a crawler reads as a
+* declared-but-empty dimension rather than an absent one.
+*
+* @public
+*/
+function openGraphTags(metadata) {
+	const tags = [
+		meta("og:url", canonicalUrl(metadata.siteUrl, metadata.pageRoute)),
+		meta("og:type", metadata.ogType),
+		meta("og:description", metadata.description)
+	];
+	const image = metadata.ogImage;
+	if (image) {
+		tags.push(meta("og:image", image.url));
+		if (image.secureUrl) tags.push(meta("og:image:secure_url", image.secureUrl));
+		if (image.type) tags.push(meta("og:image:type", image.type));
+		if (image.width) tags.push(meta("og:image:width", String(image.width)));
+		if (image.height) tags.push(meta("og:image:height", String(image.height)));
+		if (image.alt) tags.push(meta("og:image:alt", image.alt));
+	}
+	tags.push(meta("article:published_time", metadata.publishedTime));
+	tags.push(meta("article:modified_time", metadata.modifiedTime));
+	tags.push(meta("article:section", metadata.section));
+	for (const tag of metadata.tags) tags.push(meta("article:tag", tag));
+	return tags;
+}
+/**
+* Twitter card tags derived from the same metadata as the Open Graph block.
+*
+* @remarks
+* Twitter reads most `og:` tags directly, so only what it does not infer is
+* emitted here. The card type is a function of whether an image exists —
+* `summary_large_image` with one, `summary` without — because declaring the
+* large card with no image renders as a broken preview rather than degrading
+* to the small one.
+*
+* Twitter's tags use `name`, not `property`.
+*
+* @public
+*/
+function twitterTags(metadata, site) {
+	const tags = [metaNamed("twitter:card", metadata.ogImage ? "summary_large_image" : "summary"), metaNamed("twitter:description", metadata.description)];
+	if (site != null && site !== "") tags.push(metaNamed("twitter:site", site));
+	if (metadata.ogImage) {
+		tags.push(metaNamed("twitter:image", metadata.ogImage.url));
+		if (metadata.ogImage.alt) tags.push(metaNamed("twitter:image:alt", metadata.ogImage.alt));
+	}
+	return tags;
+}
+
+//#endregion
+export { OpenGraphImageConfig, OpenGraphImageMetadata, OpenGraphMetadata, createPageMetadata, ogAltText, openGraphTags, twitterTags };

package/README.md

@@ -0,0 +1,94 @@
+# @tsdoctor/seo
+
+[![npm](https://img.shields.io/npm/v/@tsdoctor%2Fseo?label=npm&color=cb3837)](https://www.npmjs.com/package/@tsdoctor/seo)
+[![License: MIT](https://img.shields.io/badge/License-MIT-4caf50.svg)](https://opensource.org/licenses/MIT)
+[![Node.js %3E%3D24.11.0](https://img.shields.io/badge/Node.js-%3E%3D24.11.0-5fa04e.svg)](https://nodejs.org/)
+[![TypeScript 6.0](https://img.shields.io/badge/TypeScript-6.0-3178c6.svg)](https://www.typescriptlang.org/)
+
+Framework-neutral `<head>` metadata for static TypeScript API documentation: schema.org JSON-LD, Open Graph and Twitter card vocabulary, canonical URLs, and package attribution derived from a `package.json` manifest. The package decides which tags a documentation page gets; a framework adapter only renders them into whatever its framework calls a head entry.
+
+## The one seam
+
+`headTags(input)` returns a flat array of neutral `HeadTag` values — a canonical `<link>`, the Open Graph block, the Twitter card block, then a JSON-LD `<script>`. A `HeadTag` is deliberately dumb (`{ tag, attrs, body? }`), so RSPress renders one into a frontmatter `head` pair and VitePress renders the same value into a `transformHead` entry. Composition living here is what keeps two adapters from disagreeing about which tags a page gets.
+
+## What you get
+
+- **`headTags(input: SeoPageInput)`** — every `<head>` tag for one page, in a fixed order so a diff over generated pages stays readable.
+- **`HeadTag`, `meta`, `metaNamed`, `link`, `jsonLd`, `escapeScriptBody`** — the neutral tag vocabulary. `escapeScriptBody` is idempotent, so a body already escaped by an upstream serializer survives a second pass unchanged.
+- **`deriveSiteUrl`, `canonicalUrl`, `resolveUrl`, `imageMimeType`** — URL derivation. With no configured origin the prefix is `""`, so URLs stay root-relative and the tags are still emitted rather than dropped.
+- **`OpenGraphImageConfig`, `OpenGraphImageMetadata`, `OpenGraphMetadata`, `createPageMetadata`, `openGraphTags`, `twitterTags`, `ogAltText`** — the Open Graph and Twitter card vocabulary, as Effect Schemas plus the emitters over them.
+- **`attributionFacts(manifest)`** — author, maintainers, repository URL, homepage, SPDX license ids and per-license canonical URLs, and keywords, derived from an `@effected/package-json` `PackageManifest`. Total and synchronous: a manifest carrying none of these yields empty arrays and no optional properties.
+- **`packageContext`, `derive`, `deriveScriptBody`** — the schema.org graph. `packageContext` is derived once per package; `derive` assembles a page's `@graph` (a `SoftwareSourceCode`, a `TechArticle` and an `APIReference`, linked by `isPartOf` and `mainEntity`, plus a `Person` per credited human).
+
+## Install
+
+```bash
+npm install @tsdoctor/seo
+# or
+pnpm add @tsdoctor/seo
+```
+
+This is an ESM-only package. `effect`, `@effected/package-json`, `@effected/schema-org` and `@effected/spdx` are peer dependencies. It is pure — no filesystem, no network, no native dependencies.
+
+## Quick start
+
+```ts
+import { deriveSiteUrl, headTags } from "@tsdoctor/seo";
+
+const siteUrl = deriveSiteUrl("https://docs.example.com", "/");
+// "https://docs.example.com"
+
+const tags = headTags({
+  siteUrl,
+  pageRoute: "/api/class/pipeline",
+  description: "Composes transformation steps.",
+  publishedTime: "2026-01-15T12:00:00.000Z",
+  modifiedTime: "2026-01-17T10:30:00.000Z",
+  section: "Classes",
+  packageName: "my-library",
+});
+
+console.log(tags[0]);
+// { tag: "link", attrs: { rel: "canonical", href: "https://docs.example.com/api/class/pipeline" } }
+```
+
+Structured data is a separate step because the package-level nodes are worth deriving once and reusing across every page of a package. `manifest` below is the documented package's `package.json` decoded through `@effected/package-json`'s `PackageManifest`, which is what gives attribution typed `Person`, `Repository` and SPDX license values to work from:
+
+```ts
+import { attributionFacts, deriveScriptBody, packageContext } from "@tsdoctor/seo";
+
+const pkg = packageContext({
+  siteUrl,
+  baseRoute: "/api",
+  packageName: "my-library",
+  version: manifest.version,
+  description: manifest.description,
+  attribution: attributionFacts(manifest),
+});
+
+const body = deriveScriptBody(pkg, {
+  pageRoute: "/api/class/pipeline",
+  symbolName: "Pipeline",
+  description: "Composes transformation steps.",
+  section: "Classes",
+  publishedTime: "2026-01-15T12:00:00.000Z",
+  modifiedTime: "2026-01-17T10:30:00.000Z",
+});
+// a Result: Success carries the serialized @graph, Failure a StructuredDataError
+```
+
+Pass the serialized graph back as `headTags`'s `structuredData` and it becomes the page's JSON-LD `<script>`.
+
+## Two postures worth knowing
+
+**Degrade, never fail.** Nothing here should be able to stop a documentation build. A graph that cannot be assembled fails with a typed `StructuredDataError` rather than throwing, so a caller reports it as a diagnostic and renders the page without that tag. Identity mistakes — a malformed `@id`, a duplicate, a colliding term — all land on that one error channel.
+
+**Absent rather than guessed.** Attribution omits a field it cannot derive instead of inventing one, because every value ends up in markup a crawler reads as authoritative. License URLs come from the SPDX catalog's own per-entry reference URL, never from concatenating an id onto a URL prefix — a `LicenseRef` has no such page and drops out of the array rather than appearing as a fabricated link. `licenseIds` and `licenseUrls` are therefore not index-aligned.
+
+## Provenance
+
+Added in phase 4 of the tsdoctor consolidation. It absorbed the Open Graph resolver and schema definitions that lived in `rspress-plugin-api-extractor`, and the schema.org vocabulary underneath it comes from `@effected/schema-org`, whose offline conformance validator gates this package's fixtures in CI.
+
+## License
+
+[MIT](LICENSE)

package/Seo.js

@@ -0,0 +1,49 @@
+import { canonicalUrl } from "./Canonical.js";
+import { jsonLd, link } from "./HeadTag.js";
+import { createPageMetadata, openGraphTags, twitterTags } from "./OpenGraph.js";
+
+//#region src/Seo.ts
+/**
+* The one seam an adapter consumes: everything a documentation page needs in
+* its `<head>`, as a flat array of neutral {@link HeadTag}s.
+*
+* @remarks
+* Composition lives here so that every adapter emits the same tags in the same
+* order. An adapter's job is to render a `HeadTag` into whatever its framework
+* calls a head entry — never to decide which tags a page gets.
+*
+* @packageDocumentation
+*/
+/**
+* Every `<head>` tag for one documentation page.
+*
+* @remarks
+* The order — canonical link, Open Graph block, Twitter block, then the
+* JSON-LD script — is fixed. It carries no semantics: a crawler reads the
+* tags as a set. It is fixed so that a page's emitted head is stable
+* build-to-build and a diff over generated pages stays readable.
+*
+* @public
+*/
+function headTags(input) {
+	const metadata = createPageMetadata({
+		siteUrl: input.siteUrl,
+		pageRoute: input.pageRoute,
+		description: input.description,
+		publishedTime: input.publishedTime,
+		modifiedTime: input.modifiedTime,
+		section: input.section,
+		packageName: input.packageName,
+		...input.ogImage != null ? { ogImage: input.ogImage } : {}
+	});
+	const tags = [
+		link("canonical", canonicalUrl(input.siteUrl, input.pageRoute)),
+		...openGraphTags(metadata),
+		...twitterTags(metadata, input.twitterSite)
+	];
+	if (input.structuredData != null && input.structuredData !== "") tags.push(jsonLd(input.structuredData));
+	return tags;
+}
+
+//#endregion
+export { headTags };