@aglyn/plugins-ai 1.0.0-beta.243 → 1.0.0-beta.246

package/src/lib/jobs/ai-site-publish.d.ts

@@ -73,6 +73,22 @@ export interface AiSitePublishDeps {
  * door). Every other build leaves drafts.
  */
 export declare function aiJobPublishesBuild(job: Pick<AiJob, 'kind' | 'inputs'>): boolean;
+/**
+ * The host fields a guided start writes for its plan's language (AGL-3750),
+ * as the Languages card saves one language: `locales` of that one and
+ * `defaultLocale` the same. `null` — nothing written — where the plan said no
+ * valid language, where it is the language the site already publishes in
+ * (English for a new site), and on a site with more than one language, whose
+ * languages are the owner's decision. Nothing is translated: the pages were
+ * written in the brief's language, and this says so to the reader.
+ */
+export declare function aiSiteLanguageUpdates(host: {
+    locales?: unknown;
+    defaultLocale?: unknown;
+}, language: string | null | undefined): {
+    locales: string[];
+    defaultLocale: string;
+} | null;
 /** Whether a finished job of this shape publishes what it built. */
 export declare function aiJobPublishesSite(job: Pick<AiJob, 'kind' | 'inputs'>): boolean;
 /**
@@ -103,10 +119,12 @@ interface NavEntry {
 export declare function aiSiteUnwrittenBlogHrefs(blogUnwritten: boolean | undefined): string[];
 /**
  * The layout's nodes with its links to the retired starter home pointed at
- * the new home, and a link for each proposed entry the header does not
- * already carry, placed in the header's toolbar after its existing links.
- * `null` when nothing changes, or when the layout has no toolbar to hold an
- * entry and no link to repoint.
+ * the new home, its links to pages the start did not write taken out, and a
+ * link for each proposed entry the header does not already carry, added by
+ * the navigation op's `aiLayoutWithMenuChanges` (AGL-3747): to the header's
+ * menu and its phone menu, after their items, or after the brand in a
+ * starter's Toolbar. `null` when nothing changes, or when the layout has no
+ * header to hold an entry and no link to repoint or take out.
  */
 export declare function aiLayoutWithNavigation(nodes: NodesMap, input: {
     entries: readonly NavEntry[];
@@ -115,6 +133,47 @@ export declare function aiLayoutWithNavigation(nodes: NodesMap, input: {
     /** Paths whose links come out: a blog the start linked and never wrote (AGL-3660). */
     droppedHrefs?: readonly string[];
 }): NodesMap | null;
+/** The blog a start writes, as its header entry links it (`aiSiteBlogNavPage`). */
+export interface AiSiteBlogEntry {
+    label: string;
+    href: string;
+}
+/**
+ * The layout's nodes with the blog's header entry put back (AGL-3747): a
+ * start whose posts part failed published with every link to the blog taken
+ * out (AGL-3660), and Try again's posts went live with none to reach them.
+ * Added by the navigation op's `aiLayoutWithMenuChanges`, as the start's
+ * other entries are — the bar's menu and the phone menu — second after the
+ * home page's item, as the start first linked it (AGL-3676), else last.
+ * `null` where some link already opens the blog, or the layout has no header
+ * menu to hold it.
+ */
+export declare function aiLayoutWithBlogEntry(nodes: NodesMap, input: {
+    blog: AiSiteBlogEntry;
+    homeId?: string | null;
+}): NodesMap | null;
+/**
+ * Puts the blog's header entry back on a live start whose posts Try again
+ * wrote (AGL-3747), as a new live version of the layout its published pages
+ * render inside, in one batch with the publish outbox entry that drops the
+ * live site's cached pages, the drop itself attempted at once. Returns
+ * whether the entry went live; never throws for a layout it cannot change.
+ */
+export declare function aiRestoreGuidedBlogEntry(firestore: Firestore, input: {
+    job: Pick<AiJob, '$id' | 'hostId'>;
+    /** The start's published pages: the layout they share is the one changed. */
+    pageIds: readonly string[];
+    /** The published home page, which the blog's entry follows. */
+    homeId?: string | null;
+    blog: AiSiteBlogEntry;
+    now: Date;
+}, deps?: Pick<AiSitePublishDeps, 'dropCache'>): Promise<boolean>;
+/**
+ * A retry's publish merged into the start's first (AGL-3730): the pages it
+ * put live join the published list, a page it published leaves the drafts,
+ * and a page it left a draft is reported with its newest reason.
+ */
+export declare function aiMergeSitePublish(previous: AiJobSitePublish, retried: AiJobSitePublish): AiJobSitePublish;
 /**
  * Publishes the pages a guided site start built. Never throws for a page; a
  * Firestore failure of the publish write itself reports every page as a
@@ -130,5 +189,18 @@ export declare function aiPublishGuidedSite(firestore: Firestore, input: {
     unwrittenHrefs?: readonly string[];
     /** A store's links a build drafted into the site's own layout (AGL-3676), which go live with its pages. */
     storeLinks?: AiSitePublishStoreLinks | null;
+    /**
+     * The start published once already, and Try again rebuilt what failed
+     * (AGL-3730): only `outputs` go live, beside what is. The home address is
+     * never taken from the starter here, the starter is never retired, and
+     * `site_published` is not sent again; a retried page at `/` that the
+     * starter still holds stays a draft and says so.
+     */
+    retry?: boolean;
+    /**
+     * The language the plan says the brief and copy are in (AGL-3750): the
+     * site publishes in it, where `aiSiteLanguageUpdates` says so.
+     */
+    language?: string | null;
 }, deps?: AiSitePublishDeps): Promise<AiJobSitePublish>;
 export {};

