@aglyn/tenant-runtime 1.0.0-beta.143

package/src/lib/emit-host-event.js

@@ -0,0 +1,30 @@
+/**
+ * @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 { runHostEventListeners } from "./host-event-listeners.js";
+/**
+ * One emit point for host events (AGL-148): hands the event to every
+ * registered host-event listener (see `host-event-listeners.ts`) and returns
+ * the site alerts they produced, so request/response emitters (form submit,
+ * booking) can surface them; fire-and-forget emitters ignore the result. No
+ * listener throws into the emitting request.
+ */ export async function emitHostEvent(hostId, event, payload = {}) {
+    return {
+        alerts: await runHostEventListeners(hostId, event, payload)
+    };
+}
+export default emitHostEvent;
+
+//# sourceMappingURL=emit-host-event.js.map

package/src/lib/emit-host-event.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../libs/tenant/runtime/src/lib/emit-host-event.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2026 Aglyn LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport type { HostActionAlert, HostEventType } from '@aglyn/aglyn/server'\nimport {\n  type HostEventPayload,\n  runHostEventListeners,\n} from './host-event-listeners'\n\n/**\n * One emit point for host events (AGL-148): hands the event to every\n * registered host-event listener (see `host-event-listeners.ts`) and returns\n * the site alerts they produced, so request/response emitters (form submit,\n * booking) can surface them; fire-and-forget emitters ignore the result. No\n * listener throws into the emitting request.\n */\nexport async function emitHostEvent(\n  hostId: string,\n  event: HostEventType,\n  payload: HostEventPayload = {},\n): Promise<{ alerts: HostActionAlert[] }> {\n  return { alerts: await runHostEventListeners(hostId, event, payload) }\n}\n\nexport default emitHostEvent\n"],"names":["runHostEventListeners","emitHostEvent","hostId","event","payload","alerts"],"mappings":"AAAA;;;;;;;;;;;;;;;CAeC,GAGD,SAEEA,qBAAqB,QAChB,4BAAwB;AAE/B;;;;;;CAMC,GACD,OAAO,eAAeC,cACpBC,MAAc,EACdC,KAAoB,EACpBC,UAA4B,CAAC,CAAC;IAE9B,OAAO;QAAEC,QAAQ,MAAML,sBAAsBE,QAAQC,OAAOC;IAAS;AACvE;AAEA,eAAeH,cAAa"}

package/src/lib/enrich-gated-page.d.ts

@@ -0,0 +1,67 @@
+/**
+ * @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.
+ */
+/**
+ * The enricher slice for a screen whose nodes are withheld from the page and
+ * fetched after a gate opens (AGL-2510) — a password-protected screen
+ * (AGL-87) and a members-only one (AGL-109).
+ *
+ * ## Why these two need their own call
+ *
+ * Every other rendered page gets its enricher props from the loader, but
+ * these two deliberately ship `nodes: null`: embedding a gated tree in static
+ * HTML would publish the very content the gate exists to withhold. So the
+ * page arrives with the built-in prompt and no site chrome at all, and the
+ * composed tree — the site's shared layout, nav and footer included — is
+ * swapped in by the client once the visitor gets past the gate. A nav menu
+ * built from primitives opens through `clientAutomations`, which is enricher
+ * output, so without this the unlocked page renders the site's nav and none
+ * of its behavior.
+ *
+ * Delivering it WITH the nodes is what keeps the gate honest. The slice is
+ * derived from the withheld tree and describes its structure; shipping it in
+ * the public HTML alongside `nodes: null` would leak an outline of the page
+ * to anyone who never answers the prompt.
+ *
+ * ## The path
+ *
+ * Taken from the host's own routing map rather than from the caller, because
+ * both callers are POST endpoints a visitor controls: a supplied path would
+ * let anyone pick which overlays and path-scoped automations a gated page
+ * runs. A screen missing from the map (never routed) gets the site root,
+ * which is what an unrouted screen's own address would be.
+ *
+ * ## The entry links
+ *
+ * `entryRoutes` rides along when the tree links to a live content entry
+ * (AGL-3118), and the client adds those keys to the page's routing map — see
+ * {@link gatedEntryLinkRoutes}.
+ *
+ * Fail-open to `{}` — an enricher slice is behavior on top of a page, and no
+ * failure here may cost a visitor the content they just unlocked.
+ */
+export declare function enrichGatedScreenPage(options: {
+    hostId: string;
+    screenId: string;
+    screen: any;
+    nodes: any;
+    /**
+     * The site document, when the caller already read it to compose `nodes`
+     * (AGL-2883). Read here when absent.
+     */
+    host?: Record<string, unknown> | null;
+}): Promise<Record<string, unknown>>;
+export default enrichGatedScreenPage;

package/src/lib/enrich-gated-page.js

