@aglyn/besigner-ui 1.0.0-beta.143

package/src/lib/drafts/besigner-draft-store.js

@@ -0,0 +1,125 @@
+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 { pruneLocalStorageByAge, writeLocalStorageWithBudget } from "@aglyn/aglyn";
+/**
+ * Local crash net for unsaved besigner work (AGL-1256).
+ *
+ * ## What this is not
+ *
+ * It is deliberately **not** version history. Versioning is a paid feature
+ * (`versioning`, Pro and above): named snapshots of the *saved* document that
+ * you can list, reopen, publish and schedule. A store of dated snapshots in
+ * the browser is one careless design decision away from being a free
+ * imitation of exactly that, so three rules hold the line, and every one of
+ * them is load-bearing rather than incidental:
+ *
+ * 1. **One draft per document, latest wins.** No list, no names, no history.
+ *    There is nothing to browse and nothing to choose between.
+ * 2. **A draft only ever holds work that was never saved.** It is cleared the
+ *    moment a save succeeds, so it can never act as "restore the document to
+ *    how it was before" — that is rollback, and rollback is what versions
+ *    sell. The only thing a draft can give back is the thing that would
+ *    otherwise be gone forever.
+ * 3. **A draft expires.** {@link DRAFT_MAX_AGE_MS} keeps it a recovery window
+ *    rather than an archive.
+ *
+ * Because of those, drafts are ungated: this is data-loss prevention, and
+ * gating it would mean a free org's crash still costs them their afternoon.
+ * A free org gets back exactly what they had in the canvas and not one
+ * revision more.
+ */ /** Every key this module owns; also the set it may evict from. */ export const BESIGNER_DRAFT_KEY_PREFIX = 'aglyn:draft:';
+/**
+ * A week. Long enough to cover "my laptop died on Friday", short enough that
+ * the store never becomes an accumulating pile of restore points.
+ */ export const DRAFT_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000;
+export function besignerDraftKey(ids) {
+    var _ids_versionId;
+    const version = (_ids_versionId = ids.versionId) != null ? _ids_versionId : 'current';
+    return `${BESIGNER_DRAFT_KEY_PREFIX}${ids.kind}:` + `${ids.scope}:${ids.docId}:${version}`;
+}
+function storageOrNull() {
+    try {
+        return typeof window === 'undefined' ? null : window.localStorage;
+    } catch (unused) {
+        return null;
+    }
+}
+/**
+ * Writes the draft, replacing any previous one for this document.
+ *
+ * Returns false when storage refused it — the caller carries on editing
+ * either way. Preview snapshots are spent first when the origin is full
+ * (they regenerate on the next Preview click); other documents' drafts only
+ * after that, oldest first.
+ */ export function writeBesignerDraft(ids, draft, now = Date.now()) {
+    const value = _extends({}, draft, {
+        updatedAt: now
+    });
+    return writeLocalStorageWithBudget({
+        key: besignerDraftKey(ids),
+        value: JSON.stringify(value),
+        evictPrefixes: [
+            'aglyn:preview:',
+            BESIGNER_DRAFT_KEY_PREFIX
+        ]
+    }).ok;
+}
+/**
+ * Reads this document's draft, or null when there is none, it is unreadable,
+ * or it has aged out. An expired draft is removed on the way past, so the
+ * store self-prunes on the path everyone takes.
+ */ export function readBesignerDraft(ids, now = Date.now()) {
+    var _draft_updatedAt;
+    const storage = storageOrNull();
+    if (!storage) return null;
+    const key = besignerDraftKey(ids);
+    const raw = storage.getItem(key);
+    if (!raw) return null;
+    let draft;
+    try {
+        const parsed = JSON.parse(raw);
+        draft = (parsed == null ? void 0 : parsed.nodes) ? parsed : null;
+    } catch (unused) {
+        draft = null;
+    }
+    if (!draft) {
+        clearBesignerDraft(ids);
+        return null;
+    }
+    if (now - ((_draft_updatedAt = draft.updatedAt) != null ? _draft_updatedAt : 0) > DRAFT_MAX_AGE_MS) {
+        clearBesignerDraft(ids);
+        return null;
+    }
+    return draft;
+}
+export function clearBesignerDraft(ids) {
+    try {
+        var _storageOrNull;
+        (_storageOrNull = storageOrNull()) == null ? void 0 : _storageOrNull.removeItem(besignerDraftKey(ids));
+    } catch (unused) {
+    // Nothing to do and nothing worth interrupting an edit for.
+    }
+}
+/** Drops every expired draft, whichever document it belongs to. */ export function pruneBesignerDrafts(now = Date.now()) {
+    return pruneLocalStorageByAge({
+        prefix: BESIGNER_DRAFT_KEY_PREFIX,
+        maxAgeMs: DRAFT_MAX_AGE_MS,
+        now
+    });
+}
+
+//# sourceMappingURL=besigner-draft-store.js.map

