@aglyn/aglyn 1.0.0-beta.143

package/src/lib/app-utils/content-authors.js

@@ -0,0 +1,771 @@
+import { _ as _extends } from "@swc/helpers/_/_extends";
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ import { HostEntityType } from "../foundation/definitions/platform.types.js";
+import { MEDIA_ALT_MAX_LENGTH } from "./media-metadata.js";
+import { absoluteMediaSrc } from "./media-ref.js";
+import { urlSlugSegment } from "./url-slug.js";
+/**
+ * Custom content authors (AGL-2486).
+ *
+ * ## An author is a RECORD, not an account
+ *
+ * Until now a post's byline was `entry.authorName` — one free-typed string
+ * (AGL-686), retyped on every entry, with no url, no portrait, no social
+ * profiles and no way to say the piece was written by the company rather than
+ * a person. That is enough to print a name under a headline and not enough to
+ * be `schema.org/author`, which wants an ENTITY: something with a stable
+ * identity a crawler can join across articles and against the site's own
+ * publisher entity.
+ *
+ * So the author becomes a document the customer authors and an entry
+ * REFERENCES (`entry.authorId`). Publishing a piece under a pen name, a guest
+ * contributor, or the company itself is then the ordinary case rather than a
+ * retyped string, and renaming an author updates every post at render time —
+ * the same property `categoryId` bought the taxonomy in AGL-582.
+ *
+ * ## Scope: the HOST, at `hosts/{hostId}/authors/{authorId}`
+ *
+ * Not the org, and this follows the data rather than inventing a rule.
+ * Content collections live at `hosts/{hostId}/collections/{collectionId}` and
+ * their entries underneath; the console surface that manages them is
+ * `/[orgSlug]/hosts/[host]/content`; and the entity an author has to
+ * serialise consistently with — `host.seo.entity`, the site's publisher — is
+ * a field of the host document. An author referenced from an entry therefore
+ * resolves inside the same document tree the entry already lives in, with the
+ * host's existing rules and the tenant's existing Admin-SDK reads. An
+ * org-scoped store would need a second root, a second read on every entry
+ * render, and a sharing model ("which sites may publish under this byline")
+ * that nothing in the product asks for yet.
+ *
+ * ## The type is a BRANCH, not a label
+ *
+ * `schema.org/Person` and `schema.org/Organization` do not carry the same
+ * fields: a Person has `jobTitle` and `worksFor` and its portrait is `image`;
+ * an Organization has no job title and its mark is `logo`. Emitting one
+ * shape with the other's keys is invalid structured data that validates as
+ * "ignored", so {@link contentAuthorJsonLd} branches on the type and the
+ * console hides the fields that do not apply.
+ */ /**
+ * How many authors one host may hold (AGL-2486).
+ *
+ * A flat PLATFORM cap, deliberately, in the shape of
+ * `ENTRIES_MAX_PER_COLLECTION` / `ACTIONS_MAX_PER_HOST` (AGL-2266) and
+ * `WEBHOOK_MAX_PER_HOST` (AGL-1360): nothing here is priced, no
+ * `OrgEntitlements` key is added, every plan gets the same number. The reason
+ * a number exists at all is the one those issues wrote down — a
+ * client-creatable host subcollection with no cap is unbounded Firestore
+ * documents mintable from the browser against a $0 subscription — and adding
+ * a new subcollection without one would be that hole, freshly dug.
+ *
+ * 200 is far past any real masthead (the largest content collection in
+ * production holds double digits of ENTRIES, let alone bylines) and small
+ * enough that the console can list every author in a single unpaginated read.
+ */ export const AUTHORS_MAX_PER_HOST = 200;
+/** Longest stored author name; the byline is a name, not a paragraph. */ export const AUTHOR_NAME_MAX_LENGTH = 120;
+/** Longest stored author slug; it is one path segment, not a sentence. */ export const AUTHOR_SLUG_MAX_LENGTH = 80;
+/**
+ * The site-wide segment an author's page lives under (AGL-2518):
+ * `/author/{slug}`, and `/author/{slug}/page/{n}` after it.
+ *
+ * Singular, and site-wide rather than nested under a collection. AGL-2517
+ * put this archive at `/{collection}/author/{slug}`, which gives one person
+ * as many pages as the site has collections — three partial archives of the
+ * same author, none of them the address a byline should link to, all three
+ * competing for the same search result. A person is not a property of a
+ * collection.
+ *
+ * NOT added to `RESERVED_SCREEN_ROUTE_SEGMENTS`. The catch-all resolves
+ * published screens BEFORE it reaches this route, exactly as it does for a
+ * collection's own `/{slug}`, so a site that already publishes a page at
+ * `/author` keeps it and simply has no author pages — the same trade every
+ * other platform-built address on a tenant site makes.
+ */ export const AUTHOR_ROUTE_SEGMENT = 'author';
+/** Most `sameAs` profile links one author may carry. */ export const AUTHOR_SAME_AS_MAX = 12;
+/** Most display links one author may carry. */ export const AUTHOR_LINKS_MAX = 12;
+/**
+ * The platforms whose mark is fixed (AGL-2516).
+ *
+ * `icon` is an `mdi` id, resolved to a path by whichever surface draws it —
+ * the renderer imports these few directly rather than through the catalog,
+ * because the set is closed and known at build time.
+ *
+ * Ordered as a masthead would list them rather than alphabetically: the
+ * places writers are actually followed first, then the ways to reach them.
+ */ export const AUTHOR_SOCIAL_PLATFORMS = [
+    {
+        id: 'x',
+        label: 'X',
+        icon: 'twitter'
+    },
+    {
+        id: 'linkedin',
+        label: 'LinkedIn',
+        icon: 'linkedin'
+    },
+    {
+        id: 'github',
+        label: 'GitHub',
+        icon: 'github'
+    },
+    {
+        id: 'mastodon',
+        label: 'Mastodon',
+        icon: 'mastodon'
+    },
+    {
+        id: 'youtube',
+        label: 'YouTube',
+        icon: 'youtube'
+    },
+    {
+        id: 'instagram',
+        label: 'Instagram',
+        icon: 'instagram'
+    },
+    {
+        id: 'facebook',
+        label: 'Facebook',
+        icon: 'facebook'
+    },
+    {
+        id: 'website',
+        label: 'Website',
+        icon: 'web'
+    },
+    {
+        id: 'email',
+        label: 'Email',
+        icon: 'email'
+    },
+    {
+        id: 'rss',
+        label: 'RSS',
+        icon: 'rss'
+    }
+];
+/** The platform a link declares, or `undefined` when it is a custom one. */ export function authorLinkPlatform(platform) {
+    const id = typeof platform === 'string' ? platform.trim() : '';
+    if (!id) return undefined;
+    return AUTHOR_SOCIAL_PLATFORMS.find((entry)=>entry.id === id);
+}
+/**
+ * What a link is CALLED, which is never the author's choice on a known
+ * platform.
+ *
+ * A custom link with no label falls back to its own URL rather than to
+ * something generic: "Link" beside four other "Link"s is not an accessible
+ * name, and the URL at least distinguishes them.
+ */ export function authorLinkLabel(link) {
+    const known = authorLinkPlatform(link.platform);
+    if (known) return known.label;
+    return text(link.label, 60) || text(link.url, 400);
+}
+/**
+ * Schemes an author link may use.
+ *
+ * `https:` and `mailto:` only, matching the share bar and the Entry Author
+ * card's own href guard. `http:` is excluded deliberately — a byline link is
+ * published on every post its author wrote, and a mixed-content warning
+ * across a whole archive is a poor trade for a scheme nobody should still be
+ * publishing. Everything else, `javascript:` first among them, is a script
+ * injection wearing a URL.
+ */ const SAFE_AUTHOR_LINK_HREF = /^(https:\/\/|mailto:)/i;
+/**
+ * Sanitize the stored link rows into the shape a renderer may assume.
+ *
+ * Drops any row without a usable, safely-schemed URL — a link that goes
+ * nowhere is worse than an absent one, because it still takes a click. A row
+ * naming a platform keeps ONLY the platform (its label and icon come from the
+ * registry, so a stored label or icon beside one is stale data that must not
+ * win); a custom row keeps its label and icon and drops any platform id that
+ * did not resolve.
+ */ export function normalizeContentAuthorLinks(value) {
+    if (!Array.isArray(value)) return [];
+    const links = [];
+    for (const row of value){
+        if (!row || typeof row !== 'object') continue;
+        const raw = row;
+        const url = text(raw['url'], 400);
+        if (!url || !SAFE_AUTHOR_LINK_HREF.test(url)) continue;
+        const known = authorLinkPlatform(raw['platform']);
+        if (known) {
+            links.push({
+                platform: known.id,
+                url
+            });
+        } else {
+            links.push({
+                label: text(raw['label'], 60),
+                icon: text(raw['icon'], 120),
+                iconPath: text(raw['iconPath'], 4000),
+                url
+            });
+        }
+        if (links.length >= AUTHOR_LINKS_MAX) break;
+    }
+    return links;
+}
+/**
+ * The author's schema type, tolerant of every spelling the store holds.
+ *
+ * The numeric enum is what `HostEntityType` declares, but the Setup → SEO →
+ * Entity form persists its Select value — a TEMPLATE LITERAL, i.e. the string
+ * `"1"` or `"2"` — and the tenant's structured data compared that with
+ * `=== HostEntityType.PERSON` (the number `2`). Strict equality across a
+ * string and a number is always false, so a site that declared itself a
+ * Person published `"@type": "Organization"` regardless (AGL-2486). Coercing
+ * here, once, is what stops the same defect being re-derived per call site.
+ *
+ * Anything unrecognised — absent, empty, a stray value — resolves to
+ * `Organization`, which is the default this repo has always emitted.
+ */ export function contentAuthorSchemaType(type) {
+    return Number(type) === HostEntityType.PERSON ? 'Person' : 'Organization';
+}
+const text = (value, max = AUTHOR_NAME_MAX_LENGTH)=>typeof value === 'string' ? value.trim().slice(0, max) : '';
+/**
+ * A stored author document, sanitized into the shape the rest of the codebase
+ * may assume — the {@link mapCollectionCategories} treatment, one collection
+ * over: only strings survive, `sameAs` keeps string entries only, and an
+ * author with no name resolves to `null` because a nameless byline is not a
+ * byline and `schema.org` requires `name` on both branches.
+ */ export function normalizeContentAuthor(value, id) {
+    if (!value || typeof value !== 'object') return null;
+    const raw = value;
+    const name = text(raw['name']);
+    if (!name) return null;
+    const sameAs = Array.isArray(raw['sameAs']) ? raw['sameAs'].map((item)=>text(item, 400)).filter(Boolean).slice(0, AUTHOR_SAME_AS_MAX) : [];
+    return _extends({}, id ? {
+        $id: id
+    } : typeof raw['$id'] === 'string' ? {
+        $id: raw['$id']
+    } : {}, {
+        type: contentAuthorSchemaType(raw['type']) === 'Person' ? HostEntityType.PERSON : HostEntityType.ORGANIZATION,
+        name,
+        // Through the URL slugifier rather than stored raw: this is a path
+        // segment, and a stored `Chris Taylor` would build `/author/Chris Taylor`
+        // while every incoming request arrived slugified and matched nothing.
+        slug: urlSlugSegment(text(raw['slug'], AUTHOR_SLUG_MAX_LENGTH)),
+        url: text(raw['url'], 400),
+        image: text(raw['image'], 1000),
+        jobTitle: text(raw['jobTitle']),
+        worksFor: text(raw['worksFor']),
+        sameAs,
+        links: normalizeContentAuthorLinks(raw['links']),
+        bio: text(raw['bio'], 600),
+        // Shorter than the bio it overrides, because it is read alone in a search
+        // result rather than beside a heading — past this nothing survives the
+        // snippet, so storing more only hides the cut from whoever wrote it.
+        seoDescription: text(raw['seoDescription'], 300),
+        seoImage: text(raw['seoImage'], 1000),
+        seoImageAlt: text(raw['seoImageAlt'], MEDIA_ALT_MAX_LENGTH)
+    });
+}
+/**
+ * The segment that addresses one author's page.
+ *
+ * Precedence is the author's stored {@link ContentAuthorRecord.slug} first
+ * and the slugified name second — the opposite of what AGL-2517 built, which
+ * put the record ID first "so the link survives a rename".
+ *
+ * A Firestore auto-id does survive a rename, and it is also unreadable. This
+ * is a PUBLIC address on a marketing site: it goes in a byline, a share
+ * sheet, a CV. `/author/hT3kQ9xLmZ2` is not an address anyone can read, and
+ * the rename it protects against is answered better by the stored slug, which
+ * is stable AND readable. The id is still ACCEPTED on the way in (see
+ * `entryMatchesAuthorRoute`), so a link built under the old precedence keeps
+ * resolving.
+ *
+ * Empty when there is nothing addressable, so a caller renders plain text
+ * rather than a link to `/author/`.
+ */ export function contentAuthorSlug(options) {
+    var _options_author, _options_author1, _options_author2;
+    return urlSlugSegment((_options_author = options.author) == null ? void 0 : _options_author.slug) || urlSlugSegment((_options_author1 = options.author) == null ? void 0 : _options_author1.name) || urlSlugSegment(options.authorName) || urlSlugSegment(options.authorId) || urlSlugSegment((_options_author2 = options.author) == null ? void 0 : _options_author2.$id);
+}
+/**
+ * Every segment that should resolve to this author.
+ *
+ * The archive answers to the stored slug, the display name, the legacy
+ * free-typed byline and the record id, because which of those a link happens
+ * to carry depends on when it was built and by what — and a byline that
+ * 404s is worse than one pointing at a page with an unexpected URL.
+ *
+ * Deduped, and empties dropped: a set containing `''` would match a request
+ * for `/author/` against every author on the site.
+ */ export function contentAuthorSlugCandidates(options) {
+    var _options_author, _options_author1, _options_author2;
+    return Array.from(new Set([
+        (_options_author = options.author) == null ? void 0 : _options_author.slug,
+        (_options_author1 = options.author) == null ? void 0 : _options_author1.name,
+        options.authorName,
+        options.authorId,
+        (_options_author2 = options.author) == null ? void 0 : _options_author2.$id
+    ].map((value)=>urlSlugSegment(value)).filter(Boolean)));
+}
+/** Does `slug` address this author? */ export function contentAuthorMatchesSlug(options, slug) {
+    const wanted = urlSlugSegment(slug);
+    if (!wanted) return false;
+    return contentAuthorSlugCandidates(options).includes(wanted);
+}
+/**
+ * The author's page on this site — `/author/{slug}` (AGL-2518).
+ *
+ * Empty when nothing addresses the author, which is what lets a template bind
+ * this unconditionally: a link whose href does not resolve renders as inert
+ * markup of the same element (AGL-1268/1357), so an entry with no byline
+ * shows no link rather than one pointing nowhere.
+ */ export function contentAuthorPageUrl(options) {
+    const slug = contentAuthorSlug(options);
+    return slug ? `/${AUTHOR_ROUTE_SEGMENT}/${slug}` : '';
+}
+/**
+ * The paginated sub-path of an author page — `/author/{slug}/page/{n}`.
+ *
+ * The same word the collection listing pages with, deliberately: a reader who
+ * has learned one URL shape on the site has learned both, and a second
+ * spelling would buy nothing. Declared here rather than imported from
+ * `collection-entries`, which imports THIS module.
+ */ const AUTHOR_PAGE_SEGMENT = 'page';
+/**
+ * The canonical URL of one page of an author's archive (AGL-2518).
+ *
+ * Page 1 is the bare `/author/{slug}` — there is no `/author/{slug}/page/1`,
+ * so the first page cannot become a second address for itself. The rule
+ * `collectionListUrl` states, one route over.
+ */ export function contentAuthorPageAtUrl(options) {
+    const base = contentAuthorPageUrl(options);
+    if (!base) return '';
+    const page = Number(options.page);
+    return Number.isFinite(page) && page > 1 ? `${base}/${AUTHOR_PAGE_SEGMENT}/${Math.floor(page)}` : base;
+}
+/**
+ * Where an author archive's pager can go from here (AGL-2518).
+ *
+ * The `collectionPaginationLinks` contract, restated for this route: **the
+ * edges resolve to the empty string, never to a URL**, which is what lets a
+ * designed author template bind `{{pagination.prevUrl}}` unconditionally. A
+ * link whose href is `''` renders as an inert placeholder of the same element
+ * (AGL-1268/1357), which is the correct pager on page 1 of 1.
+ *
+ * ONE computation, because it has the same two consumers that must agree: the
+ * built-in fallback's pager nodes and the tokens a template binds.
+ */ export function contentAuthorPaginationLinks(options) {
+    const positive = (value)=>{
+        const parsed = Math.floor(Number(value));
+        return Number.isFinite(parsed) && parsed > 0 ? parsed : 1;
+    };
+    const page = positive(options.page);
+    const totalPages = positive(options.totalPages);
+    const href = (n)=>contentAuthorPageAtUrl(_extends({}, options, {
+            page: n
+        }));
+    return {
+        page,
+        totalPages,
+        prevUrl: page > 1 ? href(page - 1) : '',
+        nextUrl: page < totalPages ? href(page + 1) : ''
+    };
+}
+/**
+ * Parse a path into an author route, or `null` when the path is not one.
+ *
+ * The two shapes are `/author/{slug}` and `/author/{slug}/page/{n}`, matching
+ * the collection listing's own pagination so a reader who has learned one URL
+ * shape on the site has learned both.
+ *
+ * A pure parser, deliberately, for the reason `parseCollectionRoute` is one:
+ * the tenant loader and its tests must not be able to disagree about what the
+ * route table says. Page `0`, a negative page and a non-numeric page all
+ * resolve to `null` rather than to page 1, so a nonsense URL 404s instead of
+ * silently serving the first page under a second address.
+ */ export function parseContentAuthorRoute(segments) {
+    const parts = (segments != null ? segments : []).filter(Boolean);
+    if (parts[0] !== AUTHOR_ROUTE_SEGMENT) return null;
+    const authorSlug = urlSlugSegment(parts[1]);
+    if (!authorSlug) return null;
+    if (parts.length === 2) return {
+        authorSlug,
+        page: 1
+    };
+    if (parts.length === 4 && parts[2] === AUTHOR_PAGE_SEGMENT) {
+        const page = Number(parts[3]);
+        return Number.isInteger(page) && page >= 1 ? {
+            authorSlug,
+            page
+        } : null;
+    }
+    return null;
+}
+/**
+ * `schema.org` JSON-LD for one author (AGL-2486) — a `Person` or an
+ * `Organization`, with the fields that branch actually defines.
+ *
+ * | field      | Person                    | Organization |
+ * | ---------- | ------------------------- | ------------ |
+ * | `name`     | required                  | required     |
+ * | `url`      | optional                  | optional     |
+ * | portrait   | `image`                   | `logo`       |
+ * | `jobTitle` | optional                  | — not valid  |
+ * | `worksFor` | optional (`Organization`) | — not valid  |
+ * | `sameAs`   | optional                  | optional     |
+ *
+ * The image goes through {@link absoluteMediaSrc}, the same resolver
+ * `og:image` and `Article.image` use (AGL-1343/1407), so a portrait picked
+ * from the DAM reaches the structured data as a fetchable absolute URL rather
+ * than the literal string `media:{scope}/{id}`. An unresolvable reference —
+ * or a site-relative path with no origin to resolve against — emits NO image
+ * key at all rather than a broken one.
+ *
+ * Returns `undefined` for an author with no usable name, so every call site
+ * can spread the result conditionally instead of emitting `"author": null`.
+ *
+ * ## Escaping
+ *
+ * Nothing is escaped HERE, and that is correct: this returns a VALUE, and the
+ * one place a value becomes markup is `Aglyn.safeJsonLd`, which every
+ * `<script type="application/ld+json">` in the repo is built with. It escapes
+ * `<`, `>`, `&` and U+2028/U+2029 to their `\uXXXX` forms after
+ * `JSON.stringify`, so an author named `</script><img onerror=…>` serialises
+ * as inert text rather than closing the element (AGL-496). Escaping a second
+ * time here would double-encode and put literal backslashes in a byline.
+ */ export function contentAuthorJsonLd(author, context) {
+    var _normalized_sameAs, _normalized_links;
+    const normalized = normalizeContentAuthor(author, author == null ? void 0 : author.$id);
+    if (!normalized) return undefined;
+    const schemaType = contentAuthorSchemaType(normalized.type);
+    const image = absoluteMediaSrc(normalized.image, {
+        hostId: context == null ? void 0 : context.hostId,
+        origin: context == null ? void 0 : context.origin
+    });
+    const sameAs = Array.from(new Set([
+        ...(_normalized_sameAs = normalized.sameAs) != null ? _normalized_sameAs : [],
+        ...((_normalized_links = normalized.links) != null ? _normalized_links : []).map((link)=>{
+            var _link_url;
+            return (_link_url = link.url) != null ? _link_url : '';
+        }).filter((url)=>/^https:\/\//i.test(url))
+    ])).slice(0, AUTHOR_SAME_AS_MAX);
+    return _extends({
+        '@type': schemaType,
+        name: normalized.name
+    }, normalized.url ? {
+        url: normalized.url
+    } : {}, image ? schemaType === 'Person' ? {
+        image
+    } : {
+        logo: image
+    } : {}, schemaType === 'Person' && normalized.jobTitle ? {
+        jobTitle: normalized.jobTitle
+    } : {}, schemaType === 'Person' && normalized.worksFor ? {
+        worksFor: {
+            '@type': 'Organization',
+            name: normalized.worksFor
+        }
+    } : {}, sameAs.length ? {
+        sameAs
+    } : {});
+}
+/**
+ * `schema.org` JSON-LD for the SITE entity (`host.seo.entity`) — the value
+ * `Article.publisher` and `WebSite.publisher` are built from.
+ *
+ * Lives beside {@link contentAuthorJsonLd} on purpose (AGL-2486): a site
+ * entity and a post author answer the same question about two different
+ * subjects, and the reason the Person branch was broken for two years is that
+ * the answer was written inline at its one call site where nothing could
+ * test it. One module, two entry points, one `Person`/`Organization`
+ * decision — {@link contentAuthorSchemaType}.
+ *
+ * `logo` is emitted verbatim on BOTH branches, unchanged from what the tenant
+ * has always published. It is `host.seo.entity.logo`, a plain URL field on
+ * the Setup form rather than a media-picker target, and re-keying it to
+ * `image` for a Person would change the publisher block on every page of
+ * every site that set one — a separate decision from this one.
+ */ export function hostSeoEntityJsonLd(entity) {
+    const name = text(entity == null ? void 0 : entity.name, 400);
+    if (!name) return undefined;
+    return {
+        '@type': contentAuthorSchemaType(entity == null ? void 0 : entity.type),
+        name
+    };
+}
+/**
+ * The publisher's picture, under the property its TYPE actually has
+ * (AGL-2486).
+ *
+ * `schema.org` gives `logo` to an Organization and not to a Person; a Person
+ * carries `image`. The tenant emitted `logo` for both, so a site that declared
+ * itself a Person published a property its own `@type` does not define —
+ * ignored by every consumer, which is the worst kind of wrong: the field is
+ * set, the console says it is published, and nothing renders it.
+ *
+ * That is the same shape as the bug one function up, where a string `"2"` was
+ * compared with a numeric enum and no site could ever publish `Person` at all.
+ * Both resolve here so the type is decided in exactly one place.
+ *
+ * Returns a spreadable object so callers stay a spread rather than a ternary:
+ * `{...hostSeoEntityImageJsonLd(entity)}` adds nothing when there is no
+ * picture, which is what an absent property should cost.
+ */ export function hostSeoEntityImageJsonLd(entity, context) {
+    /*
+    Through `absoluteMediaSrc`, exactly as an author's portrait goes
+    (AGL-1343/1407). The stored value has three generations — a raw storage
+    URL, a site-relative CDN path, and a `media:` reference — and the site
+    entity's was the one path still emitting whichever it found. A `media:`
+    reference reaches Google as the literal string `media:{scope}/{id}`,
+    which does not fetch; a site-relative path with no origin does not either.
+
+    An unresolvable value emits NO key rather than a broken one — the same
+    rule the author serializer states, and the reason both return a spreadable
+    object instead of a URL.
+  */ /*
+    TRIMMED first. `absoluteMediaSrc` does not trim, and a whitespace-only
+    value — what a field cleared by typing spaces leaves behind — is not
+    empty to it: it reads as a relative path and comes back joined to the
+    origin, so the site would publish `https://example.com/   ` as its
+    publisher logo. Trimmed here rather than in the resolver, which og:image
+    and every author portrait also go through.
+  */ const stored = typeof (entity == null ? void 0 : entity.logo) === 'string' ? entity.logo.trim() : '';
+    const image = stored ? absoluteMediaSrc(stored, {
+        hostId: context == null ? void 0 : context.hostId,
+        origin: context == null ? void 0 : context.origin
+    }) : '';
+    if (!image) return {};
+    return contentAuthorSchemaType(entity == null ? void 0 : entity.type) === 'Person' ? {
+        image
+    } : {
+        logo: image
+    };
+}
+/**
+ * The author record an entry publishes under, or `null` for "the site".
+ *
+ * ## Precedence, and why the legacy string keeps working
+ *
+ * 1. `entry.authorId` resolving against the host's authors — the new shape.
+ * 2. `entry.authorName` — every entry written before AGL-2486, and every
+ *    entry whose editor chose "custom byline" instead of a record. Promoted
+ *    to a `Person` with just a name, which is EXACTLY the JSON-LD the tenant
+ *    already emitted for it, so no published page's structured data changes.
+ * 3. `null` — the caller falls back to the site's publisher entity, as before.
+ *
+ * An `authorId` pointing at a DELETED author falls through to step 2 and then
+ * to the site rather than resolving to nothing: an author record removed from
+ * the masthead must not silently strip the byline off ten years of posts.
+ */ export function resolveEntryAuthor(entry, authors) {
+    var _ref, _ref1;
+    const authorId = ((_ref = entry == null ? void 0 : entry.authorId) != null ? _ref : '').trim();
+    if (authorId) {
+        const match = (authors != null ? authors : []).find((author)=>(author == null ? void 0 : author.$id) === authorId);
+        const normalized = normalizeContentAuthor(match, authorId);
+        if (normalized) return normalized;
+    }
+    const legacy = ((_ref1 = entry == null ? void 0 : entry.authorName) != null ? _ref1 : '').trim();
+    if (legacy) {
+        return {
+            type: HostEntityType.PERSON,
+            name: legacy,
+            sameAs: []
+        };
+    }
+    return null;
+}
+/**
+ * The byline TEXT for an entry — what `{{entry.author}}` and the Entry Meta
+ * block print (AGL-1459). Resolves a record's name, falls back to the legacy
+ * string, and returns `''` when neither exists so the block renders nothing
+ * rather than the word "undefined".
+ */ export function resolveEntryAuthorName(entry, authors) {
+    var _ref;
+    var _resolveEntryAuthor;
+    return (_ref = (_resolveEntryAuthor = resolveEntryAuthor(entry, authors)) == null ? void 0 : _resolveEntryAuthor.name) != null ? _ref : '';
+}
+/** The fragment identifier the site entity is published under. */ export const SITE_ENTITY_FRAGMENT = '#organization';
+/**
+ * EVERY PROFILE THE SITE CLAIMS AS ITSELF — `schema.org` `sameAs` (AGL-3148).
+ *
+ * Two fields hold these and only one was ever published. `seo.entity.sameAs`
+ * is the SEO form, and a production read found it unset on every host on the
+ * platform; `business.socialLinks` is the contact card the site's own footer
+ * renders from, and it is the one publishers actually fill in. So the
+ * structured data named no profiles at all on any site, while the profiles sat
+ * one field over being drawn into the page.
+ *
+ * Folding the second into `sameAs` is the AGL-2516 move one level up: a link
+ * the SITE prints is a profile the site claims, and asking a publisher to
+ * retype it into an SEO field to be believed is asking them to maintain the
+ * same list twice. The entity field stays FIRST, because it is the one written
+ * deliberately for this purpose.
+ *
+ * https-only and de-duplicated, matching both serializers beside it: a profile
+ * URL that is not fetchable teaches a consumer nothing, and one identity listed
+ * twice reads as two.
+ */ export function siteProfileUrls(host) {
+    var _ref, _ref1;
+    var _host_business, _host_seo_entity, _host_seo;
+    const rendered = ((_ref = host == null ? void 0 : (_host_business = host.business) == null ? void 0 : _host_business.socialLinks) != null ? _ref : []).map((link)=>{
+        var _ref;
+        return (_ref = link == null ? void 0 : link.url) != null ? _ref : '';
+    });
+    return Array.from(new Set([
+        ...(_ref1 = host == null ? void 0 : (_host_seo = host.seo) == null ? void 0 : (_host_seo_entity = _host_seo.entity) == null ? void 0 : _host_seo_entity.sameAs) != null ? _ref1 : [],
+        ...rendered
+    ].map((value)=>text(value, 800)).filter((value)=>/^https:\/\//i.test(value)))).slice(0, AUTHOR_SAME_AS_MAX);
+}
+/**
+ * The X (Twitter) handle among a set of profile URLs, as `@name` (AGL-3148).
+ *
+ * `twitter:site` and `twitter:creator` take a handle, and nothing on the
+ * platform stores one — what publishers and authors store is the profile URL,
+ * in the same list that feeds `sameAs`. Reading the handle back out of the URL
+ * is what lets both cards be attributed without a second field to fill in and
+ * keep in step.
+ *
+ * Both hostnames, because a link saved before the rename is still the same
+ * profile. Only a bare profile path qualifies: `x.com/AglynSoftware` is an
+ * account, while `x.com/AglynSoftware/status/123` is one post by it and
+ * `x.com/i/lists/9` is not an account at all — attributing a card to either
+ * would name something that is not the author of anything.
+ */ export function xHandleFromProfiles(urls) {
+    for (const value of urls != null ? urls : []){
+        let url;
+        try {
+            url = new URL(value);
+        } catch (unused) {
+            continue;
+        }
+        if (!/^(www\.)?(x|twitter)\.com$/i.test(url.hostname)) continue;
+        const segments = url.pathname.split('/').filter(Boolean);
+        if (segments.length !== 1) continue;
+        const handle = segments[0];
+        // X handles are 1–15 of `[A-Za-z0-9_]`. Anything else is one of the
+        // reserved paths (`i`, `home`, `search`) rather than somebody's account.
+        if (!/^[A-Za-z0-9_]{1,15}$/.test(handle)) continue;
+        if (/^(i|home|search|explore|notifications|messages|settings)$/i.test(handle)) continue;
+        return `@${handle}`;
+    }
+    return undefined;
+}
+/**
+ * The site's publisher as a STANDALONE, fully populated `schema.org` node
+ * (AGL-2716).
+ *
+ * ## Why this exists next to {@link hostSeoEntityJsonLd}
+ *
+ * That function builds the value `publisher` takes: a `@type` and a `name`,
+ * nested inside a `WebSite` or an `Article`, gated on the author having filled
+ * in the Entity form. It is deliberately narrow, and every call site nests it.
+ *
+ * A consumer asking "who runs this site, and how do I reach them" — an AI
+ * assistant answering a contact question, a readiness audit checking whether a
+ * business is identifiable — looks for a TOP-LEVEL node of type `Organization`
+ * carrying `name`, `description`, `contactPoint` and `address`. A publisher
+ * nested two levels inside a `WebSite` answers a different question, and a
+ * publisher that is absent because nobody filled in a form answers none.
+ *
+ * So this one:
+ *
+ * - is emitted as its own `<script type="application/ld+json">`, at the top
+ *   level, where it can be found without walking into another node;
+ * - FALLS BACK to the site's own identity when the Entity form is empty, so
+ *   every site on the platform publishes a complete entity rather than only
+ *   the sites whose author found the form;
+ * - carries the contact and address fields, which are what turn "a name" into
+ *   "a business a consumer can verify".
+ *
+ * ## Why the fallback is safe
+ *
+ * It changes nothing that already exists: `hostSeoEntityJsonLd` still gates on
+ * `entity.name`, so `publisher` appears exactly where it appeared before. The
+ * fallback only decides what THIS node says, and a site's display name is its
+ * publisher's name on the overwhelming majority of sites — the two differ when
+ * a company's trading name differs from its site's, which is precisely the case
+ * the Entity form exists to express.
+ *
+ * ## `@id`
+ *
+ * Both this node and the nested `publisher` carry the same `@id` when an
+ * origin is known, so a consumer merges them into one entity instead of
+ * reading a site that names its publisher twice with different detail.
+ *
+ * Returns `undefined` only when there is no name to be had from anywhere —
+ * a host document with no entity, no display name and no SEO title.
+ */ export function siteEntityJsonLd(host, context) {
+    var _ref, _ref1;
+    var _host_seo, _host_seo1, _context_origin, _host_seo2, _entity_address, _entity_address1, _entity_address2, _entity_address3, _entity_address4;
+    const entity = (_ref = host == null ? void 0 : (_host_seo = host.seo) == null ? void 0 : _host_seo.entity) != null ? _ref : undefined;
+    const name = text(entity == null ? void 0 : entity.name, 400) || text(host == null ? void 0 : host.displayName, 400) || text(host == null ? void 0 : (_host_seo1 = host.seo) == null ? void 0 : _host_seo1.title, 400);
+    if (!name) return undefined;
+    const origin = (_ref1 = context == null ? void 0 : (_context_origin = context.origin) == null ? void 0 : _context_origin.replace(/\/+$/, '')) != null ? _ref1 : '';
+    const description = text(entity == null ? void 0 : entity.description, 800) || text(host == null ? void 0 : (_host_seo2 = host.seo) == null ? void 0 : _host_seo2.description, 800);
+    const url = text(entity == null ? void 0 : entity.url, 800) || origin;
+    /*
+    `sameAs` is de-duplicated and https-only, matching the author serializer:
+    a profile URL that is not fetchable teaches a consumer nothing, and the
+    same profile listed twice reads as two identities.
+
+    Through `siteProfileUrls` (AGL-3148) so the site's rendered social links
+    count as profiles it claims, rather than only the SEO field that no host
+    on the platform had filled in.
+  */ const sameAs = siteProfileUrls(host);
+    /*
+    A contactPoint needs something to contact. `contactType` alone is a label
+    on nothing, so the point is emitted only when an address or a number is
+    present — `schema.org` requires neither, and a consumer that finds a
+    ContactPoint with no channel has been told less than it would learn from
+    its absence.
+  */ const email = text(entity == null ? void 0 : entity.email, 320);
+    const telephone = text(entity == null ? void 0 : entity.telephone, 64);
+    const contactType = text(entity == null ? void 0 : entity.contactType, 120) || 'customer support';
+    const contactPoint = email || telephone ? _extends({
+        '@type': 'ContactPoint',
+        contactType
+    }, email ? {
+        email
+    } : {}, telephone ? {
+        telephone
+    } : {}) : undefined;
+    const addressFields = {
+        streetAddress: text(entity == null ? void 0 : (_entity_address = entity.address) == null ? void 0 : _entity_address.streetAddress, 200),
+        addressLocality: text(entity == null ? void 0 : (_entity_address1 = entity.address) == null ? void 0 : _entity_address1.addressLocality, 120),
+        addressRegion: text(entity == null ? void 0 : (_entity_address2 = entity.address) == null ? void 0 : _entity_address2.addressRegion, 120),
+        postalCode: text(entity == null ? void 0 : (_entity_address3 = entity.address) == null ? void 0 : _entity_address3.postalCode, 40),
+        addressCountry: text(entity == null ? void 0 : (_entity_address4 = entity.address) == null ? void 0 : _entity_address4.addressCountry, 120)
+    };
+    const address = Object.entries(addressFields).filter(([, value])=>value);
+    const schemaType = contentAuthorSchemaType(entity == null ? void 0 : entity.type);
+    return _extends({
+        '@context': 'https://schema.org',
+        '@type': schemaType
+    }, origin ? {
+        '@id': `${origin}/${SITE_ENTITY_FRAGMENT}`
+    } : {}, {
+        name
+    }, description ? {
+        description
+    } : {}, url ? {
+        url
+    } : {}, hostSeoEntityImageJsonLd(entity, context), sameAs.length ? {
+        sameAs
+    } : {}, contactPoint ? {
+        contactPoint
+    } : {}, address.length ? {
+        address: _extends({
+            '@type': 'PostalAddress'
+        }, Object.fromEntries(address))
+    } : {});
+}
+
+//# sourceMappingURL=content-authors.js.map