@wix/himalaya-cli 0.1159.0 → 0.1161.0

package/templates/community-club-owner/tier5-src/_shared/owner-editor-value.ts

@@ -0,0 +1,56 @@
+// [rico] #3371 — how an owner form reads a RichContentEditor out of `submit(s, values)`.
+//
+// The editor writes its Ricos document into the Form's value bag as a JSON STRING under its `name`,
+// on every change and again on blur. The value is ABSENT when the editor never became ready (the
+// engine page is not bundled, failed, or timed out): the stored body must then stay exactly as it is
+// (user decision, 2026-09-26 — save everything but the body). A document is written exactly as the
+// editor produced it: never re-encoded (encodeRichContent is the VIEWER's; it rewrites media ids and
+// drops nodes the owner never touched).
+// Inside the platform source this import is a relative path, so node test runs resolve it; an app's
+// copy imports "@himalaya/wix-rich-content".
+import { parseRicosJson, RICH_CONTENT_LIMITS, type RicosDocument } from "@himalaya/wix-rich-content";
+
+export type EditorValue =
+  | { kind: "absent" }                                  // leave the stored body untouched
+  | { kind: "unchanged" }                               // byte-identical to the seed: nothing to write
+  | { kind: "doc"; doc: RicosDocument; json: string }   // write `doc`; `json` is the editor's own string
+  | { kind: "too_large" }                               // past the rich-content limits: save the rest, say why
+  | { kind: "invalid" };                                // not a Ricos document: refuse, write nothing
+
+function utf8Bytes(s: string): number {
+  let n = 0;
+  for (let i = 0; i < s.length; i++) {
+    const c = s.charCodeAt(i);
+    if (c < 0x80) n += 1;
+    else if (c < 0x800) n += 2;
+    else if (c >= 0xd800 && c <= 0xdbff && i + 1 < s.length) { n += 4; i++; }
+    else n += 3;
+  }
+  return n;
+}
+
+/** Every viewer renders a body past the rich-content limits as its fallback, so it is never written.
+ *  The viewer's order: bytes (before parsing), then depth, then the node count. */
+function overLimits(doc: RicosDocument): boolean {
+  let count = 0;
+  const work: Array<[unknown, number]> = doc.nodes.map((n) => [n, 1] as [unknown, number]);
+  while (work.length) {
+    const [n, depth] = work.pop()!;
+    if (!n || typeof n !== "object" || Array.isArray(n)) continue;
+    if (depth > RICH_CONTENT_LIMITS.maxDepth) return true;
+    if (++count > RICH_CONTENT_LIMITS.maxNodes) return true;
+    const kids = (n as { nodes?: unknown }).nodes;
+    if (Array.isArray(kids)) for (const k of kids) work.push([k, depth + 1]);
+  }
+  return false;
+}
+
+/** `raw` is `values[name]`; `seededJson` is the string the form published as the editor's seed. */
+export function editorValue(raw: unknown, seededJson: string): EditorValue {
+  if (typeof raw !== "string" || raw === "") return { kind: "absent" };
+  if (seededJson !== "" && raw === seededJson) return { kind: "unchanged" };
+  if (utf8Bytes(raw) > RICH_CONTENT_LIMITS.maxBytes) return { kind: "too_large" };
+  const doc = parseRicosJson(raw);
+  if (!doc) return { kind: "invalid" };
+  return overLimits(doc) ? { kind: "too_large" } : { kind: "doc", doc, json: raw };
+}

package/templates/community-club-owner/tier5-src/himi-owner-lite-post-form/index.ts

@@ -3,7 +3,10 @@
 // the post detail ("Edit"). On save it lands a draft; publish is on the detail
 // screen (himiOwnerLitePost.publish). Bound by buildForm ($service:himiOwnerLitePostForm.*).
 
-import { postBodyText, hasRichBody, plainPostBody, postCoverUrl } from "../_shared/owner-post-content.js";
+import { postBodyText, plainPostBody, postCoverUrl } from "../_shared/owner-post-content.js";
+import { editorValue } from "../_shared/owner-editor-value.js";
+import { parseRicosJson } from "@himalaya/wix-rich-content";
+import { ricosUploadService } from "@himalaya/wix-rich-content-editor";
 import { wixCall } from "@himalaya/wix-site-media";
 import { wixMediaUrl, WIX_DETAIL_IMAGE } from "../_shared/himi-store.js";
 import { defineService } from "@himalaya/state";
