@vit-foundation/ui 0.15.0 → 0.17.0

package/dist/edit/Editable.svelte

@@ -2,6 +2,7 @@
 	import type { Snippet } from 'svelte';
 	import { getUiConfig } from '../config/context.js';
 	import { getEditAdapter } from './context.js';
+	import { commitState } from './commit.svelte.js';
 	import type { EditDescriptor } from './types.js';
 
 	/**
@@ -58,30 +59,22 @@
 	const adapter = getEditAdapter();
 	const config = getUiConfig();
 
-	let status = $state<'idle' | 'dirty' | 'saving' | 'error'>('idle');
-	/** Last persisted value: what Escape restores and blur diffs against. */
+	/**
+	 * The commit lifecycle — the four states, the announcements, the last
+	 * persisted value and the follow-the-prop rule — is shared with
+	 * `PropertyRow` (see `./commit.svelte.js`). What stays here is where the
+	 * DRAFT lives: in the DOM, because this is a contenteditable.
+	 */
 	// svelte-ignore state_referenced_locally
-	let savedValue = $state(value);
+	const commit_ = commitState(value, config.editMessages);
 	/** What the child snippet renders. Only rewritten while the DOM is not
 	 * being typed in — Svelte and the reader must not fight over the node. */
 	// svelte-ignore state_referenced_locally
 	let renderText = $state(value);
-	let announcement = $state('');
 
-	// Follow the prop when the app reloads content underneath us — and only
-	// then. Diffing against savedValue instead would fire after every save,
-	// where savedValue has legitimately advanced past the prop, and repaint
-	// the committed draft with stale copy. Never over a draft being held.
-	// svelte-ignore state_referenced_locally
-	let lastPropValue = $state(value);
 	$effect(() => {
-		if (value !== lastPropValue) {
-			lastPropValue = value;
-			if (status === 'idle') {
-				savedValue = value;
-				renderText = value;
-			}
-		}
+		const adopted = commit_.follow(value);
+		if (adopted !== null) renderText = adopted;
 	});
 
 	const active = $derived(edit !== undefined && (adapter?.isEditing ?? false));
@@ -108,35 +101,27 @@
 		range.deleteContents();
 		range.insertNode(document.createTextNode(multiline ? text : text.replace(/\s*\n\s*/g, ' ')));
 		selection.collapseToEnd();
-		status = 'dirty';
+		commit_.markDirty();
 	}
 
 	function handleInput(): void {
-		if (status !== 'saving') status = 'dirty';
+		commit_.markDirty();
 	}
 
 	async function commit(element: HTMLElement): Promise<void> {
 		if (!edit || !adapter) return;
 		const draft = textOf(element).trim();
-		if (draft === savedValue) {
-			status = 'idle';
+		if (draft === commit_.saved) {
+			commit_.settle();
 			return;
 		}
-		status = 'saving';
-		announcement = config.editMessages.edit_saving();
-		try {
-			await adapter.save(edit, draft);
-			savedValue = draft;
-			status = 'idle';
-			announcement = config.editMessages.edit_saved();
-		} catch {
-			// Draft stays in the DOM; the reader decides whether to retry.
-			status = 'error';
-			announcement = config.editMessages.edit_saveError();
-		}
+		// A failed save leaves the draft in the DOM; the reader decides whether
+		// to retry.
+		await commit_.commit(draft, () => adapter.save(edit, draft));
 	}
 
 	function handleBlur(event: FocusEvent): void {
+		const status = commit_.status;
 		if (status === 'dirty' || status === 'error') void commit(event.currentTarget as HTMLElement);
 	}
 
@@ -146,9 +131,8 @@
 			// Svelte's cached text still equals renderText, so a state write
 			// alone cannot repaint a node the reader has mutated: restore the
 			// DOM directly, then settle.
-			element.textContent = savedValue;
-			status = 'idle';
-			announcement = '';
+			element.textContent = commit_.saved;
+			commit_.revert();
 			element.blur();
 			return;
 		}
@@ -168,7 +152,7 @@
 					role: 'textbox',
 					'aria-label': edit?.label,
 					'aria-multiline': multiline ? 'true' : undefined,
-					'data-vit-editing': status,
+					'data-vit-editing': commit_.status,
 					onbeforeinput: handleBeforeInput,
 					oninput: handleInput,
 					onblur: handleBlur,
