@aglyn/tenant-runtime 1.0.0-beta.143

package/src/lib/get-screen-version.d.ts

@@ -0,0 +1,27 @@
+/**
+ * @license
+ * Copyright 2024 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';
+export declare function getScreenVersion(options: {
+    hostId: Aglyn.HostUid;
+    screenId: Aglyn.ScreenUid;
+    versionId: Aglyn.VersionUid;
+}): Promise<{
+    version: Aglyn.AglynScreen;
+    nextPageToken: string;
+    error: any;
+}>;
+export default getScreenVersion;

package/src/lib/get-screen-version.js

@@ -0,0 +1,66 @@
+/**
+ * @license
+ * Copyright 2024 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 { firebaseAdmin, screenVersionConverter } from "@aglyn/tenant-data-admin";
+import { PUBLISHED_SITE_DATA_TTL_SECONDS, tenantDataTag, withRenderCache } from "@aglyn/tenant-data-admin/render-cache";
+/**
+ * The version doc is the LARGEST read of a render (the whole node tree), and
+ * it is keyed by `versionId` — a publish points the screen doc at a NEW
+ * version, so a re-publish lands under a new cache key on its own. The TTL
+ * is finite rather than treating versions as immutable, because the editor
+ * can save into an already-published version doc. It is
+ * `PUBLISHED_SITE_DATA_TTL_SECONDS`, an HOUR — long enough that a save into
+ * a live version is NOT what makes it visible; the publish-path
+ * `revalidateTag(tenantDataTag(hostId))` bust is (AGL-1302). A write that
+ * reaches Firestore without going through publish waits out the full TTL.
+ */ const SCREEN_VERSION_TTL_SECONDS = PUBLISHED_SITE_DATA_TTL_SECONDS;
+async function readScreenVersionDoc(hostId, screenId, versionId) {
+    const snapshot = await firebaseAdmin.app().firestore().collection('hosts').doc(hostId).collection('screens').doc(screenId).collection('versions').withConverter(screenVersionConverter).doc(versionId).get();
+    return snapshot.exists ? snapshot.data() : null;
+}
+export async function getScreenVersion(options) {
+    const hostId = options == null ? void 0 : options.hostId;
+    const screenId = options == null ? void 0 : options.screenId;
+    const versionId = options == null ? void 0 : options.versionId;
+    const data = {
+        version: undefined,
+        nextPageToken: '',
+        error: null
+    };
+    try {
+        const version = await withRenderCache({
+            key: [
+                'tenant-screen-version',
+                hostId,
+                screenId,
+                versionId
+            ],
+            revalidate: SCREEN_VERSION_TTL_SECONDS,
+            tags: [
+                tenantDataTag(hostId)
+            ],
+            read: ()=>readScreenVersionDoc(hostId, screenId, versionId),
+            store: (value)=>value !== null
+        });
+        if (version) data.version = version;
+    } catch (error) {
+        console.error(error);
+        data.error = error;
+    }
+    return data;
+}
+export default getScreenVersion;
+
+//# sourceMappingURL=get-screen-version.js.map

