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

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

@@ -0,0 +1,631 @@
+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 { checkEntitlement } from "@aglyn/aglyn/app-utils/plan-entitlements";
+import { SCREEN_KIND_TEMPLATE } from "@aglyn/aglyn/app-utils/screen-route";
+import { screenSeoStageKey, SCREEN_SEO_TEXT_FIELDS } from "@aglyn/aglyn/app-utils/screen-seo-fields";
+import { decodeStoredNodes, encodeStoredNodes } from "@aglyn/aglyn/app-utils/stored-nodes";
+import { CanvasManager } from "@aglyn/aglyn/canvas-manager/canvas-manager";
+import { FEATURE_FLAG } from "@aglyn/aglyn/foundation/constants/shared";
+import { resolveOrgIdForHost } from "@aglyn/tenant-data-admin/server/organizations";
+import { applyAssistEdit } from "../components/assist-edit-canvas.js";
+import { AI_EDIT_COMPONENT_LEFT_OUT, AI_EDIT_EMAIL_COPY, AI_EDIT_GONE_COPY, AI_EDIT_NEEDS_VERSIONING_COPY, AI_EDIT_NO_NODES_COPY, AI_EDIT_NO_SITE_COPY, AI_EDIT_NOTHING_COPY, AI_EDIT_REFUSED_COPY, AI_EDIT_SEO_LEFT_OUT, AI_EDIT_STALE_COPY, AI_EDIT_VERSION_GONE_COPY, aiEditJobOutline, aiEditOutputNote, aiEditVersionName, parseAiEditJobInputs } from "../model/ai-edit-job.js";
+import { ASSIST_EDIT_TOOL_NAME } from "../model/assist-edit.js";
+import { AI_STEP_TIERS } from "../providers/catalog.js";
+import { AI_ROUTING_TABLE, aiModelForStep } from "../providers/routing.js";
+import { runValidatedGeneration, validateStreamedGeneration } from "../runtime/ai-doctrine.js";
+import { AI_PALETTE } from "../runtime/ai-palette.generated.js";
+import { assistEditTool, checkAssistEditAnswer, editCanvasBlock, editSelectionBlock, parseAssistEditContext } from "../server/assist-edit.js";
+import { registerAiJobAdmission } from "./ai-job-admission.js";
+import { aiJobStepBudget } from "./ai-job-budget.js";
+import { aiOriginJobId } from "./ai-job-draft-ids.js";
+import { aiGenerationSpent, aiLimitReview, aiUnspentOutcome } from "./ai-job-generation.js";
+import { AI_JOB_BRIEF_MAX_CHARS } from "./ai-job-text-step.js";
+import { registerAiJobStep } from "./ai-jobs.js";
+/**
+ * The `edit` step (AGL-3616): a change to a page or a layout the site already
+ * has, from a description, made on the server with no editor open.
+ *
+ * It is the Assist edit rung, run as a job. The model is shown the stored
+ * document as the rung's outline and proposes through the rung's own tool;
+ * its answer is held to the rung's closed world and palette validators
+ * (`checkAssistEditAnswer`) and re-asked once, naming what was left out; and
+ * what survives lands through the canvas's own guarded mutators
+ * (`applyAssistEdit`), on a `CanvasManager` built headless from the stored
+ * nodes, inside the transaction that writes it.
+ *
+ * ── Where the change lands, decided before anything is spent ────────────
+ *
+ * Never on a version a visitor sees. With version history, a NEW version
+ * beside the one it started from — a copy of that version's stored fields with
+ * the changed nodes — which becomes the page's current version only when the
+ * page is not published; a published page's current version, and a layout's,
+ * never move. Without it, in place, on a version no visitor reaches: an
+ * unpublished page's, or one that is not the current version and no schedule
+ * will publish. Anything else is refused as a plan limit, charged nothing.
+ *
+ * ── What a job cannot do that the editor can ────────────────────────────
+ *
+ * The rung's chat door never offers saving part of a page as a reusable
+ * component, and neither does this. A page's search title and description
+ * live on the page itself, not on a version, so they are written only for a
+ * page that is not published; on a published page they are left out, and the
+ * output's note says so, as it says every change it left out.
+ *
+ * ── One version per job ──────────────────────────────────────────────────
+ *
+ * The new version is named by the job's id — a build's unit is named by its
+ * plan item's id — so a run asked again finds what it wrote and spends
+ * nothing. A change made in place stamps the version with the job's id for
+ * the same reason.
+ */ /** The longest the step may take reading the page and writing it. */ export const AI_EDIT_READS_MS = 2000;
+/** The step's time: its answer and its re-ask at the `job.edit` ceiling, with its own reads. */ export const AI_JOB_EDIT_STEP_BUDGET = aiJobStepBudget({
+    tier: AI_STEP_TIERS['job.edit'],
+    maxTokens: AI_ROUTING_TABLE['job.edit'].maxTokens,
+    lookups: 0,
+    ownReadsMs: AI_EDIT_READS_MS
+});
+export const AI_JOB_EDIT_STEP_MINIMUM_MS = AI_JOB_EDIT_STEP_BUDGET.minimumMs;
+export function aiJobEditModel() {
+    return aiModelForStep('job.edit');
+}
+/**
+ * The job's own rules, byte-identical on every request, ahead of the rung's
+ * protocol and catalog for the document's kind, which carries the breakpoint:
+ * both are the same for every site, so a kind's whole prefix caches once.
+ */ export const AI_JOB_EDIT_RULES = {
+    text: [
+        'You change a page or a layout the person already has, as a job that runs on its own. No editor is open, nothing is selected, and nobody can answer a question before you finish.',
+        `- Make exactly the change the request asks for, and keep everything else as it is: other elements, their text, their styles and their order. Never rewrite, restyle, move or remove what the request does not ask about.`,
+        '- Find the elements the request means in the canvas outline the request carries, by what they say and what they are. Name only ids that outline lists.',
+        `- If the outline does not show an element the request is about, change nothing for that part: never guess at an element.`,
+        `- Call ${ASSIST_EDIT_TOOL_NAME} exactly once, with every operation. Its summary is one short line saying what changed, in the language of the request; it names the version the change is saved in.`,
+        "- Fill in a page's search title or description only when the request asks for it.",
+        '- What you change is saved where no visitor sees it until the person publishes it, so never say the site or the page has changed.',
+        '- The protocol below was written for Assist’s chat. In this job there is no user to ask or to press Apply, and no selection: what it says about those does not apply. Everything else in it — the operations, their fields, the elements and the style tokens — does.'
+    ].join('\n')
+};
+/** The system blocks for one kind of document. */ export function aiJobEditInstructions(kind) {
+    return [
+        AI_JOB_EDIT_RULES,
+        {
+            text: editCanvasBlock(kind),
+            cacheBreakpoint: true
+        }
+    ];
+}
+/** What the change is asked from: the document's outline, then the request. */ export function aiJobEditPrompt(input) {
+    return [
+        editSelectionBlock(input.context),
+        '',
+        `Request: ${input.brief.slice(0, AI_JOB_BRIEF_MAX_CHARS)}`
+    ].join('\n');
+}
+/** The edit as the doctrine's loop runs it: the rung's tool, held to the rung's check. */ export function aiJobEditGeneration(request) {
+    const row = AI_ROUTING_TABLE['job.edit'];
+    const kind = request.target.kind;
+    return _extends({
+        step: 'job.edit',
+        model: request.model,
+        instructions: aiJobEditInstructions(kind),
+        messages: [
+            {
+                role: 'user',
+                content: aiJobEditPrompt(request)
+            }
+        ],
+        tool: assistEditTool(kind),
+        maxTokens: AI_JOB_EDIT_STEP_BUDGET.maxTokens(request.model)
+    }, row.thinking ? {
+        thinking: row.thinking
+    } : {}, row.effort ? {
+        effort: row.effort
+    } : {}, request.signal ? {
+        signal: request.signal
+    } : {}, {
+        check: (answer)=>checkAssistEditAnswer(answer, {
+                context: request.context,
+                target: request.target
+            })
+    });
+}
+// ── The document, headless ────────────────────────────────────────────────
+/**
+ * The slice of the platform a headless canvas asks: whether an element takes
+ * children, answered from the AI palette the edit validator reads, so the
+ * canvas refuses exactly what the validator refuses.
+ */ const AI_EDIT_CANVAS_PLATFORM = {
+    components: {
+        getSchema: (componentId)=>{
+            const entry = AI_PALETTE[componentId];
+            if (!entry) return undefined;
+            return entry.acceptsChildren ? {} : {
+                flags: {
+                    dropping: FEATURE_FLAG.DISABLED
+                }
+            };
+        },
+        getLabel: (componentId)=>{
+            var _ref;
+            var _AI_PALETTE_componentId;
+            return (_ref = (_AI_PALETTE_componentId = AI_PALETTE[componentId]) == null ? void 0 : _AI_PALETTE_componentId.displayName) != null ? _ref : componentId;
+        }
+    }
+};
+/** A canvas over a stored node map, with the editor's own guarded mutators and no editor. */ export function aiEditCanvas(nodes) {
+    const canvas = new CanvasManager(AI_EDIT_CANVAS_PLATFORM);
+    canvas.setNodes(nodes);
+    return canvas;
+}
+/**
+ * Lands a proposal on a stored node map, as the editor lands one on its open
+ * canvas: checked whole first, then one batch, all or nothing. The session is
+ * the version being written, which is never one a visitor sees; a page's
+ * search fields are captured into `seo` only where `seo` is given.
+ */ export function aiApplyEditToNodes(nodes, proposal, seo) {
+    const canvas = aiEditCanvas(nodes);
+    const fields = {};
+    if (seo) {
+        for (const field of SCREEN_SEO_TEXT_FIELDS)fields[screenSeoStageKey(field)] = (value)=>seo[field] = value;
+    }
+    const session = _extends({
+        documentKind: proposal.target.kind,
+        documentId: proposal.target.documentId,
+        versionId: proposal.target.versionId,
+        isLiveVersion: ()=>false
+    }, seo ? {
+        fields
+    } : {});
+    const applied = applyAssistEdit(canvas, proposal, session);
+    if (applied.ok === false) return {
+        ok: false,
+        reason: applied.reason
+    };
+    return {
+        ok: true,
+        nodes: canvas.toJSON().nodes
+    };
+}
+const COLLECTIONS = {
+    screen: 'screens',
+    layout: 'layouts'
+};
+const text = (value)=>typeof value === 'string' ? value : '';
+/** Whether visitors see a page's current version: it is routed, or it renders a collection's entries. */ function screenServed(screen, host) {
+    if (screen.get('kind') === SCREEN_KIND_TEMPLATE) return true;
+    const routing = host.get('screens');
+    return typeof (routing == null ? void 0 : routing[screen.id]) === 'string';
+}
+function pendingScheduleVersion(doc) {
+    const schedule = doc.get('publishSchedule');
+    if (!schedule || schedule['status'] !== 'pending' || schedule['action'] === 'unpublish') return null;
+    return text(schedule['versionId']) || null;
+}
+/**
+ * The document an edit job changes, on the job's own site: the page or
+ * layout named, not deleted, not an email design, and the version it starts
+ * from with a document in it. A refusal names what is wrong.
+ */ export async function readAiEditTarget(firestore, input) {
+    const hostRef = firestore.collection('hosts').doc(input.hostId);
+    const host = await hostRef.get();
+    if (!host.exists || host.get('orgId') !== input.orgId) return {
+        status: 404,
+        error: AI_EDIT_NO_SITE_COPY
+    };
+    const kinds = input.inputs.targetKind ? [
+        input.inputs.targetKind
+    ] : [
+        'screen',
+        'layout'
+    ];
+    for (const kind of kinds){
+        var _input_inputs_versionId;
+        const docRef = hostRef.collection(COLLECTIONS[kind]).doc(input.inputs.target);
+        const doc = await docRef.get();
+        if (!doc.exists) continue;
+        if (doc.get('deletedAt') != null) return {
+            status: 404,
+            error: AI_EDIT_GONE_COPY
+        };
+        if (kind === 'screen' && doc.get('kind') === 'email') return {
+            status: 400,
+            error: AI_EDIT_EMAIL_COPY
+        };
+        const pointerVersionId = text(doc.get('versionId')) || null;
+        const versions = docRef.collection('versions');
+        const hostSubdomain = text(host.get('subdomain')) || null;
+        const name = text(doc.get('displayName')) || (kind === 'screen' ? 'Page' : 'Layout');
+        // A run of this job that got as far as its write.
+        const own = input.jobId ? await versions.doc(input.jobId).get() : null;
+        const sourceVersionId = (_input_inputs_versionId = input.inputs.versionId) != null ? _input_inputs_versionId : pointerVersionId;
+        const base = {
+            kind,
+            id: doc.id,
+            name,
+            hostSubdomain,
+            pointerVersionId,
+            served: kind === 'layout' || screenServed(doc, host),
+            scheduledVersionId: pendingScheduleVersion(doc)
+        };
+        if ((own == null ? void 0 : own.exists) && input.jobId) {
+            const placement = pointerVersionId === input.jobId ? 'new-current' : 'new-beside';
+            return _extends({}, base, {
+                sourceVersionId: sourceVersionId != null ? sourceVersionId : input.jobId,
+                nodes: {},
+                written: {
+                    versionId: input.jobId,
+                    placement
+                }
+            });
+        }
+        if (!sourceVersionId) return {
+            status: 404,
+            error: AI_EDIT_VERSION_GONE_COPY
+        };
+        const source = await versions.doc(sourceVersionId).get();
+        if (!source.exists) return {
+            status: 404,
+            error: AI_EDIT_VERSION_GONE_COPY
+        };
+        if (input.jobId && source.get('aiEditJobId') === input.jobId) {
+            return _extends({}, base, {
+                sourceVersionId,
+                nodes: {},
+                written: {
+                    versionId: sourceVersionId,
+                    placement: 'in-place'
+                }
+            });
+        }
+        const nodes = decodeStoredNodes(source.get('nodes'));
+        if (!nodes || !Object.keys(nodes).length) return {
+            status: 400,
+            error: AI_EDIT_NO_NODES_COPY
+        };
+        return _extends({}, base, {
+            sourceVersionId,
+            nodes,
+            written: null
+        });
+    }
+    return {
+        status: 404,
+        error: AI_EDIT_GONE_COPY
+    };
+}
+/**
+ * Where a change may land (see the module head), or `refused` when the only
+ * place is a version visitors see and the plan keeps no version history.
+ */ export function aiEditPlacement(input) {
+    if (input.versioning) return !input.served && input.sourceIsPointer ? 'new-current' : 'new-beside';
+    const seen = input.sourceScheduled || input.sourceIsPointer && input.served;
+    return seen ? 'refused' : 'in-place';
+}
+/**
+ * The change written, in one transaction that reads the document as it is
+ * stored NOW — a member may have saved, published or changed plan's history
+ * since the read — decides where it lands again on that, and applies the
+ * proposal to the stored nodes through the canvas's guards. An element that
+ * changed since the model saw it refuses the whole change, as the editor does.
+ */ export async function writeAiEdit(firestore, input) {
+    const hostRef = firestore.collection('hosts').doc(input.hostId);
+    const docRef = hostRef.collection(COLLECTIONS[input.kind]).doc(input.id);
+    const versions = docRef.collection('versions');
+    const sourceRef = versions.doc(input.sourceVersionId);
+    const newRef = versions.doc(input.jobVersionId);
+    return firestore.runTransaction(async (tx)=>{
+        const [host, doc, source, already] = await Promise.all([
+            tx.get(hostRef),
+            tx.get(docRef),
+            tx.get(sourceRef),
+            tx.get(newRef)
+        ]);
+        const pointer = text(doc.get('versionId')) || null;
+        if (already.exists) {
+            return {
+                ok: true,
+                versionId: input.jobVersionId,
+                placement: pointer === input.jobVersionId ? 'new-current' : 'new-beside',
+                seoWritten: false
+            };
+        }
+        if (!doc.exists || doc.get('deletedAt') != null) return {
+            ok: false,
+            error: AI_EDIT_GONE_COPY
+        };
+        if (!source.exists) return {
+            ok: false,
+            error: AI_EDIT_VERSION_GONE_COPY
+        };
+        const served = input.kind === 'layout' || screenServed(doc, host);
+        const placement = aiEditPlacement({
+            versioning: input.versioning,
+            served,
+            sourceIsPointer: pointer === input.sourceVersionId,
+            sourceScheduled: pendingScheduleVersion(doc) === input.sourceVersionId
+        });
+        if (placement === 'refused') return {
+            ok: false,
+            error: AI_EDIT_NEEDS_VERSIONING_COPY
+        };
+        const nodes = decodeStoredNodes(source.get('nodes'));
+        if (!nodes) return {
+            ok: false,
+            error: AI_EDIT_NO_NODES_COPY
+        };
+        const versionId = placement === 'in-place' ? input.sourceVersionId : input.jobVersionId;
+        const seo = {};
+        const writeSeo = input.writeSeo && input.kind === 'screen' && !served;
+        const proposal = _extends({}, input.proposal, {
+            ops: writeSeo ? input.proposal.ops : input.proposal.ops.filter((op)=>op.op !== 'setSeo'),
+            target: _extends({}, input.proposal.target, {
+                versionId
+            })
+        });
+        const applied = aiApplyEditToNodes(nodes, proposal, writeSeo ? seo : undefined);
+        if (applied.ok === false) return {
+            ok: false,
+            error: applied.reason === 'stale' ? AI_EDIT_STALE_COPY : AI_EDIT_REFUSED_COPY
+        };
+        const packed = encodeStoredNodes(applied.nodes);
+        if (!packed) return {
+            ok: false,
+            error: AI_EDIT_NO_NODES_COPY
+        };
+        const stored = Buffer.from(packed);
+        const docPatch = {};
+        if (placement === 'in-place') {
+            tx.update(sourceRef, {
+                nodes: stored,
+                updatedAt: input.now,
+                aiEditJobId: input.jobVersionId
+            });
+        } else {
+            // A copy of the version it started from — its layout binding, its
+            // declared properties, everything the editor stored — with the changed
+            // tree, as the versions route copies one.
+            const copy = _extends({}, source.data());
+            delete copy['aiEditJobId'];
+            tx.create(newRef, _extends({}, copy, {
+                nodes: stored,
+                displayName: input.versionName,
+                createdAt: input.now,
+                updatedAt: input.now,
+                createdBy: input.uid,
+                aiJobId: input.aiJobId
+            }));
+            if (placement === 'new-current') docPatch['versionId'] = input.jobVersionId;
+        }
+        for (const [field, value] of Object.entries(seo)){
+            if (value) docPatch[`seo.${field}`] = value;
+        }
+        if (Object.keys(docPatch).length) tx.update(docRef, _extends({}, docPatch, {
+            updatedAt: input.now
+        }));
+        return {
+            ok: true,
+            versionId,
+            placement,
+            seoWritten: Object.keys(seo).length > 0
+        };
+    });
+}
+/** What an edit wrote, as the job's output: a link into the Besigner on the version written. */ export function aiEditOutput(read, hostId, written, leftOut) {
+    return {
+        resource: read.kind,
+        id: read.id,
+        versionId: written.versionId,
+        hostId,
+        hostSubdomain: read.hostSubdomain,
+        label: read.name,
+        note: aiEditOutputNote({
+            kind: read.kind,
+            placement: written.placement,
+            leftOut
+        })
+    };
+}
+/** The new version's id: the job's own, which a build's unit takes from its plan item. */ export function aiEditVersionId(job) {
+    return job.$id.slice(0, 64);
+}
+/**
+ * The ops a job may save, and why it left the rest out: never a component
+ * save, and a page's search fields only where no visitor reaches the page.
+ */ export function aiEditJobOps(ops, options) {
+    const kept = [];
+    const leftOut = new Set();
+    for (const op of ops){
+        if (op.op === 'saveAsComponent') leftOut.add(AI_EDIT_COMPONENT_LEFT_OUT);
+        else if (op.op === 'setSeo' && !options.seo) leftOut.add(AI_EDIT_SEO_LEFT_OUT);
+        else kept.push(op);
+    }
+    return {
+        ops: kept,
+        leftOut: [
+            ...leftOut
+        ]
+    };
+}
+export function createAiJobEditStep(deps = {}) {
+    var _deps_readTarget, _deps_writeEdit;
+    const readTarget = (_deps_readTarget = deps.readTarget) != null ? _deps_readTarget : readAiEditTarget;
+    const writeEdit = (_deps_writeEdit = deps.writeEdit) != null ? _deps_writeEdit : writeAiEdit;
+    return async ({ job, now, signal, firestore, org, modelFor })=>{
+        var _ref, _data;
+        const model = (_ref = modelFor == null ? void 0 : modelFor('job.edit')) != null ? _ref : aiJobEditModel();
+        const unspent = (failure)=>_extends({}, aiUnspentOutcome(model), {
+                failure
+            });
+        const inputs = parseAiEditJobInputs(job.inputs);
+        if (typeof inputs === 'string') return unspent(inputs);
+        const hostId = job.hostId;
+        if (!hostId) return unspent(AI_EDIT_NO_SITE_COPY);
+        const read = await readTarget(firestore, {
+            orgId: job.orgId,
+            hostId,
+            inputs,
+            jobId: aiEditVersionId(job)
+        });
+        if ('error' in read) return unspent(read.error);
+        if (read.written) return aiUnspentOutcome(model, {
+            outputs: [
+                aiEditOutput(read, hostId, read.written, [])
+            ]
+        });
+        const orgData = org != null ? org : (_data = (await firestore.collection('orgs').doc(job.orgId).get()).data()) != null ? _data : null;
+        const versioning = checkEntitlement(orgData, 'versioning');
+        const placement = aiEditPlacement({
+            versioning,
+            served: read.served,
+            sourceIsPointer: read.sourceVersionId === read.pointerVersionId,
+            sourceScheduled: read.scheduledVersionId === read.sourceVersionId
+        });
+        if (placement === 'refused') return aiUnspentOutcome(model, {
+            review: aiLimitReview(AI_EDIT_NEEDS_VERSIONING_COPY)
+        });
+        const outline = aiEditJobOutline(read.nodes);
+        const context = outline ? parseAssistEditContext(outline) : null;
+        if (!context) return unspent(AI_EDIT_NO_NODES_COPY);
+        const target = {
+            kind: read.kind,
+            documentId: read.id,
+            versionId: placement === 'in-place' ? read.sourceVersionId : aiEditVersionId(job),
+            hostId
+        };
+        const generation = await runValidatedGeneration('edit', aiJobEditGeneration(_extends({
+            brief: job.brief,
+            context,
+            target,
+            model
+        }, signal ? {
+            signal
+        } : {})));
+        const spent = _extends({}, aiGenerationSpent(generation), generation.effort ? {
+            effort: generation.effort
+        } : {});
+        if (generation.status === 'refused') return _extends({}, spent, {
+            refused: true
+        });
+        // An answer its re-ask still could not make whole keeps the changes that
+        // survived, as the chat door's card does, and says what it left out; one
+        // with none, or one that broke a numbered rule, is nothing to save.
+        let proposal = generation.status === 'ok' ? generation.value : null;
+        const refused = generation.status === 'needs_input' ? generation.answer : null;
+        if (!proposal && refused) {
+            const salvaged = validateStreamedGeneration('edit', {
+                answer: refused,
+                check: (answer)=>checkAssistEditAnswer(answer, {
+                        context,
+                        target
+                    })
+            });
+            proposal = salvaged.status === 'ok' ? salvaged.value : null;
+        }
+        if (!proposal) return _extends({}, spent, {
+            failure: AI_EDIT_NOTHING_COPY
+        });
+        const seo = read.kind === 'screen' && !read.served;
+        const kept = aiEditJobOps(proposal.ops, {
+            seo
+        });
+        const leftOut = [
+            ...proposal.dropped,
+            ...kept.leftOut
+        ];
+        if (!kept.ops.length) {
+            return _extends({}, spent, {
+                failure: `Nothing was saved. Left out: ${leftOut.join('; ') || 'every change'}.`
+            });
+        }
+        const write = await writeEdit(firestore, {
+            hostId,
+            kind: read.kind,
+            id: read.id,
+            sourceVersionId: read.sourceVersionId,
+            jobVersionId: aiEditVersionId(job),
+            versioning,
+            proposal: _extends({}, proposal, {
+                ops: kept.ops
+            }),
+            writeSeo: seo,
+            versionName: aiEditVersionName(proposal.summary),
+            uid: job.createdBy,
+            aiJobId: aiOriginJobId(job),
+            now
+        });
+        if (write.ok === false) return _extends({}, spent, {
+            failure: write.error
+        });
+        return _extends({}, spent, {
+            outputs: [
+                aiEditOutput(read, hostId, write, leftOut)
+            ]
+        });
+    };
+}
+export const runAiJobEditStep = createAiJobEditStep();
+/**
+ * An edit job is admitted for a page or layout of a site of its own org,
+ * and only where the change has somewhere to land that no visitor sees on
+ * this workspace's plan — refused in the plan's words before anything exists.
+ */ export function createAiEditJobAdmission(deps = {}) {
+    var _deps_readTarget, _deps_ownerOf;
+    const readTarget = (_deps_readTarget = deps.readTarget) != null ? _deps_readTarget : readAiEditTarget;
+    const ownerOf = (_deps_ownerOf = deps.ownerOf) != null ? _deps_ownerOf : resolveOrgIdForHost;
+    return async (context)=>{
+        const inputs = parseAiEditJobInputs(context.inputs);
+        if (typeof inputs === 'string') return {
+            status: 400,
+            error: inputs
+        };
+        if (!context.hostId) return {
+            status: 400,
+            error: AI_EDIT_NO_SITE_COPY
+        };
+        const owner = await ownerOf(context.hostId);
+        if (!owner || owner !== context.orgId) return {
+            status: 404,
+            error: 'Unknown site'
+        };
+        // A job asked about at its door has no run to find yet.
+        const read = await readTarget(context.firestore, {
+            orgId: context.orgId,
+            hostId: context.hostId,
+            inputs,
+            jobId: null
+        });
+        if ('error' in read) return read;
+        const placement = aiEditPlacement({
+            versioning: checkEntitlement(context.org, 'versioning'),
+            served: read.served,
+            sourceIsPointer: read.sourceVersionId === read.pointerVersionId,
+            sourceScheduled: read.scheduledVersionId === read.sourceVersionId
+        });
+        return placement === 'refused' ? {
+            status: 403,
+            error: AI_EDIT_NEEDS_VERSIONING_COPY
+        } : null;
+    };
+}
+export const aiEditJobAdmission = createAiEditJobAdmission();
+/** Registers the edit step and the check an edit job passes before it is created or resumed. */ export function registerAiEditJob() {
+    registerAiJobStep('edit', runAiJobEditStep, {
+        minimumMs: AI_JOB_EDIT_STEP_MINIMUM_MS
+    });
+    registerAiJobAdmission('edit', aiEditJobAdmission);
+}
+
+//# sourceMappingURL=ai-job-edit-step.js.map