@aglyn/aglyn 1.0.0-beta.182 → 1.0.0-beta.183

package/src/lib/app-utils/load-referenced-components.d.ts

@@ -0,0 +1,166 @@
+/**
+ * @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 ReusableComponentTree } from './compose-reusable-components';
+/**
+ * The fields of `hosts/{hostId}/components/{id}` a render reads: the PUBLISHED
+ * snapshot. `rootId`, `nodes` and the declared `props` live on the component
+ * document itself, never on its versions (AGL-679), so one read per component
+ * is the whole cost.
+ */
+export interface StoredComponentDocument {
+    rootId?: unknown;
+    nodes?: unknown;
+    props?: unknown;
+    deletedAt?: unknown;
+}
+/** Why a referenced component gave no tree to graft. */
+export type ComponentSkipReason = 
+/** No such document. */
+'missing'
+/** Soft-deleted: it renders nothing, wherever it was placed. */
+ | 'deleted'
+/** Created but never published — no `rootId`/`nodes` on the document. */
+ | 'unpublished'
+/** Its `nodes` could not be decoded; `decodeStoredNodes` logs why. */
+ | 'undecodable'
+/** Not usable as one document id, so it was never read (AGL-1771). */
+ | 'invalid'
+/** Past {@link REFERENCED_COMPONENTS_READ_LIMIT}; not read. */
+ | 'limit';
+export type StoredComponentTreeRead = {
+    ok: true;
+    tree: ReusableComponentTree;
+} | {
+    ok: false;
+    reason: Exclude<ComponentSkipReason, 'invalid' | 'limit'>;
+};
+/**
+ * A stored component document as the tree `composeReusableComponentNodes`
+ * grafts, or why it is not one.
+ *
+ * BOTH STORED FORMS (AGL-1151). A published definition is msgpack for anything
+ * promoted since components were compressed and a plain map for everything
+ * older, and nothing migrates them — `decodeStoredNodes` returns a map
+ * unchanged, so one call serves both forever. Reading the field raw is a
+ * SILENT failure: the graft looks up `nodes[rootId]` on a `Buffer`, finds
+ * nothing, and every placement of the component renders empty.
+ *
+ * An undecodable definition is skipped rather than grafted empty. The page or
+ * the mail comes out the same either way, but `decodeStoredNodes` logs the
+ * reason, and a definition that silently became `{}` would not say why the
+ * component vanished.
+ */
+export declare function readStoredComponentTree(stored: StoredComponentDocument | null | undefined): StoredComponentTreeRead;
+/**
+ * One component document by id — `null` or `undefined` when there is none. A
+ * rejection is a failed READ and fails the whole load: an email must not go out
+ * missing its footer because a request timed out, and every caller has a
+ * better answer to an error than a quietly partial design.
+ */
+export type ReadComponentDocument = (componentId: string) => Promise<StoredComponentDocument | null | undefined>;
+/** A referenced component that gave no tree, and why. */
+export interface SkippedComponent {
+    id: string;
+    reason: ComponentSkipReason;
+}
+/**
+ * Documents one load may read — the same bound `getComponents` reads a whole
+ * site under, so an on-demand render can never cost more than a page does.
+ */
+export declare const REFERENCED_COMPONENTS_READ_LIMIT = 200;
+export interface LoadReferencedComponentsOptions {
+    /** Levels of nesting to follow; the graft's own bound by default. */
+    maxDepth?: number;
+    /** Documents one load may read; {@link REFERENCED_COMPONENTS_READ_LIMIT} by default. */
+    maxDocuments?: number;
+    /**
+     * Told once, after the load, about every referenced id that gave no tree.
+     * The default logs a warning: a placement of a deleted component renders
+     * nothing, and nothing else would say why.
+     */
+    onSkipped?: (skipped: readonly SkippedComponent[]) => void;
+}
+/**
+ * The published definitions `nodes` places — directly, or through another
+ * definition — keyed by id, in the shape `composeReusableComponentNodes`
+ * takes.
+ *
+ * Reads a LEVEL at a time: the ids the document places, then the ids those
+ * definitions place, and so on to {@link MAX_COMPONENT_DEPTH}. Each level's
+ * reads run in parallel, and an id is never read twice, so a cycle costs one
+ * read per component in it. Deleted, never-published, undecodable and missing
+ * definitions are left out — a placement of one renders nothing, exactly as it
+ * does on a page — and reported through `onSkipped`.
+ */
+export declare function loadReferencedComponents(nodes: Readonly<Record<string, unknown>> | null | undefined, read: ReadComponentDocument, options?: LoadReferencedComponentsOptions): Promise<Record<string, ReusableComponentTree>>;
+/**
+ * `nodes` with every reusable-component placement expanded from the published
+ * definitions it references — {@link loadReferencedComponents} then
+ * `composeReusableComponentNodes`.
+ *
+ * After it, each placement IS its component's root, carrying the placement's
+ * id (AGL-2521): a renderer sees the component's own blocks, with the
+ * placement's property values (AGL-1247) and attribute overrides (AGL-1899)
+ * applied, and knows nothing about components. Tokens the graft does not own
+ * — merge tokens, host tokens, site variables — pass through untouched for the
+ * renderer that does.
+ *
+ * A document that places nothing comes back AS GIVEN, the same reference, with
+ * no read made. A placement whose component did not load is left exactly as
+ * authored, which is how a deleted definition never takes a document down.
+ */
+export declare function composeReferencedComponents<M extends Readonly<Record<string, unknown>>>(nodes: M, read: ReadComponentDocument, options?: LoadReferencedComponentsOptions): Promise<M>;
+/** A document snapshot, as far as {@link hostComponentReader} reads one. */
+interface ComponentSnapshotLike {
+    exists: boolean;
+    get(field: string): unknown;
+}
+interface ComponentDocumentRefLike {
+    get(): Promise<ComponentSnapshotLike>;
+    collection(path: string): ComponentCollectionRefLike;
+}
+interface ComponentCollectionRefLike {
+    doc(id: string): ComponentDocumentRefLike;
+}
+/**
+ * The slice of the Admin Firestore chain {@link hostComponentReader} walks.
+ * Structural, so a caller holding any Admin handle — or a spec's fake — passes
+ * it without a cast, and so this core module takes no `firebase-admin`
+ * dependency. `@aglyn/shared-util-email`'s `AdminFirestoreLike` satisfies it.
+ */
+export interface ComponentStoreLike {
+    collection(path: string): ComponentCollectionRefLike;
+}
+/**
+ * A {@link ReadComponentDocument} over `hosts/{hostId}/components` through the
+ * Admin SDK — one document get per component, the four fields a render needs.
+ */
+export declare function hostComponentReader(firestore: ComponentStoreLike, hostId: string): ReadComponentDocument;
+/**
+ * {@link composeReferencedComponents} for a site's own document, read through
+ * the Admin SDK: what every server path that sends, previews or publishes an
+ * email composes with.
+ *
+ * Shaped `(nodes, { firestore, hostId })` so it is passed as it stands wherever
+ * a composer is asked for — `loadHostEmail`'s `compose` is one — rather than
+ * wrapped at each call site. Skips are logged with the site they belong to.
+ */
+export declare function composeHostComponentNodes<M extends Readonly<Record<string, unknown>>>(nodes: M, context: {
+    firestore: ComponentStoreLike;
+    hostId: string;
+}): Promise<M>;
+export {};

