@aglyn/tenant-runtime 1.0.0-beta.143

package/src/lib/get-author-content.js

@@ -0,0 +1,288 @@
+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 { AUTHORS_MAX_PER_HOST, collectionTotalPages, contentAuthorMatchesSlug, contentAuthorSlug, contentAuthorSlugCandidates, hostCollectionKind, normalizeContentAuthor, urlSlugSegment } from "@aglyn/aglyn/server";
+import { firebaseAdmin } from "@aglyn/tenant-data-admin";
+import { PUBLISHED_SITE_DATA_TTL_SECONDS, tenantDataTag, withRenderCache } from "@aglyn/tenant-data-admin/render-cache";
+import { getPublishedCollectionSource } from "./get-collection-content.js";
+/**
+ * How many content collections one author page walks.
+ *
+ * The same window site search reads, and for the same reason: a host's
+ * `collections` subcollection holds commerce's catalogs too, so this is a
+ * bound on DOCUMENTS SCANNED rather than on content collections found. Sites
+ * with more than twenty collections of both kinds are not a shape the product
+ * has yet, and the alternative — an unbounded scan on a public, uncached
+ * first render — is the shape of an outage.
+ */ const AUTHOR_PAGE_COLLECTION_SCAN = 20;
+/** How long the host's author roster stays warm. */ const AUTHORS_TTL_SECONDS = PUBLISHED_SITE_DATA_TTL_SECONDS;
+/**
+ * Every author a host has defined, normalized (AGL-2518).
+ *
+ * ONE cached query, shared by the author page, the sitemap and anything else
+ * that needs to turn a slug into a person. Bounded by
+ * {@link AUTHORS_MAX_PER_HOST}, which is the platform cap, so the bound can
+ * never hide an author that exists.
+ *
+ * Reading the roster rather than resolving the author out of their own posts
+ * is a deliberate reversal of what AGL-2517 did. That version took the record
+ * off the first matching entry to avoid a second Firestore read — which meant
+ * an author with no published posts had no record, so their page had no name,
+ * no bio and no links, and rendered as an empty archive of nobody. A person
+ * who has not published yet still has a page; and this read is cached across
+ * the whole site, so it costs one query per TTL rather than one per render.
+ *
+ * Fail-open to an empty roster: the page then falls back to whatever the
+ * entries themselves carry, which is the old behavior rather than a 500.
+ */ export async function getContentAuthors(options) {
+    try {
+        return await withRenderCache({
+            key: [
+                'tenant-content-authors',
+                options.hostId
+            ],
+            revalidate: AUTHORS_TTL_SECONDS,
+            tags: [
+                tenantDataTag(options.hostId)
+            ],
+            read: ()=>readContentAuthors(options.hostId)
+        });
+    } catch (error) {
+        console.error(error);
+        return readContentAuthors(options.hostId);
+    }
+}
+async function readContentAuthors(hostId) {
+    try {
+        const snapshot = await firebaseAdmin.app().firestore().collection('hosts').doc(hostId).collection('authors').limit(AUTHORS_MAX_PER_HOST).get();
+        return snapshot.docs.map((doc)=>normalizeContentAuthor(doc.data(), doc.id)).filter((author)=>Boolean(author));
+    } catch (error) {
+        console.error(error);
+        return [];
+    }
+}
+/** The public slugs of every content collection this host owns. */ async function listContentCollections(hostId) {
+    const snapshot = await firebaseAdmin.app().firestore().collection('hosts').doc(hostId).collection('collections').limit(AUTHOR_PAGE_COLLECTION_SCAN).get();
+    const collections = [];
+    for (const doc of snapshot.docs){
+        var _doc_get, _ref, _ref1, _doc_get1;
+        // Commerce's catalogs share this path (AGL-954) and own no entries.
+        if (hostCollectionKind(doc.data()) !== 'content') continue;
+        const slug = String((_doc_get = doc.get('slug')) != null ? _doc_get : '').trim();
+        if (!slug) continue;
+        collections.push({
+            slug,
+            name: String((_ref = (_ref1 = (_doc_get1 = doc.get('displayName')) != null ? _doc_get1 : doc.get('name')) != null ? _ref1 : doc.get('title')) != null ? _ref : '').trim() || slug
+        });
+    }
+    return collections;
+}
+/**
+ * Everything one author's page shows (AGL-2518) — the person, and what they
+ * wrote across the WHOLE site.
+ *
+ * ## Where the entries come from
+ *
+ * Every content collection the host owns, through
+ * {@link getPublishedCollectionSource} — the same cached per-collection read
+ * `/blog` and every "Latest posts" rail already use. So on a warm site this
+ * page adds no Firestore reads at all: it is a filter over data the cache is
+ * holding anyway. That is the whole reason it walks collections rather than
+ * running a collection-group query on `authorId`, which would be one query
+ * but would also need its own composite index, would miss every entry written
+ * under the legacy free-typed byline (AGL-686), and would share nothing with
+ * the rest of the site.
+ *
+ * ## Why each entry is stamped with its collection
+ *
+ * One page, several collections, so the routed slug cannot build `entry.url`
+ * any more — a changelog note listed under a `/blog` route would link to a
+ * page that does not exist. Each entry carries `collectionSlug` and
+ * `collectionName` out of the read that found it, and the token map prefers
+ * them (`collectionEntryTokens`). Single-collection listings set neither and
+ * are unchanged.
+ *
+ * ## Ordering
+ *
+ * Newest first by `publishedAt`, with undated entries last rather than first:
+ * a draft-turned-live with no timestamp should not lead a person's archive.
+ * Sorted ACROSS collections, because the point of the page is a single
+ * chronological body of work rather than three lists stacked.
+ */ export async function getAuthorContent(options) {
+    var _options_authorSlug;
+    const { hostId } = options;
+    const slug = String((_options_authorSlug = options.authorSlug) != null ? _options_authorSlug : '').trim();
+    // The segment as a URL actually spells it. The route parser already
+    // slugifies, but this function is called directly by tests and by the
+    // sitemap, so it normalizes its own input rather than trusting a caller.
+    const slugified = urlSlugSegment(slug);
+    const page = Math.max(1, Math.floor(Number(options.page) || 1));
+    const perPage = Math.max(1, Math.floor(Number(options.perPage) || 10));
+    const empty = {
+        slug: slugified,
+        author: null,
+        name: slugified,
+        known: false,
+        entries: [],
+        categories: [],
+        page,
+        perPage,
+        totalEntries: 0,
+        totalPages: 1
+    };
+    if (!slugified) return empty;
+    try {
+        var _authors_find;
+        var _entries_find;
+        const [authors, collections] = await Promise.all([
+            getContentAuthors({
+                hostId
+            }),
+            listContentCollections(hostId)
+        ]);
+        const record = (_authors_find = authors.find((author)=>contentAuthorMatchesSlug({
+                author
+            }, slug))) != null ? _authors_find : null;
+        /*
+      Every segment that means this person, resolved ONCE from the record and
+      then matched against each entry — rather than asking each entry whether
+      it matches the routed segment.
+
+      The difference is not cosmetic. An entry stores `authorId`; the URL
+      carries the author's stored SLUG. Asking the entry alone, its only
+      candidate is the id, which does not equal the slug, so the archive comes
+      back empty for exactly the authors who set an address — the field whose
+      whole purpose is to give them a stable one.
+
+      It also closes a fail-open hole. `attachEntryAuthors` resolves
+      `entry.author` and is deliberately allowed to fail (a byline is not
+      worth a 500). When it does, the entry keeps only its `authorId`, and a
+      per-entry match against a name-derived segment would silently drop it —
+      an archive quietly missing posts, which looks exactly like an author who
+      wrote fewer of them.
+    */ const accepted = new Set([
+            slugified
+        ]);
+        if (record) {
+            for (const candidate of contentAuthorSlugCandidates({
+                author: record
+            })){
+                accepted.add(candidate);
+            }
+        }
+        const matchesAuthor = (entry)=>contentAuthorSlugCandidates(_extends({}, entry.author ? {
+                author: entry.author
+            } : {}, entry.authorId ? {
+                authorId: entry.authorId
+            } : {}, entry.authorName ? {
+                authorName: entry.authorName
+            } : {})).some((candidate)=>accepted.has(candidate));
+        const sources = await Promise.all(collections.map(async (collection)=>({
+                collection,
+                source: await getPublishedCollectionSource({
+                    hostId,
+                    collectionSlug: collection.slug
+                })
+            })));
+        const entries = [];
+        const categories = [];
+        for (const { collection, source } of sources){
+            categories.push(...source.categories);
+            for (const entry of source.entries){
+                if (!matchesAuthor(entry)) continue;
+                // Stamped rather than mutated in place: `source.entries` is the
+                // CACHED array, shared with every other page rendering this
+                // collection, and writing a collection slug onto it would leak this
+                // page's context into theirs.
+                entries.push(_extends({}, entry, {
+                    collectionSlug: collection.slug,
+                    collectionName: collection.name
+                }));
+            }
+        }
+        entries.sort((a, b)=>{
+            var _ref, _ref1;
+            var _b_publishedAt, _a_publishedAt;
+            return ((_ref = (_b_publishedAt = b.publishedAt) == null ? void 0 : _b_publishedAt.seconds) != null ? _ref : 0) - ((_ref1 = (_a_publishedAt = a.publishedAt) == null ? void 0 : _a_publishedAt.seconds) != null ? _ref1 : 0);
+        });
+        // The record wins for the display name; failing that, the byline of a
+        // post they actually wrote; failing that, the raw segment.
+        const name = (record == null ? void 0 : record.name) || ((_entries_find = entries.find((entry)=>{
+            var _entry_authorName;
+            return ((_entry_authorName = entry.authorName) != null ? _entry_authorName : '').trim();
+        })) == null ? void 0 : _entries_find.authorName) || slugified;
+        const totalEntries = entries.length;
+        return {
+            slug: slugified,
+            author: record,
+            name,
+            known: Boolean(record) || totalEntries > 0,
+            /*
+        The WHOLE narrowed set, not this page's slice.
+
+        Narrowing happens before the count, so `totalPages` describes this
+        author's work rather than the site's — the category route's rule, one
+        axis over. The WINDOW, though, belongs to the Collection entries
+        block: it receives `page` and `perPage` and slices for itself
+        (`expandCollectionEntries`), exactly as it does on a routed collection
+        listing, where `getCollectionContent` also hands over the full
+        filtered set.
+
+        Slicing here as well double-windows and empties every page after the
+        first: the block would take `slice(10, 20)` of a ten-element array and
+        render nothing. A page-2 archive with a working pager and no cards on
+        it — which reads as "this author wrote exactly ten things".
+      */ entries,
+            categories,
+            page,
+            perPage,
+            totalEntries,
+            totalPages: collectionTotalPages(totalEntries, perPage)
+        };
+    } catch (error) {
+        // Fail-open, like every read on this path: a person's page that 500s is
+        // worse than one that renders their name and nothing else.
+        console.error('author content read failed', error);
+        return empty;
+    }
+}
+/**
+ * Every author page this site can serve, for the sitemap (AGL-2518).
+ *
+ * Roster order, and only authors that address something: an author whose
+ * record has neither a slug nor a name has no URL, and listing one would put
+ * `/author/` in the sitemap.
+ */ export async function listAuthorPageSlugs(options) {
+    const authors = await getContentAuthors(options);
+    const seen = new Set();
+    const rows = [];
+    for (const author of authors){
+        var _author_name;
+        const slug = contentAuthorSlug({
+            author
+        });
+        if (!slug || seen.has(slug)) continue;
+        seen.add(slug);
+        rows.push({
+            slug,
+            name: (_author_name = author.name) != null ? _author_name : slug
+        });
+    }
+    return rows;
+}
+export default getAuthorContent;
+
+//# sourceMappingURL=get-author-content.js.map

