@aglyn/plugins-ai 1.0.0-beta.293 → 1.0.0-beta.296

package/src/lib/jobs/ai-job-edit-step.d.ts

@@ -23,6 +23,8 @@ import type { AiJob, AiJobOutput } from '../model/ai-jobs.types';
 import { type AssistEditCanvasContext, type AssistEditOp, type AssistEditProposal, type AssistEditTarget } from '../model/assist-edit';
 import { type AiCustomGenerationInput } from '../runtime/ai-doctrine';
 import type { AiSystemBlock } from '../runtime/ai-runtime';
+import { readAiSiteDatasets } from '../runtime/site-inventory';
+import { type AssistEditDataset, type AssistEditDatasetScope } from '../server/assist-edit';
 import { type AiJobAdmission } from './ai-job-admission';
 import { type AiJobStepRunner } from './ai-job-text-step';
 /**
@@ -39,13 +41,19 @@ import { type AiJobStepRunner } from './ai-job-text-step';
  *
  * ── 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.
+ * Never on a version a visitor sees. By default, on every plan, in the
+ * WORKING DRAFT of the version it started from (AGL-4116): the one document
+ * the Besigner saves to as an author works and offers with Open draft, which
+ * publishing moves into the version. The change is built on the draft the
+ * author already has, when the Besigner would still offer it, so their work
+ * in progress is never thrown away; otherwise on the version's own tree.
+ *
+ * Only when the request asks for a new version, and the plan keeps 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. Asked for without version
+ * history, the change goes into the draft and the output says why.
  *
  * ── What a job cannot do that the editor can ────────────────────────────
  *
@@ -59,8 +67,8 @@ import { type AiJobStepRunner } from './ai-job-text-step';
  *
  * 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.
+ * nothing. A draft the job writes is stamped with the job's id for the same
+ * reason.
  */
 /** The longest the step may take reading the page and writing it. */
 export declare const AI_EDIT_READS_MS = 2000;
@@ -76,11 +84,22 @@ export declare function aiJobEditModel(): string;
 export declare const AI_JOB_EDIT_RULES: AiSystemBlock;
 /** The system blocks for one kind of document. */
 export declare function aiJobEditInstructions(kind: AiEditTargetKind): AiSystemBlock[];
-/** What the change is asked from: the document's outline, then the request. */
+/**
+ * What the change is asked from: the document's outline, the site's datasets
+ * an element may show the records of (AGL-3616), then the request.
+ */
 export declare function aiJobEditPrompt(input: {
     brief: string;
     context: AssistEditCanvasContext;
+    datasets?: readonly AssistEditDataset[];
 }): string;
+/**
+ * The datasets an edit to this document knows (AGL-3616): every one the site
+ * holds, and the one whose record page the document is, if it is one.
+ */
+export declare function aiEditDatasetScope(datasets: ReadonlyArray<AssistEditDataset & {
+    recordScreenId?: string;
+}>, read: Pick<AiEditTargetRead, 'kind' | 'id'>): Required<AssistEditDatasetScope>;
 /** The edit as the doctrine's loop runs it: the rung's tool, held to the rung's check. */
 export declare function aiJobEditGeneration(request: {
     brief: string;
@@ -88,7 +107,7 @@ export declare function aiJobEditGeneration(request: {
     target: AssistEditTarget;
     model: string;
     signal?: AbortSignal;
-}): AiCustomGenerationInput<AssistEditProposal>;
+} & AssistEditDatasetScope): AiCustomGenerationInput<AssistEditProposal>;
 /** A canvas over a stored node map, with the editor's own guarded mutators and no editor. */
 export declare function aiEditCanvas(nodes: NodesMap): CanvasManager;
 /**
@@ -115,7 +134,16 @@ export interface AiEditTargetRead {
     pointerVersionId: string | null;
     /** The version the change starts from. */
     sourceVersionId: string;
+    /** The version's own tree. */
     nodes: NodesMap;
+    /**
+     * The version's working draft, when it has one the Besigner would still
+     * offer: an author's saved work in progress, which a change to the draft
+     * is built on. Null when there is none, or the version was saved since.
+     */
+    draft: {
+        nodes: NodesMap;
+    } | null;
     /** Whether visitors see the document's current version: a published page, a collection template, any layout. */
     served: boolean;
     /** The version a pending publish schedule will make current, if any. */
@@ -152,14 +180,29 @@ export declare function aiEditPlacement(input: {
     sourceIsPointer: boolean;
     sourceScheduled: boolean;
 }): AiEditPlacement | 'refused';