package/src/lib/jobs/ai-site-publish.js

@@ -18,12 +18,16 @@ import { _ as _extends } from "@swc/helpers/_/_extends";
 import { createResourceUid } from "@aglyn/aglyn/app-utils/create-resource-uid";
 import { hostPublicOrigin } from "@aglyn/aglyn/app-utils/host-naming";
 import { blockingRouteOwner, normalizeScreenSlug, SCREEN_ROOT_PATH, screenRoutePathToUrl } from "@aglyn/aglyn/app-utils/screen-route";
+import { resolvePageLocale } from "@aglyn/aglyn/app-utils/seo-locale";
 import { decodeStoredNodes, encodeStoredNodes } from "@aglyn/aglyn/app-utils/stored-nodes";
 import { dropPluginSiteCache } from "@aglyn/aglyn/plugin-manager/plugin-site-cache";
 import { sendGa4SitePublished } from "@aglyn/tenant-data-admin/server/ga4-measurement-protocol";
 import { FieldValue } from "firebase-admin/firestore";
+import { aiLayoutFrameHollows, aiLayoutFrameHollowsSaid, aiLayoutFrameIsHollow, aiLayoutRepairFrameHollows, aiLayoutWithoutFrameHollows } from "../layout-language/ai-layout-frame-hollows.js";
+import { aiPlanLanguage } from "../model/ai-build-plan.js";
 import { AI_SITE_BLOG_SLUGS } from "../model/ai-site-job.js";
 import { aiLayoutWithStoreLinks } from "../model/ai-layout-store-links.js";
