@aglyn/aglyn 1.0.0-beta.143

package/src/lib/app-utils/recipient-email-render.d.ts

@@ -0,0 +1,216 @@
+/**
+ * @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.
+ */
+/**
+ * ONE MESSAGE FOR ONE RECIPIENT, RENDERED — the step between a composed email
+ * and the two parts that reach an inbox.
+ *
+ * It sits on the platform's mail rail, in the core, because more than one
+ * plugin needs the SAME rendering: the plugin that sends a campaign renders
+ * each recipient's copy through it, and the plugin that designs an email
+ * checks a design through it before anything is sent. Neither may import the
+ * other, and a second renderer in either would be a preview of something else.
+ * It composes `@aglyn/shared-util-email`'s primitives with the core's HTML
+ * sanitizer, which is why it cannot live in `shared`. Imported by its own
+ * subpath; it is not in the barrel.
+ *
+ * It exists as a shared function because a preview that renders the message a
+ * second way is a preview of something else. The class of defect it is meant
+ * to catch has bitten twice on this send path — a designed campaign mailed
+ * with its product blocks missing, and merge tags that resolved to empty
+ * strings for an entire member audience — and neither would have been visible
+ * in a preview that did not go through the same renderer, the same merge-tag
+ * resolution and the same plain-text synthesis as the send.
+ *
+ * PURE, and free of `firebase-admin`, so the same call answers in three
+ * places: the per-recipient loop in `campaign-send.ts`, the composer's
+ * `renderPreview` action, and the console's own client components. Its inputs
+ * are already-loaded data — a node map, resolved products, a recipient — and
+ * the loading stays with the caller that has the credentials for it.
+ */
+import { type EmailRenderProduct } from '@aglyn/shared-util-email/email-render';
+import { type MergeTagRecipient } from '@aglyn/shared-util-email/email-merge';
+/**
+ * A designed email, loaded. `nodes` is the DECODED besigner map: the stored
+ * form is compressed msgpack from the first designer save onward, and a
+ * caller that passes the raw value renders an empty shell.
+ */
+export interface DesignedEmailTemplate {
+    nodes: Record<string, unknown>;
+    products?: Record<string, EmailRenderProduct | undefined>;
+    /** The template's own preview line, used when the campaign names none. */
+    preheader?: string;
+    /** The template's own subject, used when the campaign names none. */
+    subject?: string;
+}
+/**
+ * WHERE THE MESSAGE COMES FROM — one source, named.
+ *
+ * A union rather than two optional fields, and that is the whole point. The
+ * design already supplies BOTH parts an inbox receives: `renderEmailHtml`
+ * returns the HTML and a plain-text rendering of the same nodes, links
+ * included. So on a designed send a typed BODY — the whole message of a
+ * plain-text email — has no part to occupy, and the earlier shape, which
+ * accepted both and read the body only when no template was given, computed it
+ * and threw it away without saying so.
+ *
+ * What an author actually wants there is named for its job instead:
+ * `plainText`, the text HALF of a designed message, generated from the design
+ * by default. That is a different offer from reinterpreting a body, and
+ * deliberately — see the field.
+ *
+ * Two members and not three: a saved TEMPLATE is a besigner email screen, the
+ * same document the design picker offers, so "designed" and "from a template"
+ * name one thing.
+ *
+ * With the two collapsed into a union the discard is not merely refused, it is
+ * unsayable: the designed branch has no `body` in scope to drop, and a caller
+ * holding both has to decide which it means before it can call at all.
+ */
+export type RecipientEmailContent = {
+    /** Written in the composer; the HTML part is synthesized from it. */
+    mode: 'text';
+    /** The plain-text body, after any A/B variant override. */
+    body: string;
+} | {
+    /** Built in the besigner; the HTML part comes from the nodes. */
+    mode: 'design';
+    template: DesignedEmailTemplate;
+    /**
+     * The author's OWN plain-text part, replacing the one the design
+     * generates. Absent — not empty — means generated.
+     *
+     * Presence is the whole signal, which is why this is a separate
+     * optional field rather than a flag beside a string: a flag and a value
+     * are two things that can disagree, and the disagreement is invisible.
+     *
+     * Worth having because the generated text is good but not perfect. A
+     * button and a product keep their URLs in it; an inline link inside an
+     * `emailRichtext` block does not — the synthesis strips tags, so the
+     * href goes with them. An author who cares about what a text-only
+     * reader can actually follow needs a way to say so.
+     */
+    plainText?: string;
+};
+/** Which of the two ways one email is written. */
+export type EmailMessageMode = RecipientEmailContent['mode'];
+/**
+ * Which mode a stored email is in, from the one field that decides it.
+ *
+ * Naming a template IS being designed — there is no separate flag, and adding
+ * one would be a second answer to drift from this one. Read by the composer,
+ * by the surfaces that describe a message and by the send path, so a record
+ * cannot be shown as one thing and mailed as another.
+ */
+export declare function emailMessageMode(record: {
+    templateScreenId?: string | null;
+}): EmailMessageMode;
+export interface RecipientEmailRenderInput {
+    /** The campaign's subject, after any A/B variant override. */
+    subject: string;
+    /** The one source this message is written from. */
+    content: RecipientEmailContent;
+    /** The composer's preview line; overrides the template's own. */
+    preheader?: string;
+    /** Who this copy is being personalized for. */
+    recipient: MergeTagRecipient;
+    /** The site's own public origin, absolutizing media and product links. */
+    siteBase?: string;
+    /** Qualifies an org-scoped media asset for the unauthenticated CDN. */
+    hostId?: string;
+    /** The recipient's signed opt-out link, appended to the text part. */
+    unsubscribeUrl?: string;
+}
+export interface RenderedRecipientEmail {
+    /** The subject with this recipient's merge values resolved. */
+    subject: string;
+    /** The HTML part, which every campaign message carries. */
+    html: string;
+    /** The plain-text part, ending in the opt-out line. */
+    text: string;
+    /**
+     * The message's own plain text, WITHOUT the opt-out line.
+     *
+     * What the composer fills an authored plain-text part from. Prefilling from
+     * `text` would fold this send's footer into the stored override, and the
+     * next send would append a second one — so the two are reported apart
+     * rather than the caller trying to trim one off the other.
+     */
+    messageText: string;
+}
+/**
+ * WHERE A DESIGNED EMAIL'S PLAIN-TEXT PART COMES FROM, and whether it still
+ * describes the design.
+ *
+ * Two facts a composer has to state rather than imply. An authored text part
+ * is not overwritten when the design is edited — losing somebody's writing
+ * because they touched the canvas afterwards is not a trade worth making —
+ * which leaves the other half of the problem: an override written against a
+ * design that has since changed says something the HTML no longer says, and
+ * nothing about it is visible. A value that cannot be read scores the same as
+ * one that is absent, which is the shape of the defect this whole area is
+ * being fixed for.
+ *
+ * So the design's VERSION is recorded beside the override, and the two are
+ * compared here. Pure, and read by the composer, so the notice a merchant sees
+ * and the state the record is in cannot disagree.
+ */
+export interface EmailPlainTextState {
+    /** `authored` when somebody wrote it; `generated` from the design. */
+    source: 'generated' | 'authored';
+    /**
+     * An authored part written against a design that has moved since.
+     *
+     * False for a generated part, which cannot go stale — it is derived from
+     * whatever the design says at send time — and false when either version is
+     * unknown, because an unanswerable question must not render as a warning.
+     */
+    stale: boolean;
+}
+export declare function emailPlainTextState(record: {
+    plainText?: string | null;
+    /** The design version the override was written against. */
+    plainTextVersionId?: string | null;
+}, 
+/** The design's version as it stands now. */
+currentVersionId?: string | null): EmailPlainTextState;
+/**
+ * Renders one campaign message for one recipient.
+ *
+ * The HTML part is produced here rather than left to `sendEmail`'s fallback
+ * so that a caller can SEE it. `sendEmail` synthesizes an HTML part from the
+ * text of any message that arrives without one — a text-only message has no
+ * anchors, so its links are inert and click tracking has nothing to rewrite —
+ * and this calls the same `renderTextEmailHtml` with the same text and
+ * subject, so a plain-text campaign is byte-identical either way.
+ */
+export declare function renderRecipientEmail(input: RecipientEmailRenderInput): RenderedRecipientEmail;
+/**
+ * The merge tags the send path resolves, for the composer to offer.
+ *
+ * Kept beside the renderer because `resolveMergeTags` recognizes exactly
+ * these three and substitutes the fallback for anything else: a tag a
+ * merchant types from memory that is not on this list does not fail, it
+ * silently renders as nothing in mail that has already gone out. A composer
+ * that lists them is the difference between a documented feature and a
+ * guess.
+ */
+export declare const EMAIL_MERGE_TAGS: ReadonlyArray<{
+    /** The full token, fallback included, as it should be typed. */
+    token: string;
+    /** What it resolves to, per recipient. */
+    description: string;
+}>;