package/src/lib/app-utils/load-referenced-components.js

@@ -0,0 +1,219 @@
+/**
+ * @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 COMPONENTS ONE DOCUMENT PLACES, READ ON DEMAND (AGL-3287).
+ *
+ * A published page composes against every component the site has, read in one
+ * collection query and held in the render cache — `getComponents` in the tenant
+ * runtime. That is the right trade for a page, which is rendered constantly and
+ * served from cache. It is the wrong one for a document rendered on demand: an
+ * email sent, test-sent or previewed, a design being published elsewhere. Those
+ * are not cached pages, a cache would serve a header the site has since
+ * republished, and most of them place no component at all.
+ *
+ * So this reads ONLY what a node map references, following nesting to the same
+ * depth the graft expands ({@link MAX_COMPONENT_DEPTH}), a level at a time, each
+ * level in parallel. A document that places nothing costs no read at all.
+ *
+ * It knows nothing about Firestore. A caller hands it a {@link
+ * ReadComponentDocument} — the Admin SDK through {@link hostComponentReader},
+ * the client SDK in a console preview — so the same walk serves a send, a
+ * browser and a spec's fake. Pure otherwise, and client-safe: no Node builtin,
+ * no cache, no Next.
+ *
+ * What a stored document MEANS as a tree is {@link readStoredComponentTree},
+ * which `getComponents` reads its collection through too, so the page and the
+ * mail cannot come to disagree about a component's published design.
+ */ import { _ as _extends } from "@swc/helpers/_/_extends";
+import { collectReferencedComponentIds, composeReusableComponentNodes, MAX_COMPONENT_DEPTH } from "./compose-reusable-components.js";
+import { decodeStoredNodes } from "./stored-nodes.js";
+/**
+ * A stored component document as the tree `composeReusableComponentNodes`
+ * grafts, or why it is not one.
+ *
+ * BOTH STORED FORMS (AGL-1151). A published definition is msgpack for anything
+ * promoted since components were compressed and a plain map for everything
+ * older, and nothing migrates them — `decodeStoredNodes` returns a map
+ * unchanged, so one call serves both forever. Reading the field raw is a
+ * SILENT failure: the graft looks up `nodes[rootId]` on a `Buffer`, finds
+ * nothing, and every placement of the component renders empty.
+ *
+ * An undecodable definition is skipped rather than grafted empty. The page or
+ * the mail comes out the same either way, but `decodeStoredNodes` logs the
+ * reason, and a definition that silently became `{}` would not say why the
+ * component vanished.
+ */ export function readStoredComponentTree(stored) {
+    if (!stored) return {
+        ok: false,
+        reason: 'missing'
+    };
+    if (stored.deletedAt) return {
+        ok: false,
+        reason: 'deleted'
+    };
+    if (!stored.nodes || !stored.rootId) return {
+        ok: false,
+        reason: 'unpublished'
+    };
+    const nodes = decodeStoredNodes(stored.nodes);
+    if (!nodes) return {
+        ok: false,
+        reason: 'undecodable'
+    };
+    return {
+        ok: true,
+        tree: _extends({
+            rootId: stored.rootId,
+            nodes
+        }, Array.isArray(stored.props) && stored.props.length && {
+            props: stored.props
+        })
+    };
+}
+/**
+ * Documents one load may read — the same bound `getComponents` reads a whole
+ * site under, so an on-demand render can never cost more than a page does.
+ */ export const REFERENCED_COMPONENTS_READ_LIMIT = 200;
+/**
+ * Whether a referenced id may be handed to a reader as ONE document id.
+ *
+ * `refId` is author-controlled, and `doc()` appends a slash-separated PATH:
+ * `half/path` throws where the reference is built and `a/b/c` reads beneath a
+ * document that does not exist (AGL-1771, `isDocumentId` in
+ * `@aglyn/tenant-data-admin/server/document-id`). That predicate is
+ * server-only — it measures with `Buffer` — and this walk also runs in a
+ * browser, so the same clauses are restated with `TextEncoder`.
+ */ function isReadableComponentId(id) {
+    return id.length > 0 && !id.includes('/') && id !== '.' && id !== '..' && !/^__.*__$/.test(id) && new TextEncoder().encode(id).length <= 1500;
+}
+function warnSkipped(skipped) {
+    console.warn('reusable components skipped', skipped);
+}
+/**
+ * The published definitions `nodes` places — directly, or through another
+ * definition — keyed by id, in the shape `composeReusableComponentNodes`
+ * takes.
+ *
+ * Reads a LEVEL at a time: the ids the document places, then the ids those
+ * definitions place, and so on to {@link MAX_COMPONENT_DEPTH}. Each level's
+ * reads run in parallel, and an id is never read twice, so a cycle costs one
+ * read per component in it. Deleted, never-published, undecodable and missing
+ * definitions are left out — a placement of one renders nothing, exactly as it
+ * does on a page — and reported through `onSkipped`.
+ */ export async function loadReferencedComponents(nodes, read, options = {}) {
+    var _options_maxDepth, _options_maxDocuments, _options_onSkipped;
+    const maxDepth = (_options_maxDepth = options.maxDepth) != null ? _options_maxDepth : MAX_COMPONENT_DEPTH;
+    const maxDocuments = (_options_maxDocuments = options.maxDocuments) != null ? _options_maxDocuments : REFERENCED_COMPONENTS_READ_LIMIT;
+    const source = nodes;
+    const definitions = {};
+    /** Every id already read, refused or skipped — never asked about again. */ const settled = new Set();
+    const skipped = [];
+    let reads = 0;
+    for(let depth = 0; depth < maxDepth; depth++){
+        // The whole reference set through what has loaded so far, minus what is
+        // settled — which is exactly the next level down.
+        const wanted = [
+            ...collectReferencedComponentIds(source, definitions)
+        ].filter((id)=>!settled.has(id));
+        if (!wanted.length) break;
+        const batch = [];
+        for (const id of wanted){
+            settled.add(id);
+            if (!isReadableComponentId(id)) {
+                skipped.push({
+                    id,
+                    reason: 'invalid'
+                });
+            } else if (reads + batch.length >= maxDocuments) {
+                skipped.push({
+                    id,
+                    reason: 'limit'
+                });
+            } else {
+                batch.push(id);
+            }
+        }
+        reads += batch.length;
+        const results = await Promise.all(batch.map(async (id)=>[
+                id,
+                readStoredComponentTree(await read(id))
+            ]));
+        for (const [id, outcome] of results){
+            if (outcome.ok === true) definitions[id] = outcome.tree;
+            else skipped.push({
+                id,
+                reason: outcome.reason
+            });
+        }
+    }
+    if (skipped.length) ((_options_onSkipped = options.onSkipped) != null ? _options_onSkipped : warnSkipped)(skipped);
+    return definitions;
+}
+/**
+ * `nodes` with every reusable-component placement expanded from the published
+ * definitions it references — {@link loadReferencedComponents} then
+ * `composeReusableComponentNodes`.
+ *
+ * After it, each placement IS its component's root, carrying the placement's
+ * id (AGL-2521): a renderer sees the component's own blocks, with the
+ * placement's property values (AGL-1247) and attribute overrides (AGL-1899)
+ * applied, and knows nothing about components. Tokens the graft does not own
+ * — merge tokens, host tokens, site variables — pass through untouched for the
+ * renderer that does.
+ *
+ * A document that places nothing comes back AS GIVEN, the same reference, with
+ * no read made. A placement whose component did not load is left exactly as
+ * authored, which is how a deleted definition never takes a document down.
+ */ export async function composeReferencedComponents(nodes, read, options) {
+    if (!collectReferencedComponentIds(nodes).size) return nodes;
+    const definitions = await loadReferencedComponents(nodes, read, options);
+    return composeReusableComponentNodes(nodes, definitions);
+}
+/**
+ * A {@link ReadComponentDocument} over `hosts/{hostId}/components` through the
+ * Admin SDK — one document get per component, the four fields a render needs.
+ */ export function hostComponentReader(firestore, hostId) {
+    return async (componentId)=>{
+        const snapshot = await firestore.collection('hosts').doc(hostId).collection('components').doc(componentId).get();
+        if (!snapshot.exists) return null;
+        return {
+            rootId: snapshot.get('rootId'),
+            nodes: snapshot.get('nodes'),
+            props: snapshot.get('props'),
+            deletedAt: snapshot.get('deletedAt')
+        };
+    };
+}
+/**
+ * {@link composeReferencedComponents} for a site's own document, read through
+ * the Admin SDK: what every server path that sends, previews or publishes an
+ * email composes with.
+ *
+ * Shaped `(nodes, { firestore, hostId })` so it is passed as it stands wherever
+ * a composer is asked for — `loadHostEmail`'s `compose` is one — rather than
+ * wrapped at each call site. Skips are logged with the site they belong to.
+ */ export function composeHostComponentNodes(nodes, context) {
+    const { firestore, hostId } = context;
+    return composeReferencedComponents(nodes, hostComponentReader(firestore, hostId), {
+        onSkipped: (skipped)=>console.warn(JSON.stringify({
+                tag: 'AGL-3287:components-skipped',
+                hostId,
+                skipped
+            }))
+    });
+}
+
+//# sourceMappingURL=load-referenced-components.js.map