@@ -0,0 +1,134 @@
+import { _ as _extends } from "@swc/helpers/_/_extends";
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ import * as Aglyn from "@aglyn/aglyn/server";
+import { getHostDocAdmin, getOrgForHost } from "@aglyn/tenant-data-admin";
+/**
+ * Where the entries a gated tree links to are served (AGL-3118), or
+ * `undefined` when it names none that are live.
+ *
+ * The page's routing map was built before the gate opened, from a tree it
+ * did not have, so it holds no entry a gated page links to; these travel
+ * with the nodes for the reason the enricher slice does. A tree that names
+ * no entry costs no read.
+ *
+ * Never rejects, so the caller can start it early and abandon it on a
+ * failure of its own.
+ *
+ * The two readers it needs are loaded HERE rather than imported at the top of
+ * this file. Both reach `withRenderCache` and through it `next/cache`, which
+ * drags Next's server runtime into the module graph of everything that
+ * imports this enricher — including the commerce plugin, whose specs then
+ * fail to load at all. Loading them inside the one branch that reads also
+ * means a gated tree naming no entry pays for neither.
+ */ async function gatedEntryLinkRoutes(hostId, nodes) {
+    try {
+        const refs = Aglyn.collectEntryLinkRefs({
+            nodes: [
+                nodes
+            ]
+        });
+        if (!refs.length) return undefined;
+        const [{ getTemplateScreenRouting }, { resolveEntryLinkRoutes }] = await Promise.all([
+            import("./template-screens.js"),
+            import("./entry-link-routes.js")
+        ]);
+        const routing = await getTemplateScreenRouting({
+            hostId
+        });
+        const routes = await resolveEntryLinkRoutes({
+            hostId,
+            refs,
+            collectionSlugs: routing.collectionListings
+        });
+        return Object.keys(routes).length ? routes : undefined;
+    } catch (error) {
+        console.error('gated page entry links failed', error);
+        return undefined;
+    }
+}
+/**
+ * The enricher slice for a screen whose nodes are withheld from the page and
+ * fetched after a gate opens (AGL-2510) — a password-protected screen
+ * (AGL-87) and a members-only one (AGL-109).
+ *
+ * ## Why these two need their own call
+ *
+ * Every other rendered page gets its enricher props from the loader, but
+ * these two deliberately ship `nodes: null`: embedding a gated tree in static
+ * HTML would publish the very content the gate exists to withhold. So the
+ * page arrives with the built-in prompt and no site chrome at all, and the
+ * composed tree — the site's shared layout, nav and footer included — is
+ * swapped in by the client once the visitor gets past the gate. A nav menu
+ * built from primitives opens through `clientAutomations`, which is enricher
+ * output, so without this the unlocked page renders the site's nav and none
+ * of its behavior.
+ *
+ * Delivering it WITH the nodes is what keeps the gate honest. The slice is
+ * derived from the withheld tree and describes its structure; shipping it in
+ * the public HTML alongside `nodes: null` would leak an outline of the page
+ * to anyone who never answers the prompt.
+ *
+ * ## The path
+ *
+ * Taken from the host's own routing map rather than from the caller, because
+ * both callers are POST endpoints a visitor controls: a supplied path would
+ * let anyone pick which overlays and path-scoped automations a gated page
+ * runs. A screen missing from the map (never routed) gets the site root,
+ * which is what an unrouted screen's own address would be.
+ *
+ * ## The entry links
+ *
+ * `entryRoutes` rides along when the tree links to a live content entry
+ * (AGL-3118), and the client adds those keys to the page's routing map — see
+ * {@link gatedEntryLinkRoutes}.
+ *
+ * Fail-open to `{}` — an enricher slice is behavior on top of a page, and no
+ * failure here may cost a visitor the content they just unlocked.
+ */ export async function enrichGatedScreenPage(options) {
+    const { hostId, screenId, screen, nodes } = options;
+    try {
+        var _ref;
+        // Started first: its reads share nothing with the enrichers'.
+        const entryRoutesPromise = gatedEntryLinkRoutes(hostId, nodes);
+        const [host, orgRes] = await Promise.all([
+            options.host !== undefined ? options.host : getHostDocAdmin(hostId),
+            getOrgForHost(hostId)
+        ]);
+        const routing = (_ref = host == null ? void 0 : host.screens) != null ? _ref : {};
+        const path = routing[screenId] || Aglyn.SCREEN_ROOT_PATH;
+        const enriched = await Aglyn.runSitePageEnrichers({
+            hostId,
+            host,
+            org: orgRes == null ? void 0 : orgRes.org,
+            path,
+            slugSegments: path.split('/').filter(Boolean),
+            screenId,
+            screen,
+            nodes
+        });
+        const entryRoutes = await entryRoutesPromise;
+        return entryRoutes ? _extends({}, enriched.props, {
+            entryRoutes
+        }) : enriched.props;
+    } catch (error) {
+        console.error('gated page enrichment failed', error);
+        return {};
+    }
+}
+export default enrichGatedScreenPage;
+
+//# sourceMappingURL=enrich-gated-page.js.map