package/src/lib/app-utils/recipient-email-render.js

@@ -0,0 +1,221 @@
+import { _ as _extends } from "@swc/helpers/_/_extends";
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ /**
+ * ONE MESSAGE FOR ONE RECIPIENT, RENDERED — the step between a composed email
+ * and the two parts that reach an inbox.
+ *
+ * It sits on the platform's mail rail, in the core, because more than one
+ * plugin needs the SAME rendering: the plugin that sends a campaign renders
+ * each recipient's copy through it, and the plugin that designs an email
+ * checks a design through it before anything is sent. Neither may import the
+ * other, and a second renderer in either would be a preview of something else.
+ * It composes `@aglyn/shared-util-email`'s primitives with the core's HTML
+ * sanitizer, which is why it cannot live in `shared`. Imported by its own
+ * subpath; it is not in the barrel.
+ *
+ * It exists as a shared function because a preview that renders the message a
+ * second way is a preview of something else. The class of defect it is meant
+ * to catch has bitten twice on this send path — a designed campaign mailed
+ * with its product blocks missing, and merge tags that resolved to empty
+ * strings for an entire member audience — and neither would have been visible
+ * in a preview that did not go through the same renderer, the same merge-tag
+ * resolution and the same plain-text synthesis as the send.
+ *
+ * PURE, and free of `firebase-admin`, so the same call answers in three
+ * places: the per-recipient loop in `campaign-send.ts`, the composer's
+ * `renderPreview` action, and the console's own client components. Its inputs
+ * are already-loaded data — a node map, resolved products, a recipient — and
+ * the loading stays with the caller that has the credentials for it.
+ */ // By leaf, never the library's index: the index reaches the sender and the
+// health check, which this module has no use for.
+import { EMAIL_NODE_ROOT_ID, renderEmailHtml } from "@aglyn/shared-util-email/email-render";
+import { resolveMergeTags } from "@aglyn/shared-util-email/email-merge";
+import { appendUnsubscribeHtml, UNSUBSCRIBE_FOOTER_LABEL } from "@aglyn/shared-util-email/marketing-send";
+import { renderTextEmailHtml } from "@aglyn/shared-util-email/text-email-html";
+/*
+ * The LEAF app-util, not `@aglyn/aglyn/server`: this module is pure and is
+ * imported by client components, so a server entry point here would pull the
+ * Admin SDK into a browser bundle. The email blocks the besigner previews
+ * these same nodes under call this same function — so the mailed copy and the
+ * previewed copy are one policy over one string rather than two kept in step
+ * by hand.
+ */ import { sanitizeAuthorHtml } from "./author-html.js";
+/**
+ * Which mode a stored email is in, from the one field that decides it.
+ *
+ * Naming a template IS being designed — there is no separate flag, and adding
+ * one would be a second answer to drift from this one. Read by the composer,
+ * by the surfaces that describe a message and by the send path, so a record
+ * cannot be shown as one thing and mailed as another.
+ */ export function emailMessageMode(record) {
+    return record.templateScreenId ? 'design' : 'text';
+}
+export function emailPlainTextState(record, /** The design's version as it stands now. */ currentVersionId) {
+    var _record_plainTextVersionId;
+    var _record_plainText;
+    if (!((_record_plainText = record.plainText) == null ? void 0 : _record_plainText.trim())) return {
+        source: 'generated',
+        stale: false
+    };
+    const written = (_record_plainTextVersionId = record.plainTextVersionId) != null ? _record_plainTextVersionId : '';
+    return {
+        source: 'authored',
+        stale: Boolean(written && currentVersionId && written !== currentVersionId)
+    };
+}
+/**
+ * Renders one campaign message for one recipient.
+ *
+ * The HTML part is produced here rather than left to `sendEmail`'s fallback
+ * so that a caller can SEE it. `sendEmail` synthesizes an HTML part from the
+ * text of any message that arrives without one — a text-only message has no
+ * anchors, so its links are inert and click tracking has nothing to rewrite —
+ * and this calls the same `renderTextEmailHtml` with the same text and
+ * subject, so a plain-text campaign is byte-identical either way.
+ */ export function renderRecipientEmail(input) {
+    var _recipient_name, _name_split_, _content_template_products;
+    var _input_preheader, _content_plainText;
+    const { content, recipient, siteBase = '', hostId, unsubscribeUrl } = input;
+    const template = content.mode === 'design' ? content.template : null;
+    const subject = resolveMergeTags(input.subject || (template == null ? void 0 : template.subject) || '', recipient);
+    const preheader = ((_input_preheader = input.preheader) == null ? void 0 : _input_preheader.trim()) || (template == null ? void 0 : template.preheader) || '';
+    const name = ((_recipient_name = recipient.name) != null ? _recipient_name : '').trim();
+    /*
+   * The plain-text footer, named for what the link actually opens — see
+   * {@link UNSUBSCRIBE_FOOTER_LABEL}, which the non-campaign marketing paths
+   * write into their own footers from the same constant.
+   */ const unsubscribeLine = unsubscribeUrl ? `\n\n—\n${UNSUBSCRIBE_FOOTER_LABEL}: ${unsubscribeUrl}` : '';
+    if (content.mode === 'text') {
+        const messageText = resolveMergeTags(content.body, recipient);
+        const text = `${messageText}${unsubscribeLine}`;
+        return {
+            subject,
+            /*
+       * THE HTML FOOTER IS RENDERED, NOT LINKIFIED OUT OF THE TEXT.
+       *
+       * Synthesizing the HTML from `text` — footer included — used to work,
+       * and produced a footer whose visible words were the raw signed URL:
+       * `renderTextEmailHtml` turns a bare URL into an anchor labelled with
+       * itself, which is right for a link the AUTHOR typed and wrong for the
+       * one line this renderer writes. A hundred characters of `hostId`,
+       * `sig` and `cid` is not a thing a person reads, and it buries the only
+       * sentence in the message that tells them they can leave one stream
+       * instead of all of them.
+       *
+       * So the message is linkified WITHOUT the footer, and the footer is
+       * appended by the same helper the designed branch uses — same styling,
+       * same words, tracking-rewritten by the provider exactly as before,
+       * because rewriting keys on the `href` and not on the label.
+       *
+       * The TEXT part keeps the bare URL. Markup is invisible there and an
+       * address a reader can copy is the only form that works.
+       */ html: unsubscribeUrl ? appendUnsubscribeHtml(renderTextEmailHtml(messageText, subject, preheader), unsubscribeUrl) : renderTextEmailHtml(text, subject, preheader),
+            text,
+            messageText
+        };
+    }
+    const rendered = renderEmailHtml({
+        nodes: content.template.nodes,
+        // Besigner maps are rooted at `_@_`, not the renderer's default `root`:
+        // rendering one as `root` finds no root and emits an empty 600px shell.
+        rootId: EMAIL_NODE_ROOT_ID,
+        subject,
+        preheader,
+        sanitize: sanitizeAuthorHtml,
+        // An author-picked image is stored as a `media:` reference and resolves
+        // site-relative; an inbox has no page to resolve it against, so without an
+        // origin the renderer drops it.
+        mediaOrigin: siteBase || undefined,
+        mediaHostId: hostId,
+        merge: {
+            'contact.email': recipient.email,
+            'contact.name': name,
+            'contact.firstName': (_name_split_ = name.split(/\s+/)[0]) != null ? _name_split_ : '',
+            'site.url': siteBase,
+            unsubscribeUrl: unsubscribeUrl != null ? unsubscribeUrl : ''
+        },
+        products: Object.fromEntries(Object.entries((_content_template_products = content.template.products) != null ? _content_template_products : {}).map(([id, product])=>{
+            var _product_url;
+            return [
+                id,
+                product && _extends({}, product, {
+                    url: ((_product_url = product.url) == null ? void 0 : _product_url.startsWith('/')) ? `${siteBase}${product.url}` : product.url
+                })
+            ];
+        }))
+    });
+    /*
+   * THE PLAIN-TEXT PART: the design's own, unless somebody wrote one.
+   *
+   * Merge tags are resolved in an authored part exactly as they are in a
+   * plain-text campaign's body — a text part that ships `{{firstName|there}}`
+   * literally is worse than the generated one it replaced. The design's own
+   * text arrives already substituted, through `renderEmailHtml`'s `merge` map.
+   *
+   * The opt-out line is appended either way, and it is a BARE URL rather than
+   * an anchor: markup is invisible in a text part, so a link a text-only
+   * reader can copy is the only form that works. It is the one part of the
+   * footer an author cannot write away.
+   */ const authored = (_content_plainText = content.plainText) == null ? void 0 : _content_plainText.trim();
+    const messageText = authored ? resolveMergeTags(authored, recipient) : rendered.text;
+    return {
+        subject,
+        /*
+     * THE HTML PART GETS THE SAME FOOTER THE TEXT PART GETS.
+     *
+     * A designed template carries an opt-out only if its author placed a
+     * `{{unsubscribeUrl}}` somewhere, and nothing made them: a template whose
+     * footer block says only the copyright line renders an HTML part with no
+     * way out of the list at all, which is the half of the message almost
+     * every recipient reads. The text part had the link and the HTML did not,
+     * so the defect was invisible to anyone reading their own test send.
+     *
+     * `appendUnsubscribeHtml` is idempotent by URL, so an author who DID
+     * place the merge token keeps their own placement and gets no second
+     * footer — the same rule `sendEmail` applies to every other marketing
+     * path, applied here because the campaign sender passes no `marketing`
+     * context and so never reaches that append.
+     */ html: unsubscribeUrl ? appendUnsubscribeHtml(rendered.html, unsubscribeUrl) : rendered.html,
+        text: `${messageText}${unsubscribeLine}`,
+        messageText
+    };
+}
+/**
+ * The merge tags the send path resolves, for the composer to offer.
+ *
+ * Kept beside the renderer because `resolveMergeTags` recognizes exactly
+ * these three and substitutes the fallback for anything else: a tag a
+ * merchant types from memory that is not on this list does not fail, it
+ * silently renders as nothing in mail that has already gone out. A composer
+ * that lists them is the difference between a documented feature and a
+ * guess.
+ */ export const EMAIL_MERGE_TAGS = [
+    {
+        token: '{{firstName|there}}',
+        description: 'The recipient’s first name, or “there” when none is stored'
+    },
+    {
+        token: '{{name}}',
+        description: 'The recipient’s full name, where the audience stores one'
+    },
+    {
+        token: '{{email}}',
+        description: 'The address this copy is going to'
+    }
+];
+
+//# sourceMappingURL=recipient-email-render.js.map

