@wix/himalaya-cli 0.1172.0 → 0.1174.0

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

@@ -17,6 +17,10 @@ import {
 } from "@himalaya/wix-stores";
 import { get as dbGet, upsert as dbUpsert, remove as dbRemove, enqueue as dbEnqueue, type DbEntity } from "../_shared/owner-local-db.js";
 import { htmlIsTrivial, htmlPreviewText } from "../_shared/owner-rich-guard.js";
+import { postBodyText, plainPostBody } from "../_shared/owner-post-content.js";
+import { editorSubmitValue, queuedDocument, editorChanged, cachedRichVerdict, resetHydratedEditor } from "../_shared/owner-editor-value.js";
+import { parseRicosJson } from "@himalaya/wix-rich-content";
+import { ricosUploadService } from "@himalaya/wix-rich-content-editor";
 import { ownerLoadError, isBridgeUnavailable, isOwnerPreviewDemo, shouldQueueOwnerWrite } from "../_shared/owner-load-error.js";
 import { DEMO_PRODUCTS, DEMO_NOTE, DEMO_SAVE_NOTE, demoRefusalPatch, editablePrice } from "../_shared/owner-preview-demo.js";
 import { stashCopy, copyParam } from "../_shared/himi-copy.js";
@@ -45,12 +49,27 @@ interface ProductFormState {
   name: string;
   price: string;
   sku: string;
+  /** The description as text: the plain field's value, the locked preview, and the cached row's mirror. */
   description: string;
-  /** [rico] #3363 — the description as loaded (or last saved). A save sends `description` only
-   *  when the submitted value differs from it, so an untouched body is never re-written. */
+  /** The description as loaded (or last saved). The plain field sends `description` only when the
+   *  submitted value differs from it, so an untouched body is never re-written. */
   originalDescription: string;
-  /** A rich HTML description (more than one bare `<p>`) the plain field would flatten: it loads
-   *  locked, the descriptor shows `description` as a preview + `descriptionNote`, and an edit is refused. */
+  /** How THIS record's description is edited:
+   *  "editor" — the RichContentEditor, seeded with `descriptionJson`: a Catalog-V3 product (its Ricos
+   *             document, or trivial HTML as paragraphs), and sample data;
+   *  "plain"  — the plain text field: a new product, a V1 product with trivial HTML;
+   *  "locked" — neither: V1 rich HTML, or a V3 product whose Ricos document did not come back. */
+  descriptionMode: "editor" | "plain" | "locked";
+  /** The V3 Ricos description as a JSON string: the editor's seed ("" when none, and until this run's
+   *  load lands — see the boot reset below). Re-based to the saved document after a save. */
+  descriptionJson: string;
+  descriptionFieldHidden: boolean;   // the plain text field (bag key `descriptionText`)
+  descriptionEditorHidden: boolean;  // the RichContentEditor (bag key `description`)
+  /** The editor gate (`EditorGate` in _shared/owner-editor-value.ts): edited since load/save, and
+   *  hidden until this run's load lands. */
+  descriptionDirty: boolean;
+  descriptionPending: boolean;
+  /** Derived from the mode: "locked" shows the preview + `descriptionNote`, and refuses an edit. */
   descriptionProtected: boolean;
   descriptionEditable: boolean;
   descriptionNote: string;
@@ -111,10 +130,15 @@ function priceOf(p: WixProduct): string {
 }
 
 
+/** What every load that publishes a description resets: the editor may show it, nothing is edited yet. */
+const DESCRIPTION_LOADED = { descriptionPending: false, descriptionDirty: false } as const;
+const docJson = (doc: unknown): string => (doc ? JSON.stringify(doc) : "");
+
 function shape(s: Partial<ProductFormState>): ProductFormState {
   const mode: Mode = s.mode ?? "create";
   const id = typeof s.id === "string" ? s.id : "";
   const savedId = typeof s.savedId === "string" ? s.savedId : id;
+  const dMode = s.descriptionMode ?? (mode === "edit" ? "editor" : "plain");
   return {
     mode,
     id,
@@ -124,9 +148,15 @@ function shape(s: Partial<ProductFormState>): ProductFormState {
     sku: s.sku ?? "",
     description: s.description ?? "",
     originalDescription: s.originalDescription ?? s.description ?? "",
-    descriptionProtected: s.descriptionProtected ?? false,
-    descriptionEditable: !(s.descriptionProtected ?? false),
-    descriptionNote: s.descriptionProtected ? copyParam("ownerProductForm.richDescriptionNote", "This description has formatting or media. Edit it in your site dashboard to keep that content intact; name, price and SKU can be changed here.") : "",
+    descriptionMode: dMode,
+    descriptionJson: s.descriptionJson ?? "",
+    descriptionFieldHidden: dMode !== "plain",
+    descriptionEditorHidden: dMode !== "editor",
+    descriptionDirty: s.descriptionDirty ?? false,
+    descriptionPending: s.descriptionPending ?? false,
+    descriptionProtected: dMode === "locked",
+    descriptionEditable: dMode !== "locked",
+    descriptionNote: dMode === "locked" ? copyParam("ownerProductForm.richDescriptionNote", "This description has formatting or media. Edit it in your site dashboard to keep that content intact; name, price and SKU can be changed here.") : "",
     visible: s.visible ?? "true",
     status: s.status ?? "idle",
     error: s.error ?? "",
@@ -151,12 +181,19 @@ function demoRefusal(s: Parameters<typeof shape>[0]): ReturnType<typeof shape> {
   return shape({ ...s, ...demoRefusalPatch(copyParam("ownerCommon.demoSaveNote", DEMO_SAVE_NOTE)) });
 }
 
+// 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, 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("himiOwnerLiteProductFormUploads");
+
 const svc = defineService<ProductFormState, {
   load: (s: ProductFormState, arg?: unknown) => Promise<ProductFormState>;
+  descriptionChanged: (s: ProductFormState, arg?: unknown) => ProductFormState;
   submit: (s: ProductFormState, values?: Record<string, unknown>) => Promise<ProductFormState>;
   remove: (s: ProductFormState) => Promise<ProductFormState>;
 }>("himiOwnerLiteProductForm", {
-  state: shape({ mode: startMode, id: initialInput.id ?? "" }),
+  state: shape({ mode: startMode, id: initialInput.id ?? "", descriptionPending: startMode === "edit" }),
   actions: {
     load: async (s, arg) => {
       stashCopy(arg); // absorb the descriptor's onAppear copy-pack param
@@ -164,13 +201,14 @@ const svc = defineService<ProductFormState, {
       // 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, ...DESCRIPTION_LOADED, mode: "create", id: "", descriptionMode: "plain", descriptionJson: "", status: "idle", error: "", demoNote: isOwnerPreviewDemo() ? copyParam("ownerCommon.demoSaveNote", DEMO_SAVE_NOTE) : "" });
       if (isOwnerPreviewDemo()) {
           const d = DEMO_PRODUCTS.find((p) => p.id === id);
           if (d) {
             return shape({
               ...s, mode: "edit", id, heading: copyParam("ownerProductForm.headingEdit", "Edit product"),
               name: d.name, price: editablePrice(d.price), sku: d.sku, description: d.description,
+              ...DESCRIPTION_LOADED, descriptionMode: "editor", descriptionJson: docJson(plainPostBody(d.description)),
               visible: d.visible ? "true" : "false",
               status: "idle", error: "", savedMessage: "", demoNote: copyParam("ownerCommon.demoNote", DEMO_NOTE),
             });
@@ -179,7 +217,9 @@ const svc = defineService<ProductFormState, {
         return shape({ ...s, status: "error", error: "Sample item not found." });
       }
       try {
-        const p = (await getProduct(id)).product as WixProduct;
+        // `richDescription` (Catalog V3): the Ricos description beside the HTML one. An SDK without the
+        // option ignores it, and the key is absent: the form then keeps the plain/locked split.
+        const p = (await (getProduct as (id: string, opts?: { richDescription?: boolean }) => ReturnType<typeof getProduct>)(id, { richDescription: true })).product as WixProduct;
         if (!p || !(p as any).id) return shape({ ...s, mode: "edit", id, status: "error", error: copyParam("ownerProductForm.errorNotFound", "Product not found") });
         return shape({
           ...s,
@@ -189,7 +229,19 @@ const svc = defineService<ProductFormState, {
           name: (p as any).name ?? "",
           price: priceOf(p),
           sku: (p as any).sku ?? "",
-          ...((html: string) => ({ description: htmlPreviewText(html), originalDescription: htmlPreviewText(html), descriptionProtected: !htmlIsTrivial(html) }))(String((p as any).description ?? "")),
+          ...((html: string, rich: unknown) => {
+            // `richDescription` is present only on a Catalog V3 site. V3 is edited in the RichContentEditor;
+            // a V3 product whose Ricos document did not come back is edited only when its HTML is trivial
+            // (seeded as paragraphs), else locked — fail closed. V1 keeps the plain/locked split: the
+            // editor writes Ricos, and a V1 description is HTML.
+            const doc = rich === undefined || rich === null ? null : parseRicosJson(rich);
+            const hasDoc = !!doc && doc.nodes.length > 0;
+            const text = htmlPreviewText(html);
+            const descriptionMode = rich === undefined ? (htmlIsTrivial(html) ? "plain" as const : "locked" as const)
+              : hasDoc || htmlIsTrivial(html) ? "editor" as const : "locked" as const;
+            const descriptionJson = descriptionMode !== "editor" ? "" : hasDoc ? JSON.stringify(rich) : text ? docJson(plainPostBody(text)) : "";
+            return { ...DESCRIPTION_LOADED, description: text, originalDescription: text, descriptionMode, descriptionJson };
+          })(String((p as any).description ?? ""), (p as { richDescription?: unknown }).richDescription),
           visible: (p as any).visible !== false ? "true" : "false",
           status: "idle",
           error: "",
@@ -202,8 +254,11 @@ const svc = defineService<ProductFormState, {
           return shape({
             ...s, mode: "edit", id, heading: "Edit product",
             name: String(cached.name ?? ""), price: editablePrice(String(cached.price ?? "")), sku: String(cached.sku ?? ""),
-            // An older cached row carries no verdict, so it stays locked: fail closed.
-            description: String(cached.description ?? ""), originalDescription: String(cached.description ?? ""), descriptionProtected: cached.descriptionProtected !== "false",
+            description: String(cached.description ?? ""), originalDescription: String(cached.description ?? ""), ...DESCRIPTION_LOADED,
+            // A row cached with its document reopens in the editor. An older row has none, so its verdict
+            // decides: plain when it was plain, else locked (it carries no verdict either: fail closed).
+            ...(cached.descriptionJson ? { descriptionMode: "editor" as const, descriptionJson: String(cached.descriptionJson) }
+              : { descriptionMode: cached.descriptionProtected === "false" ? "plain" as const : "locked" as const, descriptionJson: "" }),
             visible: cached.visible === "false" ? "false" : "true",
             status: "idle", error: "", savedMessage: "",
           });
@@ -214,6 +269,7 @@ const svc = defineService<ProductFormState, {
             return shape({
               ...s, mode: "edit", id, heading: copyParam("ownerProductForm.headingEdit", "Edit product"),
               name: d.name, price: editablePrice(d.price), sku: d.sku, description: d.description,
+              ...DESCRIPTION_LOADED, descriptionMode: "editor", descriptionJson: docJson(plainPostBody(d.description)),
               visible: d.visible ? "true" : "false",
               status: "idle", error: "", savedMessage: "", demoNote: copyParam("ownerCommon.demoNote", DEMO_NOTE),
             });
@@ -222,6 +278,8 @@ const svc = defineService<ProductFormState, {
         return shape({ ...s, mode: "edit", id, status: "error", error: ownerLoadError(e) });
       }
     },
+    // The editor's on_change carries `args.dirty` only; the document stays in the form bag.
+    descriptionChanged: (s) => shape({ ...s, descriptionDirty: true, ...editorChanged(s) }),
     submit: async (s, values) => {
       if (isOwnerPreviewDemo() || s.demoNote) return demoRefusal(s);
       const v = values ?? {};
@@ -230,10 +288,34 @@ const svc = defineService<ProductFormState, {
       // "12,50" (comma-decimal keypad) is accepted and written as 12.50.
       const price = editablePrice(rawPrice);
       const sku = String(v.sku ?? s.sku).trim();
-      const description = String(v.description ?? s.description).trim();
-      // A queue replay boots a FRESH worker (empty baseline), so it carries the original verdict.
-      const descriptionEdited = typeof v.descriptionEdited === "string" ? v.descriptionEdited === "true" : description !== s.originalDescription.trim();
-      if (descriptionEdited && s.descriptionProtected) return shape({ ...s, status: "error", savedMessage: "", error: copyParam("ownerProductForm.richDescriptionError", "This description has formatting or media. Edit it in your site dashboard to keep that content intact.") });
+      // The description, per record mode. A queue replay (a FRESH worker) says so with
+      // `descriptionEdited`; this bundle's V3 editor items add the document as `descriptionJson`.
+      const replay = typeof v.descriptionEdited === "string";
+      let richDescription: { nodes: unknown[] } | null = null;   // the V3 Ricos description to WRITE
+      let docRaw = "";
+      let tooLarge = false;
+      let description = s.description;                            // the plain text (V1 / create), or the mirror
+      let descriptionEdited = false;                              // write the PLAIN description (V1 / create)
+      if (replay) {
+        const queued = queuedDocument(v.descriptionJson);
+        // A queued document that no longer reads (or is past the limits) writes NOTHING, and says so.
+        if (queued.kind === "invalid" || queued.kind === "too_large") return shape({ ...s, status: "error", savedMessage: "", error: copyParam("ownerProductForm.queuedDescriptionError", "The description saved offline could not be read, so nothing was written. Edit it again.") });
+        if (queued.kind === "doc") { richDescription = queued.doc as { nodes: unknown[] }; docRaw = queued.json; }
+        else if (v.descriptionEdited === "true") { description = String(v.description ?? "").trim(); descriptionEdited = true; }
+      } else if (s.descriptionMode === "editor") {
+        // Only an edit the editor reported counts (EditorGate). Absent (the editor never became ready):
+        // save the rest and leave the description as it is.
+        const ev = editorSubmitValue(v.description, s.descriptionJson, { pending: s.descriptionPending, dirty: s.descriptionDirty });
+        if (ev.kind === "invalid") return shape({ ...s, status: "error", savedMessage: "", error: copyParam("ownerProductForm.editorReadError", "Couldn’t read the description from the editor. Nothing was saved; try again.") });
+        if (ev.kind === "doc") { richDescription = ev.doc as { nodes: unknown[] }; docRaw = ev.json; }
+        tooLarge = ev.kind === "too_large";
+      } else {
+        // Plain or locked: the plain text field, under its own bag key.
+        description = String(v.descriptionText ?? s.description).trim();
+        descriptionEdited = description !== s.originalDescription.trim();
+        if (descriptionEdited && s.descriptionMode === "locked") return shape({ ...s, status: "error", savedMessage: "", error: copyParam("ownerProductForm.richDescriptionError", "This description has formatting or media. Edit it in your site dashboard to keep that content intact.") });
+      }
+      if (richDescription) description = postBodyText(richDescription as never);
       const visible = boolString(v.visible, s.visible) === "true";
       if (!name) return shape({ ...s, status: "error", error: copyParam("ownerProductForm.nameRequired", "Name is required"), savedMessage: "" });
       const priceNum = Number(price);
@@ -244,23 +326,41 @@ const svc = defineService<ProductFormState, {
         return shape({ ...s, name, price, sku, description, visible: visible ? "true" : "false", status: "error", error: copyParam("ownerProductForm.priceInvalid", "Enter a price of 0 or more."), savedMessage: "" });
       }
 
-      const write: WixProductWrite = {
+      // A local structural type for `richDescription`: templates compile against the PUBLISHED SDK.
+      const write: WixProductWrite & { richDescription?: { nodes: unknown[] } } = {
         name,
         priceData: { price: priceNum, currency: CURRENCY },
         visible,
         ...(sku ? { sku } : {}),
         ...(descriptionEdited ? { description } : {}),
+        ...(richDescription ? { richDescription } : {}),
         ...(s.mode === "edit" && s.id ? {} : { productType: "physical" }),
       };
+      // The document the record now holds, when known: an offline reopen seeds the editor with it.
+      const loadedJson = s.descriptionMode === "editor" && !s.descriptionPending ? s.descriptionJson : "";
+      const heldJson = docRaw || loadedJson;
+      // The cache's verdict comes from the CONTENT (a rolled-back bundle reads it to decide whether its
+      // plain field may overwrite the body): from the document when known; plain only when the record
+      // loaded as plain, or a new product's plain text. Before load lands it stays protected.
+      const heldDoc = richDescription ?? (loadedJson ? parseRicosJson(loadedJson) : null);
+      const knownPlain = s.descriptionMode === "plain" || (s.descriptionMode === "editor" && !s.descriptionPending && s.descriptionJson === "");
+      const descriptionProtected = cachedRichVerdict(heldDoc as never, knownPlain);
 
       // Optimistic local write — the list repaints from cache immediately (offline or not).
-      const localRow = (id: string): DbEntity => ({ id, name, price, sku, description, descriptionProtected: s.descriptionProtected ? "true" : "false", visible: visible ? "true" : "false", statusLabel: visible ? "Visible" : "Hidden" });
+      const localRow = (id: string): DbEntity => ({ id, name, price, sku, description, descriptionProtected, ...(heldJson ? { descriptionJson: heldJson } : {}), visible: visible ? "true" : "false", statusLabel: visible ? "Visible" : "Hidden" });
+      const wrote = richDescription !== null;
+      const savedDescription = {
+        description, originalDescription: descriptionEdited || wrote ? description : s.originalDescription,
+        ...(docRaw ? { descriptionJson: docRaw } : {}),
+        descriptionDirty: wrote ? false : s.descriptionDirty,
+        error: tooLarge ? copyParam("ownerProductForm.descriptionTooLarge", "The description is too long to save, so it was left as it was. Your other changes were saved.") : "",
+      };
       const localId = s.mode === "edit" && s.id ? s.id : `local-${Date.now()}`;
       await cachePut(localRow(localId));
       try {
         let id = s.id;
         if (s.mode === "edit" && s.id) {
-          await updateProduct(s.id, write);
+          await updateProduct(s.id, write as WixProductWrite);
         } else {
           const r = await createProduct(write);
           id = r.product?.id || localId;
@@ -275,11 +375,9 @@ const svc = defineService<ProductFormState, {
           name,
           price,
           sku,
-          description,
-          originalDescription: descriptionEdited ? description : s.originalDescription,
           visible: visible ? "true" : "false",
           status: "saved",
-          error: "",
+          ...savedDescription,
           savedMessage: copyParam("ownerProductForm.savedMessage", "Product saved."),
           savedId: id,
         });
@@ -291,11 +389,13 @@ const svc = defineService<ProductFormState, {
           if (s.demoNote) return demoRefusal(s);
           // Real device offline: the optimistic cache row already shows; queue the
           // write to replay (WriteQueue, idempotent) when connectivity returns.
-          await queueWrite("tier5.himiOwnerLiteProductForm.submit", { id: s.id, name, price, sku, description, descriptionEdited: String(descriptionEdited), visible: String(visible), mode: s.mode });
+          // A document rides as `descriptionJson` with descriptionEdited "false", so a bundle rolled back
+          // past this change leaves the description rather than flattening it to text.
+          await queueWrite("tier5.himiOwnerLiteProductForm.submit", { id: s.id, name, price, sku, description, visible: String(visible), mode: s.mode,
+            ...(docRaw ? { descriptionJson: docRaw, descriptionEdited: "false" } : { descriptionEdited: String(descriptionEdited) }) });
           return shape({
-            ...s, mode: "edit", id: localId, name, price, sku, description,
-            originalDescription: descriptionEdited ? description : s.originalDescription,
-            visible: visible ? "true" : "false", status: "saved", error: "",
+            ...s, mode: "edit", id: localId, name, price, sku, ...savedDescription,
+            visible: visible ? "true" : "false", status: "saved",
             savedMessage: copyParam("ownerProductForm.savedOffline", "Saved offline — will sync when you reconnect."),
             savedId: localId,
           });
@@ -323,4 +423,7 @@ const svc = defineService<ProductFormState, {
   },
 });
 
+// Adopter contract: the editor seeds once, so a cold boot must not seed it with the last run's document.
+resetHydratedEditor(svc, { json: "descriptionJson", pending: "descriptionPending", dirty: "descriptionDirty" }, startMode === "edit");
+
 export { svc };

package/templates/events-meetups-owner/dev/index.ts

@@ -67444,7 +67444,7 @@ const SCREENS = runtimeSetting({
                                   "onChange": {
                                     "actionId": "tier5.himiOwnerLitePostForm.bodyChanged"
                                   },
-                                  "minHeight": 360,
+                                  "minHeight": 240,
                                   "fallback": {
                                     "id": "post_form.body_unavailable",
                                     "body": {
@@ -67860,7 +67860,7 @@ const TEMPLATED: { pattern: string; display: string; liveSeed?: LiveSeed; static
                         "package": "himalaya",
                         "type": "FormField",
                         "props": {
-                          "id": "description",
+                          "id": "descriptionText",
                           "label": "Description",
                           "kind": "text",
                           "text": {
@@ -67873,7 +67873,90 @@ const TEMPLATED: { pattern: string; display: string; liveSeed?: LiveSeed; static
                         }
                       },
                       "modifiers": {
-                        "hiddenPath": "$service:himiOwnerLiteEventForm.descriptionProtected"
+                        "hiddenPath": "$service:himiOwnerLiteEventForm.descriptionFieldHidden"
+                      }
+                    },
+                    {
+                      "id": "event_form.description_slot",
+                      "body": {
+                        "package": "himalaya",
+                        "type": "VStack",
+                        "props": {
+                          "spacing": 6,
+                          "alignment": "leading",
+                          "children": [
+                            {
+                              "id": "",
+                              "body": {
+                                "package": "himalaya",
+                                "type": "Text",
+                                "props": {
+                                  "text": "Description",
+                                  "style": "bodyEmphasis"
+                                }
+                              }
+                            },
+                            {
+                              "id": "event_description_editor",
+                              "body": {
+                                "package": "himalaya",
+                                "type": "RichContentEditor",
+                                "props": {
+                                  "name": "description",
+                                  "documentPath": "$service:himiOwnerLiteEventForm.descriptionJson",
+                                  "placeholder": "What attendees should expect",
+                                  "uploadService": "himiOwnerLiteEventFormUploads",
+                                  "onChange": {
+                                    "actionId": "tier5.himiOwnerLiteEventForm.descriptionChanged"
+                                  },
+                                  "minHeight": 200,
+                                  "fallback": {
+                                    "id": "event_form.description_unavailable",
+                                    "body": {
+                                      "package": "himalaya",
+                                      "type": "VStack",
+                                      "props": {
+                                        "spacing": 4,
+                                        "alignment": "leading",
+                                        "children": [
+                                          {
+                                            "id": "",
+                                            "body": {
+                                              "package": "himalaya",
+                                              "type": "Text",
+                                              "props": {
+                                                "text": "Editor unavailable",
+                                                "style": "title3"
+                                              }
+                                            }
+                                          },
+                                          {
+                                            "id": "",
+                                            "body": {
+                                              "package": "himalaya",
+                                              "type": "Text",
+                                              "props": {
+                                                "text": "The description can’t be edited here right now. The title still saves, and the description stays as it is.",
+                                                "style": "footnote",
+                                                "color": "textSecondary"
+                                              }
+                                            }
+                                          }
+                                        ]
+                                      }
+                                    }
+                                  }
+                                }
+                              },
+                              "modifiers": {
+                                "hiddenPath": "$service:himiOwnerLiteEventForm.descriptionPending"
+                              }
+                            }
+                          ]
+                        }
+                      },
+                      "modifiers": {
+                        "hiddenPath": "$service:himiOwnerLiteEventForm.descriptionEditorHidden"
                       }
                     }
                   ],
@@ -68147,7 +68230,7 @@ const TEMPLATED: { pattern: string; display: string; liveSeed?: LiveSeed; static
                                   "onChange": {
                                     "actionId": "tier5.himiOwnerLitePostForm.bodyChanged"
                                   },
-                                  "minHeight": 360,
+                                  "minHeight": 240,
                                   "fallback": {
                                     "id": "post_form.body_unavailable",
                                     "body": {

package/templates/events-meetups-owner/tier5-src/_shared/owner-editor-value.ts

@@ -8,7 +8,7 @@
 // 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";
+import { parseRicosJson, isPlainRicos, RICH_CONTENT_LIMITS, type RicosDocument } from "@himalaya/wix-rich-content";
 
 export type EditorValue =
   | { kind: "absent" }                                  // leave the stored body untouched
@@ -45,12 +45,78 @@ function overLimits(doc: RicosDocument): boolean {
   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" };
+const TEXT_ONLY = new Set(["PARAGRAPH", "TEXT", "HEADING", "BULLETED_LIST", "ORDERED_LIST", "LIST_ITEM", "BLOCKQUOTE", "CODE_BLOCK"]);
+/** No visible text and no non-text node (an image, a divider, an embed…): an empty body. */
+export function isEmptyDocument(doc: RicosDocument): boolean {
+  const empty = (nodes: RicosDocument["nodes"] | undefined): boolean => (nodes ?? []).every((n) =>
+    TEXT_ONLY.has(String(n?.type)) && !String(n.textData?.text ?? "").trim() && empty(n.nodes));
+  return empty(doc.nodes);
+}
+
+/** A Ricos JSON string checked as every viewer would: the limits first, then the shape. */
+function checkedDocument(raw: string): EditorValue {
   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 };
 }
+
+/** `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" };
+  const checked = checkedDocument(raw);
+  // An empty editor over no body (a record that had none) writes nothing, rather than an empty document.
+  if (checked.kind === "doc" && seededJson === "" && isEmptyDocument(checked.doc)) return { kind: "unchanged" };
+  return checked;
+}
+
+// ── The per-field editor machinery every owner form shares (post body, event / product description,
+// FAQ answer). Each form keeps `<key>Json` (the seed), `<key>Pending` and `<key>Dirty` in its state.
+
+/** `<key>Pending`: until this run's load lands, the descriptor hides the editor — it seeds ONCE, so a
+ *  provisional editor the owner typed into would keep that text over the real document.
+ *  `<key>Dirty`: the editor's on_change fired since the field was loaded or saved. Once ready the bag
+ *  ALWAYS holds a document — the engine's own re-serialization of the seed, not byte-equal to it — so
+ *  only this says the owner edited the field. Every arm fires a pending on_change before it releases a
+ *  Form submit, so an edit made inside the debounce window is reported before the submit reads it. */
+export interface EditorGate { pending: boolean; dirty: boolean }
+
+/** What a live submit does with `values[name]`: only an edit the editor reported counts. */
+export function editorSubmitValue(raw: unknown, seededJson: string, gate: EditorGate): EditorValue {
+  return gate.pending || !gate.dirty ? { kind: "absent" } : editorValue(raw, seededJson);
+}
+
+/** A queued write's document. A replay runs in a FRESH worker with no editor, so the string is checked
+ *  again (shape and limits); "absent" when the item carries none. Never "unchanged": it was an edit. */
+export function queuedDocument(raw: unknown): EditorValue {
+  return typeof raw === "string" && raw !== "" ? checkedDocument(raw) : { kind: "absent" };
+}
+
+/** The editor's on_change: the field is now edited, and a confirmation of an earlier save is stale.
+ *  No timing window: an arm fires the pending on_change BEFORE it releases a submit, so any on_change
+ *  that arrives after a save carries an edit that save did not write. */
+export function editorChanged<S extends { status: string; savedMessage: string }>(s: S): Pick<S, "status" | "savedMessage"> {
+  return { status: s.status === "saved" ? "idle" : s.status, savedMessage: "" };
+}
+
+/** The offline cache's verdict on the stored body (`<key>Protected`): rich unless KNOWN plain. From the
+ *  document when the form knows it; otherwise plain only when the record was loaded as plain. A bundle
+ *  rolled back past the editor reads this flag to decide whether its plain field may overwrite the body. */
+export function cachedRichVerdict(doc: RicosDocument | null, knownPlain: boolean): "true" | "false" {
+  if (doc) return isPlainRicos(doc) ? "false" : "true";
+  return knownPlain ? "false" : "true";
+}
+
+/** Cold boot: the runtime lays this service's last persisted snapshot over its declared state, so the
+ *  editor's first seed would be the document as it was when the screen last ran — and a Save after
+ *  typing would write it over whatever the record holds now. Blank the hydrated seed and reset the gate
+ *  before anything renders, in place (no action has run yet). `extra` resets further UI state. */
+export function resetHydratedEditor(svc: unknown, keys: { json: string; pending: string; dirty: string }, pendingAtBoot: boolean, extra: Record<string, unknown> = {}): void {
+  const booted = (svc as { getState?: () => Record<string, unknown> | undefined }).getState?.();
+  if (!booted || typeof booted !== "object") return;
+  if (booted[keys.json]) booted[keys.json] = "";
+  booted[keys.pending] = pendingAtBoot;
+  booted[keys.dirty] = false;
+  Object.assign(booted, extra);
+}