@aglyn/tenant-runtime 1.0.0-beta.143

package/src/lib/compose-screen-nodes.js

@@ -0,0 +1,547 @@
+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";
+// By path: the overlay is server-only, and every `@aglyn/aglyn` barrel
+// re-exports `app-utils/server` into published pages.
+import { applyMediaAssetFacts, mediaAssetRefs } from "@aglyn/aglyn/app-utils/media-asset-facts";
+import applyDuePublishSchedule from "./apply-publish-schedule.js";
+import getComponents from "./get-components.js";
+import getDatasets from "./get-datasets.js";
+import getForms from "./get-forms.js";
+import getMediaAssetFacts from "./get-media-asset-facts.js";
+import { getPublishedCollectionSource } from "./get-collection-content.js";
+import getPluginInstalls from "./get-plugin-installs.js";
+import getVariables, { getFunctions, getWorkflows } from "./get-variables.js";
+import getPublishedLayoutVersion from "./get-layout-version.js";
+import getScreenVersion from "./get-screen-version.js";
+import { socialImageAssetFacts, socialImageRefs } from "./social-image-facts.js";
+import { stampFormDatasetBindings } from "./stamp-form-dataset-bindings.js";
+/**
+ * Which collections does this tree ask for (AGL-1152)?
+ *
+ * Extracted so the PREFETCH below and the expansion that consumes it read the
+ * tree through one function rather than two copies of the same predicate. A
+ * divergence between them is not a type error — it is a slug prefetched and
+ * never awaited, or (worse) a slug the prefetch missed that then pays the full
+ * serial read anyway — so there is deliberately no second implementation to
+ * drift.
+ */ function scanCollectionBlocks(nodes, collection) {
+    const slugs = new Set();
+    let hasRelated = false;
+    let hasCategories = false;
+    let hasSearch = false;
+    for (const node of Object.values(nodes)){
+        if ((node == null ? void 0 : node.componentId) === Aglyn.COLLECTION_ENTRIES_COMPONENT_ID) {
+            var _ref;
+            var _node_props;
+            const slug = String((_ref = node == null ? void 0 : (_node_props = node.props) == null ? void 0 : _node_props.collectionSlug) != null ? _ref : '').trim() || (collection == null ? void 0 : collection.slug);
+            if (slug) slugs.add(slug);
+        }
+        // Category pills (AGL-1321) need only the taxonomy, but it rides on the
+        // same source, so they count as a reason to resolve one.
+        if ((node == null ? void 0 : node.componentId) === Aglyn.COLLECTION_CATEGORIES_COMPONENT_ID) {
+            var _ref1;
+            var _node_props1;
+            const slug = String((_ref1 = node == null ? void 0 : (_node_props1 = node.props) == null ? void 0 : _node_props1.collectionSlug) != null ? _ref1 : '').trim() || (collection == null ? void 0 : collection.slug);
+            if (slug) {
+                hasCategories = true;
+                slugs.add(slug);
+            }
+        }
+        // The standalone toolbar search box (AGL-1516, Figma 494:1220) needs the
+        // collection's entries to index, and rides the same source the listing
+        // beside it was built from — one read, one answer.
+        if ((node == null ? void 0 : node.componentId) === Aglyn.COLLECTION_SEARCH_COMPONENT_ID) {
+            var _ref2;
+            var _node_props2;
+            const slug = String((_ref2 = node == null ? void 0 : (_node_props2 = node.props) == null ? void 0 : _node_props2.collectionSlug) != null ? _ref2 : '').trim() || (collection == null ? void 0 : collection.slug);
+            if (slug) {
+                hasSearch = true;
+                slugs.add(slug);
+            }
+        }
+        // Related posts (AGL-582) always resolve against the ROUTED collection
+        // — they only mean something with a current entry in context.
+        if ((node == null ? void 0 : node.componentId) === Aglyn.COLLECTION_RELATED_COMPONENT_ID && (collection == null ? void 0 : collection.slug) && collection.entry) {
+            hasRelated = true;
+            slugs.add(collection.slug);
+        }
+    }
+    return {
+        slugs,
+        hasRelated,
+        hasCategories,
+        hasSearch
+    };
+}
+/**
+ * Issue the collection reads AS SOON AS THE SCREEN NODES EXIST (AGL-1152).
+ *
+ * `getPublishedCollectionSource` is three SEQUENTIAL round trips —
+ * `findContentCollection`, then `listLiveEntries`, then `attachEntryAuthors`
+ * — and until this existed it ran after the chrome bundle had already been
+ * awaited, so a page carrying a Collection entries block paid the whole thing
+ * as a serial tail on the compose phase. Measured on the tenant: a page with
+ * no collection block composes in ~20 ms, one with a block in ~572 ms, and the
+ * tree work itself accounts for under 2 ms of that at 50 entries. The gap is
+ * this read, waiting for reads it shares nothing with.
+ *
+ * Same shape as `screenDatasetsPromise` directly below, and the same caveat
+ * applies: the SCREEN's own nodes are a fast path, NOT the correctness gate. A
+ * collection block can arrive from a layout or a grafted reusable component,
+ * neither of which exists yet at this point, so the real scan still runs
+ * against the composed tree and still fetches anything this missed.
+ *
+ * The ROUTED collection is deliberately excluded when its entries are already
+ * in hand: the expansion below answers that slug from `collection.entries`
+ * without reading at all, so prefetching it would buy a read nobody awaits.
+ */ function prefetchCollectionSources(hostId, screenNodes, collection) {
+    const prefetched = {};
+    for (const slug of scanCollectionBlocks(screenNodes, collection).slugs){
+        if (slug === (collection == null ? void 0 : collection.slug) && collection.entries) continue;
+        const pending = getPublishedCollectionSource({
+            hostId,
+            collectionSlug: slug
+        });
+        // Marked handled the moment it exists, for the reason `composed` is in
+        // `composeScreenNodes`: a tree that turns out not to need this slug never
+        // awaits it, and an unawaited rejection takes the process down rather than
+        // failing this one read. The real await below still sees the rejection.
+        void pending.catch(()=>undefined);
+        prefetched[slug] = pending;
+    }
+    return prefetched;
+}
+/**
+ * Expands Collection entries blocks (AGL-551) against their collections'
+ * published entries, and Related posts blocks (AGL-582) against the routed
+ * entry. Fetches lazily — screens without the blocks cost nothing — and
+ * fails open on lookup errors like every other compose stage.
+ */ async function expandCollectionEntryBlocks(hostId, nodes, collection, prefetched) {
+    const { slugs, hasRelated, hasCategories, hasSearch } = scanCollectionBlocks(nodes, collection);
+    if (!slugs.size) return nodes;
+    const sources = {};
+    await Promise.all([
+        ...slugs
+    ].map(async (slug)=>{
+        var _ref;
+        // The routed collection rides its already-fetched entries +
+        // categories (AGL-582); other collections fetch both on demand.
+        if (slug === (collection == null ? void 0 : collection.slug) && collection.entries) {
+            sources[slug] = _extends({
+                slug,
+                entries: collection.entries,
+                categories: collection.categories
+            }, collection.page ? {
+                page: collection.page
+            } : {}, collection.entriesReachedBound ? {
+                reachedBound: true
+            } : {});
+            return;
+        }
+        // The prefetch when this slug was visible on the screen's own nodes;
+        // a live read when it only appeared after layout/component grafting.
+        const fetched = await ((_ref = prefetched == null ? void 0 : prefetched[slug]) != null ? _ref : getPublishedCollectionSource({
+            hostId,
+            collectionSlug: slug
+        }));
+        sources[slug] = _extends({
+            slug,
+            entries: fetched.entries,
+            categories: slug === (collection == null ? void 0 : collection.slug) && collection.categories ? collection.categories : fetched.categories
+        }, fetched.reachedBound ? {
+            reachedBound: true
+        } : {});
+    }));
+    const expanded = Aglyn.expandCollectionEntries(nodes, sources, collection == null ? void 0 : collection.slug);
+    const withCategories = hasCategories ? Aglyn.expandCollectionCategories(expanded, sources, /*
+          No DEFAULT collection for the pills on a routeless page (AGL-2524).
+
+          Category pills are the one block that builds its links from the
+          SOURCE's slug — `/{slug}/category/{x}` — because a category is a
+          filter on one collection's own listing. On the author page that slug
+          is synthetic, so an unbound pills block stamped links to a route that
+          does not exist.
+
+          Rendering nothing is the honest answer rather than a fallback. The
+          page spans every collection, and there is no
+          `/author/{slug}/category/{x}` for a pill to lead to; the only real
+          destination would be some collection's listing, which drops the
+          author the reader is looking at. A pills block that NAMES a
+          collection is unaffected and still resolves that collection's own
+          taxonomy — "browse the blog by category", which is a sensible thing
+          to put beside an archive.
+        */ (collection == null ? void 0 : collection.routeless) ? undefined : collection == null ? void 0 : collection.slug, collection == null ? void 0 : collection.categorySlug) : expanded;
+    const withSearch = hasSearch ? Aglyn.expandCollectionSearch(withCategories, sources, collection == null ? void 0 : collection.slug) : withCategories;
+    if (!hasRelated || !(collection == null ? void 0 : collection.entry)) return withSearch;
+    return Aglyn.expandCollectionRelated(withSearch, sources[collection.slug], collection.entry);
+}
+/**
+ * Shared post-version composition (AGL-551, extracted from
+ * `composeScreenNodes`): layout chrome, reusable components, repeatables,
+ * collection entries, bindings, function definitions, plugin installs,
+ * named tokens, denormalize, and last the current facts of each placed image
+ * and film, and of the social card the page is shared as. The screen path and
+ * the collection-fallback
+ * path (which has no screen doc) build identical trees through this one
+ * pipeline.
+ */ export async function composeNodesWithChrome(options) {
+    var _ref;
+    var _this, _options_collection, _options_collection1, _options_collection2;
+    const { hostId, layoutId } = options;
+    /**
+   * The layout chain, innermost first (AGL-703).
+   *
+   * A layout may itself render inside another layout, so this walks the
+   * `layoutId` pointers rather than reading one. Fetching is sequential
+   * because each step's parent is only known once the previous layout
+   * document is in hand — but the walk is short by construction
+   * (MAX_LAYOUT_CHAIN_DEPTH) and every layout is already a cached read.
+   *
+   * `seen` stops a cycle from looping forever. Stored data can hold one
+   * even though both the console and `canNestLayout` refuse to create it:
+   * the API, a script, or a restored backup can all write a layout
+   * document directly, and a render must degrade rather than hang.
+   */ const walkLayoutChain = async ()=>{
+        const chain = [];
+        const seen = new Set();
+        const boundLayoutId = await layoutId;
+        let currentLayoutId = boundLayoutId ? String(boundLayoutId) : undefined;
+        while(currentLayoutId && !seen.has(currentLayoutId) && chain.length < Aglyn.MAX_LAYOUT_CHAIN_DEPTH){
+            var _layoutRes_version, _layoutRes_version1, _layoutRes_layout;
+            seen.add(currentLayoutId);
+            const layoutRes = await getPublishedLayoutVersion({
+                hostId,
+                layoutId: currentLayoutId
+            });
+            // The version's declared properties travel with its nodes (AGL-2893):
+            // they are applied to this layout alone, with the screen's values for
+            // this layout, before the screen is grafted into its slot.
+            chain.push({
+                layoutId: currentLayoutId,
+                nodes: layoutRes == null ? void 0 : (_layoutRes_version = layoutRes.version) == null ? void 0 : _layoutRes_version.nodes,
+                props: layoutRes == null ? void 0 : (_layoutRes_version1 = layoutRes.version) == null ? void 0 : _layoutRes_version1.props
+            });
+            const parentId = layoutRes == null ? void 0 : (_layoutRes_layout = layoutRes.layout) == null ? void 0 : _layoutRes_layout.layoutId;
+            currentLayoutId = parentId ? String(parentId) : undefined;
+        }
+        return chain;
+    };
+    /**
+   * ONE round-trip stage instead of three (AGL-1225).
+   *
+   * This used to be `await layout walk` → `await getComponents` → `await
+   * Promise.all([five reads])`: three sequential waits, where only the first
+   * has any reason to be sequential. Every one of the other six reads takes
+   * `hostId` and nothing else — none of them consumes the layout chain — so
+   * they were waiting on a walk whose result they never look at.
+   *
+   * The walk stays internally sequential because it genuinely is: each step's
+   * parent id is only known once the previous layout document is in hand. It
+   * just no longer gates anything else. The critical path becomes the walk
+   * alone rather than walk + components + bulk.
+   *
+   * Measured budget that motivated this (production, `/product/besigner`):
+   * `composeScreenNodes` was the largest single phase at 1577 ms cold and
+   * consistently ~1.4-1.6 s warm too, so this is not cold-start cost. The
+   * existing `AGL-1152:render` timing line reports `composeScreenNodes` as a
+   * phase, so the effect of this shows up there directly — no new
+   * instrumentation, and a regression would be visible in the same place.
+   */ /**
+   * Does the SCREEN itself repeat over a dataset (AGL-1440)?
+   *
+   * Asked as soon as the nodes are in hand — which since AGL-1428 is after
+   * the fan-out has been ISSUED rather than before — so the overwhelmingly
+   * common case still keeps the AGL-1225 shape: a page that repeats almost
+   * always says so on its own document, and its datasets read goes out
+   * alongside the remaining chrome reads instead of after them.
+   *
+   * It is deliberately NOT the correctness gate — a repeatable can arrive from
+   * a layout or a grafted reusable component, neither of which exists yet. The
+   * gate is re-asked against the composed tree after grafting, which is the
+   * exact input `expandRepeatables` reads.
+   */ /*
+   * ISSUE THE HOST-SCOPED READS FIRST, THEN AWAIT THE NODES (AGL-1428).
+   *
+   * Every read in this bundle is keyed by `hostId` (and `layoutId`) alone —
+   * none of them reads `screenNodes` — so starting them before the nodes are
+   * in hand lets `composeScreenNodes`' version read overlap them rather than
+   * run ahead of them. `Promise.all` is created BEFORE the `await` below on
+   * purpose: that is the line that makes the two independent, and moving the
+   * await above it silently gives the whole saving back.
+   *
+   * `getDatasets` is the one read that genuinely depends on the nodes, so it
+   * cannot join the bundle. It does not have to wait for the bundle either —
+   * it is issued the moment the nodes resolve and awaited after, so it still
+   * overlaps whatever is left of the chrome reads instead of costing the
+   * extra serial round trip that dropping it from the batch would imply.
+   */ const chromeBundle = Promise.all([
+        walkLayoutChain(),
+        getComponents({
+            hostId
+        }),
+        // Host variable + function bindings (AGL-91/93): {{name}} and
+        // {{fn:name(args)}} in string props resolve to values; unknown tokens
+        // and failed runs stay literal.
+        Promise.all([
+            getVariables({
+                hostId
+            }),
+            getFunctions({
+                hostId
+            }),
+            getWorkflows({
+                hostId
+            }),
+            getPluginInstalls({
+                hostId
+            })
+        ])
+    ]);
+    const screenNodes = await options.screenNodes;
+    const screenDatasetKeys = Aglyn.repeatDatasetKeys(screenNodes);
+    const screenDatasetsPromise = screenDatasetKeys.length ? getDatasets({
+        hostId,
+        keys: screenDatasetKeys
+    }) : undefined;
+    // Does the SCREEN itself place a form entity? Gated and re-asked exactly
+    // like the datasets read beside it (AGL-1440): most pages carry no form, and
+    // the ones that do usually say so on their own document, so the read goes
+    // out here alongside the chrome reads instead of as a serial tail. It is not
+    // the correctness gate — a placed form can arrive from a layout or a grafted
+    // component — so the composed tree is asked again below.
+    const screenFormsPromise = Aglyn.placesFormEntity(screenNodes) ? getForms({
+        hostId
+    }) : undefined;
+    // Issued HERE, beside the datasets read and before the chrome bundle is
+    // awaited, so the collection read overlaps it instead of trailing it.
+    const prefetchedSources = prefetchCollectionSources(hostId, screenNodes, options.collection);
+    const [layoutChain, componentsRes, bulk] = await chromeBundle;
+    const [rawVariables, functions, workflows, pluginInstalls] = bulk;
+    const screenDatasets = await screenDatasetsPromise;
+    // Settled by now: it is read off the same version document the layout
+    // binding the walk above waited on came from.
+    const layoutPropValues = await options.layoutPropValues;
+    const composedNodes = Aglyn.composeLayoutChainWithProps(layoutChain, screenNodes, layoutPropValues);
+    const graftedComponents = Aglyn.composeReusableComponentNodes(composedNodes, componentsRes.definitions);
+    /*
+   * PLACED FORMS RESOLVE AGAINST THEIR ENTITY (`docs/specs/reusable-forms.md`).
+   *
+   * A form node bound to `hosts/{hostId}/forms/{formId}` renders that entity's
+   * published design, so a form is edited once and every page placing it
+   * follows. Without this the entity's tree was written on every publish and
+   * read by nothing: the fields had to be redrawn per page, and the two copies
+   * diverged the moment either was touched.
+   *
+   * The gate is the COMPONENT-grafted tree, not the screen's own nodes, for
+   * the reason the repeatables gate below states: a form placed inside a
+   * layout or a shared component does not exist in `screenNodes`, and a page
+   * that renders one would silently keep its stale inline copy.
+   *
+   * The second graft re-runs the component expansion deliberately. Instances
+   * already expanded are skipped by their own prefix, so the repeat costs a
+   * scan, and passing BOTH placement kinds is what expands a reusable
+   * component nested inside a form's design — which the first pass could not
+   * have seen, because that subtree was not in the tree yet.
+   */ const forms = (_ref = (_this = await screenFormsPromise) == null ? void 0 : _this.forms) != null ? _ref : Aglyn.placesFormEntity(graftedComponents) ? (await getForms({
+        hostId
+    })).forms : undefined;
+    const grafted = forms ? Aglyn.composeReusableComponentNodes(graftedComponents, componentsRes.definitions, [
+        Aglyn.placedFormPlacement(forms)
+    ]) : graftedComponents;
+    // Computed variables (AGL-129): workflow-backed values resolve once per
+    // compose; failures keep each variable's stored fallback.
+    const variables = Aglyn.resolveComputedVariables(rawVariables, functions, workflows);
+    // Repeatables (AGL-103) expand after grafting (so they work inside
+    // reusable components) and before bindings (so {{name}} tokens inside
+    // cloned items still resolve).
+    //
+    // Only the datasets this tree repeats over are read (AGL-1440), and the tree
+    // asked is the composed one — after grafting — because that is the map the
+    // expansion reads: a repeatable living in a layout or a reusable component
+    // is invisible in `screenNodes`, and reading only the screen's keys would
+    // silently render one template row where the author put a list. The
+    // screen's own keys were issued beside the chrome reads above; a key only a
+    // layout or a component adds is read here, for that key alone.
+    const datasetKeys = Aglyn.repeatDatasetKeys(grafted);
+    const unreadDatasetKeys = datasetKeys.filter((key)=>!screenDatasetKeys.includes(key));
+    const datasets = unreadDatasetKeys.length ? _extends({}, screenDatasets, await getDatasets({
+        hostId,
+        keys: unreadDatasetKeys
+    })) : screenDatasets;
+    const repeated = Aglyn.expandRepeatables(grafted, datasets);
+    // Collection entries blocks (AGL-551) expand alongside repeatables:
+    // per-entry {{entry.*}} tokens substitute inside the clones here, while
+    // page-level tokens wait for resolveNamedTokens below.
+    const withEntries = await expandCollectionEntryBlocks(hostId, repeated, options.collection, prefetchedSources);
+    // Entry Meta blocks (AGL-1385): fill in the routed entry's date/category/
+    // tags. Needs no source fetch — the routed entry and its taxonomy are
+    // already in hand — so it sits outside `expandCollectionEntryBlocks`, which
+    // returns early when no block asks for a collection read. AFTER it, so the
+    // per-entry clones it just produced already carry their own resolved values
+    // and are skipped.
+    const withEntryMeta = Aglyn.expandCollectionEntryMeta(withEntries, (_options_collection = options.collection) == null ? void 0 : _options_collection.entry, (_options_collection1 = options.collection) == null ? void 0 : _options_collection1.categories);
+    // Entry Author cards (AGL-2486): the same fill, one block over. Its values
+    // come off the author RECORD the routed entry resolved to, which the
+    // collection read has already attached, so this costs nothing either.
+    const withEntryAuthor = Aglyn.expandCollectionEntryAuthor(withEntryMeta, (_options_collection2 = options.collection) == null ? void 0 : _options_collection2.entry);
+    const bound = Aglyn.resolveNodesBindings(withEntryAuthor, variables, functions);
+    // Host variables (AGL-1022): `{{host.*}}` resolves from the INSTALLING
+    // site, late — at render, never at install — so a rebrand propagates to
+    // every artifact that names the host instead of hard-coding it. Same
+    // registry the email path uses, so a token means one thing in both.
+    const withHostTokens = Aglyn.resolveNodesHostTokens(bound, options.host);
+    // Function widgets run client-side: embed their definitions (AGL-93), and
+    // beside each the site variables that function reads and no others
+    // (AGL-3202).
+    const withFunctions = Aglyn.attachFunctionDefinitions(withHostTokens, functions, variables);
+    // Marketplace plugins (AGL-45): stamp each marketplacePlugin node with its
+    // pinned install (version/sha256/capabilities) + kill-switch state.
+    const nodes = Aglyn.attachPluginInstalls(withFunctions, pluginInstalls);
+    // Entry-template tokens (AGL-105): {{entry.*}} from the rendered entry.
+    const finalNodes = Aglyn.resolveNamedTokens(nodes, options.tokens);
+    // The document's one `main` landmark (AGL-2486). LAST, so it reads the tree
+    // the page actually ships — a slot grafted from a layout chain, an element
+    // an author chose — rather than the screen as stored.
+    const withLandmark = Aglyn.stampDocumentLandmark(finalNodes);
+    // Each form's dataset binding, signed so the submit route can trust it
+    // (AGL-2773). Read off THIS tree, the one the page ships, so a form grafted
+    // from a layout, a component or a form entity is signed as it renders; and
+    // after every stage that rewrites props, so nothing changes what the
+    // signature covers.
+    const withFormBindings = stampFormDatasetBindings(withLandmark, hostId);
+    const denormalized = Aglyn.canvas.processNodesToDenormalized(withFormBindings);
+    /*
+   * WHAT EACH PLACED IMAGE AND FILM IS NOW (AGL-2807, AGL-2833).
+   *
+   * An image's pixel pair and a film's length, shape and poster come from the
+   * asset's DAM document as it is now, not as it was when it was picked. LAST,
+   * on the tree the page ships, because an asset can arrive from any stage
+   * above: a layout, a component, a form, a repeated row, a collection entry,
+   * a binding.
+   *
+   * ONE read for all of them, issued once the tree is final rather than beside
+   * the chrome reads. A read issued there could only cover the screen's own
+   * placements, and nearly every layout places an image the screen does not
+   * (a logo, a footer mark), so it would buy a second read on almost every
+   * page. The late read costs its own round trip after the chrome reads, paid
+   * each time a page is composed, which for a published page is its ISR
+   * regeneration. A tree with no library asset, on a page whose social card
+   * names none, issues none.
+   *
+   * THE SOCIAL CARD'S ASSETS JOIN THE SAME READ (AGL-2850), ahead of the
+   * placements. A placement the cap leaves out keeps its pick-time pair, which
+   * for an image is a reservation the decoded picture corrects. Nothing
+   * corrects a card's pair, because a crawler lays the card out from it before
+   * fetching the image, and a card names at most three documents.
+   */ const socialImages = options.socialImages;
+    const cardRefs = socialImages ? socialImageRefs(socialImages.images) : [];
+    const refs = mediaAssetRefs(denormalized);
+    if (!refs.length && !cardRefs.length) return denormalized;
+    const facts = await getMediaAssetFacts({
+        hostId,
+        refs: [
+            ...cardRefs,
+            ...refs
+        ]
+    });
+    if (socialImages) {
+        const cardFacts = socialImageAssetFacts(socialImages.images, facts);
+        if (cardFacts) socialImages.onFacts(cardFacts);
+    }
+    return applyMediaAssetFacts(denormalized, facts);
+}
+/**
+ * Full published-render composition for one screen (extracted for AGL-87 so
+ * the SSG path and the password-unlock API build identical trees): applies
+ * a due publish schedule, loads the version, composes the shared layout
+ * chrome, grafts reusable components, and denormalizes.
+ */ export async function composeScreenNodes(options) {
+    var _ref, _options_versionId;
+    const { hostId, screenId, screen } = options;
+    const effectiveVersionId = options.versionId ? null : await applyDuePublishSchedule({
+        hostId,
+        collectionName: 'screens',
+        docId: screenId,
+        parent: screen
+    });
+    const versionId = (_ref = (_options_versionId = options.versionId) != null ? _options_versionId : effectiveVersionId) != null ? _ref : screen.versionId;
+    /*
+   * OVERLAP THE VERSION READ WITH THE CHROME BUNDLE (AGL-1428).
+   *
+   * `composeNodesWithChrome`'s reads are keyed by `hostId`/`layoutId`, both
+   * of which are in hand here, so the version read no longer has to finish
+   * before they start. Handing the promise over instead of the resolved
+   * value is the whole change: it is `composeNodesWithChrome` that decides
+   * when it actually needs the nodes.
+   *
+   * The `versionId`-less screen still exits BEFORE anything is issued, so a
+   * screen that has never been published costs no reads. What remains is the
+   * narrow case of a `versionId` that points at a missing or unreadable
+   * version document — a data-integrity fault rather than a routing outcome
+   * — and that one now pays for a chrome bundle it discards. That is the
+   * deliberate trade: one wasted bundle on a broken screen, against the
+   * version read hiding under the chrome reads on every render that works.
+   */ if (!versionId) return null;
+    const versionPromise = getScreenVersion({
+        hostId,
+        screenId,
+        versionId
+    });
+    /*
+   * NEITHER DERIVED PROMISE MAY REJECT ON ITS OWN.
+   *
+   * `composed` is discarded on every failure path below, and a rejected
+   * promise nobody awaited is an unhandled rejection — which in Node takes
+   * the whole render process down instead of letting this 404. So the nodes
+   * handed to the compose absorb the failure (an empty tree it will never be
+   * asked for), and `composed` gets a rejection handler attached the moment
+   * it exists rather than at the point we decide to drop it. The real error
+   * still propagates, from the `await versionPromise` below, exactly where it
+   * did when this function awaited the version directly.
+   */ const composed = composeNodesWithChrome({
+        hostId,
+        // Version-first (key-present wins, null = explicitly no layout), screen
+        // fallback — resolved as a promise so only the layout-chain walk waits on
+        // the version read; the rest of the chrome bundle keeps the AGL-1428
+        // overlap. A failed version read falls back to the screen binding; the
+        // whole compose is discarded on that path anyway.
+        layoutId: versionPromise.then((res)=>res.version && 'layoutId' in res.version ? res.version.layoutId : screen.layoutId, ()=>screen.layoutId),
+        // The screen's values for its layouts' properties (AGL-2893), beside the
+        // binding on the same document; a failed read renders the defaults.
+        layoutPropValues: versionPromise.then((res)=>{
+            var _res_version;
+            return (_res_version = res.version) == null ? void 0 : _res_version.layoutPropValues;
+        }, ()=>undefined),
+        screenNodes: versionPromise.then((res)=>{
+            var _ref;
+            var _res_version;
+            return (_ref = (_res_version = res.version) == null ? void 0 : _res_version.nodes) != null ? _ref : {};
+        }, ()=>({})),
+        tokens: options.tokens,
+        collection: options.collection,
+        host: options.host,
+        socialImages: options.socialImages
+    });
+    void composed.catch(()=>undefined);
+    const versionRes = await versionPromise;
+    if (versionRes.error || !versionRes.version) return null;
+    return composed;
+}
+export default composeScreenNodes;
+
+//# sourceMappingURL=compose-screen-nodes.js.map