@aglyn/plugins-ai 1.0.0-beta.230 → 1.0.0-beta.232

package/src/lib/jobs/ai-job-site-content.d.ts

@@ -0,0 +1,163 @@
+/**
+ * @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 { pluginResourceDraftWriter } from '@aglyn/aglyn/plugin-manager/plugin-resource-drafts';
+import { publishContentEntries, writeContentCollection, writeContentEntryDraft } from '@aglyn/tenant-data-admin/server/content-entry-drafts';
+import type { AiJob, AiJobOutput } from '../model/ai-jobs.types';
+import { generateAiBlogPost } from '../runtime/ai-blog-post-generation';
+import { aiJobAdmissionFor } from './ai-job-admission';
+import type { AiJobStepContext, AiJobStepRunner } from './ai-job-text-step';
+/**
+ * A GUIDED START'S FIRST POSTS AND FIRST PRODUCTS (AGL-3676).
+ *
+ * A site of the kind "Blog & writing" or "Online store" got the right look
+ * and pages, and nothing real in them: the writing page's cards and the
+ * shop's grid named posts and products nobody had written. On a paid plan,
+ * the scaffold now builds one more part for those two kinds, before the
+ * pages, each its own row with its own timer and credits:
+ *
+ *  - WRITING YOUR FIRST POSTS: a content collection "Blog" — the platform's
+ *    own blog, served at `/{slug}` with an entry page per post — and
+ *    `AI_SITE_POSTS` posts in it, one generation a pass. Each is written as a
+ *    draft through the same rules the console's routes hold
+ *    (`content-entry-drafts.ts`), bylined with the business's name the person
+ *    gave, and given a starter photo as its cover. They go live with the
+ *    site: the guided start's publish publishes them with its pages
+ *    (`aiPublishSitePosts`), as a person's Publish would.
+ *  - ADDING YOUR FIRST PRODUCTS: the `products` step's catalog, asked for
+ *    `AI_SITE_PRODUCTS` products, each written through the commerce plugin's
+ *    `product` draft writer — a DRAFT with no price, off the storefront until
+ *    the owner prices it, since no price is ever invented. No photo either:
+ *    the writer takes none, and a stock picture of something else would show
+ *    a shopper a product that is not the one for sale.
+ *
+ * The pages built after them are told their titles or names, so the writing
+ * page and the shop feature what exists rather than inventing their own.
+ *
+ * ── Not on the Free taste ────────────────────────────────────────────────
+ *
+ * A Free site's sections cap is DERIVED to spend the whole taste less one
+ * retried section (`aiFreeSiteSectionsWithin`), so there is no slack a post
+ * could use without taking a section away; and a Free plan includes neither
+ * the `commerce` feature nor a product (`productsPerHost` is 0).
+ * `ai-job-free-site.spec.ts` shows the arithmetic. Free sites keep the pages
+ * their kind already describes; the owner adds posts and products after.
+ */
+/** How many first posts a paid blog gets. */
+export declare const AI_SITE_POSTS = 3;
+/** How many first products a paid store gets: asked for, and the most written. */
+export declare const AI_SITE_PRODUCTS: {
+    readonly min: 3;
+    readonly max: 6;
+};
+/** What each part's row reads. */
+export declare const AI_SITE_POSTS_LABEL = "Writing your first posts";
+export declare const AI_SITE_PRODUCTS_LABEL = "Adding your first products";
+/** The blog the posts go in, and the addresses it may answer at, in order of preference. */
+export declare const AI_SITE_BLOG_NAME = "Blog";
+export declare const AI_SITE_BLOG_SLUGS: readonly ["blog", "posts", "journal", "articles", "writing", "stories"];
+/** The input a site unit's own job carries what the part needs in. */
+export declare const AI_SITE_CONTENT_INPUT = "siteContent";
+/** Which part a site of these answers gets; `null` for the Free taste and every other kind. */
+export declare function aiSiteContentPart(inputs: Readonly<Record<string, unknown>> | null | undefined, freeTaste: boolean): 'posts' | 'products' | null;
+/**
+ * ASSUMED: what one post pass reads and writes beside its generation: the
+ * host, the collection's slug claim and the entry's transaction.
+ */
+export declare const AI_SITE_POST_WRITES_MS = 1500;
+/** One post's pass: its generation and re-ask at the `copy.blog` ceiling, and its writes. */
+export declare const AI_SITE_POST_BUDGET: import("./ai-job-budget").AiJobStepBudget;
+/** What a posts unit's job is told: the posts already written and the addresses the blog must not take. */
+export interface AiSitePostsInput {
+    written: Array<{
+        id: string;
+        title: string;
+    }>;
+    total: number;
+    /** Addresses the site's own pages answer at, which the blog must not shadow. */
+    avoidSlugs: string[];
+    /** Who the posts are by: the business's name as given, else empty. */
+    byline: string;
+}
+/** What a products unit's job is told. */
+export interface AiSiteProductsInput {
+    min: number;
+    max: number;
+}
+/** The id of the `index`th post, of the blog its unit writes under `unitJobId`. */
+export declare function aiSitePostId(unitJobId: string, index: number): string;
+/** The id of the `index`th product a products unit writes. */
+export declare function aiSiteProductId(unitJobId: string, index: number): string;
+export interface AiSitePostsRunnerDeps {
+    generate?: typeof generateAiBlogPost;
+    writeCollection?: typeof writeContentCollection;
+    writeEntry?: typeof writeContentEntryDraft;
+}
+/**
+ * The posts unit's runner, on the job the scaffold derived for it: one post a
+ * pass, continuing while posts remain. Its first pass makes the blog; every
+ * pass finds it again under the unit's own id, and a post under its own id,
+ * so a pass repeated after its write reports the post it already wrote.
+ */
+export declare function createAiSitePostsRunner(deps?: AiSitePostsRunnerDeps): AiJobStepRunner;
+export declare const runAiSitePostsUnit: AiJobStepRunner;
+export interface AiSiteProductsRunnerDeps {
+    /** The catalog's runner: the `products` step's. */
+    catalog: AiJobStepRunner;
+    writerFor?: typeof pluginResourceDraftWriter;
+}
+/** The sentence the products unit's brief ends with, which the catalog's rules read as how many. */
+export declare function aiSiteProductsBriefLine(input?: AiSiteProductsInput): string;
+/**
+ * The products unit's runner: the `products` step's catalog for the store's
+ * brief, then each proposed product, up to the most a site starts with,
+ * written as an unpriced draft by the plugin that keeps products. A product
+ * past the plan's allowance stops the writing there, and the row says how
+ * many were added; none at all is the allowance's review.
+ */
+export declare function createAiSiteProductsRunner(deps: AiSiteProductsRunnerDeps): AiJobStepRunner;
+/**
+ * Whether a part may be built for this member on this site, asked before its
+ * first pass so a refusal spends nothing; `null` admits. Products ask what a
+ * `products` job asks (the plan's commerce feature, Commerce on and released
+ * for the site) and the writer's own refusal (role, allowance); posts ask
+ * that the member may write the site's content.
+ */
+export declare function aiSiteContentRefusal(part: 'posts' | 'products', context: Pick<AiJobStepContext, 'firestore' | 'org' | 'now'> & {
+    job: Pick<AiJob, 'orgId' | 'hostId' | 'createdBy' | 'inputs'>;
+}, deps?: {
+    writerFor?: typeof pluginResourceDraftWriter;
+    admissionFor?: typeof aiJobAdmissionFor;
+}): Promise<string | null>;
+/** The guided start's posts, published with its pages (AGL-3676). */
+export interface AiSitePostsPublish {
+    published: number;
+    kept: number;
+    /** The blog's own addresses, for the publish's cache drop. */
+    paths: string[];
+}
+/**
+ * Publishes the posts a guided start wrote, as the entry editor's Publish
+ * does, once its pages are live. Never throws: a post that stays a draft is
+ * the owner's to publish from Content.
+ */
+export declare function aiPublishSitePosts(firestore: FirebaseFirestore.Firestore, input: {
+    job: Pick<AiJob, '$id' | 'orgId' | 'hostId' | 'createdBy'>;
+    outputs: readonly AiJobOutput[];
+    now: Date;
+}, publish?: typeof publishContentEntries): Promise<AiSitePostsPublish | null>;
+/** What a page of a blog or a store is told about the posts or products built before it. */
+export declare function aiSiteContentBriefLines(outputs: readonly AiJobOutput[]): string[];