package/src/lib/drafts/besigner-draft-store.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../libs/besigner/feature/designer/src/lib/drafts/besigner-draft-store.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2026 Aglyn LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  type ProcessableNodes,\n  pruneLocalStorageByAge,\n  writeLocalStorageWithBudget,\n} from '@aglyn/aglyn'\n\n/**\n * Local crash net for unsaved besigner work (AGL-1256).\n *\n * ## What this is not\n *\n * It is deliberately **not** version history. Versioning is a paid feature\n * (`versioning`, Pro and above): named snapshots of the *saved* document that\n * you can list, reopen, publish and schedule. A store of dated snapshots in\n * the browser is one careless design decision away from being a free\n * imitation of exactly that, so three rules hold the line, and every one of\n * them is load-bearing rather than incidental:\n *\n * 1. **One draft per document, latest wins.** No list, no names, no history.\n *    There is nothing to browse and nothing to choose between.\n * 2. **A draft only ever holds work that was never saved.** It is cleared the\n *    moment a save succeeds, so it can never act as \"restore the document to\n *    how it was before\" — that is rollback, and rollback is what versions\n *    sell. The only thing a draft can give back is the thing that would\n *    otherwise be gone forever.\n * 3. **A draft expires.** {@link DRAFT_MAX_AGE_MS} keeps it a recovery window\n *    rather than an archive.\n *\n * Because of those, drafts are ungated: this is data-loss prevention, and\n * gating it would mean a free org's crash still costs them their afternoon.\n * A free org gets back exactly what they had in the canvas and not one\n * revision more.\n */\n\n/** Every key this module owns; also the set it may evict from. */\nexport const BESIGNER_DRAFT_KEY_PREFIX = 'aglyn:draft:'\n\n/**\n * A week. Long enough to cover \"my laptop died on Friday\", short enough that\n * the store never becomes an accumulating pile of restore points.\n */\nexport const DRAFT_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000\n\n/**\n * Which besigner document a draft belongs to.\n *\n * Every field is part of the key on purpose. `useBesignerDocument`'s\n * `documentKey` looks like the natural choice and is not safe as one: both\n * email editors build it as `${templateKey}:${versionId}`, so a platform\n * email template and a host's override of the same key — and two different\n * hosts overriding it — all collide. This is the same trap AGL-1203 hit with\n * preview snapshots, where screen, layout, component and template ids come\n * from one generator and live in sibling collections.\n */\nexport interface BesignerDraftIds {\n  /**\n   * Owning host id, or `'platform'` for the staff-owned system documents\n   * that have no host.\n   */\n  scope: string\n  kind: 'screen' | 'layout' | 'component' | 'template' | 'email' | 'form'\n  docId: string\n  /**\n   * Which version of the document is open. Keeping this in the key is what\n   * stops a draft taken against version A being offered on version B —\n   * versions are meant to be independent, and a draft that leaked across\n   * them would corrupt the paid feature rather than merely duplicate it.\n   * Templates version but never publish, so they have none.\n   */\n  versionId?: string\n}\n\nexport interface BesignerDraft {\n  nodes: ProcessableNodes\n  /**\n   * The stored document's version stamp when this draft was taken, in\n   * `Aglyn.versionStamp` form. Null when the document had not stamped yet.\n   * This is what makes the restore prompt honest about a colleague having\n   * saved in the meantime (AGL-674).\n   */\n  baseStamp: string | null\n  /** When the draft was last written. */\n  updatedAt: number\n}\n\nexport function besignerDraftKey(ids: BesignerDraftIds): string {\n  const version = ids.versionId ?? 'current'\n  return (\n    `${BESIGNER_DRAFT_KEY_PREFIX}${ids.kind}:` +\n    `${ids.scope}:${ids.docId}:${version}`\n  )\n}\n\nfunction storageOrNull(): Storage | null {\n  try {\n    return typeof window === 'undefined' ? null : window.localStorage\n  } catch {\n    return null\n  }\n}\n\n/**\n * Writes the draft, replacing any previous one for this document.\n *\n * Returns false when storage refused it — the caller carries on editing\n * either way. Preview snapshots are spent first when the origin is full\n * (they regenerate on the next Preview click); other documents' drafts only\n * after that, oldest first.\n */\nexport function writeBesignerDraft(\n  ids: BesignerDraftIds,\n  draft: Omit<BesignerDraft, 'updatedAt'>,\n  now: number = Date.now(),\n): boolean {\n  const value: BesignerDraft = { ...draft, updatedAt: now }\n  return writeLocalStorageWithBudget({\n    key: besignerDraftKey(ids),\n    value: JSON.stringify(value),\n    evictPrefixes: ['aglyn:preview:', BESIGNER_DRAFT_KEY_PREFIX],\n  }).ok\n}\n\n/**\n * Reads this document's draft, or null when there is none, it is unreadable,\n * or it has aged out. An expired draft is removed on the way past, so the\n * store self-prunes on the path everyone takes.\n */\nexport function readBesignerDraft(\n  ids: BesignerDraftIds,\n  now: number = Date.now(),\n): BesignerDraft | null {\n  const storage = storageOrNull()\n  if (!storage) return null\n  const key = besignerDraftKey(ids)\n  const raw = storage.getItem(key)\n  if (!raw) return null\n  let draft: BesignerDraft | null\n  try {\n    const parsed = JSON.parse(raw) as BesignerDraft\n    draft = parsed?.nodes ? parsed : null\n  } catch {\n    draft = null\n  }\n  if (!draft) {\n    clearBesignerDraft(ids)\n    return null\n  }\n  if (now - (draft.updatedAt ?? 0) > DRAFT_MAX_AGE_MS) {\n    clearBesignerDraft(ids)\n    return null\n  }\n  return draft\n}\n\nexport function clearBesignerDraft(ids: BesignerDraftIds): void {\n  try {\n    storageOrNull()?.removeItem(besignerDraftKey(ids))\n  } catch {\n    // Nothing to do and nothing worth interrupting an edit for.\n  }\n}\n\n/** Drops every expired draft, whichever document it belongs to. */\nexport function pruneBesignerDrafts(now: number = Date.now()): string[] {\n  return pruneLocalStorageByAge({\n    prefix: BESIGNER_DRAFT_KEY_PREFIX,\n    maxAgeMs: DRAFT_MAX_AGE_MS,\n    now,\n  })\n}\n"],"names":["pruneLocalStorageByAge","writeLocalStorageWithBudget","BESIGNER_DRAFT_KEY_PREFIX","DRAFT_MAX_AGE_MS","besignerDraftKey","ids","version","versionId","kind","scope","docId","storageOrNull","window","localStorage","writeBesignerDraft","draft","now","Date","value","updatedAt","key","JSON","stringify","evictPrefixes","ok","readBesignerDraft","storage","raw","getItem","parsed","parse","nodes","clearBesignerDraft","removeItem","pruneBesignerDrafts","prefix","maxAgeMs"],"mappings":";AAAA;;;;;;;;;;;;;;;CAeC,GAED,SAEEA,sBAAsB,EACtBC,2BAA2B,QACtB,eAAc;AAErB;;;;;;;;;;;;;;;;;;;;;;;;;;CA0BC,GAED,gEAAgE,GAChE,OAAO,MAAMC,4BAA4B,eAAc;AAEvD;;;CAGC,GACD,OAAO,MAAMC,mBAAmB,IAAI,KAAK,KAAK,KAAK,KAAI;AA4CvD,OAAO,SAASC,iBAAiBC,GAAqB;QACpCA;IAAhB,MAAMC,WAAUD,iBAAAA,IAAIE,SAAS,YAAbF,iBAAiB;IACjC,OACE,GAAGH,4BAA4BG,IAAIG,IAAI,CAAC,CAAC,CAAC,GAC1C,GAAGH,IAAII,KAAK,CAAC,CAAC,EAAEJ,IAAIK,KAAK,CAAC,CAAC,EAAEJ,SAAS;AAE1C;AAEA,SAASK;IACP,IAAI;QACF,OAAO,OAAOC,WAAW,cAAc,OAAOA,OAAOC,YAAY;IACnE,EAAE,eAAM;QACN,OAAO;IACT;AACF;AAEA;;;;;;;CAOC,GACD,OAAO,SAASC,mBACdT,GAAqB,EACrBU,KAAuC,EACvCC,MAAcC,KAAKD,GAAG,EAAE;IAExB,MAAME,QAAuB,aAAKH;QAAOI,WAAWH;;IACpD,OAAOf,4BAA4B;QACjCmB,KAAKhB,iBAAiBC;QACtBa,OAAOG,KAAKC,SAAS,CAACJ;QACtBK,eAAe;YAAC;YAAkBrB;SAA0B;IAC9D,GAAGsB,EAAE;AACP;AAEA;;;;CAIC,GACD,OAAO,SAASC,kBACdpB,GAAqB,EACrBW,MAAcC,KAAKD,GAAG,EAAE;QAkBbD;IAhBX,MAAMW,UAAUf;IAChB,IAAI,CAACe,SAAS,OAAO;IACrB,MAAMN,MAAMhB,iBAAiBC;IAC7B,MAAMsB,MAAMD,QAAQE,OAAO,CAACR;IAC5B,IAAI,CAACO,KAAK,OAAO;IACjB,IAAIZ;IACJ,IAAI;QACF,MAAMc,SAASR,KAAKS,KAAK,CAACH;QAC1BZ,QAAQc,CAAAA,0BAAAA,OAAQE,KAAK,IAAGF,SAAS;IACnC,EAAE,eAAM;QACNd,QAAQ;IACV;IACA,IAAI,CAACA,OAAO;QACViB,mBAAmB3B;QACnB,OAAO;IACT;IACA,IAAIW,QAAOD,mBAAAA,MAAMI,SAAS,YAAfJ,mBAAmB,KAAKZ,kBAAkB;QACnD6B,mBAAmB3B;QACnB,OAAO;IACT;IACA,OAAOU;AACT;AAEA,OAAO,SAASiB,mBAAmB3B,GAAqB;IACtD,IAAI;YACFM;SAAAA,iBAAAA,oCAAAA,eAAiBsB,UAAU,CAAC7B,iBAAiBC;IAC/C,EAAE,eAAM;IACN,4DAA4D;IAC9D;AACF;AAEA,iEAAiE,GACjE,OAAO,SAAS6B,oBAAoBlB,MAAcC,KAAKD,GAAG,EAAE;IAC1D,OAAOhB,uBAAuB;QAC5BmC,QAAQjC;QACRkC,UAAUjC;QACVa;IACF;AACF"}

package/src/lib/drafts/besigner-server-draft.d.ts

@@ -0,0 +1,130 @@
+/**
+ * @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 { type Firestore } from 'firebase/firestore';
+import { type ProcessableNodes } from '@aglyn/aglyn';
+import type { BesignerDraftIds } from './besigner-draft-store';
+/**
+ * THE WORKING DRAFT — server-side, shared, one per version (AGL-1152).
+ *
+ * ## Why this exists alongside the local store
+ *
+ * `besigner-draft-store` is a crash net: it holds keystrokes that were never
+ * saved, in this browser, and dies the moment a save succeeds. That is still
+ * exactly what it should be, and nothing here changes it.
+ *
+ * This is the other thing asked for, and it is genuinely different: the
+ * draft was originally only to save lost work, but now it is becoming a
+ * working document and we want to save the working document as we make changes
+ * and then publish after we are all done. So a draft here is written
+ * DELIBERATELY, survives the browser, and lives until it is published.
+ *
+ * ## Why it is not a free version history
+ *
+ * The same line AGL-1256 drew still holds, and this stays on the safe side of
+ * it for a structural reason rather than a promise: the document id is the
+ * constant {@link DRAFT_DOC_ID}. There is no second name to write, so there is
+ * no list to browse, nothing to name and nothing to choose between — you
+ * cannot have more than one. Versions remain the paid feature: many of them,
+ * restore points, scheduled release, variants, review cycles.
+ *
+ * ## Why a subcollection and not a field on the version
+ *
+ * The tenant reads version documents to render. A draft held as a field on one
+ * would be shipped to every render of that page and billed on every read of
+ * that document, to serve a value the tenant must never show. As its own
+ * document it is read only by an editor that opens it, and it gets its own 1MB
+ * budget rather than halving the target's.
+ *
+ * ## Compressed at rest, like the document it shadows
+ *
+ * A draft holds the WHOLE working tree, so it is the same size as the version
+ * it sits beside — and that version is msgpack. Stored as a plain Firestore
+ * map instead, the same tree costs about 1.4x as many bytes, which spends the
+ * budget above on encoding rather than on content: the largest page on the
+ * platform is 574,865 bytes as msgpack and 839,226 as a map, so its draft ran
+ * at 80% of the ceiling while the version sat at 55%.
+ *
+ * That gap also blinded the guard meant to catch it. `measureNodeMap` sizes a
+ * tree with the msgpack encoder — correctly, for the documents that use it —
+ * so the editor's near-limit warning read the version's 55% for a draft write
+ * that was actually at 80%, and the first thing an author would have learned
+ * about the ceiling is a save that stopped working.
+ *
+ * ## Co-editing
+ *
+ * There is ONE draft per target, not one per person, which is what makes it
+ * work with the live mirror rather than against it: the mirror carries
+ * in-flight keystrokes between people in the room, and a draft save promotes
+ * that shared state to something durable that everyone in the room — and
+ * anyone who joins later, from any browser — loads next. That is why saving a
+ * draft clears the mirror exactly as saving the document does: Firestore has
+ * become authoritative again, and replaying the mirror over it would re-apply
+ * edits the draft already contains.
+ */
+/** The only id a draft may have. One per version, by construction. */
+export declare const DRAFT_DOC_ID = "current";
+export interface BesignerServerDraft {
+    nodes: ProcessableNodes;
+    /**
+     * The stored document's version stamp when this draft was taken. What lets
+     * the editor say "someone published since you started" honestly rather than
+     * silently overwriting them (AGL-674).
+     */
+    baseStamp: string | null;
+    /** Who last wrote it — a shared draft needs to say whose work it holds. */
+    updatedByUid: string | null;
+    updatedByEmail: string | null;
+}
+/**
+ * A draft as the store hands it back: what was written, plus WHEN.
+ *
+ * The time is the server's stamp, not the reader's clock. It is what the
+ * editor tells an author about the draft's age, and a draft saved yesterday
+ * that is described as "less than a minute ago" reads as work somebody is
+ * doing right now — the one thing a stranded draft is not (AGL-2868).
+ */
+export interface StoredServerDraft extends BesignerServerDraft {
+    /** Epoch milliseconds of the last write, or null when the document carries no stamp. */
+    updatedAt: number | null;
+}
+/**
+ * The draft's document, or null when this target cannot hold one — no host
+ * scope, no version, or a kind with no versions. Null is a supported answer
+ * and every caller treats it as "no draft here", never as an error.
+ */
+export declare function serverDraftRef(firestore: Firestore, ids: BesignerDraftIds): import("@firebase/firestore").DocumentReference<import("@firebase/firestore").DocumentData, import("@firebase/firestore").DocumentData>;
+/**
+ * Writes the working draft. Resolves false rather than throwing when the
+ * target cannot hold one, so a caller does not have to re-derive that.
+ */
+/**
+ * What a draft save did.
+ *
+ * `unchanged` is a SUCCESS, not a failure: the draft already holds this tree.
+ * Distinguished from `written` because the two deserve different words on
+ * screen — "Draft saved" said four times over an untouched document is how a
+ * reader stops believing the message (AGL-1483).
+ */
+export type ServerDraftWrite = 'written' | 'unchanged' | 'failed';
+export declare function writeServerDraft(firestore: Firestore, ids: BesignerDraftIds, draft: BesignerServerDraft): Promise<ServerDraftWrite>;
+export declare function readServerDraft(firestore: Firestore, ids: BesignerDraftIds): Promise<StoredServerDraft | null>;
+/**
+ * Clears the working draft. Called when it has been PUBLISHED — the work is in
+ * the document now, so a draft that outlived it would offer to restore the
+ * state the author just moved past.
+ */
+export declare function clearServerDraft(firestore: Firestore, ids: BesignerDraftIds): Promise<void>;

package/src/lib/drafts/besigner-server-draft.js

@@ -0,0 +1,211 @@
+import { _ as _extends } from "@swc/helpers/_/_extends";
+import { _ as _object_without_properties_loose } from "@swc/helpers/_/_object_without_properties_loose";
+/**
+ * @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 { Bytes, deleteDoc, doc, getDoc, serverTimestamp, setDoc } from "firebase/firestore";
+import { decodeStoredNodes, encodeStoredNodes } from "@aglyn/aglyn";
+/**
+ * THE WORKING DRAFT — server-side, shared, one per version (AGL-1152).
+ *
+ * ## Why this exists alongside the local store
+ *
+ * `besigner-draft-store` is a crash net: it holds keystrokes that were never
+ * saved, in this browser, and dies the moment a save succeeds. That is still
+ * exactly what it should be, and nothing here changes it.
+ *
+ * This is the other thing asked for, and it is genuinely different: the
+ * draft was originally only to save lost work, but now it is becoming a
+ * working document and we want to save the working document as we make changes
+ * and then publish after we are all done. So a draft here is written
+ * DELIBERATELY, survives the browser, and lives until it is published.
+ *
+ * ## Why it is not a free version history
+ *
+ * The same line AGL-1256 drew still holds, and this stays on the safe side of
+ * it for a structural reason rather than a promise: the document id is the
+ * constant {@link DRAFT_DOC_ID}. There is no second name to write, so there is
+ * no list to browse, nothing to name and nothing to choose between — you
+ * cannot have more than one. Versions remain the paid feature: many of them,
+ * restore points, scheduled release, variants, review cycles.
+ *
+ * ## Why a subcollection and not a field on the version
+ *
+ * The tenant reads version documents to render. A draft held as a field on one
+ * would be shipped to every render of that page and billed on every read of
+ * that document, to serve a value the tenant must never show. As its own
+ * document it is read only by an editor that opens it, and it gets its own 1MB
+ * budget rather than halving the target's.
+ *
+ * ## Compressed at rest, like the document it shadows
+ *
+ * A draft holds the WHOLE working tree, so it is the same size as the version
+ * it sits beside — and that version is msgpack. Stored as a plain Firestore
+ * map instead, the same tree costs about 1.4x as many bytes, which spends the
+ * budget above on encoding rather than on content: the largest page on the
+ * platform is 574,865 bytes as msgpack and 839,226 as a map, so its draft ran
+ * at 80% of the ceiling while the version sat at 55%.
+ *
+ * That gap also blinded the guard meant to catch it. `measureNodeMap` sizes a
+ * tree with the msgpack encoder — correctly, for the documents that use it —
+ * so the editor's near-limit warning read the version's 55% for a draft write
+ * that was actually at 80%, and the first thing an author would have learned
+ * about the ceiling is a save that stopped working.
+ *
+ * ## Co-editing
+ *
+ * There is ONE draft per target, not one per person, which is what makes it
+ * work with the live mirror rather than against it: the mirror carries
+ * in-flight keystrokes between people in the room, and a draft save promotes
+ * that shared state to something durable that everyone in the room — and
+ * anyone who joins later, from any browser — loads next. That is why saving a
+ * draft clears the mirror exactly as saving the document does: Firestore has
+ * become authoritative again, and replaying the mirror over it would re-apply
+ * edits the draft already contains.
+ */ /** The only id a draft may have. One per version, by construction. */ export const DRAFT_DOC_ID = 'current';
+/**
+ * Epoch milliseconds from a stored stamp — a Firestore `Timestamp`, or its
+ * `{ seconds, nanoseconds }` shape once it has crossed a serialization — or
+ * null for anything else. Null is an honest "not known", which the banner
+ * renders by not naming an age at all.
+ */ function stampMillis(value) {
+    if (!value || typeof value !== 'object') return null;
+    const stamp = value;
+    if (typeof stamp.toMillis === 'function') {
+        try {
+            const millis = stamp.toMillis();
+            return Number.isFinite(millis) ? millis : null;
+        } catch (unused) {
+            return null;
+        }
+    }
+    if (typeof stamp.seconds === 'number' && Number.isFinite(stamp.seconds)) {
+        var _stamp_nanoseconds;
+        return stamp.seconds * 1000 + Math.floor(((_stamp_nanoseconds = stamp.nanoseconds) != null ? _stamp_nanoseconds : 0) / 1e6);
+    }
+    return null;
+}
+/**
+ * `screen` → `screens`. The kinds that have no versioned subcollection get no
+ * draft: a template IS its document, so there is nothing for a draft to sit
+ * beside, and returning null here is what keeps callers from inventing a path.
+ */ const COLLECTION_OF = {
+    screen: 'screens',
+    layout: 'layouts',
+    component: 'components',
+    form: 'forms'
+};
+/**
+ * The draft's document, or null when this target cannot hold one — no host
+ * scope, no version, or a kind with no versions. Null is a supported answer
+ * and every caller treats it as "no draft here", never as an error.
+ */ export function serverDraftRef(firestore, ids) {
+    const collection = COLLECTION_OF[ids.kind];
+    if (!collection || !ids.scope || ids.scope === 'platform') return null;
+    if (!ids.docId || !ids.versionId) return null;
+    return doc(firestore, 'hosts', ids.scope, collection, ids.docId, 'versions', ids.versionId, 'draft', DRAFT_DOC_ID);
+}
+/**
+ * The tree last written to each draft, by path.
+ *
+ * Module scope, so all three editors get the check without repeating it, and
+ * so it survives a re-render rather than a mount.
+ *
+ * A LOCAL baseline, deliberately, where `handleSave` insists on comparing
+ * against the stored document. The two are guarding opposite mistakes.
+ * `handleSave` must never skip a write that is needed, so a baseline that
+ * lies would lose work and it re-reads to be sure. Here a stale baseline
+ * only ever causes an extra identical write, which costs one document and
+ * changes nothing — while reading the draft back on every click would cost a
+ * Firestore read per click for a check nothing depends on.
+ */ const lastWritten = new Map();
+export async function writeServerDraft(firestore, ids, draft) {
+    var _draft_baseStamp, _draft_updatedByUid;
+    const ref = serverDraftRef(firestore, ids);
+    if (!ref) return 'failed';
+    // Keyed on the whole payload, not just the nodes: a draft carries the base
+    // stamp it was taken against, and one taken against a newer document is a
+    // different draft even when the tree is identical.
+    const fingerprint = JSON.stringify([
+        draft.nodes,
+        (_draft_baseStamp = draft.baseStamp) != null ? _draft_baseStamp : null,
+        (_draft_updatedByUid = draft.updatedByUid) != null ? _draft_updatedByUid : null
+    ]);
+    if (lastWritten.get(ref.path) === fingerprint) return 'unchanged';
+    // Compressed at rest, matching the version this shadows. `nodes` is taken
+    // out of the spread rather than overwritten after it, so the plain tree can
+    // never reach the write through a future edit that reorders these keys.
+    const { nodes } = draft, rest = _object_without_properties_loose(draft, [
+        "nodes"
+    ]);
+    const packed = encodeStoredNodes(nodes);
+    // Not `merge`: a draft is the whole working tree, and merging a smaller
+    // tree into a larger one would leave nodes from a previous save behind —
+    // the shape of AGL-1445, where a partial write resurrects deleted content.
+    await setDoc(ref, _extends({}, rest, packed ? {
+        nodes: Bytes.fromUint8Array(packed)
+    } : {}, {
+        updatedAt: serverTimestamp()
+    }));
+    lastWritten.set(ref.path, fingerprint);
+    return 'written';
+}
+export async function readServerDraft(firestore, ids) {
+    var _data_baseStamp, _data_updatedByUid, _data_updatedByEmail;
+    const ref = serverDraftRef(firestore, ids);
+    if (!ref) return null;
+    const snapshot = await getDoc(ref);
+    if (!snapshot.exists()) return null;
+    // `estimate`: a draft this browser wrote a moment ago can still have its
+    // `serverTimestamp` pending, and the local estimate of it is a truer age
+    // than none.
+    const data = snapshot.data({
+        serverTimestamps: 'estimate'
+    });
+    // BOTH stored forms, permanently. Drafts written before compression are
+    // plain maps and nothing migrates them, so a reader that understood only
+    // bytes would find no tree and report the draft absent — offering an author
+    // nothing where their unpublished work actually is. `decodeStoredNodes`
+    // returns a plain map unchanged, so one call covers both.
+    const nodes = decodeStoredNodes(data == null ? void 0 : data.nodes);
+    // A draft with no tree is not a draft. Guarding here rather than at the call
+    // site because a half-written document should read as absent, not as an
+    // empty canvas someone is about to publish over their page.
+    if (!nodes) return null;
+    return {
+        nodes,
+        baseStamp: (_data_baseStamp = data.baseStamp) != null ? _data_baseStamp : null,
+        updatedByUid: (_data_updatedByUid = data.updatedByUid) != null ? _data_updatedByUid : null,
+        updatedByEmail: (_data_updatedByEmail = data.updatedByEmail) != null ? _data_updatedByEmail : null,
+        updatedAt: stampMillis(data.updatedAt)
+    };
+}
+/**
+ * Clears the working draft. Called when it has been PUBLISHED — the work is in
+ * the document now, so a draft that outlived it would offer to restore the
+ * state the author just moved past.
+ */ export async function clearServerDraft(firestore, ids) {
+    const ref = serverDraftRef(firestore, ids);
+    if (!ref) return;
+    // Forget the fingerprint with the draft. Otherwise the next save of the
+    // same tree — a publish, then an undo back to it — would report itself
+    // unchanged against a draft that no longer exists.
+    lastWritten.delete(ref.path);
+    // Best effort: a publish that succeeded must not report failure because the
+    // tidy-up afterwards did. A stale draft is offered, not applied.
+    await deleteDoc(ref).catch(()=>undefined);
+}
+
+//# sourceMappingURL=besigner-server-draft.js.map

package/src/lib/drafts/besigner-server-draft.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../libs/besigner/feature/designer/src/lib/drafts/besigner-server-draft.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2026 Aglyn LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  Bytes,\n  type Firestore,\n  deleteDoc,\n  doc,\n  getDoc,\n  serverTimestamp,\n  setDoc,\n} from 'firebase/firestore'\n\nimport {\n  type ProcessableNodes,\n  decodeStoredNodes,\n  encodeStoredNodes,\n} from '@aglyn/aglyn'\nimport type { BesignerDraftIds } from './besigner-draft-store'\n\n/**\n * THE WORKING DRAFT — server-side, shared, one per version (AGL-1152).\n *\n * ## Why this exists alongside the local store\n *\n * `besigner-draft-store` is a crash net: it holds keystrokes that were never\n * saved, in this browser, and dies the moment a save succeeds. That is still\n * exactly what it should be, and nothing here changes it.\n *\n * This is the other thing asked for, and it is genuinely different: the\n * draft was originally only to save lost work, but now it is becoming a\n * working document and we want to save the working document as we make changes\n * and then publish after we are all done. So a draft here is written\n * DELIBERATELY, survives the browser, and lives until it is published.\n *\n * ## Why it is not a free version history\n *\n * The same line AGL-1256 drew still holds, and this stays on the safe side of\n * it for a structural reason rather than a promise: the document id is the\n * constant {@link DRAFT_DOC_ID}. There is no second name to write, so there is\n * no list to browse, nothing to name and nothing to choose between — you\n * cannot have more than one. Versions remain the paid feature: many of them,\n * restore points, scheduled release, variants, review cycles.\n *\n * ## Why a subcollection and not a field on the version\n *\n * The tenant reads version documents to render. A draft held as a field on one\n * would be shipped to every render of that page and billed on every read of\n * that document, to serve a value the tenant must never show. As its own\n * document it is read only by an editor that opens it, and it gets its own 1MB\n * budget rather than halving the target's.\n *\n * ## Compressed at rest, like the document it shadows\n *\n * A draft holds the WHOLE working tree, so it is the same size as the version\n * it sits beside — and that version is msgpack. Stored as a plain Firestore\n * map instead, the same tree costs about 1.4x as many bytes, which spends the\n * budget above on encoding rather than on content: the largest page on the\n * platform is 574,865 bytes as msgpack and 839,226 as a map, so its draft ran\n * at 80% of the ceiling while the version sat at 55%.\n *\n * That gap also blinded the guard meant to catch it. `measureNodeMap` sizes a\n * tree with the msgpack encoder — correctly, for the documents that use it —\n * so the editor's near-limit warning read the version's 55% for a draft write\n * that was actually at 80%, and the first thing an author would have learned\n * about the ceiling is a save that stopped working.\n *\n * ## Co-editing\n *\n * There is ONE draft per target, not one per person, which is what makes it\n * work with the live mirror rather than against it: the mirror carries\n * in-flight keystrokes between people in the room, and a draft save promotes\n * that shared state to something durable that everyone in the room — and\n * anyone who joins later, from any browser — loads next. That is why saving a\n * draft clears the mirror exactly as saving the document does: Firestore has\n * become authoritative again, and replaying the mirror over it would re-apply\n * edits the draft already contains.\n */\n\n/** The only id a draft may have. One per version, by construction. */\nexport const DRAFT_DOC_ID = 'current'\n\nexport interface BesignerServerDraft {\n  nodes: ProcessableNodes\n  /**\n   * The stored document's version stamp when this draft was taken. What lets\n   * the editor say \"someone published since you started\" honestly rather than\n   * silently overwriting them (AGL-674).\n   */\n  baseStamp: string | null\n  /** Who last wrote it — a shared draft needs to say whose work it holds. */\n  updatedByUid: string | null\n  updatedByEmail: string | null\n}\n\n/**\n * A draft as the store hands it back: what was written, plus WHEN.\n *\n * The time is the server's stamp, not the reader's clock. It is what the\n * editor tells an author about the draft's age, and a draft saved yesterday\n * that is described as \"less than a minute ago\" reads as work somebody is\n * doing right now — the one thing a stranded draft is not (AGL-2868).\n */\nexport interface StoredServerDraft extends BesignerServerDraft {\n  /** Epoch milliseconds of the last write, or null when the document carries no stamp. */\n  updatedAt: number | null\n}\n\n/**\n * Epoch milliseconds from a stored stamp — a Firestore `Timestamp`, or its\n * `{ seconds, nanoseconds }` shape once it has crossed a serialization — or\n * null for anything else. Null is an honest \"not known\", which the banner\n * renders by not naming an age at all.\n */\nfunction stampMillis(value: unknown): number | null {\n  if (!value || typeof value !== 'object') return null\n  const stamp = value as {\n    toMillis?: () => number\n    seconds?: number\n    nanoseconds?: number\n  }\n  if (typeof stamp.toMillis === 'function') {\n    try {\n      const millis = stamp.toMillis()\n      return Number.isFinite(millis) ? millis : null\n    } catch {\n      return null\n    }\n  }\n  if (typeof stamp.seconds === 'number' && Number.isFinite(stamp.seconds)) {\n    return stamp.seconds * 1000 + Math.floor((stamp.nanoseconds ?? 0) / 1e6)\n  }\n  return null\n}\n\n/**\n * `screen` → `screens`. The kinds that have no versioned subcollection get no\n * draft: a template IS its document, so there is nothing for a draft to sit\n * beside, and returning null here is what keeps callers from inventing a path.\n */\nconst COLLECTION_OF: Partial<Record<BesignerDraftIds['kind'], string>> = {\n  screen: 'screens',\n  layout: 'layouts',\n  component: 'components',\n  form: 'forms',\n}\n\n/**\n * The draft's document, or null when this target cannot hold one — no host\n * scope, no version, or a kind with no versions. Null is a supported answer\n * and every caller treats it as \"no draft here\", never as an error.\n */\nexport function serverDraftRef(firestore: Firestore, ids: BesignerDraftIds) {\n  const collection = COLLECTION_OF[ids.kind]\n  if (!collection || !ids.scope || ids.scope === 'platform') return null\n  if (!ids.docId || !ids.versionId) return null\n  return doc(\n    firestore,\n    'hosts',\n    ids.scope,\n    collection,\n    ids.docId,\n    'versions',\n    ids.versionId,\n    'draft',\n    DRAFT_DOC_ID,\n  )\n}\n\n/**\n * Writes the working draft. Resolves false rather than throwing when the\n * target cannot hold one, so a caller does not have to re-derive that.\n */\n/**\n * What a draft save did.\n *\n * `unchanged` is a SUCCESS, not a failure: the draft already holds this tree.\n * Distinguished from `written` because the two deserve different words on\n * screen — \"Draft saved\" said four times over an untouched document is how a\n * reader stops believing the message (AGL-1483).\n */\nexport type ServerDraftWrite = 'written' | 'unchanged' | 'failed'\n\n/**\n * The tree last written to each draft, by path.\n *\n * Module scope, so all three editors get the check without repeating it, and\n * so it survives a re-render rather than a mount.\n *\n * A LOCAL baseline, deliberately, where `handleSave` insists on comparing\n * against the stored document. The two are guarding opposite mistakes.\n * `handleSave` must never skip a write that is needed, so a baseline that\n * lies would lose work and it re-reads to be sure. Here a stale baseline\n * only ever causes an extra identical write, which costs one document and\n * changes nothing — while reading the draft back on every click would cost a\n * Firestore read per click for a check nothing depends on.\n */\nconst lastWritten = new Map<string, string>()\n\nexport async function writeServerDraft(\n  firestore: Firestore,\n  ids: BesignerDraftIds,\n  draft: BesignerServerDraft,\n): Promise<ServerDraftWrite> {\n  const ref = serverDraftRef(firestore, ids)\n  if (!ref) return 'failed'\n  // Keyed on the whole payload, not just the nodes: a draft carries the base\n  // stamp it was taken against, and one taken against a newer document is a\n  // different draft even when the tree is identical.\n  const fingerprint = JSON.stringify([\n    draft.nodes,\n    draft.baseStamp ?? null,\n    draft.updatedByUid ?? null,\n  ])\n  if (lastWritten.get(ref.path) === fingerprint) return 'unchanged'\n  // Compressed at rest, matching the version this shadows. `nodes` is taken\n  // out of the spread rather than overwritten after it, so the plain tree can\n  // never reach the write through a future edit that reorders these keys.\n  const { nodes, ...rest } = draft\n  const packed = encodeStoredNodes(nodes)\n  // Not `merge`: a draft is the whole working tree, and merging a smaller\n  // tree into a larger one would leave nodes from a previous save behind —\n  // the shape of AGL-1445, where a partial write resurrects deleted content.\n  await setDoc(ref, {\n    ...rest,\n    // `Bytes` is what the client SDK accepts for a bytes field;\n    // `encodeStoredNodes` returns a bare array so it can stay Firestore-free.\n    ...(packed ? { nodes: Bytes.fromUint8Array(packed) } : {}),\n    updatedAt: serverTimestamp(),\n  })\n  lastWritten.set(ref.path, fingerprint)\n  return 'written'\n}\n\nexport async function readServerDraft(\n  firestore: Firestore,\n  ids: BesignerDraftIds,\n): Promise<StoredServerDraft | null> {\n  const ref = serverDraftRef(firestore, ids)\n  if (!ref) return null\n  const snapshot = await getDoc(ref)\n  if (!snapshot.exists()) return null\n  // `estimate`: a draft this browser wrote a moment ago can still have its\n  // `serverTimestamp` pending, and the local estimate of it is a truer age\n  // than none.\n  const data = snapshot.data({ serverTimestamps: 'estimate' }) as Partial<\n    BesignerServerDraft & { updatedAt: unknown }\n  >\n  // BOTH stored forms, permanently. Drafts written before compression are\n  // plain maps and nothing migrates them, so a reader that understood only\n  // bytes would find no tree and report the draft absent — offering an author\n  // nothing where their unpublished work actually is. `decodeStoredNodes`\n  // returns a plain map unchanged, so one call covers both.\n  const nodes = decodeStoredNodes<ProcessableNodes>(data?.nodes)\n  // A draft with no tree is not a draft. Guarding here rather than at the call\n  // site because a half-written document should read as absent, not as an\n  // empty canvas someone is about to publish over their page.\n  if (!nodes) return null\n  return {\n    nodes,\n    baseStamp: data.baseStamp ?? null,\n    updatedByUid: data.updatedByUid ?? null,\n    updatedByEmail: data.updatedByEmail ?? null,\n    updatedAt: stampMillis(data.updatedAt),\n  }\n}\n\n/**\n * Clears the working draft. Called when it has been PUBLISHED — the work is in\n * the document now, so a draft that outlived it would offer to restore the\n * state the author just moved past.\n */\nexport async function clearServerDraft(\n  firestore: Firestore,\n  ids: BesignerDraftIds,\n): Promise<void> {\n  const ref = serverDraftRef(firestore, ids)\n  if (!ref) return\n  // Forget the fingerprint with the draft. Otherwise the next save of the\n  // same tree — a publish, then an undo back to it — would report itself\n  // unchanged against a draft that no longer exists.\n  lastWritten.delete(ref.path)\n  // Best effort: a publish that succeeded must not report failure because the\n  // tidy-up afterwards did. A stale draft is offered, not applied.\n  await deleteDoc(ref).catch(() => undefined)\n}\n"],"names":["Bytes","deleteDoc","doc","getDoc","serverTimestamp","setDoc","decodeStoredNodes","encodeStoredNodes","DRAFT_DOC_ID","stampMillis","value","stamp","toMillis","millis","Number","isFinite","seconds","Math","floor","nanoseconds","COLLECTION_OF","screen","layout","component","form","serverDraftRef","firestore","ids","collection","kind","scope","docId","versionId","lastWritten","Map","writeServerDraft","draft","ref","fingerprint","JSON","stringify","nodes","baseStamp","updatedByUid","get","path","rest","packed","fromUint8Array","updatedAt","set","readServerDraft","data","snapshot","exists","serverTimestamps","updatedByEmail","clearServerDraft","delete","catch","undefined"],"mappings":"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"}

package/src/lib/form-fields/components/shared/inline-form-control.d.ts

@@ -0,0 +1,32 @@
+/**
+ * @license
+ * Copyright 2023 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 { type FieldMuteAction } from '@aglyn/shared-ui-jsx-forms';
+import { type FormControlProps, type ToggleButtonGroupProps } from '@mui/material';
+export interface InlineFormControlProps extends Omit<FormControlProps, 'onChange'> {
+    onChange?: ToggleButtonGroupProps['onChange'];
+    value?: ToggleButtonGroupProps['value'];
+    label?: JSX.Children;
+    helperText?: JSX.Children;
+    /**
+     * Switch this declaration off without losing it (AGL-2486). These rows are
+     * not grid-wrapped fields, so they carry the eye themselves — beside the
+     * label, where the row has room, rather than in a corner it does not have.
+     */
+    mute?: FieldMuteAction;
+}
+export declare const InlineFormControl: import("react").ForwardRefExoticComponent<Omit<InlineFormControlProps, "ref"> & import("react").RefAttributes<any>>;
+export default InlineFormControl;

package/src/lib/form-fields/components/shared/inline-form-control.js

@@ -0,0 +1,85 @@
+import { _ as _extends } from "@swc/helpers/_/_extends";
+import { _ as _object_without_properties_loose } from "@swc/helpers/_/_object_without_properties_loose";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * @license
+ * Copyright 2023 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 { FIELD_MUTED_STYLES, FieldMuteButton } from "@aglyn/shared-ui-jsx-forms";
+import { Box, FormControl, FormHelperText, FormLabel } from "@mui/material";
+import { forwardRef } from "react";
+export const InlineFormControl = /*#__PURE__*/ forwardRef((props, forwardRef)=>{
+    const { helperText, label, mute, onChange, children } = props, rest = _object_without_properties_loose(props, [
+        "helperText",
+        "label",
+        "mute",
+        "onChange",
+        "children"
+    ]);
+    return /*#__PURE__*/ _jsxs(FormControl, _extends({
+        ref: forwardRef,
+        margin: "normal",
+        fullWidth: true
+    }, rest, {
+        sx: [
+            (mute == null ? void 0 : mute.muted) ? FIELD_MUTED_STYLES : null,
+            ...Array.isArray(rest.sx) ? rest.sx : [
+                rest.sx
+            ]
+        ],
+        children: [
+            /*#__PURE__*/ _jsxs(Box, {
+                sx: {
+                    display: 'inline-flex',
+                    alignItems: 'center',
+                    flexDirection: 'row',
+                    gap: 1,
+                    flexWrap: 'wrap'
+                },
+                children: [
+                    /*#__PURE__*/ _jsx(FormLabel, {
+                        component: "label",
+                        sx: {
+                            flexBasis: `30%`,
+                            whiteSpace: 'nowrap',
+                            overflow: 'hidden',
+                            flexShrink: 0
+                        },
+                        children: label
+                    }),
+                    /*#__PURE__*/ _jsx(FieldMuteButton, {
+                        mute: mute,
+                        sx: {
+                            ml: -0.5
+                        }
+                    }),
+                    /*#__PURE__*/ _jsx(Box, {
+                        sx: {
+                            // overflow: 'scroll',
+                            flexGrow: 1
+                        },
+                        children: children
+                    })
+                ]
+            }),
+            /*#__PURE__*/ _jsx(FormHelperText, {
+                children: helperText
+            })
+        ]
+    }));
+});
+InlineFormControl.displayName = 'InlineFormControl';
+export default InlineFormControl;
+
+//# sourceMappingURL=inline-form-control.js.map

package/src/lib/form-fields/components/shared/inline-form-control.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../../../libs/besigner/feature/designer/src/lib/form-fields/components/shared/inline-form-control.tsx"],"sourcesContent":["/**\n * @license\n * Copyright 2023 Aglyn LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  type FieldMuteAction,\n  FIELD_MUTED_STYLES,\n  FieldMuteButton,\n} from '@aglyn/shared-ui-jsx-forms'\nimport {\n  Box,\n  FormControl,\n  type FormControlProps,\n  FormHelperText,\n  FormLabel,\n  type ToggleButtonGroupProps,\n} from '@mui/material'\nimport { forwardRef } from 'react'\n\nexport interface InlineFormControlProps extends Omit<\n  FormControlProps,\n  'onChange'\n> {\n  onChange?: ToggleButtonGroupProps['onChange']\n  value?: ToggleButtonGroupProps['value']\n  label?: JSX.Children\n  helperText?: JSX.Children\n  /**\n   * Switch this declaration off without losing it (AGL-2486). These rows are\n   * not grid-wrapped fields, so they carry the eye themselves — beside the\n   * label, where the row has room, rather than in a corner it does not have.\n   */\n  mute?: FieldMuteAction\n}\n\nexport const InlineFormControl = forwardRef<any, InlineFormControlProps>(\n  (props, forwardRef) => {\n    const { helperText, label, mute, onChange, children, ...rest } = props\n\n    return (\n      <FormControl\n        ref={forwardRef}\n        margin=\"normal\"\n        fullWidth\n        {...rest}\n        sx={[\n          mute?.muted ? FIELD_MUTED_STYLES : null,\n          ...(Array.isArray(rest.sx) ? rest.sx : [rest.sx]),\n        ]}\n      >\n        <Box\n          sx={{\n            display: 'inline-flex',\n            alignItems: 'center',\n            flexDirection: 'row',\n            gap: 1,\n            flexWrap: 'wrap',\n          }}\n        >\n          <FormLabel\n            component=\"label\"\n            sx={{\n              flexBasis: `30%`,\n              whiteSpace: 'nowrap',\n              overflow: 'hidden',\n              flexShrink: 0,\n            }}\n          >\n            {label}\n          </FormLabel>\n          <FieldMuteButton mute={mute} sx={{ ml: -0.5 }} />\n          <Box\n            sx={{\n              // overflow: 'scroll',\n              flexGrow: 1,\n            }}\n          >\n            {children}\n          </Box>\n        </Box>\n\n        <FormHelperText>{helperText}</FormHelperText>\n      </FormControl>\n    )\n  },\n)\nInlineFormControl.displayName = 'InlineFormControl'\n\nexport default InlineFormControl\n"],"names":["FIELD_MUTED_STYLES","FieldMuteButton","Box","FormControl","FormHelperText","FormLabel","forwardRef","InlineFormControl","props","helperText","label","mute","onChange","children","rest","ref","margin","fullWidth","sx","muted","Array","isArray","display","alignItems","flexDirection","gap","flexWrap","component","flexBasis","whiteSpace","overflow","flexShrink","ml","flexGrow","displayName"],"mappings":";;;AAAA;;;;;;;;;;;;;;;CAeC,GAED,SAEEA,kBAAkB,EAClBC,eAAe,QACV,6BAA4B;AACnC,SACEC,GAAG,EACHC,WAAW,EAEXC,cAAc,EACdC,SAAS,QAEJ,gBAAe;AACtB,SAASC,UAAU,QAAQ,QAAO;AAkBlC,OAAO,MAAMC,kCAAoBD,WAC/B,CAACE,OAAOF;IACN,MAAM,EAAEG,UAAU,EAAEC,KAAK,EAAEC,IAAI,EAAEC,QAAQ,EAAEC,QAAQ,EAAW,GAAGL,OAATM,wCAASN;;;;;;;IAEjE,qBACE,MAACL;QACCY,KAAKT;QACLU,QAAO;QACPC,SAAS;OACLH;QACJI,IAAI;YACFP,CAAAA,wBAAAA,KAAMQ,KAAK,IAAGnB,qBAAqB;eAC/BoB,MAAMC,OAAO,CAACP,KAAKI,EAAE,IAAIJ,KAAKI,EAAE,GAAG;gBAACJ,KAAKI,EAAE;aAAC;SACjD;;0BAED,MAAChB;gBACCgB,IAAI;oBACFI,SAAS;oBACTC,YAAY;oBACZC,eAAe;oBACfC,KAAK;oBACLC,UAAU;gBACZ;;kCAEA,KAACrB;wBACCsB,WAAU;wBACVT,IAAI;4BACFU,WAAW,CAAC,GAAG,CAAC;4BAChBC,YAAY;4BACZC,UAAU;4BACVC,YAAY;wBACd;kCAECrB;;kCAEH,KAACT;wBAAgBU,MAAMA;wBAAMO,IAAI;4BAAEc,IAAI,CAAC;wBAAI;;kCAC5C,KAAC9B;wBACCgB,IAAI;4BACF,sBAAsB;4BACtBe,UAAU;wBACZ;kCAECpB;;;;0BAIL,KAACT;0BAAgBK;;;;AAGvB,GACD;AACDF,kBAAkB2B,WAAW,GAAG;AAEhC,eAAe3B,kBAAiB"}