package/src/lib/app-utils/recipient-email-render.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../libs/aglyn/src/lib/app-utils/recipient-email-render.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 * ONE MESSAGE FOR ONE RECIPIENT, RENDERED — the step between a composed email\n * and the two parts that reach an inbox.\n *\n * It sits on the platform's mail rail, in the core, because more than one\n * plugin needs the SAME rendering: the plugin that sends a campaign renders\n * each recipient's copy through it, and the plugin that designs an email\n * checks a design through it before anything is sent. Neither may import the\n * other, and a second renderer in either would be a preview of something else.\n * It composes `@aglyn/shared-util-email`'s primitives with the core's HTML\n * sanitizer, which is why it cannot live in `shared`. Imported by its own\n * subpath; it is not in the barrel.\n *\n * It exists as a shared function because a preview that renders the message a\n * second way is a preview of something else. The class of defect it is meant\n * to catch has bitten twice on this send path — a designed campaign mailed\n * with its product blocks missing, and merge tags that resolved to empty\n * strings for an entire member audience — and neither would have been visible\n * in a preview that did not go through the same renderer, the same merge-tag\n * resolution and the same plain-text synthesis as the send.\n *\n * PURE, and free of `firebase-admin`, so the same call answers in three\n * places: the per-recipient loop in `campaign-send.ts`, the composer's\n * `renderPreview` action, and the console's own client components. Its inputs\n * are already-loaded data — a node map, resolved products, a recipient — and\n * the loading stays with the caller that has the credentials for it.\n */\n\n// By leaf, never the library's index: the index reaches the sender and the\n// health check, which this module has no use for.\nimport {\n  EMAIL_NODE_ROOT_ID,\n  renderEmailHtml,\n  type EmailRenderProduct,\n} from '@aglyn/shared-util-email/email-render'\nimport {\n  resolveMergeTags,\n  type MergeTagRecipient,\n} from '@aglyn/shared-util-email/email-merge'\nimport {\n  appendUnsubscribeHtml,\n  UNSUBSCRIBE_FOOTER_LABEL,\n} from '@aglyn/shared-util-email/marketing-send'\nimport { renderTextEmailHtml } from '@aglyn/shared-util-email/text-email-html'\n/*\n * The LEAF app-util, not `@aglyn/aglyn/server`: this module is pure and is\n * imported by client components, so a server entry point here would pull the\n * Admin SDK into a browser bundle. The email blocks the besigner previews\n * these same nodes under call this same function — so the mailed copy and the\n * previewed copy are one policy over one string rather than two kept in step\n * by hand.\n */\nimport { sanitizeAuthorHtml } from './author-html';\n\n/**\n * A designed email, loaded. `nodes` is the DECODED besigner map: the stored\n * form is compressed msgpack from the first designer save onward, and a\n * caller that passes the raw value renders an empty shell.\n */\nexport interface DesignedEmailTemplate {\n  nodes: Record<string, unknown>\n  products?: Record<string, EmailRenderProduct | undefined>\n  /** The template's own preview line, used when the campaign names none. */\n  preheader?: string\n  /** The template's own subject, used when the campaign names none. */\n  subject?: string\n}\n\n/**\n * WHERE THE MESSAGE COMES FROM — one source, named.\n *\n * A union rather than two optional fields, and that is the whole point. The\n * design already supplies BOTH parts an inbox receives: `renderEmailHtml`\n * returns the HTML and a plain-text rendering of the same nodes, links\n * included. So on a designed send a typed BODY — the whole message of a\n * plain-text email — has no part to occupy, and the earlier shape, which\n * accepted both and read the body only when no template was given, computed it\n * and threw it away without saying so.\n *\n * What an author actually wants there is named for its job instead:\n * `plainText`, the text HALF of a designed message, generated from the design\n * by default. That is a different offer from reinterpreting a body, and\n * deliberately — see the field.\n *\n * Two members and not three: a saved TEMPLATE is a besigner email screen, the\n * same document the design picker offers, so \"designed\" and \"from a template\"\n * name one thing.\n *\n * With the two collapsed into a union the discard is not merely refused, it is\n * unsayable: the designed branch has no `body` in scope to drop, and a caller\n * holding both has to decide which it means before it can call at all.\n */\nexport type RecipientEmailContent =\n  | {\n      /** Written in the composer; the HTML part is synthesized from it. */\n      mode: 'text'\n      /** The plain-text body, after any A/B variant override. */\n      body: string\n    }\n  | {\n      /** Built in the besigner; the HTML part comes from the nodes. */\n      mode: 'design'\n      template: DesignedEmailTemplate\n      /**\n       * The author's OWN plain-text part, replacing the one the design\n       * generates. Absent — not empty — means generated.\n       *\n       * Presence is the whole signal, which is why this is a separate\n       * optional field rather than a flag beside a string: a flag and a value\n       * are two things that can disagree, and the disagreement is invisible.\n       *\n       * Worth having because the generated text is good but not perfect. A\n       * button and a product keep their URLs in it; an inline link inside an\n       * `emailRichtext` block does not — the synthesis strips tags, so the\n       * href goes with them. An author who cares about what a text-only\n       * reader can actually follow needs a way to say so.\n       */\n      plainText?: string\n    }\n\n/** Which of the two ways one email is written. */\nexport type EmailMessageMode = RecipientEmailContent['mode']\n\n/**\n * Which mode a stored email is in, from the one field that decides it.\n *\n * Naming a template IS being designed — there is no separate flag, and adding\n * one would be a second answer to drift from this one. Read by the composer,\n * by the surfaces that describe a message and by the send path, so a record\n * cannot be shown as one thing and mailed as another.\n */\nexport function emailMessageMode(record: {\n  templateScreenId?: string | null\n}): EmailMessageMode {\n  return record.templateScreenId ? 'design' : 'text'\n}\n\nexport interface RecipientEmailRenderInput {\n  /** The campaign's subject, after any A/B variant override. */\n  subject: string\n  /** The one source this message is written from. */\n  content: RecipientEmailContent\n  /** The composer's preview line; overrides the template's own. */\n  preheader?: string\n  /** Who this copy is being personalized for. */\n  recipient: MergeTagRecipient\n  /** The site's own public origin, absolutizing media and product links. */\n  siteBase?: string\n  /** Qualifies an org-scoped media asset for the unauthenticated CDN. */\n  hostId?: string\n  /** The recipient's signed opt-out link, appended to the text part. */\n  unsubscribeUrl?: string\n}\n\nexport interface RenderedRecipientEmail {\n  /** The subject with this recipient's merge values resolved. */\n  subject: string\n  /** The HTML part, which every campaign message carries. */\n  html: string\n  /** The plain-text part, ending in the opt-out line. */\n  text: string\n  /**\n   * The message's own plain text, WITHOUT the opt-out line.\n   *\n   * What the composer fills an authored plain-text part from. Prefilling from\n   * `text` would fold this send's footer into the stored override, and the\n   * next send would append a second one — so the two are reported apart\n   * rather than the caller trying to trim one off the other.\n   */\n  messageText: string\n}\n\n/**\n * WHERE A DESIGNED EMAIL'S PLAIN-TEXT PART COMES FROM, and whether it still\n * describes the design.\n *\n * Two facts a composer has to state rather than imply. An authored text part\n * is not overwritten when the design is edited — losing somebody's writing\n * because they touched the canvas afterwards is not a trade worth making —\n * which leaves the other half of the problem: an override written against a\n * design that has since changed says something the HTML no longer says, and\n * nothing about it is visible. A value that cannot be read scores the same as\n * one that is absent, which is the shape of the defect this whole area is\n * being fixed for.\n *\n * So the design's VERSION is recorded beside the override, and the two are\n * compared here. Pure, and read by the composer, so the notice a merchant sees\n * and the state the record is in cannot disagree.\n */\nexport interface EmailPlainTextState {\n  /** `authored` when somebody wrote it; `generated` from the design. */\n  source: 'generated' | 'authored'\n  /**\n   * An authored part written against a design that has moved since.\n   *\n   * False for a generated part, which cannot go stale — it is derived from\n   * whatever the design says at send time — and false when either version is\n   * unknown, because an unanswerable question must not render as a warning.\n   */\n  stale: boolean\n}\n\nexport function emailPlainTextState(\n  record: {\n    plainText?: string | null\n    /** The design version the override was written against. */\n    plainTextVersionId?: string | null\n  },\n  /** The design's version as it stands now. */\n  currentVersionId?: string | null,\n): EmailPlainTextState {\n  if (!record.plainText?.trim()) return { source: 'generated', stale: false }\n  const written = record.plainTextVersionId ?? ''\n  return {\n    source: 'authored',\n    stale: Boolean(written && currentVersionId && written !== currentVersionId),\n  }\n}\n\n/**\n * Renders one campaign message for one recipient.\n *\n * The HTML part is produced here rather than left to `sendEmail`'s fallback\n * so that a caller can SEE it. `sendEmail` synthesizes an HTML part from the\n * text of any message that arrives without one — a text-only message has no\n * anchors, so its links are inert and click tracking has nothing to rewrite —\n * and this calls the same `renderTextEmailHtml` with the same text and\n * subject, so a plain-text campaign is byte-identical either way.\n */\nexport function renderRecipientEmail(\n  input: RecipientEmailRenderInput,\n): RenderedRecipientEmail {\n  const { content, recipient, siteBase = '', hostId, unsubscribeUrl } = input\n  const template = content.mode === 'design' ? content.template : null\n  const subject = resolveMergeTags(\n    input.subject || template?.subject || '',\n    recipient,\n  )\n  const preheader = input.preheader?.trim() || template?.preheader || ''\n  const name = (recipient.name ?? '').trim()\n  /*\n   * The plain-text footer, named for what the link actually opens — see\n   * {@link UNSUBSCRIBE_FOOTER_LABEL}, which the non-campaign marketing paths\n   * write into their own footers from the same constant.\n   */\n  const unsubscribeLine = unsubscribeUrl\n    ? `\\n\\n—\\n${UNSUBSCRIBE_FOOTER_LABEL}: ${unsubscribeUrl}`\n    : ''\n\n  if (content.mode === 'text') {\n    const messageText = resolveMergeTags(content.body, recipient)\n    const text = `${messageText}${unsubscribeLine}`\n    return {\n      subject,\n      /*\n       * THE HTML FOOTER IS RENDERED, NOT LINKIFIED OUT OF THE TEXT.\n       *\n       * Synthesizing the HTML from `text` — footer included — used to work,\n       * and produced a footer whose visible words were the raw signed URL:\n       * `renderTextEmailHtml` turns a bare URL into an anchor labelled with\n       * itself, which is right for a link the AUTHOR typed and wrong for the\n       * one line this renderer writes. A hundred characters of `hostId`,\n       * `sig` and `cid` is not a thing a person reads, and it buries the only\n       * sentence in the message that tells them they can leave one stream\n       * instead of all of them.\n       *\n       * So the message is linkified WITHOUT the footer, and the footer is\n       * appended by the same helper the designed branch uses — same styling,\n       * same words, tracking-rewritten by the provider exactly as before,\n       * because rewriting keys on the `href` and not on the label.\n       *\n       * The TEXT part keeps the bare URL. Markup is invisible there and an\n       * address a reader can copy is the only form that works.\n       */\n      html: unsubscribeUrl\n        ? appendUnsubscribeHtml(\n            renderTextEmailHtml(messageText, subject, preheader),\n            unsubscribeUrl,\n          )\n        : renderTextEmailHtml(text, subject, preheader),\n      text,\n      messageText,\n    }\n  }\n\n  const rendered = renderEmailHtml({\n    nodes: content.template.nodes as never,\n    // Besigner maps are rooted at `_@_`, not the renderer's default `root`:\n    // rendering one as `root` finds no root and emits an empty 600px shell.\n    rootId: EMAIL_NODE_ROOT_ID,\n    subject,\n    preheader,\n    sanitize: sanitizeAuthorHtml,\n    // An author-picked image is stored as a `media:` reference and resolves\n    // site-relative; an inbox has no page to resolve it against, so without an\n    // origin the renderer drops it.\n    mediaOrigin: siteBase || undefined,\n    mediaHostId: hostId,\n    merge: {\n      'contact.email': recipient.email,\n      'contact.name': name,\n      'contact.firstName': name.split(/\\s+/)[0] ?? '',\n      'site.url': siteBase,\n      unsubscribeUrl: unsubscribeUrl ?? '',\n    },\n    products: Object.fromEntries(\n      Object.entries(content.template.products ?? {}).map(([id, product]) => [\n        id,\n        product && {\n          ...product,\n          url: product.url?.startsWith('/')\n            ? `${siteBase}${product.url}`\n            : product.url,\n        },\n      ]),\n    ),\n  })\n  /*\n   * THE PLAIN-TEXT PART: the design's own, unless somebody wrote one.\n   *\n   * Merge tags are resolved in an authored part exactly as they are in a\n   * plain-text campaign's body — a text part that ships `{{firstName|there}}`\n   * literally is worse than the generated one it replaced. The design's own\n   * text arrives already substituted, through `renderEmailHtml`'s `merge` map.\n   *\n   * The opt-out line is appended either way, and it is a BARE URL rather than\n   * an anchor: markup is invisible in a text part, so a link a text-only\n   * reader can copy is the only form that works. It is the one part of the\n   * footer an author cannot write away.\n   */\n  const authored = content.plainText?.trim()\n  const messageText = authored\n    ? resolveMergeTags(authored, recipient)\n    : rendered.text\n  return {\n    subject,\n    /*\n     * THE HTML PART GETS THE SAME FOOTER THE TEXT PART GETS.\n     *\n     * A designed template carries an opt-out only if its author placed a\n     * `{{unsubscribeUrl}}` somewhere, and nothing made them: a template whose\n     * footer block says only the copyright line renders an HTML part with no\n     * way out of the list at all, which is the half of the message almost\n     * every recipient reads. The text part had the link and the HTML did not,\n     * so the defect was invisible to anyone reading their own test send.\n     *\n     * `appendUnsubscribeHtml` is idempotent by URL, so an author who DID\n     * place the merge token keeps their own placement and gets no second\n     * footer — the same rule `sendEmail` applies to every other marketing\n     * path, applied here because the campaign sender passes no `marketing`\n     * context and so never reaches that append.\n     */\n    html: unsubscribeUrl\n      ? appendUnsubscribeHtml(rendered.html, unsubscribeUrl)\n      : rendered.html,\n    text: `${messageText}${unsubscribeLine}`,\n    messageText,\n  }\n}\n\n/**\n * The merge tags the send path resolves, for the composer to offer.\n *\n * Kept beside the renderer because `resolveMergeTags` recognizes exactly\n * these three and substitutes the fallback for anything else: a tag a\n * merchant types from memory that is not on this list does not fail, it\n * silently renders as nothing in mail that has already gone out. A composer\n * that lists them is the difference between a documented feature and a\n * guess.\n */\nexport const EMAIL_MERGE_TAGS: ReadonlyArray<{\n  /** The full token, fallback included, as it should be typed. */\n  token: string\n  /** What it resolves to, per recipient. */\n  description: string\n}> = [\n  {\n    token: '{{firstName|there}}',\n    description: 'The recipient’s first name, or “there” when none is stored',\n  },\n  {\n    token: '{{name}}',\n    description: 'The recipient’s full name, where the audience stores one',\n  },\n  { token: '{{email}}', description: 'The address this copy is going to' },\n]\n"],"names":["EMAIL_NODE_ROOT_ID","renderEmailHtml","resolveMergeTags","appendUnsubscribeHtml","UNSUBSCRIBE_FOOTER_LABEL","renderTextEmailHtml","sanitizeAuthorHtml","emailMessageMode","record","templateScreenId","emailPlainTextState","currentVersionId","plainText","trim","source","stale","written","plainTextVersionId","Boolean","renderRecipientEmail","input","recipient","name","content","siteBase","hostId","unsubscribeUrl","template","mode","subject","preheader","unsubscribeLine","messageText","body","text","html","rendered","nodes","rootId","sanitize","mediaOrigin","undefined","mediaHostId","merge","email","split","products","Object","fromEntries","entries","map","id","product","url","startsWith","authored","EMAIL_MERGE_TAGS","token","description"],"mappings":"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"}