@@ -181,7 +165,7 @@
 
 {@render children(renderText, attrs)}
 {#if active}
-	<span class="status" role="status">{announcement}</span>
+	<span class="status" role="status">{commit_.announcement}</span>
 {/if}
 
 <style>

package/dist/edit/chrome/EditPanel.svelte

@@ -1,5 +1,5 @@
 <script lang="ts">
-	import type { PropertyDescriptor } from '../types.js';
+	import type { PropertyDescriptor, PropertyValue } from '../types.js';
 	import PropertyRow from './PropertyRow.svelte';
 
 	/**
@@ -8,7 +8,7 @@
 	 * knows nothing about the entity — the descriptors say everything.
 	 */
 	interface Props {
-		rows: { descriptor: PropertyDescriptor; value: string | null }[];
+		rows: { descriptor: PropertyDescriptor; value: PropertyValue }[];
 	}
 
 	let { rows }: Props = $props();

package/dist/edit/chrome/EditPanel.svelte.d.ts

@@ -1,4 +1,4 @@
-import type { PropertyDescriptor } from '../types.js';
+import type { PropertyDescriptor, PropertyValue } from '../types.js';
 /**
  * The property form an EditFrame's popover holds: one PropertyRow per
  * entry, each with its own independent commit lifecycle. The component
@@ -7,7 +7,7 @@ import type { PropertyDescriptor } from '../types.js';
 interface Props {
     rows: {
         descriptor: PropertyDescriptor;
-        value: string | null;
+        value: PropertyValue;
     }[];
 }
 declare const EditPanel: import("svelte").Component<Props, {}, "">;

package/dist/edit/chrome/LinkEdit.svelte

@@ -4,7 +4,9 @@
 	import Icon from '../../components/ui/Icon.svelte';
 	import Modal from '../../components/ui/Modal.svelte';
 	import { getUiConfig } from '../../config/context.js';
+	import type { ParameterlessKey } from '../../config/types.js';
 	import { getEditAdapter } from '../context.js';
+	import { propertyValue } from '../commit.svelte.js';
 	import type { EditDescriptor, EntityOp, PropertyDescriptor } from '../types.js';
 	import ConfirmDialog from './ConfirmDialog.svelte';
 
@@ -31,7 +33,11 @@
 		href: { descriptor: PropertyDescriptor | undefined; value: string };
 		/**
 		 * Extra property rows under Adreça — a menu link's Ordre. Labelled from
-		 * their descriptors, committed on Desa only when changed.
+		 * their descriptors, committed on Desa only when changed, and rendered
+		 * BY TYPE: this used to be a bare text input whatever the descriptor
+		 * said, which made it a second renderer that would silently miss any
+		 * property type the package grew. An `image` row has no place in a link
+		 * modal and is the one type refused here.
 		 */
 		extras?: { descriptor: PropertyDescriptor; value: string | null }[];
 		/** With `adapter.applyOp`, the modal gains a confirmed Elimina action. */
@@ -57,7 +63,14 @@
 	const editing = $derived(text.edit !== undefined && (adapter?.isEditing ?? false));
 	// Every field beyond the text needs both a place and a verb to save with.
 	const editsHref = $derived(href.descriptor !== undefined && adapter?.saveProperty !== undefined);
-	const editableExtras = $derived(adapter?.saveProperty !== undefined ? (extras ?? []) : []);
+	const editableExtras = $derived(
+		adapter?.saveProperty !== undefined
+			? (extras ?? []).filter((extra) => extra.descriptor.type !== 'image')
+			: []
+	);
+
+	/** A flag state's wording, from the same catalog the site renders. */
+	const wording = (key: ParameterlessKey): string => config.messages[key]?.() ?? key;
 	const removable = $derived(removeOp !== undefined && adapter?.applyOp !== undefined);
 
 	let open = $state(false);
@@ -104,7 +117,8 @@
 			for (const [index, extra] of editableExtras.entries()) {
 				const next = draftExtras[index].trim();
 				if (next === (extra.value ?? '')) continue;
-				await adapter.saveProperty!(extra.descriptor, next);
+				// A flag extra hands the adapter a BOOLEAN, like a panel row does.
+				await adapter.saveProperty!(extra.descriptor, propertyValue(extra.descriptor, next));
 				draftExtras[index] = next;
 			}
 			open = false;
@@ -167,7 +181,25 @@
 			{#each editableExtras as extra, index (index)}
 				<label>
 					<span>{extra.descriptor.label}</span>
-					<input type="text" bind:value={draftExtras[index]} disabled={saving} />
+					{#if extra.descriptor.type === 'select'}
+						<select bind:value={draftExtras[index]} disabled={saving}>
+							{#each extra.descriptor.options ?? [] as option (option.value)}
+								<option value={option.value}>{option.label}</option>
+							{/each}
+						</select>
+					{:else if extra.descriptor.type === 'flag'}
+						<select bind:value={draftExtras[index]} disabled={saving}>
+							<option value="true">{wording(extra.descriptor.on ?? 'status_published')}</option>
+							<option value="false">{wording(extra.descriptor.off ?? 'status_draft')}</option>
+						</select>
+					{:else}
+						<input
+							type={extra.descriptor.type === 'date' ? 'date' : 'text'}
+							placeholder={extra.descriptor.placeholder}
+							bind:value={draftExtras[index]}
+							disabled={saving}
+						/>
+					{/if}
 				</label>
 			{/each}
 		</div>

package/dist/edit/chrome/LinkEdit.svelte.d.ts

@@ -29,7 +29,11 @@ interface Props {
     };
     /**
      * Extra property rows under Adreça — a menu link's Ordre. Labelled from
-     * their descriptors, committed on Desa only when changed.
+     * their descriptors, committed on Desa only when changed, and rendered
+     * BY TYPE: this used to be a bare text input whatever the descriptor
+     * said, which made it a second renderer that would silently miss any
+     * property type the package grew. An `image` row has no place in a link
+     * modal and is the one type refused here.
      */
     extras?: {
         descriptor: PropertyDescriptor;

package/dist/edit/chrome/PropertyRow.svelte

@@ -1,20 +1,28 @@
 <script lang="ts">
 	import { getUiConfig } from '../../config/context.js';
+	import type { ParameterlessKey } from '../../config/types.js';
 	import { getEditAdapter } from '../context.js';
-	import type { PropertyDescriptor } from '../types.js';
+	import { commitState, propertyValue } from '../commit.svelte.js';
+	import type { PropertyDescriptor, PropertyValue } from '../types.js';
 
 	/**
 	 * One property of an EditPanel: label, a control by `descriptor.type`, and
-	 * its own commit lifecycle — Editable's state machine, panel-shaped. Each
-	 * row commits on change/blur independently; a failed save keeps the draft
-	 * in the control so nothing typed is lost.
+	 * its own commit lifecycle — literally Editable's now, through
+	 * `../commit.svelte.js`, where it used to be a second copy of the same
+	 * four states, the same follow-the-prop effect and the same three
+	 * announcements. Each row commits on change/blur independently; a failed
+	 * save keeps the draft in the control so nothing typed is lost.
 	 *
 	 * The row assumes an adapter with `saveProperty` exists — EditPanel only
 	 * renders when the frame's triple gate already established both.
+	 *
+	 * The control state is text throughout — a flag's boolean rides as
+	 * 'true'/'false' in its <select> and becomes a boolean again only at the
+	 * adapter boundary, so one draft/saved pair serves every type.
 	 */
 	interface Props {
 		descriptor: PropertyDescriptor;
-		value: string | null;
+		value: PropertyValue;
 	}
 
 	let { descriptor, value }: Props = $props();
@@ -22,57 +30,47 @@
 	const adapter = getEditAdapter();
 	const config = getUiConfig();
 
-	let status = $state<'idle' | 'dirty' | 'saving' | 'error'>('idle');
-	let announcement = $state('');
-	/** Last persisted value, what a failed draft is measured against. */
+	/** The control's reading of a property value. */
+	const asText = (next: PropertyValue): string =>
+		typeof next === 'boolean' ? String(next) : (next ?? '');
+
+	/** A flag state's wording, from the same catalog the site renders. */
+	const wording = (key: ParameterlessKey): string => config.messages[key]?.() ?? key;
+
 	// svelte-ignore state_referenced_locally
-	let savedValue = $state(value ?? '');
+	const commit_ = commitState(asText(value), config.editMessages);
 	// svelte-ignore state_referenced_locally
-	let draft = $state(value ?? '');
+	let draft = $state(asText(value));
 	let fileInput: HTMLInputElement | undefined = $state();
 
-	// Follow the prop only while idle — never repaint a held draft (the
-	// Editable rule).
-	// svelte-ignore state_referenced_locally
-	let lastPropValue = $state(value ?? '');
 	$effect(() => {
-		const next = value ?? '';
-		if (next !== lastPropValue) {
-			lastPropValue = next;
-			if (status === 'idle') {
-				savedValue = next;
-				draft = next;
-			}
-		}
+		const adopted = commit_.follow(asText(value));
+		if (adopted !== null) draft = adopted;
 	});
 
-	async function persist(next: string | null): Promise<void> {
+	async function persist(next: PropertyValue): Promise<void> {
 		if (!adapter?.saveProperty) return;
-		status = 'saving';
-		announcement = config.editMessages.edit_saving();
-		try {
-			await adapter.saveProperty(descriptor, next);
-			savedValue = next ?? '';
-			draft = next ?? '';
-			status = 'idle';
-			announcement = config.editMessages.edit_saved();
-		} catch {
-			// Draft stays in the control; the editor decides whether to retry.
-			status = 'error';
-			announcement = config.editMessages.edit_saveError();
-		}
+		const landed = await commit_.commit(asText(next), () =>
+			adapter.saveProperty!(descriptor, next)
+		);
+		// Draft stays in the control on failure; the editor decides whether to
+		// retry. On success it takes the value the adapter actually stored.
+		if (landed) draft = asText(next);
 	}
 
 	function commit(): void {
 		const trimmed = draft.trim();
-		if (trimmed === savedValue) {
-			status = 'idle';
+		if (trimmed === commit_.saved) {
+			commit_.settle();
+			return;
+		}
+		if (descriptor.type === 'flag') {
+			void persist(propertyValue(descriptor, trimmed));
 			return;
 		}
 		if (trimmed === '') {
 			if (!descriptor.nullable) {
-				status = 'error';
-				announcement = config.editMessages.edit_emptyRequired();
+				commit_.refuse(config.editMessages.edit_emptyRequired());
 				return;
 			}
 			void persist(null);
@@ -82,20 +80,21 @@
 	}
 
 	function markDirty(): void {
-		if (status !== 'saving') status = 'dirty';
+		commit_.markDirty();
 	}
 
 	async function upload(event: Event): Promise<void> {
 		const file = (event.currentTarget as HTMLInputElement).files?.[0];
 		if (!file || !adapter?.uploadImage) return;
-		status = 'saving';
-		announcement = config.editMessages.edit_saving();
 		try {
-			const path = await adapter.uploadImage(descriptor, file);
-			await persist(path);
-		} catch {
-			status = 'error';
-			announcement = config.editMessages.edit_saveError();
+			// The upload and the write are ONE gesture to the editor, so the
+			// upload runs inside the same commit: a failed upload reports as a
+			// failed save, which is what it is from the panel's side.
+			await commit_.commit(asText(value), async () => {
+				const path = await adapter.uploadImage!(descriptor, file);
+				await adapter.saveProperty!(descriptor, path);
+				draft = asText(path);
+			});
 		} finally {
 			if (fileInput) fileInput.value = '';
 		}
@@ -111,7 +110,7 @@
 	{#if descriptor.type === 'select'}
 		<select
 			{id}
-			data-vit-editing={status}
+			data-vit-editing={commit_.status}
 			value={draft}
 			onchange={(event) => {
 				draft = event.currentTarget.value;
@@ -122,14 +121,29 @@
 				<option value={option.value}>{option.label}</option>
 			{/each}
 		</select>
+	{:else if descriptor.type === 'flag'}
+		<!-- Two states, worded from the catalog: the host names the pair
+		     (published/draft, open/closed), the adapter receives a boolean. -->
+		<select
+			{id}
+			data-vit-editing={commit_.status}
+			value={draft}
+			onchange={(event) => {
+				draft = event.currentTarget.value;
+				commit();
+			}}
+		>
+			<option value="true">{wording(descriptor.on ?? 'status_published')}</option>
+			<option value="false">{wording(descriptor.off ?? 'status_draft')}</option>
+		</select>
 	{:else if descriptor.type === 'image'}
-		{#if savedValue}
-			<img class="thumb" src={savedValue} alt="" />
+		{#if commit_.saved}
+			<img class="thumb" src={commit_.saved} alt="" />
 		{/if}
 		<input
 			{id}
 			type="text"
-			data-vit-editing={status}
+			data-vit-editing={commit_.status}
 			placeholder={descriptor.placeholder}
 			bind:value={draft}
 			oninput={markDirty}
@@ -152,7 +166,7 @@
 		<input
 			{id}
 			type={descriptor.type === 'date' ? 'date' : descriptor.type === 'url' ? 'url' : 'text'}
-			data-vit-editing={status}
+			data-vit-editing={commit_.status}
 			placeholder={descriptor.placeholder}
 			bind:value={draft}
 			oninput={markDirty}
@@ -160,7 +174,7 @@
 		/>
 	{/if}
 
-	{#if descriptor.nullable && savedValue !== ''}
+	{#if descriptor.nullable && commit_.saved !== ''}
 		<button
 			type="button"
 			class="aux"
@@ -173,7 +187,7 @@
 		</button>
 	{/if}
 
-	<span class="status" role="status">{announcement}</span>
+	<span class="status" role="status">{commit_.announcement}</span>
 </div>
 
 <style>

package/dist/edit/chrome/PropertyRow.svelte.d.ts

@@ -1,16 +1,22 @@
-import type { PropertyDescriptor } from '../types.js';
+import type { PropertyDescriptor, PropertyValue } from '../types.js';
 /**
  * One property of an EditPanel: label, a control by `descriptor.type`, and
- * its own commit lifecycle — Editable's state machine, panel-shaped. Each
- * row commits on change/blur independently; a failed save keeps the draft
- * in the control so nothing typed is lost.
+ * its own commit lifecycle — literally Editable's now, through
+ * `../commit.svelte.js`, where it used to be a second copy of the same
+ * four states, the same follow-the-prop effect and the same three
+ * announcements. Each row commits on change/blur independently; a failed
+ * save keeps the draft in the control so nothing typed is lost.
  *
  * The row assumes an adapter with `saveProperty` exists — EditPanel only
  * renders when the frame's triple gate already established both.
+ *
+ * The control state is text throughout — a flag's boolean rides as
+ * 'true'/'false' in its <select> and becomes a boolean again only at the
+ * adapter boundary, so one draft/saved pair serves every type.
  */
 interface Props {
     descriptor: PropertyDescriptor;
-    value: string | null;
+    value: PropertyValue;
 }
 declare const PropertyRow: import("svelte").Component<Props, {}, "">;
 type PropertyRow = ReturnType<typeof PropertyRow>;

package/dist/edit/collection.svelte.d.ts

@@ -0,0 +1,49 @@
+import type { CollectionRef, EntityOp } from './types.js';
+type CreateOp = Extract<EntityOp, {
+    kind: 'create';
+}>;
+type RemoveOp = Extract<EntityOp, {
+    kind: 'remove';
+}>;
+/** An edit map a list may inject removal into. */
+export interface RemovableMap {
+    /** Set by the list from its `collection` — removal of this row. */
+    removeOp?: RemoveOp;
+}
+/**
+ * The structural half of one editable LIST, as its template reads it.
+ * Both members answer `undefined` while the collection is not live, so the
+ * template's `{#if}` is the whole gate.
+ */
+export interface CollectionEditing<Row, Map extends RemovableMap> {
+    /** The create op for the add slot at the end of the list. */
+    readonly add: CreateOp | undefined;
+    /** The create op for an add slot anchored before one row (Timeline). */
+    addBefore(id: string | number): CreateOp | undefined;
+    /**
+     * The host's map for one row, plus the remove op the LIST injects — lists
+     * own identity, so a host never spells a removal. Rows without an `id`
+     * keep the host's map untouched: a remove op needs an identity, and
+     * read-only hosts never pass one.
+     */
+    mapFor(row: Row): Map | undefined;
+}
+/**
+ * What every list with a `collection` prop used to repeat — Timeline,
+ * CollaboratorList, JobList, Nav and Footer each carried the triple gate
+ * (collection named ∧ adapter editing ∧ `applyOp` present) and the same
+ * remove-op injection, five times verbatim. One helper, one place to keep
+ * the rule: a structural affordance renders only when all three hold.
+ *
+ * `read` is a thunk over the list's props so both stay reactive; the
+ * adapter comes from context, so call this during component init like
+ * `getEditAdapter` itself.
+ */
+export declare function collectionEditing<Row extends {
+    id?: string | number;
+}, Map extends RemovableMap>(read: () => {
+    collection: CollectionRef | undefined;
+    /** The host's per-row map (`editFor`, or Nav/Footer's `propertiesFor`). */
+    editFor: ((row: Row) => Map | undefined) | undefined;
+}): CollectionEditing<Row, Map>;
+export {};

package/dist/edit/collection.svelte.js

@@ -0,0 +1,39 @@
+import { getEditAdapter } from './context.js';
+/**
+ * What every list with a `collection` prop used to repeat — Timeline,
+ * CollaboratorList, JobList, Nav and Footer each carried the triple gate
+ * (collection named ∧ adapter editing ∧ `applyOp` present) and the same
+ * remove-op injection, five times verbatim. One helper, one place to keep
+ * the rule: a structural affordance renders only when all three hold.
+ *
+ * `read` is a thunk over the list's props so both stay reactive; the
+ * adapter comes from context, so call this during component init like
+ * `getEditAdapter` itself.
+ */
+export function collectionEditing(read) {
+    const adapter = getEditAdapter();
+    const live = $derived.by(() => {
+        const { collection } = read();
+        return collection !== undefined &&
+            (adapter?.isEditing ?? false) &&
+            adapter?.applyOp !== undefined
+            ? collection
+            : undefined;
+    });
+    return {
+        get add() {
+            return live ? { kind: 'create', collection: live } : undefined;
+        },
+        addBefore(id) {
+            return live
+                ? { kind: 'create', collection: live, anchor: { id, placement: 'before' } }
+                : undefined;
+        },
+        mapFor(row) {
+            const map = read().editFor?.(row);
+            if (!live || row.id === undefined)
+                return map;
+            return { ...map, removeOp: { kind: 'remove', collection: live, id: row.id } };
+        }
+    };
+}

package/dist/edit/commit.svelte.d.ts

@@ -0,0 +1,58 @@
+import type { EditMessages } from '../config/edit-messages.js';
+import type { PropertyDescriptor, PropertyValue } from './types.js';
+/**
+ * The commit lifecycle of ONE editable value — the state machine
+ * `Editable` and `PropertyRow` both ran, in one place.
+ *
+ * They implemented it twice: the same four states, the same "follow the prop
+ * only while idle" effect with the same `lastPropValue` trick, and the same
+ * three announcements read from the same three message keys. The inline
+ * editor's suite covered one of them, so a bug in commit-or-rollback
+ * semantics had two homes and one test surface. `LinkEdit` is deliberately
+ * NOT a caller: a modal that batch-commits several halves and reports a
+ * partial failure is a different shape, not a simpler version of this one.
+ *
+ * Where the draft LIVES stays the caller's business — the DOM owns it for a
+ * `contenteditable`, a `$state` string owns it for a panel control — which is
+ * why this holds `saved` and the status but never the draft.
+ */
+export type CommitStatus = 'idle' | 'dirty' | 'saving' | 'error';
+export interface CommitState<T> {
+    /** What the affordance paints (`data-vit-editing`). */
+    readonly status: CommitStatus;
+    /** The visually hidden `role="status"` line. */
+    readonly announcement: string;
+    /** The last persisted value: what a revert restores and a commit diffs against. */
+    readonly saved: T;
+    /** Typing began. Never overrides an in-flight save. */
+    markDirty(): void;
+    /** Back to rest without a write — an unchanged draft. */
+    settle(): void;
+    /** Escape: back to rest AND silent, the announcement withdrawn with the draft. */
+    revert(): void;
+    /** Refuse before any write, with its own reason (an emptied required field). */
+    refuse(announcement: string): void;
+    /**
+     * Runs one write. Announces each phase, advances `saved` on success, and
+     * leaves the state at `'error'` on rejection so the caller's draft can stay
+     * on screen. Answers whether it landed.
+     */
+    commit(next: T, write: () => Promise<void>): Promise<boolean>;
+    /**
+     * Adopt a value the app reloaded underneath us — and only while idle.
+     * Diffing against `saved` instead would fire after every save, where
+     * `saved` has legitimately advanced past the prop, and repaint the
+     * committed draft with stale copy. Never over a draft being held.
+     *
+     * Answers the value the caller should render, or `null` for "leave it".
+     */
+    follow(next: T): T | null;
+}
+export declare function commitState<T>(initial: T, messages: EditMessages): CommitState<T>;
+/**
+ * A control's string draft as the value the ADAPTER takes. Every control's
+ * state is text — a flag's boolean rides as `'true'`/`'false'` in its
+ * `<select>` — and this is the one place it becomes a boolean again, so the
+ * panel row and the link modal cannot disagree about the boundary.
+ */
+export declare function propertyValue(descriptor: PropertyDescriptor, draft: string): PropertyValue;