@@ -34,9 +37,21 @@ interface PostFormState {
   excerpt: string;
   body: string;
   richContent: WixRichContent | null;
-  bodyProtected: boolean;
-  bodyEditable: boolean;
-  bodyNote: string;
+  /** [rico] #3371 — the post's raw `richContent` as a JSON string: the RichContentEditor's seed
+   *  (`documentPath`). "" for a new post, and until a load lands (see the boot reset below).
+   *  Re-based to the saved document after each save. */
+  bodyJson: string;
+  /** The "Post details" sheet (excerpt + cover) is open. */
+  detailsOpen: boolean;
+  /** The editor's on_change fired since the body was last loaded or saved. The bag ALWAYS holds a
+   *  document once the editor is ready — the engine's own serialization of the seed, which is not
+   *  byte-equal to it — so only this says the owner actually edited the body. */
+  bodyDirty: boolean;
+  /** Edit mode, until `load` lands: the descriptor hides the editor, because a provisional editor
+   *  the owner typed into keeps that text when the real document arrives (the seed latch). */
+  bodyPending: boolean;
+  /** When a save last wrote the body (ms), so its own trailing on_change does not undo "Post updated.". */
+  bodySavedAt: number;
   coverUrl: string;
   originalCoverUrl: string;
   coverPreview: string;
@@ -88,6 +103,13 @@ function boolString(value: unknown, fallback: string): string {
   if (typeof value === "string") return value === "false" ? "false" : value === "true" ? "true" : fallback;
   return fallback;
 }
+/** What every load that publishes a document resets: the editor may show it, nothing is edited yet. */
+const BODY_LOADED = { bodyPending: false, bodyDirty: false, bodySavedAt: 0, detailsOpen: false } as const;
+/** How long after a body save its own debounced on_change may still arrive (the arm waits 500 ms). */
+const TRAILING_CHANGE_MS = 1500;
+const valueOf = (arg: unknown): string =>
+  String(typeof arg === "string" ? arg : (arg as { value?: unknown; text?: unknown } | undefined)?.value ?? (arg as { text?: unknown } | undefined)?.text ?? "");
+const docJson = (doc: unknown): string => (doc ? JSON.stringify(doc) : "");
 
 
 function shape(s: Partial<PostFormState>): PostFormState {
@@ -102,9 +124,11 @@ function shape(s: Partial<PostFormState>): PostFormState {
     excerpt: s.excerpt ?? "",
     body: s.body ?? "",
     richContent: s.richContent ?? null,
-    bodyProtected: hasRichBody(s.richContent),
-    bodyEditable: !hasRichBody(s.richContent),
-    bodyNote: hasRichBody(s.richContent) ? copyParam("ownerPostForm.richBodyNote", "Formatting and embedded media are preserved. Edit this body in your site dashboard; title, summary and cover can be changed here.") : "",
+    bodyJson: s.bodyJson ?? "",
+    detailsOpen: s.detailsOpen ?? false,
+    bodyDirty: s.bodyDirty ?? false,
+    bodyPending: s.bodyPending ?? false,
+    bodySavedAt: s.bodySavedAt ?? 0,
     coverUrl: s.coverUrl ?? "",
     originalCoverUrl: s.originalCoverUrl ?? "",
     coverPreview: wixMediaUrl(s.coverUrl ?? "", WIX_DETAIL_IMAGE),
@@ -133,12 +157,23 @@ function demoRefusal(s: Parameters<typeof shape>[0]): ReturnType<typeof shape> {
   return shape({ ...s, ...demoRefusalPatch(copyParam("ownerCommon.demoSaveNote", DEMO_SAVE_NOTE)) });
 }
 
+// [rico] #3371 — the RichContentEditor's image tool (the editor's upload contract). The component picks
+// and PUTs the bytes; this service mints the signed Wix Media URL with the worker's own wixApi
+// (@himalaya/wix-site-media rides the `wix_api` grant), so no token reaches the page. Registered
+// BEFORE the form's service on purpose: the worker test harnesses treat a bundle's
+// LAST defineService as its service.
+ricosUploadService("himiOwnerLitePostFormUploads");
+
 const svc = defineService<PostFormState, {
   load: (s: PostFormState, arg?: unknown) => Promise<PostFormState>;
   setCover: (s: PostFormState, arg?: unknown) => PostFormState;
+  setExcerpt: (s: PostFormState, arg?: unknown) => PostFormState;
+  detailsOpen: (s: PostFormState) => PostFormState;
+  detailsClose: (s: PostFormState) => PostFormState;
+  bodyChanged: (s: PostFormState, arg?: unknown) => PostFormState;
   submit: (s: PostFormState, values?: Record<string, unknown>) => Promise<PostFormState>;
 }>("himiOwnerLitePostForm", {
-  state: shape({ mode: startMode, id: initialInput.id ?? "" }),
+  state: shape({ mode: startMode, id: initialInput.id ?? "", bodyPending: startMode === "edit" }),
   actions: {
     load: async (s, arg) => {
       stashCopy(arg); // absorb the descriptor's onAppear copy-pack param
@@ -146,13 +181,13 @@ const svc = defineService<PostFormState, {
       // bakes no id/mode); the onAppear `id` param is the #570 suffixed-build
       // fallback. An id ⇒ edit; no id anywhere ⇒ the create shell.
       const id = navInputId() || idFrom(arg, s.id);
-      if (!id) return shape({ ...s, mode: "create", id: "", status: "idle", error: "", demoNote: isOwnerPreviewDemo() ? copyParam("ownerCommon.demoSaveNote", DEMO_SAVE_NOTE) : "" });
+      if (!id) return shape({ ...s, ...BODY_LOADED, mode: "create", id: "", bodyJson: "", status: "idle", error: "", demoNote: isOwnerPreviewDemo() ? copyParam("ownerCommon.demoSaveNote", DEMO_SAVE_NOTE) : "" });
       if (isOwnerPreviewDemo()) {
           const d = DEMO_POSTS.find((x) => x.id === id);
           if (d) {
             return shape({
               ...s, mode: "edit", id, heading: copyParam("ownerPostForm.headingEdit", "Edit post"),
-              title: d.title, excerpt: d.excerpt, body: d.body, isFeatured: "false",
+              ...BODY_LOADED, title: d.title, excerpt: d.excerpt, body: d.body, bodyJson: docJson(plainPostBody(d.body)), isFeatured: "false",
               status: "idle", error: "", savedMessage: "", demoNote: copyParam("ownerCommon.demoNote", DEMO_NOTE),
             });
           }
@@ -166,11 +201,13 @@ const svc = defineService<PostFormState, {
           ...(p.richContent ? { richContent: JSON.stringify(p.richContent) } : {}),
           coverUrl: postCoverUrl(p), isFeatured: p.isFeatured ? "true" : "false" });
         return shape({
-          ...s, mode: "edit", id, heading: copyParam("ownerPostForm.headingEdit", "Edit post"),
+          ...s, ...BODY_LOADED, mode: "edit", id, heading: copyParam("ownerPostForm.headingEdit", "Edit post"),
           title: (p as any).title ?? "",
           excerpt: (p as any).excerpt ?? "",
           body: postBodyText(p.richContent),
           richContent: p.richContent ?? null,
+          // The editor's seed is the fetched document, byte for byte: never encodeRichContent.
+          bodyJson: docJson(p.richContent),
           coverUrl: postCoverUrl(p), originalCoverUrl: postCoverUrl(p),
           isFeatured: (p as any).isFeatured ? "true" : "false",
           status: "idle", error: "", savedMessage: "",
@@ -180,11 +217,11 @@ const svc = defineService<PostFormState, {
         const cached = await cacheGet(id);
         if (cached) {
           return shape({
-            ...s, mode: "edit", id, heading: "Edit post",
+            ...s, ...BODY_LOADED, mode: "edit", id, heading: "Edit post",
             title: String(cached.title ?? cached.name ?? ""),
             excerpt: String(cached.excerpt ?? cached.summary ?? ""),
             body: String(cached.body ?? ""),
-            richContent: cached.richContent ? JSON.parse(String(cached.richContent)) : null,
+            ...((raw: string) => ({ richContent: raw ? JSON.parse(raw) : null, bodyJson: raw || docJson(plainPostBody(String(cached.body ?? ""))) }))(cached.richContent ? String(cached.richContent) : ""),
             coverUrl: String(cached.coverUrl ?? ""), originalCoverUrl: String(cached.coverUrl ?? ""),
             isFeatured: cached.isFeatured === "true" ? "true" : "false",
             status: "idle", error: "", savedMessage: "",
@@ -195,7 +232,7 @@ const svc = defineService<PostFormState, {
           if (d) {
             return shape({
               ...s, mode: "edit", id, heading: copyParam("ownerPostForm.headingEdit", "Edit post"),
-              title: d.title, excerpt: d.excerpt, body: d.body, isFeatured: "false",
+              ...BODY_LOADED, title: d.title, excerpt: d.excerpt, body: d.body, bodyJson: docJson(plainPostBody(d.body)), isFeatured: "false",
               status: "idle", error: "", savedMessage: "", demoNote: copyParam("ownerCommon.demoNote", DEMO_NOTE),
             });
           }
@@ -203,46 +240,85 @@ const svc = defineService<PostFormState, {
         return shape({ ...s, mode: "edit", id, status: "error", error: ownerLoadError(e) });
       }
     },
-    setCover: (s, arg) => {
-      const a = arg as { value?: unknown; text?: unknown } | undefined;
-      const coverUrl = String(typeof arg === "string" ? arg : a?.value ?? a?.text ?? "").trim();
-      return shape({ ...s, coverUrl, error: "" });
+    setCover: (s, arg) => shape({ ...s, coverUrl: valueOf(arg).trim(), error: "" }),
+    setExcerpt: (s, arg) => shape({ ...s, excerpt: valueOf(arg), error: "" }),
+    detailsOpen: (s) => shape({ ...s, detailsOpen: true }),
+    detailsClose: (s) => shape({ ...s, detailsOpen: false }),
+    // The editor's debounced `on_change` carries `args.dirty` only; the document stays in the form
+    // bag. A body edited after a save is no longer saved, so drop the stale confirmation — unless
+    // this is the trailing on_change of the very edit that save wrote.
+    bodyChanged: (s) => {
+      const trailing = s.status === "saved" && s.bodySavedAt > 0 && Date.now() - s.bodySavedAt < TRAILING_CHANGE_MS;
+      return shape({ ...s, bodyDirty: true, ...(trailing ? {} : { savedMessage: "", status: s.status === "saved" ? "idle" : s.status }) });
     },
     submit: async (s, values) => {
       if (isOwnerPreviewDemo() || s.demoNote) return demoRefusal(s);
       const v = values ?? {};
       const title = String(v.title ?? s.title).trim();
+      // Excerpt and cover live in the "Post details" sheet, outside the Form: worker state carries them.
       const excerpt = String(v.excerpt ?? s.excerpt).trim();
-      const body = String(v.body ?? s.body);
       const coverUrl = String(v.coverUrl ?? s.coverUrl).trim();
       // Queue replay carries the target explicitly; it may boot a fresh worker.
       const targetId = String(v.id ?? s.id);
       const editing = (v.mode ?? s.mode) === "edit" && !!targetId;
-      const preserveBody = editing && (typeof v.preserveBody === "string"
-        ? v.preserveBody === "true" : body === s.body);
+      // A queued write replays in a FRESH worker and says so with `preserveBody`. This bundle's items
+      // carry the editor's string as `richContentJson`; the pre-editor bundle's carry a plain `body`.
+      const replay = typeof v.preserveBody === "string";
       const coverChanged = typeof v.coverChanged === "string"
         ? v.coverChanged === "true" : coverUrl !== s.originalCoverUrl;
-      if (!preserveBody && s.bodyProtected) return shape({ ...s, status: "error", error: copyParam("ownerPostForm.richBodyError", "This body contains formatting or media. Edit it in your site dashboard to keep that content intact."), savedMessage: "" });
       if (coverChanged && coverUrl && !/^https:\/\/[^\s/]+(?:\/[^\s]*)?$/.test(coverUrl)) return shape({ ...s, status: "error", error: copyParam("ownerPostForm.coverInvalid", "Enter an HTTPS image URL."), savedMessage: "" });
       const isFeatured = boolString(v.isFeatured, s.isFeatured) === "true";
+      // Required fields are checked HERE, not only by the renderer: native Save does not gate on the
+      // RichContentEditor, and a queue replay skips the renderer entirely.
       if (!title) return shape({ ...s, status: "error", error: copyParam("ownerPostForm.titleRequired", "Title is required"), savedMessage: "" });
+
+      // The body to WRITE — the editor's own document, never re-encoded. null leaves the stored body as it is.
+      let richContent: WixRichContent | null = null;
+      let bodyRaw = "";
+      let bodyTooLarge = false;
+      if (replay) {
+        const queued = typeof v.richContentJson === "string" ? parseRicosJson(v.richContentJson) : null;
+        if (queued) { richContent = queued as unknown as WixRichContent; bodyRaw = String(v.richContentJson); }
+        else if (v.preserveBody === "false") { richContent = plainPostBody(String(v.body ?? "")); bodyRaw = docJson(richContent); }
+      } else {
+        // Only an edit the editor reported counts: before load lands the editor is hidden (a body
+        // here was typed into the provisional empty editor), and an untouched bag holds the engine's
+        // re-serialization of the seed, which must not be written back.
+        const ev = s.bodyPending || !s.bodyDirty ? { kind: "absent" as const } : editorValue(v.body, s.bodyJson);
+        if (ev.kind === "invalid") return shape({ ...s, status: "error", error: copyParam("ownerPostForm.bodyInvalid", "Couldn’t read the post body from the editor. Nothing was saved; try again."), savedMessage: "" });
+        if (ev.kind === "doc") { richContent = ev.doc as unknown as WixRichContent; bodyRaw = ev.json; }
+        // A body past the rich-content limits is not written (every viewer would show its
+        // fallback); the other fields still save, and the screen says why.
+        bodyTooLarge = ev.kind === "too_large";
+        // "absent": the editor never became ready — save the rest, leave the body (user decision 2026-09-26).
+        // "unchanged": the editor handed back exactly its seed — nothing to write.
+      }
+      const bodyEdited = richContent !== null;
       const draftPost: WixDraftPostWrite & { media?: Record<string, unknown> } = {
         title,
-        ...(!preserveBody ? { richContent: plainPostBody(body) } : {}),
+        ...(bodyEdited ? { richContent: richContent! } : {}),
         isFeatured,
         excerpt,
       };
 
       // Cache the full document so later offline metadata edits retain its body.
-      let richContent = preserveBody ? s.richContent : plainPostBody(body);
-      const localRow = (id: string): DbEntity => ({ id, name: title, title, excerpt, body, coverUrl, ...(richContent ? { richContent: JSON.stringify(richContent) } : {}), isFeatured: isFeatured ? "true" : "false", postStatus: "Draft", postStatusRaw: "DRAFT" });
+      let kept: WixRichContent | null = bodyEdited ? richContent : (replay ? null : s.richContent);
+      const localRow = (id: string): DbEntity => ({ id, name: title, title, excerpt, body: postBodyText(kept), coverUrl, ...(kept ? { richContent: JSON.stringify(kept) } : {}), isFeatured: isFeatured ? "true" : "false", postStatus: "Draft", postStatusRaw: "DRAFT" });
       const localId = editing ? targetId : `local-${Date.now()}`;
+      const savedState = (id: string, savedMessage: string) => shape({
+        ...s, mode: "edit", id, heading: copyParam("ownerPostForm.headingEdit", "Edit post"),
+        title, excerpt, body: postBodyText(kept), richContent: kept, bodyJson: bodyEdited ? bodyRaw : s.bodyJson,
+        bodyDirty: bodyEdited ? false : s.bodyDirty, bodySavedAt: bodyEdited ? Date.now() : 0,
+        coverUrl, originalCoverUrl: coverUrl, isFeatured: isFeatured ? "true" : "false",
+        status: "saved", savedMessage, savedId: id,
+        error: bodyTooLarge ? copyParam("ownerPostForm.bodyTooLarge", "The post body is too long to save, so it was left as it was. Your other changes were saved.") : "",
+      });
       try {
-        // A replay worker starts without the loaded document. Entity upserts
-        // replace whole rows, so retain the cached rich body before writing back.
-        if (preserveBody && !richContent) {
+        // A replay worker starts without the loaded document. Entity upserts replace whole rows, so
+        // retain the cached rich body before writing back.
+        if (!bodyEdited && !kept) {
           const cached = await cacheGet(targetId);
-          if (cached?.richContent) richContent = JSON.parse(String(cached.richContent));
+          if (cached?.richContent) kept = JSON.parse(String(cached.richContent));
         }
         // Blog cover images reference Media Manager file ids. The legacy editor
         // wrote coverImage.id; current Blog v3 expects media.wixMedia.image.id.
@@ -254,6 +330,8 @@ const svc = defineService<PostFormState, {
             draftPost.media = { wixMedia: { image: { id: result.file.id } }, displayed: true, custom: true };
           }
         }
+        // The draft PATCH has no field mask (`fieldsets` only shapes the response): leaving
+        // `richContent` out of `draftPost` is the whole omission.
         let id = targetId;
         if (editing) {
           await updateDraftPost(targetId, draftPost);
@@ -264,31 +342,23 @@ const svc = defineService<PostFormState, {
           if (id !== localId) await cacheDrop(localId);
         }
         await cachePut(localRow(id));
-        return shape({
-          ...s, mode: "edit", id, heading: copyParam("ownerPostForm.headingEdit", "Edit post"),
-          title, excerpt, body, richContent, coverUrl, originalCoverUrl: coverUrl, isFeatured: isFeatured ? "true" : "false",
-          status: "saved", error: "",
-          savedMessage: editing
-            ? copyParam("ownerPostForm.updatedMessage", "Post updated.")
-            : copyParam("ownerPostForm.createdMessage", "Draft created."),
-          savedId: id,
-        });
+        return savedState(id, editing ? copyParam("ownerPostForm.updatedMessage", "Post updated.") : copyParam("ownerPostForm.createdMessage", "Draft created."));
       } catch (e) {
         if (shouldQueueOwnerWrite(e)) {
           // Demo / web-preview (no owner bridge; the record came from demo sample
           // data, marked by demoNote): a queued write could never replay, so answer
           // with the demo save note instead of the real-offline write-behind.
           if (s.demoNote) return demoRefusal(s);
-          // Real device offline: cache and queue the edit for reconnect.
+          // Real device offline: cache and queue the edit for reconnect. `preserveBody` stays
+          // "true" even for a body edit, so a bundle rolled back past this change keeps the stored
+          // body rather than flattening it to text. This bundle replays `richContentJson`.
           await cachePut(localRow(localId));
-          await queueWrite("tier5.himiOwnerLitePostForm.submit", { id: targetId, title, excerpt, body, coverUrl, coverChanged: String(coverChanged), preserveBody: String(preserveBody), isFeatured: String(isFeatured), mode: editing ? "edit" : "create" });
-          return shape({
-            ...s, mode: "edit", id: localId, heading: copyParam("ownerPostForm.headingEdit", "Edit post"),
-            title, excerpt, body, richContent, coverUrl, originalCoverUrl: coverUrl, isFeatured: isFeatured ? "true" : "false",
-            status: "saved", error: "",
-            savedMessage: copyParam("ownerPostForm.savedOffline", "Saved offline — will sync when you reconnect."),
-            savedId: localId,
+          await queueWrite("tier5.himiOwnerLitePostForm.submit", {
+            id: targetId, title, excerpt, coverUrl, coverChanged: String(coverChanged), preserveBody: "true",
+            body: postBodyText(kept), ...(bodyEdited ? { richContentJson: bodyRaw } : {}),
+            isFeatured: String(isFeatured), mode: editing ? "edit" : "create",
           });
+          return savedState(localId, copyParam("ownerPostForm.savedOffline", "Saved offline — will sync when you reconnect."));
         }
         return shape({ ...s, status: "error", error: ownerLoadError(e), savedMessage: "" });
       }
@@ -296,4 +366,20 @@ const svc = defineService<PostFormState, {
   },
 });
 
+// [rico] #3371 — adopter contract (#3368's review): the editor seeds ONCE, from the first
+// document `bodyJson` holds. A cold boot hydrates this service from its last persisted snapshot, so
+// that first value would be the document as it was when this screen last ran — and a Save after
+// typing would write it over whatever the post holds now. Blank the hydrated seed before anything
+// renders: the editor stays provisional (writes nothing) until `load` publishes the fresh document.
+// In place, at boot, because no action has run yet; the state object is the runtime's own merge.
+{
+  const booted = (svc as { getState?: () => Partial<PostFormState> | undefined }).getState?.();
+  if (booted && typeof booted === "object") {
+    if (booted.bodyJson) booted.bodyJson = "";
+    // Nor does it carry this run's UI over: the editor waits for this run's load, the sheet is shut.
+    booted.bodyPending = startMode === "edit";
+    booted.detailsOpen = false;
+  }
+}
+
 export { svc };