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

package/src/lib/jobs/ai-job-build-step.js

@@ -0,0 +1,657 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ import { _ as _extends } from "@swc/helpers/_/_extends";
+import { resolveEffectivePlan } from "@aglyn/aglyn/app-utils/plan-entitlements";
+import { resolveOrgIdForHost } from "@aglyn/tenant-data-admin/server/organizations";
+import { AI_BUILD_LIMITS, AI_BUILD_PUBLISH_INPUT, aiArticle, aiBuildCreditEstimate, aiBuildDegradation, aiBuildInitialLedger, aiBuildItemDelivered, aiBuildItemOpen, aiBuildNextUnit, aiBuildOrder, aiBuildPlacedItemLines, aiBuildPlanShapeRefusal, aiBuildUnits } from "../model/ai-build-job.js";
+import { isAiPlanNewRef } from "../model/ai-build-plan.js";
+import { AI_SITE_MAX_SECTIONS } from "../model/ai-site-job.js";
+import { FREE_AI_TASTE_CREDITS_PER_MONTH } from "../plan-entitlements.js";
+import { aiModelForStep } from "../providers/routing.js";
+import { AI_BUILD_UNIT_EMPTY_COPY, aiBuildBuiltRefs, aiUnitErrorRetryable, aiUnitFailure, aiUnitSpend } from "./ai-build-unit-outcome.js";
+import { assistCreditsFromUsd } from "../usage/assist-credits.js";
+import { ASSIST_RETURNED_USD_FIELD, assistSpendAfterReturnsUsd } from "../usage/assist-credit-returns.js";
+import { freeAccountUsageRef, freeAssistAccount } from "../usage/assist-free-taste.js";
+import { aiBuildOps } from "./ai-build-capabilities.js";
+import { aiJobAdmissionRefusal, registerAiJobAdmission } from "./ai-job-admission.js";
+import { aiOriginJobId } from "./ai-job-draft-ids.js";
+import { readAiDraftNodes } from "./ai-job-drafts.js";
+import { aiConfirmedPlan, aiUnspentOutcome } from "./ai-job-generation.js";
+import { AI_JOB_PAGE_STEP_MINIMUM_MS } from "./ai-job-page-budget.js";
+import { aiPluginDraftAdmissionRefusal, aiPluginDraftWriter } from "./ai-job-plugin-drafts.js";
+import { aiSitePageWritten, aiSiteResolvedRef } from "./ai-job-site-step.js";
+import { AI_JOB_BRIEF_MAX_CHARS } from "./ai-job-text-step.js";
+import { aiJobPublishesBuild, aiPublishGuidedSite } from "./ai-site-publish.js";
+import { AI_PLANNED_JOB_KINDS, aiJobStepRunMinimumMs, aiJobStepRunnerFor, registerAiJobStep, registerAiJobStepPasses } from "./ai-jobs.js";
+/**
+ * The build step (AGL-3616): the generation step of a `build` job, run once
+ * the member confirmed the plan their request produced.
+ *
+ * Like the site scaffold it generalizes, it builds nothing itself and asks no
+ * model of its own. Each pass takes the next unit in dependency order and
+ * hands it to what builds that kind of thing — a page, layout, form,
+ * component, email design or template to this plugin's own step, under a job
+ * derived for the unit; another plugin's resource to that plugin's writer on
+ * the resource-draft seam, with the content the owner's capability derives
+ * from the item's arguments. One unit, one pass, one recorded spend.
+ *
+ * ── Settled item by item ────────────────────────────────────────────────
+ *
+ * Where a unit stands is read from the job's ITEM LEDGER, never from counting
+ * outputs: the machine writes each pass's row in the transaction that
+ * records its spend (`recordStep`). A unit that fails is a FAILED ROW, not a
+ * failed job: the pass reports it, the machine gives back that item's spend
+ * where the failure was ours, and the next pass builds the next unit. What
+ * depended on it is built without it, or skipped where it cannot stand
+ * without it (`aiBuildDegradation`). The machine ends the job when nothing is
+ * left: `done` when anything was delivered, `failed` — its planning given
+ * back too — when nothing was.
+ *
+ * ── Drafts, unless asked and confirmed ───────────────────────────────────
+ *
+ * Every unit writes the draft its own kind writes, which nothing publishes.
+ * Only a build whose request asked to publish AND whose member ticked the
+ * plan card's box puts its built pages live, once, on its last pass, through
+ * the guided start's publish.
+ */ /** What a build answers with no confirmed plan to build. */ export const AI_BUILD_NO_PLAN_COPY = 'This build has no confirmed plan to build.';
+/** What a unit says when nothing on this site builds its operation any more. */ export const aiBuildUnavailableCopy = (noun)=>`Not built: ${aiArticle(noun)} cannot be made on this site right now.`;
+/** What a page that was reported built but holds none of its plan says. */ export const AI_BUILD_PAGE_NOT_WRITTEN_COPY = 'The page was not written from its plan.';
+/**
+ * The most passes a build's step may take: every unit at a page's worst — its
+ * sections and its listing — so a runner that never finishes is still
+ * bounded while the largest plan is not. Try again starts the count over.
+ */ export const AI_BUILD_MAX_PASSES = AI_BUILD_LIMITS.units * (AI_SITE_MAX_SECTIONS + 1);
+/** The job kind a creation of the build is built by. */ const CREATION_JOB_KINDS = {
+    layout: 'layout',
+    form: 'form',
+    component: 'component',
+    email: 'email'
+};
+/** The job kind a unit is built by, where an AI runner builds it. */ export function aiBuildUnitJobKind(unit, ops) {
+    var _CREATION_JOB_KINDS_unit_creation_kind;
+    var _ops_get;
+    if (unit.screen) return 'page';
+    if (unit.creation) return (_CREATION_JOB_KINDS_unit_creation_kind = CREATION_JOB_KINDS[unit.creation.kind]) != null ? _CREATION_JOB_KINDS_unit_creation_kind : null;
+    const runnerKind = (_ops_get = ops.get(unit.op)) == null ? void 0 : _ops_get.runnerKind;
+    return runnerKind ? runnerKind : null;
+}
+/** The id a unit's job, and so its draft, is named by. */ export function aiBuildUnitJobId(job, unit) {
+    var _ref, _ref1, _ref2;
+    var _unit_creation, _unit_screen, _unit_item;
+    return (_ref = (_ref1 = (_ref2 = (_unit_creation = unit.creation) == null ? void 0 : _unit_creation.id) != null ? _ref2 : (_unit_screen = unit.screen) == null ? void 0 : _unit_screen.id) != null ? _ref1 : (_unit_item = unit.item) == null ? void 0 : _unit_item.id) != null ? _ref : `${job.$id}-${unit.slot}`;
+}
+/**
+ * The job a unit is built under (generalizing `aiSiteUnitJob`): this job's
+ * org, site, creator and model; the kind that builds the unit; a plan
+ * narrowed to the unit, its `new:` references resolved to what was built and
+ * the failed ones left out; and a brief that says what the unit is, what it
+ * is built without, and which blocks its sections place.
+ */ export function aiBuildUnitJob(job, unit, context) {
+    var _job_outputs, _plan_labels, _context_briefLines, _ref;
+    const plan = job.plan;
+    const built = aiBuildBuiltRefs(context.units, context.ledger, (_job_outputs = job.outputs) != null ? _job_outputs : []);
+    const labels = _extends({}, (_plan_labels = plan.labels) != null ? _plan_labels : {});
+    for (const entry of built.values())labels[entry.id] = entry.label;
+    const brief = [
+        job.brief.trim()
+    ];
+    const unitPlan = _extends({}, plan, {
+        labels,
+        reuse: [
+            ...plan.reuse
+        ],
+        create: [],
+        screens: []
+    });
+    delete unitPlan.items;
+    const placedByScreens = new Set(plan.screens.flatMap((screen)=>screen.sections.flatMap((section)=>section.uses)));
+    if (unit.creation) {
+        unitPlan.reuse = plan.reuse.filter((entry)=>!placedByScreens.has(entry.id));
+        unitPlan.create = [
+            _extends({}, unit.creation, {
+                duplicateOf: aiSiteResolvedRef(unit.creation.duplicateOf, built)
+            })
+        ];
+        brief.push(`Build the ${unit.creation.kind} “${unit.creation.name}”: ${unit.creation.why}`);
+    }
+    if (unit.screen) {
+        var _aiSiteResolvedRef, _aiSiteResolvedRef1;
+        const screen = unit.screen;
+        for (const entry of built.values()){
+            unitPlan.reuse.push({
+                kind: entry.kind,
+                id: entry.id,
+                purpose: `the ${entry.kind} this request built`
+            });
+        }
+        let builtLayout = null;
+        for (const entry of built.values())if (entry.kind === 'layout') builtLayout = builtLayout != null ? builtLayout : entry.id;
+        unitPlan.screens = [
+            _extends({}, screen, {
+                // A page whose layout failed renders inside the site's own: the page
+                // step falls back to it when the plan names none.
+                layout: (_aiSiteResolvedRef = aiSiteResolvedRef(screen.layout, built)) != null ? _aiSiteResolvedRef : isAiPlanNewRef(screen.layout) ? builtLayout : null,
+                template: aiSiteResolvedRef(screen.template, built),
+                duplicateOf: aiSiteResolvedRef(screen.duplicateOf, built),
+                record: screen.record ? _extends({}, screen.record, {
+                    dataset: (_aiSiteResolvedRef1 = aiSiteResolvedRef(screen.record.dataset, built)) != null ? _aiSiteResolvedRef1 : screen.record.dataset
+                }) : null,
+                sections: screen.sections.map((section)=>_extends({}, section, {
+                        uses: section.uses.map((ref)=>aiSiteResolvedRef(ref, built)).filter((ref)=>!!ref)
+                    }))
+            })
+        ];
+        brief.push(`Build the page “${screen.title}”, at ${screen.slug}.`);
+        brief.push(...aiBuildPlacedItemLines(unit, {
+            units: context.units,
+            ledger: context.ledger,
+            ops: context.ops
+        }));
+    }
+    const item = unit.item;
+    if (item) {
+        var _ref1;
+        var _context_ops_get;
+        const noun = (_ref1 = (_context_ops_get = context.ops.get(item.op)) == null ? void 0 : _context_ops_get.noun) != null ? _ref1 : item.op;
+        brief.push(`Build the ${noun} “${item.name}”${item.why ? `: ${item.why}` : '.'}`);
+        // A planned kind's step builds the plan's first creation of its kind.
+        unitPlan.create = AI_PLANNED_JOB_KINDS.includes(context.kind) ? [
+            _extends({
+                kind: context.kind,
+                name: item.name,
+                why: item.why,
+                duplicateOf: null,
+                fields: []
+            }, item.id ? {
+                id: item.id
+            } : {})
+        ] : [];
+    }
+    brief.push(...(_context_briefLines = context.briefLines) != null ? _context_briefLines : []);
+    const inputs = _extends({}, job.inputs, (_ref = item == null ? void 0 : item.args) != null ? _ref : {}, {
+        originJobId: aiOriginJobId(job)
+    });
+    delete inputs[AI_BUILD_PUBLISH_INPUT];
+    return _extends({}, job, {
+        $id: aiBuildUnitJobId(job, unit),
+        kind: context.kind,
+        steps: [],
+        outputs: [],
+        items: null,
+        plan: item && !AI_PLANNED_JOB_KINDS.includes(context.kind) ? null : unitPlan,
+        inputs,
+        brief: brief.join('\n').slice(0, AI_JOB_BRIEF_MAX_CHARS)
+    });
+}
+/** The unit's failure, for its row: ours or not, why, in customer-safe words. */ function failed(slot, failure, extra = {}) {
+    return _extends({
+        slot,
+        status: 'failed',
+        failure
+    }, extra);
+}
+/** Whether a build's workspace spends the Free taste. */ export function aiBuildFreeTaste(org) {
+    return Boolean(org) && resolveEffectivePlan(org) === 'free';
+}
+/** The site document a gate reads, or `null`. */ async function readHost(firestore, hostId) {
+    var _data;
+    if (!hostId) return null;
+    return (_data = (await firestore.collection('hosts').doc(hostId).get()).data()) != null ? _data : null;
+}
+export function createAiJobBuildStep(deps = {}) {
+    var _deps_runnerFor, _deps_writerFor, _deps_opsFor, _deps_admissionFor, _deps_pluginAdmission, _deps_readNodes, _deps_publish;
+    const runnerFor = (_deps_runnerFor = deps.runnerFor) != null ? _deps_runnerFor : aiJobStepRunnerFor;
+    const writerFor = (_deps_writerFor = deps.writerFor) != null ? _deps_writerFor : aiPluginDraftWriter;
+    const opsFor = (_deps_opsFor = deps.opsFor) != null ? _deps_opsFor : (context)=>aiBuildOps(context);
+    const admissionFor = (_deps_admissionFor = deps.admissionFor) != null ? _deps_admissionFor : aiJobAdmissionRefusal;
+    const pluginAdmission = (_deps_pluginAdmission = deps.pluginAdmission) != null ? _deps_pluginAdmission : aiPluginDraftAdmissionRefusal;
+    const readNodes = (_deps_readNodes = deps.readNodes) != null ? _deps_readNodes : readAiDraftNodes;
+    const publish = (_deps_publish = deps.publish) != null ? _deps_publish : aiPublishGuidedSite;
+    return async (context)=>{
+        var _ref, _context_org, _aiBuildOrder, _job_hostId, _job_hostId1, _ref1;
+        var _job_items, _rows_get;
+        const { job, firestore } = context;
+        const model = (_ref = context.modelFor == null ? void 0 : context.modelFor.call(context, 'job.plan')) != null ? _ref : aiModelForStep('job.plan');
+        const plan = aiConfirmedPlan(job);
+        if (!plan) return _extends({}, aiUnspentOutcome(model), {
+            failure: AI_BUILD_NO_PLAN_COPY
+        });
+        const org = (_context_org = context.org) != null ? _context_org : null;
+        const units = aiBuildUnits(plan);
+        const ordered = (_aiBuildOrder = aiBuildOrder(units)) != null ? _aiBuildOrder : units;
+        const starting = !((_job_items = job.items) == null ? void 0 : _job_items.length);
+        const ledger = starting ? aiBuildInitialLedger(units) : job.items;
+        const init = starting ? {
+            items: ledger
+        } : {};
+        const unit = aiBuildNextUnit(ordered, ledger);
+        const rows = new Map(ledger.map((row)=>[
+                row.slot,
+                row
+            ]));
+        const host = await readHost(firestore, (_job_hostId = job.hostId) != null ? _job_hostId : null);
+        const ops = await opsFor({
+            orgId: job.orgId,
+            hostId: (_job_hostId1 = job.hostId) != null ? _job_hostId1 : null,
+            org,
+            host,
+            freeTaste: aiBuildFreeTaste(org)
+        });
+        /** Whether units other than this one are still to build. */ const othersOpen = (slot)=>ordered.some((one)=>{
+                var _rows_get;
+                return one.slot !== slot && aiBuildItemOpen((_rows_get = rows.get(one.slot)) != null ? _rows_get : {
+                    status: 'pending'
+                });
+            });
+        /** The build's last pass puts its pages live, where it was asked and confirmed. */ const finish = async (outcome, extraPages = [])=>{
+            var _job_outputs;
+            if (!aiJobPublishesBuild(job) || job.sitePublish || !job.hostId) return outcome;
+            const pageIds = new Set(units.filter((one)=>{
+                var _rows_get;
+                return one.screen && aiBuildItemDelivered((_rows_get = rows.get(one.slot)) != null ? _rows_get : {
+                    status: 'pending'
+                });
+            }).flatMap((one)=>{
+                var _ref;
+                var _rows_get;
+                return (_ref = (_rows_get = rows.get(one.slot)) == null ? void 0 : _rows_get.outputs) != null ? _ref : [];
+            }));
+            const pages = [
+                ...((_job_outputs = job.outputs) != null ? _job_outputs : []).filter((output)=>output.resource === 'screen' && pageIds.has(output.id)),
+                ...extraPages
+            ];
+            if (!pages.length) return outcome;
+            const sitePublish = await publish(firestore, {
+                job,
+                outputs: pages,
+                now: context.now
+            }).catch((error)=>{
+                console.error('ai build publish threw', {
+                    orgId: job.orgId,
+                    jobId: job.$id,
+                    error
+                });
+                return null;
+            });
+            return sitePublish ? _extends({}, outcome, {
+                sitePublish
+            }) : outcome;
+        };
+        if (!unit) return finish(_extends({}, aiUnspentOutcome(model), init));
+        const settle = (item, spent = aiUnspentOutcome(model))=>_extends({}, spent, init, {
+                item
+            }, item.status === 'running' || othersOpen(unit.slot) ? {
+                continue: true
+            } : {});
+        // What its dependencies came to.
+        const degradation = aiBuildDegradation(unit, {
+            units,
+            ledger,
+            ops
+        });
+        if (degradation.skip) {
+            return settle({
+                slot: unit.slot,
+                status: 'skipped',
+                note: degradation.skip,
+                degradedBy: degradation.degradedBy
+            });
+        }
+        const capability = ops.get(unit.op);
+        const noun = (_ref1 = capability == null ? void 0 : capability.noun) != null ? _ref1 : unit.op;
+        if (!capability) return settle({
+            slot: unit.slot,
+            status: 'skipped',
+            note: aiBuildUnavailableCopy(noun)
+        });
+        const degraded = degradation.degradedBy.length > 0;
+        const note = degradation.notes.length ? degradation.notes.join(' ') : null;
+        // Another plugin's resource: its writer, with the content its capability derives.
+        if (capability.draftResource) {
+            var _ref2;
+            const item = unit.item;
+            const writer = writerFor(capability.draftResource);
+            if (!item || !writer || !job.hostId) {
+                return settle({
+                    slot: unit.slot,
+                    status: 'skipped',
+                    note: aiBuildUnavailableCopy(noun)
+                });
+            }
+            const admission = {
+                firestore,
+                orgId: job.orgId,
+                hostId: job.hostId,
+                inputs: {},
+                org,
+                uid: job.createdBy
+            };
+            const refusal = await pluginAdmission(admission, {
+                kind: 'build',
+                drafts: [
+                    {
+                        resource: capability.draftResource,
+                        label: capability.noun
+                    }
+                ],
+                writerFor
+            });
+            if (refusal) return settle({
+                slot: unit.slot,
+                status: 'skipped',
+                note: `Not built: ${refusal.error}`
+            });
+            const dependencies = {};
+            for (const slot of unit.deps){
+                const dep = units.find((one)=>one.slot === slot);
+                const row = rows.get(slot);
+                if (!dep || !row || !aiBuildItemDelivered(row) || !row.outputs.length) continue;
+                dependencies[`new:${dep.label}`] = {
+                    op: dep.op,
+                    id: row.outputs[0]
+                };
+            }
+            const content = (_ref2 = capability.draftContent == null ? void 0 : capability.draftContent.call(capability, {
+                name: item.name,
+                args: item.args
+            }, {
+                hostId: job.hostId,
+                dependencies
+            })) != null ? _ref2 : item.args;
+            const checked = writer.check(content, {
+                hostId: job.hostId
+            });
+            if (checked.ok === false) {
+                var _checked_problems_;
+                return settle(failed(unit.slot, {
+                    ours: true,
+                    reason: 'step-failure',
+                    message: (_checked_problems_ = checked.problems[0]) != null ? _checked_problems_ : AI_BUILD_UNIT_EMPTY_COPY
+                }));
+            }
+            const id = aiBuildUnitJobId(job, unit);
+            const written = await writer.write({
+                orgId: job.orgId,
+                hostId: job.hostId,
+                uid: job.createdBy,
+                org,
+                now: context.now,
+                id,
+                name: item.name,
+                content
+            });
+            if (written.ok === false) {
+                return settle(failed(unit.slot, {
+                    ours: false,
+                    reason: 'review',
+                    message: written.error
+                }));
+            }
+            const output = {
+                resource: 'draft',
+                id: written.id,
+                versionId: written.versionId,
+                hostId: job.hostId,
+                label: written.name,
+                draftResource: capability.draftResource,
+                note: `A draft, in ${capability.where}.`
+            };
+            return settle(_extends({
+                slot: unit.slot,
+                status: degraded ? 'degraded' : 'succeeded',
+                outputs: [
+                    written.id
+                ],
+                note
+            }, degraded ? {
+                degradedBy: degradation.degradedBy
+            } : {}), _extends({}, aiUnspentOutcome(model), {
+                outputs: [
+                    output
+                ]
+            }));
+        }
+        // This plugin's own runner, under a job derived for the unit.
+        const kind = aiBuildUnitJobKind(unit, ops);
+        const runner = kind ? runnerFor(kind) : null;
+        if (!kind || !runner) return settle({
+            slot: unit.slot,
+            status: 'skipped',
+            note: aiBuildUnavailableCopy(noun)
+        });
+        const derived = aiBuildUnitJob(job, unit, {
+            kind,
+            units,
+            ledger,
+            ops,
+            briefLines: degradation.briefLines
+        });
+        // An item's kind is asked its own admission first (a campaign's plan,
+        // a template's subject), once, before its first pass.
+        if (unit.item && ((_rows_get = rows.get(unit.slot)) == null ? void 0 : _rows_get.status) !== 'running') {
+            var _job_hostId2;
+            const refusal = await admissionFor(kind, {
+                firestore,
+                orgId: job.orgId,
+                hostId: (_job_hostId2 = job.hostId) != null ? _job_hostId2 : null,
+                inputs: derived.inputs,
+                org,
+                uid: job.createdBy
+            }).catch((error)=>{
+                console.error('ai build item admission failed', {
+                    orgId: job.orgId,
+                    jobId: job.$id,
+                    slot: unit.slot,
+                    error
+                });
+                return {
+                    status: 403,
+                    error: AI_BUILD_UNIT_EMPTY_COPY
+                };
+            });
+            if (refusal) return settle({
+                slot: unit.slot,
+                status: 'skipped',
+                note: `Not built: ${refusal.error}`
+            });
+        }
+        let outcome;
+        try {
+            outcome = await runner(_extends({}, context, {
+                job: derived
+            }));
+        } catch (error) {
+            // A provider that will answer later is the machine's to retry; anything
+            // else is this item's failure, and the build goes on.
+            if (aiUnitErrorRetryable(error)) throw error;
+            console.error('ai build unit threw', {
+                orgId: job.orgId,
+                jobId: job.$id,
+                slot: unit.slot,
+                error
+            });
+            return settle(failed(unit.slot, {
+                ours: true,
+                reason: 'provider',
+                message: AI_BUILD_UNIT_EMPTY_COPY
+            }));
+        }
+        const spent = aiUnitSpend(outcome);
+        const ids = outcome.outputs.map((output)=>output.id);
+        const stopped = aiUnitFailure(unit.slot, outcome);
+        if (stopped) return settle(stopped, spent);
+        // A page counts as built only when its plan's sections are in it (AGL-3596).
+        if (unit.screen && job.hostId) {
+            const page = outcome.outputs.find((output)=>output.resource === 'screen');
+            const written = page !== undefined && await aiSitePageWritten(firestore, {
+                hostId: job.hostId,
+                unitJobId: derived.$id,
+                screen: unit.screen,
+                draftId: page.id
+            }, readNodes);
+            if (!written) {
+                return settle(failed(unit.slot, {
+                    ours: true,
+                    reason: 'step-failure',
+                    message: AI_BUILD_PAGE_NOT_WRITTEN_COPY
+                }), _extends({}, spent, {
+                    outputs: outcome.outputs.filter((output)=>output.resource !== 'screen')
+                }));
+            }
+        }
+        const done = settle(_extends({
+            slot: unit.slot,
+            status: degraded ? 'degraded' : 'succeeded',
+            outputs: ids,
+            note
+        }, degraded ? {
+            degradedBy: degradation.degradedBy
+        } : {}), spent);
+        if (done.continue) return done;
+        // The last unit: what was built goes live where it was asked and confirmed.
+        rows.set(unit.slot, _extends({}, rows.get(unit.slot), {
+            status: degraded ? 'degraded' : 'succeeded',
+            outputs: ids
+        }));
+        return finish(done, unit.screen ? outcome.outputs.filter((output)=>output.resource === 'screen') : []);
+    };
+}
+export const runAiJobBuildStep = createAiJobBuildStep();
+/**
+ * The least time a build's next pass needs: what the step that builds its
+ * next unit registers for the job derived for it; a page pass's when the
+ * next unit is another plugin's draft, which asks no model.
+ */ export function aiBuildJobRunMinimumMs(job) {
+    var _aiBuildOrder, _CREATION_JOB_KINDS_unit_creation_kind, _AI_BUILD_ITEM_RUNNER_KINDS_unit_op;
+    var _job_items;
+    const plan = aiConfirmedPlan(job);
+    if (!plan) return AI_JOB_PAGE_STEP_MINIMUM_MS;
+    const units = aiBuildUnits(plan);
+    const ordered = (_aiBuildOrder = aiBuildOrder(units)) != null ? _aiBuildOrder : units;
+    const ledger = ((_job_items = job.items) == null ? void 0 : _job_items.length) ? job.items : aiBuildInitialLedger(units);
+    const unit = aiBuildNextUnit(ordered, ledger);
+    if (!unit) return AI_JOB_PAGE_STEP_MINIMUM_MS;
+    const kind = unit.screen ? 'page' : unit.creation ? (_CREATION_JOB_KINDS_unit_creation_kind = CREATION_JOB_KINDS[unit.creation.kind]) != null ? _CREATION_JOB_KINDS_unit_creation_kind : null : (_AI_BUILD_ITEM_RUNNER_KINDS_unit_op = AI_BUILD_ITEM_RUNNER_KINDS[unit.op]) != null ? _AI_BUILD_ITEM_RUNNER_KINDS_unit_op : null;
+    if (!kind) return AI_JOB_PAGE_STEP_MINIMUM_MS;
+    return aiJobStepRunMinimumMs(aiBuildUnitJob(job, unit, {
+        kind,
+        units,
+        ledger,
+        ops: new Map()
+    }));
+}
+/** The runner kinds this plugin's own item operations use, for the time a pass needs without the registry. */ const AI_BUILD_ITEM_RUNNER_KINDS = {
+    template: 'template',
+    campaign: 'campaign',
+    workflow: 'workflow'
+};
+/**
+ * Why a Free build cannot be confirmed: its estimate is more than the owner's
+ * Free allowance has left this month. Read off the account month the meter
+ * writes, net of give-backs; a read that fails admits, since the reservation
+ * still refuses at the wall.
+ */ export async function aiBuildFreeBalanceRefusal(input) {
+    const account = freeAssistAccount(input.org);
+    if (!(account == null ? void 0 : account.accountUid)) return null;
+    try {
+        const month = input.now.toISOString().slice(0, 7);
+        const snapshot = await freeAccountUsageRef(input.firestore, account.accountUid, month).get();
+        const spent = assistCreditsFromUsd(assistSpendAfterReturnsUsd(snapshot.get('estCostUsd'), snapshot.get(ASSIST_RETURNED_USD_FIELD)));
+        const left = Math.max(0, FREE_AI_TASTE_CREDITS_PER_MONTH - spent);
+        return input.estimate > left ? `This plan is estimated at ${input.estimate} credits, and your Free AI credits have ${left} left this month. Ask for less, or upgrade for more.` : null;
+    } catch (error) {
+        console.error('ai build free balance read failed', {
+            error
+        });
+        return null;
+    }
+}
+/**
+ * A build is admitted for a site of the job's own org where a page can be
+ * built; and confirmed only for a plan it can build here — its shape, its
+ * operations as this site has them, and on the Free taste an estimate the
+ * month's Free credits still cover.
+ */ export function createAiBuildJobAdmission(deps = {}) {
+    var _deps_opsFor, _deps_freeBalanceRefusal, _deps_ownerOf;
+    const opsFor = (_deps_opsFor = deps.opsFor) != null ? _deps_opsFor : (context)=>aiBuildOps(context);
+    const freeBalanceRefusal = (_deps_freeBalanceRefusal = deps.freeBalanceRefusal) != null ? _deps_freeBalanceRefusal : aiBuildFreeBalanceRefusal;
+    const ownerOf = (_deps_ownerOf = deps.ownerOf) != null ? _deps_ownerOf : resolveOrgIdForHost;
+    return async (context)=>{
+        if (!context.hostId) return {
+            status: 400,
+            error: 'Open the site to build on before asking Assist to build'
+        };
+        const owner = await ownerOf(context.hostId);
+        if (!owner || owner !== context.orgId) return {
+            status: 404,
+            error: 'Unknown site'
+        };
+        if (!aiJobStepRunnerFor('page')) return {
+            status: 400,
+            error: 'Building from a request is not available yet.'
+        };
+        const plan = context.plan;
+        if (!plan) return null;
+        const org = context.org;
+        const freeTaste = aiBuildFreeTaste(org);
+        const host = await readHost(context.firestore, context.hostId);
+        const ops = await opsFor({
+            orgId: context.orgId,
+            hostId: context.hostId,
+            org,
+            host,
+            freeTaste
+        });
+        const shape = aiBuildPlanShapeRefusal(plan, {
+            freeTaste,
+            ops
+        });
+        if (shape) return {
+            status: 400,
+            error: shape
+        };
+        if (freeTaste) {
+            var _ref;
+            const refusal = await freeBalanceRefusal({
+                firestore: context.firestore,
+                org,
+                estimate: aiBuildCreditEstimate(plan, {
+                    ops
+                }),
+                now: (_ref = deps.now == null ? void 0 : deps.now.call(deps)) != null ? _ref : new Date()
+            });
+            if (refusal) return {
+                status: 403,
+                error: refusal
+            };
+        }
+        return null;
+    };
+}
+export const aiBuildJobAdmission = createAiBuildJobAdmission();
+/**
+ * Registers the build with the least time a pass needs, the time its next
+ * pass needs, the passes its largest plan may take, and its admission.
+ */ export function registerAiBuildJob() {
+    registerAiJobStep('build', runAiJobBuildStep, {
+        minimumMs: AI_JOB_PAGE_STEP_MINIMUM_MS,
+        minimumMsFor: aiBuildJobRunMinimumMs
+    });
+    registerAiJobStepPasses('build', AI_BUILD_MAX_PASSES);
+    registerAiJobAdmission('build', aiBuildJobAdmission);
+}
+
+//# sourceMappingURL=ai-job-build-step.js.map