+/**
+ * Where an edit job's change lands (AGL-4116): the version's working draft,
+ * unless the request asked for a new version and the plan keeps version
+ * history — then where {@link aiEditPlacement} puts a new one. Never refused:
+ * a draft is on every plan, and no visitor sees it.
+ */
+export declare function aiEditJobPlacement(input: {
+    newVersion: boolean;
+    versioning: boolean;
+    served: boolean;
+    sourceIsPointer: boolean;
+    sourceScheduled: boolean;
+}): AiEditPlacement;
 export interface AiEditWriteInput {
     hostId: string;
     kind: AiEditTargetKind;
     id: string;
     sourceVersionId: string;
-    /** The new version's id, which is the job's; also the stamp a change in place carries. */
+    /** The new version's id, which is the job's; also the stamp a draft it writes carries. */
     jobVersionId: string;
     versioning: boolean;
+    /** The request asked for a new version (see {@link aiEditJobPlacement}). */
+    newVersion: boolean;
     proposal: AssistEditProposal;
     /** Whether the page's search fields may be written: a page no visitor reaches. */
     writeSeo: boolean;
@@ -189,12 +232,15 @@ export declare function writeAiEdit(firestore: Firestore, input: AiEditWriteInpu
 export interface AiJobEditStepDeps {
     readTarget?: typeof readAiEditTarget;
     writeEdit?: typeof writeAiEdit;
+    readDatasets?: typeof readAiSiteDatasets;
 }
 /** What an edit wrote, as the job's output: a link into the Besigner on the version written. */
 export declare function aiEditOutput(read: Pick<AiEditTargetRead, 'kind' | 'id' | 'name' | 'hostSubdomain'>, hostId: string, written: {
     versionId: string;
     placement: AiEditPlacement;
-}, leftOut: readonly string[]): AiJobOutput;
+}, leftOut: readonly string[], options?: {
+    versionsUnavailable?: boolean;
+}): AiJobOutput;
 /** The new version's id: the job's own, which a build's unit takes from its plan item. */
 export declare function aiEditVersionId(job: Pick<AiJob, '$id'>): string;
 /**
@@ -214,9 +260,9 @@ export interface AiEditJobAdmissionDeps {
     ownerOf?: typeof resolveOrgIdForHost;
 }
 /**
- * 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.
+ * An edit job is admitted for a page or layout of a site of its own org that
+ * has a version to start from. Every plan has somewhere to put the change
+ * that no visitor sees — the version's draft — so no plan is refused.
  */
 export declare function createAiEditJobAdmission(deps?: AiEditJobAdmissionDeps): AiJobAdmission;
 export declare const aiEditJobAdmission: AiJobAdmission;

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

@@ -17,22 +17,25 @@ import { _ as _extends } from "@swc/helpers/_/_extends";
  */ 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 { hasConcurrentWrite, versionStamp } from "@aglyn/aglyn/app-utils/guarded-version-save";
 import { decodeStoredNodes, encodeStoredNodes } from "@aglyn/aglyn/app-utils/stored-nodes";
+import { VERSION_DRAFT_COLLECTION, VERSION_DRAFT_DOC_ID } from "@aglyn/aglyn/app-utils/version-draft";
 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 { AI_EDIT_COMPONENT_LEFT_OUT, AI_EDIT_EMAIL_COPY, AI_EDIT_GONE_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 { readAiSiteDatasets } from "../runtime/site-inventory.js";
+import { assistEditTool, checkAssistEditAnswer, editCanvasBlock, editDatasetsBlock, 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 { aiGenerationSpent, aiUnspentOutcome } from "./ai-job-generation.js";
 import { AI_JOB_BRIEF_MAX_CHARS } from "./ai-job-text-step.js";
 import { registerAiJobStep } from "./ai-jobs.js";
 /**
@@ -49,13 +52,19 @@ import { registerAiJobStep } from "./ai-jobs.js";
  *
  * ── 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.
+ * Never on a version a visitor sees. By default, on every plan, in the
+ * WORKING DRAFT of the version it started from (AGL-4116): the one document
+ * the Besigner saves to as an author works and offers with Open draft, which
+ * publishing moves into the version. The change is built on the draft the
+ * author already has, when the Besigner would still offer it, so their work
+ * in progress is never thrown away; otherwise on the version's own tree.
+ *
+ * Only when the request asks for a new version, and the plan keeps 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. Asked for without version
+ * history, the change goes into the draft and the output says why.
  *
  * ── What a job cannot do that the editor can ────────────────────────────
  *
@@ -69,8 +78,8 @@ import { registerAiJobStep } from "./ai-jobs.js";
  *
  * 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.
+ * nothing. A draft the job writes is stamped 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'],
@@ -89,8 +98,8 @@ export function aiJobEditModel() {
  */ 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.',
+        `- 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, beyond what making that change needs.`,
+        '- Find the elements the request means in the outline of the whole document the request carries, by what they say, what they are and where they sit on the page. 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.",
@@ -107,13 +116,41 @@ export function aiJobEditModel() {
         }
     ];
 }