package/src/lib/get-author-content.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../libs/tenant/runtime/src/lib/get-author-content.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2026 Aglyn LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  AUTHORS_MAX_PER_HOST,\n  type CollectionCategory,\n  collectionTotalPages,\n  type ContentAuthorRecord,\n  contentAuthorMatchesSlug,\n  contentAuthorSlug,\n  contentAuthorSlugCandidates,\n  hostCollectionKind,\n  normalizeContentAuthor,\n  urlSlugSegment,\n} from '@aglyn/aglyn/server'\nimport { firebaseAdmin } from '@aglyn/tenant-data-admin'\nimport {\n  PUBLISHED_SITE_DATA_TTL_SECONDS,\n  tenantDataTag,\n  withRenderCache,\n} from '@aglyn/tenant-data-admin/render-cache'\nimport {\n  type CollectionEntrySummary,\n  getPublishedCollectionSource,\n} from './get-collection-content'\n\n/**\n * How many content collections one author page walks.\n *\n * The same window site search reads, and for the same reason: a host's\n * `collections` subcollection holds commerce's catalogs too, so this is a\n * bound on DOCUMENTS SCANNED rather than on content collections found. Sites\n * with more than twenty collections of both kinds are not a shape the product\n * has yet, and the alternative — an unbounded scan on a public, uncached\n * first render — is the shape of an outage.\n */\nconst AUTHOR_PAGE_COLLECTION_SCAN = 20\n\n/** How long the host's author roster stays warm. */\nconst AUTHORS_TTL_SECONDS = PUBLISHED_SITE_DATA_TTL_SECONDS\n\n/**\n * Every author a host has defined, normalized (AGL-2518).\n *\n * ONE cached query, shared by the author page, the sitemap and anything else\n * that needs to turn a slug into a person. Bounded by\n * {@link AUTHORS_MAX_PER_HOST}, which is the platform cap, so the bound can\n * never hide an author that exists.\n *\n * Reading the roster rather than resolving the author out of their own posts\n * is a deliberate reversal of what AGL-2517 did. That version took the record\n * off the first matching entry to avoid a second Firestore read — which meant\n * an author with no published posts had no record, so their page had no name,\n * no bio and no links, and rendered as an empty archive of nobody. A person\n * who has not published yet still has a page; and this read is cached across\n * the whole site, so it costs one query per TTL rather than one per render.\n *\n * Fail-open to an empty roster: the page then falls back to whatever the\n * entries themselves carry, which is the old behavior rather than a 500.\n */\nexport async function getContentAuthors(options: {\n  hostId: string\n}): Promise<ContentAuthorRecord[]> {\n  try {\n    return await withRenderCache({\n      key: ['tenant-content-authors', options.hostId],\n      revalidate: AUTHORS_TTL_SECONDS,\n      tags: [tenantDataTag(options.hostId)],\n      read: () => readContentAuthors(options.hostId),\n    })\n  } catch (error) {\n    console.error(error)\n    return readContentAuthors(options.hostId)\n  }\n}\n\nasync function readContentAuthors(\n  hostId: string,\n): Promise<ContentAuthorRecord[]> {\n  try {\n    const snapshot = await firebaseAdmin\n      .app()\n      .firestore()\n      .collection('hosts')\n      .doc(hostId)\n      .collection('authors')\n      .limit(AUTHORS_MAX_PER_HOST)\n      .get()\n    return snapshot.docs\n      .map((doc) => normalizeContentAuthor(doc.data(), doc.id))\n      .filter((author): author is ContentAuthorRecord => Boolean(author))\n  } catch (error) {\n    console.error(error)\n    return []\n  }\n}\n\n/** The public slugs of every content collection this host owns. */\nasync function listContentCollections(hostId: string): Promise<\n  { slug: string; name: string }[]\n> {\n  const snapshot = await firebaseAdmin\n    .app()\n    .firestore()\n    .collection('hosts')\n    .doc(hostId)\n    .collection('collections')\n    .limit(AUTHOR_PAGE_COLLECTION_SCAN)\n    .get()\n  const collections: { slug: string; name: string }[] = []\n  for (const doc of snapshot.docs) {\n    // Commerce's catalogs share this path (AGL-954) and own no entries.\n    if (hostCollectionKind(doc.data()) !== 'content') continue\n    const slug = String(doc.get('slug') ?? '').trim()\n    if (!slug) continue\n    collections.push({\n      slug,\n      name:\n        String(\n          doc.get('displayName') ?? doc.get('name') ?? doc.get('title') ?? '',\n        ).trim() || slug,\n    })\n  }\n  return collections\n}\n\n/** What a `/author/{slug}` route resolved to. */\nexport interface AuthorContent {\n  /** The addressed segment, normalized — what a canonical link must say. */\n  slug: string\n  /** The author's record, when the slug names one. */\n  author: ContentAuthorRecord | null\n  /**\n   * The byline to print. Falls back to the raw segment so an unknown author\n   * still gets a page with a heading rather than a blank one.\n   */\n  name: string\n  /**\n   * Did the slug resolve to a real author — a roster record, or an entry\n   * published under that byline? An unknown slug renders an empty page rather\n   * than crashing, which is the category route's rule, but the page must not\n   * invite indexing of an address that names nobody.\n   */\n  known: boolean\n  /** This author's published entries, newest first, across every collection. */\n  entries: CollectionEntrySummary[]\n  /** The merged taxonomy of every collection walked, for name resolution. */\n  categories: CollectionCategory[]\n  page: number\n  perPage: number\n  totalEntries: number\n  totalPages: number\n}\n\n/**\n * Everything one author's page shows (AGL-2518) — the person, and what they\n * wrote across the WHOLE site.\n *\n * ## Where the entries come from\n *\n * Every content collection the host owns, through\n * {@link getPublishedCollectionSource} — the same cached per-collection read\n * `/blog` and every \"Latest posts\" rail already use. So on a warm site this\n * page adds no Firestore reads at all: it is a filter over data the cache is\n * holding anyway. That is the whole reason it walks collections rather than\n * running a collection-group query on `authorId`, which would be one query\n * but would also need its own composite index, would miss every entry written\n * under the legacy free-typed byline (AGL-686), and would share nothing with\n * the rest of the site.\n *\n * ## Why each entry is stamped with its collection\n *\n * One page, several collections, so the routed slug cannot build `entry.url`\n * any more — a changelog note listed under a `/blog` route would link to a\n * page that does not exist. Each entry carries `collectionSlug` and\n * `collectionName` out of the read that found it, and the token map prefers\n * them (`collectionEntryTokens`). Single-collection listings set neither and\n * are unchanged.\n *\n * ## Ordering\n *\n * Newest first by `publishedAt`, with undated entries last rather than first:\n * a draft-turned-live with no timestamp should not lead a person's archive.\n * Sorted ACROSS collections, because the point of the page is a single\n * chronological body of work rather than three lists stacked.\n */\nexport async function getAuthorContent(options: {\n  hostId: string\n  authorSlug: string\n  page?: number\n  perPage?: number\n}): Promise<AuthorContent> {\n  const { hostId } = options\n  const slug = String(options.authorSlug ?? '').trim()\n  // The segment as a URL actually spells it. The route parser already\n  // slugifies, but this function is called directly by tests and by the\n  // sitemap, so it normalizes its own input rather than trusting a caller.\n  const slugified = urlSlugSegment(slug)\n  const page = Math.max(1, Math.floor(Number(options.page) || 1))\n  const perPage = Math.max(1, Math.floor(Number(options.perPage) || 10))\n  const empty: AuthorContent = {\n    slug: slugified,\n    author: null,\n    name: slugified,\n    known: false,\n    entries: [],\n    categories: [],\n    page,\n    perPage,\n    totalEntries: 0,\n    totalPages: 1,\n  }\n  if (!slugified) return empty\n  try {\n    const [authors, collections] = await Promise.all([\n      getContentAuthors({ hostId }),\n      listContentCollections(hostId),\n    ])\n    const record =\n      authors.find((author) => contentAuthorMatchesSlug({ author }, slug)) ??\n      null\n\n    /*\n      Every segment that means this person, resolved ONCE from the record and\n      then matched against each entry — rather than asking each entry whether\n      it matches the routed segment.\n\n      The difference is not cosmetic. An entry stores `authorId`; the URL\n      carries the author's stored SLUG. Asking the entry alone, its only\n      candidate is the id, which does not equal the slug, so the archive comes\n      back empty for exactly the authors who set an address — the field whose\n      whole purpose is to give them a stable one.\n\n      It also closes a fail-open hole. `attachEntryAuthors` resolves\n      `entry.author` and is deliberately allowed to fail (a byline is not\n      worth a 500). When it does, the entry keeps only its `authorId`, and a\n      per-entry match against a name-derived segment would silently drop it —\n      an archive quietly missing posts, which looks exactly like an author who\n      wrote fewer of them.\n    */\n    const accepted = new Set<string>([slugified])\n    if (record) {\n      for (const candidate of contentAuthorSlugCandidates({ author: record })) {\n        accepted.add(candidate)\n      }\n    }\n    const matchesAuthor = (entry: CollectionEntrySummary): boolean =>\n      contentAuthorSlugCandidates({\n        ...(entry.author ? { author: entry.author } : {}),\n        ...(entry.authorId ? { authorId: entry.authorId } : {}),\n        ...(entry.authorName ? { authorName: entry.authorName } : {}),\n      }).some((candidate) => accepted.has(candidate))\n\n    const sources = await Promise.all(\n      collections.map(async (collection) => ({\n        collection,\n        source: await getPublishedCollectionSource({\n          hostId,\n          collectionSlug: collection.slug,\n        }),\n      })),\n    )\n\n    const entries: CollectionEntrySummary[] = []\n    const categories: CollectionCategory[] = []\n    for (const { collection, source } of sources) {\n      categories.push(...source.categories)\n      for (const entry of source.entries) {\n        if (!matchesAuthor(entry)) continue\n        // Stamped rather than mutated in place: `source.entries` is the\n        // CACHED array, shared with every other page rendering this\n        // collection, and writing a collection slug onto it would leak this\n        // page's context into theirs.\n        entries.push({\n          ...entry,\n          collectionSlug: collection.slug,\n          collectionName: collection.name,\n        })\n      }\n    }\n    entries.sort(\n      (a, b) => (b.publishedAt?.seconds ?? 0) - (a.publishedAt?.seconds ?? 0),\n    )\n\n    // The record wins for the display name; failing that, the byline of a\n    // post they actually wrote; failing that, the raw segment.\n    const name =\n      record?.name ||\n      entries.find((entry) => (entry.authorName ?? '').trim())?.authorName ||\n      slugified\n    const totalEntries = entries.length\n    return {\n      slug: slugified,\n      author: record,\n      name,\n      known: Boolean(record) || totalEntries > 0,\n      /*\n        The WHOLE narrowed set, not this page's slice.\n\n        Narrowing happens before the count, so `totalPages` describes this\n        author's work rather than the site's — the category route's rule, one\n        axis over. The WINDOW, though, belongs to the Collection entries\n        block: it receives `page` and `perPage` and slices for itself\n        (`expandCollectionEntries`), exactly as it does on a routed collection\n        listing, where `getCollectionContent` also hands over the full\n        filtered set.\n\n        Slicing here as well double-windows and empties every page after the\n        first: the block would take `slice(10, 20)` of a ten-element array and\n        render nothing. A page-2 archive with a working pager and no cards on\n        it — which reads as \"this author wrote exactly ten things\".\n      */\n      entries,\n      categories,\n      page,\n      perPage,\n      totalEntries,\n      totalPages: collectionTotalPages(totalEntries, perPage),\n    }\n  } catch (error) {\n    // Fail-open, like every read on this path: a person's page that 500s is\n    // worse than one that renders their name and nothing else.\n    console.error('author content read failed', error)\n    return empty\n  }\n}\n\n/**\n * Every author page this site can serve, for the sitemap (AGL-2518).\n *\n * Roster order, and only authors that address something: an author whose\n * record has neither a slug nor a name has no URL, and listing one would put\n * `/author/` in the sitemap.\n */\nexport async function listAuthorPageSlugs(options: {\n  hostId: string\n}): Promise<{ slug: string; name: string }[]> {\n  const authors = await getContentAuthors(options)\n  const seen = new Set<string>()\n  const rows: { slug: string; name: string }[] = []\n  for (const author of authors) {\n    const slug = contentAuthorSlug({ author })\n    if (!slug || seen.has(slug)) continue\n    seen.add(slug)\n    rows.push({ slug, name: author.name ?? slug })\n  }\n  return rows\n}\n\nexport default getAuthorContent\n"],"names":["AUTHORS_MAX_PER_HOST","collectionTotalPages","contentAuthorMatchesSlug","contentAuthorSlug","contentAuthorSlugCandidates","hostCollectionKind","normalizeContentAuthor","urlSlugSegment","firebaseAdmin","PUBLISHED_SITE_DATA_TTL_SECONDS","tenantDataTag","withRenderCache","getPublishedCollectionSource","AUTHOR_PAGE_COLLECTION_SCAN","AUTHORS_TTL_SECONDS","getContentAuthors","options","key","hostId","revalidate","tags","read","readContentAuthors","error","console","snapshot","app","firestore","collection","doc","limit","get","docs","map","data","id","filter","author","Boolean","listContentCollections","collections","slug","String","trim","push","name","getAuthorContent","authorSlug","slugified","page","Math","max","floor","Number","perPage","empty","known","entries","categories","totalEntries","totalPages","authors","Promise","all","record","find","accepted","Set","candidate","add","matchesAuthor","entry","authorId","authorName","some","has","sources","source","collectionSlug","collectionName","sort","a","b","publishedAt","seconds","length","listAuthorPageSlugs","seen","rows"],"mappings":"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"}

package/src/lib/get-collection-content.d.ts

@@ -0,0 +1,290 @@
+/**
+ * @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 { type CollectionCategory, type ContentAuthorRecord } from '@aglyn/aglyn/server';
+export interface CollectionEntrySummary {
+    $id: string;
+    title: string;
+    slug: string;
+    excerpt?: string;
+    /**
+     * The byline TEXT (AGL-686). Either the entry's own legacy free-typed
+     * string or — since AGL-2486 — the name of the author record `authorId`
+     * points at, resolved here so every downstream reader (the Entry Meta
+     * block, `{{entry.author}}`, the RSS feed) keeps asking one field.
+     */
+    authorName?: string;
+    /** Reference into `hosts/{hostId}/authors` (AGL-2486). */
+    authorId?: string;
+    /**
+     * The resolved author RECORD (AGL-2486) — what `Article.author` is built
+     * from. Null when the entry names no author, in which case the page falls
+     * back to the site's publisher entity exactly as it always has.
+     */
+    author?: ContentAuthorRecord | null;
+    body?: string;
+    coverImage?: string;
+    /** `og:image:alt` for the cover (AGL-2417); travels WITH `coverImage`. */
+    coverImageAlt?: string;
+    /**
+     * The featured video (AGL-2956): a media reference or a URL, a Wistia link
+     * included, in the shape `coverImage` is. See
+     * `CollectionEntryRecord.coverVideo`.
+     */
+    coverVideo?: string;
+    /** Search-result title override (AGL-582); falls back to `title`. */
+    seoTitle?: string;
+    /** Meta description override (AGL-582); falls back to `excerpt`. */
+    seoDescription?: string;
+    /**
+     * Stable reference into the collection's `categories` taxonomy
+     * (AGL-582); resolved to a display name at render.
+     */
+    categoryId?: string;
+    /** Legacy free-typed bucket (AGL-582); read-only fallback. */
+    category?: string;
+    /** Free-form labels (AGL-582). */
+    tags?: string[];
+    publishedAt?: {
+        seconds: number;
+    } | null;
+    /**
+     * Last edited, which is what `Article.dateModified` publishes (AGL-2534).
+     *
+     * Distinct from {@link publishedAt} on purpose: re-dating a post is not
+     * editing it, so the console writes `publishedAt` alone when an author
+     * backdates and this stays put. Google reads `dateModified` for freshness.
+     */
+    updatedAt?: {
+        seconds: number;
+    } | null;
+    /**
+     * The collection this entry came out of (AGL-2518), stamped only by a
+     * reader that MIXES collections — the author page. Unset on every routed
+     * listing, where the route already answers the question. See
+     * `CollectionEntryRecord.collectionSlug`.
+     */
+    collectionSlug?: string;
+    /** The display name of {@link collectionSlug}. */
+    collectionName?: string;
+}
+/** A scheduled entry whose time has come — before any plan question. */
+export declare function isDueScheduled(value: FirebaseFirestore.DocumentData): boolean;
+/**
+ * A scheduled entry still waiting on its time: not due yet, and not refused.
+ * Nothing but a render publishes a content entry, so a cache that stored a
+ * read holding one would withhold the render that notices it come due — see
+ * {@link LiveEntriesRead.pendingSchedule}.
+ */
+export declare function isPendingScheduled(value: FirebaseFirestore.DocumentData): boolean;
+/**
+ * Is this host's plan allowed to publish on a schedule? (AGL-471 shape.)
+ *
+ * `React.cache`-deduped per request via `getOrgForHost`, and — this is the
+ * part that keeps it off the hot path — every caller below only asks once it
+ * has already found a due scheduled entry. A collection with nothing due pays
+ * nothing, which is almost every render.
+ *
+ * THREE answers, not two, and the third is the point. `refused` means we read
+ * the plan and it does not carry the entitlement. `unresolved` means we could
+ * not find out. Both withhold the entry, but only `refused` may write the
+ * terminal marker — burning a schedule permanently on the strength of a
+ * hostIndex miss or a transient rejection would destroy a customer's post for
+ * a reason that may not be true a second later.
+ *
+ * Withholding on `unresolved` rather than publishing is what every other
+ * entitlement caller on the tenant runtime already does: `apply-publish-schedule`
+ * here, and the automation engine's two runners, all pass a possibly
+ * undefined org straight into `checkEntitlement`, which resolves a missing
+ * plan as free and denies (AGL-247). Opening here instead would make this the
+ * one gate in the lib that admits when it cannot see — the exact shape of the
+ * free-tier leak `no-plan-gated-entitlement` exists to forbid.
+ *
+ * The blast radius of withholding is deliberately small: `isLive` answers true
+ * for `status: 'published'` before it ever consults this, so an unresolved
+ * read hides only the due-scheduled entry, never the published ones, and the
+ * next render retries.
+ */
+export type SchedulePermission = 'allowed' | 'refused' | 'unresolved';
+export declare function scheduledPublishingPermission(hostId: string): Promise<SchedulePermission>;
+/**
+ * Scheduled entries (AGL-123) go live lazily like AGL-61: a due
+ * `publishAt` counts as published for this render, and the doc is flipped
+ * to `published` fail-open so the state becomes durable.
+ *
+ * PLAN GATE (AGL-471). `scheduledPublishing` is a Business entitlement, and
+ * until now nothing on the entry path checked it: the console let any plan
+ * write `status: 'scheduled'`, and this render path published it. Scheduling
+ * worked end to end on Free. The screens path has gated this since AGL-471
+ * and records its refusal since AGL-1185 — entries were simply never wired
+ * to either, which is why the leak was invisible from the screens side.
+ *
+ * The permission is threaded in rather than resolved here so the org read
+ * happens once per call site instead of once per entry.
+ *
+ * Exported for the one other reader that decides whether an entry is on the
+ * site — whether a LINK to it resolves (AGL-3118) — so a link and the page it
+ * points at can never disagree about which entries exist.
+ */
+export declare function isLive(value: FirebaseFirestore.DocumentData, permission: SchedulePermission): boolean;
+export interface CollectionContent {
+    collection: {
+        $id: string;
+        displayName: string;
+        slug: string;
+        /**
+         * Legacy entry-template screen (AGL-105); superseded by
+         * `entryScreenId` but still honored when only it is set.
+         */
+        templateScreenId?: string;
+        /** List-template screen (AGL-551); `/{collection}` renders through it. */
+        listScreenId?: string;
+        /**
+         * Entry-template screen (AGL-551); `/{collection}/{entry}` renders
+         * through it with `{{entry.*}}` tokens.
+         */
+        entryScreenId?: string;
+        /**
+         * What KIND of article this collection publishes (AGL-2536) — the
+         * `schema.org` type its entries serialise as. Unset publishes `Article`,
+         * which is what every collection published before the setting existed.
+         */
+        schemaType?: string;
+        /**
+         * Category taxonomy (AGL-582): entries reference these by stable
+         * `id`; `name` is the renameable display label.
+         */
+        categories?: CollectionCategory[];
+    } | null;
+    entries: CollectionEntrySummary[];
+    entry: CollectionEntrySummary | null;
+    /**
+     * Whether the read that produced `entries` stopped at
+     * {@link COLLECTION_SOURCE_MAX} (AGL-1516). Set on LIST routes only —
+     * an entry route reads one document by slug and bounds nothing.
+     */
+    entriesReachedBound?: boolean;
+    /** List pagination (AGL-620); null for entry pages or unpaginated lists. */
+    pagination?: CollectionPagination | null;
+    /**
+     * The category this listing is filtered to (AGL-1321); null on the
+     * canonical unfiltered list and on entry pages.
+     */
+    category?: CollectionRouteCategory | null;
+    error: unknown;
+}
+/** The category a `/{collection}/category/{slug}` route addresses (AGL-1321). */
+export interface CollectionRouteCategory {
+    /** The URL segment, normalized — what the canonical link must say. */
+    slug: string;
+    /** Taxonomy id; absent when the segment matched no known category. */
+    id?: string;
+    /** Display label; falls back to the raw segment for an unknown category. */
+    name: string;
+    /**
+     * The taxonomy's {@link CollectionCategory.description}, carried onto the
+     * route so the head can describe the FILTERED listing rather than inherit
+     * the whole collection's description. Absent for an unknown segment, which
+     * names no category and therefore has nothing to describe.
+     */
+    description?: string;
+    /**
+     * Whether the segment resolved against the collection's taxonomy. An
+     * unknown category still renders — an empty listing, not a crash — but the
+     * page must not invite indexing of a URL that names nothing.
+     */
+    known: boolean;
+}
+export interface CollectionPagination {
+    /** 1-based current page. */
+    page: number;
+    perPage: number;
+    totalPages: number;
+    totalEntries: number;
+}
+/** Compose-time view of a collection: its live entries and its taxonomy. */
+export interface PublishedCollectionSource {
+    /**
+     * The collection DOCUMENT this source was read from — its display name and
+     * its template screen ids — or null when the slug names no content
+     * collection.
+     *
+     * Carried so a routed listing can be served ENTIRELY from this cached
+     * source. `getCollectionContent` used to resolve the same document itself
+     * and then read the same entries again uncached, which meant `/blog`,
+     * every `/blog/page/{n}`, every `/blog/category/{slug}` and the RSS feed
+     * each paid a full collection read per regeneration while the identical
+     * data already sat in this cache for every OTHER page on the site.
+     */
+    collection: CollectionContent['collection'];
+    entries: CollectionEntrySummary[];
+    categories: CollectionCategory[];
+    /**
+     * Whether the read saw a schedule it is still waiting on — see
+     * {@link LiveEntriesRead.pendingSchedule}. Never stored, only consulted by
+     * the cache above, so no consumer has to know about it.
+     */
+    pendingSchedule?: boolean;
+    /**
+     * Whether the entries read stopped at {@link COLLECTION_SOURCE_MAX}
+     * (AGL-1516) — carried out of the loader because `entries.length` cannot
+     * answer it once the liveness filter has run. Fail-open paths report
+     * `false`: an empty result is not a bounded read, and describing it as one
+     * would tell a reader their search covered less than it did.
+     */
+    reachedBound: boolean;
+}
+/**
+ * Published entries + category taxonomy for a collection resolved by slug —
+ * the data source of the Collection entries block on arbitrary screens
+ * (AGL-551/582). Fail-open: errors and unknown slugs resolve to an empty
+ * list so a renamed collection never takes a published screen down.
+ */
+export declare function getPublishedCollectionSource(options: {
+    hostId: string;
+    collectionSlug: string;
+}): Promise<PublishedCollectionSource>;
+/** Entries-only view of {@link getPublishedCollectionSource} (AGL-551). */
+export declare function getPublishedCollectionEntries(options: {
+    hostId: string;
+    collectionSlug: string;
+}): Promise<CollectionEntrySummary[]>;
+/**
+ * Resolves a non-screen path against the host's content collections
+ * (Content Collections & Blog): `/{collectionSlug}` returns the published
+ * entry list, `/{collectionSlug}/{entrySlug}` one entry. Fail-open — errors
+ * resolve to `collection: null` and the caller 404s.
+ *
+ * A listing resolves only for a collection with a live entry (AGL-3101); one
+ * with nothing live answers `collection: null` as well, so its listing, feed
+ * and markdown twin are not public until its first entry is.
+ */
+export declare function getCollectionContent(options: {
+    hostId: string;
+    collectionSlug: string;
+    entrySlug?: string;
+    /** 1-based list page (AGL-620); with `perPage`, drives pagination metadata. */
+    page?: number;
+    /** Entries per page (AGL-620); when set the list is paginated. */
+    perPage?: number;
+    /**
+     * Category segment of `/{collection}/category/{slug}` (AGL-1321). Filters
+     * the listing before pagination is computed, so page counts and the page
+     * windows describe the FILTERED set rather than the whole collection.
+     */
+    categorySlug?: string;
+}): Promise<CollectionContent>;
+export default getCollectionContent;