@panphora/clayjs 1.15.2 → 1.17.0

package/src/page/ybind/tokens.js

@@ -1,6 +1,6 @@
 import { attrKeys, sameJson } from "./layout.js";
 import { blockJson } from "../model.js";
-import { marksKey, marksAttrs } from "./marks.js";
+import { marksKey, marksFields } from "./marks.js";
 import { createProjectionMap } from "./projection-map.js";
 
 export const implicitFlags = (doc, visible) => {
@@ -19,7 +19,16 @@ export const implicitFlags = (doc, visible) => {
   });
   return out;
 };
-const pickAttrs = (node) => { const o = {}; for (const k of attrKeys(node.type)) o[k] = node.attrs[k]; if (node.type.name === "table") o.rows = blockJson(node).rows; return o; };
+const opaqueOf = (node) => node.attrs.raw ?? null;
+const pickAttrs = (node) => {
+  const raw = opaqueOf(node);
+  if (raw) { const o = { ...raw }; delete o.t; delete o.pos; return o; }
+  const o = {};
+  for (const k of attrKeys(node.type)) o[k] = node.attrs[k];
+  if (node.type.name === "table") o.rows = blockJson(node).rows;
+  return o;
+};
+const typeOfNode = (node) => opaqueOf(node)?.t ?? node.type.name;
 
 export function tokensOf(doc, alias = new Map(), visible = null) {
   const toks = [];
@@ -27,9 +36,9 @@ export function tokensOf(doc, alias = new Map(), visible = null) {
   doc.forEach((block, _o, index) => {
     const implicit = flags[index] && !alias.has(block.attrs.id);
     const brk = visible ? visible[index]?.brk ?? null : null;
-    if (!implicit) toks.push({ k: "b", id: flags[index] && alias.has(block.attrs.id) ? alias.get(block.attrs.id) : block.attrs.id, t: block.type.name, attrs: pickAttrs(block), brk });
+    if (!implicit) toks.push({ k: "b", id: flags[index] && alias.has(block.attrs.id) ? alias.get(block.attrs.id) : block.attrs.id, t: typeOfNode(block), attrs: pickAttrs(block), brk });
     if (block.isTextblock) block.content.forEach((n) => {
-      if (n.isText) { const ms = block.type.name === "code_block" ? [] : n.marks; const mk = marksKey(ms), ma = marksAttrs(ms); for (let i = 0; i < n.text.length; i++) toks.push({ k: "c", ch: n.text[i], mk, ma }); }
+      if (n.isText) { const ms = typeOfNode(block) === "code_block" ? [] : n.marks; const mk = marksKey(ms), ma = marksFields(ms); for (let i = 0; i < n.text.length; i++) toks.push({ k: "c", ch: n.text[i], mk, ma }); }
       else if (n.type.name === "hard_break") toks.push({ k: "h" });
     });
   });
@@ -74,8 +83,8 @@ export function textTokenRange(doc, from, to) {
     const a = Math.max(0, startOffset - cursor), b = Math.min(node.nodeSize, endOffset - cursor);
     if (a < b) {
       if (node.isText) {
-        const marks = block.type.name === "code_block" ? [] : node.marks;
-        const mk = marksKey(marks), ma = marksAttrs(marks);
+        const marks = typeOfNode(block) === "code_block" ? [] : node.marks;
+        const mk = marksKey(marks), ma = marksFields(marks);
         for (let i = a; i < b; i++) tokens.push({ k: "c", ch: node.text[i], mk, ma });
       } else if (node.type.name === "hard_break") tokens.push({ k: "h" });
     }

package/src/page/ybind/walk.js

@@ -144,14 +144,21 @@ function walkFlow(pd, index) {
     const root = recoveredRoot(sourceKey, removalsBySource.get(sourceKey) ?? [], intents);
     const id = `recovered:${sourceKey}`;
     const t = root ? root.type : "paragraph";
-    cur = { kind: "b", id, baseId: id, brk: { client: it.id.client, clock: it.id.clock }, implicit: false, runs: [], len: 1, atom: !schema.nodes[t]?.isTextblock, recovered: true, restored: !moved, sourceKey, t, fields: root ? root.attrs : null };
+    const opaque = !Object.hasOwn(schema.nodes, t);
+    cur = { kind: "b", id, baseId: id, brk: { client: it.id.client, clock: it.id.clock }, implicit: false, runs: [], len: 1, atom: !opaque && !schema.nodes[t]?.isTextblock, opaque, recovered: true, restored: !moved, sourceKey, t, fields: root ? root.attrs : null };
     segs.push(cur);
     prevId = id;
   };
   const open = (id, brk, implicit) => {
     cur = { kind: "b", id, baseId: id, brk, implicit, runs: [], len: implicit ? 0 : 1, atom: false, items: !implicit && (markerCount.get(id) ?? 0) > 1 ? [] : null };
-    if (!implicit) { cur.t = typeOf(id); cur.atom = !schema.nodes[cur.t]?.isTextblock; }
-    else cur.t = "paragraph";
+    if (!implicit) {
+      cur.t = typeOf(id);
+      // A type this runtime has no schema for still owns the text and marks up to
+      // the next block marker: it is not an atom whose following text becomes an
+      // implicit paragraph, and it is never rewritten as one.
+      cur.opaque = !Object.hasOwn(schema.nodes, cur.t);
+      cur.atom = !cur.opaque && !schema.nodes[cur.t]?.isTextblock;
+    } else cur.t = "paragraph";
     segs.push(cur);
     prevId = id;
   };

package/src/page/ybind/writer.js

@@ -8,10 +8,23 @@ import { resolveTableFields, tableSeed, writeTable } from "./table.js";
 import { resolveBoardFields, writeBoard } from "./board.js";
 import { createOriginIndex } from "./origins.js";
 
+const FIELD = (value) => (value === true ? {} : value);
+const sameValue = (a, b) => sameJson(FIELD(a), FIELD(b));
+
 export function setAttrs(pd, id, t, attrs) {
   let m = pd.attrs.get(id);
   if (!m) { m = new Y.Map(); pd.attrs.set(id, m); }
   const type = schema.nodes[t];
+  // A block type this runtime has no schema for keeps its original record: no
+  // known field list to normalize it against, and never a paragraph in its place.
+  if (!type) {
+    if (m.get("t") !== t) m.set("t", t);
+    for (const [k, v] of Object.entries(attrs ?? {})) {
+      if (k === "t" || k === "pos") continue;
+      if (!sameJson(m.has(k) ? m.get(k) : undefined, v)) m.set(k, v);
+    }
+    return;
+  }
   const table = t === "table" && m.get("t") === "table" && !recoveredSource(id);
   const board = t === "board" && !recoveredSource(id);
   const before = table ? resolveTableFields(pd.tableFields, id, tableSeed(pd, id)) : board ? resolveBoardFields(pd.boardFields, id) : null;
@@ -46,6 +59,31 @@ export function liveKeys(ctx) {
   return out;
 }
 
+// The live keys this runtime has no schema mark for, including the reserved
+// compact-code bridge. A command never cancels them: they stay byte for byte
+// until something that understands them rewrites them.
+export function opaqueKeys(ctx) {
+  const cancelled = new Set();
+  for (const [k, v] of ctx) if (isCancel(k) && v) cancelled.add(k.split("!")[0]);
+  const out = [];
+  for (const [k, v] of ctx) if (!isCancel(k) && v !== null && v !== undefined && !cancelled.has(k) && !schema.marks[markName(k)]) out.push([k, v]);
+  return out;
+}
+
+// The attributes an inserted unit carries over from its neighbours: every known
+// key as before, and an opaque key only when the editor's mark set still names
+// it, so text at a span boundary does not inherit a format nobody can read.
+export function baseAttributes(ctx, want = {}) {
+  const out = {};
+  let opaque = false;
+  for (const [k, v] of ctx) if (isCancel(k) || schema.marks[markName(k)]) out[k] = v;
+  for (const [k, v] of opaqueKeys(ctx)) {
+    opaque = true;
+    if (want[markName(k)] !== undefined) out[k] = v;
+  }
+  return { attrs: out, opaque };
+}
+
 export function runAttributes(pd, ctx, want) {
   const rid = mintOp(pd);
   const changes = {};
@@ -54,12 +92,17 @@ export function runAttributes(pd, ctx, want) {
   for (const [k, v] of have) {
     const n = markName(k);
     const w = want[n];
-    if (w !== undefined && sameJson(w === true ? true : w, v)) kept.add(n);
+    if (w !== undefined && sameValue(w, v)) kept.add(n);
     else changes[`${k}!${rid}`] = true;
   }
+  for (const [k, v] of opaqueKeys(ctx)) {
+    const n = markName(k);
+    if (want[n] !== undefined && sameValue(want[n], v)) kept.add(n);
+  }
   for (const [n, w] of Object.entries(want)) if (!kept.has(n)) changes[`${n}~${mintOp(pd)}`] = w;
-  if (!Object.keys(changes).length) return undefined;
-  return { ...Object.fromEntries(ctx), ...changes };
+  const base = baseAttributes(ctx, want);
+  if (!Object.keys(changes).length && !base.opaque) return undefined;
+  return { ...base.attrs, ...changes };
 }
 
 export const CHUNK_CHARS = 2000;
@@ -119,7 +162,7 @@ function insertChunk(pd, yIdx, toks, fences = null) {
     i += run.length;
     run = "";
   };
-  const embed = (e) => { const attrs = Object.fromEntries(ctxAt(pd, i)); beforeFence(pd, i, fences, () => pd.flow.insertEmbed(i, e, attrs)); i += 1; };
+  const embed = (e) => { const attrs = baseAttributes(ctxAt(pd, i)).attrs; beforeFence(pd, i, fences, () => pd.flow.insertEmbed(i, e, attrs)); i += 1; };
   for (const t of toks) {
     if (t.k === "c") { if (runMk !== null && t.mk !== runMk) flush(); runMk = t.mk; runMa = t.ma; run += t.ch; }
     else if (t.k === "h") { flush(); runMk = null; embed({ br: 1 }); }
@@ -249,6 +292,7 @@ export function applyRegion(ctx, ta, oldToks, newToks, oldSurvives = null) {
     else insertTokens(pd, map.toPhysical(e.at, "before"), e.i.toks, ctx.tx, ctx.fences);
   }
   for (const [ob, nb] of attrs) ctx.tx(() => {
+    if (!schema.nodes[nb.t]) return;
     const source = ctx.recovered.get(ob.id);
     if (source) {
       if (ob.t !== nb.t) pd.gone.set(attrKey(source, "t"), nb.t);

package/src/plugins/ai-edit.js

@@ -41,10 +41,9 @@
  * invisible to the mutation system (its status text changes constantly), absent from
  * every snapshot and from what peers receive.
  */
-import { HyperMorph } from "../vendor/hyper-morph.vendor.js";
-import { mergeTagRecognizers } from "../sync/merge-tags.js";
+import { loadedEngine, mergeEngine } from "../sync/merge-engine.js";
 import Mutation from "../lib/mutation.js";
-import { isEditMode } from "../core/is-edit-mode.js";
+import { startsAtImport } from "../core/is-edit-mode.js";
 import { holdAllSaves, releaseAllSaves } from "../core/save.js";
 import { STRIP_FROM_SAVE, SNAPSHOT_REMOVE_SELECTOR } from "../lib/region-policy.js";
 import { enableContentEditable } from "../core/admin-contenteditable.js";
@@ -81,7 +80,10 @@ let barMode = null;  // "working", "ready", "saving" or "error"
 let barLifecycle = null;
 let barCloseTimer = null;
 let panelPointerDown = false; // the last pointerdown began in the panel: its click is not a page click
-const drafts = new WeakMap();  // compose text a target keeps while the panel is shut
+let drafts = new WeakMap();  // compose text a target keeps while the panel is shut
+// A WeakMap cannot be read back, and an exit has to know whether anything typed here is
+// still unsent, so the targets that hold a draft are counted beside it.
+const drafted = new Set();
 let anchorEl = null;    // element the panel is currently anchored to
 let chipTarget = null;  // unit the hover chip currently points at
 let chipHideTimer = null;
@@ -92,6 +94,24 @@ let selectionTimer = null;
 let anchorRange = null;  // the selection the open panel was raised for
 let returnFocus = null;  // where focus goes back to when the panel closes
 let helperState = null;  // "ready" or "unavailable"
+let listeners = null;    // the AbortController every handler one session added listens on
+let observers = [];      // the page observers that session opened
+let styleEl = null;      // the one stylesheet the chrome needed
+let chromeToken = 0;     // the latest init(); a teardown retires the one before it
+
+function dropDraft(el) {
+  drafts.delete(el);
+  drafted.delete(el);
+}
+
+function keepDraft(el, text) {
+  if (!text) {
+    dropDraft(el);
+    return;
+  }
+  drafts.set(el, text);
+  drafted.add(el);
+}
 
 const HIGHLIGHT = 'clay-ai-edit';
 const OFF_MESSAGE = 'AI editing is turned off. Turn it on from the app’s menu.';
@@ -190,6 +210,7 @@ function strippedBodyHTML() {
 // ---------------------------------------------------------------- morphing
 
 function morphTo(el, content, scripts) {
+  const { HyperMorph } = loadedEngine();
   return HyperMorph.morph(el, content, { morphStyle: 'outerHTML', restoreFocus: true, scripts });
 }
 
@@ -201,6 +222,7 @@ function morphTo(el, content, scripts) {
 // against the snapshot the model saw, so data the user changed mid-flight survives
 // the reply. Rewinds must restore the snapshot exactly, so they disable merging.
 function sessionMorph(s, content, { rewind = false } = {}) {
+  const { HyperMorph, mergeTagRecognizers } = loadedEngine();
   // handle:false: a reply's scripts never run, so the preview cannot execute code
   // before Keep, and neither can a rewind.
   const scripts = rewind
@@ -300,7 +322,7 @@ async function sendRequest(el, comment, quote) {
   }
   // The sent comment is this target's draft until the reply is ready: Error, Stop, a
   // refused reply, a morph failure and a host cancellation all leave it in place.
-  drafts.set(el, comment);
+  keepDraft(el, comment);
   closePanelForSend();
   session.paused = true;
   pauseObservers();
@@ -321,6 +343,9 @@ async function sendRequest(el, comment, quote) {
   session.handle = handle;
   const outcome = await handle.done;
   if (!session || session.handle !== handle) return;
+  // The engine is fetched here, where a reply is applied, not at boot.
+  await mergeEngine();
+  if (!session || session.handle !== handle) return;
   if (outcome.state === 'done') onDone(outcome.result || {});
   else if (outcome.state === 'cancelled') onError('HTML Clay stopped this edit.');
   else onError(outcome.error || 'the helper reported an error');
@@ -417,7 +442,7 @@ function onDone(payload) {
     return;
   }
   positionChrome();
-  drafts.delete(session.el); // delivered: the comment is no longer this target's draft
+  dropDraft(session.el); // delivered: the comment is no longer this target's draft
   showBar('ready');
   setBarStatus(readyText(warnings, payload.model), warnings.length ? 'warn' : '');
 }
@@ -444,7 +469,7 @@ function revertSession() {
   session = null;
   if (!s) return;
   try {
-    if (s.state === 'requesting' || s.state === 'deciding') {
+    if ((s.state === 'requesting' || s.state === 'deciding') && loadedEngine()) {
       sessionMorph(s, s.snapshot, { rewind: true });
     }
   } finally {
@@ -507,15 +532,16 @@ function marked(el, name, value) {
 }
 
 function buildChrome() {
-  const style = document.createElement('style');
-  style.setAttribute('clay', RUNTIME_ONLY);
-  style.textContent = `
+  const { signal } = listeners;
+  styleEl = document.createElement('style');
+  styleEl.setAttribute('clay', RUNTIME_ONLY);
+  styleEl.textContent = `
     [editmode\\:contenteditable][contenteditable]:focus {
       outline: 1px solid #4a4a6a; outline-offset: 4px; border-radius: 2px;
     }
     ::highlight(clay-ai-edit) { background-color: ${TOKENS['brass-soft']} !important; }
   `;
-  document.head.appendChild(style);
+  document.head.appendChild(styleEl);
 
   const scheme = `color-scheme:${pageScheme()}`;
 
@@ -641,24 +667,28 @@ function buildChrome() {
     openPanel(document.body, quoteFromSelection(document.body));
   });
 
-  window.addEventListener('scroll', () => { positionChrome(); hideChip(); }, { passive: true });
-  window.addEventListener('resize', () => { placeBubble(); if (panel && !panel.hidden) fitTextarea(); positionChrome(); }, { passive: true });
+  window.addEventListener('scroll', () => { positionChrome(); hideChip(); }, { passive: true, signal });
+  window.addEventListener('resize', () => { placeBubble(); if (panel && !panel.hidden) fitTextarea(); positionChrome(); }, { passive: true, signal });
   // The CMS toggle can arrive after this chrome, and a docked sidebar slides it left.
   const replace = () => { placeBubble(); positionChrome(); };
-  document.addEventListener('hcms:open', () => { replace(); setTimeout(replace, 350); });
-  document.addEventListener('hcms:close', () => { replace(); setTimeout(replace, 350); });
-  new MutationObserver((records) => {
+  document.addEventListener('hcms:open', () => { replace(); setTimeout(replace, 350); }, { signal });
+  document.addEventListener('hcms:close', () => { replace(); setTimeout(replace, 350); }, { signal });
+  const cmsToggle = new MutationObserver((records) => {
     syncBubble();
     const touched = (nodes) => [...nodes].some((n) => n.nodeType === 1 && n.hasAttribute('data-hcms-toggle-host'));
     if (records.some((r) => touched(r.addedNodes) || touched(r.removedNodes))) replace();
-  }).observe(document.body, { childList: true });
+  });
+  cmsToggle.observe(document.body, { childList: true });
+  observers.push(cmsToggle);
 
   // A target removed from the page ends its edit, so the save hold and the paused
   // observers never outlive it. A running bar is no exception: it is torn down with
   // the target it was describing.
-  new MutationObserver(() => {
+  const targetGone = new MutationObserver(() => {
     if (anchorEl && !anchorEl.isConnected) abandonTarget();
-  }).observe(document.body, { childList: true, subtree: true });
+  });
+  targetGone.observe(document.body, { childList: true, subtree: true });
+  observers.push(targetGone);
 }
 
 // The panel's height changes as the box grows and the status line fills, so it is
@@ -709,6 +739,7 @@ function applyHelperState() {
 // The host's toggle can change while the page is open, so each opening asks again.
 function refreshHelperState() {
   helperStateNow().then((state) => {
+    if (!panel) return; // the session this asked for has ended
     helperState = state || 'unavailable';
     if (!panel.hidden && !session) applyHelperState();
     else syncBubble();
@@ -939,8 +970,7 @@ function openPanel(el, quote) {
 // panel is opened on that target again.
 function storeDraft() {
   if (!anchorEl) return;
-  if (textarea.value) drafts.set(anchorEl, textarea.value);
-  else drafts.delete(anchorEl);
+  keepDraft(anchorEl, textarea.value);
 }
 
 function closePanel() {
@@ -1023,6 +1053,7 @@ function escapeIsMine(event) {
 }
 
 function wireInteractions() {
+  const { signal } = listeners;
   // Clicks: text units are contenteditable (caret) and figures keep their own
   // interactivity, so neither is intercepted, and nothing here prevents the click from
   // landing. Any click on the page away from ClayJS chrome closes the box, a click
@@ -1033,7 +1064,7 @@ function wireInteractions() {
   // box and ends on the page is still the box's, not a click away from it.
   document.addEventListener('pointerdown', (event) => {
     panelPointerDown = panel.contains(event.target);
-  }, { capture: true });
+  }, { capture: true, signal });
 
   document.addEventListener('click', (event) => {
     const startedInPanel = panelPointerDown;
@@ -1050,7 +1081,7 @@ function wireInteractions() {
     } else if (!panel.hidden) {
       closePanel();
     }
-  });
+  }, { signal });
 
   // Hover chip: follows the unit under the cursor while no panel is open.
   let lastMove = 0;
@@ -1064,7 +1095,7 @@ function wireInteractions() {
     const unit = unitFrom(event.target);
     if (unit) showChipFor(unit);
     else scheduleChipHide();
-  });
+  }, { signal });
 
   document.addEventListener('keydown', (event) => {
     if (isShortcut(event)) {
@@ -1094,26 +1125,35 @@ function wireInteractions() {
     if (barMode === 'error') { closeBar(); return; }
     if (barMode) return;
     if (!panel.hidden) closePanel();
-  });
+  }, { signal });
 
   document.addEventListener('selectionchange', () => {
     clearTimeout(selectionTimer);
     selectionTimer = setTimeout(showChipForSelection, 150);
-  });
+  }, { signal });
 }
 
 // ---------------------------------------------------------------- boot
 
-async function init() {
-  if (!isEditMode || panel) return;  // an owner/editor feature, built once
+async function loadHelper() {
+  const token = ++chromeToken;
   helperState = await helperStateNow();
-  // No ai-edit helper on this host: stay dormant. A concurrent open() that got here
-  // first may also have built the chrome already.
+  return token === chromeToken;
+}
+
+function build() {
   if (!helperState || panel) return;
+  listeners = new AbortController();
   buildChrome();
   wireInteractions();
 }
 
+async function init() {
+  if (!startsAtImport() || panel) return;  // an owner/editor feature, built once
+  if (!(await loadHelper())) return;
+  build();
+}
+
 // A target the composer can be opened on: a connected content element of this
 // document. ClayJS chrome, transient UI, everything the save strips and everything
 // that holds no text are not targets.
@@ -1141,11 +1181,106 @@ async function open(el, { prompt } = {}) {
     textarea.focus();
     return true;
   }
-  if (typeof prompt === 'string' && !drafts.has(el)) drafts.set(el, prompt);
+  if (typeof prompt === 'string' && !drafts.has(el)) keepDraft(el, prompt);
   openPanel(el, null);
   return true;
 }
 
-onDomReady(() => { init().catch(() => {}); });
+/**
+ * A committed exit: the chrome, every handler this session added and every page
+ * observer go. What the person typed is a draft, and an exit that could not represent it
+ * never gets here, so nothing unsent is thrown away by this.
+ */
+function teardown() {
+  chromeToken++;
+  const s = session;
+  session = null;
+  try {
+    s?.handle?.cancel();
+    if (s) {
+      if (s.paused) resumeObservers();
+      if (s.held) releaseAllSaves();
+    }
+  } catch {}
+  clearTimeout(selectionTimer);
+  selectionTimer = null;
+  clearTimeout(chipHideTimer);
+  chipHideTimer = null;
+  clearTimeout(barCloseTimer);
+  barCloseTimer = null;
+  clearHighlight();
+  listeners?.abort();
+  listeners = null;
+  for (const observer of observers) observer.disconnect();
+  observers = [];
+  for (const node of [styleEl, ring, panel, bar, chip, docBubble]) node?.remove();
+  styleEl = ring = panel = textarea = statusEl = pointer = bar = barStatus = null;
+  barStop = barKeep = barRevert = barClose = chip = docBubble = null;
+  buttons = {};
+  barMode = null;
+  barLifecycle = null;
+  anchorEl = null;
+  anchorRange = null;
+  returnFocus = null;
+  pendingSelection = undefined;
+  chipTarget = null;
+  chipSelection = undefined;
+  panelPointerDown = false;
+  helperState = null;
+  drafts = new WeakMap();
+  drafted.clear();
+}
+
+/**
+ * ai-edit as a mode lease.
+ *
+ * Preparing this lease asks the host whether it lists a ready helper, which is safe while
+ * the committed mode is still view; the commit that enters edit builds the chrome, inert
+ * until somebody opens it, exactly as `clay.aiEdit.init()` does. What a session adds is
+ * everything still unresolved — a request on the wire, a preview waiting for Keep or
+ * Revert, a comment typed and not sent — so `quiesce` refuses the exit and `resume`
+ * leaves that same preview, comment and selection timer exactly as they were.
+ * `dispose` (after the barrier) stops every editor-only handler and takes the chrome
+ * down, so a save or selection event in view draws nothing. `initial: true` adopts the
+ * chrome the boot's own import built, and asks the host nothing a second time.
+ */
+export function aiEditParticipant() {
+  return {
+    id: "clay:ai-edit",
+    order: 950, // after the wire (900): this request is sent through it
+    prepare(context = {}) {
+      const initial = context.initial === true;
+      return {
+        ready: initial ? boot : loadHelper(),
+        enable() {
+          if (!initial) build();
+        },
+        quiesce() {
+          const unsent = (panel && !panel.hidden && textarea.value.trim() !== '') ||
+            [...drafted].some((el) => el.isConnected);
+          const pending = [];
+          if (session) pending.push(session.id);
+          if (barMode === 'saving') pending.push('save');
+          if (unsent) pending.push('prompt');
+          if (!pending.length) return;
+          throw Object.assign(new Error('clay.aiEdit: an edit here is still unresolved'), {
+            code: 'pending-input',
+            pending,
+          });
+        },
+        resume() {},
+        dispose() {
+          teardown();
+        },
+      };
+    },
+  };
+}
+
+// The boot's own answer, which an explicit edit boot's exit adopts rather than re-asking.
+let boot = null;
+onDomReady(() => { boot = init().then(() => {}, () => {}); });
+
+export { aiEditParticipant as modeParticipant };
 
 export const aiEdit = { init, open };