@aglyn/tenant-runtime 1.0.0-beta.143

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

@@ -0,0 +1,565 @@
+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, collectionCategorySlug, checkEntitlement, COLLECTION_SOURCE_MAX, collectionTotalPages, entryMatchesCategoryRoute, hostCollectionKind, normalizeContentAuthor, normalizeContentSchemaType, resolveCollectionCategoryBySlug, resolveEntryAuthor } from "@aglyn/aglyn/server";
+import { firebaseAdmin, getOrgForHost } from "@aglyn/tenant-data-admin";
+import { PUBLISHED_SITE_DATA_TTL_SECONDS, tenantDataTag, withRenderCache } from "@aglyn/tenant-data-admin/render-cache";
+/**
+ * ONE cached read per collection, shared by every surface that lists it
+ * (AGL-1302).
+ *
+ * It began as the compose-time source only: a Collection entries block in a
+ * shared layout re-read up to ~100 entry docs on EVERY page of the site. The
+ * routed listing was left out on the argument that the page's own ISR entry
+ * amortized it — which is true of ONE address and false of a collection,
+ * because a collection is not one address. `/blog`, `/blog/page/2…10`, a
+ * `/blog/category/{slug}` per category and `/blog/rss.xml` are all the same
+ * data, each paying its own `1 + entries + authors` per window, beside a
+ * cache already holding exactly that.
+ *
+ * The other half of that argument was real and is answered rather than
+ * dropped: `flipDueEntry` is a write, and nothing else publishes a content
+ * entry, so a cache that stored a collection with a schedule still pending
+ * would suppress the render that publishes it. `getPublishedCollectionSource`
+ * therefore declines to STORE exactly those collections — see its `store`
+ * predicate — which leaves scheduled publishing on the render window it has
+ * always been on, and puts everything else on this TTL.
+ */ const COLLECTION_SOURCE_TTL_SECONDS = PUBLISHED_SITE_DATA_TTL_SECONDS;
+/**
+ * Resolve a public content-collection slug (AGL-954). Commerce's product
+ * collections share `hosts/{hostId}/collections`, and a slug is only unique
+ * within a kind — a bare `limit(1)` handed the URL to whichever doc Firestore
+ * returned first, so a catalog collection could shadow a blog. Reads a small
+ * window instead and takes the first content-kind match.
+ */ async function findContentCollection(hostId, collectionSlug) {
+    const matches = await firebaseAdmin.app().firestore().collection('hosts').doc(hostId).collection('collections').where('slug', '==', collectionSlug).limit(5).get();
+    return matches.docs.find((docSnapshot)=>hostCollectionKind(docSnapshot.data()) === 'content');
+}
+/** Entry-doc fields shared by the list and single-entry mappers (AGL-582). */ function mapEntryFields(value) {
+    var _value_excerpt, _value_authorName, _value_authorId, _value_coverImage, _value_coverImageAlt, _value_coverVideo, _value_seoTitle, _value_seoDescription, _value_categoryId, _value_category;
+    var _value_updatedAt;
+    return {
+        excerpt: (_value_excerpt = value['excerpt']) != null ? _value_excerpt : '',
+        // The byline was DECLARED on `CollectionEntrySummary` (AGL-686) and
+        // mapped by nobody, so `entry.authorName` was `undefined` on every entry
+        // this loader returned — which is every routed entry page and every
+        // Collection entries block. The console collected the field, the rules
+        // stored it, the JSON-LD builder read it and the Entry Meta block printed
+        // it, and all three saw nothing, because the one hop between Firestore
+        // and them dropped it (AGL-2486). Written but never read, in the
+        // direction that leaves no error behind.
+        authorName: (_value_authorName = value['authorName']) != null ? _value_authorName : '',
+        authorId: (_value_authorId = value['authorId']) != null ? _value_authorId : '',
+        coverImage: (_value_coverImage = value['coverImage']) != null ? _value_coverImage : '',
+        coverImageAlt: (_value_coverImageAlt = value['coverImageAlt']) != null ? _value_coverImageAlt : '',
+        // Here, where both read paths pick it up, so a list card and the routed
+        // entry page can each bind the featured video (AGL-2956).
+        coverVideo: (_value_coverVideo = value['coverVideo']) != null ? _value_coverVideo : '',
+        seoTitle: (_value_seoTitle = value['seoTitle']) != null ? _value_seoTitle : '',
+        seoDescription: (_value_seoDescription = value['seoDescription']) != null ? _value_seoDescription : '',
+        categoryId: (_value_categoryId = value['categoryId']) != null ? _value_categoryId : '',
+        category: (_value_category = value['category']) != null ? _value_category : '',
+        tags: Array.isArray(value['tags']) ? value['tags'].filter((tag)=>typeof tag === 'string') : [],
+        /*
+      `dateModified`'s source (AGL-2534), and it was missing for the same
+      reason `authorName` was — the reason this function's own comment above
+      describes.
+
+      The console has written `updatedAt` on every save, `page.tsx` reads
+      `entry.updatedAt.seconds` to publish `Article.dateModified`, a spec
+      asserts the conversion, and two console comments explain why it must not
+      track `publishedAt`. Nothing mapped it, so `entry.updatedAt` was
+      `undefined` on every entry the loader has ever returned and no published
+      article has ever carried a `dateModified` — the freshness signal Google
+      reads. The spec passed throughout because it builds its entry object by
+      hand and never crosses this boundary.
+
+      Mapped HERE rather than beside `publishedAt` at the two call sites: this
+      is an ordinary field with no `publishAt` fallback and nothing sorts on
+      it, so one place is enough — and one place is what stops the next read
+      path from forgetting it.
+    */ updatedAt: ((_value_updatedAt = value['updatedAt']) == null ? void 0 : _value_updatedAt.seconds) ? {
+            seconds: value['updatedAt'].seconds
+        } : null
+    };
+}
+/**
+ * The collection doc's category taxonomy (AGL-582), sanitized: only
+ * `{ id, name }` pairs with non-empty strings survive, order preserved.
+ *
+ * `description` rides along when the author wrote one and is dropped when it
+ * is blank or not a string, so the head can tell "described" from "not
+ * described" by truthiness alone — an empty string reaching the metadata
+ * would suppress the template screen's description and leave the listing with
+ * none at all.
+ */ function mapCollectionCategories(value) {
+    if (!Array.isArray(value)) return [];
+    return value.filter((item)=>typeof (item == null ? void 0 : item.id) === 'string' && item.id.trim() !== '' && typeof (item == null ? void 0 : item.name) === 'string' && item.name.trim() !== '').map((item)=>{
+        const description = typeof item.description === 'string' ? item.description.trim() : '';
+        return _extends({
+            id: item.id,
+            name: item.name
+        }, description ? {
+            description
+        } : {});
+    });
+}
+/**
+ * The routed view of a collection DOCUMENT (AGL-551): its name and the
+ * template screens its list and entry routes render through.
+ *
+ * `slug` is the slug that was ASKED FOR rather than the one stored, which is
+ * what every caller of this file has always returned — a listing has to build
+ * its own URLs out of the segment the reader is standing on.
+ */ function mapCollectionDoc(collectionDoc, collectionSlug) {
+    var _collectionDoc_get, _collectionDoc_get1, _collectionDoc_get2, _collectionDoc_get3;
+    return {
+        $id: collectionDoc.id,
+        displayName: (_collectionDoc_get = collectionDoc.get('displayName')) != null ? _collectionDoc_get : collectionSlug,
+        slug: collectionSlug,
+        templateScreenId: (_collectionDoc_get1 = collectionDoc.get('templateScreenId')) != null ? _collectionDoc_get1 : undefined,
+        listScreenId: (_collectionDoc_get2 = collectionDoc.get('listScreenId')) != null ? _collectionDoc_get2 : undefined,
+        entryScreenId: (_collectionDoc_get3 = collectionDoc.get('entryScreenId')) != null ? _collectionDoc_get3 : undefined,
+        // Normalized HERE rather than at the head (AGL-2536), so an unrecognised
+        // stored value can never reach the JSON-LD: an `@type` the vocabulary
+        // does not define makes a consumer discard the whole node, costing the
+        // page every property it publishes rather than just this one.
+        schemaType: normalizeContentSchemaType(collectionDoc.get('schemaType')),
+        categories: mapCollectionCategories(collectionDoc.get('categories'))
+    };
+}
+/**
+ * Resolve the author RECORDS a set of entries reference (AGL-2486).
+ *
+ * Costs ZERO reads when no entry names an `authorId`, which is every site
+ * that has not adopted custom authors and every entry written before them —
+ * the check is on the ids already in hand, not a probe of the collection. When
+ * ids are present it is one `getAll` of the DISTINCT ones, bounded by
+ * {@link AUTHORS_MAX_PER_HOST} and by the ≤100-entry page above it, rather
+ * than a read per entry.
+ *
+ * Fail-open, like every other read in this file: an authors read that throws
+ * leaves the entries with their legacy `authorName` (or the site entity) and
+ * the page renders. A byline is not worth a 500.
+ */ async function attachEntryAuthors(hostId, entries) {
+    const ids = [
+        ...new Set(entries.map((entry)=>{
+            var _entry_authorId;
+            return ((_entry_authorId = entry.authorId) != null ? _entry_authorId : '').trim();
+        }).filter(Boolean))
+    ].slice(0, AUTHORS_MAX_PER_HOST);
+    let authors = [];
+    if (ids.length) {
+        try {
+            const authorsRef = firebaseAdmin.app().firestore().collection('hosts').doc(hostId).collection('authors');
+            const snapshots = await firebaseAdmin.app().firestore().getAll(...ids.map((id)=>authorsRef.doc(id)));
+            authors = snapshots.map((snapshot)=>snapshot.exists ? normalizeContentAuthor(snapshot.data(), snapshot.id) : null).filter((author)=>Boolean(author));
+        } catch (error) {
+            console.error(error);
+        }
+    }
+    for (const entry of entries){
+        const author = resolveEntryAuthor(entry, authors);
+        entry.author = author;
+        // The byline TEXT is denormalized onto the field everything downstream
+        // already reads, so a record-backed author needs no change in the Entry
+        // Meta block, the token map, the fallback nodes or the RSS feed. A record
+        // WINS over the legacy string on the same entry: picking an author is the
+        // more recent statement of who wrote it.
+        if (author == null ? void 0 : author.name) entry.authorName = author.name;
+    }
+}
+/**
+ * Terminal refusal marker for an entry schedule, the flat-status twin of
+ * `publishSchedule.status: 'skipped-unentitled'` on screens (AGL-1185).
+ *
+ * A field rather than a new `status` value on purpose. `status` is queried
+ * (`where('status', 'in', [...])`), rendered by the console, and sorted on by
+ * `bundle-timestamps.ts`; adding a member would have meant auditing every one
+ * of those readers. A sibling field is invisible to all of them and is read
+ * only here.
+ */ const ENTRY_SCHEDULE_SKIPPED = 'skipped-unentitled';
+/** A schedule this entry already had declined, and will not have reconsidered. */ function scheduleAlreadyRefused(value) {
+    return value['scheduleStatus'] === ENTRY_SCHEDULE_SKIPPED;
+}
+/** A scheduled entry whose time has come — before any plan question. */ export function isDueScheduled(value) {
+    var _ref;
+    var _value_publishAt;
+    return value['status'] === 'scheduled' && !scheduleAlreadyRefused(value) && ((_ref = (_value_publishAt = value['publishAt']) == null ? void 0 : _value_publishAt.seconds) != null ? _ref : Number.POSITIVE_INFINITY) * 1000 <= Date.now();
+}
+/**
+ * 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 function isPendingScheduled(value) {
+    return value['status'] === 'scheduled' && !scheduleAlreadyRefused(value) && !isDueScheduled(value);
+}
+export async function scheduledPublishingPermission(hostId) {
+    try {
+        var _this;
+        const org = (_this = await getOrgForHost(hostId)) == null ? void 0 : _this.org;
+        if (!org) return 'unresolved';
+        return checkEntitlement(org, 'scheduledPublishing') ? 'allowed' : 'refused';
+    } catch (error) {
+        // Caught rather than thrown: the only caller sits inside
+        // `getCollectionContent`'s try/catch, which returns an EMPTY collection —
+        // so an unhandled rejection here would blank every published entry on the
+        // page, not just the scheduled one.
+        console.error(error);
+        return 'unresolved';
+    }
+}
+/**
+ * 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 function isLive(value, permission) {
+    if (value['status'] === 'published') return true;
+    return permission === 'allowed' && isDueScheduled(value);
+}
+/**
+ * Make the due state durable — or record that it was refused.
+ *
+ * The refusal is TERMINAL, for the AGL-1185 reason: left as a bare pending
+ * `scheduled`, the entry stays permanently due, so the day the org upgrades
+ * to Business the next render publishes it. Content scheduled on a plan that
+ * could not honour it, and forgotten, surfacing during an upgrade — exactly
+ * when nobody is looking for it. Recording the refusal is what makes it stop
+ * being due, and it also stops this path re-reading the org on every
+ * subsequent render.
+ *
+ * Both writes fail open: an error leaves today's state, and the next render
+ * retries.
+ */ function flipDueEntry(docRef, value, permission) {
+    if (value['status'] !== 'scheduled') return;
+    if (scheduleAlreadyRefused(value)) return;
+    // `unresolved` writes NOTHING. It withholds this render and leaves the
+    // schedule exactly as it found it, so a later render can still publish it.
+    if (permission === 'unresolved') return;
+    if (permission === 'refused') {
+        if (!isDueScheduled(value)) return;
+        docRef.update({
+            scheduleStatus: ENTRY_SCHEDULE_SKIPPED
+        }).catch((error)=>console.error(error));
+        return;
+    }
+    docRef.update({
+        status: 'published',
+        publishedAt: value['publishAt']
+    }).catch((error)=>console.error(error));
+}
+/**
+ * Fetches a collection's live entries (newest first), shared by the route
+ * loader and the compose-time Collection entries block (AGL-551).
+ */ async function listLiveEntries(entriesRef, hostId) {
+    // No orderBy: entries missing publishedAt would be dropped by Firestore;
+    // sort client-side like the version lists.
+    const entriesQuery = await entriesRef.where('status', 'in', [
+        'published',
+        'scheduled'
+    ])// Named rather than literal (AGL-1516): a search index has to be able to
+    // say "this read reached its bound", and it can only do that against a
+    // bound it shares with the query. `collectionSourceReachedBound` reads
+    // the same constant.
+    .limit(COLLECTION_SOURCE_MAX).get();
+    // Ask the plan question ONLY if something is actually due (AGL-471). A
+    // collection with no due schedule — almost every render — never reads the
+    // org at all.
+    const due = entriesQuery.docs.filter((entryDoc)=>isDueScheduled(entryDoc.data()));
+    const permission = due.length ? await scheduledPublishingPermission(hostId) : 'allowed';
+    // Record the terminal refusal on its own pass, because a refused entry is
+    // NOT live and so never reaches the `flipDueEntry` inside the map below.
+    // Without this the entry stays due forever: excluded from every render, and
+    // re-reading the org on each one.
+    if (permission !== 'allowed') {
+        for (const entryDoc of due){
+            flipDueEntry(entryDoc.ref, entryDoc.data(), permission);
+        }
+    }
+    // Measured on the RAW docs, before the liveness filter (AGL-1516). This is
+    // the only place that can still see how many documents the query returned;
+    // one line down that number is gone for good.
+    const reachedBound = entriesQuery.docs.length >= COLLECTION_SOURCE_MAX;
+    // Also measured on the RAW docs, and for the same reason: a not-yet-due
+    // entry is filtered out one line down, so this is the last place that can
+    // see one at all.
+    const pendingSchedule = entriesQuery.docs.some((entryDoc)=>isPendingScheduled(entryDoc.data()));
+    const entries = entriesQuery.docs.filter((entryDoc)=>isLive(entryDoc.data(), permission)).map((entryDoc)=>{
+        var _value_title, _value_slug, _value_publishedAt, _value_publishedAt1;
+        const value = entryDoc.data();
+        flipDueEntry(entryDoc.ref, value, permission);
+        return _extends({
+            $id: entryDoc.id,
+            title: (_value_title = value['title']) != null ? _value_title : entryDoc.id,
+            slug: (_value_slug = value['slug']) != null ? _value_slug : entryDoc.id
+        }, mapEntryFields(value), {
+            publishedAt: ((_value_publishedAt = value['publishedAt']) != null ? _value_publishedAt : value['publishAt']) ? {
+                seconds: ((_value_publishedAt1 = value['publishedAt']) != null ? _value_publishedAt1 : value['publishAt']).seconds
+            } : null
+        });
+    }).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);
+    });
+    return {
+        entries,
+        reachedBound,
+        pendingSchedule
+    };
+}
+/**
+ * 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 async function getPublishedCollectionSource(options) {
+    try {
+        return await withRenderCache({
+            key: [
+                'tenant-collection-source',
+                options.hostId,
+                options.collectionSlug
+            ],
+            revalidate: COLLECTION_SOURCE_TTL_SECONDS,
+            tags: [
+                tenantDataTag(options.hostId)
+            ],
+            read: ()=>readPublishedCollectionSource(options),
+            // A collection with a schedule still pending is SERVED but not STORED.
+            //
+            // No beat publishes a content entry — `flipDueEntry` during a render is
+            // the whole mechanism — so storing this source would suppress the very
+            // renders that would have noticed the entry coming due, and the post
+            // would wait out the TTL rather than land at its time. Declining to
+            // store leaves those collections exactly as uncached as they were
+            // before this cache existed, which is the only cost this cache is not
+            // allowed to reduce.
+            //
+            // Also refuses a collection that resolved to nothing, for the reason
+            // `withRenderCache` states about negatives generally: a slug that
+            // misses once must not miss for an hour.
+            store: (value)=>Boolean(value.collection) && !value.pendingSchedule
+        });
+    } catch (error) {
+        console.error(error);
+        return readPublishedCollectionSource(options);
+    }
+}
+async function readPublishedCollectionSource(options) {
+    try {
+        const collectionDoc = await findContentCollection(options.hostId, options.collectionSlug);
+        if (!collectionDoc) {
+            return {
+                collection: null,
+                entries: [],
+                categories: [],
+                reachedBound: false
+            };
+        }
+        const { entries, reachedBound, pendingSchedule } = await listLiveEntries(collectionDoc.ref.collection('entries'), options.hostId);
+        // The compose-time source feeds the Collection entries block, whose byline
+        // reads `authorName` — so a record-backed author has to be resolved here
+        // too, or the block prints nothing for the entries a list page shows
+        // (AGL-2486). This result is the cached one, which is what keeps the extra
+        // read amortized across every page of the site that carries the block.
+        await attachEntryAuthors(options.hostId, entries);
+        return _extends({
+            collection: mapCollectionDoc(collectionDoc, options.collectionSlug),
+            entries,
+            categories: mapCollectionCategories(collectionDoc.get('categories')),
+            reachedBound
+        }, pendingSchedule ? {
+            pendingSchedule: true
+        } : {});
+    } catch (error) {
+        console.error(error);
+        return {
+            collection: null,
+            entries: [],
+            categories: [],
+            reachedBound: false
+        };
+    }
+}
+/** Entries-only view of {@link getPublishedCollectionSource} (AGL-551). */ export async function getPublishedCollectionEntries(options) {
+    return (await getPublishedCollectionSource(options)).entries;
+}
+/**
+ * Narrows a listing to its routed category and stamps its pagination
+ * (AGL-1321 / AGL-620).
+ *
+ * Category first, ALWAYS: the two have to describe the same set. Counting
+ * pages over the whole collection and then filtering would advertise pages
+ * that render empty and hide entries that exist.
+ *
+ * `entriesReachedBound` is read by the caller BEFORE this runs, because a
+ * category route hands its already-narrowed entries to compose and the
+ * entries block's "measure the raw set, not the filtered one" rule then has
+ * nothing raw left to measure (AGL-1516).
+ */ function applyCategoryAndPagination(data, options) {
+    var _options_categorySlug;
+    const { page = 1, perPage } = options;
+    const routedCategory = ((_options_categorySlug = options.categorySlug) != null ? _options_categorySlug : '').trim();
+    if (routedCategory) {
+        var _ref;
+        var _data_collection;
+        const match = resolveCollectionCategoryBySlug((_data_collection = data.collection) == null ? void 0 : _data_collection.categories, routedCategory);
+        data.category = _extends({
+            slug: collectionCategorySlug(routedCategory)
+        }, match ? {
+            id: match.id
+        } : {}, {
+            name: (_ref = match == null ? void 0 : match.name) != null ? _ref : routedCategory
+        }, (match == null ? void 0 : match.description) ? {
+            description: match.description
+        } : {}, {
+            known: Boolean(match)
+        });
+        data.entries = data.entries.filter((entry)=>{
+            var _data_collection;
+            return entryMatchesCategoryRoute(entry, _extends({
+                slug: routedCategory
+            }, match ? {
+                category: match
+            } : {}), (_data_collection = data.collection) == null ? void 0 : _data_collection.categories);
+        });
+    }
+    if (perPage && perPage > 0) {
+        const totalEntries = data.entries.length;
+        data.pagination = {
+            page,
+            perPage,
+            totalEntries,
+            totalPages: collectionTotalPages(totalEntries, perPage)
+        };
+    }
+}
+/**
+ * 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 async function getCollectionContent(options) {
+    const { hostId, collectionSlug, entrySlug } = options;
+    const data = {
+        collection: null,
+        entries: [],
+        entry: null,
+        pagination: null,
+        category: null,
+        error: null
+    };
+    try {
+        // A LIST route is served entirely from the CACHED source, which every
+        // other page on the site already shares. It used to resolve the
+        // collection and re-read its entries here, uncached, on every
+        // regeneration of every listing address — `/blog`, nine `/blog/page/{n}`,
+        // one `/blog/category/{slug}` per category, and the RSS feed — so a
+        // collection of N live entries cost `1 + N + authors` reads per address
+        // per window, for data byte-identical to what the cache was already
+        // holding for the home page's "Latest posts" rail.
+        //
+        // An ENTRY route stays where it was: it reads ONE document by slug and
+        // has nothing to share.
+        if (!entrySlug) {
+            const source = await getPublishedCollectionSource({
+                hostId,
+                collectionSlug
+            });
+            if (!source.collection) return data;
+            // A collection is not a PAGE until something in it is live (AGL-3101).
+            // Without this, creating one publishes `/{slug}` at once — an empty
+            // listing with a feed and a markdown twin, before a word of it is
+            // written. Answering it as no collection makes every listing address
+            // 404 the way an unknown slug does, until the first entry is published
+            // or its schedule comes due.
+            //
+            // Read off the UNFILTERED live set, before the category narrows it, so
+            // an empty category of a live collection still renders. A read that
+            // stopped at its bound cannot prove the collection empty — the live
+            // entries may be past it — so that one keeps its listing. The rule
+            // lives here and not in the source above: the source also feeds the
+            // Collection entries block and the author page, and to them an empty
+            // collection is an empty list, not a missing one.
+            if (!source.entries.length && !source.reachedBound) return data;
+            data.collection = source.collection;
+            data.entries = source.entries;
+            data.entriesReachedBound = source.reachedBound;
+            applyCategoryAndPagination(data, options);
+            return data;
+        }
+        const collectionDoc = await findContentCollection(hostId, collectionSlug);
+        if (!collectionDoc) return data;
+        data.collection = mapCollectionDoc(collectionDoc, collectionSlug);
+        const entryQuery = await collectionDoc.ref.collection('entries').where('slug', '==', entrySlug).limit(5).get();
+        // Same two-step as `listLiveEntries`: only pay for the org read when
+        // something is due, and record the refusal on its own pass because a
+        // refused entry never becomes the `entryDoc` below (AGL-471).
+        const dueHere = entryQuery.docs.filter((docSnapshot)=>isDueScheduled(docSnapshot.data()));
+        const permission = dueHere.length ? await scheduledPublishingPermission(hostId) : 'allowed';
+        if (permission !== 'allowed') {
+            for (const docSnapshot of dueHere){
+                flipDueEntry(docSnapshot.ref, docSnapshot.data(), permission);
+            }
+        }
+        const entryDoc = entryQuery.docs.find((docSnapshot)=>isLive(docSnapshot.data(), permission));
+        if (entryDoc) {
+            var _value_title, _value_body, _value_publishedAt, _value_publishedAt1;
+            const value = entryDoc.data();
+            flipDueEntry(entryDoc.ref, value, permission);
+            data.entry = _extends({
+                $id: entryDoc.id,
+                title: (_value_title = value['title']) != null ? _value_title : entrySlug,
+                slug: entrySlug,
+                body: (_value_body = value['body']) != null ? _value_body : ''
+            }, mapEntryFields(value), {
+                publishedAt: ((_value_publishedAt = value['publishedAt']) != null ? _value_publishedAt : value['publishAt']) ? {
+                    seconds: ((_value_publishedAt1 = value['publishedAt']) != null ? _value_publishedAt1 : value['publishAt']).seconds
+                } : null
+            });
+            await attachEntryAuthors(hostId, [
+                data.entry
+            ]);
+        }
+    } catch (error) {
+        console.error(error);
+        data.error = error;
+    }
+    return data;
+}
+export default getCollectionContent;
+
+//# sourceMappingURL=get-collection-content.js.map