+import { aiLayoutWithMenuChanges, aiNoMenuChanges } from "../model/ai-layout-menus.js";
 import { AI_STORE_LINKS_SOURCE_FIELD as STORE_LINKS_SOURCE_FIELD } from "./ai-job-store-links-layout.js";
 /**
  * Whether a build puts its pages live (AGL-3616): only where its request
@@ -34,6 +38,34 @@ import { AI_STORE_LINKS_SOURCE_FIELD as STORE_LINKS_SOURCE_FIELD } from "./ai-jo
     var _job_inputs, _job_inputs1;
     return job.kind === 'build' && ((_job_inputs = job.inputs) == null ? void 0 : _job_inputs['publish']) === true && ((_job_inputs1 = job.inputs) == null ? void 0 : _job_inputs1['publishConfirmed']) === true;
 }
+/**
+ * The host fields a guided start writes for its plan's language (AGL-3750),
+ * as the Languages card saves one language: `locales` of that one and
+ * `defaultLocale` the same. `null` — nothing written — where the plan said no
+ * valid language, where it is the language the site already publishes in
+ * (English for a new site), and on a site with more than one language, whose
+ * languages are the owner's decision. Nothing is translated: the pages were
+ * written in the brief's language, and this says so to the reader.
+ */ export function aiSiteLanguageUpdates(host, language) {
+    const code = aiPlanLanguage(language);
+    if (!code) return null;
+    const locales = Array.isArray(host.locales) ? host.locales.filter((one)=>typeof one === 'string' && one.trim() !== '') : [];
+    if (locales.length > 1) return null;
+    const current = resolvePageLocale({
+        host: _extends({}, typeof host.defaultLocale === 'string' ? {
+            defaultLocale: host.defaultLocale
+        } : {}, {
+            locales
+        })
+    });
+    if (current === code) return null;
+    return {
+        locales: [
+            code
+        ],
+        defaultLocale: code
+    };
+}
 /** Whether a finished job of this shape publishes what it built. */ export function aiJobPublishesSite(job) {
     var _job_inputs;
     return job.kind === 'site' && ((_job_inputs = job.inputs) == null ? void 0 : _job_inputs['autoConfirm']) === true;
@@ -80,10 +112,12 @@ function navEntriesOf(outputs) {
 }
 /**
  * The layout's nodes with its links to the retired starter home pointed at
- * the new home, and a link for each proposed entry the header does not
- * already carry, placed in the header's toolbar after its existing links.
- * `null` when nothing changes, or when the layout has no toolbar to hold an
- * entry and no link to repoint.
+ * the new home, its links to pages the start did not write taken out, and a
+ * link for each proposed entry the header does not already carry, added by
+ * the navigation op's `aiLayoutWithMenuChanges` (AGL-3747): to the header's
+ * menu and its phone menu, after their items, or after the brand in a
+ * starter's Toolbar. `null` when nothing changes, or when the layout has no
+ * header to hold an entry and no link to repoint or take out.
  */ export function aiLayoutWithNavigation(nodes, input) {
     var _input_droppedHrefs;
     const map = {};
@@ -113,6 +147,9 @@ function navEntriesOf(outputs) {
                 var _node_nodes;
                 if ((_node_nodes = node.nodes) == null ? void 0 : _node_nodes.some((child)=>gone.has(child))) node.nodes = node.nodes.filter((child)=>!gone.has(child));
             }
+            // A footer heading whose links all went goes with them, and its column
+            // when that leaves it only the heading (AGL-3735).
+            aiLayoutRepairFrameHollows(map);
             changed = true;
         }
     }
@@ -128,51 +165,162 @@ function navEntriesOf(outputs) {
             }
         }
     }
+    // The entries go into the header through the navigation op's own code
+    // (AGL-3747): the bar's menu and the phone menu's, after the items already
+    // there, each looking like its neighbours. A page some link already opens,
+    // or an item of the same name, is not added again.
     const linked = new Set(links.map((link)=>{
         var _link_props;
         return (_link_props = link.props) == null ? void 0 : _link_props['screenId'];
     }).filter(Boolean));
-    const toolbar = Object.values(map).find((node)=>node.componentId === 'muiToolbar');
     const missing = input.entries.filter((entry)=>!linked.has(entry.screenId));
