@keemakr/ui-sdk 1.5.0 → 1.6.0-dev-20261026104018

package/dist/conform.js

@@ -0,0 +1,310 @@
+// Fit a negotiated tree to the schema an app really parses with (published/index.ts).
+//
+// Negotiation (negotiate.ts) swaps the node TYPES an app cannot draw. Two kinds of drift are left,
+// and this file closes both against the app's own published schema:
+//
+// 1. A value or shape the app's parse REFUSES fails the whole screen. Known ones are folded to the
+//    nearest value the parse takes; anything else replaces the smallest node that holds it:
+//      - a chart's `chartType: 'area'` (after 1.4.0)          -> 'line' (a chart's `stacked` and
+//        `legend` are stripped by such a parse, so its bars are drawn side by side)
+//      - `tone: 'info' | 'accent'` (badge cells, tags, board columns, calendar entries, progress
+//        bars; after 1.4.0)                    -> 'default', or the first tone that parse lists
+//      - a string `min`/`max` on a date or datetime field (after 1.4.0)  -> dropped
+//      - an image's or video's portrait `aspect: '3:4' | '9:16'` (after 1.4.0)
+//                                              -> 'auto', so the picture keeps its own shape
+//      - a chart with more points than the parse takes (120 after 1.4.0, 50 before)
+//                                              -> thinned to that many evenly spaced points,
+//                                                 first and last kept (chart.ts)
+//      - anything else the parse refuses (a longer label, a larger list, a value no fold knows)
+//                                              -> the node's own text fallback
+// 2. A SAFETY field the app's parse STRIPS while it keeps the control (a `confirm`, or
+//    `disabled: true`) would leave a control that acts without asking, or acts when it must not.
+//    Found by comparing the tree with what the parse returns, so every such field is caught, not
+//    only the ones listed here. Known today: a form's `submit.confirm` (ui-sdk 1.1.0 drops it).
+//    A control in a list of controls (header `actions`, row `actions`, bulk `actions`, form
+//    `secondary`, `headerControls`) is dropped; any other node becomes one calm line.
+//
+// Pure, and bounded by the screen's size: each parse lists every issue at once and they are all
+// repaired before the next parse, so a 500-row table with a refused tone in every row costs one
+// repair pass, not 500 parses. Every repair makes the tree strictly simpler (a value folded to one
+// the parse lists, a key or a control removed, a node replaced by its fallback and that by one
+// line), so the number of repairs is bounded by the number of objects in the tree; the passes are
+// capped at that bound, and a pass that can repair nothing ends the loop. Only then does the
+// screen become one line.
+import { thinChart } from './chart.js';
+/** Repairs one object of a tree can take at most: a tone, a min, a max, a drop, two replacements. */
+const REPAIRS_PER_OBJECT = 6;
+/** Lists of controls a client can lose one of without losing the node that holds them. */
+const CONTROL_LISTS = new Set(['actions', 'secondary', 'headerControls']);
+/** Keys of a tree's root that are not optional: the tree cannot do without them. */
+const ROOT_REQUIRED = new Set(['version', 'title', 'children']);
+const isObject = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+const pathText = (path) => path
+    .map((part, index) => typeof part === 'number' ? `[${part}]` : index === 0 ? part : `.${part}`)
+    .join('');
+function at(root, path) {
+    let here = root;
+    for (const part of path) {
+        if (here === null || typeof here !== 'object')
+            return undefined;
+        here = here[part];
+    }
+    return here;
+}
+/** The deepest `children[i]` on the path: the node that holds whatever the path points at. */
+function nodeAt(path) {
+    for (let i = path.length - 1; i >= 1; i--) {
+        if (path[i - 1] === 'children' && typeof path[i] === 'number')
+            return path.slice(0, i + 1);
+    }
+    return null;
+}
+/** The deepest element of a list of controls on the path, if it is nearer than any node. */
+function controlAt(path) {
+    const node = nodeAt(path);
+    for (let i = path.length - 1; i >= 1; i--) {
+        if (node && i < node.length)
+            break;
+        const list = path[i - 1];
+        if (typeof list === 'string' && CONTROL_LISTS.has(list) && typeof path[i] === 'number') {
+            return path.slice(0, i + 1);
+        }
+    }
+    return null;
+}
+/** Remove one control from its list; an emptied list goes, and so does a bulk bar left empty. */
+function dropControl(tree, path) {
+    const listPath = path.slice(0, -1);
+    const list = at(tree, listPath);
+    list.splice(path[path.length - 1], 1);
+    if (list.length > 0)
+        return;
+    const holderPath = listPath.slice(0, -1);
+    const holder = at(tree, holderPath);
+    delete holder[listPath[listPath.length - 1]];
+    if (holderPath[holderPath.length - 1] === 'bulk') {
+        const table = at(tree, holderPath.slice(0, -1));
+        delete table.bulk;
+    }
+}
+function setAt(tree, path, value) {
+    const holder = at(tree, path.slice(0, -1));
+    holder[path[path.length - 1]] = value;
+}
+/** Every object whose `confirm` or `disabled: true` the parse dropped while keeping it. */
+function strippedSafety(sent, kept, path = [], out = []) {
+    if (Array.isArray(sent)) {
+        if (!Array.isArray(kept))
+            return out;
+        for (let i = 0; i < sent.length; i++)
+            strippedSafety(sent[i], kept[i], [...path, i], out);
+        return out;
+    }
+    if (!isObject(sent) || !isObject(kept))
+        return out;
+    if ((typeof sent.confirm === 'string' && kept.confirm !== sent.confirm) ||
+        (sent.disabled === true && kept.disabled !== true)) {
+        out.push(path);
+        return out;
+    }
+    for (const [key, value] of Object.entries(sent)) {
+        strippedSafety(value, kept[key], [...path, key], out);
+    }
+    return out;
+}
+/** How many objects and arrays the tree holds: what bounds the repairs. */
+function sizeOf(value) {
+    let count = 0;
+    const stack = [value];
+    while (stack.length > 0) {
+        const here = stack.pop();
+        if (here === null || typeof here !== 'object')
+            continue;
+        count += 1;
+        for (const child of Array.isArray(here) ? here : Object.values(here)) {
+            if (child !== null && typeof child === 'object')
+                stack.push(child);
+        }
+    }
+    return count;
+}
+/**
+ * Later paths first: a higher index before a lower one in the same list (removing one control
+ * does not move the ones still to come), and a longer path before its own prefix.
+ */
+function laterFirst(a, b) {
+    const n = Math.min(a.length, b.length);
+    for (let i = 0; i < n; i++) {
+        const x = a[i];
+        const y = b[i];
+        if (x === y)
+            continue;
+        if (typeof x === 'number' && typeof y === 'number')
+            return y - x;
+        return String(y) < String(x) ? -1 : 1;
+    }
+    return b.length - a.length;
+}
+const pathKey = (path) => path.join('\u0000');
+/**
+ * The tree as `parser` takes it, with every change listed. The input is not touched. Each change
+ * keeps the tree valid against this package's own schema.
+ */
+export function conformTree(tree, parser, options) {
+    const work = structuredClone(tree);
+    const fallbacks = [];
+    // What one pass removed or replaced: a later issue inside it has nothing left to repair.
+    // Kept as path keys, so checking an issue costs its depth, not the number of repairs so far.
+    let gone = new Set();
+    const markGone = (path) => {
+        gone.add(pathKey(path));
+    };
+    const isGone = (path) => {
+        for (let i = 1; i <= path.length; i++)
+            if (gone.has(pathKey(path.slice(0, i))))
+                return true;
+        return false;
+    };
+    const replaceNode = (path, reason, line) => {
+        const node = at(work, path);
+        const type = typeof node?.type === 'string' ? node.type : 'unknown';
+        let next = line ? { type: 'text', value: line, muted: true } : options.fallback(node);
+        // A node that is already its own fallback (a text this parse still refuses) says less instead.
+        if (JSON.stringify(next) === JSON.stringify(node)) {
+            next = { type: 'text', value: options.genericText, muted: true };
+            // Already the last line it can say: nothing simpler is left, so this is no repair.
+            if (JSON.stringify(next) === JSON.stringify(node))
+                return false;
+        }
+        setAt(work, path, next);
+        markGone(path);
+        fallbacks.push({ path: pathText(path), type, reason, as: next.type });
+        return true;
+    };
+    const drop = (control, reason) => {
+        dropControl(work, control);
+        markGone(control);
+        fallbacks.push({ path: pathText(control), type: 'control', reason, as: 'dropped' });
+        return true;
+    };
+    const repair = (issue) => {
+        const path = issue.path;
+        if (isGone(path))
+            return false;
+        const key = path[path.length - 1];
+        const holder = at(work, path.slice(0, -1));
+        if (key === 'tone' && issue.code === 'invalid_value' && isObject(holder)) {
+            const values = issue.values ?? [];
+            const folded = values.includes('default') ? 'default' : values[0];
+            if (holder.tone === folded)
+                return false;
+            holder.tone = folded;
+            fallbacks.push({ path: pathText(path), type: 'tone', reason: 'parse', as: 'folded' });
+            return true;
+        }
+        if (key === 'chartType' &&
+            issue.code === 'invalid_value' &&
+            isObject(holder) &&
+            holder.type === 'chart' &&
+            holder.chartType === 'area' &&
+            (issue.values ?? []).includes('line')) {
+            // An area is a line with the room under it filled: the line keeps the trend.
+            holder.chartType = 'line';
+            fallbacks.push({ path: pathText(path), type: 'chartType', reason: 'parse', as: 'folded' });
+            return true;
+        }
+        if (key === 'aspect' &&
+            issue.code === 'invalid_value' &&
+            isObject(holder) &&
+            (holder.type === 'image' || holder.type === 'video') &&
+            holder.aspect !== 'auto' &&
+            (issue.values ?? []).includes('auto')) {
+            // A portrait photograph cropped to a landscape box loses what it shows; `auto` draws it at
+            // its own shape, which for a portrait picture is the shape the module asked for.
+            holder.aspect = 'auto';
+            fallbacks.push({ path: pathText(path), type: 'aspect', reason: 'parse', as: 'folded' });
+            return true;
+        }
+        if ((key === 'min' || key === 'max') && isObject(holder) && key in holder) {
+            delete holder[key];
+            fallbacks.push({ path: pathText(path), type: String(key), reason: 'parse', as: 'folded' });
+            return true;
+        }
+        if ((key === 'categories' || key === 'values') && issue.code === 'too_big') {
+            const chartPath = key === 'categories' ? path.slice(0, -1) : path.slice(0, -3);
+            const chart = at(work, chartPath);
+            const limit = Number(issue.maximum);
+            if ((key === 'categories' || path[path.length - 3] === 'series') &&
+                isObject(chart) &&
+                chart.type === 'chart' &&
+                Array.isArray(chart.categories) &&
+                Array.isArray(chart.series) &&
+                Number.isInteger(limit) &&
+                limit >= 1) {
+                // Every too-big list of one chart is one thinning: a later issue of it finds it done.
+                if (chart.categories.length <= limit)
+                    return false;
+                setAt(work, chartPath, thinChart(chart, limit));
+                fallbacks.push({ path: pathText(chartPath), type: 'chart', reason: 'parse', as: 'folded' });
+                return true;
+            }
+        }
+        const control = controlAt(path);
+        if (control)
+            return isGone(control) ? false : drop(control, 'parse');
+        const node = nodeAt(path);
+        if (node)
+            return isGone(node) ? false : replaceNode(node, 'parse');
+        const root = path[0];
+        if (typeof root === 'string' && !ROOT_REQUIRED.has(root) && root in work) {
+            delete work[root];
+            markGone([root]);
+            fallbacks.push({ path: root, type: root, reason: 'parse', as: 'dropped' });
+            return true;
+        }
+        return false;
+    };
+    const guard = (unsafe) => {
+        if (isGone(unsafe))
+            return false;
+        const control = controlAt(unsafe);
+        if (control)
+            return isGone(control) ? false : drop(control, 'safety');
+        const node = nodeAt(unsafe);
+        if (!node || isGone(node))
+            return false;
+        return replaceNode(node, 'safety', options.safetyText);
+    };
+    const maxPasses = REPAIRS_PER_OBJECT * sizeOf(work) + 2;
+    for (let pass = 0; pass < maxPasses; pass++) {
+        gone = new Set();
+        const parsed = parser.safeParse(work);
+        // Every issue of this parse, later paths first, each repaired once.
+        const found = parsed.success
+            ? strippedSafety(work, parsed.data)
+            : parsed.error.issues.map((issue) => issue.path);
+        if (found.length === 0)
+            return { tree: work, fallbacks };
+        const order = found
+            .map((path, index) => ({ path, index }))
+            .sort((a, b) => laterFirst(a.path, b.path));
+        let repaired = false;
+        for (const { path, index } of order) {
+            const did = parsed.success ? guard(path) : repair(parsed.error.issues[index]);
+            repaired = did || repaired;
+        }
+        if (!repaired)
+            break;
+    }
+    // Nothing above made the tree acceptable: send the screen as one line rather than a broken one.
+    const title = typeof work.title === 'string' ? work.title : '';
+    fallbacks.push({ path: 'children', type: 'screen', reason: 'parse', as: 'text' });
+    return {
+        tree: {
+            version: 1,
+            title,
+            children: [{ type: 'text', value: options.genericText, muted: true }],
+        },
+        fallbacks,
+    };
+}