package/src/lib/app-utils/load-referenced-components.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../libs/aglyn/src/lib/app-utils/load-referenced-components.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 COMPONENTS ONE DOCUMENT PLACES, READ ON DEMAND (AGL-3287).\n *\n * A published page composes against every component the site has, read in one\n * collection query and held in the render cache — `getComponents` in the tenant\n * runtime. That is the right trade for a page, which is rendered constantly and\n * served from cache. It is the wrong one for a document rendered on demand: an\n * email sent, test-sent or previewed, a design being published elsewhere. Those\n * are not cached pages, a cache would serve a header the site has since\n * republished, and most of them place no component at all.\n *\n * So this reads ONLY what a node map references, following nesting to the same\n * depth the graft expands ({@link MAX_COMPONENT_DEPTH}), a level at a time, each\n * level in parallel. A document that places nothing costs no read at all.\n *\n * It knows nothing about Firestore. A caller hands it a {@link\n * ReadComponentDocument} — the Admin SDK through {@link hostComponentReader},\n * the client SDK in a console preview — so the same walk serves a send, a\n * browser and a spec's fake. Pure otherwise, and client-safe: no Node builtin,\n * no cache, no Next.\n *\n * What a stored document MEANS as a tree is {@link readStoredComponentTree},\n * which `getComponents` reads its collection through too, so the page and the\n * mail cannot come to disagree about a component's published design.\n */\n\nimport type {\n  AglynNodeSchema,\n  NodeId,\n  ReusableComponentProp,\n} from '../foundation'\nimport {\n  collectReferencedComponentIds,\n  composeReusableComponentNodes,\n  MAX_COMPONENT_DEPTH,\n  type ReusableComponentTree,\n} from './compose-reusable-components'\nimport { decodeStoredNodes } from './stored-nodes'\n\n/**\n * The fields of `hosts/{hostId}/components/{id}` a render reads: the PUBLISHED\n * snapshot. `rootId`, `nodes` and the declared `props` live on the component\n * document itself, never on its versions (AGL-679), so one read per component\n * is the whole cost.\n */\nexport interface StoredComponentDocument {\n  rootId?: unknown\n  nodes?: unknown\n  props?: unknown\n  deletedAt?: unknown\n}\n\n/** Why a referenced component gave no tree to graft. */\nexport type ComponentSkipReason =\n  /** No such document. */\n  | 'missing'\n  /** Soft-deleted: it renders nothing, wherever it was placed. */\n  | 'deleted'\n  /** Created but never published — no `rootId`/`nodes` on the document. */\n  | 'unpublished'\n  /** Its `nodes` could not be decoded; `decodeStoredNodes` logs why. */\n  | 'undecodable'\n  /** Not usable as one document id, so it was never read (AGL-1771). */\n  | 'invalid'\n  /** Past {@link REFERENCED_COMPONENTS_READ_LIMIT}; not read. */\n  | 'limit'\n\nexport type StoredComponentTreeRead =\n  | { ok: true; tree: ReusableComponentTree }\n  | { ok: false; reason: Exclude<ComponentSkipReason, 'invalid' | 'limit'> }\n\n/**\n * A stored component document as the tree `composeReusableComponentNodes`\n * grafts, or why it is not one.\n *\n * BOTH STORED FORMS (AGL-1151). A published definition is msgpack for anything\n * promoted since components were compressed and a plain map for everything\n * older, and nothing migrates them — `decodeStoredNodes` returns a map\n * unchanged, so one call serves both forever. Reading the field raw is a\n * SILENT failure: the graft looks up `nodes[rootId]` on a `Buffer`, finds\n * nothing, and every placement of the component renders empty.\n *\n * An undecodable definition is skipped rather than grafted empty. The page or\n * the mail comes out the same either way, but `decodeStoredNodes` logs the\n * reason, and a definition that silently became `{}` would not say why the\n * component vanished.\n */\nexport function readStoredComponentTree(\n  stored: StoredComponentDocument | null | undefined,\n): StoredComponentTreeRead {\n  if (!stored) return { ok: false, reason: 'missing' }\n  if (stored.deletedAt) return { ok: false, reason: 'deleted' }\n  if (!stored.nodes || !stored.rootId)\n    return { ok: false, reason: 'unpublished' }\n  const nodes = decodeStoredNodes<ReusableComponentTree['nodes']>(stored.nodes)\n  if (!nodes) return { ok: false, reason: 'undecodable' }\n  return {\n    ok: true,\n    tree: {\n      rootId: stored.rootId as NodeId,\n      nodes,\n      // Declared props (AGL-1247): without these the graft leaves every\n      // `{{prop.*}}` token unresolved wherever the component is placed.\n      ...(Array.isArray(stored.props) &&\n        stored.props.length && {\n          props: stored.props as ReusableComponentProp[],\n        }),\n    },\n  }\n}\n\n/**\n * One component document by id — `null` or `undefined` when there is none. A\n * rejection is a failed READ and fails the whole load: an email must not go out\n * missing its footer because a request timed out, and every caller has a\n * better answer to an error than a quietly partial design.\n */\nexport type ReadComponentDocument = (\n  componentId: string,\n) => Promise<StoredComponentDocument | null | undefined>\n\n/** A referenced component that gave no tree, and why. */\nexport interface SkippedComponent {\n  id: string\n  reason: ComponentSkipReason\n}\n\n/**\n * Documents one load may read — the same bound `getComponents` reads a whole\n * site under, so an on-demand render can never cost more than a page does.\n */\nexport const REFERENCED_COMPONENTS_READ_LIMIT = 200\n\nexport interface LoadReferencedComponentsOptions {\n  /** Levels of nesting to follow; the graft's own bound by default. */\n  maxDepth?: number\n  /** Documents one load may read; {@link REFERENCED_COMPONENTS_READ_LIMIT} by default. */\n  maxDocuments?: number\n  /**\n   * Told once, after the load, about every referenced id that gave no tree.\n   * The default logs a warning: a placement of a deleted component renders\n   * nothing, and nothing else would say why.\n   */\n  onSkipped?: (skipped: readonly SkippedComponent[]) => void\n}\n\n/**\n * Whether a referenced id may be handed to a reader as ONE document id.\n *\n * `refId` is author-controlled, and `doc()` appends a slash-separated PATH:\n * `half/path` throws where the reference is built and `a/b/c` reads beneath a\n * document that does not exist (AGL-1771, `isDocumentId` in\n * `@aglyn/tenant-data-admin/server/document-id`). That predicate is\n * server-only — it measures with `Buffer` — and this walk also runs in a\n * browser, so the same clauses are restated with `TextEncoder`.\n */\nfunction isReadableComponentId(id: string): boolean {\n  return (\n    id.length > 0 &&\n    !id.includes('/') &&\n    id !== '.' &&\n    id !== '..' &&\n    !/^__.*__$/.test(id) &&\n    new TextEncoder().encode(id).length <= 1500\n  )\n}\n\nfunction warnSkipped(skipped: readonly SkippedComponent[]): void {\n  console.warn('reusable components skipped', skipped)\n}\n\n/**\n * The published definitions `nodes` places — directly, or through another\n * definition — keyed by id, in the shape `composeReusableComponentNodes`\n * takes.\n *\n * Reads a LEVEL at a time: the ids the document places, then the ids those\n * definitions place, and so on to {@link MAX_COMPONENT_DEPTH}. Each level's\n * reads run in parallel, and an id is never read twice, so a cycle costs one\n * read per component in it. Deleted, never-published, undecodable and missing\n * definitions are left out — a placement of one renders nothing, exactly as it\n * does on a page — and reported through `onSkipped`.\n */\nexport async function loadReferencedComponents(\n  nodes: Readonly<Record<string, unknown>> | null | undefined,\n  read: ReadComponentDocument,\n  options: LoadReferencedComponentsOptions = {},\n): Promise<Record<string, ReusableComponentTree>> {\n  const maxDepth = options.maxDepth ?? MAX_COMPONENT_DEPTH\n  const maxDocuments = options.maxDocuments ?? REFERENCED_COMPONENTS_READ_LIMIT\n  const source = nodes as Record<string, AglynNodeSchema | undefined> | null\n  const definitions: Record<string, ReusableComponentTree> = {}\n  /** Every id already read, refused or skipped — never asked about again. */\n  const settled = new Set<string>()\n  const skipped: SkippedComponent[] = []\n  let reads = 0\n\n  for (let depth = 0; depth < maxDepth; depth++) {\n    // The whole reference set through what has loaded so far, minus what is\n    // settled — which is exactly the next level down.\n    const wanted = [\n      ...collectReferencedComponentIds(source, definitions),\n    ].filter((id) => !settled.has(id))\n    if (!wanted.length) break\n    const batch: string[] = []\n    for (const id of wanted) {\n      settled.add(id)\n      if (!isReadableComponentId(id)) {\n        skipped.push({ id, reason: 'invalid' })\n      } else if (reads + batch.length >= maxDocuments) {\n        skipped.push({ id, reason: 'limit' })\n      } else {\n        batch.push(id)\n      }\n    }\n    reads += batch.length\n    const results = await Promise.all(\n      batch.map(\n        async (id) => [id, readStoredComponentTree(await read(id))] as const,\n      ),\n    )\n    for (const [id, outcome] of results) {\n      if (outcome.ok === true) definitions[id] = outcome.tree\n      else skipped.push({ id, reason: outcome.reason })\n    }\n  }\n\n  if (skipped.length) (options.onSkipped ?? warnSkipped)(skipped)\n  return definitions\n}\n\n/**\n * `nodes` with every reusable-component placement expanded from the published\n * definitions it references — {@link loadReferencedComponents} then\n * `composeReusableComponentNodes`.\n *\n * After it, each placement IS its component's root, carrying the placement's\n * id (AGL-2521): a renderer sees the component's own blocks, with the\n * placement's property values (AGL-1247) and attribute overrides (AGL-1899)\n * applied, and knows nothing about components. Tokens the graft does not own\n * — merge tokens, host tokens, site variables — pass through untouched for the\n * renderer that does.\n *\n * A document that places nothing comes back AS GIVEN, the same reference, with\n * no read made. A placement whose component did not load is left exactly as\n * authored, which is how a deleted definition never takes a document down.\n */\nexport async function composeReferencedComponents<\n  M extends Readonly<Record<string, unknown>>,\n>(\n  nodes: M,\n  read: ReadComponentDocument,\n  options?: LoadReferencedComponentsOptions,\n): Promise<M> {\n  if (!collectReferencedComponentIds(nodes as never).size) return nodes\n  const definitions = await loadReferencedComponents(nodes, read, options)\n  return composeReusableComponentNodes(\n    nodes as unknown as Record<NodeId, AglynNodeSchema>,\n    definitions,\n  ) as unknown as M\n}\n\n/** A document snapshot, as far as {@link hostComponentReader} reads one. */\ninterface ComponentSnapshotLike {\n  exists: boolean\n  get(field: string): unknown\n}\ninterface ComponentDocumentRefLike {\n  get(): Promise<ComponentSnapshotLike>\n  collection(path: string): ComponentCollectionRefLike\n}\ninterface ComponentCollectionRefLike {\n  doc(id: string): ComponentDocumentRefLike\n}\n\n/**\n * The slice of the Admin Firestore chain {@link hostComponentReader} walks.\n * Structural, so a caller holding any Admin handle — or a spec's fake — passes\n * it without a cast, and so this core module takes no `firebase-admin`\n * dependency. `@aglyn/shared-util-email`'s `AdminFirestoreLike` satisfies it.\n */\nexport interface ComponentStoreLike {\n  collection(path: string): ComponentCollectionRefLike\n}\n\n/**\n * A {@link ReadComponentDocument} over `hosts/{hostId}/components` through the\n * Admin SDK — one document get per component, the four fields a render needs.\n */\nexport function hostComponentReader(\n  firestore: ComponentStoreLike,\n  hostId: string,\n): ReadComponentDocument {\n  return async (componentId) => {\n    const snapshot = await firestore\n      .collection('hosts')\n      .doc(hostId)\n      .collection('components')\n      .doc(componentId)\n      .get()\n    if (!snapshot.exists) return null\n    return {\n      rootId: snapshot.get('rootId'),\n      nodes: snapshot.get('nodes'),\n      props: snapshot.get('props'),\n      deletedAt: snapshot.get('deletedAt'),\n    }\n  }\n}\n\n/**\n * {@link composeReferencedComponents} for a site's own document, read through\n * the Admin SDK: what every server path that sends, previews or publishes an\n * email composes with.\n *\n * Shaped `(nodes, { firestore, hostId })` so it is passed as it stands wherever\n * a composer is asked for — `loadHostEmail`'s `compose` is one — rather than\n * wrapped at each call site. Skips are logged with the site they belong to.\n */\nexport function composeHostComponentNodes<\n  M extends Readonly<Record<string, unknown>>,\n>(\n  nodes: M,\n  context: { firestore: ComponentStoreLike; hostId: string },\n): Promise<M> {\n  const { firestore, hostId } = context\n  return composeReferencedComponents(\n    nodes,\n    hostComponentReader(firestore, hostId),\n    {\n      onSkipped: (skipped) =>\n        console.warn(\n          JSON.stringify({\n            tag: 'AGL-3287:components-skipped',\n            hostId,\n            skipped,\n          }),\n        ),\n    },\n  )\n}\n"],"names":["collectReferencedComponentIds","composeReusableComponentNodes","MAX_COMPONENT_DEPTH","decodeStoredNodes","readStoredComponentTree","stored","ok","reason","deletedAt","nodes","rootId","tree","Array","isArray","props","length","REFERENCED_COMPONENTS_READ_LIMIT","isReadableComponentId","id","includes","test","TextEncoder","encode","warnSkipped","skipped","console","warn","loadReferencedComponents","read","options","maxDepth","maxDocuments","source","definitions","settled","Set","reads","depth","wanted","filter","has","batch","add","push","results","Promise","all","map","outcome","onSkipped","composeReferencedComponents","size","hostComponentReader","firestore","hostId","componentId","snapshot","collection","doc","get","exists","composeHostComponentNodes","context","JSON","stringify","tag"],"mappings":"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"}

package/src/lib/app-utils/reusable-component-kind.d.ts

@@ -0,0 +1,119 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { HostViewType, type ReusableComponentKind } from '../foundation/definitions/platform.types';
+/**
+ * Where a reusable component is placed, and every answer that follows from it
+ * (AGL-3287) — see {@link ReusableComponentKind}.
+ *
+ * One module so the questions are answered from one place: which kind a
+ * promotion makes, which view a component's own editor opens in, which drawer
+ * group offers it, and which starters a new email block can begin from. The
+ * console, the designer and the plugins each ask one of them, and a second
+ * answer to any would let a component be saved as one kind and offered as the
+ * other.
+ */
+/** Placed on pages: what every component made before AGL-3287 is. */
+export declare const REUSABLE_COMPONENT_KIND_SITE: ReusableComponentKind;
+/** Placed in emails: a reusable email block, such as a header or a footer. */
+export declare const REUSABLE_COMPONENT_KIND_EMAIL: ReusableComponentKind;
+/** Every value a component may be stored with. */
+export declare const REUSABLE_COMPONENT_KINDS: readonly ReusableComponentKind[];
+/**
+ * The bundle whose blocks an email's drawer offers (AGL-395).
+ *
+ * The EMAIL view keeps a drawer entry only when the entry's own `pluginId`
+ * names this bundle, and every other view drops such an entry. A reusable
+ * email block is filed under it for exactly that reason — it is the whole of
+ * how one reaches an email's drawer and never a page's.
+ */
+export declare const EMAIL_VIEW_BUNDLE_ID = "email";
+/** Whether a value is one a component may be stored with. */
+export declare function isReusableComponentKind(value: unknown): value is ReusableComponentKind;
+/**
+ * The kind a component document says it is.
+ *
+ * Anything but `email` — absent, `site`, or a value no reader knows — is a
+ * page component, which is what every component was before the field
+ * existed. Reading it any other way would move components nobody touched out
+ * of the drawer their pages use.
+ */
+export declare function reusableComponentKindOf(component: {
+    kind?: unknown;
+} | null | undefined): ReusableComponentKind;
+/**
+ * The kind a component saved from an editor showing this view is: an email
+ * block when it was promoted out of an email, a page component otherwise.
+ *
+ * The view decides because the view decides what the subtree can be made of.
+ * An email's drawer offers email blocks alone, so whatever is promoted there
+ * is built from them — and renders in an email and nowhere else.
+ */
+export declare function reusableComponentKindForView(viewType: unknown): ReusableComponentKind;
+/**
+ * The kind a promoted subtree makes, read from the element being promoted:
+ * an email block when that element is one of the email bundle's.
+ *
+ * For a surface that reads the canvas but cannot see the designer's view — a
+ * plugin's own save action. It agrees with {@link reusableComponentKindForView}
+ * wherever both can be asked, because an email offers email blocks alone and
+ * a page never offers one.
+ */
+export declare function reusableComponentKindForRoot(root: {
+    pluginId?: unknown;
+} | null | undefined): ReusableComponentKind;
+/**
+ * The view a component's own editor opens in.
+ *
+ * An email block edits in the EMAIL view, so its drawer offers what an
+ * email's does and its canvas draws what an email's does. A page component
+ * sets none, which leaves the editor in the screen view it has always used —
+ * deliberately not LAYOUT, whose slot outlet has nowhere to graft inside a
+ * component (AGL-680).
+ */
+export declare function reusableComponentEditorView(kind: ReusableComponentKind): HostViewType | undefined;
+/** Where a component's entry sits in the element drawer. */
+export interface ReusableComponentPaletteSlot {
+    /** The drawer group the entry is listed under. */
+    category: string;
+    /** The bundle the entry is filed under, which the view filter reads. */
+    pluginId?: string;
+}
+/**
+ * The drawer group and bundle a component's entry is registered with.
+ *
+ * An email block is filed under {@link EMAIL_VIEW_BUNDLE_ID}, so the EMAIL
+ * view keeps it and every other view drops it — the rule the email plugin's
+ * own blocks already follow. A page component names no bundle, as it never
+ * has: it belongs to no plugin, so the email view drops it and no plugin
+ * switch on the site can hide it.
+ *
+ * Only the ENTRY is filed this way. The node it inserts is an ordinary
+ * instance, the same on a page and in an email, which is what lets the
+ * canvas draw either through one graft.
+ */
+export declare function reusableComponentPaletteSlot(kind: ReusableComponentKind): ReusableComponentPaletteSlot;
+/** What a new email block can start as on the Components page. */
+export type ReusableEmailBlockStarter = 'header' | 'footer' | 'blank';
+/**
+ * The element presets a Header or a Footer email block starts from, by id.
+ *
+ * Named here and registered by the email plugin, which owns the trees: the
+ * Components page builds its starters from the same presets an author drops
+ * into an email, so each starter is one tree wherever it is started from.
+ * `blank` has no preset — it is the empty canvas every new component opens on.
+ */
+export declare const REUSABLE_EMAIL_BLOCK_STARTER_PRESET_IDS: Readonly<Record<Exclude<ReusableEmailBlockStarter, 'blank'>, string>>;

package/src/lib/app-utils/reusable-component-kind.js

@@ -0,0 +1,119 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ import { REUSABLE_COMPONENT_CATEGORY, REUSABLE_EMAIL_BLOCK_CATEGORY } from "../foundation/constants/components.js";
+import { HostViewType } from "../foundation/definitions/platform.types.js";
+/**
+ * Where a reusable component is placed, and every answer that follows from it
+ * (AGL-3287) — see {@link ReusableComponentKind}.
+ *
+ * One module so the questions are answered from one place: which kind a
+ * promotion makes, which view a component's own editor opens in, which drawer
+ * group offers it, and which starters a new email block can begin from. The
+ * console, the designer and the plugins each ask one of them, and a second
+ * answer to any would let a component be saved as one kind and offered as the
+ * other.
+ */ /** Placed on pages: what every component made before AGL-3287 is. */ export const REUSABLE_COMPONENT_KIND_SITE = 'site';
+/** Placed in emails: a reusable email block, such as a header or a footer. */ export const REUSABLE_COMPONENT_KIND_EMAIL = 'email';
+/** Every value a component may be stored with. */ export const REUSABLE_COMPONENT_KINDS = [
+    REUSABLE_COMPONENT_KIND_SITE,
+    REUSABLE_COMPONENT_KIND_EMAIL
+];
+/**
+ * The bundle whose blocks an email's drawer offers (AGL-395).
+ *
+ * The EMAIL view keeps a drawer entry only when the entry's own `pluginId`
+ * names this bundle, and every other view drops such an entry. A reusable
+ * email block is filed under it for exactly that reason — it is the whole of
+ * how one reaches an email's drawer and never a page's.
+ */ export const EMAIL_VIEW_BUNDLE_ID = 'email';
+/** Whether a value is one a component may be stored with. */ export function isReusableComponentKind(value) {
+    return REUSABLE_COMPONENT_KINDS.includes(value);
+}
+/**
+ * The kind a component document says it is.
+ *
+ * Anything but `email` — absent, `site`, or a value no reader knows — is a
+ * page component, which is what every component was before the field
+ * existed. Reading it any other way would move components nobody touched out
+ * of the drawer their pages use.
+ */ export function reusableComponentKindOf(component) {
+    return (component == null ? void 0 : component.kind) === REUSABLE_COMPONENT_KIND_EMAIL ? REUSABLE_COMPONENT_KIND_EMAIL : REUSABLE_COMPONENT_KIND_SITE;
+}
+/**
+ * The kind a component saved from an editor showing this view is: an email
+ * block when it was promoted out of an email, a page component otherwise.
+ *
+ * The view decides because the view decides what the subtree can be made of.
+ * An email's drawer offers email blocks alone, so whatever is promoted there
+ * is built from them — and renders in an email and nowhere else.
+ */ export function reusableComponentKindForView(viewType) {
+    return viewType === HostViewType.EMAIL ? REUSABLE_COMPONENT_KIND_EMAIL : REUSABLE_COMPONENT_KIND_SITE;
+}
+/**
+ * The kind a promoted subtree makes, read from the element being promoted:
+ * an email block when that element is one of the email bundle's.
+ *
+ * For a surface that reads the canvas but cannot see the designer's view — a
+ * plugin's own save action. It agrees with {@link reusableComponentKindForView}
+ * wherever both can be asked, because an email offers email blocks alone and
+ * a page never offers one.
+ */ export function reusableComponentKindForRoot(root) {
+    return (root == null ? void 0 : root.pluginId) === EMAIL_VIEW_BUNDLE_ID ? REUSABLE_COMPONENT_KIND_EMAIL : REUSABLE_COMPONENT_KIND_SITE;
+}
+/**
+ * The view a component's own editor opens in.
+ *
+ * An email block edits in the EMAIL view, so its drawer offers what an
+ * email's does and its canvas draws what an email's does. A page component
+ * sets none, which leaves the editor in the screen view it has always used —
+ * deliberately not LAYOUT, whose slot outlet has nowhere to graft inside a
+ * component (AGL-680).
+ */ export function reusableComponentEditorView(kind) {
+    return kind === REUSABLE_COMPONENT_KIND_EMAIL ? HostViewType.EMAIL : undefined;
+}
+/**
+ * The drawer group and bundle a component's entry is registered with.
+ *
+ * An email block is filed under {@link EMAIL_VIEW_BUNDLE_ID}, so the EMAIL
+ * view keeps it and every other view drops it — the rule the email plugin's
+ * own blocks already follow. A page component names no bundle, as it never
+ * has: it belongs to no plugin, so the email view drops it and no plugin
+ * switch on the site can hide it.
+ *
+ * Only the ENTRY is filed this way. The node it inserts is an ordinary
+ * instance, the same on a page and in an email, which is what lets the
+ * canvas draw either through one graft.
+ */ export function reusableComponentPaletteSlot(kind) {
+    return kind === REUSABLE_COMPONENT_KIND_EMAIL ? {
+        category: REUSABLE_EMAIL_BLOCK_CATEGORY,
+        pluginId: EMAIL_VIEW_BUNDLE_ID
+    } : {
+        category: REUSABLE_COMPONENT_CATEGORY
+    };
+}
+/**
+ * The element presets a Header or a Footer email block starts from, by id.
+ *
+ * Named here and registered by the email plugin, which owns the trees: the
+ * Components page builds its starters from the same presets an author drops
+ * into an email, so each starter is one tree wherever it is started from.
+ * `blank` has no preset — it is the empty canvas every new component opens on.
+ */ export const REUSABLE_EMAIL_BLOCK_STARTER_PRESET_IDS = {
+    header: 'email:emailSection.header',
+    footer: 'email:emailSection.footer'
+};
+
+//# sourceMappingURL=reusable-component-kind.js.map