@aglyn/plugins-mui 1.0.0-beta.143

package/src/lib/components/collection.js

@@ -0,0 +1,2999 @@
+import { _ as _extends } from "@swc/helpers/_/_extends";
+import { _ as _object_without_properties_loose } from "@swc/helpers/_/_object_without_properties_loose";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+/**
+ * @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 Aglyn from "@aglyn/aglyn";
+import { mdiAccountCircleOutline, mdiContentCopy, mdiEmail, mdiFacebook, mdiGithub, mdiInstagram, mdiLinkVariant, mdiLinkedin, mdiMagnify, mdiMastodon, mdiNewspaperVariantOutline, mdiPostOutline, mdiRss, mdiShareVariant, mdiTagMultipleOutline, mdiTagOutline, mdiTextLong, mdiTwitter, mdiWeb, mdiYoutube } from "@aglyn/shared-data-mdi";
+import { AppLink, MdiIcon } from "@aglyn/shared-ui-jsx";
+// The icon picker's fuzzy matcher (use-mdi-icons-fuzzy), not a re-implementation
+// (AGL-1516): search here has to feel like search does everywhere else in the
+// product, and two matchers is how they drift.
+import { Fuse } from "@aglyn/shared-util-vendor/fuse";
+import Box from "@mui/material/Box";
+import Chip from "@mui/material/Chip";
+import IconButton from "@mui/material/IconButton";
+import InputBase from "@mui/material/InputBase";
+import MuiLink from "@mui/material/Link";
+import MuiStack from "@mui/material/Stack";
+import Typography from "@mui/material/Typography";
+import { Children, forwardRef, useContext, useMemo, useState } from "react";
+import { BUNDLE_ID } from "../constants/bundle-common.js";
+import { generatePresetId } from "../utils/generate-preset-id.js";
+// One coercion for every authored count in this bundle (AGL-1457) — number
+// fields round-trip as strings, and a second parser here would drift.
+import { toCount } from "./image-list.js";
+// The theme's own type steps (AGL-2486), shared with the Typography element
+// rather than a second list here — one rung list, one place to extend.
+import { typographyVariants } from "./typography.js";
+// Persisted component ids (AGL-551/582); the compose pipeline references
+// them through @aglyn/aglyn constants. Never rename.
+export const ENTRIES_ID = Aglyn.COLLECTION_ENTRIES_COMPONENT_ID;
+export const ENTRY_BODY_ID = Aglyn.COLLECTION_ENTRY_BODY_COMPONENT_ID;
+export const RELATED_ID = Aglyn.COLLECTION_RELATED_COMPONENT_ID;
+export const SHARE_ID = Aglyn.COLLECTION_SHARE_COMPONENT_ID;
+export const ENTRY_META_ID = Aglyn.COLLECTION_ENTRY_META_COMPONENT_ID;
+export const ENTRY_AUTHOR_ID = Aglyn.COLLECTION_ENTRY_AUTHOR_COMPONENT_ID;
+export const CATEGORIES_ID = Aglyn.COLLECTION_CATEGORIES_COMPONENT_ID;
+export const SEARCH_ID = Aglyn.COLLECTION_SEARCH_COMPONENT_ID;
+export const AUTHOR_PROFILE_ID = Aglyn.CONTENT_AUTHOR_PROFILE_COMPONENT_ID;
+/**
+ * Author-facing choices for {@link CollectionEntriesProps.searchMode}.
+ *
+ * Both values are truthy on purpose (AGL-1453): `''` cannot survive a save,
+ * so an author who tried the other mode would have no route back. "Filter"
+ * carries the absent-value reading, which is what every block published
+ * before AGL-1525 has.
+ */ export const COLLECTION_SEARCH_MODE_OPTIONS = [
+    {
+        value: 'filter',
+        label: 'Filter the entries in place'
+    },
+    {
+        value: 'suggest',
+        label: 'Show a suggestions dropdown'
+    }
+];
+/** The toolbar search field, from the frame (Figma 494:1220). */ const SEARCH_FIELD_WIDTH = 240;
+/** Suggestion panel (Figma 496:1218). */ const SUGGESTION_PANEL_WIDTH = 420;
+/**
+ * Rows in the panel before it stops. The frame shows five; the sixth row is
+ * always the "View all results" link, which is the honest overflow answer —
+ * a scrolling suggestion panel is a worse results page.
+ */ const SUGGESTION_LIMIT = 5;
+/** Where "View all results" goes — the reserved site-search route (AGL-88). */ const searchResultsHref = (query)=>`/search?q=${encodeURIComponent(query)}`;
+/**
+ * The frame's compact filled field: magnify glyph + hint on the quiet
+ * surface token, right-aligned so it sits where the toolbar row puts it.
+ * Palette tokens only, so it follows the site theme in both modes.
+ */ const searchFieldSx = {
+    alignSelf: 'flex-end',
+    display: 'flex',
+    alignItems: 'center',
+    gap: 1,
+    px: 1.5,
+    py: 0.75,
+    borderRadius: 2,
+    bgcolor: 'action.hover',
+    color: 'text.secondary',
+    width: SEARCH_FIELD_WIDTH,
+    maxWidth: '100%'
+};
+/**
+ * The positioned parent of the suggestion panel (AGL-1525). It takes over
+ * `alignSelf` from the field so the toolbar row is unchanged — the panel
+ * hangs off the field, it does not move it.
+ */ const suggestionAnchorSx = {
+    alignSelf: 'flex-end',
+    position: 'relative',
+    width: SEARCH_FIELD_WIDTH,
+    maxWidth: '100%'
+};
+/**
+ * The floating panel itself. Right-aligned to the field it drops from, and
+ * wider than it, as the frame draws it — a suggestion row carries a title, a
+ * chip, a date and a line of excerpt, none of which fit in 240px.
+ *
+ * Palette and shadow tokens only, so it follows the site theme in both
+ * modes rather than pinning a light-mode card onto a dark page.
+ */ const suggestionPanelSx = {
+    position: 'absolute',
+    top: 'calc(100% + 8px)',
+    right: 0,
+    zIndex: 10,
+    width: SUGGESTION_PANEL_WIDTH,
+    // Never wider than the viewport on a phone, where the anchor is narrow
+    // and `right: 0` would otherwise hang the panel off the left edge.
+    maxWidth: 'calc(100vw - 32px)',
+    bgcolor: 'background.paper',
+    color: 'text.primary',
+    border: 1,
+    borderColor: 'divider',
+    borderRadius: 2,
+    boxShadow: 6,
+    overflow: 'hidden',
+    textAlign: 'left'
+};
+const suggestionRowLinkSx = {
+    display: 'block',
+    color: 'inherit',
+    '&:hover': {
+        bgcolor: 'action.hover'
+    }
+};
+const suggestionFooterSx = {
+    display: 'block',
+    px: 2,
+    py: 1.25,
+    borderTop: 1,
+    borderColor: 'divider',
+    bgcolor: 'action.hover',
+    fontSize: 14,
+    fontWeight: 500
+};
+/**
+ * The frame's search input (Figma 494:1220) — the magnify glyph and a bare
+ * `InputBase` on the quiet surface token.
+ *
+ * Presentational and stateless, so the entries block's in-place filter and
+ * the standalone toolbar box (AGL-1516) are the SAME field rather than two
+ * that merely look alike. `inert` is the editing-surface rendering: read-only
+ * and handler-free, so a click or stray keystroke in the besigner never edits
+ * state the canvas cannot use — how Category Pills go inert there too.
+ */ const SearchField = ({ value, placeholder, inert, landmark, onQuery, onEscape })=>/*#__PURE__*/ _jsxs(Box, _extends({}, landmark ? {
+        role: 'search'
+    } : {}, {
+        sx: searchFieldSx,
+        children: [
+            /*#__PURE__*/ _jsx(MdiIcon, {
+                path: mdiMagnify.path
+            }),
+            /*#__PURE__*/ _jsx(InputBase, _extends({
+                value: value,
+                name: "q",
+                placeholder: (placeholder != null ? placeholder : '').trim() || 'Search posts…',
+                inputProps: {
+                    'aria-label': 'Search entries'
+                },
+                sx: {
+                    flex: 1,
+                    fontSize: 14,
+                    color: 'text.primary'
+                }
+            }, inert ? {
+                readOnly: true
+            } : {
+                onChange: (event)=>onQuery == null ? void 0 : onQuery(event.target.value),
+                onKeyDown: (event)=>{
+                    if (event.key === 'Escape') onEscape == null ? void 0 : onEscape();
+                }
+            }))
+        ]
+    }));
+/**
+ * The floating suggestion panel (AGL-1525, Figma 496:1218) — rows straight
+ * off the server-stamped index, and a "View all results" link that is there
+ * hits or no hits.
+ *
+ * `emptyText` is the caller's, not this component's, and that is the whole
+ * point of it being a parameter: a page-windowed entries block and a
+ * whole-collection toolbar box searched different sets, and a miss has to say
+ * WHICH set came back empty. A shared "No matches." would let one of them
+ * claim a reach it never had.
+ */ const SuggestionPanel = ({ suggestions, trimmed, emptyText })=>/*#__PURE__*/ _jsxs(Box, {
+        sx: suggestionPanelSx,
+        children: [
+            suggestions.length ? suggestions.map((item, index)=>{
+                const row = /*#__PURE__*/ _jsxs(MuiStack, {
+                    spacing: 0.5,
+                    sx: {
+                        px: 2,
+                        py: 1.25
+                    },
+                    children: [
+                        /*#__PURE__*/ _jsxs(MuiStack, {
+                            direction: "row",
+                            spacing: 1,
+                            sx: {
+                                alignItems: 'center'
+                            },
+                            children: [
+                                /*#__PURE__*/ _jsx(Typography, {
+                                    variant: "subtitle2",
+                                    sx: {
+                                        color: 'text.primary'
+                                    },
+                                    children: item.title
+                                }),
+                                item.category ? /*#__PURE__*/ _jsx(Chip, {
+                                    label: item.category,
+                                    size: "small"
+                                }) : null,
+                                item.date ? /*#__PURE__*/ _jsx(Typography, {
+                                    variant: "caption",
+                                    sx: {
+                                        color: 'text.secondary'
+                                    },
+                                    children: item.date
+                                }) : null
+                            ]
+                        }),
+                        item.excerpt ? /*#__PURE__*/ _jsx(Typography, {
+                            variant: "body2",
+                            sx: {
+                                color: 'text.secondary',
+                                // One line of excerpt, as the frame draws it. A row that
+                                // grows with the prose turns the panel into a page.
+                                overflow: 'hidden',
+                                textOverflow: 'ellipsis',
+                                whiteSpace: 'nowrap'
+                            },
+                            children: item.excerpt
+                        }) : null
+                    ]
+                });
+                // A row without a `url` is a page cached before AGL-1525 stamped one,
+                // or a slugless entry. It renders as TEXT rather than as a link to
+                // nowhere: a suggestion that navigates to the wrong page is worse
+                // than one the reader has to read.
+                return item.url ? /*#__PURE__*/ _jsx(AppLink, {
+                    href: item.url,
+                    sx: suggestionRowLinkSx,
+                    underline: "none",
+                    children: row
+                }, index) : /*#__PURE__*/ _jsx(Box, {
+                    children: row
+                }, index);
+            }) : /*#__PURE__*/ _jsx(Typography, {
+                variant: "body2",
+                sx: {
+                    color: 'text.secondary',
+                    px: 2,
+                    py: 1.25
+                },
+                children: emptyText
+            }),
+            /*#__PURE__*/ _jsx(AppLink, {
+                href: searchResultsHref(trimmed),
+                sx: suggestionFooterSx,
+                underline: "none",
+                children: `View all results for “${trimmed}” →`
+            })
+        ]
+    });
+/**
+ * Field plus dropdown, in a REAL form (AGL-1525) — so Enter reaches the
+ * results page and the box still works with the panel's JS doing nothing at
+ * all. The panel is an enhancement over a working search box, not the search
+ * box.
+ *
+ * Owns the query, because nothing outside it needs one: `suggest` never
+ * touches the cards underneath. That is what lets the standalone toolbar
+ * block exist at all (AGL-1516) — a box with no clones to hide is a complete
+ * feature, not a crippled one.
+ */ const SuggestSearchBox = ({ fuzzy, items, placeholder, inert, emptyText })=>{
+    const [query, setQuery] = useState('');
+    /** Escape dismissed THIS answer (AGL-1525); typing brings it back. */ const [closed, setClosed] = useState(false);
+    const trimmed = query.trim();
+    const suggestions = !inert && trimmed && fuzzy && items ? fuzzy.search(trimmed).slice(0, SUGGESTION_LIMIT).map((result)=>items[result.refIndex]).filter(Boolean) : [];
+    const field = /*#__PURE__*/ _jsx(SearchField, _extends({
+        value: query
+    }, placeholder === undefined ? {} : {
+        placeholder
+    }, inert ? {
+        inert: true,
+        landmark: true
+    } : {}, {
+        onQuery: (next)=>{
+            setQuery(next);
+            // A new query reopens a panel the reader dismissed — Escape closes
+            // THIS answer, it does not turn the feature off for the visit.
+            setClosed(false);
+        },
+        onEscape: ()=>setClosed(true)
+    }));
+    if (inert) return field;
+    return /*#__PURE__*/ _jsxs(Box, {
+        component: "form",
+        role: "search",
+        action: "/search",
+        method: "get",
+        sx: suggestionAnchorSx,
+        children: [
+            field,
+            trimmed && !closed ? /*#__PURE__*/ _jsx(SuggestionPanel, {
+                suggestions: suggestions,
+                trimmed: trimmed,
+                emptyText: emptyText(trimmed)
+            }) : null
+        ]
+    });
+};
+/**
+ * How much of the collection an entries block's search could actually see
+ * (AGL-1516, AGL-2569) — `truncated` says the rendered window is smaller
+ * than the set, `paginated` says the missing part lives on other pages of
+ * this same list rather than merely outside the block.
+ *
+ * The test is whether the window is SMALLER THAN THE SET, which only the
+ * server knows — `perPage` is the wrong proxy for it in both directions. A
+ * block truncated by `entriesLimit` or by the 100-entry cap has no `perPage`
+ * at all and would claim a global miss over 6 of 40 posts; a block whose
+ * `perPage` exceeds its entry count is a single complete page and would
+ * blame pages that do not exist. `searchTotal` is stamped with `searchIndex`,
+ * so the two are always in step.
+ *
+ * Absent — a page cached before that stamp shipped — falls back to the old
+ * `perPage` reading rather than guessing "complete": understating the scope
+ * of a search is the safe direction to be wrong in.
+ *
+ * `searchCapped` is the second way a block can fail to hold the set, and the
+ * invisible one: `searchTotal` counts the entries the server READ, and that
+ * read is bounded. Past the bound `shown === searchTotal` is satisfied by a
+ * block holding 100 of 400 posts, and the wording that claims to have looked
+ * everywhere is exactly the branch it would take.
+ *
+ * Both the miss and the hit disclose off this one answer, so the two can
+ * never disagree about the same block.
+ */ const searchScope = ({ perPage, shown, searchTotal, searchCapped })=>{
+    var _toCount;
+    const paginated = ((_toCount = toCount(perPage, 0)) != null ? _toCount : 0) > 0;
+    return {
+        paginated,
+        truncated: typeof searchTotal === 'number' ? shown < searchTotal || Boolean(searchCapped) : paginated || Boolean(searchCapped)
+    };
+};
+/**
+ * Repeats its children once per published entry of a content collection
+ * (AGL-551) — the collections sibling of the dataset repeatable. The tenant
+ * expands it at compose time with `{{entry.*}}` tokens; in the besigner the
+ * template renders once with literal tokens, matching the repeatable UX.
+ *
+ * Search (AGL-1516): with `search` on, a toolbar search box filters the
+ * rendered entry clones client-side against the server-stamped
+ * `searchIndex` — fuzzy, via the same Fuse the icon picker uses. The clones
+ * arrive as `children` in stamp order, one group of template roots per
+ * entry, so group N of the children IS entry N of the index. Matches keep
+ * the list's own order rather than Fuse's score order: a blog list is
+ * chronological, and search narrows it, it does not reshuffle it. In the
+ * besigner the field renders as an inert affordance (the template renders
+ * once with literal tokens and there is no index to search), matching how
+ * Category Pills go inert on editing surfaces.
+ */ const CollectionEntries = /*#__PURE__*/ forwardRef(// collectionSlug/entriesLimit/filter*/search* are compose-time or
+// search-only attributes: strip so they never hit the DOM.
+(_0, _1)=>{
+    let _ref = [
+        _0,
+        _1
+    ], [_ref1, ..._rest] = _ref, { collectionSlug, entriesLimit, filterCategory, filterTag, perPage, page, firstPageOnly, search, searchMode, searchPlaceholder, searchIndex, searchTotal, searchCapped, children } = _ref1, props = _object_without_properties_loose(_ref1, [
+        "collectionSlug",
+        "entriesLimit",
+        "filterCategory",
+        "filterTag",
+        "perPage",
+        "page",
+        "firstPageOnly",
+        "search",
+        "searchMode",
+        "searchPlaceholder",
+        "searchIndex",
+        "searchTotal",
+        "searchCapped",
+        "children"
+    ]), [ref] = _rest;
+    const { suppressNavigation } = useContext(Aglyn.ScreenLinkContext);
+    /** `filter` mode only — `suggest` owns its own query (AGL-1516). */ const [query, setQuery] = useState('');
+    const items = search ? searchIndex : undefined;
+    const fuzzy = useMemo(()=>(items == null ? void 0 : items.length) ? // results page this block's panel links to — a query the panel
+        // forgave must not come back empty from "View all results".
+        new Fuse(items, _extends({}, Aglyn.COLLECTION_SEARCH_FUSE_OPTIONS)) : null, [
+        items
+    ]);
+    if (!search) {
+        return /*#__PURE__*/ _jsx(MuiStack, _extends({
+            ref: ref,
+            spacing: 4
+        }, props, {
+            children: children
+        }));
+    }
+    const childArray = Children.toArray(children);
+    // Template roots per entry. Every entry clones the same template, so the
+    // children divide evenly; anything else means the children are not the
+    // stamped clones, and filtering blind would hide the wrong cards —
+    // fail open and render everything.
+    const groupSize = (items == null ? void 0 : items.length) && childArray.length % items.length === 0 ? childArray.length / items.length : 0;
+    // `suggest` draws its rows from the INDEX and never touches the clones,
+    // so the clone-alignment precondition is a `filter` precondition only.
+    // A block whose children do not divide evenly still suggests correctly;
+    // requiring `groupSize` here would silently kill the panel on exactly
+    // the templates that made the fail-open necessary.
+    const mode = searchMode === 'suggest' ? 'suggest' : 'filter';
+    const live = !suppressNavigation && Boolean(fuzzy) && (mode === 'suggest' || groupSize > 0);
+    const trimmed = query.trim();
+    let visible = children;
+    /**
+     * The one line under the results that says what the search covered —
+     * either a miss scoped to the set that came back empty, or a hit scoped
+     * to the window it was drawn from. Never both.
+     */ let scopeNote = null;
+    if (mode === 'suggest') {
+        // The grid is deliberately untouched (Figma 496:1218): the panel is an
+        // overlay on a page the reader is still reading, not a filter.
+        visible = children;
+    } else if (live && trimmed && fuzzy) {
+        var _ref2;
+        const matched = new Set(fuzzy.search(trimmed).map((result)=>result.refIndex));
+        visible = childArray.filter((_, index)=>matched.has(Math.floor(index / groupSize)));
+        // HONEST scope (AGL-1516, AGL-2569): this block holds whatever window
+        // the expansion gave it, and pretending the search was global would
+        // turn every miss into a false "this post does not exist" — and every
+        // hit into a result set that looks like the whole answer.
+        const shown = (_ref2 = items == null ? void 0 : items.length) != null ? _ref2 : 0;
+        const { paginated, truncated } = searchScope({
+            perPage,
+            shown,
+            searchTotal,
+            searchCapped
+        });
+        if (!visible.length) {
+            scopeNote = /*#__PURE__*/ _jsx(Typography, {
+                variant: "body2",
+                sx: {
+                    color: 'text.secondary'
+                },
+                children: !truncated ? `No matches for “${trimmed}”.` : paginated ? `No matches for “${trimmed}” on this page — other pages ` + 'are not searched.' : `No matches for “${trimmed}” in the ${shown} entries ` + 'shown here — the rest of the collection is not searched.'
+            });
+        } else if (truncated) {
+            // The hit half of the same honesty (AGL-2569). Matches are drawn from
+            // the same window the miss apologizes for, they carry no pager of
+            // their own, and nothing else on screen says the pages behind this
+            // one went unread — so a list that happens to be partial reads as
+            // complete. A block that holds the whole collection says nothing
+            // here: a disclaimer on a complete answer is noise, and every small
+            // site would carry it.
+            //
+            // No route out to `/search?q=` (AGL-88): the suggestion panel links
+            // there because it is the panel's only possible answer, but this
+            // mode has a working list under the field and that page does not
+            // exist yet. Trading a silent partial answer for a dead link is not
+            // the trade.
+            scopeNote = /*#__PURE__*/ _jsx(Typography, {
+                variant: "body2",
+                sx: {
+                    color: 'text.secondary'
+                },
+                children: paginated ? 'Showing matches on this page — other pages are not searched.' : `Showing matches in the ${shown} entries here — the rest of ` + 'the collection is not searched.'
+            });
+        }
+    }
+    // The field renders when there is something to search, and as an inert
+    // affordance on editing surfaces so the author sees what they enabled.
+    // A live surface with nothing stamped (unknown collection, zero entries)
+    // renders no field at all — a search box over nothing is a lie.
+    const showField = suppressNavigation || live;
+    const field = !showField ? null : mode === 'suggest' ? // Rows in Fuse's SCORE order, the opposite of what `filter` does and
+    // deliberately: filtering narrows a chronological feed, so reshuffling
+    // it would be a second, unasked-for change to what the reader is
+    // looking at. A suggestion list is not a feed — it is an answer to a
+    // question, and the best answer belongs first.
+    /*#__PURE__*/ _jsx(SuggestSearchBox, _extends({
+        fuzzy: fuzzy
+    }, items ? {
+        items
+    } : {}, searchPlaceholder === undefined ? {} : {
+        placeholder: searchPlaceholder
+    }, suppressNavigation ? {
+        inert: true
+    } : {}, {
+        // This block searched the entries IT rendered — a page window, an
+        // `entriesLimit` slice, or a bounded read. Never "this collection".
+        emptyText: (text)=>`No matches for “${text}” on this page.`
+    })) : /*#__PURE__*/ _jsx(SearchField, _extends({
+        value: query,
+        landmark: true
+    }, searchPlaceholder === undefined ? {} : {
+        placeholder: searchPlaceholder
+    }, suppressNavigation ? {
+        inert: true
+    } : {}, {
+        onQuery: setQuery
+    }));
+    return /*#__PURE__*/ _jsxs(MuiStack, _extends({
+        ref: ref,
+        spacing: 4
+    }, props, {
+        children: [
+            field,
+            visible,
+            scopeNote
+        ]
+    }));
+});
+CollectionEntries.displayName = 'AglynCollectionEntries';
+export const collectionEntriesSchema = {
+    $id: ENTRIES_ID,
+    pluginId: BUNDLE_ID,
+    displayName: 'Collection Entries',
+    description: 'Repeats its children once per entry in a content collection.',
+    category: Aglyn.ComponentCategory.DATA_DISPLAY,
+    icon: {
+        path: mdiPostOutline.path,
+        sx: {
+            color: 'secondary.main'
+        }
+    },
+    attributes: [
+        {
+            name: 'collectionSlug',
+            label: 'Collection slug',
+            description: 'Content collection whose published entries the children repeat ' + 'over (e.g. "blog"). Leave blank on a list-template screen to use ' + 'the collection from the URL.',
+            component: Aglyn.FieldComponentType.TEXT_FIELD
+        },
+        {
+            name: 'entriesLimit',
+            label: 'Entries limit',
+            description: 'Maximum entries rendered (blank = all, capped at 100).',
+            component: Aglyn.FieldComponentType.TEXT_FIELD,
+            type: 'number'
+        },
+        {
+            name: 'filterCategory',
+            label: 'Filter by category',
+            description: 'Only entries in this category repeat — the category name or its ' + 'stable id both match (e.g. "Guides"). Blank = no category filter.',
+            component: Aglyn.FieldComponentType.TEXT_FIELD
+        },
+        {
+            name: 'filterTag',
+            label: 'Filter by tag',
+            description: 'Only entries carrying this tag repeat (e.g. "nextjs"). Blank = ' + 'no tag filter.',
+            component: Aglyn.FieldComponentType.TEXT_FIELD
+        },
+        {
+            name: 'perPage',
+            label: 'Entries per page',
+            description: 'Paginate the list: entries per page (blank = no pagination). ' + 'Pairs with the page from /{collection}/page/{n}.',
+            component: Aglyn.FieldComponentType.TEXT_FIELD,
+            type: 'number'
+        },
+        {
+            name: 'page',
+            label: 'Page',
+            description: '1-based page to render when Entries per page is set.',
+            component: Aglyn.FieldComponentType.TEXT_FIELD,
+            type: 'number'
+        },
+        {
+            name: 'firstPageOnly',
+            label: 'Only on page 1',
+            description: 'Show this block on the first page of the listing only. Use it ' + 'for a featured or lead card: without it the same entry repeats ' + 'at the top of every /page/{n}, above a page of different ones.',
+            component: Aglyn.FieldComponentType.SWITCH
+        },
+        {
+            name: 'search',
+            label: 'Search',
+            description: 'Show a search box that filters the rendered entries by title ' + 'and excerpt as the reader types. It searches the entries this ' + 'block rendered — whatever paging, an entry limit or the ' + '100-entry cap left it holding, and it says so on a miss.',
+            component: Aglyn.FieldComponentType.SWITCH
+        },
+        {
+            name: 'searchMode',
+            label: 'When the reader types',
+            description: 'Filter the entries in place, or leave the list alone and open a ' + 'dropdown of matching entries under the box — each one a link, ' + 'ending in "View all results" for a search across the whole site.',
+            component: Aglyn.FieldComponentType.SELECT,
+            options: COLLECTION_SEARCH_MODE_OPTIONS.map((option)=>_extends({}, option)),
+            // Meaningless while there is no search box to type in.
+            condition: {
+                when: 'search',
+                is: true
+            }
+        },
+        {
+            name: 'searchPlaceholder',
+            label: 'Search placeholder',
+            description: 'Hint text inside this block’s own search box — the one that ' + 'filters the entries below it as a reader types. Blank shows ' + '"Search posts…".',
+            component: Aglyn.FieldComponentType.TEXT_FIELD,
+            // Meaningless while there is no search box to hint in.
+            condition: {
+                when: 'search',
+                is: true
+            }
+        },
+        // `searchIndex` and `searchTotal` are deliberately NOT attributes: both
+        // are server-stamped by expandCollectionEntries, like Category Pills'
+        // `items` and Related Posts' `entries`.
+        {
+            name: 'spacing',
+            label: 'Spacing',
+            description: 'Defines the space/gap between entries.',
+            component: Aglyn.FieldComponentType.TEXT_FIELD,
+            type: 'number'
+        }
+    ]
+};
+/** A still-unresolved `{{token}}` (no entry context on this render). */ const UNRESOLVED_TOKEN = /^\{\{[^}]+\}\}$/;
+const renderInlines = (inlines, links)=>inlines.map((item, index)=>{
+        if (item.type === 'bold') return /*#__PURE__*/ _jsx("strong", {
+            children: item.text
+        }, index);
+        if (item.type === 'italic') return /*#__PURE__*/ _jsx("em", {
+            children: item.text
+        }, index);
+        if (item.type !== 'link') return /*#__PURE__*/ _jsx("span", {
+            children: item.text
+        }, index);
+        // Internal paths route through AppLink for client-side navigation
+        // (AGL-582); external links stay plain anchors. Editing surfaces render
+        // the link look without an href so clicks never navigate. A target named
+        // by REFERENCE resolves against the routing map first (AGL-3118), and one
+        // whose entry, listing or screen is gone renders as the words alone —
+        // never as an anchor holding the stored value.
+        const link = Aglyn.resolveMarkdownLink(item.href, links);
+        if (link.kind === 'text') return /*#__PURE__*/ _jsx("span", {
+            children: item.text
+        }, index);
+        if (link.kind === 'inert') {
+            return /*#__PURE__*/ _jsx(MuiLink, {
+                component: "span",
+                sx: {
+                    cursor: 'default'
+                },
+                children: item.text
+            }, index);
+        }
+        return link.kind === 'internal' ? /*#__PURE__*/ _jsx(AppLink, {
+            href: link.href,
+            children: item.text
+        }, index) : /*#__PURE__*/ _jsx(MuiLink, {
+            href: link.href,
+            children: item.text
+        }, index);
+    });
+/**
+ * Renders a content entry's markdown-lite body as themed MUI elements
+ * (AGL-551): headings, paragraphs, lists, and images pick up the site
+ * theme's typography instead of the old unthemed article HTML. Parsing is
+ * pure, so the full body server-renders (SEO keeps the article text).
+ */ const CollectionEntryBody = /*#__PURE__*/ forwardRef((props, ref)=>{
+    // `intrinsicSizes` is destructured out rather than left in `rest`: `rest` is
+    // spread onto a Box, and a composition-stamped object would reach the DOM as
+    // an attribute React has no idea what to do with.
+    const { markdown, intrinsicSizes } = props, rest = _object_without_properties_loose(props, [
+        "markdown",
+        "intrinsicSizes"
+    ]);
+    // Node styles ride the renderer-merged sx; recompose (stack.ts pattern).
+    const nodeSx = Array.isArray(props['sx']) ? props['sx'] : [
+        props['sx']
+    ];
+    // The routing map travels with the suppression flag: both decide what a
+    // link in this body renders as (AGL-3118).
+    const { suppressNavigation, screens } = useContext(Aglyn.ScreenLinkContext);
+    const links = useMemo(()=>({
+            suppressNavigation,
+            screens
+        }), [
+        suppressNavigation,
+        screens
+    ]);
+    // The site being rendered, for image blocks (AGL-1686) — read once here
+    // because hooks cannot run inside the block map below.
+    const { hostId } = Aglyn.useSite();
+    const source = (markdown != null ? markdown : '').trim();
+    const unresolved = !source || UNRESOLVED_TOKEN.test(source);
+    const blocks = useMemo(()=>unresolved ? [] : Aglyn.parseMarkdownLite(source), [
+        source,
+        unresolved
+    ]);
+    // Heading anchors, on the same terms as the Markdown element (AGL-1162).
+    // Without them a blog article could not carry an "On this page" aside at
+    // all: the Table of Contents element emits `#slug` links, and there was
+    // nothing on this page for them to land on.
+    const slugs = useMemo(()=>Aglyn.markdownHeadingSlugs(blocks), [
+        blocks
+    ]);
+    if (unresolved) {
+        // Editing surfaces get an affordance; the published site renders
+        // nothing rather than a literal token.
+        if (!suppressNavigation) return /*#__PURE__*/ _jsx(Box, _extends({
+            ref: ref
+        }, rest));
+        return /*#__PURE__*/ _jsx(Box, _extends({
+            ref: ref
+        }, rest, {
+            sx: [
+                {
+                    p: 2,
+                    border: '1px dashed',
+                    borderColor: 'divider',
+                    color: 'text.secondary',
+                    fontSize: 12,
+                    fontFamily: 'system-ui, sans-serif'
+                },
+                ...nodeSx
+            ],
+            children: 'Entry body — the {{entry.body}} markdown renders here'
+        }));
+    }
+    return /*#__PURE__*/ _jsx(Box, _extends({
+        ref: ref
+    }, rest, {
+        children: blocks.map((block, index)=>{
+            if (block.type === 'heading') {
+                return /*#__PURE__*/ _jsx(Typography, {
+                    id: slugs[index],
+                    variant: block.level === 2 ? 'h4' : 'h5',
+                    component: block.level === 2 ? 'h2' : 'h3',
+                    gutterBottom: true,
+                    sx: {
+                        scrollMarginTop: `${Aglyn.HEADING_ANCHOR_SCROLL_MARGIN}px`
+                    },
+                    children: renderInlines(block.inlines, links)
+                }, index);
+            }
+            if (block.type === 'image') {
+                return /*#__PURE__*/ _jsx(Box, _extends({
+                    component: "img"
+                }, Aglyn.mediaBodyImageAttributes({
+                    src: block.src,
+                    hostId,
+                    size: intrinsicSizes == null ? void 0 : intrinsicSizes[block.src]
+                }), {
+                    alt: block.alt,
+                    // Paired with the `width`/`height` above — see the Markdown
+                    // element's copy of this: without it the height hint outlives
+                    // the `maxWidth` cap and squashes the picture.
+                    sx: {
+                        maxWidth: '100%',
+                        height: 'auto',
+                        borderRadius: 1,
+                        my: 1
+                    }
+                }, Aglyn.DEFERRED_IMAGE_ATTRIBUTES), index);
+            }
+            if (block.type === 'list') {
+                return /*#__PURE__*/ _jsx(Box, {
+                    component: "ul",
+                    sx: {
+                        lineHeight: 1.7,
+                        pl: 3
+                    },
+                    children: block.items.map((item, itemIndex)=>/*#__PURE__*/ _jsx("li", {
+                            children: renderInlines(item, links)
+                        }, itemIndex))
+                }, index);
+            }
+            // A numbered list (AGL-1320) — a real `<ol>`, so the markers are the
+            // browser's and `start` survives: a notice that resumes at 7 has to
+            // read as 7 for the enumeration to mean anything.
+            if (block.type === 'orderedList') {
+                return /*#__PURE__*/ _jsx(Box, {
+                    component: "ol",
+                    start: block.start,
+                    sx: {
+                        lineHeight: 1.7,
+                        pl: 3
+                    },
+                    children: block.items.map((item, itemIndex)=>/*#__PURE__*/ _jsx("li", {
+                            children: renderInlines(item, links)
+                        }, itemIndex))
+                }, index);
+            }
+            // Code blocks and tables (AGL-974). Both scroll rather than wrap:
+            // a wrapped code line or a squeezed table column loses the very
+            // structure that made the block worth writing.
+            if (block.type === 'code') {
+                return /*#__PURE__*/ _jsx(Box, {
+                    component: "pre",
+                    sx: {
+                        my: 2,
+                        p: 2,
+                        overflowX: 'auto',
+                        borderRadius: 1,
+                        bgcolor: 'action.hover',
+                        fontFamily: 'monospace',
+                        fontSize: 14
+                    },
+                    children: /*#__PURE__*/ _jsx("code", {
+                        children: block.text
+                    })
+                }, index);
+            }
+            if (block.type === 'table') {
+                return /*#__PURE__*/ _jsx(Box, {
+                    sx: {
+                        my: 2,
+                        overflowX: 'auto'
+                    },
+                    children: /*#__PURE__*/ _jsxs(Box, {
+                        component: "table",
+                        sx: {
+                            borderCollapse: 'collapse',
+                            width: '100%',
+                            '& th, & td': {
+                                border: '1px solid',
+                                borderColor: 'divider',
+                                px: 1.5,
+                                py: 1
+                            },
+                            '& th': {
+                                bgcolor: 'action.hover'
+                            }
+                        },
+                        children: [
+                            /*#__PURE__*/ _jsx("thead", {
+                                children: /*#__PURE__*/ _jsx("tr", {
+                                    children: block.header.map((cell, cellIndex)=>{
+                                        var _block_align_cellIndex;
+                                        return /*#__PURE__*/ _jsx("th", {
+                                            style: {
+                                                textAlign: (_block_align_cellIndex = block.align[cellIndex]) != null ? _block_align_cellIndex : 'left'
+                                            },
+                                            children: renderInlines(cell, links)
+                                        }, cellIndex);
+                                    })
+                                })
+                            }),
+                            /*#__PURE__*/ _jsx("tbody", {
+                                children: block.rows.map((row, rowIndex)=>/*#__PURE__*/ _jsx("tr", {
+                                        children: row.map((cell, cellIndex)=>{
+                                            var _block_align_cellIndex;
+                                            return /*#__PURE__*/ _jsx("td", {
+                                                style: {
+                                                    textAlign: (_block_align_cellIndex = block.align[cellIndex]) != null ? _block_align_cellIndex : 'left'
+                                                },
+                                                children: renderInlines(cell, links)
+                                            }, cellIndex);
+                                        })
+                                    }, rowIndex))
+                            })
+                        ]
+                    })
+                }, index);
+            }
+            // The article template's pull-quote (AGL-1315, Figma 170:225):
+            // larger italic prose behind a left accent. Palette tokens only, so
+            // it follows the site theme in both modes.
+            if (block.type === 'quote') {
+                return /*#__PURE__*/ _jsx(Typography, {
+                    component: "blockquote",
+                    sx: {
+                        my: 3,
+                        mx: 0,
+                        pl: 2.5,
+                        borderLeft: '3px solid',
+                        borderColor: 'primary.main',
+                        fontStyle: 'italic',
+                        fontSize: '1.25em',
+                        lineHeight: 1.6,
+                        color: 'text.primary'
+                    },
+                    children: renderInlines(block.inlines, links)
+                }, index);
+            }
+            return /*#__PURE__*/ _jsx(Typography, {
+                variant: "body1",
+                sx: {
+                    lineHeight: 1.7
+                },
+                gutterBottom: true,
+                children: renderInlines(block.inlines, links)
+            }, index);
+        })
+    }));
+});
+CollectionEntryBody.displayName = 'AglynCollectionEntryBody';
+export const collectionEntryBodySchema = {
+    $id: ENTRY_BODY_ID,
+    pluginId: BUNDLE_ID,
+    displayName: 'Entry Body',
+    description: "The current entry's markdown body, on an entry template.",
+    category: Aglyn.ComponentCategory.TEXT,
+    icon: {
+        path: mdiTextLong.path,
+        sx: {
+            color: 'secondary.main'
+        }
+    },
+    flags: {
+        selfClosing: Aglyn.FEATURE_FLAG.ENABLED
+    },
+    attributes: [
+        {
+            name: 'markdown',
+            label: 'Markdown',
+            description: 'Markdown-lite content. Keep {{entry.body}} on entry-template ' + "screens so each entry's body renders here.",
+            component: Aglyn.FieldComponentType.TEXT_FIELD
+        }
+    ]
+};
+/** The frame's 3-up (Figma 170:242) when nothing usable is authored. */ const RELATED_DEFAULT_COLUMNS = 3;
+/**
+ * The cover's PROPORTION in the card grid.
+ *
+ * ONE ratio for every card, rather than each record's own shape: the titles
+ * under the covers only line up when the covers are the same height, and a
+ * grid of honest shapes is a ragged grid.
+ *
+ * The ratio is the shape the console asks authors for — 1200 x 630, the same
+ * image that heads the entry and doubles as its share card — so a cover
+ * authored as instructed loses nothing to the crop. The frame's own card is
+ * 445 x 180 (Figma 170:243), which is 2.47 against that art's 1.90: held
+ * there, `objectFit: cover` discarded 23% of every card's picture at every
+ * width. Cover art is usually a composed lockup, so what it discards is the
+ * title set on it.
+ *
+ * Before the ratio it was a fixed 180px height, which was the frame's number
+ * without the frame's shape: a card is 445 wide there, the grid's columns
+ * grow with the viewport and 180 does not, so every extra pixel of width
+ * flattened the box further — 3.57:1 by a 2000px viewport. A ratio holds the
+ * shape at every width; this ratio holds the picture as well.
+ */ const RELATED_COVER_ASPECT = '1200 / 630';
+/**
+ * The card's category chip (AGL-1457). ONE fixed token pair for every
+ * category: colour-coding a chip per category needs conditional styling,
+ * which is not expressible yet (AGL-1307), and inventing a palette here
+ * would have to be unpicked when it is. Same shape as the tag chips Entry
+ * Meta already renders, so the two blocks read as one vocabulary.
+ */ const relatedChipSx = {
+    alignSelf: 'flex-start',
+    borderColor: 'divider',
+    color: 'text.secondary',
+    '& .MuiChip-label': {
+        // 9px, the frame's own inset on a 69 x 24 chip.
+        px: 1.125,
+        // The frame sets this label in the same uppercase, letter-spaced step as
+        // the kicker above an article title, which is what `overline` IS in the
+        // site theme. Naming the step keeps the chip on the theme's scale instead
+        // of a hand-written size that drifts the moment the theme moves.
+        typography: 'overline',
+        // `size="small"` gives the chip the frame's 24px height, and `overline`
+        // carries a 2.66 line-height meant for a standalone kicker with room
+        // around it. Inside a fixed-height chip the box sets the height, so the
+        // line collapses to it and the label centres.
+        lineHeight: 1
+    }
+};
+/** The heading step the block has always emitted. */ const RELATED_DEFAULT_HEADING_VARIANT = 'h5';
+/** The card-title step the block has always emitted. */ const RELATED_DEFAULT_TITLE_VARIANT = 'subtitle1';
+/**
+ * The instant the sample cards are dated. A FIXED one, never `Date.now()`:
+ * the canvas has to render the same bytes every time it opens, and this is
+ * the date the Date-format labels use as their worked example — so the
+ * dropdown and the cards it previews agree word for word.
+ */ const RELATED_SAMPLE_PUBLISHED_AT = {
+    seconds: Date.UTC(2026, 7, 9) / 1000
+};
+/**
+ * Titles for the sample cards. Deliberately unmistakable as copy: the author
+ * is looking at a LAYOUT, and a plausible-looking headline here is one an
+ * author can mistake for a post that exists — or worse, design around.
+ */ const RELATED_SAMPLE_TITLES = [
+    'Sample related post',
+    'A second sample post',
+    'A third sample post'
+];
+/** Category chip text for the sample cards; names the field, not a taxonomy. */ const RELATED_SAMPLE_CATEGORY = 'Category';
+/** Excerpt text for the sample cards; one line, so the card keeps its shape. */ const RELATED_SAMPLE_EXCERPT = 'Each post’s own excerpt reads here, trimmed to a line or two.';
+/**
+ * Stand-in posts for editing surfaces (AGL-2486).
+ *
+ * Related posts are resolved FROM the routed entry, and a besigner canvas has
+ * no routed entry — so the block used to draw a one-line dashed strip and the
+ * author styled a layout they could not see. The sample is the block's REAL
+ * markup, at the author's own settings, which is the only way the canvas can
+ * answer "what will this look like".
+ *
+ * It exists only where {@link ScreenLinkContext.suppressNavigation} is on —
+ * the besigner canvas and Preview. A published render reaches this function
+ * on no path at all, so no visitor can ever be shown a post that does not
+ * exist.
+ *
+ * The count follows the author's own `limit` so a 6-post rail at 3 columns
+ * previews as two rows, and is bounded by the same ceiling the server
+ * applies rather than a second one.
+ */ const sampleRelatedEntries = (limit, dateFormat)=>{
+    const count = Math.min(// `|| default` also rejects 0, which `toCount` would otherwise accept and
+    // preview as an empty rail — the one thing the sample exists to avoid.
+    toCount(limit, Aglyn.COLLECTION_RELATED_DEFAULT_LIMIT) || Aglyn.COLLECTION_RELATED_DEFAULT_LIMIT, Aglyn.COLLECTION_RELATED_MAX);
+    const date = Aglyn.formatCollectionEntryDate(RELATED_SAMPLE_PUBLISHED_AT, dateFormat);
+    return Array.from({
+        length: count
+    }, (_, index)=>{
+        var _RELATED_SAMPLE_TITLES_index;
+        return {
+            title: (_RELATED_SAMPLE_TITLES_index = RELATED_SAMPLE_TITLES[index]) != null ? _RELATED_SAMPLE_TITLES_index : `Sample related post ${index + 1}`,
+            // Empty, not a plausible path: every surface that renders the sample
+            // suppresses navigation, so the title is text rather than an anchor and
+            // this is never read. A real-looking href would be a link to nowhere the
+            // moment that stopped being true.
+            url: '',
+            date,
+            category: RELATED_SAMPLE_CATEGORY,
+            excerpt: RELATED_SAMPLE_EXCERPT
+        };
+    });
+};
+/**
+ * Lists other entries of the same collection sharing the current entry's
+ * category or a tag (AGL-582). The tenant stamps `entries` at compose time
+ * on entry renders; without them the published site renders nothing and an
+ * editing surface renders sample cards (AGL-2486).
+ *
+ * Two layouts (AGL-1457). `list` is the plain-link list that has always
+ * shipped and stays the default — the block is live on every blog entry, so
+ * a new default would restyle published pages nobody asked about. `cards` is
+ * the article frame's grid: cover, category chip, title, at an author-set
+ * column count.
+ *
+ * The block owns its markup, so nothing inside a card is a node the Styles
+ * panel can select. Every part it renders therefore needs an attribute, or
+ * it is unauthorable by construction — which is what the type steps and the
+ * `show*` switches are (AGL-2486).
+ */ const CollectionRelated = /*#__PURE__*/ forwardRef((props, ref)=>{
+    // `limit` and `dateFormat` are compose-time: the tenant resolves them
+    // while stamping `entries`; strip them so they never hit the DOM. The
+    // rest are read here, so they must not reach it either.
+    const { heading, limit, entries, showCover, layout, columns, headingVariant, titleVariant, showDate, dateFormat, showCategory, showExcerpt } = props, rest = _object_without_properties_loose(props, [
+        "heading",
+        "limit",
+        "entries",
+        "showCover",
+        "layout",
+        "columns",
+        "headingVariant",
+        "titleVariant",
+        "showDate",
+        "dateFormat",
+        "showCategory",
+        "showExcerpt"
+    ]);
+    // Node styles ride the renderer-merged sx; recompose (stack.ts pattern).
+    const nodeSx = Array.isArray(props['sx']) ? props['sx'] : [
+        props['sx']
+    ];
+    const { suppressNavigation } = useContext(Aglyn.ScreenLinkContext);
+    // The resolver every other surface shares (AGL-1215): a stamped `media:`
+    // reference becomes a CDN URL HERE, not in the document, so one
+    // reference keeps working across sites. Called before the early return —
+    // it is a hook.
+    const { hostId } = Aglyn.useSite();
+    // An editing surface has no routed entry, so nothing is stamped and the
+    // block used to be the one part of the page that was not WYSIWYG. The
+    // sample stands in for exactly that gap, and only there.
+    const sample = !(entries == null ? void 0 : entries.length) && Boolean(suppressNavigation);
+    const items = (entries == null ? void 0 : entries.length) ? entries : sample ? sampleRelatedEntries(limit, Aglyn.normalizeCollectionEntryDateFormat(dateFormat)) : [];
+    if (!items.length) return /*#__PURE__*/ _jsx(Box, _extends({
+        ref: ref
+    }, rest));
+    const title = heading != null ? heading : 'Related articles';
+    const headingNode = title ? /*#__PURE__*/ _jsx(Typography, {
+        variant: headingVariant || RELATED_DEFAULT_HEADING_VARIANT,
+        component: "h2",
+        children: title
+    }) : null;
+    /**
+     * The card title, as a HEADING in the site theme.
+     *
+     * It used to be a bare `AppLink`, which is MUI's `Link` — `primary.main`
+     * and `underline="always"` — so the one thing a related card is FOR read
+     * as a default browser link on a themed page, at no heading level, and
+     * with no attribute able to touch it. The type step now comes from the
+     * theme's own rungs and the anchor inherits the colour, exactly as the
+     * Entry Author card's byline link does.
+     *
+     * `linked` is false wherever the whole card is already the anchor: an
+     * `<a>` inside an `<a>` is invalid markup that browsers silently unnest.
+     */ const titleNode = (entry, linked)=>/*#__PURE__*/ _jsx(Typography, {
+            variant: titleVariant || RELATED_DEFAULT_TITLE_VARIANT,
+            component: "h3",
+            children: linked && !suppressNavigation && entry.url ? /*#__PURE__*/ _jsx(AppLink, {
+                href: entry.url,
+                sx: {
+                    color: 'inherit'
+                },
+                underline: "hover",
+                children: entry.title
+            }) : entry.title
+        });
+    const dateNode = (entry)=>showDate !== false && entry.date ? /*#__PURE__*/ _jsx(Typography, {
+            variant: "caption",
+            sx: {
+                color: 'text.secondary'
+            },
+            children: entry.date
+        }) : null;
+    const excerptNode = (entry)=>showExcerpt && entry.excerpt ? /*#__PURE__*/ _jsx(Typography, {
+            variant: "body2",
+            sx: {
+                color: 'text.secondary'
+            },
+            children: entry.excerpt
+        }) : null;
+    /**
+     * The cover, when the author asked for one AND the entry has one. An
+     * entry without a cover gets no box at all rather than a placeholder:
+     * the related list is a real feed, and a row of grey rectangles is worse
+     * than a row of titles.
+     *
+     * The sample cards are the exception, and for the opposite reason: they
+     * stand in for posts that do not exist yet, so the cover SLOT is what
+     * the author is looking at. A card grid previewing without its images is
+     * not the grid being styled.
+     */ const coverNode = (entry)=>{
+        const src = showCover ? Aglyn.resolveMediaSrc(entry.coverImage, {
+            hostId
+        }) : undefined;
+        if (!src) {
+            if (!sample || !showCover) return null;
+            return /*#__PURE__*/ _jsx(Box, {
+                "aria-hidden": true,
+                sx: {
+                    width: '100%',
+                    aspectRatio: RELATED_COVER_ASPECT,
+                    borderRadius: 1,
+                    backgroundColor: 'action.hover'
+                }
+            });
+        }
+        return /*#__PURE__*/ _jsx(Box, _extends({
+            component: "img",
+            src: src,
+            // The author's own description wins, and the title stays the
+            // fallback (AGL-2418). Unlike the entry hero and the event
+            // thumbnail — which render empty when nothing is authored — this
+            // cover is the LINK's own content, so it must carry an accessible
+            // name rather than go silent.
+            alt: Aglyn.renderedMediaAlt(entry.coverImageAlt, entry.title),
+            sx: {
+                display: 'block',
+                width: '100%',
+                aspectRatio: RELATED_COVER_ASPECT,
+                objectFit: 'cover',
+                borderRadius: 1
+            }
+        }, Aglyn.DEFERRED_IMAGE_ATTRIBUTES));
+    };
+    /**
+     * The notice that says these cards are not posts (AGL-2486). Editing
+     * surfaces only, and outside the card markup rather than inside it, so
+     * the author is styling the same tree the site will render.
+     */ const sampleNotice = sample ? /*#__PURE__*/ _jsx(Typography, {
+        variant: "caption",
+        sx: {
+            display: 'block',
+            p: 1,
+            border: '1px dashed',
+            borderColor: 'divider',
+            borderRadius: 1,
+            color: 'text.secondary',
+            fontFamily: 'system-ui, sans-serif'
+        },
+        children: 'Sample posts — entries sharing this entry’s category or tags ' + 'replace these on the published page'
+    }) : null;
+    if (layout === 'cards') {
+        // `toCount` rounds and rejects junk; `|| default` also rejects 0, which
+        // it would otherwise accept as a column count and emit `repeat(0, …)`.
+        const columnCount = toCount(columns, RELATED_DEFAULT_COLUMNS) || RELATED_DEFAULT_COLUMNS;
+        /**
+       * One card's contents, always with a PLAIN title: the caller wraps the
+       * whole card in the anchor, because a reader aiming at a 180px cover
+       * should not have to hit the line of text under it — and a second
+       * anchor around the title inside that one is markup browsers unnest.
+       */ const card = (entry)=>// 12px between cover, chip and title — the frame's rhythm (170:243
+            // puts the chip at y=192 under a cover ending at 180, and the title
+            // at y=228 under a chip ending at 216).
+            /*#__PURE__*/ _jsxs(MuiStack, {
+                spacing: 1.5,
+                children: [
+                    coverNode(entry),
+                    showCategory !== false && entry.category ? /*#__PURE__*/ _jsx(Chip, {
+                        label: entry.category,
+                        size: "small",
+                        variant: "outlined",
+                        sx: relatedChipSx
+                    }) : null,
+                    titleNode(entry, false),
+                    excerptNode(entry),
+                    dateNode(entry)
+                ]
+            });
+        return /*#__PURE__*/ _jsxs(Box, _extends({
+            ref: ref
+        }, rest, {
+            // MERGE, never replace (AGL-1450) — the node's slice arrives as the
+            // ARRAY `mergeSxProps` builds in leaf.tsx, so folding it into an
+            // object spreads numeric keys and discards every authored property
+            // while these defaults still apply. Defaults first, node's after.
+            sx: [
+                {
+                    display: 'grid',
+                    gridTemplateColumns: `repeat(${columnCount}, minmax(0, 1fr))`,
+                    alignItems: 'start',
+                    columnGap: 3,
+                    rowGap: 4
+                },
+                ...nodeSx
+            ],
+            children: [
+                headingNode ? /*#__PURE__*/ _jsx(Box, {
+                    sx: {
+                        gridColumn: '1 / -1'
+                    },
+                    children: headingNode
+                }) : null,
+                sampleNotice ? /*#__PURE__*/ _jsx(Box, {
+                    sx: {
+                        gridColumn: '1 / -1'
+                    },
+                    children: sampleNotice
+                }) : null,
+                items.map((entry, index)=>{
+                    const linked = !suppressNavigation && Boolean(entry.url);
+                    return linked ? /*#__PURE__*/ _jsx(AppLink, {
+                        href: entry.url,
+                        underline: "none",
+                        // A grid ITEM, so it has to be a block; `color: inherit`
+                        // keeps the cover, chip and date reading as themed content
+                        // rather than as the inside of a link.
+                        sx: {
+                            color: 'inherit',
+                            display: 'block'
+                        },
+                        children: card(entry)
+                    }, index) : /*#__PURE__*/ _jsx(Box, {
+                        children: card(entry)
+                    }, index);
+                })
+            ]
+        }));
+    }
+    return /*#__PURE__*/ _jsxs(MuiStack, _extends({
+        ref: ref,
+        spacing: 1.5
+    }, rest, {
+        children: [
+            headingNode,
+            sampleNotice,
+            items.map((entry, index)=>{
+                const meta = [
+                    showDate !== false ? entry.date : '',
+                    showCategory !== false ? entry.category : ''
+                ].filter(Boolean);
+                return /*#__PURE__*/ _jsxs(MuiStack, {
+                    spacing: 0.25,
+                    children: [
+                        coverNode(entry),
+                        titleNode(entry, true),
+                        excerptNode(entry),
+                        meta.length ? /*#__PURE__*/ _jsx(Typography, {
+                            variant: "caption",
+                            sx: {
+                                color: 'text.secondary'
+                            },
+                            children: meta.join(' · ')
+                        }) : null
+                    ]
+                }, index);
+            })
+        ]
+    }));
+});
+CollectionRelated.displayName = 'AglynCollectionRelated';
+export const collectionRelatedSchema = {
+    $id: RELATED_ID,
+    pluginId: BUNDLE_ID,
+    displayName: 'Related Posts',
+    description: "Other entries sharing this one's category or tags.",
+    category: Aglyn.ComponentCategory.DATA_DISPLAY,
+    icon: {
+        path: mdiNewspaperVariantOutline.path,
+        sx: {
+            color: 'secondary.main'
+        }
+    },
+    flags: {
+        selfClosing: Aglyn.FEATURE_FLAG.ENABLED
+    },
+    attributes: [
+        {
+            name: 'heading',
+            label: 'Heading',
+            description: 'Section heading (blank hides it).',
+            component: Aglyn.FieldComponentType.TEXT_FIELD
+        },
+        {
+            name: 'limit',
+            label: 'Limit',
+            description: 'Most related posts listed (default 3).',
+            component: Aglyn.FieldComponentType.TEXT_FIELD,
+            type: 'number'
+        },
+        {
+            name: 'layout',
+            label: 'Layout',
+            description: 'List keeps the plain links this block has always rendered. ' + 'Cards is the article layout: cover, category, title, in a grid.',
+            component: Aglyn.FieldComponentType.SELECT,
+            // Both values are REAL (AGL-1451/AGL-1453): `''` cannot survive a
+            // save, so an author who switched to Cards would have no route back.
+            // `list` is also the value the render falls back to, so naming it is
+            // the same choice, not a second one.
+            options: [
+                {
+                    value: 'list',
+                    label: 'List (default)'
+                },
+                {
+                    value: 'cards',
+                    label: 'Card grid'
+                }
+            ]
+        },
+        {
+            name: 'columns',
+            label: 'Columns',
+            description: 'Cards per row in the card grid. Default 3.',
+            component: Aglyn.FieldComponentType.TEXT_FIELD,
+            type: 'number',
+            // Meaningless on the list, where each post is its own row.
+            condition: {
+                when: 'layout',
+                is: 'cards'
+            }
+        },
+        {
+            name: 'showCover',
+            label: 'Show cover',
+            description: 'Show each post’s cover image. Posts without one show their ' + 'title alone rather than an empty box.',
+            component: Aglyn.FieldComponentType.SWITCH
+        },
+        {
+            name: 'headingVariant',
+            label: 'Heading style',
+            description: 'Which type step from the site theme the section heading above ' + 'the posts reads at. Default Heading 5.',
+            component: Aglyn.FieldComponentType.SELECT,
+            // The theme's own rungs, shared with the Typography element rather
+            // than a second list here: two lists is how a step added to the
+            // theme becomes reachable in one place and not the other.
+            options: [
+                ...typographyVariants
+            ]
+        },
+        {
+            name: 'titleVariant',
+            label: 'Title style',
+            description: 'Which type step from the site theme each post’s title reads at. ' + 'Default Subtitle 1; the title takes the surrounding text colour ' + 'rather than the link colour.',
+            component: Aglyn.FieldComponentType.SELECT,
+            options: [
+                ...typographyVariants
+            ]
+        },
+        {
+            name: 'showDate',
+            label: 'Show date',
+            description: 'Off drops each post’s published date. The posts stay in ' + 'newest-first order either way — this is about the card, not the ' + 'ordering.',
+            component: Aglyn.FieldComponentType.SWITCH,
+            // Unset means SHOWN in the renderer above, so the switch has to
+            // OPEN in that position or it lies about the block in front of
+            // the author — and the first click, which writes the `true` that
+            // was already in effect, changes nothing and reads as a dead
+            // control (AGL-2506).
+            initialValue: true
+        },
+        {
+            name: 'dateFormat',
+            label: 'Date format',
+            description: 'How each post’s published date reads on its card. Site default ' + 'is the format this block has always used.',
+            component: Aglyn.FieldComponentType.SELECT,
+            // The formats the pure layer knows how to produce, so the list
+            // cannot offer a shape nothing renders. Every value is REAL,
+            // including the do-nothing one (AGL-1451/AGL-1453).
+            options: [
+                ...Aglyn.COLLECTION_ENTRY_DATE_FORMAT_OPTIONS
+            ]
+        },
+        {
+            name: 'showCategory',
+            label: 'Show category',
+            description: 'Off drops the category — the chip above each card title, or the ' + 'second half of the line under each link on the list layout.',
+            component: Aglyn.FieldComponentType.SWITCH,
+            // Unset means SHOWN in the renderer above, so the switch has to
+            // OPEN in that position or it lies about the block in front of
+            // the author — and the first click, which writes the `true` that
+            // was already in effect, changes nothing and reads as a dead
+            // control (AGL-2506).
+            initialValue: true
+        },
+        {
+            name: 'showExcerpt',
+            label: 'Show excerpt',
+            description: 'Adds each post’s excerpt under its title. Posts with no excerpt ' + 'are unchanged rather than leaving a gap.',
+            component: Aglyn.FieldComponentType.SWITCH
+        }
+    ]
+};
+const SHARE_TARGETS = [
+    {
+        label: 'Share on X',
+        path: mdiTwitter.path,
+        href: (url)=>`https://twitter.com/intent/tweet?url=${encodeURIComponent(url)}`
+    },
+    {
+        label: 'Share on LinkedIn',
+        path: mdiLinkedin.path,
+        href: (url)=>'https://www.linkedin.com/sharing/share-offsite/?url=' + encodeURIComponent(url)
+    },
+    {
+        label: 'Share on Facebook',
+        path: mdiFacebook.path,
+        href: (url)=>`https://www.facebook.com/sharer/sharer.php?u=${encodeURIComponent(url)}`
+    }
+];
+/**
+ * Share buttons for the CURRENT page URL (AGL-582): X, LinkedIn, Facebook,
+ * and copy-link. Pure client behavior — the URL is read at click time so
+ * SSR and besigner renders stay markup-identical; editing surfaces no-op.
+ */ const CollectionShare = /*#__PURE__*/ forwardRef((props, ref)=>{
+    const { heading } = props, rest = _object_without_properties_loose(props, [
+        "heading"
+    ]);
+    // Node styles ride the renderer-merged sx; recompose (stack.ts pattern).
+    const nodeSx = Array.isArray(props['sx']) ? props['sx'] : [
+        props['sx']
+    ];
+    const { suppressNavigation } = useContext(Aglyn.ScreenLinkContext);
+    const [copied, setCopied] = useState(false);
+    const title = heading != null ? heading : 'Share';
+    const open = (buildHref)=>()=>{
+            if (suppressNavigation || typeof window === 'undefined') return;
+            window.open(buildHref(window.location.href), '_blank', 'noopener,noreferrer');
+        };
+    const copy = async ()=>{
+        if (suppressNavigation || typeof window === 'undefined') return;
+        try {
+            await navigator.clipboard.writeText(window.location.href);
+            setCopied(true);
+            setTimeout(()=>setCopied(false), 2000);
+        } catch (unused) {
+        // Clipboard unavailable (permissions, http) — silently skip.
+        }
+    };
+    return /*#__PURE__*/ _jsxs(MuiStack, _extends({
+        ref: ref,
+        direction: "row",
+        spacing: 0.5
+    }, rest, {
+        // MERGE, never replace (AGL-1450) — see Entry Meta below.
+        sx: [
+            {
+                alignItems: 'center'
+            },
+            ...nodeSx
+        ],
+        children: [
+            title ? // `component="p"` because this labels a row of buttons; it is not a
+            // section heading (AGL-2486). MUI's `defaultVariantMapping` sends
+            // `subtitle2` to `<h6>`, so without this the Share Bar puts a level-6
+            // heading into the document outline of every page carrying it. On a
+            // blog post the nearest preceding heading is an `h2`, which makes it
+            // a skipped level and a `heading-order` failure.
+            //
+            // Said here rather than as a theme-wide `variantMapping` override: a
+            // default would silently change the element under every `subtitle2`
+            // in the codebase, including surfaces where an `h6` is correct.
+            /*#__PURE__*/ _jsx(Typography, {
+                component: "p",
+                variant: "subtitle2",
+                sx: {
+                    mr: 1
+                },
+                children: title
+            }) : null,
+            SHARE_TARGETS.map((target)=>/*#__PURE__*/ _jsx(IconButton, {
+                    "aria-label": target.label,
+                    size: "small",
+                    onClick: open(target.href),
+                    children: /*#__PURE__*/ _jsx(MdiIcon, {
+                        path: target.path
+                    })
+                }, target.label)),
+            /*#__PURE__*/ _jsx(IconButton, {
+                "aria-label": copied ? 'Link copied' : 'Copy link',
+                size: "small",
+                color: copied ? 'success' : 'default',
+                onClick: copy,
+                children: /*#__PURE__*/ _jsx(MdiIcon, {
+                    path: mdiContentCopy.path
+                })
+            })
+        ]
+    }));
+});
+CollectionShare.displayName = 'AglynCollectionShare';
+export const collectionShareSchema = {
+    $id: SHARE_ID,
+    pluginId: BUNDLE_ID,
+    displayName: 'Share Bar',
+    description: 'Share buttons for the current page, plus a copy link.',
+    category: Aglyn.ComponentCategory.NAVIGATION,
+    icon: {
+        path: mdiShareVariant.path,
+        sx: {
+            color: 'secondary.main'
+        }
+    },
+    flags: {
+        selfClosing: Aglyn.FEATURE_FLAG.ENABLED
+    },
+    attributes: [
+        {
+            name: 'heading',
+            label: 'Heading',
+            description: 'Text before the buttons (blank hides it).',
+            component: Aglyn.FieldComponentType.TEXT_FIELD
+        }
+    ]
+};
+/**
+ * THE SAMPLE VALUES THE ENTRY BLOCKS PREVIEW WITH (AGL-2486).
+ *
+ * Entry Meta and Entry Author resolve FROM the routed entry, and a besigner
+ * canvas has no routed entry — so both drew a one-line dashed strip and an
+ * author styling a byline or an author card was styling something they could
+ * not see. Related Posts had the same gap and was answered the same way: the
+ * block's REAL markup, at the author's own settings, on editing surfaces
+ * only.
+ *
+ * These two need no "this is a sample" notice the way the related CARDS do.
+ * A card carries a title, a cover and a category, which is what a real post
+ * looks like; a byline reading `Sample author` says what it is in the words
+ * themselves, and a notice above a single line of caption text would be
+ * taller than the thing it labels.
+ *
+ * The date is a FIXED instant, never `Date.now()`: the canvas has to render
+ * the same bytes every time it opens, and it is the same instant the related
+ * sample uses, so two blocks on one template never disagree about what day
+ * their example is.
+ */ const ENTRY_SAMPLE_PUBLISHED_AT = RELATED_SAMPLE_PUBLISHED_AT;
+/** Byline name for the samples; names the field rather than a person. */ const ENTRY_SAMPLE_AUTHOR = 'Sample author';
+/** Category text for the samples; names the field, not a taxonomy. */ const ENTRY_SAMPLE_CATEGORY = RELATED_SAMPLE_CATEGORY;
+/** Two chips, so the row previews its own wrapping and gap. */ const ENTRY_SAMPLE_TAGS = 'first tag, second tag';
+/** Bio line for the author-card sample; one sentence, as a real one is. */ const ENTRY_SAMPLE_BIO = 'The bio from this author’s record reads here, in a line or two.';
+/**
+ * The portrait STAND-IN, for a sample that has no image to resolve.
+ *
+ * A neutral plate rather than nothing, and for the reason the related sample
+ * draws its cover slot: on an entry template the portrait arrives from the
+ * author record at render, so the slot is exactly what the author is sizing
+ * and spacing. `aria-hidden` because it depicts nothing.
+ */ const samplePortraitSx = (size)=>({
+        width: size,
+        height: size,
+        flexShrink: 0,
+        borderRadius: '50%',
+        backgroundColor: 'action.hover'
+    });
+/** Byline avatar, from the article frame (Figma 170:190). */ const ENTRY_AVATAR_SIZE = 36;
+/** Unresolved tokens render empty on the site, literal in the besigner. */ const metaValue = (value, suppressNavigation)=>{
+    const trimmed = (value != null ? value : '').trim();
+    if (!trimmed) return '';
+    if (UNRESOLVED_TOKEN.test(trimmed) && !suppressNavigation) return '';
+    return trimmed;
+};
+/**
+ * "{{entry.date}} · {{entry.category}}" meta line plus tag chips
+ * (AGL-582). Values arrive through entry tokens on entry renders; on other
+ * surfaces unresolved tokens collapse to nothing instead of leaking.
+ *
+ * On an entry template the tenant now also FILLS the three values from the
+ * routed entry when nothing is bound (`expandCollectionEntryMeta`, AGL-1385).
+ * Before that, a block dragged from the palette rather than dropped as the
+ * preset had no values at all — three "Show" switches gating nothing — and
+ * rendered as the empty `<Box>` below, at height 0.
+ */ const CollectionEntryMeta = /*#__PURE__*/ forwardRef((props, ref)=>{
+    const { date, // Compose-time (AGL-1459): read by `expandCollectionEntryMeta`, which has
+    // the timestamp. Destructured so it never reaches the DOM.
+    dateFormat: _dateFormat, author, authorPageUrl, linkAuthor, category, tags, avatarImage, showDate, showAuthor, showCategory, showTags, showAvatar } = props, rest = _object_without_properties_loose(props, [
+        "date",
+        "dateFormat",
+        "author",
+        "authorPageUrl",
+        "linkAuthor",
+        "category",
+        "tags",
+        "avatarImage",
+        "showDate",
+        "showAuthor",
+        "showCategory",
+        "showTags",
+        "showAvatar"
+    ]);
+    // Node styles ride the renderer-merged sx; recompose (stack.ts pattern).
+    const nodeSx = Array.isArray(props['sx']) ? props['sx'] : [
+        props['sx']
+    ];
+    const { suppressNavigation } = useContext(Aglyn.ScreenLinkContext);
+    // The resolver every other surface shares (AGL-1215), so one media
+    // reference keeps working across sites. A hook — before any early return.
+    const { hostId } = Aglyn.useSite();
+    const dateValue = showDate !== false ? metaValue(date, suppressNavigation) : '';
+    const authorValue = showAuthor !== false ? metaValue(author, suppressNavigation) : '';
+    const categoryValue = showCategory !== false ? metaValue(category, suppressNavigation) : '';
+    const tagsValue = showTags !== false ? metaValue(tags, suppressNavigation) : '';
+    const tagList = tagsValue.split(',').map((tag)=>tag.trim()).filter(Boolean);
+    // An unresolved token empties on EVERY surface here, unlike the text
+    // fields: a literal `{{…}}` in a src is a broken image in the canvas, and a
+    // byline that renders a broken avatar on every post is worse than no
+    // avatar at all.
+    const avatarRaw = (avatarImage != null ? avatarImage : '').trim();
+    const avatarSrc = showAvatar !== false && avatarRaw && !UNRESOLVED_TOKEN.test(avatarRaw) ? Aglyn.resolveMediaSrc(avatarRaw, {
+        hostId
+    }) : '';
+    // Author leads, so the frame's "The Aglyn Team · Jul 2026" reads in that
+    // order. With no author the join is character-for-character what it was.
+    const filledLine = [
+        authorValue,
+        dateValue,
+        categoryValue
+    ].filter(Boolean).join(' · ');
+    /*
+    The rest of the line, WITHOUT the author (AGL-2519).
+
+    The row is one string everywhere else, which is what a `·`-joined byline
+    wants — but a link is an element, so the author has to come out of the
+    join to be one. Split rather than reassembled from parts, so the
+    separator, the order and the empty-field collapsing all stay in the one
+    expression above: the linked row and the plain row cannot render a
+    different sentence.
+  */ const authorHrefRaw = metaValue(authorPageUrl, suppressNavigation);
+    const authorHref = linkAuthor !== false && SAFE_AUTHOR_HREF.test(authorHrefRaw) ? authorHrefRaw : '';
+    const trailingLine = [
+        dateValue,
+        categoryValue
+    ].filter(Boolean).join(' · ');
+    // Nothing to show and nothing to route from: an editing surface previews
+    // the block's own markup at the author's own settings, and a published page
+    // renders nothing at all (AGL-2486). The switches are honoured here exactly
+    // as they are below, so a row with Show date off previews without one.
+    const sample = !filledLine && !tagList.length && !avatarSrc && suppressNavigation;
+    const line = sample ? [
+        showAuthor !== false ? ENTRY_SAMPLE_AUTHOR : '',
+        showDate !== false ? Aglyn.formatCollectionEntryDate(ENTRY_SAMPLE_PUBLISHED_AT, Aglyn.normalizeCollectionEntryDateFormat(_dateFormat)) : '',
+        showCategory !== false ? ENTRY_SAMPLE_CATEGORY : ''
+    ].filter(Boolean).join(' · ') : filledLine;
+    const chips = sample ? showTags !== false ? ENTRY_SAMPLE_TAGS.split(',').map((tag)=>tag.trim()) : [] : tagList;
+    // The portrait an entry's own author record supplies arrives at compose
+    // time, so on the canvas there is none to resolve — the slot is drawn
+    // instead, which is what a byline's spacing is actually built around.
+    const samplePortrait = sample && showAvatar !== false;
+    if (!line && !chips.length && !avatarSrc && !samplePortrait) {
+        return /*#__PURE__*/ _jsx(Box, _extends({
+            ref: ref
+        }, rest));
+    }
+    return /*#__PURE__*/ _jsxs(MuiStack, _extends({
+        ref: ref,
+        direction: "row",
+        spacing: 1
+    }, rest, {
+        // MERGE, never replace (AGL-1450, same class as AGL-1284). `rest.sx`
+        // is the ARRAY `mergeSxProps` builds in leaf.tsx, so spreading it into
+        // an object produced `{0: …, 1: …, 2: …}` — numeric keys emotion emits
+        // as invalid selectors — and discarded EVERY authored property while
+        // these two defaults still applied. The block looked deliberately
+        // styled, so nothing suggested the value had been dropped. Defaults
+        // go first; the node's slice comes after and can override them.
+        sx: [
+            {
+                alignItems: 'center',
+                flexWrap: 'wrap'
+            },
+            ...nodeSx
+        ],
+        children: [
+            avatarSrc ? /*#__PURE__*/ _jsx(Box, _extends({
+                component: "img",
+                src: avatarSrc,
+                // Decorative: the byline names the author in text right beside it,
+                // so a screen reader announcing the mark again is noise.
+                alt: "",
+                sx: {
+                    display: 'block',
+                    width: ENTRY_AVATAR_SIZE,
+                    height: ENTRY_AVATAR_SIZE,
+                    borderRadius: '50%',
+                    objectFit: 'cover'
+                }
+            }, Aglyn.DEFERRED_IMAGE_ATTRIBUTES)) : samplePortrait ? /*#__PURE__*/ _jsx(Box, {
+                "aria-hidden": true,
+                sx: samplePortraitSx(ENTRY_AVATAR_SIZE)
+            }) : null,
+            line ? /*#__PURE__*/ _jsx(Typography, {
+                variant: "caption",
+                sx: {
+                    color: 'text.secondary'
+                },
+                children: // Linked only on the real byline, never on the canvas sample: a
+                // preview whose placeholder name navigates is a trap, and the
+                // sample author has no page to go to.
+                authorHref && authorValue && !sample ? /*#__PURE__*/ _jsxs(_Fragment, {
+                    children: [
+                        /*#__PURE__*/ _jsx(AppLink, {
+                            href: authorHref,
+                            sx: {
+                                color: 'inherit'
+                            },
+                            underline: "hover",
+                            children: authorValue
+                        }),
+                        trailingLine ? ` · ${trailingLine}` : ''
+                    ]
+                }) : line
+            }) : null,
+            chips.map((tag)=>/*#__PURE__*/ _jsx(Chip, {
+                    label: tag,
+                    size: "small",
+                    variant: "outlined"
+                }, tag))
+        ]
+    }));
+});
+CollectionEntryMeta.displayName = 'AglynCollectionEntryMeta';
+export const collectionEntryMetaSchema = {
+    $id: ENTRY_META_ID,
+    pluginId: BUNDLE_ID,
+    displayName: 'Entry Meta',
+    description: 'The byline row for an entry — author, date, category and tags.',
+    category: Aglyn.ComponentCategory.TEXT,
+    icon: {
+        path: mdiTagOutline.path,
+        sx: {
+            color: 'secondary.main'
+        }
+    },
+    flags: {
+        selfClosing: Aglyn.FEATURE_FLAG.ENABLED
+    },
+    attributes: [
+        {
+            name: 'date',
+            label: 'Date',
+            description: 'Blank shows the entry’s own published date on entry templates. ' + 'Type here (or bind {{entry.date}}) only to override it.',
+            component: Aglyn.FieldComponentType.TEXT_FIELD
+        },
+        {
+            name: 'dateFormat',
+            label: 'Date format',
+            description: 'How the published date reads. Site default is the format this ' + 'block has always used; it has no effect on a Date you typed in ' + 'yourself.',
+            component: Aglyn.FieldComponentType.SELECT,
+            // The formats the pure layer knows how to produce, so the list cannot
+            // offer a shape nothing renders. Every value is REAL — including the
+            // do-nothing one (AGL-1451/AGL-1453): `''` cannot survive a save, so
+            // an author who tried a format would have no route back.
+            options: [
+                ...Aglyn.COLLECTION_ENTRY_DATE_FORMAT_OPTIONS
+            ]
+        },
+        {
+            name: 'author',
+            label: 'Author',
+            description: 'Blank shows the entry’s own author. Type here (or bind ' + '{{entry.author}}) only to override it.',
+            component: Aglyn.FieldComponentType.TEXT_FIELD
+        },
+        {
+            name: 'category',
+            label: 'Category',
+            description: 'Blank shows the entry’s own category. Type here (or bind ' + '{{entry.category}}) only to override it.',
+            component: Aglyn.FieldComponentType.TEXT_FIELD
+        },
+        {
+            name: 'tags',
+            label: 'Tags',
+            description: 'Comma-separated. Blank shows the entry’s own tags; type here (or ' + 'bind {{entry.tags}}) only to override them.',
+            component: Aglyn.FieldComponentType.TEXT_FIELD
+        },
+        {
+            name: 'avatarImage',
+            label: 'Avatar',
+            description: 'Round image before the byline — your brand mark, or any image ' + 'from the media library. Blank shows no avatar.',
+            component: Aglyn.FieldComponentType.TEXT_FIELD
+        },
+        {
+            name: 'showDate',
+            label: 'Show date',
+            description: 'Off hides the published date from the line without clearing what ' + 'the Date field would have shown.',
+            component: Aglyn.FieldComponentType.SWITCH,
+            // Unset means SHOWN in the renderer above, so the switch has to
+            // OPEN in that position or it lies about the block in front of
+            // the author — and the first click, which writes the `true` that
+            // was already in effect, changes nothing and reads as a dead
+            // control (AGL-2506).
+            initialValue: true
+        },
+        {
+            name: 'showCategory',
+            label: 'Show category',
+            description: 'Off drops the category from the line. The entry keeps its ' + 'category — this is about the byline, not the taxonomy.',
+            component: Aglyn.FieldComponentType.SWITCH,
+            // Unset means SHOWN in the renderer above, so the switch has to
+            // OPEN in that position or it lies about the block in front of
+            // the author — and the first click, which writes the `true` that
+            // was already in effect, changes nothing and reads as a dead
+            // control (AGL-2506).
+            initialValue: true
+        },
+        {
+            name: 'showTags',
+            label: 'Show tags',
+            description: 'Off hides the tag chips below the line. Leave it on and the ' + 'other three off for a tags-only row.',
+            component: Aglyn.FieldComponentType.SWITCH,
+            // Unset means SHOWN in the renderer above, so the switch has to
+            // OPEN in that position or it lies about the block in front of
+            // the author — and the first click, which writes the `true` that
+            // was already in effect, changes nothing and reads as a dead
+            // control (AGL-2506).
+            initialValue: true
+        },
+        {
+            name: 'authorPageUrl',
+            label: 'Author links to',
+            description: 'Blank sends the byline to the author’s page on this site. Type ' + 'here (or bind {{entry.authorPageUrl}}) only to override it.',
+            component: Aglyn.FieldComponentType.TEXT_FIELD
+        },
+        {
+            name: 'linkAuthor',
+            label: 'Link author',
+            description: 'Off leaves the byline as plain text even when the author has a ' + 'page. On, the name links there and the date and category beside ' + 'it do not.',
+            component: Aglyn.FieldComponentType.SWITCH,
+            // Unset means LINKED in the renderer above, so the switch has to open
+            // in that position or it lies about the block in front of the author
+            // (AGL-2506).
+            initialValue: true
+        },
+        {
+            name: 'showAuthor',
+            label: 'Show author',
+            description: 'Off hides the byline. The avatar follows it: a block with no ' + 'author shown never fills in the author’s portrait.',
+            component: Aglyn.FieldComponentType.SWITCH,
+            // Unset means SHOWN in the renderer above, so the switch has to
+            // OPEN in that position or it lies about the block in front of
+            // the author — and the first click, which writes the `true` that
+            // was already in effect, changes nothing and reads as a dead
+            // control (AGL-2506).
+            initialValue: true
+        },
+        {
+            name: 'showAvatar',
+            label: 'Show avatar',
+            description: 'Off hides the round image in front of the byline, including an ' + 'author’s own portrait.',
+            component: Aglyn.FieldComponentType.SWITCH,
+            // Unset means SHOWN in the renderer above, so the switch has to
+            // OPEN in that position or it lies about the block in front of
+            // the author — and the first click, which writes the `true` that
+            // was already in effect, changes nothing and reads as a dead
+            // control (AGL-2506).
+            initialValue: true
+        }
+    ]
+};
+/** The card's portrait, larger than the byline's 36px mark (Figma 170:190). */ const AUTHOR_AVATAR_SIZE = 48;
+/**
+ * The mark for each platform the author model knows (AGL-2516).
+ *
+ * Imported rather than resolved through the icon catalog, because this set is
+ * CLOSED and known at build time — the catalog is ~2.9 MB and only picker
+ * surfaces load it, so a renderer that reached for it to draw ten glyphs
+ * would ship the whole thing to every visitor of every article.
+ *
+ * Keyed by the registry's `icon`, so adding a platform is one entry there and
+ * one import here, and a platform whose mark was never imported falls through
+ * to the generic link glyph rather than rendering nothing.
+ */ const AUTHOR_LINK_ICON_PATHS = {
+    twitter: mdiTwitter.path,
+    linkedin: mdiLinkedin.path,
+    github: mdiGithub.path,
+    mastodon: mdiMastodon.path,
+    youtube: mdiYoutube.path,
+    instagram: mdiInstagram.path,
+    facebook: mdiFacebook.path,
+    web: mdiWeb.path,
+    email: mdiEmail.path,
+    rss: mdiRss.path
+};
+/**
+ * What one link row draws.
+ *
+ * A known platform takes its mark from the table above. A CUSTOM link takes
+ * the path the console stored beside the picked id (AGL-1212) — and falls back
+ * to a generic link glyph rather than to nothing, because a row with a label
+ * and a url is still a working link whose icon simply failed to resolve.
+ */ function authorLinkIconPath(link) {
+    var _link_iconPath;
+    const platform = Aglyn.authorLinkPlatform(link.platform);
+    if (platform) {
+        var _AUTHOR_LINK_ICON_PATHS_platform_icon;
+        return (_AUTHOR_LINK_ICON_PATHS_platform_icon = AUTHOR_LINK_ICON_PATHS[platform.icon]) != null ? _AUTHOR_LINK_ICON_PATHS_platform_icon : mdiLinkVariant.path;
+    }
+    return ((_link_iconPath = link.iconPath) != null ? _link_iconPath : '').trim() || mdiLinkVariant.path;
+}
+/**
+ * Schemes a rendered author link may use — the model's own guard, restated at
+ * the boundary that produces the `href`.
+ *
+ * `normalizeContentAuthorLinks` already drops everything else, and this is
+ * deliberately not trusting that: the props on this component are authorable,
+ * so a link can reach the renderer without ever passing through the store's
+ * normalizer. Two checks, because only one of them is on the path an attacker
+ * would use.
+ */ const SAFE_AUTHOR_LINK_HREF = /^(https:\/\/|mailto:)/i;
+/**
+ * What the byline may link to — an absolute `https:` page, or a route on this
+ * site. The Social Links block guards its hrefs the same way and for the same
+ * reason: the value comes from a stored record, so `javascript:` and friends
+ * have to be unreachable rather than merely unlikely.
+ */ const SAFE_AUTHOR_HREF = /^(https:\/\/|\/(?!\/))/i;
+/** An off-site author page opens in a new tab; a route on this site does not. */ const EXTERNAL_AUTHOR_HREF = /^https:\/\//i;
+/**
+ * The author's profile links as a row of marks (AGL-2516).
+ *
+ * Shared by the article's Entry Author card and the Author Profile block on
+ * the author's own page (AGL-2518) — the one part of the two that would
+ * genuinely drift, since an icon row is where the accessible-name rule and
+ * the `rel` on an off-site profile live.
+ *
+ * Renders nothing for an empty list, so a caller can drop it in
+ * unconditionally rather than guarding at every call site.
+ */ function AuthorLinkRows(props) {
+    if (!props.links.length) return null;
+    return /*#__PURE__*/ _jsx(MuiStack, {
+        direction: "row",
+        spacing: 0.5,
+        sx: {
+            flexWrap: 'wrap',
+            ml: -1
+        },
+        children: props.links.map((link, index)=>{
+            var _link_url, _props_size;
+            const label = Aglyn.authorLinkLabel(link);
+            return /*#__PURE__*/ _jsx(AppLink, {
+                componentVariant: "icon-button",
+                href: ((_link_url = link.url) != null ? _link_url : '').trim(),
+                // The name IS the icon here, so it has to be announced — a row of
+                // unlabelled icon buttons is a row a screen reader reads as
+                // "link, link, link".
+                "aria-label": label,
+                title: label,
+                size: "small",
+                sx: {
+                    color: 'text.secondary'
+                },
+                // A profile lives off this site by definition, and `mailto:` must
+                // not replace the article either.
+                target: "_blank",
+                rel: "noopener noreferrer me",
+                children: /*#__PURE__*/ _jsx(MdiIcon, {
+                    path: authorLinkIconPath(link),
+                    size: (_props_size = props.size) != null ? _props_size : 0.85
+                })
+            }, index);
+        })
+    });
+}
+/**
+ * The rows a card will actually draw, guarded at the boundary.
+ *
+ * These arrive as PROPS, so a link can reach a renderer without ever passing
+ * through the store's normalizer — the reason the byline's own `url` is
+ * checked twice as well.
+ */ function safeAuthorLinks(links, show) {
+    if (show === false) return [];
+    return (links != null ? links : []).filter((link)=>{
+        var _ref;
+        return SAFE_AUTHOR_LINK_HREF.test(((_ref = link == null ? void 0 : link.url) != null ? _ref : '').trim());
+    });
+}
+/**
+ * The author card that closes an article (AGL-2486) — portrait, byline, bio.
+ *
+ * Entry Meta prints a NAME beside a date, which is all an entry carried when
+ * it was written: one free-typed string. Custom authors made the byline a
+ * record with a portrait, a bio and a url, and a template that wanted the
+ * card the article frame draws still had to type the name and the blurb in as
+ * literal text — text that keeps saying whatever it said under posts somebody
+ * else wrote, and that no edit to the author record can ever reach. This is
+ * that card, filled from the record.
+ *
+ * Every field is independently overridable and every one of them collapses
+ * when empty: an author with no portrait renders the text alone rather than a
+ * gap where a face would be, and an entry with no author at all renders
+ * nothing — never an empty bordered box.
+ */ const CollectionEntryAuthor = /*#__PURE__*/ forwardRef((props, ref)=>{
+    // None of these are DOM attributes (`name` least of all), so they are
+    // destructured rather than spread — the stack.ts pattern.
+    const { name, bio, image, url, pageUrl, links, showBio, showAvatar, showLinks } = props, rest = _object_without_properties_loose(props, [
+        "name",
+        "bio",
+        "image",
+        "url",
+        "pageUrl",
+        "links",
+        "showBio",
+        "showAvatar",
+        "showLinks"
+    ]);
+    const nodeSx = Array.isArray(props['sx']) ? props['sx'] : [
+        props['sx']
+    ];
+    const { suppressNavigation } = useContext(Aglyn.ScreenLinkContext);
+    const { hostId } = Aglyn.useSite();
+    const nameValue = metaValue(name, suppressNavigation);
+    const bioValue = showBio !== false ? metaValue(bio, suppressNavigation) : '';
+    // Their page here first, their own site second (AGL-2519) — see `pageUrl`.
+    const hrefRaw = metaValue(pageUrl, suppressNavigation) || metaValue(url, suppressNavigation);
+    const urlValue = SAFE_AUTHOR_HREF.test(hrefRaw) ? hrefRaw : '';
+    // An unresolved token empties on EVERY surface, as in the byline: a literal
+    // `{{…}}` in a src is a broken portrait in the canvas.
+    const imageRaw = (image != null ? image : '').trim();
+    const imageSrc = showAvatar !== false && imageRaw && !UNRESOLVED_TOKEN.test(imageRaw) ? Aglyn.resolveMediaSrc(imageRaw, {
+        hostId
+    }) : '';
+    // Nothing to show and nothing to route from: an editing surface previews
+    // the card's own markup at the author's own settings, and a published page
+    // renders nothing at all (AGL-2486). Every part still answers its own
+    // switch, so a card with Show bio off previews as portrait and name.
+    const sample = !nameValue && !bioValue && !imageSrc && Boolean(suppressNavigation);
+    const displayName = sample ? ENTRY_SAMPLE_AUTHOR : nameValue;
+    const displayBio = sample && showBio !== false ? ENTRY_SAMPLE_BIO : bioValue;
+    // The record's portrait arrives at compose time, so there is none to
+    // resolve on the canvas — the card draws its slot, which is the thing its
+    // spacing is built around.
+    const samplePortrait = sample && showAvatar !== false;
+    /**
+   * The rows this card will actually draw (AGL-2516).
+   *
+   * Guarded here rather than trusted from the store: these arrive as PROPS,
+   * so a link can reach the renderer without passing the record normalizer,
+   * and `javascript:` has to be unreachable rather than merely unlikely — the
+   * same reason the byline's own `url` is checked twice.
+   */ const linkRows = safeAuthorLinks(links, showLinks);
+    if (!displayName && !displayBio && !imageSrc && !samplePortrait && !linkRows.length) {
+        return /*#__PURE__*/ _jsx(Box, _extends({
+            ref: ref
+        }, rest));
+    }
+    return /*#__PURE__*/ _jsxs(MuiStack, _extends({
+        ref: ref,
+        direction: "row",
+        spacing: 2
+    }, rest, {
+        // MERGE, never replace (AGL-1450): `rest.sx` is the array leaf.tsx
+        // builds, and spreading it into an object drops every authored value.
+        sx: [
+            {
+                alignItems: 'flex-start',
+                p: 2.5,
+                border: '1px solid',
+                borderColor: 'divider',
+                borderRadius: 1
+            },
+            ...nodeSx
+        ],
+        children: [
+            imageSrc ? /*#__PURE__*/ _jsx(Box, _extends({
+                component: "img",
+                src: imageSrc,
+                // Decorative: the card names the author in text right beside it.
+                alt: "",
+                sx: {
+                    display: 'block',
+                    flexShrink: 0,
+                    width: AUTHOR_AVATAR_SIZE,
+                    height: AUTHOR_AVATAR_SIZE,
+                    borderRadius: '50%',
+                    objectFit: 'cover'
+                }
+            }, Aglyn.DEFERRED_IMAGE_ATTRIBUTES)) : samplePortrait ? /*#__PURE__*/ _jsx(Box, {
+                "aria-hidden": true,
+                sx: samplePortraitSx(AUTHOR_AVATAR_SIZE)
+            }) : null,
+            /*#__PURE__*/ _jsxs(MuiStack, {
+                spacing: 0.5,
+                sx: {
+                    minWidth: 0
+                },
+                children: [
+                    displayName ? /*#__PURE__*/ _jsx(Typography, {
+                        component: "p",
+                        variant: "subtitle2",
+                        children: urlValue ? /*#__PURE__*/ _jsx(AppLink, _extends({
+                            href: urlValue,
+                            sx: {
+                                color: 'inherit'
+                            },
+                            underline: "hover"
+                        }, EXTERNAL_AUTHOR_HREF.test(urlValue) ? {
+                            target: '_blank',
+                            rel: 'noopener noreferrer'
+                        } : {}, {
+                            children: displayName
+                        })) : displayName
+                    }) : null,
+                    displayBio ? /*#__PURE__*/ _jsx(Typography, {
+                        variant: "body2",
+                        sx: {
+                            color: 'text.secondary'
+                        },
+                        children: displayBio
+                    }) : null,
+                    /*#__PURE__*/ _jsx(AuthorLinkRows, {
+                        links: linkRows
+                    })
+                ]
+            })
+        ]
+    }));
+});
+CollectionEntryAuthor.displayName = 'AglynCollectionEntryAuthor';
+export const collectionEntryAuthorSchema = {
+    $id: ENTRY_AUTHOR_ID,
+    pluginId: BUNDLE_ID,
+    displayName: 'Entry Author',
+    description: 'The author card for an entry — portrait, byline and bio.',
+    category: Aglyn.ComponentCategory.TEXT,
+    icon: {
+        path: mdiAccountCircleOutline.path,
+        sx: {
+            color: 'secondary.main'
+        }
+    },
+    flags: {
+        selfClosing: Aglyn.FEATURE_FLAG.ENABLED
+    },
+    attributes: [
+        {
+            name: 'name',
+            label: 'Name',
+            description: 'Blank shows the name from the entry’s author record. Type here ' + '(or bind {{entry.author}}) to sign this card differently from ' + 'the byline above the article.',
+            component: Aglyn.FieldComponentType.TEXT_FIELD
+        },
+        {
+            name: 'bio',
+            label: 'Bio',
+            description: 'Blank shows the bio from the author’s record. Type here (or bind ' + '{{entry.authorBio}}) only to override it.',
+            component: Aglyn.FieldComponentType.TEXTAREA
+        },
+        {
+            name: 'image',
+            label: 'Portrait',
+            description: 'Blank shows the portrait from the author’s record. Pick from your ' + 'media library with "Browse media" only to override it.',
+            component: Aglyn.FieldComponentType.TEXT_FIELD
+        },
+        {
+            name: 'pageUrl',
+            label: 'Name links to',
+            description: 'Blank sends the name to the author’s page on this site — ' + 'everything they wrote. Falls back to their own url when they have ' + 'no page; type here to override both.',
+            component: Aglyn.FieldComponentType.TEXT_FIELD
+        },
+        {
+            name: 'url',
+            label: 'Their own site',
+            description: 'Blank uses the url on the author’s record. Used only when they ' + 'have no page on this site for the name to link to.',
+            component: Aglyn.FieldComponentType.TEXT_FIELD
+        },
+        {
+            name: 'showLinks',
+            label: 'Show links',
+            description: 'Off hides the author’s profile links. They come from the author ' + 'record — a known platform brings its own mark, and a custom link ' + 'brings the icon and label chosen there.',
+            component: Aglyn.FieldComponentType.SWITCH,
+            // Unset means SHOWN in the renderer above, so the switch has to open
+            // in that position or it lies about the card in front of the author
+            // (AGL-2506).
+            initialValue: true
+        },
+        {
+            name: 'showBio',
+            label: 'Show bio',
+            description: 'Off leaves the card as a portrait and a name — for a masthead ' + 'where the blurb would repeat what the page already says.',
+            component: Aglyn.FieldComponentType.SWITCH,
+            // Unset means SHOWN in the renderer above, so the switch has to
+            // OPEN in that position or it lies about the block in front of
+            // the author — and the first click, which writes the `true` that
+            // was already in effect, changes nothing and reads as a dead
+            // control (AGL-2506).
+            initialValue: true
+        },
+        {
+            name: 'showAvatar',
+            label: 'Show portrait',
+            description: 'Off leaves the text alone, with no space held for a picture.',
+            component: Aglyn.FieldComponentType.SWITCH,
+            // Unset means SHOWN in the renderer above, so the switch has to
+            // OPEN in that position or it lies about the block in front of
+            // the author — and the first click, which writes the `true` that
+            // was already in effect, changes nothing and reads as a dead
+            // control (AGL-2506).
+            initialValue: true
+        }
+    ]
+};
+/** The page subject's portrait — a step up from the card's 48px. */ const PROFILE_AVATAR_SIZE = 96;
+/**
+ * Who an author page is about (AGL-2518) — portrait, name, role, bio, links.
+ *
+ * The Entry Author card renders the same person as a footnote under an
+ * article. This renders them as the SUBJECT of a page, which is why it has
+ * the two fields that card has no room for: `jobTitle` and `worksFor` are
+ * what tell a stranger who they are looking at, and they are already on the
+ * record because `schema.org/Person` defines them (AGL-2486).
+ *
+ * Every field is independently overridable and every one collapses when
+ * empty, exactly as the card's do — an author with no portrait renders the
+ * text alone rather than a gap where a face would be. On an editing surface
+ * the block previews its own shape with sample text, because a template is
+ * designed before any author is routed through it.
+ */ const ContentAuthorProfile = /*#__PURE__*/ forwardRef((props, ref)=>{
+    // None of these are DOM attributes (`name` least of all), so they are
+    // destructured rather than spread — the stack.ts pattern.
+    const { name, bio, image, jobTitle, worksFor, url, links, showBio, showAvatar, showRole, showLinks } = props, rest = _object_without_properties_loose(props, [
+        "name",
+        "bio",
+        "image",
+        "jobTitle",
+        "worksFor",
+        "url",
+        "links",
+        "showBio",
+        "showAvatar",
+        "showRole",
+        "showLinks"
+    ]);
+    const nodeSx = Array.isArray(props['sx']) ? props['sx'] : [
+        props['sx']
+    ];
+    const { suppressNavigation } = useContext(Aglyn.ScreenLinkContext);
+    const { hostId } = Aglyn.useSite();
+    const nameValue = metaValue(name, suppressNavigation);
+    const bioValue = showBio !== false ? metaValue(bio, suppressNavigation) : '';
+    const jobValue = showRole !== false ? metaValue(jobTitle, suppressNavigation) : '';
+    const worksForValue = showRole !== false ? metaValue(worksFor, suppressNavigation) : '';
+    const urlRaw = metaValue(url, suppressNavigation);
+    const urlValue = SAFE_AUTHOR_HREF.test(urlRaw) ? urlRaw : '';
+    // An unresolved token empties on EVERY surface, as in the byline: a literal
+    // `{{…}}` in a src is a broken portrait in the canvas.
+    const imageRaw = (image != null ? image : '').trim();
+    const imageSrc = showAvatar !== false && imageRaw && !UNRESOLVED_TOKEN.test(imageRaw) ? Aglyn.resolveMediaSrc(imageRaw, {
+        hostId
+    }) : '';
+    const linkRows = safeAuthorLinks(links, showLinks);
+    // Nothing routed and nothing typed: an editing surface previews the block's
+    // own markup at its own settings, and a published page renders nothing at
+    // all. Every part still answers its own switch, so a block with Show bio
+    // off previews as portrait and name.
+    const sample = !nameValue && !bioValue && !jobValue && !imageSrc && !linkRows.length && Boolean(suppressNavigation);
+    const displayName = sample ? ENTRY_SAMPLE_AUTHOR : nameValue;
+    const displayBio = sample && showBio !== false ? ENTRY_SAMPLE_BIO : bioValue;
+    const samplePortrait = sample && showAvatar !== false;
+    /**
+   * "Founder at Aglyn" — one line, from two fields, and a middle dot would be
+   * wrong here: this is a phrase, not a list of facts like the byline's
+   * `name · date`. Either field alone still reads.
+   */ const roleLine = [
+        jobValue,
+        worksForValue
+    ].filter(Boolean).join(' at ');
+    if (!displayName && !displayBio && !roleLine && !imageSrc && !samplePortrait && !linkRows.length) {
+        return /*#__PURE__*/ _jsx(Box, _extends({
+            ref: ref
+        }, rest));
+    }
+    return /*#__PURE__*/ _jsxs(MuiStack, _extends({
+        ref: ref,
+        direction: "row",
+        spacing: 3
+    }, rest, {
+        // MERGE, never replace (AGL-1450): `rest.sx` is the array leaf.tsx
+        // builds, and spreading it into an object drops every authored value.
+        sx: [
+            {
+                alignItems: 'flex-start'
+            },
+            ...nodeSx
+        ],
+        children: [
+            imageSrc ? /*#__PURE__*/ _jsx(Box, _extends({
+                component: "img",
+                src: imageSrc,
+                // Decorative: the block names the author in text right beside it.
+                alt: "",
+                sx: {
+                    display: 'block',
+                    flexShrink: 0,
+                    width: PROFILE_AVATAR_SIZE,
+                    height: PROFILE_AVATAR_SIZE,
+                    borderRadius: '50%',
+                    objectFit: 'cover'
+                }
+            }, Aglyn.DEFERRED_IMAGE_ATTRIBUTES)) : samplePortrait ? /*#__PURE__*/ _jsx(Box, {
+                "aria-hidden": true,
+                sx: samplePortraitSx(PROFILE_AVATAR_SIZE)
+            }) : null,
+            /*#__PURE__*/ _jsxs(MuiStack, {
+                spacing: 1,
+                sx: {
+                    minWidth: 0
+                },
+                children: [
+                    displayName ? // `h1` because the author IS this page's subject — the one heading
+                    // rule a built-in body has to get right, since the template around
+                    // it cannot know what the block will be handed.
+                    /*#__PURE__*/ _jsx(Typography, {
+                        component: "h1",
+                        variant: "h4",
+                        children: urlValue ? /*#__PURE__*/ _jsx(AppLink, _extends({
+                            href: urlValue,
+                            sx: {
+                                color: 'inherit'
+                            },
+                            underline: "hover"
+                        }, EXTERNAL_AUTHOR_HREF.test(urlValue) ? {
+                            target: '_blank',
+                            rel: 'noopener noreferrer'
+                        } : {}, {
+                            children: displayName
+                        })) : displayName
+                    }) : null,
+                    roleLine ? /*#__PURE__*/ _jsx(Typography, {
+                        variant: "subtitle2",
+                        sx: {
+                            color: 'text.secondary'
+                        },
+                        children: roleLine
+                    }) : null,
+                    displayBio ? /*#__PURE__*/ _jsx(Typography, {
+                        variant: "body1",
+                        sx: {
+                            color: 'text.secondary'
+                        },
+                        children: displayBio
+                    }) : null,
+                    /*#__PURE__*/ _jsx(AuthorLinkRows, {
+                        links: linkRows,
+                        size: 1
+                    })
+                ]
+            })
+        ]
+    }));
+});
+ContentAuthorProfile.displayName = 'AglynContentAuthorProfile';
+export { ContentAuthorProfile };
+export const contentAuthorProfileSchema = {
+    $id: AUTHOR_PROFILE_ID,
+    pluginId: BUNDLE_ID,
+    displayName: 'Author Profile',
+    description: 'Who an author page is about — portrait, name, role, bio and links.',
+    category: Aglyn.ComponentCategory.TEXT,
+    icon: {
+        path: mdiAccountCircleOutline.path,
+        sx: {
+            color: 'secondary.main'
+        }
+    },
+    flags: {
+        selfClosing: Aglyn.FEATURE_FLAG.ENABLED
+    },
+    attributes: [
+        {
+            name: 'name',
+            label: 'Name',
+            description: 'Blank shows the name of the author whose page this is. Type here ' + '(or bind {{author.name}}) only to override it.',
+            component: Aglyn.FieldComponentType.TEXT_FIELD
+        },
+        {
+            name: 'bio',
+            label: 'Bio',
+            description: 'Blank shows the bio from the author’s record. Type here (or bind ' + '{{author.bio}}) only to override it.',
+            component: Aglyn.FieldComponentType.TEXTAREA
+        },
+        {
+            name: 'image',
+            label: 'Portrait',
+            description: 'Blank shows the portrait of the author whose page this is, at the ' + 'larger size a profile takes. Pick from your media library only to ' + 'override it.',
+            component: Aglyn.FieldComponentType.TEXT_FIELD
+        },
+        {
+            name: 'jobTitle',
+            label: 'Role',
+            description: 'Blank shows the job title from the author’s record. Only a person ' + 'has one — an author record set to Organization leaves it empty.',
+            component: Aglyn.FieldComponentType.TEXT_FIELD
+        },
+        {
+            name: 'worksFor',
+            label: 'Organization',
+            description: 'Blank shows who the author writes for, from their record. Shown ' + 'after the role as "Role at Organization".',
+            component: Aglyn.FieldComponentType.TEXT_FIELD
+        },
+        {
+            name: 'url',
+            label: 'Link',
+            description: 'Blank uses the author’s own url. The name links here; with no url ' + 'it renders as plain text. This block is already the author’s page ' + 'on this site, so it never links to itself.',
+            component: Aglyn.FieldComponentType.TEXT_FIELD
+        },
+        {
+            name: 'showLinks',
+            label: 'Show links',
+            description: 'Off hides the row of profile links under the bio — the place a ' + 'reader follows this author elsewhere. Turning it off on a page ' + 'about them is rarely what you want.',
+            component: Aglyn.FieldComponentType.SWITCH,
+            // Unset means SHOWN in the renderer above, so the switch has to open
+            // in that position or it lies about the block in front of the author
+            // (AGL-2506).
+            initialValue: true
+        },
+        {
+            name: 'showBio',
+            label: 'Show bio',
+            description: 'Off leaves the block as a portrait, a name and a role.',
+            component: Aglyn.FieldComponentType.SWITCH,
+            initialValue: true
+        },
+        {
+            name: 'showRole',
+            label: 'Show role',
+            description: 'Off hides the "Role at Organization" line under the name.',
+            component: Aglyn.FieldComponentType.SWITCH,
+            initialValue: true
+        },
+        {
+            name: 'showAvatar',
+            label: 'Show portrait',
+            description: 'Off drops the portrait and lets the name and bio run the full ' + 'width, with no space held for a picture.',
+            component: Aglyn.FieldComponentType.SWITCH,
+            initialValue: true
+        }
+    ]
+};
+/** Pill look, in palette tokens so it follows the site theme in both modes. */ const pillSx = (active)=>({
+        px: 1.75,
+        py: 0.75,
+        borderRadius: 999,
+        border: '1px solid',
+        borderColor: active ? 'primary.main' : 'divider',
+        bgcolor: active ? 'primary.main' : 'transparent',
+        color: active ? 'primary.contrastText' : 'text.secondary',
+        fontSize: 14,
+        lineHeight: 1.2,
+        whiteSpace: 'nowrap',
+        '&:hover': {
+            borderColor: active ? 'primary.main' : 'text.primary',
+            color: active ? 'primary.contrastText' : 'text.primary'
+        }
+    });
+/**
+ * The category filter row for a collection listing (AGL-1321): "All" plus one
+ * pill per category, each a REAL anchor to `/{collection}/category/{slug}`.
+ *
+ * Anchors, not click handlers, and that is the whole design. A JS-only toggle
+ * would be invisible to crawlers, unopenable in a new tab, unlinkable, and
+ * unreachable without hydration — and it could not exist anyway, since the
+ * filter is resolved server-side before the page is composed. The pill the
+ * current URL selected carries `aria-current="page"`, stamped on the server so
+ * it is in the HTML rather than derived after hydration.
+ */ const CollectionCategories = /*#__PURE__*/ forwardRef((props, ref)=>{
+    // `collectionSlug`/`allLabel` are compose-time: the tenant resolves them
+    // while stamping `items`; strip so they never hit the DOM.
+    const { collectionSlug, allLabel, items } = props, rest = _object_without_properties_loose(props, [
+        "collectionSlug",
+        "allLabel",
+        "items"
+    ]);
+    // Node styles ride the renderer-merged sx; recompose (stack.ts pattern).
+    const nodeSx = Array.isArray(props['sx']) ? props['sx'] : [
+        props['sx']
+    ];
+    const { suppressNavigation } = useContext(Aglyn.ScreenLinkContext);
+    if (!(items == null ? void 0 : items.length)) {
+        if (!suppressNavigation) return /*#__PURE__*/ _jsx(Box, _extends({
+            ref: ref
+        }, rest));
+        return /*#__PURE__*/ _jsx(Box, _extends({
+            ref: ref
+        }, rest, {
+            sx: [
+                {
+                    p: 2,
+                    border: '1px dashed',
+                    borderColor: 'divider',
+                    color: 'text.secondary',
+                    fontSize: 12,
+                    fontFamily: 'system-ui, sans-serif'
+                },
+                ...nodeSx
+            ],
+            children: 'Category pills — All + one pill per collection category render here'
+        }));
+    }
+    return /*#__PURE__*/ _jsx(MuiStack, _extends({
+        ref: ref,
+        direction: "row",
+        spacing: 1
+    }, rest, {
+        // MERGE, never replace (AGL-1450) — see Entry Meta above.
+        sx: [
+            {
+                flexWrap: 'wrap',
+                rowGap: 1
+            },
+            ...nodeSx
+        ],
+        children: items.map((item)=>// Editing surfaces render the pill look without an href, so a click
+            // in the besigner never navigates the canvas away.
+            suppressNavigation ? /*#__PURE__*/ _jsx(Box, {
+                sx: pillSx(item.active),
+                children: item.label
+            }, item.href) : /*#__PURE__*/ _jsx(AppLink, {
+                href: item.href,
+                underline: "none",
+                "aria-current": item.active ? 'page' : undefined,
+                sx: pillSx(item.active),
+                children: item.label
+            }, item.href))
+    }));
+});
+CollectionCategories.displayName = 'AglynCollectionCategories';
+export const collectionCategoriesSchema = {
+    $id: CATEGORIES_ID,
+    pluginId: BUNDLE_ID,
+    displayName: 'Category Pills',
+    description: 'A pill per collection category, each filtering the listing.',
+    category: Aglyn.ComponentCategory.NAVIGATION,
+    icon: {
+        path: mdiTagMultipleOutline.path,
+        sx: {
+            color: 'secondary.main'
+        }
+    },
+    flags: {
+        selfClosing: Aglyn.FEATURE_FLAG.ENABLED
+    },
+    attributes: [
+        {
+            name: 'collectionSlug',
+            label: 'Collection slug',
+            description: 'Content collection whose categories render as pills (e.g. ' + '"blog"). Leave blank on a list-template screen to use the ' + 'collection from the URL.',
+            component: Aglyn.FieldComponentType.TEXT_FIELD
+        },
+        {
+            name: 'allLabel',
+            label: 'All label',
+            description: 'Label for the unfiltered pill, which links to the collection ' + 'root (default "All"). Clear the box to omit that pill — it then ' + 'reads "none", which is what makes the omission stick. Typing ' + '"none" does the same thing.',
+            component: Aglyn.FieldComponentType.TEXT_FIELD,
+            // Without this the emptied field persists NOTHING (AGL-1336): ddf
+            // maps an emptied value to `clearedValue`, final-form's parse turns
+            // `''` into `undefined`, and the missing key takes the runtime
+            // default — so "clear it to omit that pill" was undoable by
+            // clicking. Same shape as FIELD_COLOR_ALT1's `'default'` (AGL-1191):
+            // a value that means something has to BE something.
+            //
+            // ddf only substitutes `clearedValue` when the field HAD an initial
+            // value (`enhancedOnChange`'s `typeof initial !== 'undefined'`),
+            // which is why the preset below seeds `allLabel` and why the
+            // sentinel is a word an author can also type. A block that never
+            // carried the prop has an already-empty box and nothing to clear.
+            clearedValue: Aglyn.COLLECTION_ALL_PILL_NONE
+        }
+    ]
+};
+/**
+ * A search box for a collection that lives where the author puts it
+ * (AGL-1516, Figma 494:1220).
+ *
+ * The entries block has had a search box since AGL-1516's first half, and it
+ * renders inside that block — first child of its own stack. The frame puts
+ * the field in the listing's TOOLBAR: category pills on the left, search and
+ * RSS on the right, one row. That was unbuildable, and unbuildable in both
+ * directions — a block's own child cannot be lifted out of it, and the pills
+ * cannot be moved in, because every child of an entries block is cloned once
+ * per entry. Three passes of authoring hit the same wall.
+ *
+ * So the field became its own block. It searches the collection the listing
+ * beside it is drawn from, and answers with the suggestion panel (496:1218)
+ * — the only behaviour a standalone box can honestly have, since it owns no
+ * cards to hide. Enter submits to the site-wide results page, so the box
+ * works with no JavaScript at all.
+ *
+ * Inert on editing surfaces, like Category Pills: the besigner has no index
+ * to search, and a field that answered there would be answering about
+ * nothing.
+ */ const CollectionSearch = /*#__PURE__*/ forwardRef((props, ref)=>{
+    // Compose-time and search-only attributes: strip so they never hit the
+    // DOM.
+    const { collectionSlug, searchPlaceholder, searchIndex, searchTotal, searchCapped } = props, rest = _object_without_properties_loose(props, [
+        "collectionSlug",
+        "searchPlaceholder",
+        "searchIndex",
+        "searchTotal",
+        "searchCapped"
+    ]);
+    // Node styles ride the renderer-merged sx; recompose (stack.ts pattern).
+    const nodeSx = Array.isArray(props['sx']) ? props['sx'] : [
+        props['sx']
+    ];
+    const { suppressNavigation } = useContext(Aglyn.ScreenLinkContext);
+    const fuzzy = useMemo(()=>(searchIndex == null ? void 0 : searchIndex.length) ? new Fuse(searchIndex, _extends({}, Aglyn.COLLECTION_SEARCH_FUSE_OPTIONS)) : null, [
+        searchIndex
+    ]);
+    if (!suppressNavigation && !fuzzy) {
+        // Nothing stamped on a live surface: an unknown collection, an empty
+        // one, or a page composed before this block existed. Renders NOTHING
+        // rather than a field that can only ever answer "no matches" — that
+        // answer would read as a fact about the reader's query instead of
+        // about the absent index behind it.
+        return /*#__PURE__*/ _jsx(Box, _extends({
+            ref: ref
+        }, rest));
+    }
+    return /*#__PURE__*/ _jsx(MuiStack, _extends({
+        ref: ref
+    }, rest, {
+        sx: [
+            {
+                alignItems: 'flex-end'
+            },
+            ...nodeSx
+        ],
+        children: /*#__PURE__*/ _jsx(SuggestSearchBox, _extends({
+            fuzzy: fuzzy
+        }, searchIndex ? {
+            items: searchIndex
+        } : {}, searchPlaceholder === undefined ? {} : {
+            placeholder: searchPlaceholder
+        }, suppressNavigation ? {
+            inert: true
+        } : {}, {
+            // The honest miss for THIS box. It searched one bounded read of the
+            // collection — never "the collection", and on a category route not
+            // even the whole of it, because the source arrives filtered. So it
+            // reports the number it actually looked through, and says plainly
+            // when that number was a ceiling rather than a total.
+            emptyText: (text)=>{
+                var _ref, _ref1;
+                return searchCapped ? `No matches for “${text}” in the ${(_ref = searchIndex == null ? void 0 : searchIndex.length) != null ? _ref : 0} ` + 'entries searched here — the collection holds more, which ' + 'this box has not read.' : `No matches for “${text}” in the ${(_ref1 = searchIndex == null ? void 0 : searchIndex.length) != null ? _ref1 : 0} ` + 'entries searched here.';
+            }
+        }))
+    }));
+});
+CollectionSearch.displayName = 'AglynCollectionSearch';
+export const collectionSearchSchema = {
+    $id: SEARCH_ID,
+    pluginId: BUNDLE_ID,
+    displayName: 'Collection Search',
+    description: 'A search box for a content collection, with a suggestions dropdown.',
+    category: Aglyn.ComponentCategory.NAVIGATION,
+    icon: {
+        path: mdiMagnify.path,
+        sx: {
+            color: 'secondary.main'
+        }
+    },
+    flags: {
+        selfClosing: Aglyn.FEATURE_FLAG.ENABLED
+    },
+    attributes: [
+        {
+            name: 'collectionSlug',
+            label: 'Collection slug',
+            description: 'Content collection this box searches (e.g. "blog"). Leave blank ' + 'on a list-template screen to use the collection from the URL.',
+            component: Aglyn.FieldComponentType.TEXT_FIELD
+        },
+        {
+            name: 'searchPlaceholder',
+            label: 'Search placeholder',
+            description: 'Hint text inside this box. Blank shows "Search posts…", which is ' + 'worth changing when the collection is not posts.',
+            component: Aglyn.FieldComponentType.TEXT_FIELD
+        }
+    ]
+};
+/* ── Presets ────────────────────────────────────────────────────────────── */ /**
+ * Styling rides the node's own `sx`, never `props.sx` (AGL-1346): both
+ * render, but only `node.sx` is the record the Styles panel can edit or
+ * clear. `Leaf` composes `node.sx` last, so this is the same result.
+ */ const entryText = (variant, children, extra)=>{
+    const _ref = extra != null ? extra : {}, { sx } = _ref, props = _object_without_properties_loose(_ref, [
+        "sx"
+    ]);
+    return _extends({
+        $id: null,
+        componentId: 'muiTypography',
+        pluginId: BUNDLE_ID,
+        props: _extends({
+            variant,
+            children
+        }, props)
+    }, sx ? {
+        sx
+    } : {});
+};
+export const collectionPresets = [
+    {
+        $id: generatePresetId(ENTRIES_ID),
+        type: Aglyn.NodeType.PRESET,
+        displayName: 'Collection Entries',
+        pluginId: BUNDLE_ID,
+        description: 'Repeats a card (title, date, excerpt, Read more) per published ' + 'entry of a content collection',
+        category: Aglyn.ComponentCategory.BLOCKS,
+        icon: {
+            path: mdiPostOutline.path,
+            sx: {
+                color: 'secondary.main'
+            }
+        },
+        data: {
+            $id: null,
+            componentId: ENTRIES_ID,
+            pluginId: BUNDLE_ID,
+            props: {
+                spacing: 4
+            },
+            nodes: [
+                {
+                    $id: null,
+                    componentId: 'muiStack',
+                    pluginId: BUNDLE_ID,
+                    props: {
+                        spacing: 0.5
+                    },
+                    nodes: [
+                        entryText('h5', '{{entry.title}}', {
+                            component: 'h2'
+                        }),
+                        entryText('caption', '{{entry.date}}', {
+                            sx: {
+                                color: 'text.secondary'
+                            }
+                        }),
+                        entryText('body1', '{{entry.excerpt}}'),
+                        {
+                            $id: null,
+                            componentId: 'muiScreenLink',
+                            pluginId: BUNDLE_ID,
+                            props: {
+                                children: 'Read more',
+                                href: '{{entry.url}}',
+                                size: 'small'
+                            },
+                            sx: {
+                                alignSelf: 'flex-start'
+                            }
+                        }
+                    ]
+                }
+            ]
+        }
+    },
+    {
+        $id: generatePresetId(ENTRY_BODY_ID),
+        type: Aglyn.NodeType.PRESET,
+        displayName: 'Entry Body',
+        pluginId: BUNDLE_ID,
+        description: "Renders the current entry's markdown body, themed",
+        category: Aglyn.ComponentCategory.TEXT,
+        icon: {
+            path: mdiTextLong.path,
+            sx: {
+                color: 'secondary.main'
+            }
+        },
+        data: {
+            $id: null,
+            componentId: ENTRY_BODY_ID,
+            pluginId: BUNDLE_ID,
+            props: {
+                markdown: '{{entry.body}}'
+            }
+        }
+    },
+    {
+        $id: generatePresetId(RELATED_ID),
+        type: Aglyn.NodeType.PRESET,
+        displayName: 'Related Posts',
+        pluginId: BUNDLE_ID,
+        description: "Other entries sharing the current entry's category or tags",
+        category: Aglyn.ComponentCategory.DATA_DISPLAY,
+        icon: {
+            path: mdiNewspaperVariantOutline.path,
+            sx: {
+                color: 'secondary.main'
+            }
+        },
+        data: {
+            $id: null,
+            componentId: RELATED_ID,
+            pluginId: BUNDLE_ID,
+            // `layout`, the two type steps and `dateFormat` are seeded rather than
+            // left to the runtime fallback so each dropdown opens on the value the
+            // block is actually rendering, and an author who tries another has a
+            // named route back (AGL-1457/AGL-1459). The `show*` switches are
+            // deliberately absent: their unset state IS the shipped behaviour.
+            props: {
+                heading: 'Related articles',
+                limit: 3,
+                layout: 'list',
+                headingVariant: 'h5',
+                titleVariant: 'subtitle1',
+                dateFormat: Aglyn.COLLECTION_ENTRY_DATE_FORMAT_DEFAULT
+            }
+        }
+    },
+    {
+        $id: generatePresetId(SHARE_ID),
+        type: Aglyn.NodeType.PRESET,
+        displayName: 'Share Bar',
+        pluginId: BUNDLE_ID,
+        description: 'X, LinkedIn, Facebook, and copy-link buttons for the page',
+        category: Aglyn.ComponentCategory.NAVIGATION,
+        icon: {
+            path: mdiShareVariant.path,
+            sx: {
+                color: 'secondary.main'
+            }
+        },
+        data: {
+            $id: null,
+            componentId: SHARE_ID,
+            pluginId: BUNDLE_ID,
+            props: {
+                heading: 'Share'
+            }
+        }
+    },
+    {
+        $id: generatePresetId(CATEGORIES_ID),
+        type: Aglyn.NodeType.PRESET,
+        displayName: 'Category Pills',
+        pluginId: BUNDLE_ID,
+        description: "Links to each of the collection's categories, filtering the listing",
+        category: Aglyn.ComponentCategory.NAVIGATION,
+        icon: {
+            path: mdiTagMultipleOutline.path,
+            sx: {
+                color: 'secondary.main'
+            }
+        },
+        data: {
+            $id: null,
+            componentId: CATEGORIES_ID,
+            pluginId: BUNDLE_ID,
+            // Seeded, not left to the runtime default: an explicit initial value
+            // is what lets the attributes form substitute the cleared sentinel
+            // when the author empties the box (AGL-1336).
+            props: {
+                allLabel: Aglyn.COLLECTION_ALL_PILL_DEFAULT
+            }
+        }
+    },
+    {
+        // Every author-placeable component needs a preset: the element drawer is
+        // built from PRESETS alone (`ComponentManager.schemasByCategory` iterates
+        // `this.presets`), so a component with only a schema renders correctly
+        // once a node exists but can never be put on a canvas by clicking.
+        //
+        // This one earns its place in the drawer because the entries block's own
+        // search field cannot leave that block, and the toolbar row wants the
+        // search beside the category pills rather than above the entries.
+        $id: generatePresetId(SEARCH_ID),
+        type: Aglyn.NodeType.PRESET,
+        displayName: 'Collection Search',
+        pluginId: BUNDLE_ID,
+        description: 'Search box for a collection, with a dropdown of matching entries',
+        category: Aglyn.ComponentCategory.NAVIGATION,
+        icon: {
+            path: mdiMagnify.path,
+            sx: {
+                color: 'secondary.main'
+            }
+        },
+        data: {
+            $id: null,
+            componentId: SEARCH_ID,
+            pluginId: BUNDLE_ID,
+            // Deliberately no seeded props. Both attributes read blank as a real
+            // choice — `collectionSlug` blank means "take the collection from the
+            // URL", which is correct on the list templates this block is for, and
+            // `searchPlaceholder` blank means the designed "Search posts…".
+            props: {}
+        }
+    },
+    {
+        $id: generatePresetId(ENTRY_META_ID),
+        type: Aglyn.NodeType.PRESET,
+        displayName: 'Entry Meta',
+        pluginId: BUNDLE_ID,
+        description: 'Author · date · category line with tag chips for the entry',
+        category: Aglyn.ComponentCategory.TEXT,
+        icon: {
+            path: mdiTagOutline.path,
+            sx: {
+                color: 'secondary.main'
+            }
+        },
+        data: {
+            $id: null,
+            componentId: ENTRY_META_ID,
+            pluginId: BUNDLE_ID,
+            props: {
+                date: '{{entry.date}}',
+                // Named rather than left to the runtime fallback (AGL-1459): the
+                // dropdown opens on the value the block is actually rendering, and
+                // an author who tries a format has a named route back. `default` is
+                // also the fallback, so naming it is the same choice, not a second.
+                dateFormat: Aglyn.COLLECTION_ENTRY_DATE_FORMAT_DEFAULT,
+                author: '{{entry.author}}',
+                category: '{{entry.category}}',
+                tags: '{{entry.tags}}'
+            }
+        }
+    },
+    {
+        $id: generatePresetId(ENTRY_AUTHOR_ID),
+        type: Aglyn.NodeType.PRESET,
+        displayName: 'Entry Author',
+        pluginId: BUNDLE_ID,
+        description: 'Portrait, byline and bio card for the entry’s author',
+        category: Aglyn.ComponentCategory.TEXT,
+        icon: {
+            path: mdiAccountCircleOutline.path,
+            sx: {
+                color: 'secondary.main'
+            }
+        },
+        data: {
+            $id: null,
+            componentId: ENTRY_AUTHOR_ID,
+            pluginId: BUNDLE_ID,
+            // Seeded EMPTY, unlike Entry Meta's preset. Those bindings predate the
+            // server fill and stay for compatibility; here the fill is the only
+            // mechanism, and a seeded `{{entry.authorImage}}` would render a broken
+            // portrait on every surface that is not an entry template.
+            props: {}
+        }
+    },
+    {
+        $id: generatePresetId(AUTHOR_PROFILE_ID),
+        type: Aglyn.NodeType.PRESET,
+        displayName: 'Author Profile',
+        pluginId: BUNDLE_ID,
+        description: 'Portrait, name, role, bio and links for an author page',
+        category: Aglyn.ComponentCategory.TEXT,
+        icon: {
+            path: mdiAccountCircleOutline.path,
+            sx: {
+                color: 'secondary.main'
+            }
+        },
+        data: {
+            $id: null,
+            componentId: AUTHOR_PROFILE_ID,
+            pluginId: BUNDLE_ID,
+            // Seeded EMPTY, for the reason the card above it is: the server fill is
+            // the only mechanism here, and a seeded `{{author.image}}` would render
+            // a broken portrait on every surface that is not an author page.
+            props: {}
+        }
+    }
+];
+export { CollectionCategories, CollectionEntries, CollectionEntryAuthor, CollectionEntryBody, CollectionEntryMeta, CollectionRelated, CollectionSearch, CollectionShare,  };
+export default CollectionEntries;
+
+//# sourceMappingURL=collection.js.map