@aglyn/aglyn 1.0.0-beta.143

package/src/lib/app-utils/collection-entries.js

@@ -0,0 +1,1285 @@
+/**
+ * @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 { _ as _extends } from "@swc/helpers/_/_extends";
+import { COLLECTION_ENTRY_DATE_FORMAT_DEFAULT, collectionEntryPublishedAtIso, formatCollectionEntryDate, normalizeCollectionEntryDateFormat } from "./collection-entry-date.js";
+import { contentAuthorPageUrl, normalizeContentAuthorLinks } from "./content-authors.js";
+import { resolveNamedTokens } from "./resolve-named-tokens.js";
+export * from "./collection-entry-date.js";
+/**
+ * Persisted component id of the "Collection entries" repeater block
+ * (plugins-mui). Like `layoutSlot`, the id lives here so the tenant compose
+ * pipeline can find the block without importing the component bundle.
+ */ export const COLLECTION_ENTRIES_COMPONENT_ID = 'collectionEntries';
+/** Persisted component id of the markdown "Entry body" block (plugins-mui). */ export const COLLECTION_ENTRY_BODY_COMPONENT_ID = 'collectionEntryBody';
+/**
+ * Persisted component id of the "Related posts" block (plugins-mui,
+ * AGL-582). The compose pipeline stamps the related entries onto the node,
+ * so the id lives here like the entries/body blocks.
+ */ export const COLLECTION_RELATED_COMPONENT_ID = 'collectionRelated';
+/** Persisted component id of the share-bar block (plugins-mui, AGL-582). */ export const COLLECTION_SHARE_COMPONENT_ID = 'collectionShare';
+/** Persisted component id of the entry-meta block (plugins-mui, AGL-582). */ export const COLLECTION_ENTRY_META_COMPONENT_ID = 'collectionEntryMeta';
+/**
+ * Persisted component id of the author card that closes an article
+ * (plugins-mui, AGL-2486).
+ *
+ * Entry Meta prints the byline — a NAME, on one line, beside the date. The
+ * author record it now resolves against carries a portrait, a bio, a job
+ * title and a url, and none of those have anywhere to render: a template that
+ * wanted the card the article frame draws had to type the name and the blurb
+ * as literal text, which then said "The Aglyn Team" under a post somebody
+ * else wrote and went stale the moment the author record was edited. The id
+ * lives here, with the other collection blocks, so the compose pipeline can
+ * fill the card without importing the bundle.
+ */ export const COLLECTION_ENTRY_AUTHOR_COMPONENT_ID = 'collectionEntryAuthor';
+/**
+ * Persisted component id of the "Category Pills" block (plugins-mui,
+ * AGL-1321). Like the entries repeater, the id lives here so the tenant
+ * compose pipeline can stamp the block's links without importing the bundle.
+ */ export const COLLECTION_CATEGORIES_COMPONENT_ID = 'collectionCategories';
+/**
+ * Persisted component id of the standalone "Collection Search" block
+ * (plugins-mui, AGL-1516).
+ *
+ * The Collection Entries block grew its own search box first, and it renders
+ * INSIDE that block — first child of the block's own stack. Figma 494:1220
+ * puts the field in the listing's toolbar row instead, beside the RSS button
+ * with the category pills opposite it, and no amount of authoring can lift a
+ * block's own child out of it. The pills cannot move the other way either:
+ * every child of an entries block is cloned once per entry.
+ *
+ * So the field became a block an author can put where the frame draws it.
+ * Suggestion-panel only, by construction rather than by omission — a
+ * standalone box has no clones to hide, so `filter` is a thing it genuinely
+ * cannot do, and the one behaviour it does have is the toolbar behaviour the
+ * frame asks for.
+ */ export const COLLECTION_SEARCH_COMPONENT_ID = 'collectionSearch';
+/**
+ * Reserved list sub-paths (AGL-620 `page`, AGL-1321 `category`). Both are
+ * only reserved as the HEAD of a longer path, so an entry legitimately
+ * slugged `page` or `category` keeps serving at `/{collection}/{entry}`.
+ */ export const COLLECTION_PAGE_ROUTE_SEGMENT = 'page';
+export const COLLECTION_CATEGORY_ROUTE_SEGMENT = 'category';
+/** Namespaces cloned template ids per container/entry (cf. `rep__`). */ export const COLLECTION_ENTRIES_NODE_ID_PREFIX = 'centry__';
+/** Hard bound on entries a single block renders, before `entriesLimit`. */ export const COLLECTION_ENTRIES_MAX = 100;
+/**
+ * Hard bound on the entries one READ of a collection returns (AGL-1516) — the
+ * `.limit()` the tenant's live-entries query carries.
+ *
+ * Named here, beside the render bound it has always silently matched, because
+ * a search index has to know the difference. The render bound is a choice
+ * about a block; this one is a choice about the DATA, and a set that reaches
+ * it is a set nobody has seen all of. Two 100s that happened to agree meant
+ * `entries.length === 100` could be read either as "this collection has 100
+ * entries" or "this read stopped at 100", and the honest empty state turns on
+ * exactly that distinction.
+ */ export const COLLECTION_SOURCE_MAX = 100;
+/**
+ * Whether a collection source is a COMPLETE read or a bounded one
+ * (AGL-1516) — true when the read came back holding its own limit, which is
+ * the only signal a limited query without a count leaves behind.
+ *
+ * Deliberately errs toward "bounded": a collection of exactly
+ * {@link COLLECTION_SOURCE_MAX} entries answers true and gets described one
+ * notch more cautiously than it needed. Overstating what a search covered is
+ * the failure that renders as a confident "nothing matched".
+ */ export function collectionSourceReachedBound(entries) {
+    var _ref;
+    return ((_ref = entries == null ? void 0 : entries.length) != null ? _ref : 0) >= COLLECTION_SOURCE_MAX;
+}
+/**
+ * Whether the read behind a collection source was a bounded one (AGL-1516),
+ * asking the READER first and only then falling back to counting.
+ *
+ * The count is a proxy, and it under-reports in two ways that both landed
+ * after `collectionSourceReachedBound` was written:
+ *
+ * 1. The query takes `status in ['published', 'scheduled']` and the loader
+ *    then drops what is not live yet — a future `publishAt`, or since AGL-471
+ *    a due schedule the plan does not carry. A read that came back holding
+ *    its full 100 docs can therefore hand over 96 entries, and 96 does not
+ *    look like a ceiling. A blog with a scheduling queue is exactly the site
+ *    that hits this.
+ * 2. A category route filters `entries` before compose ever sees them, so the
+ *    "raw set" the entries block is careful to measure is already narrowed.
+ *
+ * Both make the flag read FALSE on a read that really did stop at its bound,
+ * and false is the direction that produces the confident "nothing matched"
+ * this signal exists to prevent. So `reachedBound` is threaded down from the
+ * query that owns the fact, and the count survives only as the fallback for a
+ * source that predates it — a payload cached before this shipped, or a caller
+ * that assembles a source by hand.
+ */ export function collectionSourceIsBounded(source) {
+    if (source == null ? void 0 : source.reachedBound) return true;
+    return collectionSourceReachedBound(source == null ? void 0 : source.entries);
+}
+/** Default entries per page for a paginated collection list (AGL-620). */ export const COLLECTION_LIST_PAGE_SIZE = 10;
+/**
+ * Total pages for `total` entries at `perPage` per page — at least 1 so an
+ * empty collection still has a page 1 (AGL-620).
+ */ export function collectionTotalPages(total, perPage) {
+    if (perPage <= 0) return 1;
+    return Math.max(1, Math.ceil(total / perPage));
+}
+/** Default/most related posts a Related posts block renders (AGL-582). */ export const COLLECTION_RELATED_DEFAULT_LIMIT = 3;
+export const COLLECTION_RELATED_MAX = 12;
+/** Most categories a collection's taxonomy holds (AGL-582). */ export const COLLECTION_CATEGORIES_MAX = 50;
+/**
+ * How many LIVE entries one content collection may hold (AGL-2266).
+ *
+ * `hosts/{hostId}/collections/{cid}/entries/{eid}` had a DEDICATED rules block
+ * re-granting `create` to any editor, client-direct — deliberately, because the
+ * name-based exclusions on the host catch-all must not reach entries — so it
+ * was the one quota-governed shape under a host with no quota at all. A free
+ * org could mint unbounded Firestore documents from the browser.
+ *
+ * This is a flat PLATFORM cap, not a plan dimension. AGL-1387 declined
+ * `collectionsPerHost` and this does not re-open it: nothing here is priced,
+ * no `OrgEntitlements` key is added, and every plan gets the same number. It is
+ * the `WEBHOOK_MAX_PER_HOST` (AGL-1360) / `NON_PAGE_SCREEN_MAX_PER_HOST`
+ * (AGL-1399) shape, which both issues invented for exactly this: uncapped
+ * infrastructure behind a $0 subscription.
+ *
+ * ## Per COLLECTION, paired with {@link COLLECTIONS_MAX_PER_HOST}
+ *
+ * A per-HOST entry cap would need a count across every collection the host
+ * holds, which is a collection-group read the entry documents carry no `hostId`
+ * to scope. Per collection is one `count()` on the collection the create is
+ * addressed to — the same read every other cap on `/api/hosts/resources`
+ * already pays — and the host is bounded by the PRODUCT of the two numbers,
+ * which is why the sibling cap had to land in the same change. One of the two
+ * alone bounds nothing: unbounded collections each holding 10,000 entries is
+ * the same unbounded store, spelled differently.
+ *
+ * ## Why 10,000
+ *
+ * A blog publishing daily reaches it after twenty-seven years; the largest
+ * content collection in production holds double digits. The failure mode of a
+ * flat cap set too low is blocking real authoring with an error the price list
+ * cannot explain, so it is sized to the heaviest plausible library rather than
+ * to today's data. It also bounds the cost of the console's own listing, which
+ * reads entries with `limit(200)` and would otherwise page through a store with
+ * no ceiling.
+ */ export const ENTRIES_MAX_PER_COLLECTION = 10000;
+/**
+ * How many LIVE content collections one host may hold (AGL-2266).
+ *
+ * The other half of the entry bound above, and the reason it means anything.
+ * Collection creation was already server-owned — the rules deny client `create`
+ * and `/api/hosts/collections` claims the slug transactionally (AGL-978) — so
+ * the collection had a WRITER with authority and simply no number to enforce.
+ *
+ * Again a platform cap and not `collectionsPerHost`: AGL-1387 decided
+ * collections are not a thing customers are charged for, and that decision is
+ * untouched. 100 is far past any real site's taxonomy — production's busiest
+ * host has a handful — and short enough that the entries ceiling above
+ * multiplies out to a bounded store rather than an unbounded one.
+ */ export const COLLECTIONS_MAX_PER_HOST = 100;
+/**
+ * Display name of an entry's category (AGL-582): the `categoryId` lookup
+ * into the collection's taxonomy wins; the legacy free-typed
+ * `entry.category` string is the fallback so existing data keeps
+ * rendering. An ID referencing a deleted category resolves to nothing —
+ * by design the entry simply shows no category.
+ */ export function resolveEntryCategoryName(entry, // `readonly` because this only reads (AGL-1321): the route helpers hold
+// the taxonomy as readonly and would otherwise have to copy it to ask.
+categories) {
+    var _entry_categoryId, _entry_category;
+    const categoryId = ((_entry_categoryId = entry.categoryId) != null ? _entry_categoryId : '').trim();
+    if (categoryId) {
+        const match = (categories != null ? categories : []).find((category)=>category.id === categoryId);
+        if (match == null ? void 0 : match.name) return match.name;
+    }
+    const legacy = ((_entry_category = entry.category) != null ? _entry_category : '').trim();
+    return legacy || undefined;
+}
+/* ── Published-date formats (AGL-1459) ──────────────────────────────────── */ /**
+ * The values an Entry Meta block shows, in the exact spellings the
+ * `{{entry.date}}` / `{{entry.author}}` / `{{entry.category}}` /
+ * `{{entry.tags}}` tokens produce (AGL-1385, author added AGL-1459).
+ *
+ * Extracted so the token map and {@link expandCollectionEntryMeta} cannot
+ * drift: the same entry has to read the same way whether the author bound the
+ * tokens by hand or let the server fill the block in.
+ */ export function collectionEntryMetaValues(entry, categories, dateFormat) {
+    var _resolveEntryCategoryName, _entry_tags;
+    var _entry_author;
+    return {
+        date: formatCollectionEntryDate(entry.publishedAt, dateFormat),
+        // The per-entry byline the editor already collects (AGL-686). It was
+        // reachable in the entry's JSON-LD and nowhere on the page, which is what
+        // made the frame's byline unauthorable (AGL-1459).
+        //
+        // The resolved RECORD first, then the legacy string (AGL-2486) — the
+        // precedence `resolveEntryAuthor` applies, spelled the same way here. The
+        // tenant denormalizes the record's name onto `authorName` before this
+        // runs, so on a live render the two agree; reading the record directly is
+        // what makes that a convenience rather than the only thing holding the
+        // byline up.
+        author: (((_entry_author = entry.author) == null ? void 0 : _entry_author.name) || entry.authorName || '').trim(),
+        // Entry model v2 (AGL-582): category resolves by stable ID against the
+        // collection's taxonomy, falling back to the legacy free-typed string.
+        category: (_resolveEntryCategoryName = resolveEntryCategoryName(entry, categories)) != null ? _resolveEntryCategoryName : '',
+        tags: ((_entry_tags = entry.tags) != null ? _entry_tags : []).join(', ')
+    };
+}
+/**
+ * The values an Entry Author card shows (AGL-2486) — the fields of the
+ * resolved author RECORD, in the spellings the `{{entry.author*}}` tokens
+ * produce.
+ *
+ * Extracted for the reason {@link collectionEntryMetaValues} was: the card,
+ * the token map and {@link expandCollectionEntryAuthor} have to agree, and
+ * three copies of "name, falling back to the legacy string" would not.
+ *
+ * `image` stays RAW — a `media:` reference or a plain url, whichever the
+ * author saved — because the resolver that turns one into a fetchable src
+ * needs the rendering host and this function has no host (`resolveMediaSrc`,
+ * AGL-1215). Every other consumer of an image field in this file does the
+ * same.
+ */ export function collectionEntryAuthorValues(entry) {
+    var _ref, _ref1, _ref2, _ref3, _ref4;
+    const author = entry.author;
+    return {
+        // Their page on THIS site (AGL-2518/2519) — a different destination from
+        // `url`, which is their own. Empty when nothing addresses them, so the
+        // byline renders as plain text rather than as a link to `/author/`.
+        pageUrl: contentAuthorPageUrl(_extends({}, author ? {
+            author
+        } : {}, entry.authorId ? {
+            authorId: entry.authorId
+        } : {}, entry.authorName ? {
+            authorName: entry.authorName
+        } : {})),
+        // The rows the card PRINTS (AGL-2516). Normalized here rather than
+        // trusted, because this is the boundary a stored document crosses to
+        // become props: the renderer guards the href too, but only one of the two
+        // sits on the path a hand-written document would take.
+        links: normalizeContentAuthorLinks(author == null ? void 0 : author.links),
+        // The record wins, then the legacy free-typed byline (AGL-686), which is
+        // the same precedence `resolveEntryAuthor` applies — an entry written
+        // before custom authors still fills a card, with the one field it has.
+        name: ((_ref = (_ref1 = author == null ? void 0 : author.name) != null ? _ref1 : entry.authorName) != null ? _ref : '').trim(),
+        bio: ((_ref2 = author == null ? void 0 : author.bio) != null ? _ref2 : '').trim(),
+        image: ((_ref3 = author == null ? void 0 : author.image) != null ? _ref3 : '').trim(),
+        url: ((_ref4 = author == null ? void 0 : author.url) != null ? _ref4 : '').trim()
+    };
+}
+/**
+ * The `{{entry.*}}` token map for one entry (AGL-105/551): substituted
+ * globally on entry-template screens and per-clone inside the Collection
+ * entries block. `entry.url` resolves to the entry's auto-route so links
+ * (`Read more`, titles) work without hardcoding the collection slug.
+ */ export function collectionEntryTokens(entry, collectionSlug, categories) {
+    var _entry_collectionSlug, _entry_title, _entry_excerpt, _entry_body, _entry_coverImage, _entry_coverVideo, _entry_slug, _entry_slug1, _entry_collectionName;
+    const meta = collectionEntryMetaValues(entry, categories);
+    const author = collectionEntryAuthorValues(entry);
+    // The entry's OWN collection wins over the routed one (AGL-2518) — see
+    // `CollectionEntryRecord.collectionSlug`. Unset on every single-collection
+    // listing, which is why this changes nothing for them.
+    const slug = ((_entry_collectionSlug = entry.collectionSlug) != null ? _entry_collectionSlug : '').trim() || collectionSlug;
+    return {
+        'entry.title': (_entry_title = entry.title) != null ? _entry_title : '',
+        'entry.excerpt': (_entry_excerpt = entry.excerpt) != null ? _entry_excerpt : '',
+        'entry.body': (_entry_body = entry.body) != null ? _entry_body : '',
+        'entry.coverImage': (_entry_coverImage = entry.coverImage) != null ? _entry_coverImage : '',
+        // The featured video (AGL-2956), raw like the cover: a template binds it
+        // into a Video element's source, and the element resolves a reference
+        // against the site rendering it.
+        'entry.coverVideo': (_entry_coverVideo = entry.coverVideo) != null ? _entry_coverVideo : '',
+        'entry.slug': (_entry_slug = entry.slug) != null ? _entry_slug : '',
+        'entry.url': `/${slug}/${(_entry_slug1 = entry.slug) != null ? _entry_slug1 : ''}`,
+        // Which section this entry belongs to (AGL-2518). Worth binding only on a
+        // listing that MIXES collections — the author page — where a card
+        // otherwise gives a reader no way to tell a release note from an essay.
+        'entry.collection': ((_entry_collectionName = entry.collectionName) != null ? _entry_collectionName : '').trim(),
+        'entry.collectionSlug': slug,
+        'entry.collectionUrl': slug ? `/${slug}` : '',
+        'entry.date': meta.date,
+        // The same instant for a parser (AGL-2956). `entry.date` is written for a
+        // reader, so a Video element's publication date bound to it publishes an
+        // `uploadDate` no crawler can read; this one is an ISO date-time.
+        'entry.publishedAt': collectionEntryPublishedAtIso(entry.publishedAt),
+        // The byline (AGL-1459). Bindable by hand for the same reason every other
+        // field is: a template that wants it somewhere Entry Meta does not reach.
+        'entry.author': meta.author,
+        // The rest of the author RECORD (AGL-2486). Bindable by hand for the
+        // same reason `entry.author` is: a card laid out by the designer rather
+        // than dropped as the Entry Author block still has to say who wrote the
+        // piece, and typing the blurb in as literal text is how a byline starts
+        // naming the wrong person.
+        'entry.authorBio': author.bio,
+        'entry.authorImage': author.image,
+        'entry.authorUrl': author.url,
+        /**
+     * This author's page on this site (AGL-2518) — "more from the person who
+     * wrote this".
+     *
+     * A separate token from `entry.authorUrl`, which is the author's own site,
+     * because they are different destinations and a template should be able to
+     * offer either or both. Empty when there is nothing addressable, so a
+     * binding renders no link rather than one pointing at `/author/`.
+     */ 'entry.authorPageUrl': contentAuthorPageUrl(_extends({}, entry.author ? {
+            author: entry.author
+        } : {}, entry.authorId ? {
+            authorId: entry.authorId
+        } : {}, entry.authorName ? {
+            authorName: entry.authorName
+        } : {})),
+        // Entry model v2 (AGL-582): taxonomy + SEO tokens. The SEO pair falls
+        // back to title/excerpt so templates can bind them unconditionally.
+        'entry.category': meta.category,
+        'entry.tags': meta.tags,
+        'entry.seoTitle': entry.seoTitle || entry.title || '',
+        'entry.seoDescription': entry.seoDescription || entry.excerpt || ''
+    };
+}
+/**
+ * Category/tag membership check (AGL-582), shared by the Collection entries
+ * filter props and the query-less list surfaces. Matching is trimmed and
+ * case-insensitive — editors type these by hand. A category filter matches
+ * either the entry's stable `categoryId` or its RESOLVED display name (id
+ * lookup first, legacy string fallback), so filters written against either
+ * spelling keep working across the taxonomy migration.
+ */ export function entryMatchesFilter(entry, filter, categories) {
+    const normalize = (value)=>value.trim().toLowerCase();
+    if (filter.category) {
+        var _entry_categoryId, _entry_categoryId1, _resolveEntryCategoryName;
+        const wanted = normalize(filter.category);
+        const matchesId = Boolean(((_entry_categoryId = entry.categoryId) != null ? _entry_categoryId : '').trim()) && normalize((_entry_categoryId1 = entry.categoryId) != null ? _entry_categoryId1 : '') === wanted;
+        const matchesName = normalize((_resolveEntryCategoryName = resolveEntryCategoryName(entry, categories)) != null ? _resolveEntryCategoryName : '') === wanted;
+        if (!matchesId && !matchesName) return false;
+    }
+    if (filter.tag) {
+        var _entry_tags;
+        const wanted = normalize(filter.tag);
+        if (!((_entry_tags = entry.tags) != null ? _entry_tags : []).some((tag)=>normalize(tag) === wanted)) {
+            return false;
+        }
+    }
+    return true;
+}
+/* ── Category routes (AGL-1321) ─────────────────────────────────────────── */ /**
+ * URL form of a category id or display name (AGL-1321): lowercase, runs of
+ * non-alphanumerics collapsed to a single `-`, no leading/trailing dash.
+ *
+ * Deliberately lossy and idempotent, so the same category addresses the same
+ * URL whether the author typed the taxonomy id, the display name, or the URL
+ * segment itself. `Open source` → `open-source` → `open-source`.
+ */ export function collectionCategorySlug(value) {
+    return String(value != null ? value : '').trim().toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
+}
+/**
+ * The taxonomy category a URL segment addresses (AGL-1321), matched on the
+ * stable `id` OR the slugified display name — an author linking
+ * `/blog/category/open-source` should not have to know which of the two the
+ * data happens to store, and an `id` that survives a rename is exactly why
+ * the taxonomy has one. `undefined` = the segment names no known category;
+ * the caller renders an empty listing rather than crashing.
+ */ export function resolveCollectionCategoryBySlug(categories, slug) {
+    const wanted = collectionCategorySlug(slug);
+    if (!wanted) return undefined;
+    return (categories != null ? categories : []).find((category)=>collectionCategorySlug(category.id) === wanted || collectionCategorySlug(category.name) === wanted);
+}
+/**
+ * The canonical URL of a collection listing (AGL-1321). ONE builder, because
+ * the pills, the pager, the `<link rel="canonical">`, the JSON-LD and the
+ * sitemap must all agree on the shape or the filter quietly becomes a
+ * duplicate-content generator.
+ *
+ * The unfiltered page-1 listing is the bare `/{collection}` — there is no
+ * `/{collection}/category/all` and no `?category=all`, so "All" cannot become
+ * a second address for the page that already exists.
+ */ export function collectionListUrl(options) {
+    const scoped = options.categorySlug ? `/${options.collectionSlug}/${COLLECTION_CATEGORY_ROUTE_SEGMENT}/` + collectionCategorySlug(options.categorySlug) : `/${options.collectionSlug}`;
+    const page = Number(options.page);
+    return Number.isFinite(page) && page > 1 ? `${scoped}/${COLLECTION_PAGE_ROUTE_SEGMENT}/${Math.floor(page)}` : scoped;
+}
+/**
+ * Everything a pager needs for one listing (AGL-1386): which page it is on,
+ * how many there are, and where prev/next go — through
+ * {@link collectionListUrl}, so both links stay inside the category they are
+ * paging rather than dumping the reader back onto the unfiltered list.
+ *
+ * **The edges resolve to the empty string, never to a URL.** No previous page
+ * means `prevUrl` is `''`; no next page means `nextUrl` is `''`. That is what
+ * lets an authored template bind these unconditionally: one static list screen
+ * serves the bare listing, every `/page/{n}`, and every
+ * `/category/{slug}` — and there is no runtime conditional to hide a link
+ * with. A link whose href resolves to `''` 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 two consumers that must agree: the built-in
+ * fallback pager's nodes and the `{{pagination.*}}` tokens an authored
+ * template binds. A second derivation is how a fallback and a template start
+ * disagreeing about which page they are on.
+ */ export function collectionPaginationLinks(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)=>collectionListUrl(_extends({
+            collectionSlug: options.collectionSlug
+        }, options.categorySlug ? {
+            categorySlug: options.categorySlug
+        } : {}, {
+            page: n
+        }));
+    return {
+        page,
+        totalPages,
+        prevUrl: page > 1 ? href(page - 1) : '',
+        nextUrl: page < totalPages ? href(page + 1) : ''
+    };
+}
+const POSITIVE_INTEGER = /^[1-9]\d*$/;
+/**
+ * Parses a non-screen path against the content-collection route shapes
+ * (AGL-81/620/1321), or `null` when it is none of them and the caller should
+ * fall through to the 404 chain:
+ *
+ * ```
+ * /{collection}                                list, page 1, all categories
+ * /{collection}/{entry}                        one entry
+ * /{collection}/page/{n}                       list page n
+ * /{collection}/category/{slug}                filtered list, page 1
+ * /{collection}/category/{slug}/page/{n}       filtered list, page n
+ * ```
+ *
+ * Pure, and shared by the tenant loader and its tests, because the route
+ * table IS the ISR cache key here: the tenant catch-all caches by PATH, so a
+ * listing variant that lives in the path gets its own cache entry for free,
+ * while one that lived in a query string would share `/blog`'s entry and
+ * serve one category's HTML for another.
+ */ export function parseCollectionRoute(segments) {
+    const [collectionSlug, ...rest] = segments;
+    if (!collectionSlug) return null;
+    if (!rest.length) return {
+        collectionSlug,
+        page: 1
+    };
+    if (rest.length === 1) return {
+        collectionSlug,
+        entrySlug: rest[0],
+        page: 1
+    };
+    if (rest.length === 2 && rest[0] === COLLECTION_PAGE_ROUTE_SEGMENT) {
+        return POSITIVE_INTEGER.test(rest[1]) ? {
+            collectionSlug,
+            page: Number(rest[1])
+        } : null;
+    }
+    if (rest.length === 2 && rest[0] === COLLECTION_CATEGORY_ROUTE_SEGMENT) {
+        const categorySlug = collectionCategorySlug(rest[1]);
+        return categorySlug ? {
+            collectionSlug,
+            categorySlug,
+            page: 1
+        } : null;
+    }
+    if (rest.length === 4 && rest[0] === COLLECTION_CATEGORY_ROUTE_SEGMENT && rest[2] === COLLECTION_PAGE_ROUTE_SEGMENT && POSITIVE_INTEGER.test(rest[3])) {
+        const categorySlug = collectionCategorySlug(rest[1]);
+        return categorySlug ? {
+            collectionSlug,
+            categorySlug,
+            page: Number(rest[3])
+        } : null;
+    }
+    return null;
+}
+/**
+ * Does this entry belong to the category a URL segment addresses (AGL-1321)?
+ *
+ * Every spelling the route could plausibly mean is slugified into one set and
+ * checked against both of the entry's own spellings — the stable `categoryId`
+ * and the RESOLVED display name. So `/blog/category/open-source` answers for
+ * a taxonomy whose id is `opensource`, for one whose id is opaque but whose
+ * name is "Open source", and for a legacy free-typed entry that predates the
+ * taxonomy entirely. `entryMatchesFilter` cannot stand in: it compares raw
+ * trimmed strings, so it would miss every multi-word category name.
+ */ export function entryMatchesCategoryRoute(entry, route, categories) {
+    var _route_category, _route_category1;
+    const wanted = new Set([
+        route.slug,
+        (_route_category = route.category) == null ? void 0 : _route_category.id,
+        (_route_category1 = route.category) == null ? void 0 : _route_category1.name
+    ].map((value)=>collectionCategorySlug(value)).filter(Boolean));
+    if (!wanted.size) return false;
+    const entryId = collectionCategorySlug(entry.categoryId);
+    if (entryId && wanted.has(entryId)) return true;
+    const entryName = collectionCategorySlug(resolveEntryCategoryName(entry, categories));
+    return Boolean(entryName) && wanted.has(entryName);
+}
+/** Label the unfiltered pill carries when the author never named one. */ export const COLLECTION_ALL_PILL_DEFAULT = 'All';
+/**
+ * The value that persists "no All pill" (AGL-1336).
+ *
+ * The attribute documented "clear it to omit that pill" and could not do it:
+ * the attributes form strips an emptied text field's KEY (ddf maps an
+ * emptied field to its `clearedValue`, final-form's default parse turns
+ * `''` into `undefined`, and `updateNodeProps` replaces the props object),
+ * so the absent key took {@link COLLECTION_ALL_PILL_DEFAULT} and the pill
+ * came straight back. `''` is therefore not a value this field can hold —
+ * the same AGL-1191 trap that made the App Bar's "Default" unpersistable.
+ *
+ * So the field carries this as its `clearedValue`: clearing the box writes
+ * the word `none`, which survives the round trip and is honoured here.
+ * Deliberately a readable word rather than a magic character — an author who
+ * reopens the panel sees `none` in the All-label box and can read what it
+ * did. Removing the prop entirely (the ✕ affordance) still means "unset",
+ * and restores the default.
+ */ export const COLLECTION_ALL_PILL_NONE = 'none';
+/**
+ * What the unfiltered pill should be labelled, or `''` to omit it — the ONE
+ * place the {@link COLLECTION_ALL_PILL_NONE} sentinel is interpreted
+ * (AGL-1336). Matched case-insensitively on the trimmed value, because the
+ * sentinel is typed by a human only when they are re-entering it by hand.
+ *
+ * `undefined` is UNSET and takes the default. `null` is CLEARED and omits —
+ * it reaches here only from a hand-edited or imported document, but the two
+ * are different questions and must not collapse into one answer.
+ */ export function resolveCollectionAllLabel(value) {
+    if (value === undefined) return COLLECTION_ALL_PILL_DEFAULT;
+    if (value === null) return '';
+    const text = `${value}`.trim();
+    if (!text) return '';
+    return text.toLowerCase() === COLLECTION_ALL_PILL_NONE ? '' : text;
+}
+/**
+ * The pill row for a collection (AGL-1321): "All" pointing at the canonical
+ * unfiltered listing, then one pill per taxonomy category.
+ *
+ * Each pill addresses its category by the STABLE id where there is one, so a
+ * rename moves the label without breaking the link. Active state is decided
+ * through the same resolver the route used, not by string equality, because
+ * the URL may legitimately have named the category by either spelling.
+ */ export function buildCollectionCategoryLinks(options) {
+    var _options_categories;
+    const { collectionSlug } = options;
+    const active = collectionCategorySlug(options.activeCategorySlug);
+    const links = [];
+    for (const category of (_options_categories = options.categories) != null ? _options_categories : []){
+        const idSlug = collectionCategorySlug(category.id);
+        const nameSlug = collectionCategorySlug(category.name);
+        const slug = idSlug || nameSlug;
+        if (!slug) continue;
+        links.push({
+            label: category.name,
+            href: collectionListUrl({
+                collectionSlug,
+                categorySlug: slug
+            }),
+            active: Boolean(active) && (idSlug === active || nameSlug === active)
+        });
+    }
+    // A lone "All" pill is not a filter, it is decoration — a collection with
+    // no taxonomy gets no row at all.
+    if (!links.length) return [];
+    const allLabel = resolveCollectionAllLabel(options.allLabel);
+    return allLabel ? [
+        {
+            label: allLabel,
+            href: collectionListUrl({
+                collectionSlug
+            }),
+            active: !active
+        },
+        ...links
+    ] : links;
+}
+/**
+ * The matchable text a search box holds for a set of entries (AGL-1516),
+ * built ONCE for both blocks that carry one — the entries block's in-place
+ * filter and the standalone toolbar box (AGL-1516, Figma 494:1220).
+ *
+ * Shared rather than copied for the same reason
+ * {@link COLLECTION_SEARCH_FUSE_OPTIONS} is: the two boxes can sit on the
+ * same page, over the same collection, and a reader who sees a suggestion in
+ * one and a miss in the other has been told the site is broken. Two builders
+ * is how the row's date, chip and link drift apart.
+ *
+ * The row's link, date and category are resolved HERE, where the entry still
+ * exists — a component only holds rendered markup by the time it runs, and
+ * the suggestion panel draws its rows from this index rather than from the
+ * clones. Through the same three resolvers Related posts uses (AGL-1926 for
+ * the date especially): a suggestion for a post is the same post as the card
+ * below it and must not be able to disagree with it about its date.
+ */ export function buildCollectionSearchIndex(entries, collectionSlug, categories) {
+    return entries.map((entry)=>{
+        var _entry_title, _entry_excerpt, _entry_collectionSlug;
+        var _entry_publishedAt;
+        const categoryName = resolveEntryCategoryName(entry, categories);
+        return _extends({
+            title: (_entry_title = entry.title) != null ? _entry_title : '',
+            excerpt: (_entry_excerpt = entry.excerpt) != null ? _entry_excerpt : ''
+        }, entry.slug ? {
+            url: `/${((_entry_collectionSlug = entry.collectionSlug) != null ? _entry_collectionSlug : '').trim() || collectionSlug}/${entry.slug}`
+        } : {}, ((_entry_publishedAt = entry.publishedAt) == null ? void 0 : _entry_publishedAt.seconds) ? {
+            date: formatCollectionEntryDate(entry.publishedAt)
+        } : {}, categoryName ? {
+            category: categoryName
+        } : {});
+    });
+}
+/**
+ * The collection blocks that can be BOUND to a collection by name, rather
+ * than inheriting the routed one.
+ *
+ * The same three `scanCollectionBlocks` resolves a source for, and the same
+ * three that can therefore put a collection's entries on a page that is not
+ * one of the collection's own routes — a "Latest posts" rail on the home
+ * page, a category pill strip in a layout's chrome, a search box in a header.
+ *
+ * Related posts is deliberately absent. It resolves against the routed
+ * collection and renders nothing without a current entry in context, so it
+ * only ever appears on an entry page, which the entry's own address already
+ * covers.
+ */ const COLLECTION_BOUND_COMPONENT_IDS = [
+    COLLECTION_ENTRIES_COMPONENT_ID,
+    COLLECTION_CATEGORIES_COMPONENT_ID,
+    COLLECTION_SEARCH_COMPONENT_ID
+];
+/**
+ * Does this tree render the collection `collectionSlug` away from the
+ * collection's own routes?
+ *
+ * The content twin of {@link nodesPlaceForm}, and it exists for the same
+ * reason: an entry edit changes every page that renders the collection, and
+ * those pages are found by SEARCHING node trees rather than by matching a
+ * pointer. A collection's own addresses are derivable from its slug; a rail
+ * on the home page is not derivable from anything.
+ *
+ * Matches only an EXPLICIT `collectionSlug`. A block that names none inherits
+ * the routed collection — which means it renders nothing at all off-route
+ * (`scanCollectionBlocks` adds no slug, so the block is left untouched) and
+ * renders the routed collection on-route, where the collection's own list and
+ * entry addresses already reach it. Treating an unbound block as a dependent
+ * of every collection on the site would make every entry save drop every page
+ * that carries one.
+ *
+ * The comparison is against the slug rather than the document id because that
+ * is what the binding stores, and what `scanCollectionBlocks` resolves. A
+ * collection whose slug was just changed is a different question, and one the
+ * slug change itself has to answer.
+ */ export function nodesRenderCollection(nodes, collectionSlug) {
+    const wanted = String(collectionSlug != null ? collectionSlug : '').trim();
+    if (!wanted) return false;
+    for (const node of Object.values(nodes != null ? nodes : {})){
+        var _node_props;
+        if (!node) continue;
+        if (!COLLECTION_BOUND_COMPONENT_IDS.includes(String(node.componentId))) {
+            continue;
+        }
+        const bound = (_node_props = node.props) == null ? void 0 : _node_props['collectionSlug'];
+        if (typeof bound === 'string' && bound.trim() === wanted) return true;
+    }
+    return false;
+}
+/**
+ * Collection entries blocks (AGL-551): a `collectionEntries` container
+ * treats its children as the item template and renders them once per
+ * published entry, with `{{entry.*}}` tokens in cloned string props replaced
+ * per entry — the content-collection sibling of {@link expandRepeatables}.
+ *
+ * - The block's collection resolves from its `collectionSlug` prop, falling
+ *   back to `defaultSlug` (the routed collection on list-template screens).
+ * - Clone ids are namespaced `centry__{containerId}__{index}__…` so repeats
+ *   never collide; run AFTER grafting and BEFORE binding resolution.
+ * - Rows are bounded by `props.entriesLimit` and
+ *   {@link COLLECTION_ENTRIES_MAX}.
+ * - `props.firstPageOnly` renders zero rows past page 1 of the ROUTED
+ *   listing (AGL-1871), so a lead card does not repeat down the pagination.
+ * - An UNKNOWN collection leaves the node untouched (fail-open: a renamed
+ *   collection must never take a screen down). A known collection with no
+ *   matching entries renders zero rows — never the unsubstituted template.
+ * - Inputs are never mutated; template nodes stay in the map unreferenced.
+ */ export function expandCollectionEntries(nodes, sourcesBySlug, defaultSlug) {
+    const containers = Object.entries(nodes).filter(([, node])=>(node == null ? void 0 : node.componentId) === COLLECTION_ENTRIES_COMPONENT_ID);
+    if (!containers.length) return nodes;
+    const next = _extends({}, nodes);
+    for (const [containerId, container] of containers){
+        var _ref, _ref1, _ref2;
+        var _container_props, _container_props1, _container_props2, _container_props3, _container_props4, _container_props5, _container_props6, _container_props7;
+        const slug = String((_ref = (_container_props = container.props) == null ? void 0 : _container_props.collectionSlug) != null ? _ref : '').trim() || defaultSlug;
+        const source = slug ? sourcesBySlug[slug] : undefined;
+        // An UNKNOWN collection leaves the node untouched — fail-open, so a
+        // renamed collection never takes a published screen down.
+        //
+        // A KNOWN collection with nothing to show is a different question, and
+        // used to get the same answer (AGL-1321). Leaving the template in place
+        // renders it once, with its `{{entry.title}}` / `{{entry.url}}` tokens
+        // never substituted, so the page shipped a ghost row of literal braces.
+        // That was rare while the only way to empty a list was to publish an
+        // empty collection; a category filter makes it reachable from any pill
+        // whose category has no posts yet. Zero entries now means zero rows.
+        if (!source) continue;
+        const limitRaw = Number((_container_props1 = container.props) == null ? void 0 : _container_props1.entriesLimit);
+        const limit = Number.isFinite(limitRaw) && limitRaw > 0 ? Math.min(limitRaw, COLLECTION_ENTRIES_MAX) : COLLECTION_ENTRIES_MAX;
+        // Pagination (AGL-620): when `perPage` is set the block renders one page
+        // window `[(page-1)*perPage, page*perPage)`; without it, the legacy
+        // `entriesLimit` slice from the top applies unchanged.
+        const perPageRaw = Number((_container_props2 = container.props) == null ? void 0 : _container_props2.perPage);
+        const perPage = Number.isFinite(perPageRaw) && perPageRaw > 0 ? Math.min(Math.floor(perPageRaw), COLLECTION_ENTRIES_MAX) : undefined;
+        // The block's own `page` wins; otherwise the ROUTE's page applies, so
+        // `/blog/page/2` and `/blog/category/guides/page/2` render page 2 of a
+        // template listing instead of silently re-serving page 1 at a second URL
+        // (AGL-1321). Only ever the routed collection: `source.page` is set
+        // nowhere else.
+        const pageRaw = Number((_container_props3 = container.props) == null ? void 0 : _container_props3.page);
+        const routedPage = Number(source.page);
+        const page = Number.isFinite(pageRaw) && pageRaw >= 1 ? Math.floor(pageRaw) : Number.isFinite(routedPage) && routedPage >= 1 ? Math.floor(routedPage) : 1;
+        // "Only on page 1" (AGL-1871): a LEAD block takes the top of the set and
+        // has no page window of its own, so on `/blog/page/2` it repeats exactly
+        // what page 1 led with — same cover, same title, same excerpt — above a
+        // page of different posts, under an eyebrow that reads "Latest". True on
+        // page 1, false everywhere after it.
+        //
+        // Opt-in and default off. The alternative reading — "a block with no
+        // `perPage` on a paginated route is a lead block" — is wrong: a "popular
+        // posts" rail is the same shape and belongs on every page of the listing.
+        // Only the author knows which one they built, so the author says so.
+        //
+        // Gated on the ROUTE's page, never on the block's own pinned `page`. A
+        // block that names its own page is a deliberately fixed window ("the
+        // entries page 3 would show, here"), which says nothing about which page
+        // of the listing the reader is on; and off a routed listing entirely
+        // (a blog rail on the homepage) `source.page` is unset, so the switch
+        // correctly hides nothing.
+        const firstPageOnly = Boolean((_container_props4 = container.props) == null ? void 0 : _container_props4.firstPageOnly);
+        const suppressedBeyondFirstPage = firstPageOnly && Number.isFinite(routedPage) && routedPage > 1;
+        const templateIds = Array.isArray(container.nodes) ? container.nodes : [];
+        if (!templateIds.length) continue;
+        // Category/tag filter props (AGL-582): the block-level answer to
+        // /blog?tag=x — query params never reach the ISR-cached loader, so
+        // filtered lists are designed as filtered BLOCKS instead.
+        const filterCategory = String((_ref1 = (_container_props5 = container.props) == null ? void 0 : _container_props5.filterCategory) != null ? _ref1 : '').trim();
+        const filterTag = String((_ref2 = (_container_props6 = container.props) == null ? void 0 : _container_props6.filterTag) != null ? _ref2 : '').trim();
+        const filtered = filterCategory || filterTag ? source.entries.filter((entry)=>entryMatchesFilter(entry, {
+                category: filterCategory || undefined,
+                tag: filterTag || undefined
+            }, source.categories)) : source.entries;
+        // Whether the READ behind `source.entries` reached its own bound
+        // (AGL-1516). Taken off the raw set, never off `filtered`: a block-level
+        // category filter legitimately narrows a complete read, and a narrowed
+        // set is not a bounded one. The source's own `reachedBound` wins over
+        // counting it, because the count cannot see a read that came back full
+        // and was then thinned by the liveness gate.
+        const sourceCapped = collectionSourceIsBounded(source);
+        const windowed = suppressedBeyondFirstPage ? [] : perPage ? filtered.slice((page - 1) * perPage, (page - 1) * perPage + perPage) : filtered.slice(0, limit);
+        const childIds = [];
+        windowed.forEach((entry, index)=>{
+            const prefix = `${COLLECTION_ENTRIES_NODE_ID_PREFIX}${containerId}__${index}__`;
+            const prefixId = (id)=>`${prefix}${id}`;
+            const cloned = {};
+            const cloneSubtree = (id, parentId)=>{
+                const node = nodes[id];
+                if (!node) return;
+                const clonedChildren = Array.isArray(node.nodes) ? node.nodes : undefined;
+                cloned[prefixId(id)] = _extends({}, node, {
+                    $id: prefixId(id),
+                    parentId
+                }, clonedChildren && {
+                    nodes: clonedChildren.map((childId)=>prefixId(childId))
+                });
+                clonedChildren == null ? void 0 : clonedChildren.forEach((childId)=>cloneSubtree(childId, prefixId(id)));
+            };
+            for (const templateId of templateIds){
+                cloneSubtree(templateId, containerId);
+                childIds.push(prefixId(templateId));
+            }
+            // Fill the entry blocks in THIS card from THIS card's entry (AGL-2486).
+            //
+            // The routed-entry passes (`expandCollectionEntryMeta`,
+            // `expandCollectionEntryAuthor`) skip clones deliberately: stamping the
+            // routed entry into a listing would date every card the same. That left
+            // a cloned block with only its `{{entry.*}}` bindings, and a binding
+            // carries no FORMAT — so an Entry Meta inside a card rendered the locale
+            // default whatever its Date format said, while the identical block on
+            // the article above it obeyed the picker. A field that cannot move the
+            // thing it names is worse than a missing one.
+            //
+            // The fill runs against each clone's own entry, so every card dates
+            // itself, and it runs BEFORE substitution so a filled value is already
+            // a literal by the time the tokens resolve. The precedence is the
+            // shared one: an authored value wins, except the `{{entry.date}}`
+            // binding under a chosen format, which is the case this exists for.
+            for (const [cloneId, cloneNode] of Object.entries(cloned)){
+                var _cloneNode_props;
+                const fill = (cloneNode == null ? void 0 : cloneNode.componentId) === COLLECTION_ENTRY_META_COMPONENT_ID ? entryMetaFill(cloneNode, entry, source.categories) : (cloneNode == null ? void 0 : cloneNode.componentId) === COLLECTION_ENTRY_AUTHOR_COMPONENT_ID ? entryAuthorFill(cloneNode, entry) : undefined;
+                if (!fill || !Object.keys(fill).length) continue;
+                cloned[cloneId] = _extends({}, cloneNode, {
+                    props: _extends({}, (_cloneNode_props = cloneNode.props) != null ? _cloneNode_props : {}, fill)
+                });
+            }
+            Object.assign(next, resolveNamedTokens(cloned, collectionEntryTokens(entry, source.slug, source.categories)));
+        });
+        // Search (AGL-1516): the block's search box filters CLIENT-SIDE over the
+        // entries this expansion just rendered — the ISR-cached page is the whole
+        // data set, so no query ever goes back to Firestore. The component only
+        // holds cloned markup by render time, so the matchable text is stamped
+        // here, where the entries still exist, index-aligned with the clone
+        // groups. Stamped ONLY when the author enabled it: an untouched block's
+        // node — and its serialized payload — stays byte-identical.
+        const searchEnabled = Boolean((_container_props7 = container.props) == null ? void 0 : _container_props7.search);
+        next[containerId] = searchEnabled ? _extends({}, container, {
+            props: _extends({}, container.props, {
+                searchIndex: buildCollectionSearchIndex(windowed, source.slug, source.categories),
+                // How many entries the window above was drawn FROM (AGL-1516).
+                //
+                // The component has to tell the reader whether a miss means "not
+                // here" or "not anywhere", and it cannot work that out for
+                // itself: it sees `perPage`, but `perPage` is only one of three
+                // ways this block gets truncated. `entriesLimit` slices too, and
+                // so does COLLECTION_ENTRIES_MAX at 100. A block set to "latest 6
+                // posts" indexes 6 of 40 and, keyed off `perPage` alone, told the
+                // reader flatly that their post does not exist.
+                //
+                // Stamped as the COUNT rather than as a `truncated` verdict, so
+                // the component decides the wording and this stays a fact. It is
+                // the post-filter total — a category-filtered block searches its
+                // category, and "the rest of the collection" means the rest of
+                // what this block would otherwise show.
+                searchTotal: filtered.length
+            }, sourceCapped ? {
+                searchCapped: true
+            } : {}),
+            nodes: childIds
+        }) : _extends({}, container, {
+            nodes: childIds
+        });
+    }
+    return next;
+}
+/**
+ * Category Pills blocks (AGL-1321): stamps each `collectionCategories` node
+ * with its collection's pill row as a serializable `items` prop the component
+ * renders as real anchors — the same server-stamped shape Related posts uses,
+ * and for the same reason: the block owns its markup, so there is no template
+ * to clone.
+ *
+ * `activeCategorySlug` marks a pill only on the ROUTED collection. A pills
+ * block pointing at some other collection is not what this URL filters, so
+ * marking one of its pills current would be a lie in the HTML.
+ *
+ * A collection with no taxonomy leaves its block untouched, so the component's
+ * besigner affordance / empty site render applies. Inputs are never mutated.
+ */ export function expandCollectionCategories(nodes, sourcesBySlug, defaultSlug, activeCategorySlug) {
+    const containers = Object.entries(nodes).filter(([, node])=>(node == null ? void 0 : node.componentId) === COLLECTION_CATEGORIES_COMPONENT_ID);
+    if (!containers.length) return nodes;
+    const next = _extends({}, nodes);
+    for (const [containerId, container] of containers){
+        var _ref;
+        var _container_props, _container_props1;
+        const slug = String((_ref = (_container_props = container.props) == null ? void 0 : _container_props.collectionSlug) != null ? _ref : '').trim() || defaultSlug;
+        const source = slug ? sourcesBySlug[slug] : undefined;
+        if (!source) continue;
+        const allLabel = (_container_props1 = container.props) == null ? void 0 : _container_props1.allLabel;
+        const items = buildCollectionCategoryLinks(_extends({
+            collectionSlug: source.slug,
+            categories: source.categories
+        }, slug === defaultSlug ? {
+            activeCategorySlug
+        } : {}, allLabel === undefined ? {} : {
+            allLabel: allLabel === null ? null : String(allLabel)
+        }));
+        if (!items.length) continue;
+        next[containerId] = _extends({}, container, {
+            props: _extends({}, container.props, {
+                items
+            })
+        });
+    }
+    return next;
+}
+/**
+ * Collection Search blocks (AGL-1516): stamps each `collectionSearch` node
+ * with its collection's search index, the size of the set that index was
+ * drawn from, and whether that set was a bounded read — the same
+ * server-stamped shape Category Pills and Related posts use, and for the same
+ * reason: the block owns its markup, so there is no template to clone.
+ *
+ * Indexes the WHOLE source rather than a page window. The entries block's box
+ * searches the entries that block rendered because it filters them in place;
+ * a toolbar box filters nothing and suggests, so scoping it to one page of a
+ * listing would be an arbitrary cut nobody asked for. What it can honestly
+ * cover is the set the page's listing is drawn from — which on a category
+ * route is that category, because `source.entries` arrives filtered.
+ *
+ * Clones are SKIPPED by their `centry__` prefix: a search box inside an entry
+ * template would otherwise be stamped once per card. Nodes are never mutated,
+ * and a collection with no entries leaves its block untouched, so the
+ * component's besigner affordance and its empty site render both stand.
+ */ export function expandCollectionSearch(nodes, sourcesBySlug, defaultSlug) {
+    const containers = Object.entries(nodes).filter(([id, node])=>(node == null ? void 0 : node.componentId) === COLLECTION_SEARCH_COMPONENT_ID && !id.startsWith(COLLECTION_ENTRIES_NODE_ID_PREFIX));
+    if (!containers.length) return nodes;
+    const next = _extends({}, nodes);
+    for (const [containerId, container] of containers){
+        var _ref;
+        var _container_props;
+        const slug = String((_ref = (_container_props = container.props) == null ? void 0 : _container_props.collectionSlug) != null ? _ref : '').trim() || defaultSlug;
+        const source = slug ? sourcesBySlug[slug] : undefined;
+        // An unknown collection leaves the node untouched — fail-open, exactly as
+        // the entries and pills blocks do, so a rename never takes a screen down.
+        if (!source) continue;
+        // A collection with nothing published gets no box. A search field over an
+        // empty index can only ever answer "no matches", which reads as a fact
+        // about the reader's query rather than about the empty collection it
+        // really describes.
+        if (!source.entries.length) continue;
+        next[containerId] = _extends({}, container, {
+            props: _extends({}, container.props, {
+                searchIndex: buildCollectionSearchIndex(source.entries, source.slug, source.categories),
+                searchTotal: source.entries.length
+            }, collectionSourceIsBounded(source) ? {
+                searchCapped: true
+            } : {})
+        });
+    }
+    return next;
+}
+/**
+ * Entry Meta blocks (AGL-1385): stamps each `collectionEntryMeta` node with
+ * the routed entry's date, category and tags — the same server-stamped shape
+ * Category Pills and Related posts already use.
+ *
+ * MEASURED on the live marketing blog, which is what this fixes. The block was
+ * on `blogEntryTmpl` carrying props `{showDate: true, showCategory: true,
+ * showTags: true}` and NOTHING else, and rendered as an empty `<div>` at height
+ * 0 — while the very same entry's `<pubDate>` and `Guides` category appeared in
+ * its feed item, its JSON-LD, and a heading two nodes above it. So the data was
+ * never missing; the block simply had nothing bound to it.
+ *
+ * The design is what made that reachable. Every other collection block sources
+ * itself; this one required the author to type `{{entry.date}}` into a text
+ * field. Only the PRESET seeds those tokens — drag the bare component out of
+ * the palette and you get three switches labelled "Show date / Show category /
+ * Show tags", all defaulting to on, gating values that can never exist. That is
+ * an affordance promising something the component cannot deliver, so this is a
+ * defect in the block and not in anyone's content, and it hits every collection
+ * that uses it, not just blog.
+ *
+ * Deliberately narrow:
+ *
+ *  - An AUTHORED value always wins. Only an absent or blank prop is filled, so
+ *    a hand-typed byline, a pinned string, or a `{{entry.*}}` token still
+ *    awaiting substitution is never overwritten. (Blank counts as unset
+ *    because a cleared text field cannot persist `''` anyway — AGL-1336. The
+ *    way to hide a value is the switch that exists for it.)
+ *  - Nodes cloned per entry by {@link expandCollectionEntries} are SKIPPED by
+ *    their `centry__` id prefix. Their tokens resolve per clone; stamping the
+ *    routed entry into them would date every card in a listing the same.
+ *  - Without a routed entry — a list route, a plain screen — nothing is
+ *    stamped, so the besigner affordance and the empty site render stand.
+ *
+ * `dateFormat` (AGL-1459) is answered here, where the timestamp still exists,
+ * and is the ONE exception to "an authored value always wins" — narrowly, and
+ * only for the literal `{{entry.date}}` binding. That binding is what the
+ * block's own preset seeds, so a format that filled blanks only would do
+ * nothing on the exact surface it was built for. The token is not a hand-typed
+ * override; it NAMES the value being reformatted. A literal string an author
+ * typed still wins, unchanged.
+ *
+ * Inputs are never mutated.
+ */ export function expandCollectionEntryMeta(nodes, entry, categories) {
+    if (!entry) return nodes;
+    const containers = Object.entries(nodes).filter(([id, node])=>(node == null ? void 0 : node.componentId) === COLLECTION_ENTRY_META_COMPONENT_ID && !id.startsWith(COLLECTION_ENTRIES_NODE_ID_PREFIX));
+    if (!containers.length) return nodes;
+    const next = _extends({}, nodes);
+    for (const [containerId, container] of containers){
+        var _container_props;
+        const filled = entryMetaFill(container, entry, categories);
+        if (!Object.keys(filled).length) continue;
+        next[containerId] = _extends({}, container, {
+            props: _extends({}, (_container_props = container.props) != null ? _container_props : {}, filled)
+        });
+    }
+    return next;
+}
+/**
+ * The values ONE Entry Meta node takes from ONE entry (AGL-2486).
+ *
+ * Extracted so a node inside a listing's card can be filled from the entry
+ * that card is for, which is a different entry per clone and therefore
+ * cannot come from the routed-entry pass above. Both callers apply the same
+ * precedence, because the same block cannot mean two things depending on
+ * where an author dropped it.
+ *
+ * Returns only the keys that change; an empty object means "leave this node
+ * exactly as authored".
+ */ function entryMetaFill(container, entry, categories) {
+    {
+        var _container_props, _ref, _props_author;
+        var _entry_author;
+        const props = (_container_props = container.props) != null ? _container_props : {};
+        // Per node: the format is a prop, so two blocks on one template can read
+        // their dates differently.
+        const dateFormat = normalizeCollectionEntryDateFormat(props['dateFormat']);
+        const values = collectionEntryMetaValues(entry, categories, dateFormat);
+        const filled = {};
+        for (const key of [
+            'date',
+            'author',
+            'category',
+            'tags'
+        ]){
+            var _props_key;
+            const authored = String((_props_key = props[key]) != null ? _props_key : '').trim();
+            if (authored && !reformattableEntryDate(key, authored, dateFormat)) {
+                continue;
+            }
+            if (!values[key]) continue;
+            filled[key] = values[key];
+        }
+        // The byline avatar follows the BYLINE, and is the second narrow
+        // exception to "an authored value always wins" (after `dateFormat`).
+        //
+        // `avatarImage` was introduced as a block-level pick because entries then
+        // carried a byline STRING and no portrait anywhere, so the site's brand
+        // mark chosen once on the template was the only answer available. Custom
+        // authors changed that: an entry resolves to a record, and a record has
+        // an `image`. Keeping the authored mark in front of it would print the
+        // company logo beside a named person — the wrong face, on every post that
+        // person wrote, which is worse than the generic mark it was standing in
+        // for.
+        //
+        // Deliberately narrow, so nothing else moves: only a resolved author
+        // RECORD that actually carries an image displaces the authored value. A
+        // legacy string byline, an author with no portrait, and an entry with no
+        // author at all all leave the template's mark exactly where it was.
+        //
+        // And only where a byline is actually PRINTED. This block is also the
+        // product's tag row — the article frame ends on one with `Show author`,
+        // `Show date` and `Show category` off and nothing but chips left — so a
+        // portrait filled in unconditionally lands beside the tags, halfway down
+        // the page from the byline it belongs to. The avatar is `alt=""` on the
+        // grounds that "the byline names the author in text right beside it",
+        // which is exactly the thing a chips-only block does not have.
+        const authorImage = String((_ref = (_entry_author = entry.author) == null ? void 0 : _entry_author.image) != null ? _ref : '').trim();
+        const bylineShown = props['showAuthor'] !== false && Boolean(filled['author'] || String((_props_author = props['author']) != null ? _props_author : '').trim());
+        if (authorImage && bylineShown && props['showAvatar'] !== false) {
+            filled['avatarImage'] = authorImage;
+        }
+        /*
+      Where the byline GOES (AGL-2519).
+
+      Filled on the same terms as the avatar and for the same reason: it
+      belongs to the byline, so it is only filled where a byline is actually
+      printed. This block doubles as the product's tag row — the article frame
+      ends on one with the author, date and category all switched off — and a
+      link stamped there would have nothing to attach to.
+
+      An authored value still wins, which is what `Link author` off leaves
+      behind once the switch has written an explicit `false`: the switch is
+      read by the renderer, and this only supplies the destination.
+    */ if (bylineShown) {
+            var _props_authorPageUrl;
+            const pageUrl = collectionEntryAuthorValues(entry).pageUrl;
+            if (pageUrl && !String((_props_authorPageUrl = props['authorPageUrl']) != null ? _props_authorPageUrl : '').trim()) {
+                filled['authorPageUrl'] = pageUrl;
+            }
+        }
+        return filled;
+    }
+}
+/**
+ * Fill Entry Author cards from the routed entry's author record (AGL-2486),
+ * on the same terms {@link expandCollectionEntryMeta} fills the byline:
+ *
+ *  - an authored value always wins, and a blank one is a blank, not a
+ *    request for the default — the way to hide a field is its Show switch;
+ *  - per-entry clones (`centry__`) are skipped, so a listing's cards keep
+ *    resolving their own tokens rather than every card naming the routed
+ *    entry's author;
+ *  - without a routed entry nothing is stamped, which leaves the besigner's
+ *    placeholder card visible on the canvas.
+ *
+ * Inputs are never mutated.
+ */ export function expandCollectionEntryAuthor(nodes, entry) {
+    if (!entry) return nodes;
+    const containers = Object.entries(nodes).filter(([id, node])=>(node == null ? void 0 : node.componentId) === COLLECTION_ENTRY_AUTHOR_COMPONENT_ID && !id.startsWith(COLLECTION_ENTRIES_NODE_ID_PREFIX));
+    if (!containers.length) return nodes;
+    const next = _extends({}, nodes);
+    for (const [containerId, container] of containers){
+        var _container_props;
+        const filled = entryAuthorFill(container, entry);
+        if (!Object.keys(filled).length) continue;
+        next[containerId] = _extends({}, container, {
+            props: _extends({}, (_container_props = container.props) != null ? _container_props : {}, filled)
+        });
+    }
+    return next;
+}
+/**
+ * The values ONE Entry Author node takes from ONE entry (AGL-2486) — the
+ * companion to {@link entryMetaFill}, extracted for the same reason: a card
+ * inside a listing is filled from the entry that card is for.
+ */ function entryAuthorFill(container, entry) {
+    var _container_props;
+    const values = collectionEntryAuthorValues(entry);
+    const props = (_container_props = container.props) != null ? _container_props : {};
+    const filled = {};
+    for (const key of [
+        'name',
+        'bio',
+        'image',
+        'url',
+        'pageUrl'
+    ]){
+        var _props_key;
+        if (String((_props_key = props[key]) != null ? _props_key : '').trim()) continue;
+        if (!values[key]) continue;
+        filled[key] = values[key];
+    }
+    // `links` is not authorable as text — a row carries a platform or a picked
+    // icon, and the console's author editor is where those are chosen — so
+    // there is no authored value to defer to. The record's rows are the only
+    // ones there are; `Show links` is the template's control over them.
+    if (values.links.length) filled['links'] = values.links;
+    return filled;
+}
+/** The one binding a chosen date format may replace (AGL-1459). */ const ENTRY_DATE_BINDING = '{{entry.date}}';
+/**
+ * Is this authored value the `{{entry.date}}` binding under a chosen format
+ * (AGL-1459)? Anything else — a literal string, another token, the default
+ * format — answers no, and the authored value stands.
+ */ function reformattableEntryDate(key, authored, dateFormat) {
+    return key === 'date' && authored === ENTRY_DATE_BINDING && dateFormat !== COLLECTION_ENTRY_DATE_FORMAT_DEFAULT;
+}
+/**
+ * The ONE matcher configuration behind every entry search in the product
+ * (AGL-1516/AGL-1525) — the block's toolbar box, its suggestion panel, and
+ * the site-wide results page the panel links to.
+ *
+ * Shared rather than copied because the two halves are joined by a link the
+ * reader clicks: the panel's "View all results" hands its query to /search,
+ * and if the results page matched more strictly it would answer a visible
+ * suggestion with "no results". A typo the panel forgave — "platfrom" — is
+ * exactly the query most likely to make that trip.
+ *
+ * The shape is the icon picker's (use-mdi-icons-fuzzy), tuned once for prose
+ * and MEASURED before shipping: the title names the post and the excerpt
+ * merely describes it, so they are weighted 0.7/0.3; the default location
+ * scoring buries a legitimate mid-sentence hit in a sentence-long excerpt,
+ * and the default 0.6 threshold matches "media" against every post on letter
+ * soup, so location is ignored and the threshold tightened to 0.3.
+ *
+ * A plain object, not a Fuse instance: `libs/aglyn` is dependency-light by
+ * design, and each consumer already imports Fuse from the vendor bundle.
+ */ export const COLLECTION_SEARCH_FUSE_OPTIONS = {
+    keys: [
+        {
+            name: 'title',
+            weight: 0.7
+        },
+        {
+            name: 'excerpt',
+            weight: 0.3
+        }
+    ],
+    includeScore: true,
+    shouldSort: true,
+    ignoreLocation: true,
+    threshold: 0.3
+};
+/**
+ * Related-post selection (AGL-582): other entries of the same collection
+ * that share the current entry's category or at least one tag, newest
+ * first. Pure so the compose stage and tests share one implementation. An
+ * entry with no category and no tags relates to nothing — the caller
+ * renders nothing rather than guessing.
+ *
+ * Two entries share a category when their stable `categoryId`s are equal
+ * (survives renames AND deletions) or their RESOLVED display names match
+ * case-insensitively — so a legacy free-typed entry still relates to a
+ * migrated `categoryId` entry whose taxonomy name spells the same.
+ */ export function selectRelatedEntries(entries, current, limit = COLLECTION_RELATED_DEFAULT_LIMIT, categories) {
+    var _current_categoryId, _resolveEntryCategoryName, _current_tags;
+    const categoryId = ((_current_categoryId = current.categoryId) != null ? _current_categoryId : '').trim();
+    const categoryName = ((_resolveEntryCategoryName = resolveEntryCategoryName(current, categories)) != null ? _resolveEntryCategoryName : '').toLowerCase();
+    const tags = ((_current_tags = current.tags) != null ? _current_tags : []).map((tag)=>tag.trim()).filter(Boolean);
+    if (!categoryId && !categoryName && !tags.length) return [];
+    const bounded = Math.min(Math.max(limit, 0) || COLLECTION_RELATED_DEFAULT_LIMIT, COLLECTION_RELATED_MAX);
+    return entries.filter((entry)=>{
+        var _entry_categoryId, _resolveEntryCategoryName;
+        if (entry.$id && entry.$id === current.$id || entry.slug && entry.slug === current.slug) {
+            return false;
+        }
+        if (categoryId && ((_entry_categoryId = entry.categoryId) != null ? _entry_categoryId : '').trim() === categoryId) {
+            return true;
+        }
+        if (categoryName && ((_resolveEntryCategoryName = resolveEntryCategoryName(entry, categories)) != null ? _resolveEntryCategoryName : '').trim().toLowerCase() === categoryName) {
+            return true;
+        }
+        return tags.some((tag)=>entryMatchesFilter(entry, {
+                tag
+            }));
+    }).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);
+    }).slice(0, bounded);
+}
+/**
+ * Related posts blocks (AGL-582): stamps each `collectionRelated` node with
+ * the current entry's related posts as a serializable `entries` prop the
+ * component renders directly (no template cloning — the block owns its
+ * markup). Runs only on entry renders; without an entry context the nodes
+ * stay untouched, so the component's sample cards (editing surfaces) or its
+ * empty site render apply. Inputs are never mutated.
+ */ export function expandCollectionRelated(nodes, source, currentEntry) {
+    if (!source || !currentEntry) return nodes;
+    const containers = Object.entries(nodes).filter(([, node])=>(node == null ? void 0 : node.componentId) === COLLECTION_RELATED_COMPONENT_ID);
+    if (!containers.length) return nodes;
+    const next = _extends({}, nodes);
+    for (const [containerId, container] of containers){
+        var _source_entries;
+        var _container_props, _container_props1;
+        const limitRaw = Number((_container_props = container.props) == null ? void 0 : _container_props.limit);
+        // Per node, exactly as the byline reads it (AGL-1459): the format is a
+        // prop, so two rails on one template can date their cards differently.
+        const dateFormat = normalizeCollectionEntryDateFormat((_container_props1 = container.props) == null ? void 0 : _container_props1.dateFormat);
+        const related = selectRelatedEntries((_source_entries = source.entries) != null ? _source_entries : [], currentEntry, Number.isFinite(limitRaw) && limitRaw > 0 ? limitRaw : COLLECTION_RELATED_DEFAULT_LIMIT, source.categories);
+        const items = related.map((entry)=>{
+            var _entry_title, _entry_slug;
+            var _entry_publishedAt;
+            const categoryName = resolveEntryCategoryName(entry, source.categories);
+            return _extends({
+                title: (_entry_title = entry.title) != null ? _entry_title : '',
+                url: `/${source.slug}/${(_entry_slug = entry.slug) != null ? _entry_slug : ''}`
+            }, ((_entry_publishedAt = entry.publishedAt) == null ? void 0 : _entry_publishedAt.seconds) ? {
+                date: formatCollectionEntryDate(entry.publishedAt, dateFormat)
+            } : {}, entry.excerpt ? {
+                excerpt: entry.excerpt
+            } : {}, entry.coverImage ? {
+                coverImage: entry.coverImage
+            } : {}, entry.coverImage && entry.coverImageAlt ? {
+                coverImageAlt: entry.coverImageAlt
+            } : {}, categoryName ? {
+                category: categoryName
+            } : {});
+        });
+        next[containerId] = _extends({}, container, {
+            props: _extends({}, container.props, {
+                entries: items
+            })
+        });
+    }
+    return next;
+}
+export default expandCollectionEntries;
+
+//# sourceMappingURL=collection-entries.js.map