package/src/lib/get-screen-version.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../libs/tenant/runtime/src/lib/get-screen-version.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2024 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 { firebaseAdmin, screenVersionConverter } from '@aglyn/tenant-data-admin'\nimport {\n  PUBLISHED_SITE_DATA_TTL_SECONDS,\n  tenantDataTag,\n  withRenderCache,\n} from '@aglyn/tenant-data-admin/render-cache'\n\n/**\n * The version doc is the LARGEST read of a render (the whole node tree), and\n * it is keyed by `versionId` — a publish points the screen doc at a NEW\n * version, so a re-publish lands under a new cache key on its own. The TTL\n * is finite rather than treating versions as immutable, because the editor\n * can save into an already-published version doc. It is\n * `PUBLISHED_SITE_DATA_TTL_SECONDS`, an HOUR — long enough that a save into\n * a live version is NOT what makes it visible; the publish-path\n * `revalidateTag(tenantDataTag(hostId))` bust is (AGL-1302). A write that\n * reaches Firestore without going through publish waits out the full TTL.\n */\nconst SCREEN_VERSION_TTL_SECONDS = PUBLISHED_SITE_DATA_TTL_SECONDS\n\nasync function readScreenVersionDoc(\n  hostId: string,\n  screenId: string,\n  versionId: string,\n): Promise<Aglyn.AglynScreen | null> {\n  const snapshot = await firebaseAdmin\n    .app()\n    .firestore()\n    .collection('hosts')\n    .doc(hostId)\n    .collection('screens')\n    .doc(screenId)\n    .collection('versions')\n    .withConverter(screenVersionConverter)\n    .doc(versionId)\n    .get()\n  return snapshot.exists ? (snapshot.data() as Aglyn.AglynScreen) : null\n}\n\nexport async function getScreenVersion(options: {\n  hostId: Aglyn.HostUid\n  screenId: Aglyn.ScreenUid\n  versionId: Aglyn.VersionUid\n}) {\n  const hostId = options?.hostId as string\n  const screenId = options?.screenId as string\n  const versionId = options?.versionId as string\n  const data = {\n    version: undefined as Aglyn.AglynScreen,\n    nextPageToken: '',\n    error: null,\n  }\n\n  try {\n    const version = await withRenderCache({\n      key: ['tenant-screen-version', hostId, screenId, versionId],\n      revalidate: SCREEN_VERSION_TTL_SECONDS,\n      tags: [tenantDataTag(hostId)],\n      read: () => readScreenVersionDoc(hostId, screenId, versionId),\n      store: (value) => value !== null,\n    })\n    if (version) data.version = version\n  } catch (error) {\n    console.error(error)\n    data.error = error\n  }\n\n  return data\n}\n\nexport default getScreenVersion\n"],"names":["firebaseAdmin","screenVersionConverter","PUBLISHED_SITE_DATA_TTL_SECONDS","tenantDataTag","withRenderCache","SCREEN_VERSION_TTL_SECONDS","readScreenVersionDoc","hostId","screenId","versionId","snapshot","app","firestore","collection","doc","withConverter","get","exists","data","getScreenVersion","options","version","undefined","nextPageToken","error","key","revalidate","tags","read","store","value","console"],"mappings":"AAAA;;;;;;;;;;;;;;;CAeC,GAGD,SAASA,aAAa,EAAEC,sBAAsB,QAAQ,2BAA0B;AAChF,SACEC,+BAA+B,EAC/BC,aAAa,EACbC,eAAe,QACV,wCAAuC;AAE9C;;;;;;;;;;CAUC,GACD,MAAMC,6BAA6BH;AAEnC,eAAeI,qBACbC,MAAc,EACdC,QAAgB,EAChBC,SAAiB;IAEjB,MAAMC,WAAW,MAAMV,cACpBW,GAAG,GACHC,SAAS,GACTC,UAAU,CAAC,SACXC,GAAG,CAACP,QACJM,UAAU,CAAC,WACXC,GAAG,CAACN,UACJK,UAAU,CAAC,YACXE,aAAa,CAACd,wBACda,GAAG,CAACL,WACJO,GAAG;IACN,OAAON,SAASO,MAAM,GAAIP,SAASQ,IAAI,KAA2B;AACpE;AAEA,OAAO,eAAeC,iBAAiBC,OAItC;IACC,MAAMb,SAASa,2BAAAA,QAASb,MAAM;IAC9B,MAAMC,WAAWY,2BAAAA,QAASZ,QAAQ;IAClC,MAAMC,YAAYW,2BAAAA,QAASX,SAAS;IACpC,MAAMS,OAAO;QACXG,SAASC;QACTC,eAAe;QACfC,OAAO;IACT;IAEA,IAAI;QACF,MAAMH,UAAU,MAAMjB,gBAAgB;YACpCqB,KAAK;gBAAC;gBAAyBlB;gBAAQC;gBAAUC;aAAU;YAC3DiB,YAAYrB;YACZsB,MAAM;gBAACxB,cAAcI;aAAQ;YAC7BqB,MAAM,IAAMtB,qBAAqBC,QAAQC,UAAUC;YACnDoB,OAAO,CAACC,QAAUA,UAAU;QAC9B;QACA,IAAIT,SAASH,KAAKG,OAAO,GAAGA;IAC9B,EAAE,OAAOG,OAAO;QACdO,QAAQP,KAAK,CAACA;QACdN,KAAKM,KAAK,GAAGA;IACf;IAEA,OAAON;AACT;AAEA,eAAeC,iBAAgB"}

package/src/lib/get-screen.d.ts

@@ -0,0 +1,39 @@
+/**
+ * @license
+ * Copyright 2022 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';
+export declare function getScreen(options: {
+    screenId: Aglyn.ScreenUid;
+    hostId: Aglyn.HostUid;
+    /**
+     * Serve a `kind: 'template'` document too (AGL-1400).
+     *
+     * Set ONLY by the two composers that render a template against a routed
+     * subject — the collection entry page and commerce's PDP/catalog pages. A
+     * caller resolving a request path must leave it off: that is what makes the
+     * exclusion honest (an excluded screen genuinely is not a page) and it is the
+     * same trade AGL-1383 made for `kind: 'email'`.
+     *
+     * It also keys the render cache, so a template fetched for composition can
+     * never be handed back to a path-resolving caller out of the same slot.
+     */
+    allowTemplate?: boolean;
+}): Promise<{
+    screen: Aglyn.AglynScreen;
+    nextPageToken: string;
+    error: any;
+}>;
+export default getScreen;

package/src/lib/get-screen.js