package/src/lib/app-utils/redispatch-caught-error.d.ts

@@ -0,0 +1,38 @@
+/**
+ * @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.
+ */
+/**
+ * Put a CAUGHT error back on the path an uncaught one takes (AGL-1538).
+ *
+ * React 19 routes errors an error boundary catches to `console.error`, and
+ * only uncaught ones to `reportError` — so a boundary that renders quietly
+ * turns a reported crash into an invisible one. `reportError` dispatches an
+ * `error` event on `window`, which is the listener `installErrorBeacon`
+ * registers, so a re-dispatched failure lands in Cloud Error Reporting
+ * exactly as it would have without the boundary.
+ *
+ * Every error boundary in both apps needs this and each of them had grown its
+ * own copy of it. A module of its own rather than a function inside
+ * `error-beacon.ts`, which re-exports it: an error boundary importing one
+ * name off that file would drag the beacon's whole installer into its chunk,
+ * and a boundary's chunk is downloaded by every visitor whether or not
+ * anything ever throws.
+ *
+ * Optional and swallowed on both counts: jsdom and older Safari have no
+ * `reportError`, and reporting a failure may never be the thing that causes
+ * one.
+ */
+export declare function redispatchCaughtError(error: unknown): void;

package/src/lib/app-utils/redispatch-caught-error.js

