@aglyn/plugins-ai 1.0.0-beta.143

package/src/lib/components/assist-edit-canvas.js

@@ -0,0 +1,636 @@
+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 { screenSeoStageKey } from "@aglyn/aglyn/app-utils/screen-seo-fields";
+import { NODE_HIDE_IF_PROP, replaceSubtreeWithInstance, reusableComponentDefinitionFrom } from "@aglyn/aglyn/app-utils/compose-reusable-components";
+import { CANVAS_ROOT_ELEMENT_ID } from "@aglyn/aglyn/foundation/constants/canvas";
+import { stageEditorSessionFields } from "@aglyn/aglyn/plugin-manager/editor-sessions";
+import { ASSIST_EDIT_CONTEXT_MAX_NODES, ASSIST_EDIT_CONTEXT_MAX_PROPS, ASSIST_EDIT_OUTLINE_TEXT_CHARS, ASSIST_EDIT_SELECTED_TEXT_CHARS, assistEditOpCounts } from "../model/assist-edit.js";
+const UNDESCRIBED_PROP = /^(html|sx|style|className|dangerouslySetInnerHTML|on[A-Z].*)$/;
+const isRecord = (value)=>typeof value === 'object' && value !== null && !Array.isArray(value);
+/**
+ * An observable's own keys as a plain object. A canvas node's `props` and
+ * `sx` are observable proxies, and a spread of one is how a merge silently
+ * copies nothing.
+ */ function plain(value) {
+    const out = {};
+    if (!value || typeof value !== 'object') return out;
+    for(const key in value){
+        out[key] = value[key];
+    }
+    return out;
+}
+function describeProps(raw, textChars) {
+    const props = {};
+    let kept = 0;
+    for (const [name, value] of Object.entries(plain(raw))){
+        if (kept >= ASSIST_EDIT_CONTEXT_MAX_PROPS) break;
+        if (UNDESCRIBED_PROP.test(name)) continue;
+        if (typeof value === 'string') {
+            if (!value.trim()) continue;
+            props[name] = value.slice(0, textChars);
+        } else if (typeof value === 'number' && Number.isFinite(value)) {
+            props[name] = value;
+        } else if (typeof value === 'boolean') {
+            props[name] = value;
+        } else {
+            continue;
+        }
+        kept += 1;
+    }
+    return kept ? props : undefined;
+}
+function describeSx(raw) {
+    const sx = {};
+    for (const [key, value] of Object.entries(plain(raw))){
+        if (typeof value === 'string' || typeof value === 'number') sx[key] = value;
+        else if (isRecord(value)) sx[key] = plain(value);
+    }
+    return Object.keys(sx).length ? sx : undefined;
+}
+/**
+ * The selection's ancestors below the document root, top-level section first
+ * and the selection last; null when its parents do not lead to the root,
+ * which is not a chain the server can check.
+ */ function chainToRoot(canvas, selected) {
+    const chain = [];
+    const walked = new Set();
+    let current = selected;
+    while((current == null ? void 0 : current.$id) && current.$id !== CANVAS_ROOT_ELEMENT_ID && !walked.has(current.$id)){
+        walked.add(current.$id);
+        chain.unshift(current.$id);
+        current = current.parentId ? canvas.getNode(current.parentId) : undefined;
+    }
+    return (current == null ? void 0 : current.$id) === CANVAS_ROOT_ELEMENT_ID ? chain : null;
+}
+/** Elements one shape is taken over at most; a larger subtree is never called alike. */ const SHAPE_LIMIT = 200;
+/**
+ * How an element is built: its component and, in order, its children's —
+ * what two cards of one row have in common whatever their text. Null past
+ * `SHAPE_LIMIT` elements, or for a subtree that loops back on itself.
+ */ function shapeOf(canvas, rootId) {
+    let budget = SHAPE_LIMIT;
+    const walked = new Set();
+    const walk = (id)=>{
+        var _node_nodes, _node_componentId;
+        const node = canvas.getNode(id);
+        if (!node || walked.has(id) || --budget < 0) return null;
+        walked.add(id);
+        const parts = [];
+        for (const child of (_node_nodes = node.nodes) != null ? _node_nodes : []){
+            const part = walk(child);
+            if (part === null) return null;
+            parts.push(part);
+        }
+        return `${String((_node_componentId = node.componentId) != null ? _node_componentId : '')}(${parts.join(',')})`;
+    };
+    return walk(rootId);
+}
+/** Elements reachable from the document root through child lists, the root included. */ function countElements(canvas) {
+    let count = 0;
+    const reached = new Set([
+        CANVAS_ROOT_ELEMENT_ID
+    ]);
+    const pending = [
+        CANVAS_ROOT_ELEMENT_ID
+    ];
+    while(pending.length){
+        var _node_nodes;
+        const node = canvas.getNode(pending.pop());
+        if (!node) continue;
+        count += 1;
+        for (const child of (_node_nodes = node.nodes) != null ? _node_nodes : []){
+            if (reached.has(child)) continue;
+            reached.add(child);
+            pending.push(child);
+        }
+    }
+    return count;
+}
+/**
+ * The canvas outline a question carries on the edit rung, in two tiers, until
+ * the cap.
+ *
+ * Described in full, settings and all: the document root, the selection's
+ * ancestors and the selection, the document's top-level sections, everything
+ * inside the selection — what an edit to it changes — and its siblings.
+ *
+ * Described briefly, by place alone (`brief`): what surrounds that, so the
+ * model knows it exists and asks for it rather than calling it missing —
+ *
+ * 1. what the selection's siblings hold, level by level (the icons beside a
+ *    selected link, in the card they share);
+ * 2. the siblings of each ancestor below the top-level section, nearest
+ *    first (the other cards of the row, then what sits beside the row).
+ *
+ * An element built the same way as the selection, or as the ancestor it sits
+ * beside, is marked `like` it and its contents are left out: one card
+ * described, and every other card of the row says it holds the same.
+ *
+ * With nothing selected, it is the root, the top-level sections and one level
+ * inside each: enough for a change to the page as a whole, and the prompt asks
+ * for a selection before anything more specific.
+ *
+ * An element is only ever described after its parent, so every ancestor chain
+ * the server checks is whole. `total` counts the document, and each element's
+ * `childCount` stays its real one, so the server can tell the model what the
+ * outline leaves out. The server holds this to its own limits before it quotes
+ * a byte of it; null when the canvas has no document root loaded.
+ */ export function describeAssistEditCanvas(canvas, selectedId) {
+    const root = canvas.getNode(CANVAS_ROOT_ELEMENT_ID);
+    if (!root) return null;
+    const order = [];
+    const seen = new Set();
+    const brief = new Set();
+    const like = new Map();
+    const full = ()=>order.length >= ASSIST_EDIT_CONTEXT_MAX_NODES;
+    const add = (id, briefly = false)=>{
+        if (!id || seen.has(id) || full()) return;
+        if (!canvas.getNode(id)) return;
+        seen.add(id);
+        order.push(id);
+        if (briefly) brief.add(id);
+    };
+    const childrenOf = (id)=>{
+        var _ref;
+        var _canvas_getNode;
+        return (_ref = (_canvas_getNode = canvas.getNode(id)) == null ? void 0 : _canvas_getNode.nodes) != null ? _ref : [];
+    };
+    const shapes = new Map();
+    const shape = (id)=>{
+        var _shapes_get;
+        if (!shapes.has(id)) shapes.set(id, shapeOf(canvas, id));
+        return (_shapes_get = shapes.get(id)) != null ? _shapes_get : null;
+    };
+    // Alike only when there are contents to leave out.
+    const alike = (id, model)=>childrenOf(id).length > 0 && shape(id) !== null && shape(id) === shape(model);
+    add(CANVAS_ROOT_ELEMENT_ID);
+    const selected = selectedId && selectedId !== CANVAS_ROOT_ELEMENT_ID ? canvas.getNode(selectedId) : undefined;
+    const chain = (selected == null ? void 0 : selected.$id) ? chainToRoot(canvas, selected) : null;
+    chain == null ? void 0 : chain.forEach((id)=>add(id));
+    if ((selected == null ? void 0 : selected.$id) && chain && seen.has(selected.$id)) {
+        var _root_nodes;
+        for (const id of (_root_nodes = root.nodes) != null ? _root_nodes : [])add(id);
+        const inside = new Set([
+            selected.$id
+        ]);
+        const queue = [
+            ...childrenOf(selected.$id)
+        ];
+        while(queue.length && !full()){
+            const id = queue.shift();
+            if (inside.has(id)) continue;
+            inside.add(id);
+            add(id);
+            queue.push(...childrenOf(id));
+        }
+        const siblings = selected.parentId ? childrenOf(selected.parentId).filter((id)=>id !== selected.$id) : [];
+        const held = [];
+        for (const id of siblings){
+            add(id);
+            // A sibling the cap left out takes its contents with it.
+            if (!seen.has(id)) continue;
+            if (alike(id, selected.$id)) like.set(id, selected.$id);
+            else held.push(...childrenOf(id));
+        }
+        const reached = new Set([
+            ...inside,
+            ...siblings,
+            ...held
+        ]);
+        for(let level = held; level.length && !full();){
+            const deeper = [];
+            for (const id of level){
+                add(id, true);
+                for (const child of childrenOf(id)){
+                    if (reached.has(child)) continue;
+                    reached.add(child);
+                    deeper.push(child);
+                }
+            }
+            level = deeper;
+        }
+        // Parent first; the top-level section's own siblings are the sections above.
+        for (const ancestor of chain.slice(1, -1).reverse()){
+            var _canvas_getNode;
+            const parentId = (_canvas_getNode = canvas.getNode(ancestor)) == null ? void 0 : _canvas_getNode.parentId;
+            for (const id of parentId ? childrenOf(parentId) : []){
+                if (id === ancestor || seen.has(id)) continue;
+                add(id, true);
+                if (seen.has(id) && alike(id, ancestor)) like.set(id, ancestor);
+            }
+        }
+    } else {
+        var _root_nodes1, _root_nodes2;
+        for (const id of (_root_nodes1 = root.nodes) != null ? _root_nodes1 : [])add(id);
+        for (const section of (_root_nodes2 = root.nodes) != null ? _root_nodes2 : []){
+            for (const id of childrenOf(section))add(id);
+        }
+    }
+    const nodes = order.map((id)=>{
+        var _node_parentId, _node_componentId, _ref, _ref1;
+        var _parent_nodes, _node_nodes;
+        const node = canvas.getNode(id);
+        const isRoot = id === CANVAS_ROOT_ELEMENT_ID;
+        const parentId = isRoot ? null : (_node_parentId = node.parentId) != null ? _node_parentId : null;
+        const parent = parentId ? canvas.getNode(parentId) : undefined;
+        const isSelected = id === (selected == null ? void 0 : selected.$id);
+        const isBrief = brief.has(id);
+        const props = isBrief ? undefined : describeProps(node.props, isSelected ? ASSIST_EDIT_SELECTED_TEXT_CHARS : ASSIST_EDIT_OUTLINE_TEXT_CHARS);
+        const sx = isSelected ? describeSx(node.sx) : undefined;
+        const model = like.get(id);
+        return _extends({
+            id,
+            componentId: String((_node_componentId = node.componentId) != null ? _node_componentId : ''),
+            parentId,
+            index: Math.max(0, (_ref = parent == null ? void 0 : (_parent_nodes = parent.nodes) == null ? void 0 : _parent_nodes.indexOf(id)) != null ? _ref : 0),
+            childCount: (_ref1 = (_node_nodes = node.nodes) == null ? void 0 : _node_nodes.length) != null ? _ref1 : 0
+        }, node.name ? {
+            name: String(node.name)
+        } : {}, props ? {
+            props
+        } : {}, sx ? {
+            sx
+        } : {}, isBrief ? {
+            brief: true
+        } : {}, model ? {
+            like: model
+        } : {});
+    });
+    return {
+        selectedId: (selected == null ? void 0 : selected.$id) && seen.has(selected.$id) ? selected.$id : null,
+        total: countElements(canvas),
+        nodes
+    };
+}
+/** Ids of the subtree at `rootId`, the root included, through child lists only. */ function subtreeIds(canvas, rootId) {
+    var _ref;
+    var _canvas_getNode;
+    const found = new Set([
+        rootId
+    ]);
+    const queue = [
+        ...(_ref = (_canvas_getNode = canvas.getNode(rootId)) == null ? void 0 : _canvas_getNode.nodes) != null ? _ref : []
+    ];
+    while(queue.length){
+        var _ref1;
+        var _canvas_getNode1;
+        const id = queue.shift();
+        if (found.has(id) || !canvas.getNode(id)) continue;
+        found.add(id);
+        queue.push(...(_ref1 = (_canvas_getNode1 = canvas.getNode(id)) == null ? void 0 : _canvas_getNode1.nodes) != null ? _ref1 : []);
+    }
+    return found;
+}
+const STALE = {
+    ok: false,
+    reason: 'stale',
+    message: 'The canvas has changed since this was proposed, so nothing was applied. Ask again.'
+};
+/**
+ * Whether the proposal can land on the open editor as it stands — checked in
+ * full before anything is touched, so a refusal never leaves half an edit.
+ */ export function checkAssistEdit(canvas, proposal, session) {
+    if (!session) {
+        return {
+            ok: false,
+            reason: 'no-editor',
+            message: 'Open the editor this change was proposed for to apply it.'
+        };
+    }
+    if (session.documentKind !== proposal.target.kind || session.documentId !== proposal.target.documentId) {
+        return {
+            ok: false,
+            reason: 'other-document',
+            message: 'This change was proposed for a different document than the one open.'
+        };
+    }
+    if (session.isLiveVersion()) {
+        return {
+            ok: false,
+            reason: 'live-version',
+            message: 'This is the version your live site shows. Make a new version first, then apply the change there.'
+        };
+    }
+    for (const op of proposal.ops){
+        switch(op.op){
+            case 'setSeo':
+                {
+                    for (const field of Object.keys(op.fields)){
+                        var _session_fields;
+                        if (typeof ((_session_fields = session.fields) == null ? void 0 : _session_fields[screenSeoStageKey(field)]) !== 'function') {
+                            return {
+                                ok: false,
+                                reason: 'other-document',
+                                message: 'This editor has no search fields to fill in.'
+                            };
+                        }
+                    }
+                    break;
+                }
+            case 'insertSubtree':
+                {
+                    const parent = canvas.getNode(op.parentId);
+                    if (!parent || parent.componentId !== op.parentComponentId) return STALE;
+                    if (!canvas.nodeAcceptsChildren(parent)) return STALE;
+                    break;
+                }
+            case 'move':
+                {
+                    const node = canvas.getNode(op.nodeId);
+                    const parent = canvas.getNode(op.parentId);
+                    if (!node || node.componentId !== op.componentId) return STALE;
+                    if (!parent || parent.componentId !== op.parentComponentId) return STALE;
+                    break;
+                }
+            case 'saveAsComponent':
+                {
+                    const node = canvas.getNode(op.nodeId);
+                    if (!node || node.componentId !== op.componentId) return STALE;
+                    // The document itself is not a section of itself: promoting the root
+                    // would leave a document holding one instance of its own contents.
+                    if (op.nodeId === CANVAS_ROOT_ELEMENT_ID) return STALE;
+                    const inside = subtreeIds(canvas, op.nodeId);
+                    for (const binding of op.bindings){
+                        const bound = canvas.getNode(binding.nodeId);
+                        if (!bound || bound.componentId !== binding.componentId) return STALE;
+                        // A closed world: a token outside the promoted subtree would bind a
+                        // property of the new component to an element it does not contain.
+                        if (!inside.has(binding.nodeId)) return STALE;
+                    }
+                    break;
+                }
+            default:
+                {
+                    const node = canvas.getNode(op.nodeId);
+                    if (!node || node.componentId !== op.componentId) return STALE;
+                }
+        }
+    }
+    return {
+        ok: true
+    };
+}
+/**
+ * Styles merged one key at a time. A responsive patch over a plain value
+ * keeps that value as the base breakpoint, so "more padding on wide screens"
+ * does not quietly remove the padding everywhere else.
+ */ function mergeSx(current, patch) {
+    const out = _extends({}, current);
+    for (const [key, value] of Object.entries(patch)){
+        const existing = out[key];
+        if (isRecord(value) && isRecord(existing)) {
+            out[key] = _extends({}, plain(existing), value);
+        } else if (isRecord(value) && (typeof existing === 'string' || typeof existing === 'number')) {
+            out[key] = _extends({
+                xs: existing
+            }, value);
+        } else {
+            out[key] = value;
+        }
+    }
+    return out;
+}
+/** A validated flat subtree as the nested shape `addNodeFromNested` takes. */ function nestSubtree(op) {
+    const visited = new Set();
+    const build = (id)=>{
+        visited.add(id);
+        const node = op.nodes[id];
+        return _extends({
+            componentId: node.componentId
+        }, node.pluginId ? {
+            pluginId: node.pluginId
+        } : {}, {
+            props: _extends({}, node.props)
+        }, node.sx ? {
+            sx: _extends({}, node.sx)
+        } : {}, node.hidden ? {
+            hidden: true
+        } : {}, {
+            nodes: node.nodes.filter((child)=>op.nodes[child] && !visited.has(child)).map((child)=>build(child))
+        });
+    };
+    return build(op.rootId);
+}
+function live(canvas, id) {
+    const node = canvas.getNode(id);
+    if (!node) throw new Error(`element ${id} is no longer on the canvas`);
+    return node;
+}
+function applyOne(canvas, op) {
+    switch(op.op){
+        case 'updateProps':
+            {
+                const node = live(canvas, op.nodeId);
+                // Spread the props the element has: `updateNodeProps` REPLACES the bag,
+                // and a patch of one setting would otherwise strip every other one.
+                const next = _extends({}, plain(node.props), op.props);
+                // Rich text renders `html` over `children`; proposed text replaces it.
+                if ('children' in op.props) delete next['html'];
+                canvas.updateNodeProps(node, next);
+                return;
+            }
+        case 'updateSx':
+            {
+                const node = live(canvas, op.nodeId);
+                canvas.updateNodeFields(node, {
+                    sx: mergeSx(plain(node.sx), op.sx)
+                });
+                return;
+            }
+        case 'move':
+            var _op_index;
+            canvas.reparentNode(live(canvas, op.nodeId), live(canvas, op.parentId), (_op_index = op.index) != null ? _op_index : NaN);
+            return;
+        case 'remove':
+            canvas.deleteNode(live(canvas, op.nodeId));
+            return;
+        case 'rename':
+            canvas.updateNodeFields(live(canvas, op.nodeId), {
+                name: op.name
+            });
+            return;
+        case 'insertSubtree':
+            var _op_index1;
+            canvas.addNodeFromNested(nestSubtree(op), live(canvas, op.parentId), (_op_index1 = op.index) != null ? _op_index1 : NaN);
+            return;
+        case 'setSeo':
+        case 'saveAsComponent':
+            // Both are applied outside the canvas batch: search fields are staged
+            // into the editor's own form, and a component save mints a document
+            // first and then swaps the subtree for an instance of it.
+            return;
+    }
+}
+/**
+ * The value a bound field holds on the live canvas right now, which becomes
+ * the property's default.
+ *
+ * `hideIf` is the exception: the part is on the page, so the property that
+ * hides it starts at no. Every other field answers with what the author can
+ * see, which is what makes the instance render exactly what was there.
+ */ function currentValue(node, field) {
+    if (field === NODE_HIDE_IF_PROP) return false;
+    const value = plain(node.props)[field];
+    if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+        return value;
+    }
+    return undefined;
+}
+/**
+ * Whether a default the canvas gave is one the property's own control
+ * offers. A Choice whose current value is not among its answers is a
+ * selection that has changed since the proposal was made, and applying it
+ * would declare a property no page could ever set back.
+ */ function defaultFitsProp(prop, value) {
+    var _prop_options;
+    if (!((_prop_options = prop.options) == null ? void 0 : _prop_options.length)) return true;
+    return prop.options.some((option)=>option.value === value);
+}
+/**
+ * The definition the new component holds: the promoted subtree, with each
+ * bound field replaced by its property's token.
+ *
+ * The defaults are read off the SAME fields a moment before they are
+ * replaced, so the instance that takes the subtree's place renders what the
+ * author was looking at. Returns null when a default no longer fits its
+ * property, which is the stale case.
+ */ function componentDefinition(canvas, op) {
+    const nodes = reusableComponentDefinitionFrom(canvas.toJSON().nodes, op.nodeId);
+    const defaults = new Map();
+    for (const binding of op.bindings){
+        const live = canvas.getNode(binding.nodeId);
+        const stored = nodes[binding.nodeId];
+        if (!live || !stored) return null;
+        if (!defaults.has(binding.prop)) defaults.set(binding.prop, currentValue(live, binding.field));
+        stored['props'] = _extends({}, plain(stored['props']), {
+            [binding.field]: `{{prop.${binding.prop}}}`
+        });
+    }
+    const props = [];
+    for (const declared of op.props){
+        const value = defaults.get(declared.name);
+        if (!defaultFitsProp(declared, value)) return null;
+        props.push(_extends({}, declared, value === undefined ? {} : {
+            defaultValue: value
+        }));
+    }
+    return {
+        nodes,
+        props
+    };
+}
+/**
+ * Lands a confirmed proposal on the open editor: the canvas ops as ONE batch
+ * — one undo step, all or nothing — then any search fields staged into the
+ * editor's own form. Nothing is saved.
+ */ export function applyAssistEdit(canvas, proposal, session) {
+    const check = checkAssistEdit(canvas, proposal, session);
+    if (check.ok === false) return check;
+    const open = session;
+    const canvasOps = proposal.ops.filter((op)=>op.op !== 'setSeo' && op.op !== 'saveAsComponent');
+    if (canvasOps.length) {
+        try {
+            canvas.batch(()=>{
+                for (const op of canvasOps)applyOne(canvas, op);
+            });
+        } catch (error) {
+            console.error('assist edit refused by the canvas', error);
+            return {
+                ok: false,
+                reason: 'refused',
+                message: 'The editor refused part of this change, so none of it was applied.'
+            };
+        }
+    }
+    const staged = [];
+    for (const op of proposal.ops){
+        if (op.op !== 'setSeo') continue;
+        const values = {};
+        for (const [field, value] of Object.entries(op.fields)){
+            values[screenSeoStageKey(field)] = String(value);
+        }
+        staged.push(...stageEditorSessionFields(open, values).staged);
+    }
+    return {
+        ok: true,
+        opCounts: assistEditOpCounts(proposal.ops),
+        staged
+    };
+}
+/**
+ * Lands a proposal that saves the selection as a reusable component
+ * (AGL-2908) — AGL-2866's recipe, in place, with no clipboard.
+ *
+ * The order is the manual action's order, and it matters:
+ *
+ * 1. the definition is read off the live subtree, each bound field replaced
+ *    by its token and its current value kept as that property's default;
+ * 2. the component is created through the host resources route, where the
+ *    server enforces the plan's entitlement and its own allow-list — so a
+ *    refusal happens before the open document is touched at all;
+ * 3. the subtree is swapped for an instance of what was just created, inside
+ *    ONE `batch` with the rest of the proposal's canvas ops: one undo step.
+ *
+ * The only document created is the component, exactly as Save as reusable
+ * component creates one. The page change is an unsaved edit on the version
+ * the editor has open, which the check has already refused to be a live one.
+ * Nothing is published and nothing is saved.
+ */ export async function applyAssistEditSavingComponent(canvas, proposal, session, writer) {
+    const save = proposal.ops.find((op)=>op.op === 'saveAsComponent');
+    if (!save) return applyAssistEdit(canvas, proposal, session);
+    const check = checkAssistEdit(canvas, proposal, session);
+    if (check.ok === false) return check;
+    const definition = componentDefinition(canvas, save);
+    if (!definition) return STALE;
+    let componentId;
+    try {
+        componentId = await writer.createComponent({
+            name: save.name,
+            rootId: save.nodeId,
+            nodes: definition.nodes,
+            props: definition.props
+        });
+    } catch (error) {
+        console.error('assist edit could not create the component', error);
+        return {
+            ok: false,
+            reason: 'refused',
+            message: error instanceof Error && error.message ? error.message : 'The component could not be saved, so nothing on this page was changed.'
+        };
+    }
+    const canvasOps = proposal.ops.filter((op)=>op.op !== 'setSeo' && op.op !== 'saveAsComponent');
+    try {
+        canvas.batch(()=>{
+            for (const op of canvasOps)applyOne(canvas, op);
+            canvas.applyNodes(replaceSubtreeWithInstance(canvas.toJSON().nodes, save.nodeId, componentId, save.name));
+        });
+    } catch (error) {
+        console.error('assist edit refused by the canvas', error);
+        return {
+            ok: false,
+            reason: 'refused',
+            message: 'The component was saved, but the editor refused to swap this element for it. ' + 'Insert it from Your components instead.'
+        };
+    }
+    return {
+        ok: true,
+        opCounts: assistEditOpCounts(proposal.ops),
+        staged: []
+    };
+}
+
+//# sourceMappingURL=assist-edit-canvas.js.map