@@ -0,0 +1,126 @@
+/**
+ * @license
+ * Copyright 2022 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ import * as Aglyn from "@aglyn/aglyn/server";
+import { firebaseAdmin, screenConverter } from "@aglyn/tenant-data-admin";
+import { PUBLISH_POINTER_TTL_SECONDS, tenantDataTag, withRenderCache } from "@aglyn/tenant-data-admin/render-cache";
+/**
+ * Backstop TTL only (AGL-1302): a screen publish flips `versionId` on this
+ * doc, and the publish path already busts `tenant-data:{hostId}` through the
+ * tenant `/api/revalidate` route, so publishes stay as instant as AGL-1150
+ * made them.
+ *
+ * This is the ONE read whose data a screen publish changes without changing
+ * its cache key — the version body next door is keyed by `versionId` and
+ * misses on its own — so when the announce does not arrive, this document is
+ * the entire reason a published page keeps serving the old one. It is held to
+ * the page's own ISR window rather than the hour every other published read
+ * gets (AGL-2573); `PUBLISH_POINTER_TTL_SECONDS` carries that argument.
+ */ const SCREEN_DOC_TTL_SECONDS = PUBLISH_POINTER_TTL_SECONDS;
+async function readScreenDoc(hostId, screenId, /** Compose-time reads that WANT the template document — see {@link getScreen}. */ allowTemplate = false) {
+    const snapshot = await firebaseAdmin.app().firestore().collection('hosts').doc(hostId).collection('screens').withConverter(screenConverter).doc(screenId).get();
+    if (!snapshot.exists) return null;
+    const screen = snapshot.data();
+    // Serve-side agreement with the quota (AGL-1383). `countBillableScreens`
+    // subtracts soft-deleted and `kind: 'email'` screens from `screensPerHost`,
+    // and both fields are client-writable — so before this, one `updateDoc` on
+    // the screen's own document took it off the plan while leaving it live: the
+    // host's routing map still pointed at it and nothing on this path ever
+    // looked. Refusing them here is what makes the exclusion honest — an
+    // excluded screen genuinely is not a page — and it turns the bypass into a
+    // trade (the field costs you the page) rather than a discount.
+    //
+    // Indistinguishable from a missing screen on purpose: every caller already
+    // treats `null` as a 404, and this must not become a probe for which
+    // screens exist. Not cached either (`store` refuses `null`), so clearing
+    // the field brings the page back on the next request rather than in 60s.
+    //
+    // The Emails page is untouched: campaign sends read the email screen and
+    // its version straight off Firestore in `loadEmailTemplate`, never through
+    // the tenant runtime — email documents are not, and never were, URLs.
+    //
+    // `kind: 'template'` joins them (AGL-1400) and needs the escape hatch they do
+    // not, because a template IS rendered by this runtime — just never at an
+    // address of its own. `composeCollectionTemplatePage` and commerce's
+    // site-page resolver ask for it deliberately, against a routed entry or
+    // product; every other caller is resolving a REQUEST PATH, and for those a
+    // template is a 404 exactly as an email document is.
+    if (allowTemplate && (screen == null ? void 0 : screen.kind) === Aglyn.SCREEN_KIND_TEMPLATE) {
+        return screen.deletedAt == null ? screen : null;
+    }
+    // `kind: 'error'` (AGL-2092) is served, and served UNCONDITIONALLY — no
+    // opt-in flag like `allowTemplate` above, on purpose.
+    //
+    // The two exclusions this function refuses are refused because refusing is
+    // what makes them honest: they are client-writable, so `kind: 'email'` had to
+    // cost the page or it would have been a discount (AGL-1383). Neither half of
+    // that argument holds here. A client cannot write `kind` at all — the rules
+    // have frozen it since AGL-1383 and only /api/hosts/screens stamps this
+    // value, bounded at `ERROR_SCREEN_MAX_PER_HOST` — and, decisively, an error
+    // screen that is still in the host's routing map still COUNTS, because the
+    // map outranks the document for this value. So there is no page being had for
+    // free to refuse, and refusing would only mean that assigning a 404 screen
+    // silently broke it: the very error-render callers below fetch it through
+    // this function, and a host that ALSO still publishes it at `/404` (which is
+    // exactly how every error screen on the platform exists today) would find
+    // that address 404ing the moment somebody used the Error pages card.
+    //
+    // What keeps the exclusion honest instead is the routing map: the screen
+    // stops counting when, and only when, it stops having an address of its own.
+    if ((screen == null ? void 0 : screen.kind) === Aglyn.SCREEN_KIND_ERROR) {
+        return screen.deletedAt == null ? screen : null;
+    }
+    return Aglyn.screenClaimsToBeAPage(screen) ? screen : null;
+}
+export async function getScreen(options) {
+    const { screenId, hostId, allowTemplate = false } = options;
+    const data = {
+        screen: undefined,
+        nextPageToken: '',
+        error: null
+    };
+    try {
+        const screen = await withRenderCache({
+            key: [
+                allowTemplate ? 'tenant-screen-doc-template' : 'tenant-screen-doc',
+                hostId,
+                screenId
+            ],
+            revalidate: SCREEN_DOC_TTL_SECONDS,
+            tags: [
+                tenantDataTag(hostId)
+            ],
+            read: ()=>readScreenDoc(hostId, screenId, allowTemplate),
+            // Never store a missing screen, and never store a doc carrying a
+            // PENDING publish schedule: `applyDuePublishSchedule` reads
+            // `publishSchedule.publishAt.seconds` off a live Timestamp, and the
+            // JSON round trip a cache hit implies decays that to `_seconds` —
+            // which would make every pending schedule look already due. A pending
+            // schedule therefore keeps its doc read fresh until it resolves.
+            store: (value)=>{
+                var _value_publishSchedule;
+                return value !== null && ((_value_publishSchedule = value.publishSchedule) == null ? void 0 : _value_publishSchedule.status) !== 'pending';
+            }
+        });
+        if (screen) data.screen = screen;
+    } catch (error) {
+        console.error(error);
+        data.error = error;
+    }
+    return data;
+}
+export default getScreen;
+
+//# sourceMappingURL=get-screen.js.map