package/src/lib/enrich-gated-page.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../libs/tenant/runtime/src/lib/enrich-gated-page.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2026 Aglyn LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport * as Aglyn from '@aglyn/aglyn/server'\nimport { getHostDocAdmin, getOrgForHost } from '@aglyn/tenant-data-admin'\n\n/**\n * Where the entries a gated tree links to are served (AGL-3118), or\n * `undefined` when it names none that are live.\n *\n * The page's routing map was built before the gate opened, from a tree it\n * did not have, so it holds no entry a gated page links to; these travel\n * with the nodes for the reason the enricher slice does. A tree that names\n * no entry costs no read.\n *\n * Never rejects, so the caller can start it early and abandon it on a\n * failure of its own.\n *\n * The two readers it needs are loaded HERE rather than imported at the top of\n * this file. Both reach `withRenderCache` and through it `next/cache`, which\n * drags Next's server runtime into the module graph of everything that\n * imports this enricher — including the commerce plugin, whose specs then\n * fail to load at all. Loading them inside the one branch that reads also\n * means a gated tree naming no entry pays for neither.\n */\nasync function gatedEntryLinkRoutes(\n  hostId: string,\n  nodes: unknown,\n): Promise<Record<string, string> | undefined> {\n  try {\n    const refs = Aglyn.collectEntryLinkRefs({\n      nodes: [nodes as Record<string, unknown> | null],\n    })\n    if (!refs.length) return undefined\n    const [{ getTemplateScreenRouting }, { resolveEntryLinkRoutes }] =\n      await Promise.all([\n        import('./template-screens'),\n        import('./entry-link-routes'),\n      ])\n    const routing = await getTemplateScreenRouting({ hostId })\n    const routes = await resolveEntryLinkRoutes({\n      hostId,\n      refs,\n      collectionSlugs: routing.collectionListings,\n    })\n    return Object.keys(routes).length ? routes : undefined\n  } catch (error) {\n    console.error('gated page entry links failed', error)\n    return undefined\n  }\n}\n\n/**\n * The enricher slice for a screen whose nodes are withheld from the page and\n * fetched after a gate opens (AGL-2510) — a password-protected screen\n * (AGL-87) and a members-only one (AGL-109).\n *\n * ## Why these two need their own call\n *\n * Every other rendered page gets its enricher props from the loader, but\n * these two deliberately ship `nodes: null`: embedding a gated tree in static\n * HTML would publish the very content the gate exists to withhold. So the\n * page arrives with the built-in prompt and no site chrome at all, and the\n * composed tree — the site's shared layout, nav and footer included — is\n * swapped in by the client once the visitor gets past the gate. A nav menu\n * built from primitives opens through `clientAutomations`, which is enricher\n * output, so without this the unlocked page renders the site's nav and none\n * of its behavior.\n *\n * Delivering it WITH the nodes is what keeps the gate honest. The slice is\n * derived from the withheld tree and describes its structure; shipping it in\n * the public HTML alongside `nodes: null` would leak an outline of the page\n * to anyone who never answers the prompt.\n *\n * ## The path\n *\n * Taken from the host's own routing map rather than from the caller, because\n * both callers are POST endpoints a visitor controls: a supplied path would\n * let anyone pick which overlays and path-scoped automations a gated page\n * runs. A screen missing from the map (never routed) gets the site root,\n * which is what an unrouted screen's own address would be.\n *\n * ## The entry links\n *\n * `entryRoutes` rides along when the tree links to a live content entry\n * (AGL-3118), and the client adds those keys to the page's routing map — see\n * {@link gatedEntryLinkRoutes}.\n *\n * Fail-open to `{}` — an enricher slice is behavior on top of a page, and no\n * failure here may cost a visitor the content they just unlocked.\n */\nexport async function enrichGatedScreenPage(options: {\n  hostId: string\n  screenId: string\n  screen: any\n  nodes: any\n  /**\n   * The site document, when the caller already read it to compose `nodes`\n   * (AGL-2883). Read here when absent.\n   */\n  host?: Record<string, unknown> | null\n}): Promise<Record<string, unknown>> {\n  const { hostId, screenId, screen, nodes } = options\n  try {\n    // Started first: its reads share nothing with the enrichers'.\n    const entryRoutesPromise = gatedEntryLinkRoutes(hostId, nodes)\n    const [host, orgRes] = await Promise.all([\n      options.host !== undefined ? options.host : getHostDocAdmin(hostId),\n      getOrgForHost(hostId),\n    ])\n    const routing = ((host as { screens?: Record<string, string> })?.screens ??\n      {}) as Record<string, string>\n    const path = routing[screenId] || Aglyn.SCREEN_ROOT_PATH\n    const enriched = await Aglyn.runSitePageEnrichers({\n      hostId,\n      host,\n      org: orgRes?.org,\n      path,\n      slugSegments: path.split('/').filter(Boolean),\n      screenId,\n      screen,\n      nodes,\n    })\n    const entryRoutes = await entryRoutesPromise\n    return entryRoutes ? { ...enriched.props, entryRoutes } : enriched.props\n  } catch (error) {\n    console.error('gated page enrichment failed', error)\n    return {}\n  }\n}\n\nexport default enrichGatedScreenPage\n"],"names":["Aglyn","getHostDocAdmin","getOrgForHost","gatedEntryLinkRoutes","hostId","nodes","refs","collectEntryLinkRefs","length","undefined","getTemplateScreenRouting","resolveEntryLinkRoutes","Promise","all","routing","routes","collectionSlugs","collectionListings","Object","keys","error","console","enrichGatedScreenPage","options","screenId","screen","entryRoutesPromise","host","orgRes","screens","path","SCREEN_ROOT_PATH","enriched","runSitePageEnrichers","org","slugSegments","split","filter","Boolean","entryRoutes","props"],"mappings":";AAAA;;;;;;;;;;;;;;;CAeC,GAED,YAAYA,WAAW,sBAAqB;AAC5C,SAASC,eAAe,EAAEC,aAAa,QAAQ,2BAA0B;AAEzE;;;;;;;;;;;;;;;;;;CAkBC,GACD,eAAeC,qBACbC,MAAc,EACdC,KAAc;IAEd,IAAI;QACF,MAAMC,OAAON,MAAMO,oBAAoB,CAAC;YACtCF,OAAO;gBAACA;aAAwC;QAClD;QACA,IAAI,CAACC,KAAKE,MAAM,EAAE,OAAOC;QACzB,MAAM,CAAC,EAAEC,wBAAwB,EAAE,EAAE,EAAEC,sBAAsB,EAAE,CAAC,GAC9D,MAAMC,QAAQC,GAAG,CAAC;YAChB,MAAM,CAAC;YACP,MAAM,CAAC;SACR;QACH,MAAMC,UAAU,MAAMJ,yBAAyB;YAAEN;QAAO;QACxD,MAAMW,SAAS,MAAMJ,uBAAuB;YAC1CP;YACAE;YACAU,iBAAiBF,QAAQG,kBAAkB;QAC7C;QACA,OAAOC,OAAOC,IAAI,CAACJ,QAAQP,MAAM,GAAGO,SAASN;IAC/C,EAAE,OAAOW,OAAO;QACdC,QAAQD,KAAK,CAAC,iCAAiCA;QAC/C,OAAOX;IACT;AACF;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsCC,GACD,OAAO,eAAea,sBAAsBC,OAU3C;IACC,MAAM,EAAEnB,MAAM,EAAEoB,QAAQ,EAAEC,MAAM,EAAEpB,KAAK,EAAE,GAAGkB;IAC5C,IAAI;;QACF,8DAA8D;QAC9D,MAAMG,qBAAqBvB,qBAAqBC,QAAQC;QACxD,MAAM,CAACsB,MAAMC,OAAO,GAAG,MAAMhB,QAAQC,GAAG,CAAC;YACvCU,QAAQI,IAAI,KAAKlB,YAAYc,QAAQI,IAAI,GAAG1B,gBAAgBG;YAC5DF,cAAcE;SACf;QACD,MAAMU,kBAAYa,wBAAD,AAACA,KAA+CE,OAAO,mBACtE,CAAC;QACH,MAAMC,OAAOhB,OAAO,CAACU,SAAS,IAAIxB,MAAM+B,gBAAgB;QACxD,MAAMC,WAAW,MAAMhC,MAAMiC,oBAAoB,CAAC;YAChD7B;YACAuB;YACAO,GAAG,EAAEN,0BAAAA,OAAQM,GAAG;YAChBJ;YACAK,cAAcL,KAAKM,KAAK,CAAC,KAAKC,MAAM,CAACC;YACrCd;YACAC;YACApB;QACF;QACA,MAAMkC,cAAc,MAAMb;QAC1B,OAAOa,cAAc,aAAKP,SAASQ,KAAK;YAAED;aAAgBP,SAASQ,KAAK;IAC1E,EAAE,OAAOpB,OAAO;QACdC,QAAQD,KAAK,CAAC,gCAAgCA;QAC9C,OAAO,CAAC;IACV;AACF;AAEA,eAAeE,sBAAqB"}

package/src/lib/entry-link-routes.d.ts

@@ -0,0 +1,61 @@
+/**
+ * @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.
+ */
+/**
+ * The most entries one page's links are resolved for (AGL-3118).
+ *
+ * A real page names a handful — a "read next" row, the links in a post — so
+ * this is not a budget anything should approach. It is the bound on what one
+ * pathological page can cost: a single batched read of at most this many
+ * documents per regeneration. Past it, the keys that sort last are not read,
+ * and their links render as plain text.
+ */
+export declare const ENTRY_LINK_ROUTES_MAX = 100;
+/**
+ * Where each entry a page's links name is served now (AGL-3118): entry key
+ * → `{collectionSlug}/{entrySlug}`, the map format `linkableScreenRoutes`
+ * takes as `entryRoutes`.
+ *
+ * Only LIVE entries answer — published, or scheduled and due on a plan that
+ * allows it, judged by the same `isLive` as the entry's own route — so a
+ * link can never offer a page that route would 404. A draft, an unpublished
+ * or a deleted entry is simply absent, and its links render inert.
+ *
+ * The reads are the minimum the question allows:
+ *
+ * - NONE for a page that names no entry, the common case — nor for
+ *   references whose collection has no listing, which no read could route;
+ * - otherwise ONE batched read of exactly the named documents (at most
+ *   {@link ENTRY_LINK_ROUTES_MAX}), cached like the rest of the site's
+ *   published data: keyed by the host and the sorted key set, busted by the
+ *   `tenant-data:{hostId}` tag an entry save announces, and held for the
+ *   same window as every other published read;
+ * - and none for the collections' slugs, which the caller hands over from
+ *   the routing read the render already made. Only the ENTRY facts are
+ *   cached, and the path is assembled per call, so a renamed collection
+ *   moves its entries' links as soon as the routing read has the new slug.
+ *
+ * Fails open to `{}` — a failed read renders inert links, never a 500 — and
+ * the failure is not cached, so the next render asks again.
+ */
+export declare function resolveEntryLinkRoutes(options: {
+    hostId: string;
+    /** Entry keys, as `collectEntryLinkRefs` answers them. */
+    refs: readonly string[];
+    /** Content collection id → slug: the routing read's `collectionListings`. */
+    collectionSlugs: Record<string, string> | null | undefined;
+}): Promise<Record<string, string>>;
+export default resolveEntryLinkRoutes;

package/src/lib/entry-link-routes.js

@@ -0,0 +1,169 @@
+import { _ as _extends } from "@swc/helpers/_/_extends";
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ import { collectionEntryRoutePath, formatEntryLinkValue, parseEntryLinkValue } from "@aglyn/aglyn/server";
+import { firebaseAdmin } from "@aglyn/tenant-data-admin";
+import { PUBLISHED_SITE_DATA_TTL_SECONDS, tenantDataTag, withRenderCache } from "@aglyn/tenant-data-admin/render-cache";
+import { isDueScheduled, isLive, isPendingScheduled, scheduledPublishingPermission } from "./get-collection-content.js";
+/**
+ * The most entries one page's links are resolved for (AGL-3118).
+ *
+ * A real page names a handful — a "read next" row, the links in a post — so
+ * this is not a budget anything should approach. It is the bound on what one
+ * pathological page can cost: a single batched read of at most this many
+ * documents per regeneration. Past it, the keys that sort last are not read,
+ * and their links render as plain text.
+ */ export const ENTRY_LINK_ROUTES_MAX = 100;
+/**
+ * The fields an entry link is decided from: whether the entry is live (the
+ * three `isLive` reads) and where it is served (its slug). Projected, because
+ * an entry document carries its whole body and a link needs none of it.
+ */ const ENTRY_LINK_FIELDS = [
+    'status',
+    'publishAt',
+    'scheduleStatus',
+    'slug'
+];
+/**
+ * A document id Firestore will address. A reference is authored data, and
+ * one id `getAll` refuses fails the whole batch, which would take every
+ * other entry link on the page down with it.
+ */ function isAddressableId(id) {
+    return id.length <= 500 && id !== '.' && id !== '..' && !/^__.*__$/.test(id);
+}
+/**
+ * The live slugs of exactly these entries: one batched `getAll` of the
+ * documents, projected to {@link ENTRY_LINK_FIELDS}. Throws on a failed
+ * read, so the failure is never stored.
+ */ async function readEntryLinkFacts(hostId, targets) {
+    const firestore = firebaseAdmin.app().firestore();
+    const collections = firestore.collection('hosts').doc(hostId).collection('collections');
+    const refs = targets.map(({ collectionId, entryId })=>collections.doc(collectionId).collection('entries').doc(entryId));
+    // Snapshots come back in the order the references were asked in.
+    const snapshots = await firestore.getAll(...refs, {
+        fieldMask: ENTRY_LINK_FIELDS
+    });
+    const values = snapshots.map((snapshot)=>{
+        var _snapshot_data;
+        return snapshot.exists ? (_snapshot_data = snapshot.data()) != null ? _snapshot_data : null : null;
+    });
+    // The plan is read only when one of these entries is due, as on the entry's
+    // own route — which is almost never.
+    const due = values.some((value)=>value !== null && isDueScheduled(value));
+    const permission = due ? await scheduledPublishingPermission(hostId) : 'allowed';
+    const slugs = {};
+    values.forEach((value, index)=>{
+        var _targets_index;
+        const key = (_targets_index = targets[index]) == null ? void 0 : _targets_index.key;
+        if (!key || !value || !isLive(value, permission)) return;
+        const slug = typeof value['slug'] === 'string' ? value['slug'].trim() : '';
+        // The entry route matches one path segment against `slug`, so an entry
+        // with none — or with a slash in it — has no address to link to.
+        if (slug && !slug.includes('/')) slugs[key] = slug;
+    });
+    const unsettled = values.some((value)=>value !== null && isPendingScheduled(value)) || due && permission === 'unresolved';
+    return unsettled ? {
+        slugs,
+        unsettled: true
+    } : {
+        slugs
+    };
+}
+/**
+ * Where each entry a page's links name is served now (AGL-3118): entry key
+ * → `{collectionSlug}/{entrySlug}`, the map format `linkableScreenRoutes`
+ * takes as `entryRoutes`.
+ *
+ * Only LIVE entries answer — published, or scheduled and due on a plan that
+ * allows it, judged by the same `isLive` as the entry's own route — so a
+ * link can never offer a page that route would 404. A draft, an unpublished
+ * or a deleted entry is simply absent, and its links render inert.
+ *
+ * The reads are the minimum the question allows:
+ *
+ * - NONE for a page that names no entry, the common case — nor for
+ *   references whose collection has no listing, which no read could route;
+ * - otherwise ONE batched read of exactly the named documents (at most
+ *   {@link ENTRY_LINK_ROUTES_MAX}), cached like the rest of the site's
+ *   published data: keyed by the host and the sorted key set, busted by the
+ *   `tenant-data:{hostId}` tag an entry save announces, and held for the
+ *   same window as every other published read;
+ * - and none for the collections' slugs, which the caller hands over from
+ *   the routing read the render already made. Only the ENTRY facts are
+ *   cached, and the path is assembled per call, so a renamed collection
+ *   moves its entries' links as soon as the routing read has the new slug.
+ *
+ * Fails open to `{}` — a failed read renders inert links, never a 500 — and
+ * the failure is not cached, so the next render asks again.
+ */ export async function resolveEntryLinkRoutes(options) {
+    const { hostId, collectionSlugs } = options;
+    if (!hostId || !collectionSlugs) return {};
+    const slugOf = (collectionId)=>{
+        const slug = collectionSlugs[collectionId];
+        return typeof slug === 'string' ? slug.trim() : '';
+    };
+    const targets = new Map();
+    for (const ref of options.refs){
+        const entry = parseEntryLinkValue(ref);
+        if (!entry || !slugOf(entry.collectionId)) continue;
+        if (!isAddressableId(entry.collectionId) || !isAddressableId(entry.entryId)) {
+            continue;
+        }
+        const key = formatEntryLinkValue(entry.collectionId, entry.entryId);
+        targets.set(key, _extends({
+            key
+        }, entry));
+    }
+    if (!targets.size) return {};
+    const wanted = [
+        ...targets.keys()
+    ].sort().slice(0, ENTRY_LINK_ROUTES_MAX);
+    try {
+        var _ref;
+        const facts = await withRenderCache({
+            // One key part for the whole set, so no two sets can join to the same
+            // string.
+            key: [
+                'tenant-entry-link-routes',
+                hostId,
+                JSON.stringify(wanted)
+            ],
+            revalidate: PUBLISHED_SITE_DATA_TTL_SECONDS,
+            tags: [
+                tenantDataTag(hostId)
+            ],
+            read: ()=>readEntryLinkFacts(hostId, wanted.flatMap((key)=>{
+                    var _targets_get;
+                    return (_targets_get = targets.get(key)) != null ? _targets_get : [];
+                })),
+            store: (value)=>!value.unsettled
+        });
+        const routes = {};
+        for (const [key, entrySlug] of Object.entries((_ref = facts == null ? void 0 : facts.slugs) != null ? _ref : {})){
+            const entry = parseEntryLinkValue(key);
+            const collectionSlug = entry ? slugOf(entry.collectionId) : '';
+            if (!collectionSlug) continue;
+            routes[key] = collectionEntryRoutePath(collectionSlug, entrySlug);
+        }
+        return routes;
+    } catch (error) {
+        console.error('entry link lookup failed:', error);
+        return {};
+    }
+}
+export default resolveEntryLinkRoutes;
+
+//# sourceMappingURL=entry-link-routes.js.map

package/src/lib/entry-link-routes.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../libs/tenant/runtime/src/lib/entry-link-routes.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2026 Aglyn LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  collectionEntryRoutePath,\n  formatEntryLinkValue,\n  parseEntryLinkValue,\n} from '@aglyn/aglyn/server'\nimport { firebaseAdmin } from '@aglyn/tenant-data-admin'\nimport {\n  PUBLISHED_SITE_DATA_TTL_SECONDS,\n  tenantDataTag,\n  withRenderCache,\n} from '@aglyn/tenant-data-admin/render-cache'\nimport {\n  isDueScheduled,\n  isLive,\n  isPendingScheduled,\n  type SchedulePermission,\n  scheduledPublishingPermission,\n} from './get-collection-content'\n\n/**\n * The most entries one page's links are resolved for (AGL-3118).\n *\n * A real page names a handful — a \"read next\" row, the links in a post — so\n * this is not a budget anything should approach. It is the bound on what one\n * pathological page can cost: a single batched read of at most this many\n * documents per regeneration. Past it, the keys that sort last are not read,\n * and their links render as plain text.\n */\nexport const ENTRY_LINK_ROUTES_MAX = 100\n\n/**\n * The fields an entry link is decided from: whether the entry is live (the\n * three `isLive` reads) and where it is served (its slug). Projected, because\n * an entry document carries its whole body and a link needs none of it.\n */\nconst ENTRY_LINK_FIELDS = ['status', 'publishAt', 'scheduleStatus', 'slug']\n\n/**\n * A document id Firestore will address. A reference is authored data, and\n * one id `getAll` refuses fails the whole batch, which would take every\n * other entry link on the page down with it.\n */\nfunction isAddressableId(id: string): boolean {\n  return (\n    id.length <= 500 && id !== '.' && id !== '..' && !/^__.*__$/.test(id)\n  )\n}\n\n/** One referenced entry, by its canonical key and the ids it names. */\ninterface EntryLinkTarget {\n  key: string\n  collectionId: string\n  entryId: string\n}\n\n/** What the cached read answers — plain data, so a hit equals a miss. */\ninterface EntryLinkFacts {\n  /** Entry key → the entry's slug, for each referenced entry that is live. */\n  slugs: Record<string, string>\n  /**\n   * The read saw an entry whose liveness will change with no write — a\n   * schedule still waiting on its time, or a due one whose plan could not be\n   * read — so the answer is served but not stored.\n   */\n  unsettled?: boolean\n}\n\n/**\n * The live slugs of exactly these entries: one batched `getAll` of the\n * documents, projected to {@link ENTRY_LINK_FIELDS}. Throws on a failed\n * read, so the failure is never stored.\n */\nasync function readEntryLinkFacts(\n  hostId: string,\n  targets: readonly EntryLinkTarget[],\n): Promise<EntryLinkFacts> {\n  const firestore = firebaseAdmin.app().firestore()\n  const collections = firestore\n    .collection('hosts')\n    .doc(hostId)\n    .collection('collections')\n  const refs = targets.map(({ collectionId, entryId }) =>\n    collections.doc(collectionId).collection('entries').doc(entryId),\n  )\n  // Snapshots come back in the order the references were asked in.\n  const snapshots = await firestore.getAll(...refs, {\n    fieldMask: ENTRY_LINK_FIELDS,\n  })\n  const values = snapshots.map((snapshot) =>\n    snapshot.exists ? (snapshot.data() ?? null) : null,\n  )\n  // The plan is read only when one of these entries is due, as on the entry's\n  // own route — which is almost never.\n  const due = values.some((value) => value !== null && isDueScheduled(value))\n  const permission: SchedulePermission = due\n    ? await scheduledPublishingPermission(hostId)\n    : 'allowed'\n  const slugs: Record<string, string> = {}\n  values.forEach((value, index) => {\n    const key = targets[index]?.key\n    if (!key || !value || !isLive(value, permission)) return\n    const slug = typeof value['slug'] === 'string' ? value['slug'].trim() : ''\n    // The entry route matches one path segment against `slug`, so an entry\n    // with none — or with a slash in it — has no address to link to.\n    if (slug && !slug.includes('/')) slugs[key] = slug\n  })\n  const unsettled =\n    values.some((value) => value !== null && isPendingScheduled(value)) ||\n    (due && permission === 'unresolved')\n  return unsettled ? { slugs, unsettled: true } : { slugs }\n}\n\n/**\n * Where each entry a page's links name is served now (AGL-3118): entry key\n * → `{collectionSlug}/{entrySlug}`, the map format `linkableScreenRoutes`\n * takes as `entryRoutes`.\n *\n * Only LIVE entries answer — published, or scheduled and due on a plan that\n * allows it, judged by the same `isLive` as the entry's own route — so a\n * link can never offer a page that route would 404. A draft, an unpublished\n * or a deleted entry is simply absent, and its links render inert.\n *\n * The reads are the minimum the question allows:\n *\n * - NONE for a page that names no entry, the common case — nor for\n *   references whose collection has no listing, which no read could route;\n * - otherwise ONE batched read of exactly the named documents (at most\n *   {@link ENTRY_LINK_ROUTES_MAX}), cached like the rest of the site's\n *   published data: keyed by the host and the sorted key set, busted by the\n *   `tenant-data:{hostId}` tag an entry save announces, and held for the\n *   same window as every other published read;\n * - and none for the collections' slugs, which the caller hands over from\n *   the routing read the render already made. Only the ENTRY facts are\n *   cached, and the path is assembled per call, so a renamed collection\n *   moves its entries' links as soon as the routing read has the new slug.\n *\n * Fails open to `{}` — a failed read renders inert links, never a 500 — and\n * the failure is not cached, so the next render asks again.\n */\nexport async function resolveEntryLinkRoutes(options: {\n  hostId: string\n  /** Entry keys, as `collectEntryLinkRefs` answers them. */\n  refs: readonly string[]\n  /** Content collection id → slug: the routing read's `collectionListings`. */\n  collectionSlugs: Record<string, string> | null | undefined\n}): Promise<Record<string, string>> {\n  const { hostId, collectionSlugs } = options\n  if (!hostId || !collectionSlugs) return {}\n  const slugOf = (collectionId: string): string => {\n    const slug = collectionSlugs[collectionId]\n    return typeof slug === 'string' ? slug.trim() : ''\n  }\n  const targets = new Map<string, EntryLinkTarget>()\n  for (const ref of options.refs) {\n    const entry = parseEntryLinkValue(ref)\n    if (!entry || !slugOf(entry.collectionId)) continue\n    if (!isAddressableId(entry.collectionId) || !isAddressableId(entry.entryId)) {\n      continue\n    }\n    const key = formatEntryLinkValue(entry.collectionId, entry.entryId)\n    targets.set(key, { key, ...entry })\n  }\n  if (!targets.size) return {}\n  const wanted = [...targets.keys()].sort().slice(0, ENTRY_LINK_ROUTES_MAX)\n  try {\n    const facts = await withRenderCache<EntryLinkFacts>({\n      // One key part for the whole set, so no two sets can join to the same\n      // string.\n      key: ['tenant-entry-link-routes', hostId, JSON.stringify(wanted)],\n      revalidate: PUBLISHED_SITE_DATA_TTL_SECONDS,\n      tags: [tenantDataTag(hostId)],\n      read: () =>\n        readEntryLinkFacts(\n          hostId,\n          wanted.flatMap((key) => targets.get(key) ?? []),\n        ),\n      store: (value) => !value.unsettled,\n    })\n    const routes: Record<string, string> = {}\n    for (const [key, entrySlug] of Object.entries(facts?.slugs ?? {})) {\n      const entry = parseEntryLinkValue(key)\n      const collectionSlug = entry ? slugOf(entry.collectionId) : ''\n      if (!collectionSlug) continue\n      routes[key] = collectionEntryRoutePath(collectionSlug, entrySlug)\n    }\n    return routes\n  } catch (error) {\n    console.error('entry link lookup failed:', error)\n    return {}\n  }\n}\n\nexport default resolveEntryLinkRoutes\n"],"names":["collectionEntryRoutePath","formatEntryLinkValue","parseEntryLinkValue","firebaseAdmin","PUBLISHED_SITE_DATA_TTL_SECONDS","tenantDataTag","withRenderCache","isDueScheduled","isLive","isPendingScheduled","scheduledPublishingPermission","ENTRY_LINK_ROUTES_MAX","ENTRY_LINK_FIELDS","isAddressableId","id","length","test","readEntryLinkFacts","hostId","targets","firestore","app","collections","collection","doc","refs","map","collectionId","entryId","snapshots","getAll","fieldMask","values","snapshot","exists","data","due","some","value","permission","slugs","forEach","index","key","slug","trim","includes","unsettled","resolveEntryLinkRoutes","options","collectionSlugs","slugOf","Map","ref","entry","set","size","wanted","keys","sort","slice","facts","JSON","stringify","revalidate","tags","read","flatMap","get","store","routes","entrySlug","Object","entries","collectionSlug","error","console"],"mappings":"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"}

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

@@ -0,0 +1,119 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { type CollectionCategory, type ContentAuthorRecord } from '@aglyn/aglyn/server';
+import { type CollectionEntrySummary } from './get-collection-content';
+/**
+ * Every author a host has defined, normalized (AGL-2518).
+ *
+ * ONE cached query, shared by the author page, the sitemap and anything else
+ * that needs to turn a slug into a person. Bounded by
+ * {@link AUTHORS_MAX_PER_HOST}, which is the platform cap, so the bound can
+ * never hide an author that exists.
+ *
+ * Reading the roster rather than resolving the author out of their own posts
+ * is a deliberate reversal of what AGL-2517 did. That version took the record
+ * off the first matching entry to avoid a second Firestore read — which meant
+ * an author with no published posts had no record, so their page had no name,
+ * no bio and no links, and rendered as an empty archive of nobody. A person
+ * who has not published yet still has a page; and this read is cached across
+ * the whole site, so it costs one query per TTL rather than one per render.
+ *
+ * Fail-open to an empty roster: the page then falls back to whatever the
+ * entries themselves carry, which is the old behavior rather than a 500.
+ */
+export declare function getContentAuthors(options: {
+    hostId: string;
+}): Promise<ContentAuthorRecord[]>;
+/** What a `/author/{slug}` route resolved to. */
+export interface AuthorContent {
+    /** The addressed segment, normalized — what a canonical link must say. */
+    slug: string;
+    /** The author's record, when the slug names one. */
+    author: ContentAuthorRecord | null;
+    /**
+     * The byline to print. Falls back to the raw segment so an unknown author
+     * still gets a page with a heading rather than a blank one.
+     */
+    name: string;
+    /**
+     * Did the slug resolve to a real author — a roster record, or an entry
+     * published under that byline? An unknown slug renders an empty page rather
+     * than crashing, which is the category route's rule, but the page must not
+     * invite indexing of an address that names nobody.
+     */
+    known: boolean;
+    /** This author's published entries, newest first, across every collection. */
+    entries: CollectionEntrySummary[];
+    /** The merged taxonomy of every collection walked, for name resolution. */
+    categories: CollectionCategory[];
+    page: number;
+    perPage: number;
+    totalEntries: number;
+    totalPages: number;
+}
+/**
+ * Everything one author's page shows (AGL-2518) — the person, and what they
+ * wrote across the WHOLE site.
+ *
+ * ## Where the entries come from
+ *
+ * Every content collection the host owns, through
+ * {@link getPublishedCollectionSource} — the same cached per-collection read
+ * `/blog` and every "Latest posts" rail already use. So on a warm site this
+ * page adds no Firestore reads at all: it is a filter over data the cache is
+ * holding anyway. That is the whole reason it walks collections rather than
+ * running a collection-group query on `authorId`, which would be one query
+ * but would also need its own composite index, would miss every entry written
+ * under the legacy free-typed byline (AGL-686), and would share nothing with
+ * the rest of the site.
+ *
+ * ## Why each entry is stamped with its collection
+ *
+ * One page, several collections, so the routed slug cannot build `entry.url`
+ * any more — a changelog note listed under a `/blog` route would link to a
+ * page that does not exist. Each entry carries `collectionSlug` and
+ * `collectionName` out of the read that found it, and the token map prefers
+ * them (`collectionEntryTokens`). Single-collection listings set neither and
+ * are unchanged.
+ *
+ * ## Ordering
+ *
+ * Newest first by `publishedAt`, with undated entries last rather than first:
+ * a draft-turned-live with no timestamp should not lead a person's archive.
+ * Sorted ACROSS collections, because the point of the page is a single
+ * chronological body of work rather than three lists stacked.
+ */
+export declare function getAuthorContent(options: {
+    hostId: string;
+    authorSlug: string;
+    page?: number;
+    perPage?: number;
+}): Promise<AuthorContent>;
+/**
+ * Every author page this site can serve, for the sitemap (AGL-2518).
+ *
+ * Roster order, and only authors that address something: an author whose
+ * record has neither a slug nor a name has no URL, and listing one would put
+ * `/author/` in the sitemap.
+ */
+export declare function listAuthorPageSlugs(options: {
+    hostId: string;
+}): Promise<{
+    slug: string;
+    name: string;
+}[]>;
+export default getAuthorContent;