@@ -0,0 +1,46 @@
+/**
+ * @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.
+ */ /**
+ * Put a CAUGHT error back on the path an uncaught one takes (AGL-1538).
+ *
+ * React 19 routes errors an error boundary catches to `console.error`, and
+ * only uncaught ones to `reportError` — so a boundary that renders quietly
+ * turns a reported crash into an invisible one. `reportError` dispatches an
+ * `error` event on `window`, which is the listener `installErrorBeacon`
+ * registers, so a re-dispatched failure lands in Cloud Error Reporting
+ * exactly as it would have without the boundary.
+ *
+ * Every error boundary in both apps needs this and each of them had grown its
+ * own copy of it. A module of its own rather than a function inside
+ * `error-beacon.ts`, which re-exports it: an error boundary importing one
+ * name off that file would drag the beacon's whole installer into its chunk,
+ * and a boundary's chunk is downloaded by every visitor whether or not
+ * anything ever throws.
+ *
+ * Optional and swallowed on both counts: jsdom and older Safari have no
+ * `reportError`, and reporting a failure may never be the thing that causes
+ * one.
+ */ export function redispatchCaughtError(error) {
+    if (typeof window === 'undefined') return;
+    try {
+        ;
+        window.reportError == null ? void 0 : window.reportError.call(window, error);
+    } catch (unused) {
+    // Reporting never breaks the page.
+    }
+}
+
+//# sourceMappingURL=redispatch-caught-error.js.map