package/src/lib/get-screen.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../libs/tenant/runtime/src/lib/get-screen.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2022 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 { firebaseAdmin, screenConverter } from '@aglyn/tenant-data-admin'\nimport {\n  PUBLISH_POINTER_TTL_SECONDS,\n  tenantDataTag,\n  withRenderCache,\n} from '@aglyn/tenant-data-admin/render-cache'\n\n/**\n * Backstop TTL only (AGL-1302): a screen publish flips `versionId` on this\n * doc, and the publish path already busts `tenant-data:{hostId}` through the\n * tenant `/api/revalidate` route, so publishes stay as instant as AGL-1150\n * made them.\n *\n * This is the ONE read whose data a screen publish changes without changing\n * its cache key — the version body next door is keyed by `versionId` and\n * misses on its own — so when the announce does not arrive, this document is\n * the entire reason a published page keeps serving the old one. It is held to\n * the page's own ISR window rather than the hour every other published read\n * gets (AGL-2573); `PUBLISH_POINTER_TTL_SECONDS` carries that argument.\n */\nconst SCREEN_DOC_TTL_SECONDS = PUBLISH_POINTER_TTL_SECONDS\n\nasync function readScreenDoc(\n  hostId: string,\n  screenId: string,\n  /** Compose-time reads that WANT the template document — see {@link getScreen}. */\n  allowTemplate = false,\n): Promise<Aglyn.AglynScreen | null> {\n  const snapshot = await firebaseAdmin\n    .app()\n    .firestore()\n    .collection('hosts')\n    .doc(hostId)\n    .collection('screens')\n    .withConverter(screenConverter)\n    .doc(screenId)\n    .get()\n  if (!snapshot.exists) return null\n  const screen = snapshot.data() as Aglyn.AglynScreen\n  // Serve-side agreement with the quota (AGL-1383). `countBillableScreens`\n  // subtracts soft-deleted and `kind: 'email'` screens from `screensPerHost`,\n  // and both fields are client-writable — so before this, one `updateDoc` on\n  // the screen's own document took it off the plan while leaving it live: the\n  // host's routing map still pointed at it and nothing on this path ever\n  // looked. Refusing them here is what makes the exclusion honest — an\n  // excluded screen genuinely is not a page — and it turns the bypass into a\n  // trade (the field costs you the page) rather than a discount.\n  //\n  // Indistinguishable from a missing screen on purpose: every caller already\n  // treats `null` as a 404, and this must not become a probe for which\n  // screens exist. Not cached either (`store` refuses `null`), so clearing\n  // the field brings the page back on the next request rather than in 60s.\n  //\n  // The Emails page is untouched: campaign sends read the email screen and\n  // its version straight off Firestore in `loadEmailTemplate`, never through\n  // the tenant runtime — email documents are not, and never were, URLs.\n  //\n  // `kind: 'template'` joins them (AGL-1400) and needs the escape hatch they do\n  // not, because a template IS rendered by this runtime — just never at an\n  // address of its own. `composeCollectionTemplatePage` and commerce's\n  // site-page resolver ask for it deliberately, against a routed entry or\n  // product; every other caller is resolving a REQUEST PATH, and for those a\n  // template is a 404 exactly as an email document is.\n  if (allowTemplate && screen?.kind === Aglyn.SCREEN_KIND_TEMPLATE) {\n    return screen.deletedAt == null ? screen : null\n  }\n  // `kind: 'error'` (AGL-2092) is served, and served UNCONDITIONALLY — no\n  // opt-in flag like `allowTemplate` above, on purpose.\n  //\n  // The two exclusions this function refuses are refused because refusing is\n  // what makes them honest: they are client-writable, so `kind: 'email'` had to\n  // cost the page or it would have been a discount (AGL-1383). Neither half of\n  // that argument holds here. A client cannot write `kind` at all — the rules\n  // have frozen it since AGL-1383 and only /api/hosts/screens stamps this\n  // value, bounded at `ERROR_SCREEN_MAX_PER_HOST` — and, decisively, an error\n  // screen that is still in the host's routing map still COUNTS, because the\n  // map outranks the document for this value. So there is no page being had for\n  // free to refuse, and refusing would only mean that assigning a 404 screen\n  // silently broke it: the very error-render callers below fetch it through\n  // this function, and a host that ALSO still publishes it at `/404` (which is\n  // exactly how every error screen on the platform exists today) would find\n  // that address 404ing the moment somebody used the Error pages card.\n  //\n  // What keeps the exclusion honest instead is the routing map: the screen\n  // stops counting when, and only when, it stops having an address of its own.\n  if (screen?.kind === Aglyn.SCREEN_KIND_ERROR) {\n    return screen.deletedAt == null ? screen : null\n  }\n  return Aglyn.screenClaimsToBeAPage(screen as Aglyn.ScreenPageClaim)\n    ? screen\n    : null\n}\n\nexport async function getScreen(options: {\n  screenId: Aglyn.ScreenUid\n  hostId: Aglyn.HostUid\n  /**\n   * Serve a `kind: 'template'` document too (AGL-1400).\n   *\n   * Set ONLY by the two composers that render a template against a routed\n   * subject — the collection entry page and commerce's PDP/catalog pages. A\n   * caller resolving a request path must leave it off: that is what makes the\n   * exclusion honest (an excluded screen genuinely is not a page) and it is the\n   * same trade AGL-1383 made for `kind: 'email'`.\n   *\n   * It also keys the render cache, so a template fetched for composition can\n   * never be handed back to a path-resolving caller out of the same slot.\n   */\n  allowTemplate?: boolean\n}) {\n  const { screenId, hostId, allowTemplate = false } = options\n  const data = {\n    screen: undefined as Aglyn.AglynScreen,\n    nextPageToken: '',\n    error: null,\n  }\n\n  try {\n    const screen = await withRenderCache({\n      key: [\n        allowTemplate ? 'tenant-screen-doc-template' : 'tenant-screen-doc',\n        hostId as string,\n        screenId as string,\n      ],\n      revalidate: SCREEN_DOC_TTL_SECONDS,\n      tags: [tenantDataTag(hostId as string)],\n      read: () =>\n        readScreenDoc(hostId as string, screenId as string, allowTemplate),\n      // Never store a missing screen, and never store a doc carrying a\n      // PENDING publish schedule: `applyDuePublishSchedule` reads\n      // `publishSchedule.publishAt.seconds` off a live Timestamp, and the\n      // JSON round trip a cache hit implies decays that to `_seconds` —\n      // which would make every pending schedule look already due. A pending\n      // schedule therefore keeps its doc read fresh until it resolves.\n      store: (value) =>\n        value !== null &&\n        (value as { publishSchedule?: { status?: string } }).publishSchedule\n          ?.status !== 'pending',\n    })\n    if (screen) data.screen = screen\n  } catch (error) {\n    console.error(error)\n    data.error = error\n  }\n\n  return data\n}\n\nexport default getScreen\n"],"names":["Aglyn","firebaseAdmin","screenConverter","PUBLISH_POINTER_TTL_SECONDS","tenantDataTag","withRenderCache","SCREEN_DOC_TTL_SECONDS","readScreenDoc","hostId","screenId","allowTemplate","snapshot","app","firestore","collection","doc","withConverter","get","exists","screen","data","kind","SCREEN_KIND_TEMPLATE","deletedAt","SCREEN_KIND_ERROR","screenClaimsToBeAPage","getScreen","options","undefined","nextPageToken","error","key","revalidate","tags","read","store","value","publishSchedule","status","console"],"mappings":"AAAA;;;;;;;;;;;;;;;CAeC,GAED,YAAYA,WAAW,sBAAqB;AAC5C,SAASC,aAAa,EAAEC,eAAe,QAAQ,2BAA0B;AACzE,SACEC,2BAA2B,EAC3BC,aAAa,EACbC,eAAe,QACV,wCAAuC;AAE9C;;;;;;;;;;;;CAYC,GACD,MAAMC,yBAAyBH;AAE/B,eAAeI,cACbC,MAAc,EACdC,QAAgB,EAChB,gFAAgF,GAChFC,gBAAgB,KAAK;IAErB,MAAMC,WAAW,MAAMV,cACpBW,GAAG,GACHC,SAAS,GACTC,UAAU,CAAC,SACXC,GAAG,CAACP,QACJM,UAAU,CAAC,WACXE,aAAa,CAACd,iBACda,GAAG,CAACN,UACJQ,GAAG;IACN,IAAI,CAACN,SAASO,MAAM,EAAE,OAAO;IAC7B,MAAMC,SAASR,SAASS,IAAI;IAC5B,yEAAyE;IACzE,4EAA4E;IAC5E,2EAA2E;IAC3E,4EAA4E;IAC5E,uEAAuE;IACvE,qEAAqE;IACrE,2EAA2E;IAC3E,+DAA+D;IAC/D,EAAE;IACF,2EAA2E;IAC3E,qEAAqE;IACrE,yEAAyE;IACzE,yEAAyE;IACzE,EAAE;IACF,yEAAyE;IACzE,2EAA2E;IAC3E,sEAAsE;IACtE,EAAE;IACF,8EAA8E;IAC9E,yEAAyE;IACzE,qEAAqE;IACrE,wEAAwE;IACxE,2EAA2E;IAC3E,qDAAqD;IACrD,IAAIV,iBAAiBS,CAAAA,0BAAAA,OAAQE,IAAI,MAAKrB,MAAMsB,oBAAoB,EAAE;QAChE,OAAOH,OAAOI,SAAS,IAAI,OAAOJ,SAAS;IAC7C;IACA,wEAAwE;IACxE,sDAAsD;IACtD,EAAE;IACF,2EAA2E;IAC3E,8EAA8E;IAC9E,6EAA6E;IAC7E,4EAA4E;IAC5E,wEAAwE;IACxE,4EAA4E;IAC5E,2EAA2E;IAC3E,8EAA8E;IAC9E,2EAA2E;IAC3E,0EAA0E;IAC1E,6EAA6E;IAC7E,0EAA0E;IAC1E,qEAAqE;IACrE,EAAE;IACF,yEAAyE;IACzE,6EAA6E;IAC7E,IAAIA,CAAAA,0BAAAA,OAAQE,IAAI,MAAKrB,MAAMwB,iBAAiB,EAAE;QAC5C,OAAOL,OAAOI,SAAS,IAAI,OAAOJ,SAAS;IAC7C;IACA,OAAOnB,MAAMyB,qBAAqB,CAACN,UAC/BA,SACA;AACN;AAEA,OAAO,eAAeO,UAAUC,OAgB/B;IACC,MAAM,EAAElB,QAAQ,EAAED,MAAM,EAAEE,gBAAgB,KAAK,EAAE,GAAGiB;IACpD,MAAMP,OAAO;QACXD,QAAQS;QACRC,eAAe;QACfC,OAAO;IACT;IAEA,IAAI;QACF,MAAMX,SAAS,MAAMd,gBAAgB;YACnC0B,KAAK;gBACHrB,gBAAgB,+BAA+B;gBAC/CF;gBACAC;aACD;YACDuB,YAAY1B;YACZ2B,MAAM;gBAAC7B,cAAcI;aAAkB;YACvC0B,MAAM,IACJ3B,cAAcC,QAAkBC,UAAoBC;YACtD,iEAAiE;YACjE,4DAA4D;YAC5D,oEAAoE;YACpE,kEAAkE;YAClE,sEAAsE;YACtE,iEAAiE;YACjEyB,OAAO,CAACC;oBAEN;uBADAA,UAAU,QACV,EAAA,yBAAA,AAACA,MAAoDC,eAAe,qBAApE,uBACIC,MAAM,MAAK;;QACnB;QACA,IAAInB,QAAQC,KAAKD,MAAM,GAAGA;IAC5B,EAAE,OAAOW,OAAO;QACdS,QAAQT,KAAK,CAACA;QACdV,KAAKU,KAAK,GAAGA;IACf;IAEA,OAAOV;AACT;AAEA,eAAeM,UAAS"}

package/src/lib/get-variables.d.ts

@@ -0,0 +1,41 @@
+/**
+ * @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 * as Aglyn from '@aglyn/aglyn/server';
+/**
+ * Fetches the host's variables keyed by doc id (AGL-185/194) for
+ * `{{var:id}}` tokens; expression scopes read names off the values.
+ * Fail-open: on error an empty map is returned and tokens render
+ * literally/empty.
+ */
+export declare function getVariables(options: {
+    hostId: string;
+}): Promise<Record<string, Aglyn.HostVariable>>;
+/**
+ * Fetches the host's function definitions keyed by name for
+ * `{{fn:name(...)}}` bindings (AGL-93). Fail-open like variables.
+ */
+export declare function getFunctions(options: {
+    hostId: string;
+}): Promise<Record<string, Aglyn.HostFunction>>;
+export default getVariables;
+/**
+ * Fetches the host's workflows keyed by name for computed variables and
+ * function→workflow calls (AGL-129). Fail-open like variables.
+ */
+export declare function getWorkflows(options: {
+    hostId: string;
+}): Promise<Record<string, Aglyn.HostWorkflow>>;

package/src/lib/get-variables.js

@@ -0,0 +1,128 @@
+/**
+ * @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 { firebaseAdmin } from "@aglyn/tenant-data-admin";
+import { PUBLISHED_SITE_DATA_TTL_SECONDS, tenantDataTag, withRenderCache } from "@aglyn/tenant-data-admin/render-cache";
+/**
+ * Part of the per-host compose bundle every page render pays (AGL-1302):
+ * variables, functions and workflows were three ~100-doc queries per
+ * render. All three fail open, so a cache-layer failure degrades to the
+ * uncached read rather than an empty map. 60s matches the page's own ISR
+ * window; the publish path busts `tenant-data:{hostId}` on top.
+ */ const HOST_BINDINGS_TTL_SECONDS = PUBLISHED_SITE_DATA_TTL_SECONDS;
+const cachedBindingsRead = async (name, hostId, read)=>{
+    try {
+        return await withRenderCache({
+            key: [
+                name,
+                hostId
+            ],
+            revalidate: HOST_BINDINGS_TTL_SECONDS,
+            tags: [
+                tenantDataTag(hostId)
+            ],
+            read
+        });
+    } catch (error) {
+        console.error(error);
+        return read();
+    }
+};
+/**
+ * Fetches the host's variables keyed by doc id (AGL-185/194) for
+ * `{{var:id}}` tokens; expression scopes read names off the values.
+ * Fail-open: on error an empty map is returned and tokens render
+ * literally/empty.
+ */ export async function getVariables(options) {
+    return cachedBindingsRead('tenant-variables', options.hostId, ()=>readVariables(options));
+}
+async function readVariables(options) {
+    const variables = {};
+    try {
+        const snapshot = await firebaseAdmin.app().firestore().collection('hosts').doc(options.hostId).collection('variables').limit(100).get();
+        for (const docSnapshot of snapshot.docs){
+            const data = docSnapshot.data();
+            if ((data == null ? void 0 : data.name) && !data.deletedAt) {
+                variables[docSnapshot.id] = data;
+            }
+        }
+    } catch (error) {
+        console.error(error);
+    }
+    return variables;
+}
+/**
+ * Fetches the host's function definitions keyed by name for
+ * `{{fn:name(...)}}` bindings (AGL-93). Fail-open like variables.
+ */ export async function getFunctions(options) {
+    return cachedBindingsRead('tenant-functions', options.hostId, ()=>readFunctions(options));
+}
+async function readFunctions(options) {
+    const functions = {};
+    try {
+        const snapshot = await firebaseAdmin.app().firestore().collection('hosts').doc(options.hostId).collection('functions').limit(100).get();
+        for (const docSnapshot of snapshot.docs){
+            const data = docSnapshot.data();
+            if ((data == null ? void 0 : data.name) && !data.deletedAt) {
+                var _data_parameters, _data_variables, _data_operations;
+                // Plain evaluator fields only: doc timestamps aren't
+                // JSON-serializable and definitions embed into page props.
+                const definition = _extends({
+                    name: data.name,
+                    parameters: (_data_parameters = data.parameters) != null ? _data_parameters : [],
+                    variables: (_data_variables = data.variables) != null ? _data_variables : [],
+                    operations: (_data_operations = data.operations) != null ? _data_operations : []
+                }, data.returnValue && {
+                    returnValue: data.returnValue
+                });
+                // Keyed by doc id ({{fn:id(...)}}, AGL-185/194) AND name so
+                // legacy workflow steps that stored functionName keep resolving
+                // (AGL-261).
+                functions[docSnapshot.id] = definition;
+                if (!functions[data.name]) functions[data.name] = definition;
+            }
+        }
+    } catch (error) {
+        console.error(error);
+    }
+    return functions;
+}
+export default getVariables;
+/**
+ * Fetches the host's workflows keyed by name for computed variables and
+ * function→workflow calls (AGL-129). Fail-open like variables.
+ */ export async function getWorkflows(options) {
+    return cachedBindingsRead('tenant-workflows', options.hostId, ()=>readWorkflows(options));
+}
+async function readWorkflows(options) {
+    const workflows = {};
+    try {
+        const snapshot = await firebaseAdmin.app().firestore().collection('hosts').doc(options.hostId).collection('workflows').limit(100).get();
+        for (const docSnapshot of snapshot.docs){
+            const data = docSnapshot.data();
+            if (data.deletedAt) continue;
+            // Double-keyed by doc id AND name (AGL-261): id references are
+            // rename-safe; legacy name references keep resolving.
+            workflows[docSnapshot.id] = data;
+            if (data == null ? void 0 : data.name) workflows[data.name] = data;
+        }
+    } catch (error) {
+        console.error(error);
+    }
+    return workflows;
+}
+
+//# sourceMappingURL=get-variables.js.map

package/src/lib/get-variables.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../libs/tenant/runtime/src/lib/get-variables.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2026 Aglyn LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport type * as Aglyn from '@aglyn/aglyn/server'\nimport { firebaseAdmin } from '@aglyn/tenant-data-admin'\nimport {\n  PUBLISHED_SITE_DATA_TTL_SECONDS,\n  tenantDataTag,\n  withRenderCache,\n} from '@aglyn/tenant-data-admin/render-cache'\n\n/**\n * Part of the per-host compose bundle every page render pays (AGL-1302):\n * variables, functions and workflows were three ~100-doc queries per\n * render. All three fail open, so a cache-layer failure degrades to the\n * uncached read rather than an empty map. 60s matches the page's own ISR\n * window; the publish path busts `tenant-data:{hostId}` on top.\n */\nconst HOST_BINDINGS_TTL_SECONDS = PUBLISHED_SITE_DATA_TTL_SECONDS\n\nconst cachedBindingsRead = async <T>(\n  name: string,\n  hostId: string,\n  read: () => Promise<Record<string, T>>,\n): Promise<Record<string, T>> => {\n  try {\n    return await withRenderCache({\n      key: [name, hostId],\n      revalidate: HOST_BINDINGS_TTL_SECONDS,\n      tags: [tenantDataTag(hostId)],\n      read,\n    })\n  } catch (error) {\n    console.error(error)\n    return read()\n  }\n}\n\n/**\n * Fetches the host's variables keyed by doc id (AGL-185/194) for\n * `{{var:id}}` tokens; expression scopes read names off the values.\n * Fail-open: on error an empty map is returned and tokens render\n * literally/empty.\n */\nexport async function getVariables(options: {\n  hostId: string\n}): Promise<Record<string, Aglyn.HostVariable>> {\n  return cachedBindingsRead('tenant-variables', options.hostId, () =>\n    readVariables(options),\n  )\n}\n\nasync function readVariables(options: {\n  hostId: string\n}): Promise<Record<string, Aglyn.HostVariable>> {\n  const variables: Record<string, Aglyn.HostVariable> = {}\n  try {\n    const snapshot = await firebaseAdmin\n      .app()\n      .firestore()\n      .collection('hosts')\n      .doc(options.hostId)\n      .collection('variables')\n      .limit(100)\n      .get()\n    for (const docSnapshot of snapshot.docs) {\n      const data = docSnapshot.data() as Aglyn.HostVariable\n      if (data?.name && !((data as any).deletedAt)) {\n        variables[docSnapshot.id] = data\n      }\n    }\n  } catch (error) {\n    console.error(error)\n  }\n  return variables\n}\n\n/**\n * Fetches the host's function definitions keyed by name for\n * `{{fn:name(...)}}` bindings (AGL-93). Fail-open like variables.\n */\nexport async function getFunctions(options: {\n  hostId: string\n}): Promise<Record<string, Aglyn.HostFunction>> {\n  return cachedBindingsRead('tenant-functions', options.hostId, () =>\n    readFunctions(options),\n  )\n}\n\nasync function readFunctions(options: {\n  hostId: string\n}): Promise<Record<string, Aglyn.HostFunction>> {\n  const functions: Record<string, Aglyn.HostFunction> = {}\n  try {\n    const snapshot = await firebaseAdmin\n      .app()\n      .firestore()\n      .collection('hosts')\n      .doc(options.hostId)\n      .collection('functions')\n      .limit(100)\n      .get()\n    for (const docSnapshot of snapshot.docs) {\n      const data = docSnapshot.data() as Aglyn.HostFunction\n      if (data?.name && !(data as any).deletedAt) {\n        // Plain evaluator fields only: doc timestamps aren't\n        // JSON-serializable and definitions embed into page props.\n        const definition = {\n          name: data.name,\n          parameters: data.parameters ?? [],\n          variables: data.variables ?? [],\n          operations: data.operations ?? [],\n          ...(data.returnValue && { returnValue: data.returnValue }),\n        }\n        // Keyed by doc id ({{fn:id(...)}}, AGL-185/194) AND name so\n        // legacy workflow steps that stored functionName keep resolving\n        // (AGL-261).\n        functions[docSnapshot.id] = definition\n        if (!functions[data.name]) functions[data.name] = definition\n      }\n    }\n  } catch (error) {\n    console.error(error)\n  }\n  return functions\n}\n\nexport default getVariables\n\n/**\n * Fetches the host's workflows keyed by name for computed variables and\n * function→workflow calls (AGL-129). Fail-open like variables.\n */\nexport async function getWorkflows(options: {\n  hostId: string\n}): Promise<Record<string, Aglyn.HostWorkflow>> {\n  return cachedBindingsRead('tenant-workflows', options.hostId, () =>\n    readWorkflows(options),\n  )\n}\n\nasync function readWorkflows(options: {\n  hostId: string\n}): Promise<Record<string, Aglyn.HostWorkflow>> {\n  const workflows: Record<string, Aglyn.HostWorkflow> = {}\n  try {\n    const snapshot = await firebaseAdmin\n      .app()\n      .firestore()\n      .collection('hosts')\n      .doc(options.hostId)\n      .collection('workflows')\n      .limit(100)\n      .get()\n    for (const docSnapshot of snapshot.docs) {\n      const data = docSnapshot.data() as Aglyn.HostWorkflow\n      if ((data as any).deletedAt) continue\n      // Double-keyed by doc id AND name (AGL-261): id references are\n      // rename-safe; legacy name references keep resolving.\n      workflows[docSnapshot.id] = data\n      if (data?.name) workflows[data.name] = data\n    }\n  } catch (error) {\n    console.error(error)\n  }\n  return workflows\n}\n"],"names":["firebaseAdmin","PUBLISHED_SITE_DATA_TTL_SECONDS","tenantDataTag","withRenderCache","HOST_BINDINGS_TTL_SECONDS","cachedBindingsRead","name","hostId","read","key","revalidate","tags","error","console","getVariables","options","readVariables","variables","snapshot","app","firestore","collection","doc","limit","get","docSnapshot","docs","data","deletedAt","id","getFunctions","readFunctions","functions","definition","parameters","operations","returnValue","getWorkflows","readWorkflows","workflows"],"mappings":"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"}

package/src/lib/get-video-asset-facts.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * The film name for `get-media-asset-facts.ts`, which reads every placed image
+ * and film in one projected batch. A film's entry is the same answer under
+ * either name, so a caller that only lays films can keep importing this one.
+ */
+export { getMediaAssetFacts as getVideoAssetFacts, MEDIA_ASSET_FACTS_PER_RENDER as VIDEO_ASSET_FACTS_PER_RENDER, getMediaAssetFacts as default, } from './get-media-asset-facts';

package/src/lib/get-video-asset-facts.js

@@ -0,0 +1,22 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ /**
+ * The film name for `get-media-asset-facts.ts`, which reads every placed image
+ * and film in one projected batch. A film's entry is the same answer under
+ * either name, so a caller that only lays films can keep importing this one.
+ */ export { getMediaAssetFacts as getVideoAssetFacts, MEDIA_ASSET_FACTS_PER_RENDER as VIDEO_ASSET_FACTS_PER_RENDER, getMediaAssetFacts as default } from "./get-media-asset-facts.js";
+
+//# sourceMappingURL=get-video-asset-facts.js.map

package/src/lib/get-video-asset-facts.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../libs/tenant/runtime/src/lib/get-video-asset-facts.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\n/**\n * The film name for `get-media-asset-facts.ts`, which reads every placed image\n * and film in one projected batch. A film's entry is the same answer under\n * either name, so a caller that only lays films can keep importing this one.\n */\nexport {\n  getMediaAssetFacts as getVideoAssetFacts,\n  MEDIA_ASSET_FACTS_PER_RENDER as VIDEO_ASSET_FACTS_PER_RENDER,\n  getMediaAssetFacts as default,\n} from './get-media-asset-facts'\n"],"names":["getMediaAssetFacts","getVideoAssetFacts","MEDIA_ASSET_FACTS_PER_RENDER","VIDEO_ASSET_FACTS_PER_RENDER","default"],"mappings":"AAAA;;;;;;;;;;;;;;;CAeC,GAED;;;;CAIC,GACD,SACEA,sBAAsBC,kBAAkB,EACxCC,gCAAgCC,4BAA4B,EAC5DH,sBAAsBI,OAAO,QACxB,6BAAyB"}

package/src/lib/host-event-listeners.d.ts

@@ -0,0 +1,83 @@
+/**
+ * @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 { HostActionAlert } from '@aglyn/aglyn/server';
+/**
+ * WHO HEARS A HOST EVENT.
+ *
+ * A host event — a form submitted, a member signed up, a deal won — is raised
+ * by the server door that performed the write, through `emitHostEvent`. What
+ * runs because of it is not the runtime's business: an automation engine, an
+ * integration, a marketplace plugin. Each registers a listener here and the
+ * runtime fans every event out to all of them, knowing none by name.
+ *
+ * ## Registered by a call, at boot
+ *
+ * A listener is registered by a function the platform calls BY NAME — a
+ * plugin's `serverDeclarations` entry, which both apps run once per process
+ * from `instrumentation.ts`, and its API register functions, which the plugin
+ * loader runs. Never by a bare `import './x'`: a bundler drops a module its
+ * package does not list as a side effect, and jest does not, so a registration
+ * that relies on one passes every spec and runs in no build (AGL-3025).
+ *
+ * Boot registration is what lets a core route that never loads a plugin — the
+ * form submission, the page-view collector — still reach every listener.
+ *
+ * ## Isolated, and never thrown into the emitter
+ *
+ * The event has already happened: the submission is stored, the member exists.
+ * A listener that throws is logged against its plugin and the others still
+ * run, and the emitting request never sees the failure.
+ */
+/** What an event carries into everything that listens for it. */
+export type HostEventPayload = Record<string, string | number | boolean>;
+export interface HostEventListener {
+    /**
+     * Runs whatever this plugin does when `event` happens on the site.
+     *
+     * Resolves the site alerts a request/response emitter shows its visitor —
+     * a form submission returns them in its response — or nothing.
+     */
+    onEvent(hostId: string, event: string, payload: HostEventPayload): Promise<readonly HostActionAlert[] | void>;
+    /**
+     * Runs ONE automation, by id, that a published page fired for a site event
+     * it evaluated itself — a scroll depth, a click, exit intent. The page has
+     * already decided the trigger matched, so the listener runs that one
+     * automation rather than every automation on the event; a listener that
+     * does not own the id resolves nothing.
+     */
+    onDispatch?(hostId: string, automationId: string, event: string, payload: HostEventPayload): Promise<readonly HostActionAlert[] | void>;
+}
+/**
+ * Subscribes a plugin to every host event. Registering again under the same
+ * plugin id replaces the earlier listener in place, so a register function
+ * the platform calls twice — boot, then the API surface — leaves one.
+ */
+export declare function registerHostEventListener(pluginId: string, listener: HostEventListener): void;
+/** The plugins listening, in registration order, for diagnostics. */
+export declare function listHostEventListeners(): string[];
+/** Test seam: forget every listener. */
+export declare function resetHostEventListenersForTests(): void;
+/**
+ * Hands one event to every listener, concurrently, and gathers the alerts
+ * they produced. Never rejects.
+ */
+export declare function runHostEventListeners(hostId: string, event: string, payload?: HostEventPayload): Promise<HostActionAlert[]>;
+/**
+ * Hands one page-dispatched automation to the listeners that dispatch, and
+ * gathers the alerts it produced. Never rejects.
+ */
+export declare function dispatchHostAutomation(hostId: string, automationId: string, event: string, payload?: HostEventPayload): Promise<HostActionAlert[]>;