@aglyn/tenant-runtime 1.0.0-beta.143

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../libs/tenant/runtime/src/lib/compose-screen-nodes.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'\n// By path: the overlay is server-only, and every `@aglyn/aglyn` barrel\n// re-exports `app-utils/server` into published pages.\nimport {\n  applyMediaAssetFacts,\n  mediaAssetRefs,\n} from '@aglyn/aglyn/app-utils/media-asset-facts'\nimport applyDuePublishSchedule from './apply-publish-schedule'\nimport getComponents from './get-components'\nimport getDatasets from './get-datasets'\nimport getForms from './get-forms'\nimport getMediaAssetFacts from './get-media-asset-facts'\nimport {\n  getPublishedCollectionSource,\n  type PublishedCollectionSource,\n} from './get-collection-content'\nimport getPluginInstalls from './get-plugin-installs'\nimport getVariables, { getFunctions, getWorkflows } from './get-variables'\nimport getPublishedLayoutVersion from './get-layout-version'\nimport getScreenVersion from './get-screen-version'\nimport {\n  type ComposeSocialImages,\n  socialImageAssetFacts,\n  socialImageRefs,\n} from './social-image-facts'\nimport { stampFormDatasetBindings } from './stamp-form-dataset-bindings'\n\n/**\n * Content-collection context for a compose (AGL-551): the collection the\n * route resolved (list/entry template screens). `entries` rides along when\n * the route already fetched them (list pages); blocks bound to other\n * collections — or to this one when `entries` is absent — fetch on demand.\n */\nexport interface ComposeCollectionContext {\n  slug: string\n  entries?: Aglyn.CollectionEntryRecord[]\n  /**\n   * The entry being rendered (AGL-582, entry-template screens / entry\n   * fallback) — the Related posts block resolves against it.\n   */\n  entry?: Aglyn.CollectionEntryRecord | null\n  /**\n   * The routed collection's category taxonomy (AGL-582): entry\n   * `categoryId`s resolve to display names against it during expansion.\n   */\n  categories?: Aglyn.CollectionCategory[]\n  /**\n   * The list page the URL asked for (AGL-1321). Fills in an entries block\n   * that declares `perPage` but no `page` — design time cannot know which\n   * page a visitor is on.\n   */\n  page?: number\n  /**\n   * The category segment the URL filtered on (AGL-1321); marks the current\n   * pill in a Category Pills block. `entries` arrives already filtered.\n   */\n  categorySlug?: string\n  /**\n   * Whether the read behind `entries` stopped at its `.limit()` (AGL-1516).\n   * Travels with the entries because the search boxes downstream have to say\n   * what they actually searched, and — with the liveness gate and the route's\n   * category filter both in between — `entries.length` no longer tells them.\n   */\n  entriesReachedBound?: boolean\n  /**\n   * Whether {@link slug} is a cache KEY rather than an address (AGL-2524).\n   *\n   * The author page mixes collections, and the compose pipeline keys entry\n   * sources by collection slug — so it hands over a synthetic one\n   * (`AUTHOR_ENTRIES_SOURCE_SLUG`) with its entries already in hand. That is\n   * harmless for the entries block, whose every row carries its OWN\n   * `collectionSlug` and builds `entry.url` from it, and for the search box,\n   * whose index is built the same way.\n   *\n   * It is NOT harmless for anything that builds a URL from the source's slug\n   * itself. Set this and such a block resolves nothing rather than pointing\n   * readers at `/{synthetic}/…`.\n   */\n  routeless?: boolean\n}\n\ninterface CollectionBlockScan {\n  slugs: Set<string>\n  hasRelated: boolean\n  hasCategories: boolean\n  hasSearch: boolean\n}\n\n/**\n * Which collections does this tree ask for (AGL-1152)?\n *\n * Extracted so the PREFETCH below and the expansion that consumes it read the\n * tree through one function rather than two copies of the same predicate. A\n * divergence between them is not a type error — it is a slug prefetched and\n * never awaited, or (worse) a slug the prefetch missed that then pays the full\n * serial read anyway — so there is deliberately no second implementation to\n * drift.\n */\nfunction scanCollectionBlocks(\n  nodes: Record<string, any>,\n  collection?: ComposeCollectionContext,\n): CollectionBlockScan {\n  const slugs = new Set<string>()\n  let hasRelated = false\n  let hasCategories = false\n  let hasSearch = false\n  for (const node of Object.values(nodes)) {\n    if (node?.componentId === Aglyn.COLLECTION_ENTRIES_COMPONENT_ID) {\n      const slug =\n        String(node?.props?.collectionSlug ?? '').trim() || collection?.slug\n      if (slug) slugs.add(slug)\n    }\n    // Category pills (AGL-1321) need only the taxonomy, but it rides on the\n    // same source, so they count as a reason to resolve one.\n    if (node?.componentId === Aglyn.COLLECTION_CATEGORIES_COMPONENT_ID) {\n      const slug =\n        String(node?.props?.collectionSlug ?? '').trim() || collection?.slug\n      if (slug) {\n        hasCategories = true\n        slugs.add(slug)\n      }\n    }\n    // The standalone toolbar search box (AGL-1516, Figma 494:1220) needs the\n    // collection's entries to index, and rides the same source the listing\n    // beside it was built from — one read, one answer.\n    if (node?.componentId === Aglyn.COLLECTION_SEARCH_COMPONENT_ID) {\n      const slug =\n        String(node?.props?.collectionSlug ?? '').trim() || collection?.slug\n      if (slug) {\n        hasSearch = true\n        slugs.add(slug)\n      }\n    }\n    // Related posts (AGL-582) always resolve against the ROUTED collection\n    // — they only mean something with a current entry in context.\n    if (\n      node?.componentId === Aglyn.COLLECTION_RELATED_COMPONENT_ID &&\n      collection?.slug &&\n      collection.entry\n    ) {\n      hasRelated = true\n      slugs.add(collection.slug)\n    }\n  }\n  return { slugs, hasRelated, hasCategories, hasSearch }\n}\n\n/**\n * Issue the collection reads AS SOON AS THE SCREEN NODES EXIST (AGL-1152).\n *\n * `getPublishedCollectionSource` is three SEQUENTIAL round trips —\n * `findContentCollection`, then `listLiveEntries`, then `attachEntryAuthors`\n * — and until this existed it ran after the chrome bundle had already been\n * awaited, so a page carrying a Collection entries block paid the whole thing\n * as a serial tail on the compose phase. Measured on the tenant: a page with\n * no collection block composes in ~20 ms, one with a block in ~572 ms, and the\n * tree work itself accounts for under 2 ms of that at 50 entries. The gap is\n * this read, waiting for reads it shares nothing with.\n *\n * Same shape as `screenDatasetsPromise` directly below, and the same caveat\n * applies: the SCREEN's own nodes are a fast path, NOT the correctness gate. A\n * collection block can arrive from a layout or a grafted reusable component,\n * neither of which exists yet at this point, so the real scan still runs\n * against the composed tree and still fetches anything this missed.\n *\n * The ROUTED collection is deliberately excluded when its entries are already\n * in hand: the expansion below answers that slug from `collection.entries`\n * without reading at all, so prefetching it would buy a read nobody awaits.\n */\nfunction prefetchCollectionSources(\n  hostId: string,\n  screenNodes: Record<string, any>,\n  collection?: ComposeCollectionContext,\n): Record<string, Promise<PublishedCollectionSource>> {\n  const prefetched: Record<\n    string,\n    Promise<PublishedCollectionSource>\n  > = {}\n  for (const slug of scanCollectionBlocks(screenNodes, collection).slugs) {\n    if (slug === collection?.slug && collection.entries) continue\n    const pending = getPublishedCollectionSource({\n      hostId,\n      collectionSlug: slug,\n    })\n    // Marked handled the moment it exists, for the reason `composed` is in\n    // `composeScreenNodes`: a tree that turns out not to need this slug never\n    // awaits it, and an unawaited rejection takes the process down rather than\n    // failing this one read. The real await below still sees the rejection.\n    void pending.catch(() => undefined)\n    prefetched[slug] = pending\n  }\n  return prefetched\n}\n\n/**\n * Expands Collection entries blocks (AGL-551) against their collections'\n * published entries, and Related posts blocks (AGL-582) against the routed\n * entry. Fetches lazily — screens without the blocks cost nothing — and\n * fails open on lookup errors like every other compose stage.\n */\nasync function expandCollectionEntryBlocks(\n  hostId: string,\n  nodes: Record<string, any>,\n  collection?: ComposeCollectionContext,\n  prefetched?: Record<string, Promise<PublishedCollectionSource>>,\n): Promise<Record<string, any>> {\n  const { slugs, hasRelated, hasCategories, hasSearch } = scanCollectionBlocks(\n    nodes,\n    collection,\n  )\n  if (!slugs.size) return nodes\n  const sources: Record<string, Aglyn.CollectionEntriesSource> = {}\n  await Promise.all(\n    [...slugs].map(async (slug) => {\n      // The routed collection rides its already-fetched entries +\n      // categories (AGL-582); other collections fetch both on demand.\n      if (slug === collection?.slug && collection.entries) {\n        sources[slug] = {\n          slug,\n          entries: collection.entries,\n          categories: collection.categories,\n          // Only the ROUTED collection carries the URL's page (AGL-1321) — a\n          // block bound to another collection must not inherit it.\n          ...(collection.page ? { page: collection.page } : {}),\n          // ...nor its bound (AGL-1516): this is a fact about the read the\n          // route already performed, and it describes only that collection.\n          ...(collection.entriesReachedBound ? { reachedBound: true } : {}),\n        }\n        return\n      }\n      // The prefetch when this slug was visible on the screen's own nodes;\n      // a live read when it only appeared after layout/component grafting.\n      const fetched = await (prefetched?.[slug] ??\n        getPublishedCollectionSource({ hostId, collectionSlug: slug }))\n      sources[slug] = {\n        slug,\n        entries: fetched.entries,\n        categories:\n          slug === collection?.slug && collection.categories\n            ? collection.categories\n            : fetched.categories,\n        ...(fetched.reachedBound ? { reachedBound: true } : {}),\n      }\n    }),\n  )\n  const expanded = Aglyn.expandCollectionEntries(\n    nodes,\n    sources,\n    collection?.slug,\n  )\n  const withCategories = hasCategories\n    ? Aglyn.expandCollectionCategories(\n        expanded,\n        sources,\n        /*\n          No DEFAULT collection for the pills on a routeless page (AGL-2524).\n\n          Category pills are the one block that builds its links from the\n          SOURCE's slug — `/{slug}/category/{x}` — because a category is a\n          filter on one collection's own listing. On the author page that slug\n          is synthetic, so an unbound pills block stamped links to a route that\n          does not exist.\n\n          Rendering nothing is the honest answer rather than a fallback. The\n          page spans every collection, and there is no\n          `/author/{slug}/category/{x}` for a pill to lead to; the only real\n          destination would be some collection's listing, which drops the\n          author the reader is looking at. A pills block that NAMES a\n          collection is unaffected and still resolves that collection's own\n          taxonomy — \"browse the blog by category\", which is a sensible thing\n          to put beside an archive.\n        */\n        collection?.routeless ? undefined : collection?.slug,\n        collection?.categorySlug,\n      )\n    : expanded\n  const withSearch = hasSearch\n    ? Aglyn.expandCollectionSearch(withCategories, sources, collection?.slug)\n    : withCategories\n  if (!hasRelated || !collection?.entry) return withSearch\n  return Aglyn.expandCollectionRelated(\n    withSearch,\n    sources[collection.slug],\n    collection.entry,\n  )\n}\n\n/**\n * Shared post-version composition (AGL-551, extracted from\n * `composeScreenNodes`): layout chrome, reusable components, repeatables,\n * collection entries, bindings, function definitions, plugin installs,\n * named tokens, denormalize, and last the current facts of each placed image\n * and film, and of the social card the page is shared as. The screen path and\n * the collection-fallback\n * path (which has no screen doc) build identical trees through this one\n * pipeline.\n */\nexport async function composeNodesWithChrome(options: {\n  hostId: string\n  /**\n   * The layout binding, or a PROMISE of it.\n   *\n   * The unresolved form exists for the same reason `screenNodes` accepts one\n   * (AGL-1428): the binding may live on the version document (key-present\n   * wins over the screen's), and awaiting the version before this call would\n   * put every host-scoped read back behind it. Only the layout-chain walk\n   * consumes the binding, so it alone waits; the rest of the chrome bundle\n   * still starts immediately.\n   */\n  layoutId?:\n    | string\n    | null\n    | Promise<string | null | undefined>\n  /**\n   * The screen's values for the properties of the layouts it renders inside\n   * (AGL-2893), keyed by layout id — or a PROMISE of them, for the reason\n   * `layoutId` accepts one: they live on the version document beside the\n   * binding. Absent, every layout renders its properties' defaults.\n   */\n  layoutPropValues?:\n    | Aglyn.AglynScreenVersion['layoutPropValues']\n    | null\n    | Promise<Aglyn.AglynScreenVersion['layoutPropValues'] | null | undefined>\n  /**\n   * The screen's own nodes, or a PROMISE of them (AGL-1428).\n   *\n   * Accepting the unresolved form is what lets `composeScreenNodes` hand the\n   * version read over before it has finished, so the host-scoped reads below\n   * — none of which look at these nodes — overlap it instead of queueing\n   * behind it. Passing a resolved value behaves exactly as before, which is\n   * what every other caller does.\n   */\n  screenNodes: Record<string, any> | Promise<Record<string, any>>\n  /** Entry-template tokens (AGL-105) substituted before denormalize. */\n  tokens?: Record<string, string>\n  /** Routed content collection (AGL-551) for Collection entries blocks. */\n  collection?: ComposeCollectionContext\n  /**\n   * The host document, for `host.*` tokens (AGL-1022).\n   *\n   * Passed in rather than read here: every caller already holds it, and\n   * `composeScreenNodes` was the largest single render phase before AGL-1225\n   * cut it to one round trip — adding a read back would spend that win on\n   * data we already have in hand.\n   */\n  host?: Aglyn.HostTokenSource | null\n  /**\n   * The social card the head shares this page as (AGL-2850). The documents of\n   * the assets it names are read in the same batch as the images and films\n   * the tree places.\n   */\n  socialImages?: ComposeSocialImages\n}): Promise<Record<string, any>> {\n  const { hostId, layoutId } = options\n\n  /**\n   * The layout chain, innermost first (AGL-703).\n   *\n   * A layout may itself render inside another layout, so this walks the\n   * `layoutId` pointers rather than reading one. Fetching is sequential\n   * because each step's parent is only known once the previous layout\n   * document is in hand — but the walk is short by construction\n   * (MAX_LAYOUT_CHAIN_DEPTH) and every layout is already a cached read.\n   *\n   * `seen` stops a cycle from looping forever. Stored data can hold one\n   * even though both the console and `canNestLayout` refuse to create it:\n   * the API, a script, or a restored backup can all write a layout\n   * document directly, and a render must degrade rather than hang.\n   */\n  const walkLayoutChain = async () => {\n    const chain: Aglyn.LayoutChainEntry[] = []\n    const seen = new Set<string>()\n    const boundLayoutId = await layoutId\n    let currentLayoutId = boundLayoutId ? String(boundLayoutId) : undefined\n    while (\n      currentLayoutId &&\n      !seen.has(currentLayoutId) &&\n      chain.length < Aglyn.MAX_LAYOUT_CHAIN_DEPTH\n    ) {\n      seen.add(currentLayoutId)\n      const layoutRes = await getPublishedLayoutVersion({\n        hostId,\n        layoutId: currentLayoutId,\n      })\n      // The version's declared properties travel with its nodes (AGL-2893):\n      // they are applied to this layout alone, with the screen's values for\n      // this layout, before the screen is grafted into its slot.\n      chain.push({\n        layoutId: currentLayoutId,\n        nodes: layoutRes?.version?.nodes as any,\n        props: (layoutRes?.version as Aglyn.AglynLayoutVersion | undefined)\n          ?.props,\n      })\n      const parentId = (layoutRes?.layout as any)?.layoutId\n      currentLayoutId = parentId ? String(parentId) : undefined\n    }\n    return chain\n  }\n\n  /**\n   * ONE round-trip stage instead of three (AGL-1225).\n   *\n   * This used to be `await layout walk` → `await getComponents` → `await\n   * Promise.all([five reads])`: three sequential waits, where only the first\n   * has any reason to be sequential. Every one of the other six reads takes\n   * `hostId` and nothing else — none of them consumes the layout chain — so\n   * they were waiting on a walk whose result they never look at.\n   *\n   * The walk stays internally sequential because it genuinely is: each step's\n   * parent id is only known once the previous layout document is in hand. It\n   * just no longer gates anything else. The critical path becomes the walk\n   * alone rather than walk + components + bulk.\n   *\n   * Measured budget that motivated this (production, `/product/besigner`):\n   * `composeScreenNodes` was the largest single phase at 1577 ms cold and\n   * consistently ~1.4-1.6 s warm too, so this is not cold-start cost. The\n   * existing `AGL-1152:render` timing line reports `composeScreenNodes` as a\n   * phase, so the effect of this shows up there directly — no new\n   * instrumentation, and a regression would be visible in the same place.\n   */\n  /**\n   * Does the SCREEN itself repeat over a dataset (AGL-1440)?\n   *\n   * Asked as soon as the nodes are in hand — which since AGL-1428 is after\n   * the fan-out has been ISSUED rather than before — so the overwhelmingly\n   * common case still keeps the AGL-1225 shape: a page that repeats almost\n   * always says so on its own document, and its datasets read goes out\n   * alongside the remaining chrome reads instead of after them.\n   *\n   * It is deliberately NOT the correctness gate — a repeatable can arrive from\n   * a layout or a grafted reusable component, neither of which exists yet. The\n   * gate is re-asked against the composed tree after grafting, which is the\n   * exact input `expandRepeatables` reads.\n   */\n  /*\n   * ISSUE THE HOST-SCOPED READS FIRST, THEN AWAIT THE NODES (AGL-1428).\n   *\n   * Every read in this bundle is keyed by `hostId` (and `layoutId`) alone —\n   * none of them reads `screenNodes` — so starting them before the nodes are\n   * in hand lets `composeScreenNodes`' version read overlap them rather than\n   * run ahead of them. `Promise.all` is created BEFORE the `await` below on\n   * purpose: that is the line that makes the two independent, and moving the\n   * await above it silently gives the whole saving back.\n   *\n   * `getDatasets` is the one read that genuinely depends on the nodes, so it\n   * cannot join the bundle. It does not have to wait for the bundle either —\n   * it is issued the moment the nodes resolve and awaited after, so it still\n   * overlaps whatever is left of the chrome reads instead of costing the\n   * extra serial round trip that dropping it from the batch would imply.\n   */\n  const chromeBundle = Promise.all([\n    walkLayoutChain(),\n    getComponents({ hostId }),\n    // Host variable + function bindings (AGL-91/93): {{name}} and\n    // {{fn:name(args)}} in string props resolve to values; unknown tokens\n    // and failed runs stay literal.\n    Promise.all([\n      getVariables({ hostId }),\n      getFunctions({ hostId }),\n      getWorkflows({ hostId }),\n      getPluginInstalls({ hostId }),\n    ]),\n  ])\n  const screenNodes = await options.screenNodes\n  const screenDatasetKeys = Aglyn.repeatDatasetKeys(screenNodes)\n  const screenDatasetsPromise = screenDatasetKeys.length\n    ? getDatasets({ hostId, keys: screenDatasetKeys })\n    : undefined\n  // Does the SCREEN itself place a form entity? Gated and re-asked exactly\n  // like the datasets read beside it (AGL-1440): most pages carry no form, and\n  // the ones that do usually say so on their own document, so the read goes\n  // out here alongside the chrome reads instead of as a serial tail. It is not\n  // the correctness gate — a placed form can arrive from a layout or a grafted\n  // component — so the composed tree is asked again below.\n  const screenFormsPromise = Aglyn.placesFormEntity(screenNodes)\n    ? getForms({ hostId })\n    : undefined\n  // Issued HERE, beside the datasets read and before the chrome bundle is\n  // awaited, so the collection read overlaps it instead of trailing it.\n  const prefetchedSources = prefetchCollectionSources(\n    hostId,\n    screenNodes,\n    options.collection,\n  )\n  const [layoutChain, componentsRes, bulk] = await chromeBundle\n  const [rawVariables, functions, workflows, pluginInstalls] = bulk\n  const screenDatasets = await screenDatasetsPromise\n  // Settled by now: it is read off the same version document the layout\n  // binding the walk above waited on came from.\n  const layoutPropValues = await options.layoutPropValues\n\n  const composedNodes = Aglyn.composeLayoutChainWithProps(\n    layoutChain as any,\n    screenNodes as any,\n    layoutPropValues,\n  )\n  const graftedComponents = Aglyn.composeReusableComponentNodes(\n    composedNodes as any,\n    componentsRes.definitions as any,\n  )\n  /*\n   * PLACED FORMS RESOLVE AGAINST THEIR ENTITY (`docs/specs/reusable-forms.md`).\n   *\n   * A form node bound to `hosts/{hostId}/forms/{formId}` renders that entity's\n   * published design, so a form is edited once and every page placing it\n   * follows. Without this the entity's tree was written on every publish and\n   * read by nothing: the fields had to be redrawn per page, and the two copies\n   * diverged the moment either was touched.\n   *\n   * The gate is the COMPONENT-grafted tree, not the screen's own nodes, for\n   * the reason the repeatables gate below states: a form placed inside a\n   * layout or a shared component does not exist in `screenNodes`, and a page\n   * that renders one would silently keep its stale inline copy.\n   *\n   * The second graft re-runs the component expansion deliberately. Instances\n   * already expanded are skipped by their own prefix, so the repeat costs a\n   * scan, and passing BOTH placement kinds is what expands a reusable\n   * component nested inside a form's design — which the first pass could not\n   * have seen, because that subtree was not in the tree yet.\n   */\n  const forms =\n    (await screenFormsPromise)?.forms ??\n    (Aglyn.placesFormEntity(graftedComponents as any)\n      ? (await getForms({ hostId })).forms\n      : undefined)\n  const grafted = forms\n    ? Aglyn.composeReusableComponentNodes(\n        graftedComponents as any,\n        componentsRes.definitions as any,\n        [Aglyn.placedFormPlacement(forms as any)],\n      )\n    : graftedComponents\n  // Computed variables (AGL-129): workflow-backed values resolve once per\n  // compose; failures keep each variable's stored fallback.\n  const variables = Aglyn.resolveComputedVariables(\n    rawVariables,\n    functions,\n    workflows,\n  )\n  // Repeatables (AGL-103) expand after grafting (so they work inside\n  // reusable components) and before bindings (so {{name}} tokens inside\n  // cloned items still resolve).\n  //\n  // Only the datasets this tree repeats over are read (AGL-1440), and the tree\n  // asked is the composed one — after grafting — because that is the map the\n  // expansion reads: a repeatable living in a layout or a reusable component\n  // is invisible in `screenNodes`, and reading only the screen's keys would\n  // silently render one template row where the author put a list. The\n  // screen's own keys were issued beside the chrome reads above; a key only a\n  // layout or a component adds is read here, for that key alone.\n  const datasetKeys = Aglyn.repeatDatasetKeys(grafted as any)\n  const unreadDatasetKeys = datasetKeys.filter(\n    (key) => !screenDatasetKeys.includes(key),\n  )\n  const datasets = unreadDatasetKeys.length\n    ? {\n        ...screenDatasets,\n        ...(await getDatasets({ hostId, keys: unreadDatasetKeys })),\n      }\n    : screenDatasets\n  const repeated = Aglyn.expandRepeatables(grafted as any, datasets)\n  // Collection entries blocks (AGL-551) expand alongside repeatables:\n  // per-entry {{entry.*}} tokens substitute inside the clones here, while\n  // page-level tokens wait for resolveNamedTokens below.\n  const withEntries = await expandCollectionEntryBlocks(\n    hostId,\n    repeated,\n    options.collection,\n    prefetchedSources,\n  )\n  // Entry Meta blocks (AGL-1385): fill in the routed entry's date/category/\n  // tags. Needs no source fetch — the routed entry and its taxonomy are\n  // already in hand — so it sits outside `expandCollectionEntryBlocks`, which\n  // returns early when no block asks for a collection read. AFTER it, so the\n  // per-entry clones it just produced already carry their own resolved values\n  // and are skipped.\n  const withEntryMeta = Aglyn.expandCollectionEntryMeta(\n    withEntries as any,\n    options.collection?.entry,\n    options.collection?.categories,\n  )\n  // Entry Author cards (AGL-2486): the same fill, one block over. Its values\n  // come off the author RECORD the routed entry resolved to, which the\n  // collection read has already attached, so this costs nothing either.\n  const withEntryAuthor = Aglyn.expandCollectionEntryAuthor(\n    withEntryMeta as any,\n    options.collection?.entry,\n  )\n  const bound = Aglyn.resolveNodesBindings(\n    withEntryAuthor as any,\n    variables,\n    functions,\n  )\n  // Host variables (AGL-1022): `{{host.*}}` resolves from the INSTALLING\n  // site, late — at render, never at install — so a rebrand propagates to\n  // every artifact that names the host instead of hard-coding it. Same\n  // registry the email path uses, so a token means one thing in both.\n  const withHostTokens = Aglyn.resolveNodesHostTokens(\n    bound as any,\n    options.host,\n  )\n  // Function widgets run client-side: embed their definitions (AGL-93), and\n  // beside each the site variables that function reads and no others\n  // (AGL-3202).\n  const withFunctions = Aglyn.attachFunctionDefinitions(\n    withHostTokens,\n    functions,\n    variables,\n  )\n  // Marketplace plugins (AGL-45): stamp each marketplacePlugin node with its\n  // pinned install (version/sha256/capabilities) + kill-switch state.\n  const nodes = Aglyn.attachPluginInstalls(withFunctions, pluginInstalls)\n  // Entry-template tokens (AGL-105): {{entry.*}} from the rendered entry.\n  const finalNodes = Aglyn.resolveNamedTokens(nodes as any, options.tokens)\n  // The document's one `main` landmark (AGL-2486). LAST, so it reads the tree\n  // the page actually ships — a slot grafted from a layout chain, an element\n  // an author chose — rather than the screen as stored.\n  const withLandmark = Aglyn.stampDocumentLandmark(finalNodes as any)\n  // Each form's dataset binding, signed so the submit route can trust it\n  // (AGL-2773). Read off THIS tree, the one the page ships, so a form grafted\n  // from a layout, a component or a form entity is signed as it renders; and\n  // after every stage that rewrites props, so nothing changes what the\n  // signature covers.\n  const withFormBindings = stampFormDatasetBindings(withLandmark, hostId)\n  const denormalized = Aglyn.canvas.processNodesToDenormalized(\n    withFormBindings as any,\n  )\n  /*\n   * WHAT EACH PLACED IMAGE AND FILM IS NOW (AGL-2807, AGL-2833).\n   *\n   * An image's pixel pair and a film's length, shape and poster come from the\n   * asset's DAM document as it is now, not as it was when it was picked. LAST,\n   * on the tree the page ships, because an asset can arrive from any stage\n   * above: a layout, a component, a form, a repeated row, a collection entry,\n   * a binding.\n   *\n   * ONE read for all of them, issued once the tree is final rather than beside\n   * the chrome reads. A read issued there could only cover the screen's own\n   * placements, and nearly every layout places an image the screen does not\n   * (a logo, a footer mark), so it would buy a second read on almost every\n   * page. The late read costs its own round trip after the chrome reads, paid\n   * each time a page is composed, which for a published page is its ISR\n   * regeneration. A tree with no library asset, on a page whose social card\n   * names none, issues none.\n   *\n   * THE SOCIAL CARD'S ASSETS JOIN THE SAME READ (AGL-2850), ahead of the\n   * placements. A placement the cap leaves out keeps its pick-time pair, which\n   * for an image is a reservation the decoded picture corrects. Nothing\n   * corrects a card's pair, because a crawler lays the card out from it before\n   * fetching the image, and a card names at most three documents.\n   */\n  const socialImages = options.socialImages\n  const cardRefs = socialImages ? socialImageRefs(socialImages.images) : []\n  const refs = mediaAssetRefs(denormalized)\n  if (!refs.length && !cardRefs.length) return denormalized\n  const facts = await getMediaAssetFacts({\n    hostId,\n    refs: [...cardRefs, ...refs],\n  })\n  if (socialImages) {\n    const cardFacts = socialImageAssetFacts(socialImages.images, facts)\n    if (cardFacts) socialImages.onFacts(cardFacts)\n  }\n  return applyMediaAssetFacts(denormalized, facts)\n}\n\n/**\n * Full published-render composition for one screen (extracted for AGL-87 so\n * the SSG path and the password-unlock API build identical trees): applies\n * a due publish schedule, loads the version, composes the shared layout\n * chrome, grafts reusable components, and denormalizes.\n */\nexport async function composeScreenNodes(options: {\n  hostId: string\n  screenId: string\n  screen: Aglyn.AglynScreen\n  /** Entry-template tokens (AGL-105) substituted before denormalize. */\n  tokens?: Record<string, string>\n  /** Routed content collection (AGL-551) for Collection entries blocks. */\n  collection?: ComposeCollectionContext\n  /**\n   * Compose a specific version instead of the published one (AGL-253):\n   * experiment variants point at versions; schedules don't apply.\n   */\n  versionId?: string\n  /** The host document, for `host.*` tokens (AGL-1022). */\n  host?: Aglyn.HostTokenSource | null\n  /** The social card the head shares this page as (AGL-2850). */\n  socialImages?: ComposeSocialImages\n}): Promise<Record<string, any> | null> {\n  const { hostId, screenId, screen } = options\n\n  const effectiveVersionId = options.versionId\n    ? null\n    : await applyDuePublishSchedule({\n        hostId,\n        collectionName: 'screens',\n        docId: screenId,\n        parent: screen,\n      })\n  const versionId = (options.versionId ??\n    effectiveVersionId ??\n    screen.versionId) as string\n\n  /*\n   * OVERLAP THE VERSION READ WITH THE CHROME BUNDLE (AGL-1428).\n   *\n   * `composeNodesWithChrome`'s reads are keyed by `hostId`/`layoutId`, both\n   * of which are in hand here, so the version read no longer has to finish\n   * before they start. Handing the promise over instead of the resolved\n   * value is the whole change: it is `composeNodesWithChrome` that decides\n   * when it actually needs the nodes.\n   *\n   * The `versionId`-less screen still exits BEFORE anything is issued, so a\n   * screen that has never been published costs no reads. What remains is the\n   * narrow case of a `versionId` that points at a missing or unreadable\n   * version document — a data-integrity fault rather than a routing outcome\n   * — and that one now pays for a chrome bundle it discards. That is the\n   * deliberate trade: one wasted bundle on a broken screen, against the\n   * version read hiding under the chrome reads on every render that works.\n   */\n  if (!versionId) return null\n\n  const versionPromise = getScreenVersion({ hostId, screenId, versionId })\n\n  /*\n   * NEITHER DERIVED PROMISE MAY REJECT ON ITS OWN.\n   *\n   * `composed` is discarded on every failure path below, and a rejected\n   * promise nobody awaited is an unhandled rejection — which in Node takes\n   * the whole render process down instead of letting this 404. So the nodes\n   * handed to the compose absorb the failure (an empty tree it will never be\n   * asked for), and `composed` gets a rejection handler attached the moment\n   * it exists rather than at the point we decide to drop it. The real error\n   * still propagates, from the `await versionPromise` below, exactly where it\n   * did when this function awaited the version directly.\n   */\n  const composed = composeNodesWithChrome({\n    hostId,\n    // Version-first (key-present wins, null = explicitly no layout), screen\n    // fallback — resolved as a promise so only the layout-chain walk waits on\n    // the version read; the rest of the chrome bundle keeps the AGL-1428\n    // overlap. A failed version read falls back to the screen binding; the\n    // whole compose is discarded on that path anyway.\n    layoutId: versionPromise.then(\n      (res) =>\n        res.version && 'layoutId' in res.version\n          ? ((res.version as Aglyn.AglynScreenVersion).layoutId as\n              | string\n              | null)\n          : (screen.layoutId as string | undefined),\n      () => screen.layoutId as string | undefined,\n    ),\n    // The screen's values for its layouts' properties (AGL-2893), beside the\n    // binding on the same document; a failed read renders the defaults.\n    layoutPropValues: versionPromise.then(\n      (res) =>\n        (res.version as Aglyn.AglynScreenVersion | undefined)?.layoutPropValues,\n      () => undefined,\n    ),\n    screenNodes: versionPromise.then(\n      (res) => (res.version?.nodes ?? {}) as any,\n      () => ({}) as any,\n    ),\n    tokens: options.tokens,\n    collection: options.collection,\n    host: options.host,\n    socialImages: options.socialImages,\n  })\n  void composed.catch(() => undefined)\n\n  const versionRes = await versionPromise\n  if (versionRes.error || !versionRes.version) return null\n\n  return composed\n}\n\nexport default composeScreenNodes\n"],"names":["Aglyn","applyMediaAssetFacts","mediaAssetRefs","applyDuePublishSchedule","getComponents","getDatasets","getForms","getMediaAssetFacts","getPublishedCollectionSource","getPluginInstalls","getVariables","getFunctions","getWorkflows","getPublishedLayoutVersion","getScreenVersion","socialImageAssetFacts","socialImageRefs","stampFormDatasetBindings","scanCollectionBlocks","nodes","collection","slugs","Set","hasRelated","hasCategories","hasSearch","node","Object","values","componentId","COLLECTION_ENTRIES_COMPONENT_ID","slug","String","props","collectionSlug","trim","add","COLLECTION_CATEGORIES_COMPONENT_ID","COLLECTION_SEARCH_COMPONENT_ID","COLLECTION_RELATED_COMPONENT_ID","entry","prefetchCollectionSources","hostId","screenNodes","prefetched","entries","pending","catch","undefined","expandCollectionEntryBlocks","size","sources","Promise","all","map","categories","page","entriesReachedBound","reachedBound","fetched","expanded","expandCollectionEntries","withCategories","expandCollectionCategories","routeless","categorySlug","withSearch","expandCollectionSearch","expandCollectionRelated","composeNodesWithChrome","options","layoutId","walkLayoutChain","chain","seen","boundLayoutId","currentLayoutId","has","length","MAX_LAYOUT_CHAIN_DEPTH","layoutRes","push","version","parentId","layout","chromeBundle","screenDatasetKeys","repeatDatasetKeys","screenDatasetsPromise","keys","screenFormsPromise","placesFormEntity","prefetchedSources","layoutChain","componentsRes","bulk","rawVariables","functions","workflows","pluginInstalls","screenDatasets","layoutPropValues","composedNodes","composeLayoutChainWithProps","graftedComponents","composeReusableComponentNodes","definitions","forms","grafted","placedFormPlacement","variables","resolveComputedVariables","datasetKeys","unreadDatasetKeys","filter","key","includes","datasets","repeated","expandRepeatables","withEntries","withEntryMeta","expandCollectionEntryMeta","withEntryAuthor","expandCollectionEntryAuthor","bound","resolveNodesBindings","withHostTokens","resolveNodesHostTokens","host","withFunctions","attachFunctionDefinitions","attachPluginInstalls","finalNodes","resolveNamedTokens","tokens","withLandmark","stampDocumentLandmark","withFormBindings","denormalized","canvas","processNodesToDenormalized","socialImages","cardRefs","images","refs","facts","cardFacts","onFacts","composeScreenNodes","screenId","screen","effectiveVersionId","versionId","collectionName","docId","parent","versionPromise","composed","then","res","versionRes","error"],"mappings":";AAAA;;;;;;;;;;;;;;;CAeC,GAED,YAAYA,WAAW,sBAAqB;AAC5C,uEAAuE;AACvE,sDAAsD;AACtD,SACEC,oBAAoB,EACpBC,cAAc,QACT,2CAA0C;AACjD,OAAOC,6BAA6B,8BAA0B;AAC9D,OAAOC,mBAAmB,sBAAkB;AAC5C,OAAOC,iBAAiB,oBAAgB;AACxC,OAAOC,cAAc,iBAAa;AAClC,OAAOC,wBAAwB,6BAAyB;AACxD,SACEC,4BAA4B,QAEvB,8BAA0B;AACjC,OAAOC,uBAAuB,2BAAuB;AACrD,OAAOC,gBAAgBC,YAAY,EAAEC,YAAY,QAAQ,qBAAiB;AAC1E,OAAOC,+BAA+B,0BAAsB;AAC5D,OAAOC,sBAAsB,0BAAsB;AACnD,SAEEC,qBAAqB,EACrBC,eAAe,QACV,0BAAsB;AAC7B,SAASC,wBAAwB,QAAQ,mCAA+B;AA+DxE;;;;;;;;;CASC,GACD,SAASC,qBACPC,KAA0B,EAC1BC,UAAqC;IAErC,MAAMC,QAAQ,IAAIC;IAClB,IAAIC,aAAa;IACjB,IAAIC,gBAAgB;IACpB,IAAIC,YAAY;IAChB,KAAK,MAAMC,QAAQC,OAAOC,MAAM,CAACT,OAAQ;QACvC,IAAIO,CAAAA,wBAAAA,KAAMG,WAAW,MAAK7B,MAAM8B,+BAA+B,EAAE;;gBAEtDJ;YADT,MAAMK,OACJC,eAAON,yBAAAA,cAAAA,KAAMO,KAAK,qBAAXP,YAAaQ,cAAc,mBAAI,IAAIC,IAAI,OAAMf,8BAAAA,WAAYW,IAAI;YACtE,IAAIA,MAAMV,MAAMe,GAAG,CAACL;QACtB;QACA,wEAAwE;QACxE,yDAAyD;QACzD,IAAIL,CAAAA,wBAAAA,KAAMG,WAAW,MAAK7B,MAAMqC,kCAAkC,EAAE;;gBAEzDX;YADT,MAAMK,OACJC,gBAAON,yBAAAA,eAAAA,KAAMO,KAAK,qBAAXP,aAAaQ,cAAc,oBAAI,IAAIC,IAAI,OAAMf,8BAAAA,WAAYW,IAAI;YACtE,IAAIA,MAAM;gBACRP,gBAAgB;gBAChBH,MAAMe,GAAG,CAACL;YACZ;QACF;QACA,yEAAyE;QACzE,uEAAuE;QACvE,mDAAmD;QACnD,IAAIL,CAAAA,wBAAAA,KAAMG,WAAW,MAAK7B,MAAMsC,8BAA8B,EAAE;;gBAErDZ;YADT,MAAMK,OACJC,gBAAON,yBAAAA,eAAAA,KAAMO,KAAK,qBAAXP,aAAaQ,cAAc,oBAAI,IAAIC,IAAI,OAAMf,8BAAAA,WAAYW,IAAI;YACtE,IAAIA,MAAM;gBACRN,YAAY;gBACZJ,MAAMe,GAAG,CAACL;YACZ;QACF;QACA,uEAAuE;QACvE,8DAA8D;QAC9D,IACEL,CAAAA,wBAAAA,KAAMG,WAAW,MAAK7B,MAAMuC,+BAA+B,KAC3DnB,8BAAAA,WAAYW,IAAI,KAChBX,WAAWoB,KAAK,EAChB;YACAjB,aAAa;YACbF,MAAMe,GAAG,CAAChB,WAAWW,IAAI;QAC3B;IACF;IACA,OAAO;QAAEV;QAAOE;QAAYC;QAAeC;IAAU;AACvD;AAEA;;;;;;;;;;;;;;;;;;;;;CAqBC,GACD,SAASgB,0BACPC,MAAc,EACdC,WAAgC,EAChCvB,UAAqC;IAErC,MAAMwB,aAGF,CAAC;IACL,KAAK,MAAMb,QAAQb,qBAAqByB,aAAavB,YAAYC,KAAK,CAAE;QACtE,IAAIU,UAASX,8BAAAA,WAAYW,IAAI,KAAIX,WAAWyB,OAAO,EAAE;QACrD,MAAMC,UAAUtC,6BAA6B;YAC3CkC;YACAR,gBAAgBH;QAClB;QACA,uEAAuE;QACvE,0EAA0E;QAC1E,2EAA2E;QAC3E,wEAAwE;QACxE,KAAKe,QAAQC,KAAK,CAAC,IAAMC;QACzBJ,UAAU,CAACb,KAAK,GAAGe;IACrB;IACA,OAAOF;AACT;AAEA;;;;;CAKC,GACD,eAAeK,4BACbP,MAAc,EACdvB,KAA0B,EAC1BC,UAAqC,EACrCwB,UAA+D;IAE/D,MAAM,EAAEvB,KAAK,EAAEE,UAAU,EAAEC,aAAa,EAAEC,SAAS,EAAE,GAAGP,qBACtDC,OACAC;IAEF,IAAI,CAACC,MAAM6B,IAAI,EAAE,OAAO/B;IACxB,MAAMgC,UAAyD,CAAC;IAChE,MAAMC,QAAQC,GAAG,CACf;WAAIhC;KAAM,CAACiC,GAAG,CAAC,OAAOvB;;QACpB,4DAA4D;QAC5D,gEAAgE;QAChE,IAAIA,UAASX,8BAAAA,WAAYW,IAAI,KAAIX,WAAWyB,OAAO,EAAE;YACnDM,OAAO,CAACpB,KAAK,GAAG;gBACdA;gBACAc,SAASzB,WAAWyB,OAAO;gBAC3BU,YAAYnC,WAAWmC,UAAU;eAG7BnC,WAAWoC,IAAI,GAAG;gBAAEA,MAAMpC,WAAWoC,IAAI;YAAC,IAAI,CAAC,GAG/CpC,WAAWqC,mBAAmB,GAAG;gBAAEC,cAAc;YAAK,IAAI,CAAC;YAEjE;QACF;QACA,qEAAqE;QACrE,qEAAqE;QACrE,MAAMC,UAAU,eAAOf,8BAAAA,UAAY,CAACb,KAAK,mBACvCvB,6BAA6B;YAAEkC;YAAQR,gBAAgBH;QAAK;QAC9DoB,OAAO,CAACpB,KAAK,GAAG;YACdA;YACAc,SAASc,QAAQd,OAAO;YACxBU,YACExB,UAASX,8BAAAA,WAAYW,IAAI,KAAIX,WAAWmC,UAAU,GAC9CnC,WAAWmC,UAAU,GACrBI,QAAQJ,UAAU;WACpBI,QAAQD,YAAY,GAAG;YAAEA,cAAc;QAAK,IAAI,CAAC;IAEzD;IAEF,MAAME,WAAW5D,MAAM6D,uBAAuB,CAC5C1C,OACAgC,SACA/B,8BAAAA,WAAYW,IAAI;IAElB,MAAM+B,iBAAiBtC,gBACnBxB,MAAM+D,0BAA0B,CAC9BH,UACAT,SACA;;;;;;;;;;;;;;;;;QAiBA,GACA/B,CAAAA,8BAAAA,WAAY4C,SAAS,IAAGhB,YAAY5B,8BAAAA,WAAYW,IAAI,EACpDX,8BAAAA,WAAY6C,YAAY,IAE1BL;IACJ,MAAMM,aAAazC,YACfzB,MAAMmE,sBAAsB,CAACL,gBAAgBX,SAAS/B,8BAAAA,WAAYW,IAAI,IACtE+B;IACJ,IAAI,CAACvC,cAAc,EAACH,8BAAAA,WAAYoB,KAAK,GAAE,OAAO0B;IAC9C,OAAOlE,MAAMoE,uBAAuB,CAClCF,YACAf,OAAO,CAAC/B,WAAWW,IAAI,CAAC,EACxBX,WAAWoB,KAAK;AAEpB;AAEA;;;;;;;;;CASC,GACD,OAAO,eAAe6B,uBAAuBC,OAuD5C;;QAyKI,OAyDDA,qBACAA,sBAOAA;IAzOF,MAAM,EAAE5B,MAAM,EAAE6B,QAAQ,EAAE,GAAGD;IAE7B;;;;;;;;;;;;;GAaC,GACD,MAAME,kBAAkB;QACtB,MAAMC,QAAkC,EAAE;QAC1C,MAAMC,OAAO,IAAIpD;QACjB,MAAMqD,gBAAgB,MAAMJ;QAC5B,IAAIK,kBAAkBD,gBAAgB3C,OAAO2C,iBAAiB3B;QAC9D,MACE4B,mBACA,CAACF,KAAKG,GAAG,CAACD,oBACVH,MAAMK,MAAM,GAAG9E,MAAM+E,sBAAsB,CAC3C;gBAWSC,oBACCA,qBAGQA;YAdlBN,KAAKtC,GAAG,CAACwC;YACT,MAAMI,YAAY,MAAMnE,0BAA0B;gBAChD6B;gBACA6B,UAAUK;YACZ;YACA,sEAAsE;YACtE,sEAAsE;YACtE,2DAA2D;YAC3DH,MAAMQ,IAAI,CAAC;gBACTV,UAAUK;gBACVzD,KAAK,EAAE6D,8BAAAA,qBAAAA,UAAWE,OAAO,qBAAlBF,mBAAoB7D,KAAK;gBAChCc,KAAK,EAAG+C,8BAAAA,sBAAAA,UAAWE,OAAO,qBAAnB,AAACF,oBACJ/C,KAAK;YACX;YACA,MAAMkD,WAAYH,8BAAAA,oBAAAA,UAAWI,MAAM,qBAAlB,AAACJ,kBAA2BT,QAAQ;YACrDK,kBAAkBO,WAAWnD,OAAOmD,YAAYnC;QAClD;QACA,OAAOyB;IACT;IAEA;;;;;;;;;;;;;;;;;;;;GAoBC,GACD;;;;;;;;;;;;;GAaC,GACD;;;;;;;;;;;;;;;GAeC,GACD,MAAMY,eAAejC,QAAQC,GAAG,CAAC;QAC/BmB;QACApE,cAAc;YAAEsC;QAAO;QACvB,8DAA8D;QAC9D,sEAAsE;QACtE,gCAAgC;QAChCU,QAAQC,GAAG,CAAC;YACV3C,aAAa;gBAAEgC;YAAO;YACtB/B,aAAa;gBAAE+B;YAAO;YACtB9B,aAAa;gBAAE8B;YAAO;YACtBjC,kBAAkB;gBAAEiC;YAAO;SAC5B;KACF;IACD,MAAMC,cAAc,MAAM2B,QAAQ3B,WAAW;IAC7C,MAAM2C,oBAAoBtF,MAAMuF,iBAAiB,CAAC5C;IAClD,MAAM6C,wBAAwBF,kBAAkBR,MAAM,GAClDzE,YAAY;QAAEqC;QAAQ+C,MAAMH;IAAkB,KAC9CtC;IACJ,yEAAyE;IACzE,6EAA6E;IAC7E,0EAA0E;IAC1E,6EAA6E;IAC7E,6EAA6E;IAC7E,yDAAyD;IACzD,MAAM0C,qBAAqB1F,MAAM2F,gBAAgB,CAAChD,eAC9CrC,SAAS;QAAEoC;IAAO,KAClBM;IACJ,wEAAwE;IACxE,sEAAsE;IACtE,MAAM4C,oBAAoBnD,0BACxBC,QACAC,aACA2B,QAAQlD,UAAU;IAEpB,MAAM,CAACyE,aAAaC,eAAeC,KAAK,GAAG,MAAMV;IACjD,MAAM,CAACW,cAAcC,WAAWC,WAAWC,eAAe,GAAGJ;IAC7D,MAAMK,iBAAiB,MAAMZ;IAC7B,sEAAsE;IACtE,8CAA8C;IAC9C,MAAMa,mBAAmB,MAAM/B,QAAQ+B,gBAAgB;IAEvD,MAAMC,gBAAgBtG,MAAMuG,2BAA2B,CACrDV,aACAlD,aACA0D;IAEF,MAAMG,oBAAoBxG,MAAMyG,6BAA6B,CAC3DH,eACAR,cAAcY,WAAW;IAE3B;;;;;;;;;;;;;;;;;;;GAmBC,GACD,MAAMC,iBACH,QAAA,MAAMjB,uCAAP,AAAC,MAA2BiB,KAAK,mBAChC3G,MAAM2F,gBAAgB,CAACa,qBACpB,AAAC,CAAA,MAAMlG,SAAS;QAAEoC;IAAO,EAAC,EAAGiE,KAAK,GAClC3D;IACN,MAAM4D,UAAUD,QACZ3G,MAAMyG,6BAA6B,CACjCD,mBACAV,cAAcY,WAAW,EACzB;QAAC1G,MAAM6G,mBAAmB,CAACF;KAAc,IAE3CH;IACJ,wEAAwE;IACxE,0DAA0D;IAC1D,MAAMM,YAAY9G,MAAM+G,wBAAwB,CAC9Cf,cACAC,WACAC;IAEF,mEAAmE;IACnE,sEAAsE;IACtE,+BAA+B;IAC/B,EAAE;IACF,6EAA6E;IAC7E,2EAA2E;IAC3E,2EAA2E;IAC3E,0EAA0E;IAC1E,oEAAoE;IACpE,4EAA4E;IAC5E,+DAA+D;IAC/D,MAAMc,cAAchH,MAAMuF,iBAAiB,CAACqB;IAC5C,MAAMK,oBAAoBD,YAAYE,MAAM,CAC1C,CAACC,MAAQ,CAAC7B,kBAAkB8B,QAAQ,CAACD;IAEvC,MAAME,WAAWJ,kBAAkBnC,MAAM,GACrC,aACKsB,gBACC,MAAM/F,YAAY;QAAEqC;QAAQ+C,MAAMwB;IAAkB,MAE1Db;IACJ,MAAMkB,WAAWtH,MAAMuH,iBAAiB,CAACX,SAAgBS;IACzD,oEAAoE;IACpE,wEAAwE;IACxE,uDAAuD;IACvD,MAAMG,cAAc,MAAMvE,4BACxBP,QACA4E,UACAhD,QAAQlD,UAAU,EAClBwE;IAEF,0EAA0E;IAC1E,sEAAsE;IACtE,4EAA4E;IAC5E,2EAA2E;IAC3E,4EAA4E;IAC5E,mBAAmB;IACnB,MAAM6B,gBAAgBzH,MAAM0H,yBAAyB,CACnDF,cACAlD,sBAAAA,QAAQlD,UAAU,qBAAlBkD,oBAAoB9B,KAAK,GACzB8B,uBAAAA,QAAQlD,UAAU,qBAAlBkD,qBAAoBf,UAAU;IAEhC,2EAA2E;IAC3E,qEAAqE;IACrE,sEAAsE;IACtE,MAAMoE,kBAAkB3H,MAAM4H,2BAA2B,CACvDH,gBACAnD,uBAAAA,QAAQlD,UAAU,qBAAlBkD,qBAAoB9B,KAAK;IAE3B,MAAMqF,QAAQ7H,MAAM8H,oBAAoB,CACtCH,iBACAb,WACAb;IAEF,uEAAuE;IACvE,wEAAwE;IACxE,qEAAqE;IACrE,oEAAoE;IACpE,MAAM8B,iBAAiB/H,MAAMgI,sBAAsB,CACjDH,OACAvD,QAAQ2D,IAAI;IAEd,0EAA0E;IAC1E,mEAAmE;IACnE,cAAc;IACd,MAAMC,gBAAgBlI,MAAMmI,yBAAyB,CACnDJ,gBACA9B,WACAa;IAEF,2EAA2E;IAC3E,oEAAoE;IACpE,MAAM3F,QAAQnB,MAAMoI,oBAAoB,CAACF,eAAe/B;IACxD,wEAAwE;IACxE,MAAMkC,aAAarI,MAAMsI,kBAAkB,CAACnH,OAAcmD,QAAQiE,MAAM;IACxE,4EAA4E;IAC5E,2EAA2E;IAC3E,sDAAsD;IACtD,MAAMC,eAAexI,MAAMyI,qBAAqB,CAACJ;IACjD,uEAAuE;IACvE,4EAA4E;IAC5E,2EAA2E;IAC3E,qEAAqE;IACrE,oBAAoB;IACpB,MAAMK,mBAAmBzH,yBAAyBuH,cAAc9F;IAChE,MAAMiG,eAAe3I,MAAM4I,MAAM,CAACC,0BAA0B,CAC1DH;IAEF;;;;;;;;;;;;;;;;;;;;;;;GAuBC,GACD,MAAMI,eAAexE,QAAQwE,YAAY;IACzC,MAAMC,WAAWD,eAAe9H,gBAAgB8H,aAAaE,MAAM,IAAI,EAAE;IACzE,MAAMC,OAAO/I,eAAeyI;IAC5B,IAAI,CAACM,KAAKnE,MAAM,IAAI,CAACiE,SAASjE,MAAM,EAAE,OAAO6D;IAC7C,MAAMO,QAAQ,MAAM3I,mBAAmB;QACrCmC;QACAuG,MAAM;eAAIF;eAAaE;SAAK;IAC9B;IACA,IAAIH,cAAc;QAChB,MAAMK,YAAYpI,sBAAsB+H,aAAaE,MAAM,EAAEE;QAC7D,IAAIC,WAAWL,aAAaM,OAAO,CAACD;IACtC;IACA,OAAOlJ,qBAAqB0I,cAAcO;AAC5C;AAEA;;;;;CAKC,GACD,OAAO,eAAeG,mBAAmB/E,OAiBxC;QAWoBA,MAAAA;IAVnB,MAAM,EAAE5B,MAAM,EAAE4G,QAAQ,EAAEC,MAAM,EAAE,GAAGjF;IAErC,MAAMkF,qBAAqBlF,QAAQmF,SAAS,GACxC,OACA,MAAMtJ,wBAAwB;QAC5BuC;QACAgH,gBAAgB;QAChBC,OAAOL;QACPM,QAAQL;IACV;IACJ,MAAME,aAAanF,QAAAA,qBAAAA,QAAQmF,SAAS,YAAjBnF,qBACjBkF,8BADiBlF,OAEjBiF,OAAOE,SAAS;IAElB;;;;;;;;;;;;;;;;GAgBC,GACD,IAAI,CAACA,WAAW,OAAO;IAEvB,MAAMI,iBAAiB/I,iBAAiB;QAAE4B;QAAQ4G;QAAUG;IAAU;IAEtE;;;;;;;;;;;GAWC,GACD,MAAMK,WAAWzF,uBAAuB;QACtC3B;QACA,wEAAwE;QACxE,0EAA0E;QAC1E,qEAAqE;QACrE,uEAAuE;QACvE,kDAAkD;QAClD6B,UAAUsF,eAAeE,IAAI,CAC3B,CAACC,MACCA,IAAI9E,OAAO,IAAI,cAAc8E,IAAI9E,OAAO,GACnC,AAAC8E,IAAI9E,OAAO,CAA8BX,QAAQ,GAGlDgF,OAAOhF,QAAQ,EACtB,IAAMgF,OAAOhF,QAAQ;QAEvB,yEAAyE;QACzE,oEAAoE;QACpE8B,kBAAkBwD,eAAeE,IAAI,CACnC,CAACC;gBACEA;oBAAAA,eAAAA,IAAI9E,OAAO,qBAAZ,AAAC8E,aAAsD3D,gBAAgB;WACzE,IAAMrD;QAERL,aAAakH,eAAeE,IAAI,CAC9B,CAACC;;gBAASA;4BAAAA,eAAAA,IAAI9E,OAAO,qBAAX8E,aAAa7I,KAAK,mBAAI,CAAC;WACjC,IAAO,CAAA,CAAC,CAAA;QAEVoH,QAAQjE,QAAQiE,MAAM;QACtBnH,YAAYkD,QAAQlD,UAAU;QAC9B6G,MAAM3D,QAAQ2D,IAAI;QAClBa,cAAcxE,QAAQwE,YAAY;IACpC;IACA,KAAKgB,SAAS/G,KAAK,CAAC,IAAMC;IAE1B,MAAMiH,aAAa,MAAMJ;IACzB,IAAII,WAAWC,KAAK,IAAI,CAACD,WAAW/E,OAAO,EAAE,OAAO;IAEpD,OAAO4E;AACT;AAEA,eAAeT,mBAAkB"}

package/src/lib/compose-search-page.d.ts

@@ -0,0 +1,39 @@
+/**
+ * @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 SearchResultsNodesOptions } from './search-results-nodes';
+/**
+ * `/search` composed the way every other page of the site is (AGL-2513):
+ * the built-in results body grafted into the site's shared layout, so the
+ * page carries the same header, nav and footer as the pages it links to.
+ *
+ * Which layout is the host's to choose — see `resolveBuiltInPageLayoutId`.
+ * With none resolvable the body composes alone, which is the page as it was
+ * before this existed: themed, chrome-less, and still a working search page.
+ *
+ * Fail-open to `null`, and the route then renders the body with no chrome at
+ * all. A search page is where a lost visitor goes; it must not be the page
+ * that 500s because a layout was deleted.
+ */
+export declare function composeSearchPage(options: {
+    hostId: string;
+    host: any;
+    results: SearchResultsNodesOptions;
+}): Promise<{
+    nodes: Record<string, any>;
+    layoutId?: string;
+} | null>;
+export default composeSearchPage;

package/src/lib/compose-search-page.js

@@ -0,0 +1,57 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ import { _ as _extends } from "@swc/helpers/_/_extends";
+import { resolveBuiltInPageLayoutId } from "./built-in-page-layout.js";
+import { composeNodesWithChrome } from "./compose-screen-nodes.js";
+import { buildSearchResultsNodes } from "./search-results-nodes.js";
+/**
+ * `/search` composed the way every other page of the site is (AGL-2513):
+ * the built-in results body grafted into the site's shared layout, so the
+ * page carries the same header, nav and footer as the pages it links to.
+ *
+ * Which layout is the host's to choose — see `resolveBuiltInPageLayoutId`.
+ * With none resolvable the body composes alone, which is the page as it was
+ * before this existed: themed, chrome-less, and still a working search page.
+ *
+ * Fail-open to `null`, and the route then renders the body with no chrome at
+ * all. A search page is where a lost visitor goes; it must not be the page
+ * that 500s because a layout was deleted.
+ */ export async function composeSearchPage(options) {
+    const { hostId, host, results } = options;
+    try {
+        const layoutId = await resolveBuiltInPageLayoutId({
+            hostId,
+            host
+        });
+        const nodes = await composeNodesWithChrome({
+            hostId,
+            layoutId,
+            screenNodes: buildSearchResultsNodes(results),
+            host: host
+        });
+        return nodes ? _extends({
+            nodes
+        }, layoutId ? {
+            layoutId
+        } : {}) : null;
+    } catch (error) {
+        console.error('search page composition failed', error);
+        return null;
+    }
+}
+export default composeSearchPage;
+
+//# sourceMappingURL=compose-search-page.js.map

package/src/lib/compose-search-page.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../libs/tenant/runtime/src/lib/compose-search-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 { resolveBuiltInPageLayoutId } from './built-in-page-layout'\nimport { composeNodesWithChrome } from './compose-screen-nodes'\nimport {\n  buildSearchResultsNodes,\n  type SearchResultsNodesOptions,\n} from './search-results-nodes'\n\n/**\n * `/search` composed the way every other page of the site is (AGL-2513):\n * the built-in results body grafted into the site's shared layout, so the\n * page carries the same header, nav and footer as the pages it links to.\n *\n * Which layout is the host's to choose — see `resolveBuiltInPageLayoutId`.\n * With none resolvable the body composes alone, which is the page as it was\n * before this existed: themed, chrome-less, and still a working search page.\n *\n * Fail-open to `null`, and the route then renders the body with no chrome at\n * all. A search page is where a lost visitor goes; it must not be the page\n * that 500s because a layout was deleted.\n */\nexport async function composeSearchPage(options: {\n  hostId: string\n  host: any\n  results: SearchResultsNodesOptions\n}): Promise<{ nodes: Record<string, any>; layoutId?: string } | null> {\n  const { hostId, host, results } = options\n  try {\n    const layoutId = await resolveBuiltInPageLayoutId({ hostId, host })\n    const nodes = await composeNodesWithChrome({\n      hostId,\n      layoutId,\n      screenNodes: buildSearchResultsNodes(results),\n      host: host as Aglyn.HostTokenSource,\n    })\n    return nodes ? { nodes, ...(layoutId ? { layoutId } : {}) } : null\n  } catch (error) {\n    console.error('search page composition failed', error)\n    return null\n  }\n}\n\nexport default composeSearchPage\n"],"names":["resolveBuiltInPageLayoutId","composeNodesWithChrome","buildSearchResultsNodes","composeSearchPage","options","hostId","host","results","layoutId","nodes","screenNodes","error","console"],"mappings":"AAAA;;;;;;;;;;;;;;;CAeC;AAGD,SAASA,0BAA0B,QAAQ,4BAAwB;AACnE,SAASC,sBAAsB,QAAQ,4BAAwB;AAC/D,SACEC,uBAAuB,QAElB,4BAAwB;AAE/B;;;;;;;;;;;;CAYC,GACD,OAAO,eAAeC,kBAAkBC,OAIvC;IACC,MAAM,EAAEC,MAAM,EAAEC,IAAI,EAAEC,OAAO,EAAE,GAAGH;IAClC,IAAI;QACF,MAAMI,WAAW,MAAMR,2BAA2B;YAAEK;YAAQC;QAAK;QACjE,MAAMG,QAAQ,MAAMR,uBAAuB;YACzCI;YACAG;YACAE,aAAaR,wBAAwBK;YACrCD,MAAMA;QACR;QACA,OAAOG,QAAQ;YAAEA;WAAWD,WAAW;YAAEA;QAAS,IAAI,CAAC,KAAO;IAChE,EAAE,OAAOG,OAAO;QACdC,QAAQD,KAAK,CAAC,kCAAkCA;QAChD,OAAO;IACT;AACF;AAEA,eAAeR,kBAAiB"}

package/src/lib/convert-host-lead.d.ts

@@ -0,0 +1,189 @@
+/**
+ * @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.
+ */
+/**
+ * A lead becomes a contact, and optionally a company and a deal (AGL-2608,
+ * AGL-2627).
+ *
+ * ## Why one function under two doors
+ *
+ * The console's convert dialog posts to the CRM plugin's `crm/lead-convert`
+ * route, and an integration posts to `POST /v1/leads/{id}/convert`. The two
+ * doors authenticate differently — an ID token against the site's role, an
+ * API key against its scopes — and answer in different envelopes, but what
+ * they DO has to be one thing: a conversion that opened a second deal for
+ * one person because two callers reached the same lead through two
+ * implementations is the bug this file exists to make impossible. The doors
+ * own their transport; this owns the writes.
+ *
+ * It lives here, in the tenancy runtime, rather than beside the plugin
+ * route it came from, because the console's REST layer may not import a
+ * feature plugin (the app→addons boundary), while both the plugin and the
+ * console may import the runtime — which already holds the capture door
+ * and the owner assignment this conversion goes through.
+ *
+ * ## Why a server function and not four client writes
+ *
+ * The lead is a host document the browser may edit, and a company or a deal
+ * is a client-creatable org document. What the browser cannot do is CREATE A
+ * CONTACT: the contacts collection is written only by `captureHostContact`
+ * (the runtime's wrapper over `upsertHostContact`, so `contactCreated`
+ * fires), because that function is the dedupe — one human, one row, found by
+ * normalized address across every site in the org — and the audience-band
+ * gate. A client that wrote a contact document of its own would mint a
+ * second row for a person the org already holds, and would do it past the
+ * band.
+ *
+ * Once the contact has to come from the server, the rest follows it: the
+ * conversion is one act with four writes, and a caller that made three of
+ * them and lost the connection before the fourth leaves a lead marked
+ * qualified with no contact, or a deal pointing at a contact that was never
+ * stamped on the lead. Here the order is fixed — contact, then company, then
+ * deal, then the lead — and the lead is stamped LAST, so a lead that carries
+ * `convertedContactId` names a contact that exists.
+ *
+ * ## Idempotent on the lead
+ *
+ * A lead already carrying `convertedContactId` answers with the ids it has
+ * and creates nothing more. A double-click on the dialog's button, a retry
+ * after a slow response, or a Zapier zap replaying a step must not open a
+ * second deal for one person.
+ *
+ * ## The actor
+ *
+ * A signed-in member converting from the console owns what nobody else
+ * claimed: their uid is the owner of last resort, written directly rather
+ * than through the deliberate reassignment, because they may be staff
+ * converting on a workspace's behalf and a roster check would refuse the one
+ * person who is actually here. An API key is not a person and is on no
+ * roster, so for an `api` actor that last step is skipped and a contact
+ * nobody chose an owner for — and no rule assigned — stays unowned, which
+ * the console renders honestly as unassigned. Either way the caller has
+ * already been authorized by its door; nothing here asks again.
+ */
+import { type CrmDealStage, type CrmPipeline } from '@aglyn/aglyn/server';
+/** Who is converting, as far as the writes need to know. */
+export interface LeadConvertActor {
+    /**
+     * What `createdByUid` records on every record the conversion opens, and
+     * who the audit line names. A member's uid, or the literal `'api'` for a
+     * key — the same attribution the REST creates stamp.
+     */
+    uid: string;
+    email?: string | null;
+    /**
+     * `member`: a signed-in person, who becomes the owner when nobody else
+     * does. `api`: a key, which cannot own a record — see the header.
+     */
+    kind: 'member' | 'api';
+    /**
+     * For an `api` actor, the key's name — what the audit line attributes the
+     * conversion to, since a key has no address to be named by.
+     */
+    apiKeyName?: string | null;
+}
+/** What a conversion is asked to do. Validated by the door before it gets here. */
+export interface ConvertHostLeadInput {
+    firestore: FirebaseFirestore.Firestore;
+    hostId: string;
+    orgId: string;
+    /** The org document, as the door resolved it. */
+    org: Record<string, unknown>;
+    /** `hosts/{hostId}/leads/{leadId}` — the document id, which is the person key. */
+    leadId: string;
+    actor: LeadConvertActor;
+    /**
+     * Who owns the resulting contact (and deal). Defaults to the lead's own
+     * owner; failing that the org's assignment rules and the site's default
+     * owner decide (AGL-2618), and failing those a member actor — somebody
+     * converted this person, and a record with no owner is one nobody follows
+     * up.
+     */
+    ownerUid?: string;
+    /** Link an existing `orgs/{orgId}/companies/{companyId}`. */
+    companyId?: string;
+    /** Or create one. Ignored when `companyId` is given. Already normalized. */
+    createCompany?: {
+        name: string;
+        domain: string | null;
+    } | null;
+    /** Open a deal in the org's default pipeline. Already normalized. */
+    deal?: {
+        title: string;
+        amountCents: number | null;
+        /** Lowercase ISO 4217. */
+        currency: string;
+        /** A stage of the default pipeline; its first open stage when absent. */
+        stageId?: string;
+    } | null;
+}
+/**
+ * Why a conversion did not happen. Each is a state of the data, not a fault
+ * of the request — the door has already refused a malformed body — and each
+ * leaves the lead unconverted so a retry after the remedy finds it where it
+ * was.
+ */
+export type ConvertHostLeadRefusal = 
+/** No document at `hosts/{hostId}/leads/{leadId}`. */
+'unknown-lead'
+/** The lead's address cannot become a contact. */
+ | 'no-email'
+/**
+ * The capture door produced no contact — it swallows its own failures and
+ * drops a creation past a Free org's audience band. Nothing was written.
+ */
+ | 'contact-not-created'
+/**
+ * The site holds an erasure for the lead's address (AGL-2623): the person
+ * asked to be forgotten, and the capture door refuses to rebuild a record
+ * for them — by a conversion as by a form. Nothing was written, and the
+ * lead stays as it was; the erasure removes it when it runs.
+ */
+ | 'erased'
+/** The CRM records band is full (AGL-2611); the contact stands, nothing more was opened. */
+ | 'band-full'
+/** `companyId` names no company in this organization. The contact stands. */
+ | 'unknown-company'
+/** The default pipeline has no stages to open a deal in. The contact stands. */
+ | 'no-stages';
+export type ConvertHostLeadResult = {
+    ok: true;
+    contactId: string;
+    companyId?: string;
+    dealId?: string;
+    /** The lead was converted before this call; nothing was created now. */
+    alreadyConverted: boolean;
+} | {
+    ok: false;
+    reason: ConvertHostLeadRefusal;
+};
+/**
+ * The stage a new deal opens in.
+ *
+ * The caller's choice when the pipeline has it, otherwise the first OPEN
+ * stage by order — a deal created by converting a lead is by definition not
+ * yet won or lost, so defaulting to a closed stage would record an outcome
+ * nobody reached. A pipeline with no open stage at all falls back to its
+ * first stage rather than refusing: the merchant edited their pipeline into
+ * that shape, and a conversion that failed because of it would read as a bug
+ * in the lead.
+ */
+export declare function stageForNewDeal(pipeline: Pick<CrmPipeline, 'stages'>, requestedStageId: string | undefined): CrmDealStage | null;
+/**
+ * Convert one lead. Throws only on infrastructure failure; every refusal
+ * the data can produce is a `ConvertHostLeadResult`.
+ */
+export declare function convertHostLead(input: ConvertHostLeadInput): Promise<ConvertHostLeadResult>;