package/src/lib/jobs/ai-job-site-content.js

@@ -0,0 +1,443 @@
+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.
+ */ import { hostRoleCanWrite } from "@aglyn/aglyn/app-utils/organizations";
+import { pluginResourceDraftWriter } from "@aglyn/aglyn/plugin-manager/plugin-resource-drafts";
+import { publishContentEntries, writeContentCollection, writeContentEntryDraft } from "@aglyn/tenant-data-admin/server/content-entry-drafts";
+import { aiProductsProposalOf } from "../model/ai-products.js";
+import { aiSiteKindOfInputs } from "../model/ai-site-kinds.js";
+import { AI_STEP_TIERS } from "../providers/catalog.js";
+import { aiModelForStep } from "../providers/routing.js";
+import { AI_BLOG_POST_MAX_TOKENS, AI_BLOG_POST_STEP, generateAiBlogPost } from "../runtime/ai-blog-post-generation.js";
+import { aiLayoutStarterPhotos } from "../layout-language/ai-layout-pictures.js";
+import { aiJobAdmissionFor } from "./ai-job-admission.js";
+import { aiJobStepBudget } from "./ai-job-budget.js";
+import { aiGenerationSpent, aiUnspentOutcome } from "./ai-job-generation.js";
+/**
+ * A GUIDED START'S FIRST POSTS AND FIRST PRODUCTS (AGL-3676).
+ *
+ * A site of the kind "Blog & writing" or "Online store" got the right look
+ * and pages, and nothing real in them: the writing page's cards and the
+ * shop's grid named posts and products nobody had written. On a paid plan,
+ * the scaffold now builds one more part for those two kinds, before the
+ * pages, each its own row with its own timer and credits:
+ *
+ *  - WRITING YOUR FIRST POSTS: a content collection "Blog" — the platform's
+ *    own blog, served at `/{slug}` with an entry page per post — and
+ *    `AI_SITE_POSTS` posts in it, one generation a pass. Each is written as a
+ *    draft through the same rules the console's routes hold
+ *    (`content-entry-drafts.ts`), bylined with the business's name the person
+ *    gave, and given a starter photo as its cover. They go live with the
+ *    site: the guided start's publish publishes them with its pages
+ *    (`aiPublishSitePosts`), as a person's Publish would.
+ *  - ADDING YOUR FIRST PRODUCTS: the `products` step's catalog, asked for
+ *    `AI_SITE_PRODUCTS` products, each written through the commerce plugin's
+ *    `product` draft writer — a DRAFT with no price, off the storefront until
+ *    the owner prices it, since no price is ever invented. No photo either:
+ *    the writer takes none, and a stock picture of something else would show
+ *    a shopper a product that is not the one for sale.
+ *
+ * The pages built after them are told their titles or names, so the writing
+ * page and the shop feature what exists rather than inventing their own.
+ *
+ * ── Not on the Free taste ────────────────────────────────────────────────
+ *
+ * A Free site's sections cap is DERIVED to spend the whole taste less one
+ * retried section (`aiFreeSiteSectionsWithin`), so there is no slack a post
+ * could use without taking a section away; and a Free plan includes neither
+ * the `commerce` feature nor a product (`productsPerHost` is 0).
+ * `ai-job-free-site.spec.ts` shows the arithmetic. Free sites keep the pages
+ * their kind already describes; the owner adds posts and products after.
+ */ /** How many first posts a paid blog gets. */ export const AI_SITE_POSTS = 3;
+/** How many first products a paid store gets: asked for, and the most written. */ export const AI_SITE_PRODUCTS = {
+    min: 3,
+    max: 6
+};
+/** What each part's row reads. */ export const AI_SITE_POSTS_LABEL = 'Writing your first posts';
+export const AI_SITE_PRODUCTS_LABEL = 'Adding your first products';
+/** The blog the posts go in, and the addresses it may answer at, in order of preference. */ export const AI_SITE_BLOG_NAME = 'Blog';
+export const AI_SITE_BLOG_SLUGS = [
+    'blog',
+    'posts',
+    'journal',
+    'articles',
+    'writing',
+    'stories'
+];
+/** The input a site unit's own job carries what the part needs in. */ export const AI_SITE_CONTENT_INPUT = 'siteContent';
+/** Which part a site of these answers gets; `null` for the Free taste and every other kind. */ export function aiSiteContentPart(inputs, freeTaste) {
+    var _aiSiteKindOfInputs;
+    if (freeTaste) return null;
+    const kind = (_aiSiteKindOfInputs = aiSiteKindOfInputs(inputs)) == null ? void 0 : _aiSiteKindOfInputs.id;
+    if (kind === 'blog') return 'posts';
+    if (kind === 'store') return 'products';
+    return null;
+}
+/**
+ * ASSUMED: what one post pass reads and writes beside its generation: the
+ * host, the collection's slug claim and the entry's transaction.
+ */ export const AI_SITE_POST_WRITES_MS = 1500;
+/** One post's pass: its generation and re-ask at the `copy.blog` ceiling, and its writes. */ export const AI_SITE_POST_BUDGET = aiJobStepBudget({
+    tier: AI_STEP_TIERS[AI_BLOG_POST_STEP],
+    maxTokens: AI_BLOG_POST_MAX_TOKENS,
+    lookups: 0,
+    ownReadsMs: AI_SITE_POST_WRITES_MS
+});
+const str = (value)=>typeof value === 'string' ? value.trim() : '';
+function postsInputOf(job) {
+    var _ref;
+    var _job_inputs;
+    const raw = (_ref = (_job_inputs = job.inputs) == null ? void 0 : _job_inputs[AI_SITE_CONTENT_INPUT]) != null ? _ref : {};
+    return {
+        written: Array.isArray(raw.written) ? raw.written.filter((one)=>one && typeof one.id === 'string') : [],
+        total: typeof raw.total === 'number' && raw.total > 0 ? Math.floor(raw.total) : AI_SITE_POSTS,
+        avoidSlugs: Array.isArray(raw.avoidSlugs) ? raw.avoidSlugs.map(str).filter(Boolean) : [],
+        byline: str(raw.byline)
+    };
+}
+/** The id of the `index`th post, of the blog its unit writes under `unitJobId`. */ export function aiSitePostId(unitJobId, index) {
+    return `${unitJobId}-${index}`;
+}
+/** The id of the `index`th product a products unit writes. */ export function aiSiteProductId(unitJobId, index) {
+    return `${unitJobId}-${index}`;
+}
+/** A site's subdomain and name, as its outputs and its posts' byline read them. */ async function readSite(firestore, hostId) {
+    var _host_get;
+    const host = await firestore.collection('hosts').doc(hostId).get();
+    if (!host.exists) return null;
+    const seo = (_host_get = host.get('seo')) != null ? _host_get : {};
+    const subdomain = str(host.get('subdomain')) || null;
+    return {
+        subdomain,
+        name: str(host.get('displayName')) || str(seo['title'])
+    };
+}
+const limitReview = (message)=>({
+        reason: 'limit',
+        message,
+        findings: []
+    });
+/**
+ * The posts unit's runner, on the job the scaffold derived for it: one post a
+ * pass, continuing while posts remain. Its first pass makes the blog; every
+ * pass finds it again under the unit's own id, and a post under its own id,
+ * so a pass repeated after its write reports the post it already wrote.
+ */ export function createAiSitePostsRunner(deps = {}) {
+    var _deps_generate, _deps_writeCollection, _deps_writeEntry;
+    const generate = (_deps_generate = deps.generate) != null ? _deps_generate : generateAiBlogPost;
+    const writeCollection = (_deps_writeCollection = deps.writeCollection) != null ? _deps_writeCollection : writeContentCollection;
+    const writeEntry = (_deps_writeEntry = deps.writeEntry) != null ? _deps_writeEntry : writeContentEntryDraft;
+    return async (context)=>{
+        var _ref;
+        var _covers_index;
+        const { job, firestore, signal } = context;
+        const model = (_ref = context.modelFor == null ? void 0 : context.modelFor.call(context, AI_BLOG_POST_STEP)) != null ? _ref : aiModelForStep(AI_BLOG_POST_STEP);
+        if (!job.hostId) return _extends({}, aiUnspentOutcome(model), {
+            failure: 'Open the site before writing its posts.'
+        });
+        const input = postsInputOf(job);
+        const index = input.written.length;
+        if (index >= input.total) return aiUnspentOutcome(model);
+        const site = await readSite(firestore, job.hostId);
+        if (!site) return _extends({}, aiUnspentOutcome(model), {
+            failure: 'This site no longer exists.'
+        });
+        const avoid = new Set(input.avoidSlugs.map((slug)=>slug.toLowerCase()));
+        const blog = await writeCollection(firestore, {
+            hostId: job.hostId,
+            uid: job.createdBy,
+            id: job.$id,
+            displayName: AI_SITE_BLOG_NAME,
+            slugs: AI_SITE_BLOG_SLUGS.filter((slug)=>!avoid.has(slug)),
+            now: context.now
+        });
+        if (blog.ok === false) return aiUnspentOutcome(model, {
+            review: limitReview(blog.error)
+        });
+        const generation = await generate(_extends({
+            brief: job.brief,
+            merchantWords: job.brief,
+            earlierTitles: input.written.map((post)=>post.title),
+            index: index + 1,
+            total: input.total,
+            model,
+            maxTokens: AI_SITE_POST_BUDGET.maxTokens(model)
+        }, signal ? {
+            signal
+        } : {}));
+        const spent = aiGenerationSpent(generation);
+        if (generation.status === 'refused') return _extends({}, spent, {
+            refused: true
+        });
+        if (generation.status === 'needs_input') return _extends({}, spent, {
+            failure: generation.message
+        });
+        const post = generation.value;
+        // A starter photo as its cover, turned by the job so blogs differ.
+        const covers = aiLayoutStarterPhotos(Array.from({
+            length: input.total
+        }, (_, slot)=>({
+                imageId: `cover${slot}`,
+                frameId: null,
+                iconId: null,
+                alt: '',
+                aspect: 16 / 9,
+                sectionIndex: slot + 1,
+                role: 'gallery'
+            })), job.$id);
+        const byline = input.byline || site.name;
+        const written = await writeEntry(firestore, {
+            hostId: job.hostId,
+            collectionId: blog.id,
+            uid: job.createdBy,
+            id: aiSitePostId(job.$id, index),
+            content: _extends({
+                title: post.title,
+                excerpt: post.excerpt,
+                body: post.body,
+                seoDescription: post.seoDescription,
+                coverImage: (_covers_index = covers[index]) == null ? void 0 : _covers_index.src
+            }, byline ? {
+                authorName: byline
+            } : {}),
+            now: context.now
+        });
+        if (written.ok === false) return _extends({}, spent, {
+            review: limitReview(written.error)
+        });
+        const output = {
+            resource: 'entry',
+            id: written.id,
+            hostId: job.hostId,
+            hostSubdomain: site.subdomain,
+            label: written.title,
+            note: `A post in ${blog.displayName}, at /${blog.slug}/${written.slug}. It goes live with the site.`,
+            proposal: {
+                collectionId: blog.id,
+                collectionSlug: blog.slug,
+                slug: written.slug
+            }
+        };
+        return _extends({}, spent, {
+            outputs: [
+                output
+            ]
+        }, index + 1 < input.total ? {
+            continue: true
+        } : {});
+    };
+}
+export const runAiSitePostsUnit = createAiSitePostsRunner();
+/** The sentence the products unit's brief ends with, which the catalog's rules read as how many. */ export function aiSiteProductsBriefLine(input = AI_SITE_PRODUCTS) {
+    return `Propose between ${input.min} and ${input.max} products: the store's first ones.`;
+}
+/**
+ * The products unit's runner: the `products` step's catalog for the store's
+ * brief, then each proposed product, up to the most a site starts with,
+ * written as an unpriced draft by the plugin that keeps products. A product
+ * past the plan's allowance stops the writing there, and the row says how
+ * many were added; none at all is the allowance's review.
+ */ export function createAiSiteProductsRunner(deps) {
+    var _deps_writerFor;
+    const writerFor = (_deps_writerFor = deps.writerFor) != null ? _deps_writerFor : pluginResourceDraftWriter;
+    return async (context)=>{
+        var _ref;
+        var _catalog_proposal;
+        const { job } = context;
+        const keeper = writerFor('product');
+        const model = (_ref = context.modelFor == null ? void 0 : context.modelFor.call(context, 'job.products')) != null ? _ref : aiModelForStep('job.products');
+        if (!keeper || !job.hostId) return _extends({}, aiUnspentOutcome(model), {
+            failure: 'Products are not available on this site.'
+        });
+        const outcome = await deps.catalog(_extends({}, context, {
+            job: _extends({}, job, {
+                kind: 'products',
+                inputs: _extends({}, job.inputs, {
+                    target: 'catalog'
+                })
+            })
+        }));
+        if (outcome.refused || outcome.failure || outcome.review) return outcome;
+        const catalog = outcome.outputs.map((output)=>({
+                output,
+                proposal: aiProductsProposalOf(output)
+            })).find((entry)=>{
+            var _entry_proposal;
+            return ((_entry_proposal = entry.proposal) == null ? void 0 : _entry_proposal.kind) === 'catalog';
+        });
+        if (!catalog || ((_catalog_proposal = catalog.proposal) == null ? void 0 : _catalog_proposal.kind) !== 'catalog') return _extends({}, outcome, {
+            outputs: []
+        });
+        const proposed = catalog.proposal.products.slice(0, AI_SITE_PRODUCTS.max);
+        const outputs = [];
+        let stopped = null;
+        for (const [index, product] of proposed.entries()){
+            var _context_org, _catalog_output_hostSubdomain;
+            const written = await keeper.writer.write({
+                orgId: job.orgId,
+                hostId: job.hostId,
+                uid: job.createdBy,
+                org: (_context_org = context.org) != null ? _context_org : null,
+                now: context.now,
+                id: aiSiteProductId(job.$id, index),
+                name: product.name,
+                // No price: the owner sets it. No photo: the writer takes none.
+                content: {
+                    name: product.name,
+                    type: product.type,
+                    description: product.description,
+                    tags: product.tags,
+                    options: product.options,
+                    seoTitle: product.seoTitle,
+                    seoDescription: product.seoDescription
+                }
+            });
+            if (written.ok === false) {
+                stopped = written.error;
+                break;
+            }
+            outputs.push({
+                resource: 'product',
+                id: written.id,
+                hostId: job.hostId,
+                hostSubdomain: (_catalog_output_hostSubdomain = catalog.output.hostSubdomain) != null ? _catalog_output_hostSubdomain : null,
+                label: written.name,
+                note: 'A draft with no price. Set its price and photo in Products to put it on sale.'
+            });
+        }
+        if (!outputs.length) {
+            return _extends({}, outcome, {
+                outputs: [],
+                review: limitReview(stopped != null ? stopped : 'No product could be added.')
+            });
+        }
+        // The allowance that stopped the rest is said where the last one added is.
+        if (stopped) {
+            const last = outputs[outputs.length - 1];
+            last.note = `${last.note} ${outputs.length} of ${proposed.length} added: ${stopped}.`;
+        }
+        return _extends({}, outcome, {
+            outputs
+        });
+    };
+}
+/**
+ * Whether a part may be built for this member on this site, asked before its
+ * first pass so a refusal spends nothing; `null` admits. Products ask what a
+ * `products` job asks (the plan's commerce feature, Commerce on and released
+ * for the site) and the writer's own refusal (role, allowance); posts ask
+ * that the member may write the site's content.
+ */ export async function aiSiteContentRefusal(part, context, deps = {}) {
+    var _deps_admissionFor, _context_org, _deps_writerFor, _context_org1, _ref;
+    const { job, firestore } = context;
+    if (!job.hostId) return 'Open the site first.';
+    if (part === 'posts') {
+        var _host_get;
+        const host = await firestore.collection('hosts').doc(job.hostId).get();
+        return hostRoleCanWrite(((_host_get = host.get('memberRoles')) != null ? _host_get : {})[job.createdBy]) ? null : 'Editing requires the editor role';
+    }
+    const admission = ((_deps_admissionFor = deps.admissionFor) != null ? _deps_admissionFor : aiJobAdmissionFor)('products');
+    const refused = admission ? await admission({
+        firestore,
+        orgId: job.orgId,
+        hostId: job.hostId,
+        inputs: {
+            target: 'catalog'
+        },
+        org: (_context_org = context.org) != null ? _context_org : null,
+        uid: job.createdBy
+    }) : {
+        status: 403,
+        error: 'Products are not available on this site.'
+    };
+    if (refused) return refused.error;
+    const keeper = ((_deps_writerFor = deps.writerFor) != null ? _deps_writerFor : pluginResourceDraftWriter)('product');
+    if (!keeper) return 'Products are not available on this site.';
+    const room = await keeper.writer.refusal({
+        orgId: job.orgId,
+        hostId: job.hostId,
+        uid: job.createdBy,
+        org: (_context_org1 = context.org) != null ? _context_org1 : null,
+        now: context.now
+    });
+    return (_ref = room == null ? void 0 : room.error) != null ? _ref : null;
+}
+/**
+ * Publishes the posts a guided start wrote, as the entry editor's Publish
+ * does, once its pages are live. Never throws: a post that stays a draft is
+ * the owner's to publish from Content.
+ */ export async function aiPublishSitePosts(firestore, input, publish = publishContentEntries) {
+    var _posts__proposal, _posts_, _posts__proposal1, _posts_1;
+    const posts = input.outputs.filter((output)=>output.resource === 'entry');
+    const collectionId = str((_posts_ = posts[0]) == null ? void 0 : (_posts__proposal = _posts_.proposal) == null ? void 0 : _posts__proposal['collectionId']);
+    const collectionSlug = str((_posts_1 = posts[0]) == null ? void 0 : (_posts__proposal1 = _posts_1.proposal) == null ? void 0 : _posts__proposal1['collectionSlug']);
+    if (!input.job.hostId || !posts.length || !collectionId) return null;
+    try {
+        const result = await publish(firestore, {
+            hostId: input.job.hostId,
+            collectionId,
+            uid: input.job.createdBy,
+            ids: posts.map((post)=>post.id),
+            now: input.now
+        });
+        if ('ok' in result) {
+            console.warn('ai site posts not published', {
+                jobId: input.job.$id,
+                error: result.error
+            });
+            return {
+                published: 0,
+                kept: posts.length,
+                paths: []
+            };
+        }
+        const slugs = posts.filter((post)=>result.published.includes(post.id)).map((post)=>{
+            var _post_proposal;
+            return str((_post_proposal = post.proposal) == null ? void 0 : _post_proposal['slug']);
+        }).filter(Boolean);
+        return {
+            published: result.published.length,
+            kept: result.kept.length,
+            paths: collectionSlug ? [
+                `/${collectionSlug}`,
+                ...slugs.map((slug)=>`/${collectionSlug}/${slug}`)
+            ] : []
+        };
+    } catch (error) {
+        console.error('ai site posts publish threw', {
+            orgId: input.job.orgId,
+            jobId: input.job.$id,
+            error
+        });
+        return null;
+    }
+}
+/** What a page of a blog or a store is told about the posts or products built before it. */ export function aiSiteContentBriefLines(outputs) {
+    const posts = outputs.filter((output)=>output.resource === 'entry');
+    const products = outputs.filter((output)=>output.resource === 'product' && !output.proposal);
+    const lines = [];
+    if (posts.length) {
+        var _posts__proposal;
+        const slug = str((_posts__proposal = posts[0].proposal) == null ? void 0 : _posts__proposal['collectionSlug']);
+        lines.push(`This site's blog${slug ? ` at /${slug}` : ''} has these posts: ${posts.map((post)=>`“${post.label}”`).join(', ')}.`, 'Where a page features writing, feature these posts by their titles; never name a post that is not in this list.');
+    }
+    if (products.length) {
+        lines.push(`This store's products are: ${products.map((product)=>`“${product.label}”`).join(', ')}.`, 'Where a page features products, feature these by their names; never name another product, and never state a price.');
+    }
+    return lines;
+}
+
+//# sourceMappingURL=ai-job-site-content.js.map