-/** What the change is asked from: the document's outline, then the request. */ export function aiJobEditPrompt(input) {
+/**
+ * What the change is asked from: the document's outline, the site's datasets
+ * an element may show the records of (AGL-3616), then the request.
+ */ export function aiJobEditPrompt(input) {
+    var _input_datasets;
+    const datasets = editDatasetsBlock((_input_datasets = input.datasets) != null ? _input_datasets : []);
     return [
         editSelectionBlock(input.context),
+        ...datasets ? [
+            '',
+            datasets
+        ] : [],
         '',
         `Request: ${input.brief.slice(0, AI_JOB_BRIEF_MAX_CHARS)}`
     ].join('\n');
 }
+/**
+ * The datasets an edit to this document knows (AGL-3616): every one the site
+ * holds, and the one whose record page the document is, if it is one.
+ */ export function aiEditDatasetScope(datasets, read) {
+    var _ref;
+    const record = read.kind === 'screen' ? datasets.find((dataset)=>dataset.recordScreenId === read.id) : undefined;
+    return {
+        datasets: datasets.map(({ id, name, fields, fieldIds, imageField })=>_extends({
+                id,
+                name,
+                fields
+            }, fieldIds ? {
+                fieldIds
+            } : {}, imageField ? {
+                imageField
+            } : {})),
+        recordDatasetId: (_ref = record == null ? void 0 : record.id) != null ? _ref : null
+    };
+}
 /** 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;
@@ -136,10 +173,14 @@ export function aiJobEditModel() {
     } : {}, request.signal ? {
         signal: request.signal
     } : {}, {
-        check: (answer)=>checkAssistEditAnswer(answer, {
+        check: (answer)=>checkAssistEditAnswer(answer, _extends({
                 context: request.context,
                 target: request.target
-            })
+            }, request.datasets ? {
+                datasets: request.datasets
+            } : {}, request.recordDatasetId ? {
+                recordDatasetId: request.recordDatasetId
+            } : {}))
     });
 }
 // ── The document, headless ────────────────────────────────────────────────
@@ -214,6 +255,25 @@ function pendingScheduleVersion(doc) {
     if (!schedule || schedule['status'] !== 'pending' || schedule['action'] === 'unpublish') return null;
     return text(schedule['versionId']) || null;
 }
+/**
+ * A version's working draft as the Besigner would offer it: a tree, taken
+ * against the version as it is stored now. A draft the version has been
+ * saved past is not offered there (it would undo that save), so a change is
+ * not built on it here either. `aiEditJobId` names the job that wrote it.
+ */ function usableDraft(draft, version) {
+    if (!draft.exists) return null;
+    const nodes = decodeStoredNodes(draft.get('nodes'));
+    if (!nodes || !Object.keys(nodes).length) return null;
+    const baseStamp = typeof draft.get('baseStamp') === 'string' ? draft.get('baseStamp') : null;
+    if (hasConcurrentWrite(baseStamp, versionStamp(version.get('updatedAt')))) return null;
+    return {
+        nodes,
+        aiEditJobId: text(draft.get('aiEditJobId')) || null
+    };
+}
+/** A version's working draft document: the Besigner's, at the core's one address. */ function draftRef(versions, versionId) {
+    return versions.doc(versionId).collection(VERSION_DRAFT_COLLECTION).doc(VERSION_DRAFT_DOC_ID);
+}
 /**
  * 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
@@ -265,6 +325,7 @@ function pendingScheduleVersion(doc) {
             return _extends({}, base, {
                 sourceVersionId: sourceVersionId != null ? sourceVersionId : input.jobId,
                 nodes: {},
+                draft: null,
                 written: {
                     versionId: input.jobId,
                     placement
@@ -275,7 +336,10 @@ function pendingScheduleVersion(doc) {
             status: 404,
             error: AI_EDIT_VERSION_GONE_COPY
         };
-        const source = await versions.doc(sourceVersionId).get();
+        const [source, draftDoc] = await Promise.all([
+            versions.doc(sourceVersionId).get(),
+            draftRef(versions, sourceVersionId).get()
+        ]);
         if (!source.exists) return {
             status: 404,
             error: AI_EDIT_VERSION_GONE_COPY
@@ -284,12 +348,25 @@ function pendingScheduleVersion(doc) {
             return _extends({}, base, {
                 sourceVersionId,
                 nodes: {},
+                draft: null,
                 written: {
                     versionId: sourceVersionId,
                     placement: 'in-place'
                 }
             });
         }
+        const draft = usableDraft(draftDoc, source);
+        if (input.jobId && (draft == null ? void 0 : draft.aiEditJobId) === input.jobId) {
+            return _extends({}, base, {
+                sourceVersionId,
+                nodes: {},
+                draft: null,
+                written: {
+                    versionId: sourceVersionId,
+                    placement: 'draft'
+                }
+            });
+        }
         const nodes = decodeStoredNodes(source.get('nodes'));
         if (!nodes || !Object.keys(nodes).length) return {
             status: 400,
@@ -298,6 +375,9 @@ function pendingScheduleVersion(doc) {
         return _extends({}, base, {
             sourceVersionId,
             nodes,
+            draft: draft ? {
+                nodes: draft.nodes
+            } : null,
             written: null
         });
     }
@@ -314,6 +394,16 @@ function pendingScheduleVersion(doc) {
     const seen = input.sourceScheduled || input.sourceIsPointer && input.served;
     return seen ? 'refused' : 'in-place';
 }
+/**
+ * Where an edit job's change lands (AGL-4116): the version's working draft,
+ * unless the request asked for a new version and the plan keeps version
+ * history — then where {@link aiEditPlacement} puts a new one. Never refused:
+ * a draft is on every plan, and no visitor sees it.
+ */ export function aiEditJobPlacement(input) {
+    if (!input.newVersion || !input.versioning) return 'draft';
+    const placed = aiEditPlacement(input);
+    return placed === 'refused' ? 'draft' : placed;
+}
 /**
  * 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
@@ -326,12 +416,15 @@ function pendingScheduleVersion(doc) {
     const versions = docRef.collection('versions');
     const sourceRef = versions.doc(input.sourceVersionId);
     const newRef = versions.doc(input.jobVersionId);
+    const sourceDraftRef = draftRef(versions, input.sourceVersionId);
     return firestore.runTransaction(async (tx)=>{
-        const [host, doc, source, already] = await Promise.all([
+        var _ref;
+        const [host, doc, source, already, draftDoc] = await Promise.all([
             tx.get(hostRef),
             tx.get(docRef),
             tx.get(sourceRef),
-            tx.get(newRef)
+            tx.get(newRef),
+            tx.get(sourceDraftRef)
         ]);
         const pointer = text(doc.get('versionId')) || null;
         if (already.exists) {
@@ -351,22 +444,30 @@ function pendingScheduleVersion(doc) {
             error: AI_EDIT_VERSION_GONE_COPY
         };
         const served = input.kind === 'layout' || screenServed(doc, host);
-        const placement = aiEditPlacement({
+        const placement = aiEditJobPlacement({
+            newVersion: input.newVersion,
             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'));
+        // Read again here, as the version is: an author who saved their draft,
+        // or published it, since the read is what the change is built on now.
+        const draft = placement === 'draft' ? usableDraft(draftDoc, source) : null;
+        if ((draft == null ? void 0 : draft.aiEditJobId) === input.jobVersionId) {
+            return {
+                ok: true,
+                versionId: input.sourceVersionId,
+                placement,
+                seoWritten: false
+            };
+        }
+        const nodes = (_ref = draft == null ? void 0 : draft.nodes) != null ? _ref : 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 versionId = placement === 'draft' ? input.sourceVersionId : input.jobVersionId;
         const seo = {};
         const writeSeo = input.writeSeo && input.kind === 'screen' && !served;
         const proposal = _extends({}, input.proposal, {
@@ -387,9 +488,14 @@ function pendingScheduleVersion(doc) {
         };
         const stored = Buffer.from(packed);
         const docPatch = {};
-        if (placement === 'in-place') {
-            tx.update(sourceRef, {
+        if (placement === 'draft') {
+            // The whole working tree, as the Besigner writes a draft, taken against
+            // the version as stored so the Besigner offers it with Open draft.
+            tx.set(sourceDraftRef, {
                 nodes: stored,
+                baseStamp: versionStamp(source.get('updatedAt')),
+                updatedByUid: input.uid,
+                updatedByEmail: null,
                 updatedAt: input.now,
                 aiEditJobId: input.jobVersionId
             });
@@ -423,20 +529,25 @@ function pendingScheduleVersion(doc) {
         };
     });
 }
-/** 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 {
+/** 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, options = {}) {
+    return _extends({
         resource: read.kind,
         id: read.id,
         versionId: written.versionId,
         hostId,
         hostSubdomain: read.hostSubdomain,
-        label: read.name,
-        note: aiEditOutputNote({
+        label: read.name
+    }, written.placement === 'draft' ? {
+        inDraft: true
+    } : {}, {
+        note: aiEditOutputNote(_extends({
             kind: read.kind,
             placement: written.placement,
             leftOut
-        })
-    };
+        }, options.versionsUnavailable ? {
+            versionsUnavailable: true
+        } : {}))
+    });
 }
 /** 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);
@@ -460,9 +571,10 @@ function pendingScheduleVersion(doc) {
     };
 }
 export function createAiJobEditStep(deps = {}) {
-    var _deps_readTarget, _deps_writeEdit;
+    var _deps_readTarget, _deps_writeEdit, _deps_readDatasets;
     const readTarget = (_deps_readTarget = deps.readTarget) != null ? _deps_readTarget : readAiEditTarget;
     const writeEdit = (_deps_writeEdit = deps.writeEdit) != null ? _deps_writeEdit : writeAiEdit;
+    const readDatasets = (_deps_readDatasets = deps.readDatasets) != null ? _deps_readDatasets : readAiSiteDatasets;
     return async ({ job, now, signal, firestore, org, modelFor })=>{
         var _ref, _data;
         const model = (_ref = modelFor == null ? void 0 : modelFor('job.edit')) != null ? _ref : aiJobEditModel();
@@ -487,30 +599,34 @@ export function createAiJobEditStep(deps = {}) {
         });
         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({
+        const placement = aiEditJobPlacement({
+            newVersion: inputs.newVersion,
             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;
+        // A change to the draft is made on the draft the author already has.
+        const outline = aiEditJobOutline(placement === 'draft' && read.draft ? read.draft.nodes : read.nodes);
+        const context = outline ? parseAssistEditContext(outline, {
+            whole: true
+        }) : 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),
+            versionId: placement === 'draft' ? read.sourceVersionId : aiEditVersionId(job),
             hostId
         };
+        // The site's datasets, so a request to show records binds a repeat to a
+        // real one instead of writing tokens nothing fills (AGL-3616).
+        const datasets = aiEditDatasetScope(await readDatasets(job.orgId, hostId), read);
         const generation = await runValidatedGeneration('edit', aiJobEditGeneration(_extends({
             brief: job.brief,
             context,
             target,
             model
-        }, signal ? {
+        }, datasets, signal ? {
             signal
         } : {})));
         const spent = _extends({}, aiGenerationSpent(generation), generation.effort ? {
@@ -527,10 +643,10 @@ export function createAiJobEditStep(deps = {}) {
         if (!proposal && refused) {
             const salvaged = validateStreamedGeneration('edit', {
                 answer: refused,
-                check: (answer)=>checkAssistEditAnswer(answer, {
+                check: (answer)=>checkAssistEditAnswer(answer, _extends({
                         context,
                         target
-                    })
+                    }, datasets))
             });
             proposal = salvaged.status === 'ok' ? salvaged.value : null;
         }
@@ -557,6 +673,7 @@ export function createAiJobEditStep(deps = {}) {
             sourceVersionId: read.sourceVersionId,
             jobVersionId: aiEditVersionId(job),
             versioning,
+            newVersion: inputs.newVersion,
             proposal: _extends({}, proposal, {
                 ops: kept.ops
             }),
@@ -569,18 +686,21 @@ export function createAiJobEditStep(deps = {}) {
         if (write.ok === false) return _extends({}, spent, {
             failure: write.error
         });
+        const versionsUnavailable = inputs.newVersion && !versioning;
         return _extends({}, spent, {
             outputs: [
-                aiEditOutput(read, hostId, write, leftOut)
+                aiEditOutput(read, hostId, write, leftOut, {
+                    versionsUnavailable
+                })
             ]
         });
     };
 }
 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.
+ * An edit job is admitted for a page or layout of a site of its own org that
+ * has a version to start from. Every plan has somewhere to put the change
+ * that no visitor sees — the version's draft — so no plan is refused.
  */ export function createAiEditJobAdmission(deps = {}) {
     var _deps_readTarget, _deps_ownerOf;
     const readTarget = (_deps_readTarget = deps.readTarget) != null ? _deps_readTarget : readAiEditTarget;
@@ -607,17 +727,8 @@ export const runAiJobEditStep = createAiJobEditStep();
             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;
+        // Every plan has somewhere to put the change: the page's draft (AGL-4116).
+        return 'error' in read ? read : null;
     };
 }
 export const aiEditJobAdmission = createAiEditJobAdmission();