package/src/lib/app-utils/redispatch-caught-error.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../libs/aglyn/src/lib/app-utils/redispatch-caught-error.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 * Put a CAUGHT error back on the path an uncaught one takes (AGL-1538).\n *\n * React 19 routes errors an error boundary catches to `console.error`, and\n * only uncaught ones to `reportError` — so a boundary that renders quietly\n * turns a reported crash into an invisible one. `reportError` dispatches an\n * `error` event on `window`, which is the listener `installErrorBeacon`\n * registers, so a re-dispatched failure lands in Cloud Error Reporting\n * exactly as it would have without the boundary.\n *\n * Every error boundary in both apps needs this and each of them had grown its\n * own copy of it. A module of its own rather than a function inside\n * `error-beacon.ts`, which re-exports it: an error boundary importing one\n * name off that file would drag the beacon's whole installer into its chunk,\n * and a boundary's chunk is downloaded by every visitor whether or not\n * anything ever throws.\n *\n * Optional and swallowed on both counts: jsdom and older Safari have no\n * `reportError`, and reporting a failure may never be the thing that causes\n * one.\n */\nexport function redispatchCaughtError(error: unknown): void {\n  if (typeof window === 'undefined') return\n  try {\n    ;(\n      window as Window & { reportError?: (error: unknown) => void }\n    ).reportError?.(error)\n  } catch {\n    // Reporting never breaks the page.\n  }\n}\n"],"names":["redispatchCaughtError","error","window","reportError"],"mappings":"AAAA;;;;;;;;;;;;;;;CAeC,GAED;;;;;;;;;;;;;;;;;;;;CAoBC,GACD,OAAO,SAASA,sBAAsBC,KAAc;IAClD,IAAI,OAAOC,WAAW,aAAa;IACnC,IAAI;;QAEAA,OACAC,WAAW,oBAFZ,AACCD,OACAC,WAAW,MADXD,QACcD;IAClB,EAAE,eAAM;IACN,mCAAmC;IACrC;AACF"}

package/src/lib/app-utils/registering-plugin.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @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.
+ */
+export declare function setRegisteringPluginId(pluginId: string | undefined): void;
+/** The plugin whose register fn is running, or undefined outside registration. */
+export declare function getRegisteringPluginId(): string | undefined;

package/src/lib/app-utils/registering-plugin.js

@@ -0,0 +1,38 @@
+/**
+ * @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.
+ */ /**
+ * Which plugin's register fn is currently running.
+ *
+ * A LEAF module on purpose — it imports nothing, so anything may import it
+ * without risking a cycle. This lived in `api-plugins`, which is reachable
+ * only through the `/server` entry; when `site-page-hooks` (in the shared
+ * plugin-manager barrel, client and server both) reached for it, the cycle
+ * that created left the binding missing at runtime and the server threw
+ * `ReferenceError: getRegisteringPluginId is not defined` (AGL-1289).
+ *
+ * The marker is set by the plugin loader around each register-fn call, so any
+ * registry can record who registered what: `registerPluginApiRoute` uses it
+ * for path→plugin ownership, `registerSitePageEnricher` for attributing a
+ * page contribution back to the plugin that produced it.
+ */ let registeringPluginId;
+export function setRegisteringPluginId(pluginId) {
+    registeringPluginId = pluginId;
+}
+/** The plugin whose register fn is running, or undefined outside registration. */ export function getRegisteringPluginId() {
+    return registeringPluginId;
+}
+
+//# sourceMappingURL=registering-plugin.js.map

package/src/lib/app-utils/registering-plugin.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../libs/aglyn/src/lib/app-utils/registering-plugin.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 * Which plugin's register fn is currently running.\n *\n * A LEAF module on purpose — it imports nothing, so anything may import it\n * without risking a cycle. This lived in `api-plugins`, which is reachable\n * only through the `/server` entry; when `site-page-hooks` (in the shared\n * plugin-manager barrel, client and server both) reached for it, the cycle\n * that created left the binding missing at runtime and the server threw\n * `ReferenceError: getRegisteringPluginId is not defined` (AGL-1289).\n *\n * The marker is set by the plugin loader around each register-fn call, so any\n * registry can record who registered what: `registerPluginApiRoute` uses it\n * for path→plugin ownership, `registerSitePageEnricher` for attributing a\n * page contribution back to the plugin that produced it.\n */\nlet registeringPluginId: string | undefined\n\nexport function setRegisteringPluginId(pluginId: string | undefined): void {\n  registeringPluginId = pluginId\n}\n\n/** The plugin whose register fn is running, or undefined outside registration. */\nexport function getRegisteringPluginId(): string | undefined {\n  return registeringPluginId\n}\n"],"names":["registeringPluginId","setRegisteringPluginId","pluginId","getRegisteringPluginId"],"mappings":"AAAA;;;;;;;;;;;;;;;CAeC,GAED;;;;;;;;;;;;;;CAcC,GACD,IAAIA;AAEJ,OAAO,SAASC,uBAAuBC,QAA4B;IACjEF,sBAAsBE;AACxB;AAEA,gFAAgF,GAChF,OAAO,SAASC;IACd,OAAOH;AACT"}