-    if (toolbar && missing.length) {
-        var _toolbar_nodes;
-        const children = (_toolbar_nodes = toolbar.nodes) != null ? _toolbar_nodes : [];
-        // After the last link already in the toolbar (the brand), before the
-        // search, the mode switch and the call to action.
-        const lastLink = children.reduce((at, id, index)=>{
-            var _map_id;
-            return ((_map_id = map[id]) == null ? void 0 : _map_id.componentId) === 'muiScreenLink' ? index : at;
-        }, -1);
-        const added = missing.map((entry)=>{
-            const id = `ai_nav_${createResourceUid()}`;
-            map[id] = {
-                $id: id,
-                componentId: 'muiScreenLink',
-                pluginId: 'mui',
-                parentId: toolbar.$id,
-                props: {
-                    children: entry.label,
-                    screenId: entry.screenId,
-                    renderAs: 'link',
-                    color: 'inherit'
-                },
-                sx: {
-                    textDecoration: 'none',
-                    whiteSpace: 'nowrap'
-                },
-                nodes: []
-            };
-            return id;
+    if (missing.length) {
+        const added = aiLayoutWithMenuChanges(map, [
+            'header'
+        ], _extends({}, aiNoMenuChanges(), {
+            add: missing.map((entry)=>({
+                    parent: null,
+                    label: entry.label,
+                    to: {
+                        screenId: entry.screenId
+                    }
+                }))
+        }), {
+            newId: ()=>`ai_nav_${createResourceUid()}`
         });
-        toolbar.nodes = [
-            ...children.slice(0, lastLink + 1),
-            ...added,
-            ...children.slice(lastLink + 1)
-        ];
-        changed = true;
+        if (added.nodes) return added.nodes;
     }
     return changed ? map : null;
 }
+/**
+ * The layout's nodes with the blog's header entry put back (AGL-3747): a
+ * start whose posts part failed published with every link to the blog taken
+ * out (AGL-3660), and Try again's posts went live with none to reach them.
+ * Added by the navigation op's `aiLayoutWithMenuChanges`, as the start's
+ * other entries are — the bar's menu and the phone menu — second after the
+ * home page's item, as the start first linked it (AGL-3676), else last.
+ * `null` where some link already opens the blog, or the layout has no header
+ * menu to hold it.
+ */ export function aiLayoutWithBlogEntry(nodes, input) {
+    var _added_nodes;
+    const blogHrefs = new Set([
+        input.blog.href,
+        ...AI_SITE_BLOG_SLUGS.map((slug)=>`/${slug}`)
+    ]);
+    const linked = Object.values(nodes).some((node)=>{
+        var _ref;
+        var _node_props;
+        return (node == null ? void 0 : node.componentId) === 'muiScreenLink' && blogHrefs.has(String((_ref = (_node_props = node.props) == null ? void 0 : _node_props['href']) != null ? _ref : ''));
+    });
+    if (linked) return null;
+    const home = [
+        ...input.homeId ? [
+            {
+                screenId: input.homeId
+            }
+        ] : [],
+        {
+            href: '/'
+        }
+    ];
+    const added = aiLayoutWithMenuChanges(nodes, [
+        'header'
+    ], _extends({}, aiNoMenuChanges(), {
+        add: [
+            {
+                parent: null,
+                label: input.blog.label,
+                to: {
+                    href: input.blog.href
+                },
+                after: home
+            }
+        ]
+    }), {
+        newId: ()=>`ai_nav_${createResourceUid()}`
+    });
+    return (_added_nodes = added.nodes) != null ? _added_nodes : null;
+}
+/**
+ * Puts the blog's header entry back on a live start whose posts Try again
+ * wrote (AGL-3747), as a new live version of the layout its published pages
+ * render inside, in one batch with the publish outbox entry that drops the
+ * live site's cached pages, the drop itself attempted at once. Returns
+ * whether the entry went live; never throws for a layout it cannot change.
+ */ export async function aiRestoreGuidedBlogEntry(firestore, input, deps = {}) {
+    var _deps_dropCache, _input_job_hostId;
+    const dropCache = (_deps_dropCache = deps.dropCache) != null ? _deps_dropCache : dropPluginSiteCache;
+    const hostId = (_input_job_hostId = input.job.hostId) != null ? _input_job_hostId : '';
+    if (!hostId || !input.pageIds.length) return false;
+    const layoutId = await aiPagesLayoutId(firestore, hostId, input.pageIds);
+    if (!layoutId) return false;
+    const write = await aiLayoutVersionWrite(firestore, {
+        hostId,
+        layoutId,
+        transform: (nodes)=>{
+            var _input_homeId;
+            return aiLayoutWithBlogEntry(nodes, {
+                blog: input.blog,
+                homeId: (_input_homeId = input.homeId) != null ? _input_homeId : null
+            });
+        },
+        storeLinks: null,
+        jobId: input.job.$id,
+        now: input.now,
+        displayName: 'Navigation for the blog'
+    });
+    if (!(write == null ? void 0 : write.version)) return false;
+    const batch = firestore.batch();
+    batch.create(write.versionRef, write.version);
+    batch.set(write.layoutRef, {
+        versionId: write.versionRef.id,
+        updatedAt: input.now
+    }, {
+        merge: true
+    });
+    // A layout change reaches every page, so the announce asks for the whole site.
+    const outboxRef = firestore.collection('publishOutbox').doc(createResourceUid());
+    batch.set(outboxRef, {
+        hostId,
+        paths: [
+            SCREEN_ROOT_PATH
+        ],
+        createdAt: FieldValue.serverTimestamp(),
+        attempts: 0,
+        entireHost: true
+    });
+    await batch.commit();
+    const dropped = await dropCache({
+        hostIds: [
+            hostId
+        ],
+        reason: 'guided AI site start linked its blog'
+    });
+    if (dropped.complete) await outboxRef.delete().catch(()=>undefined);
+    return true;
+}
+/**
+ * A retry's publish merged into the start's first (AGL-3730): the pages it
+ * put live join the published list, a page it published leaves the drafts,
+ * and a page it left a draft is reported with its newest reason.
+ */ export function aiMergeSitePublish(previous, retried) {
+    var _retried_liveUrl;
+    const now = new Set([
+        ...retried.published,
+        ...retried.drafts
+    ].map((page)=>page.id));
+    return {
+        liveUrl: (_retried_liveUrl = retried.liveUrl) != null ? _retried_liveUrl : previous.liveUrl,
+        published: [
+            ...previous.published.filter((page)=>!now.has(page.id)),
+            ...retried.published
+        ],
+        drafts: [
+            ...previous.drafts.filter((page)=>!now.has(page.id)),
+            ...retried.drafts
+        ]
+    };
+}
 /**
  * Publishes the pages a guided site start built. Never throws for a page; a
  * Firestore failure of the publish write itself reports every page as a
@@ -199,7 +347,9 @@ function navEntriesOf(outputs) {
     };
     if (!host.exists || !pages.length) return result;
     const before = _extends({}, (_host_get = host.get('screens')) != null ? _host_get : {});
-    const placeholder = host.get('defaultHomeScreenId') || null;
+    const starter = host.get('defaultHomeScreenId') || null;
+    // A retry never takes `/` from the starter (AGL-3730): it holds it like any page.
+    const placeholder = input.retry ? null : starter;
     const routing = _extends({}, before);
     const entries = {};
     const accepted = [];
@@ -318,6 +468,14 @@ function navEntriesOf(outputs) {
     } else if (placeholder && entries[placeholder]) {
         hostUpdates['defaultHomeScreenId'] = FieldValue.delete();
     }
+    // The site's language, from its plan (AGL-3750): every page's `<html lang>`
+    // reads it, so the announce below asks for the whole site.
+    const language = aiSiteLanguageUpdates({
+        locales: host.get('locales'),
+        defaultLocale: host.get('defaultLocale')
+    }, input.language);
+    if (language) Object.assign(hostUpdates, language);
+    const entireHost = layoutWrites.length > 0 || language !== null;
     batch.update(hostRef, hostUpdates);
     for (const page of accepted){
         batch.set(hostRef.collection('screens').doc(page.id), {
@@ -346,7 +504,7 @@ function navEntriesOf(outputs) {
         ],
         createdAt: FieldValue.serverTimestamp(),
         attempts: 0
-    }, layoutWrites.length ? {
+    }, entireHost ? {
         entireHost: true
     } : {}));
     try {
@@ -376,14 +534,15 @@ function navEntriesOf(outputs) {
             hostId
         ],
         reason: 'guided AI site start published'
-    }, layoutWrites.length ? {} : {
+    }, entireHost ? {} : {
         paths: {
             [hostId]: paths
         }
     }));
     if (dropped.complete) await outboxRef.delete().catch(()=>undefined);
-    // A site that came alive with nobody's browser on the publish (AGL-1589).
-    await sendSitePublished({
+    // A site that came alive with nobody's browser on the publish (AGL-1589),
+    // announced once: a retry's pages join a site already announced (AGL-3730).
+    if (!input.retry) await sendSitePublished({
         hostId,
         firstPublish: isFirstPublishedRoute(before, placeholder)
     });
@@ -396,9 +555,21 @@ function navEntriesOf(outputs) {
  */ async function aiNavigationLayoutWrite(firestore, input) {
     var _input_storeLinks;
     if (!input.entries.length && !input.retiredHomeId && !input.droppedHrefs.length && !input.storeLinks) return null;
-    const hostRef = firestore.collection('hosts').doc(input.hostId);
+    const layoutId = await aiPagesLayoutId(firestore, input.hostId, input.pageIds);
+    if (!layoutId) return null;
+    return aiLayoutVersionWrite(firestore, {
+        hostId: input.hostId,
+        layoutId,
+        transform: (nodes)=>aiLayoutWithNavigation(nodes, input),
+        storeLinks: (_input_storeLinks = input.storeLinks) != null ? _input_storeLinks : null,
+        jobId: input.jobId,
+        now: input.now
+    });
+}
+/** The one layout the pages render inside, by their current versions; `null` where they do not share one. */ async function aiPagesLayoutId(firestore, hostId, pageIds) {
+    const hostRef = firestore.collection('hosts').doc(hostId);
     const layoutIds = new Set();
-    for (const id of input.pageIds){
+    for (const id of pageIds){
         var _ref;
         const screen = await hostRef.collection('screens').doc(id).get();
         const versionId = screen.get('versionId');
@@ -406,18 +577,9 @@ function navEntriesOf(outputs) {
         const layoutId = (_ref = version == null ? void 0 : version.get('layoutId')) != null ? _ref : screen.get('layoutId');
         if (typeof layoutId === 'string' && layoutId) layoutIds.add(layoutId);
     }
-    if (layoutIds.size !== 1) return null;
-    const [layoutId] = [
+    return layoutIds.size === 1 ? [
         ...layoutIds
-    ];
-    return aiLayoutVersionWrite(firestore, {
-        hostId: input.hostId,
-        layoutId,
-        transform: (nodes)=>aiLayoutWithNavigation(nodes, input),
-        storeLinks: (_input_storeLinks = input.storeLinks) != null ? _input_storeLinks : null,
-        jobId: input.jobId,
-        now: input.now
-    });
+    ][0] : null;
 }
 /**
  * The new live version of one layout: `transform` applied to the version
@@ -426,6 +588,7 @@ function navEntriesOf(outputs) {
  * to the live version otherwise; a draft with nothing more to add becomes
  * the live version as it is. `null` when nothing changes.
  */ async function aiLayoutVersionWrite(firestore, input) {
+    var _aiLayoutWithoutFrameHollows, _input_displayName;
     var _input_storeLinks;
     const { layoutId } = input;
     const layoutRef = firestore.collection('hosts').doc(input.hostId).collection('layouts').doc(layoutId);
@@ -446,6 +609,15 @@ function navEntriesOf(outputs) {
         const added = aiLayoutWithStoreLinks(next != null ? next : nodes, links.links, links.screenPaths);
         next = (_added_nodes = added.nodes) != null ? _added_nodes : next;
     }
+    // What a publish puts live has no hollow heading, column or menu (AGL-3735).
+    next = (_aiLayoutWithoutFrameHollows = aiLayoutWithoutFrameHollows(next != null ? next : nodes)) != null ? _aiLayoutWithoutFrameHollows : next;
+    const hollow = aiLayoutFrameHollows(next != null ? next : nodes);
+    if (aiLayoutFrameIsHollow(hollow)) {
+        console.error('ai site publish: a layout is still hollow after its repair', {
+            layoutId,
+            hollow: aiLayoutFrameHollowsSaid(hollow)
+        });
+    }
     if (!next) return fromDraft && draftRef ? {
         layoutRef,
         versionRef: draftRef,
@@ -460,7 +632,7 @@ function navEntriesOf(outputs) {
         version: {
             layoutId,
             hostId: input.hostId,
-            displayName: 'Navigation for the new pages',
+            displayName: (_input_displayName = input.displayName) != null ? _input_displayName : 'Navigation for the new pages',
             nodes: Buffer.from(packed),
             createdAt: input.now,
             updatedAt: input.now,