package/dist/dataset.d.ts

@@ -62,9 +62,9 @@ export declare const datasetFieldSchema: z.ZodObject<{
     type: z.ZodEnum<{
         number: "number";
         boolean: "boolean";
-        text: "text";
-        datetime: "datetime";
         date: "date";
+        datetime: "datetime";
+        text: "text";
         enum: "enum";
         url: "url";
         tags: "tags";
@@ -102,9 +102,9 @@ export declare const datasetDeclarationSchema: z.ZodObject<{
         type: z.ZodEnum<{
             number: "number";
             boolean: "boolean";
-            text: "text";
-            datetime: "datetime";
             date: "date";
+            datetime: "datetime";
+            text: "text";
             enum: "enum";
             url: "url";
             tags: "tags";
@@ -159,9 +159,9 @@ export declare const datasetManifestSchema: z.ZodArray<z.ZodObject<{
         type: z.ZodEnum<{
             number: "number";
             boolean: "boolean";
-            text: "text";
-            datetime: "datetime";
             date: "date";
+            datetime: "datetime";
+            text: "text";
             enum: "enum";
             url: "url";
             tags: "tags";

package/dist/date-format.d.ts

@@ -0,0 +1,64 @@
+/** How a screen writes dates and times. Every field is optional. */
+export interface DateFormat {
+    /** Lead with the short weekday: "Thu 15 Oct". Default false. */
+    weekday?: boolean;
+    /**
+     * When to write the year. `always` (the default) writes it, `never` leaves it
+     * out, and `auto` leaves it out for a date in the current year (in the
+     * screen's time zone) and writes it otherwise.
+     */
+    year?: 'auto' | 'always' | 'never';
+    /**
+     * true: a 12-hour clock with a lowercase "am"/"pm" ("8:47 pm", the gap a
+     * no-break space). false: a 24-hour clock ("20:47"). Unset: the locale's
+     * own clock.
+     */
+    hour12?: boolean;
+    /**
+     * A BCP 47 locale the words follow, "en-GB", in place of the viewer's own.
+     * The order of day and month, and the commas, come from it.
+     */
+    locale?: string;
+}
+/** What a renderer draws: a date, a date and a time, or only the clock. */
+export type MomentStyle = 'date' | 'datetime' | 'time';
+/**
+ * The format one value is drawn with: the screen's, with the fields the node
+ * sets in its own `dateFormat` laid over it. undefined when neither sets one,
+ * which means "draw as before".
+ */
+export declare function mergeDateFormat(screen: DateFormat | undefined, own: DateFormat | undefined): DateFormat | undefined;
+/** True for a BCP 47 locale this runtime can format in: "en-GB", "fr-CA". */
+export declare function isDateLocale(value: string): boolean;
+/**
+ * The Intl options for a moment. Without a format these are the renderers'
+ * defaults (medium date, short time); with one, the parts it asks for.
+ */
+export declare function dateTimeFormatOptions(iso: string, style: MomentStyle, opts?: {
+    format?: DateFormat;
+    timeZone?: string;
+    now?: number;
+}): Intl.DateTimeFormatOptions;
+/**
+ * A moment as words, in `timeZone` (an IANA name; undefined is the runtime's
+ * own zone). `locale` is the viewer's (undefined: the runtime's), and a
+ * format's own `locale` wins over it. With `hour12: true` the day period is
+ * written lowercase without dots, "8:47 pm", whatever the locale writes, after
+ * a no-break space (U+00A0) so the time never wraps apart from it.
+ *
+ * Never throws for a locale the runtime cannot use: it falls back to the
+ * viewer's.
+ *
+ * ```ts
+ * formatMoment('2026-10-16T00:47:00Z', 'datetime', {
+ *   format: { weekday: true, year: 'auto', hour12: true, locale: 'en-GB' },
+ *   timeZone: 'America/Toronto',
+ * }); // "Thu 15 Oct, 8:47 pm" during 2026
+ * ```
+ */
+export declare function formatMoment(iso: string, style: MomentStyle, opts?: {
+    format?: DateFormat;
+    timeZone?: string;
+    locale?: string;
+    now?: number;
+}): string;

package/dist/date-format.js

@@ -0,0 +1,132 @@
+// Renderer-side helper for how a screen writes a moment: "Thu 15 Oct, 8:47 pm"
+// instead of the default "15 Oct 2026, 20:47". It lives in the SDK, not in a
+// renderer, because core and every client draw dates: the same tree must read
+// the same on web and mobile.
+//
+// A screen opts in with `tree.dateFormat`; a `timestamp` block or a `date` cell
+// may override single fields with its own `dateFormat`. Without either, a
+// renderer keeps its default (Intl's medium date and short time), so screens
+// that never set it draw exactly as before.
+const FIELDS = ['weekday', 'year', 'hour12', 'locale'];
+/**
+ * The format one value is drawn with: the screen's, with the fields the node
+ * sets in its own `dateFormat` laid over it. undefined when neither sets one,
+ * which means "draw as before".
+ */
+export function mergeDateFormat(screen, own) {
+    if (!screen && !own)
+        return undefined;
+    const out = {};
+    for (const source of [screen, own]) {
+        if (!source)
+            continue;
+        for (const key of FIELDS) {
+            if (source[key] !== undefined)
+                Object.assign(out, { [key]: source[key] });
+        }
+    }
+    return out;
+}
+/** True for a BCP 47 locale this runtime can format in: "en-GB", "fr-CA". */
+export function isDateLocale(value) {
+    try {
+        return Intl.DateTimeFormat.supportedLocalesOf([value]).length > 0;
+    }
+    catch {
+        return false;
+    }
+}
+/** The year a moment falls in, in a zone (undefined: the runtime's own). */
+function yearIn(ms, timeZone) {
+    return new Intl.DateTimeFormat('en-US', { year: 'numeric', timeZone }).format(new Date(ms));
+}
+/**
+ * The Intl options for a moment. Without a format these are the renderers'
+ * defaults (medium date, short time); with one, the parts it asks for.
+ */
+export function dateTimeFormatOptions(iso, style, opts = {}) {
+    const { format, timeZone } = opts;
+    if (!format) {
+        if (style === 'date')
+            return { dateStyle: 'medium', timeZone };
+        if (style === 'time')
+            return { timeStyle: 'short', timeZone };
+        return { dateStyle: 'medium', timeStyle: 'short', timeZone };
+    }
+    const options = { timeZone };
+    if (style !== 'time') {
+        if (format.weekday)
+            options.weekday = 'short';
+        options.day = 'numeric';
+        options.month = 'short';
+        const year = format.year ?? 'always';
+        const showYear = year === 'always' ||
+            (year === 'auto' &&
+                yearIn(Date.parse(iso), timeZone) !== yearIn(opts.now ?? Date.now(), timeZone));
+        if (showYear)
+            options.year = 'numeric';
+    }
+    if (style !== 'date') {
+        options.hour = 'numeric';
+        options.minute = '2-digit';
+        if (format.hour12 === true)
+            options.hourCycle = 'h12';
+        if (format.hour12 === false) {
+            // A 24-hour clock pads the hour: "08:05", "00:05".
+            options.hour = '2-digit';
+            options.hourCycle = 'h23';
+        }
+    }
+    return options;
+}
+/** "p.m.", "PM", "p. m." → "pm". Only an a/p + m day period is rewritten. */
+function lowerDayPeriod(value) {
+    const match = /^([ap])\.?\s?m\.?$/i.exec(value.trim());
+    return match ? `${match[1].toLowerCase()}m` : value;
+}
+/**
+ * A moment as words, in `timeZone` (an IANA name; undefined is the runtime's
+ * own zone). `locale` is the viewer's (undefined: the runtime's), and a
+ * format's own `locale` wins over it. With `hour12: true` the day period is
+ * written lowercase without dots, "8:47 pm", whatever the locale writes, after
+ * a no-break space (U+00A0) so the time never wraps apart from it.
+ *
+ * Never throws for a locale the runtime cannot use: it falls back to the
+ * viewer's.
+ *
+ * ```ts
+ * formatMoment('2026-10-16T00:47:00Z', 'datetime', {
+ *   format: { weekday: true, year: 'auto', hour12: true, locale: 'en-GB' },
+ *   timeZone: 'America/Toronto',
+ * }); // "Thu 15 Oct, 8:47 pm" during 2026
+ * ```
+ */
+export function formatMoment(iso, style, opts = {}) {
+    const options = dateTimeFormatOptions(iso, style, opts);
+    const date = new Date(iso);
+    const wanted = opts.format?.locale ?? opts.locale;
+    let formatter;
+    try {
+        formatter = new Intl.DateTimeFormat(wanted, options);
+    }
+    catch {
+        formatter = new Intl.DateTimeFormat(opts.locale, options);
+    }
+    if (opts.format?.hour12 !== true || style === 'date')
+        return formatter.format(date);
+    const parts = formatter.formatToParts(date);
+    return parts
+        .map((part, i) => {
+        if (part.type === 'dayPeriod')
+            return lowerDayPeriod(part.value);
+        // The gap before "pm" is a no-break space on every engine (ICU writes a
+        // narrow one, older engines a plain one), so "8:47 pm" never wraps apart.
+        if (part.type === 'literal' &&
+            parts[i + 1]?.type === 'dayPeriod' &&
+            /^\s+$/u.test(part.value)) {
+            return '\u00a0';
+        }
+        return part.value;
+    })
+        .join('');
+}

package/dist/drawer.d.ts

@@ -0,0 +1,22 @@
+import type { NavigatePress } from './schema.js';
+/** Where a screen is shown: a page of its own, or a drawer over another screen. */
+export type ScreenPlace = 'page' | 'drawer';
+/** True for a navigate press that opens its screen in a drawer. */
+export declare function opensInDrawer(press: {
+    kind: string;
+    open?: unknown;
+} | undefined): press is NavigatePress & {
+    open: 'drawer';
+};
+/**
+ * Where a navigate lands, from the screen it came from (`from`):
+ *   - a press with `open: 'drawer'` opens a drawer, or shows its screen in the drawer it was
+ *     pressed in (a drawer never opens another drawer);
+ *   - a press without it opens a page, and from a drawer that leaves the drawer;
+ *   - an action result's `navigate` (`via: 'result'`) stays where the action ran: a drawer's
+ *     action moves the drawer on ("Save and next"), a page's moves the page.
+ */
+export declare function screenPlace(navigate: {
+    screen: string;
+    open?: unknown;
+}, via: 'press' | 'result', from: ScreenPlace): ScreenPlace;

package/dist/drawer.js

@@ -0,0 +1,21 @@
+// Where a module screen opens (UI-14): as a page, or in a drawer over the screen the reader was
+// on. Core and every client host screens, so the rule is written once, here, and the same tree
+// opens the same way on web, on the phone and in core's own pages. The contract is on the
+// navigate press in schema.ts (`open`).
+/** True for a navigate press that opens its screen in a drawer. */
+export function opensInDrawer(press) {
+    return press?.kind === 'navigate' && press.open === 'drawer';
+}
+/**
+ * Where a navigate lands, from the screen it came from (`from`):
+ *   - a press with `open: 'drawer'` opens a drawer, or shows its screen in the drawer it was
+ *     pressed in (a drawer never opens another drawer);
+ *   - a press without it opens a page, and from a drawer that leaves the drawer;
+ *   - an action result's `navigate` (`via: 'result'`) stays where the action ran: a drawer's
+ *     action moves the drawer on ("Save and next"), a page's moves the page.
+ */
+export function screenPlace(navigate, via, from) {
+    if (via === 'result')
+        return from;
+    return navigate.open === 'drawer' ? 'drawer' : 'page';
+}

package/dist/edit.d.ts

@@ -0,0 +1,60 @@
+/** The `edit` fields these helpers read. Loose, so a client whose installed SDK predates them can
+ *  pass its own node. */
+export interface InlineEditLike {
+    action: string;
+    input?: Record<string, unknown>;
+    label?: string;
+}
+export interface InlineEditOption {
+    value: string;
+    label: string;
+}
+/** What an action press built by `inlineEditPress` looks like. */
+export interface InlineEditPress {
+    kind: 'action';
+    action: string;
+    input: Record<string, unknown>;
+}
+/** The edit control's accessible name and tooltip when the module gave no `label`. */
+export declare const INLINE_EDIT_DEFAULT_LABEL = "Edit";
+/** The edit control's accessible name and tooltip: the module's `label`, or "Edit". */
+export declare function inlineEditLabel(edit: Pick<InlineEditLike, 'label'>): string;
+/**
+ * The ONE action press Save posts: the edit's `action`, its `input`, and each field's key set to
+ * its new value. A value wins over `input` on the same key, because it is what the reader just
+ * typed.
+ */
+export declare function inlineEditPress(edit: InlineEditLike, values: Readonly<Record<string, string>>): InlineEditPress;
+/**
+ * Save for one table cell: `row` is the row's key, and the column's key holds the new value.
+ */
+export declare function tableCellEditPress(edit: InlineEditLike, column: string, rowKey: string, value: string): InlineEditPress;
+/** The cell fields these helpers read. */
+export interface EditableCellLike {
+    kind: string;
+    value?: unknown;
+}
+/** True for a cell an editable column lets the reader change: a `text` or `badge` cell. */
+export declare function cellEditable(cell: EditableCellLike | undefined): boolean;
+/**
+ * What a field starts with. An explicit `start` (a details item's `edit.value`) wins. With
+ * options, the option whose value or label is the shown text (a badge shows the label), or the
+ * first option. Without, the shown text.
+ */
+export declare function inlineEditStart(shown: string, options?: readonly InlineEditOption[], start?: string): string;
+/** The details item fields these helpers read. */
+export interface EditableDetailsItemLike {
+    value: EditableCellLike;
+    edit?: {
+        field: string;
+        options?: readonly InlineEditOption[];
+        value?: string;
+    };
+}
+/**
+ * What each field of an editable `details` block starts with, by field key. Items without `edit`
+ * (and date items, which cannot be edited) are left out.
+ */
+export declare function detailsEditStart(items: readonly EditableDetailsItemLike[]): Record<string, string>;
+/** True when any field differs from what it started with: an edit that holds the screen still. */
+export declare function inlineEditDirty(start: Readonly<Record<string, string>>, draft: Readonly<Record<string, string>>): boolean;