@mythicalos/ui-core 0.2.2 → 0.3.0

package/dist/logic/queue.d.ts

@@ -0,0 +1,142 @@
+import type { DeliveryClass } from "./sendbar.js";
+/** Queue record lifecycle. `queued` is the ONLY cancellable state (see `canCancelRow`). */
+export type QueueItemStatus = "queued" | "leased" | "delivered" | "canceled";
+/** One queue record, generic over the product: an opaque id, its class, its body, its status. */
+export interface QueueItem {
+    id: string;
+    cls: DeliveryClass;
+    body: string;
+    status: QueueItemStatus;
+}
+/**
+ * Why the queue cannot be shown. These stay DISTINCT on purpose (see `QUEUE_UNAVAILABLE_COPY`):
+ * collapsing them into one message would make the UI claim something it does not know.
+ *  - `unsupported`  — this deployment does not do queued delivery at all.
+ *  - `error`        — the read failed. Says only that; never that the queue is empty.
+ *  - `unaddressable` — there is no queue address to read for this target.
+ */
+export type QueueUnavailableReason = "unsupported" | "error" | "unaddressable";
+/**
+ * HONESTY INVARIANT (binding, do not reword): CAPABILITY-NEUTRAL empty copy. It reports what the
+ * READ returned and nothing else. It must never claim operational emptiness ("queue empty", "no
+ * pending deliveries"), never imply a store exists, and never restate the design card's
+ * "deliveries land here by class (ASAP interrupts · ON-DONE waits)" — that line is doubly false
+ * (it asserts a store AND the interrupt semantics `DELIVERY_HINT` corrects).
+ */
+export declare const QUEUE_EMPTY_COPY = "The queue read returned no records.";
+/** Stale = last-known data. NO retry/reconnect claim — nothing here is recovering on its own. */
+export declare const QUEUE_STALE_COPY = "Queue disconnected \u2014 showing the last received list.";
+export declare const QUEUE_LOADING_COPY = "Loading queue\u2026";
+/** The three unavailable reasons, each with its own copy. Asserted pairwise-distinct by test. */
+export declare const QUEUE_UNAVAILABLE_COPY: Record<QueueUnavailableReason, string>;
+export declare const QUEUE_CANCEL_ASK = "Cancel this delivery?";
+export declare const QUEUE_CANCEL_YES = "Cancel it";
+export declare const QUEUE_CANCEL_NO = "Keep";
+export declare const QUEUE_CANCEL_LABEL = "\u2715 cancel";
+/**
+ * Every structural class the queue renders. Named here — not typed literally in a binding — so the
+ * Preact and React bindings cannot drift.
+ */
+export declare const QUEUE_CLASSES: {
+    readonly panel: "my-queue";
+    readonly list: "my-queue__list";
+    readonly state: "my-queue__state";
+    readonly stale: "my-queue__stale";
+    readonly empty: "my-queue__empty";
+    readonly rowBody: "my-qrow__body";
+    readonly rowStatus: "my-qrow__status";
+    readonly cancel: "my-qrow__cancel";
+    readonly ask: "my-qrow__ask";
+    readonly actions: "my-qrow__acts";
+    readonly confirmYes: "my-qmini my-qmini--yes";
+    readonly confirmNo: "my-qmini my-qmini--no";
+};
+/**
+ * The queue's input. `stale` is its OWN state, never folded into `ok` — a failing poll that still
+ * holds the last received list is a materially different claim from a fresh successful read.
+ */
+export type QueueSource = {
+    kind: "loading";
+} | {
+    kind: "unavailable";
+    reason: QueueUnavailableReason;
+} | {
+    kind: "ok";
+    items: readonly QueueItem[];
+} | {
+    kind: "stale";
+    items: readonly QueueItem[];
+};
+/** What the panel body renders. `empty` is reachable from exactly one source arm — see below. */
+export type QueueView = {
+    kind: "state";
+    copy: string;
+} | {
+    kind: "empty";
+    copy: string;
+} | {
+    kind: "list";
+    items: readonly QueueItem[];
+    staleCopy: string | null;
+    /** See `isFreshSource` — false suppresses every cancel affordance in the list. */
+    fresh: boolean;
+};
+/**
+ * HONESTY INVARIANT (binding): only a completed SUCCESSFUL read is fresh. A `stale` list is
+ * last-known data — the poll is failing, so each row's status is what it WAS, not what it is. That
+ * makes a cancel control on a stale row a claim the component cannot support: it would assert the
+ * record is still `queued` right beside a banner saying the list is no longer current. Stale rows
+ * therefore render with no cancel affordance, and an armed confirm force-disarms when its source
+ * goes stale (`shouldDisarmCancel`).
+ */
+export declare function isFreshSource(source: QueueSource): boolean;
+/**
+ * HONESTY INVARIANT (binding): the empty presentation renders ONLY on `ok` + zero items — i.e. only
+ * after a fresh successful read actually returned nothing.
+ *  - `loading` renders the loading state, NEVER "empty" (an unfinished read knows nothing yet).
+ *  - `unavailable` renders its own distinct reason copy, NEVER "empty".
+ *  - `stale` with zero items renders a flagged (but empty) LIST, never the empty copy — the last
+ *    received list happening to be empty is not a fresh "there is nothing queued" claim.
+ *
+ * `unavailableDetail` lets a product ADD what it knows about a reason (e.g. which mode the daemon
+ * is in). It is APPENDED to this package's own sentence, never substituted for it — a caller
+ * therefore cannot collapse two reasons into one message, deliberately or by accident: the distinct
+ * base sentences always survive, so two reasons can never render identical copy.
+ */
+export declare function unavailableText(reason: QueueUnavailableReason, detail?: string): string;
+export declare function queueView(source: QueueSource, unavailableDetail?: Partial<Record<QueueUnavailableReason, string>>): QueueView;
+/** ASAP / ON-DONE badge label (verbatim). */
+export declare function queueBadgeLabel(cls: DeliveryClass): "ASAP" | "ON-DONE";
+/** Badge class: ASAP → accent-soft, ON-DONE → disabled-muted (design card). */
+export declare function queueBadgeClass(cls: DeliveryClass): string;
+/** The row class. An armed row swaps to the confirm presentation instead of a status modifier. */
+export declare function queueRowClass(status: QueueItemStatus, armed: boolean): string;
+/** Human status label — the status verbatim, never a friendlier synonym that loses precision. */
+export declare function queueStatusLabel(status: QueueItemStatus): string;
+/**
+ * HONESTY INVARIANT (binding): the cancel affordance exists ONLY on `queued` records AND only when
+ * the caller says the record is cancellable at all (`canCancel` — e.g. the viewer owns the queue).
+ * Every other status renders WITHOUT an active cancel control: no greyed-out button that implies a
+ * cancel could have happened, and never a control whose click would be rejected downstream.
+ */
+export declare function canCancelRow(status: QueueItemStatus, canCancel: boolean): boolean;
+export type CancelState = {
+    armedId: string | null;
+};
+export type CancelEvent = {
+    type: "arm";
+    id: string;
+} | {
+    type: "confirm";
+} | {
+    type: "disarm";
+};
+export declare function cancelReducer(state: CancelState, event: CancelEvent): CancelState;
+/**
+ * An armed two-step cancel must NEVER outlive its cancelability. Force-disarm when cancelability is
+ * lost (`canCancel` flips false), when the source stops being FRESH (it went stale, unavailable, or
+ * back to loading — the armed row is then last-known data, not a live record), or when the armed row
+ * is no longer a live `queued` record in the current source (it left the queue as
+ * leased/delivered/canceled, or vanished).
+ */
+export declare function shouldDisarmCancel(armedId: string | null, canCancel: boolean, source: QueueSource): boolean;

package/dist/logic/queue.js

@@ -0,0 +1,143 @@
+// @mythicalos/ui-core — the queue-row half of the terminal set (ds/components-terminal, spec v2):
+// the delivery queue's source→view resolution, row classes, and the two-step inline-cancel state
+// machine. Pure — no framework, no DOM. The honesty rules below live HERE, not in the product, so
+// every consumer inherits them.
+import { deliveryClassLabel } from "./sendbar.js";
+/**
+ * HONESTY INVARIANT (binding, do not reword): CAPABILITY-NEUTRAL empty copy. It reports what the
+ * READ returned and nothing else. It must never claim operational emptiness ("queue empty", "no
+ * pending deliveries"), never imply a store exists, and never restate the design card's
+ * "deliveries land here by class (ASAP interrupts · ON-DONE waits)" — that line is doubly false
+ * (it asserts a store AND the interrupt semantics `DELIVERY_HINT` corrects).
+ */
+export const QUEUE_EMPTY_COPY = "The queue read returned no records.";
+/** Stale = last-known data. NO retry/reconnect claim — nothing here is recovering on its own. */
+export const QUEUE_STALE_COPY = "Queue disconnected — showing the last received list.";
+export const QUEUE_LOADING_COPY = "Loading queue…";
+/** The three unavailable reasons, each with its own copy. Asserted pairwise-distinct by test. */
+export const QUEUE_UNAVAILABLE_COPY = {
+    unsupported: "Queued delivery is unavailable in this mode.",
+    error: "The queue could not be read.",
+    unaddressable: "This session has no queue address.",
+};
+export const QUEUE_CANCEL_ASK = "Cancel this delivery?";
+export const QUEUE_CANCEL_YES = "Cancel it";
+export const QUEUE_CANCEL_NO = "Keep";
+export const QUEUE_CANCEL_LABEL = "✕ cancel";
+/**
+ * Every structural class the queue renders. Named here — not typed literally in a binding — so the
+ * Preact and React bindings cannot drift.
+ */
+export const QUEUE_CLASSES = {
+    panel: "my-queue",
+    list: "my-queue__list",
+    state: "my-queue__state",
+    stale: "my-queue__stale",
+    empty: "my-queue__empty",
+    rowBody: "my-qrow__body",
+    rowStatus: "my-qrow__status",
+    cancel: "my-qrow__cancel",
+    ask: "my-qrow__ask",
+    actions: "my-qrow__acts",
+    confirmYes: "my-qmini my-qmini--yes",
+    confirmNo: "my-qmini my-qmini--no",
+};
+/**
+ * HONESTY INVARIANT (binding): only a completed SUCCESSFUL read is fresh. A `stale` list is
+ * last-known data — the poll is failing, so each row's status is what it WAS, not what it is. That
+ * makes a cancel control on a stale row a claim the component cannot support: it would assert the
+ * record is still `queued` right beside a banner saying the list is no longer current. Stale rows
+ * therefore render with no cancel affordance, and an armed confirm force-disarms when its source
+ * goes stale (`shouldDisarmCancel`).
+ */
+export function isFreshSource(source) {
+    return source.kind === "ok";
+}
+/**
+ * HONESTY INVARIANT (binding): the empty presentation renders ONLY on `ok` + zero items — i.e. only
+ * after a fresh successful read actually returned nothing.
+ *  - `loading` renders the loading state, NEVER "empty" (an unfinished read knows nothing yet).
+ *  - `unavailable` renders its own distinct reason copy, NEVER "empty".
+ *  - `stale` with zero items renders a flagged (but empty) LIST, never the empty copy — the last
+ *    received list happening to be empty is not a fresh "there is nothing queued" claim.
+ *
+ * `unavailableDetail` lets a product ADD what it knows about a reason (e.g. which mode the daemon
+ * is in). It is APPENDED to this package's own sentence, never substituted for it — a caller
+ * therefore cannot collapse two reasons into one message, deliberately or by accident: the distinct
+ * base sentences always survive, so two reasons can never render identical copy.
+ */
+export function unavailableText(reason, detail) {
+    const base = QUEUE_UNAVAILABLE_COPY[reason];
+    const extra = detail?.trim();
+    return extra ? `${base} ${extra}` : base;
+}
+export function queueView(source, unavailableDetail) {
+    switch (source.kind) {
+        case "loading":
+            return { kind: "state", copy: QUEUE_LOADING_COPY };
+        case "unavailable":
+            return { kind: "state", copy: unavailableText(source.reason, unavailableDetail?.[source.reason]) };
+        case "ok":
+            return source.items.length === 0
+                ? { kind: "empty", copy: QUEUE_EMPTY_COPY }
+                : { kind: "list", items: source.items, staleCopy: null, fresh: true };
+        case "stale":
+            return { kind: "list", items: source.items, staleCopy: QUEUE_STALE_COPY, fresh: false };
+    }
+}
+// ── class + label derivation ──
+/** ASAP / ON-DONE badge label (verbatim). */
+export function queueBadgeLabel(cls) {
+    return deliveryClassLabel(cls);
+}
+/** Badge class: ASAP → accent-soft, ON-DONE → disabled-muted (design card). */
+export function queueBadgeClass(cls) {
+    return cls === "asap" ? "my-qbadge my-qbadge--asap" : "my-qbadge my-qbadge--done";
+}
+/** The row class. An armed row swaps to the confirm presentation instead of a status modifier. */
+export function queueRowClass(status, armed) {
+    return armed ? "my-qrow is-confirm" : `my-qrow my-qrow--${status}`;
+}
+/** Human status label — the status verbatim, never a friendlier synonym that loses precision. */
+export function queueStatusLabel(status) {
+    return status;
+}
+/**
+ * HONESTY INVARIANT (binding): the cancel affordance exists ONLY on `queued` records AND only when
+ * the caller says the record is cancellable at all (`canCancel` — e.g. the viewer owns the queue).
+ * Every other status renders WITHOUT an active cancel control: no greyed-out button that implies a
+ * cancel could have happened, and never a control whose click would be rejected downstream.
+ */
+export function canCancelRow(status, canCancel) {
+    return canCancel && status === "queued";
+}
+export function cancelReducer(state, event) {
+    switch (event.type) {
+        case "arm":
+            return { armedId: event.id };
+        case "confirm":
+            return { armedId: null }; // the onCancel(id) side-effect belongs to the component, not here
+        case "disarm":
+            return { armedId: null };
+    }
+}
+/**
+ * An armed two-step cancel must NEVER outlive its cancelability. Force-disarm when cancelability is
+ * lost (`canCancel` flips false), when the source stops being FRESH (it went stale, unavailable, or
+ * back to loading — the armed row is then last-known data, not a live record), or when the armed row
+ * is no longer a live `queued` record in the current source (it left the queue as
+ * leased/delivered/canceled, or vanished).
+ */
+export function shouldDisarmCancel(armedId, canCancel, source) {
+    if (armedId === null)
+        return false;
+    if (!canCancel)
+        return true;
+    // deliberately `ok` only: a `stale` list still carries items, but they are the LAST RECEIVED
+    // statuses, so an arm held against them would be a cancel aimed at data we know is out of date
+    if (!isFreshSource(source))
+        return true;
+    const items = source.kind === "ok" ? source.items : [];
+    const row = items.find((it) => it.id === armedId);
+    return row === undefined || !canCancelRow(row.status, canCancel);
+}

package/dist/logic/sendbar.d.ts

@@ -0,0 +1,105 @@
+/** Delivery class. `asap` takes the first turn gap; `on-done` waits for full idle. */
+export type DeliveryClass = "asap" | "on-done";
+export declare const DELIVERY_CLASSES: readonly DeliveryClass[];
+/** The class a bar starts on when the caller expresses no preference. One definition, so the two
+ *  bindings cannot ship different defaults. */
+export declare const DEFAULT_DELIVERY_CLASS: DeliveryClass;
+/** Verbatim badge/button label for a delivery class. */
+export declare function deliveryClassLabel(cls: DeliveryClass): "ASAP" | "ON-DONE";
+/**
+ * HONESTY INVARIANT (binding, do not reword): delivery ALWAYS waits for a turn boundary. The design
+ * card's older per-class wording — "ASAP interrupts · ON-DONE waits" — is FALSE: nothing about ASAP
+ * interrupts a turn in flight, it merely takes the FIRST gap between turns. This one combined line
+ * replaces both of the card's per-class hints. Never reintroduce "interrupts" here.
+ */
+export declare const DELIVERY_HINT = "ASAP takes the first turn gap \u00B7 ON-DONE waits for full idle.";
+/** Enabled placeholder when the caller supplies no target name. */
+export declare const SEND_PLACEHOLDER = "Message\u2026 (\u23CE send \u00B7 \u21E7\u23CE newline)";
+/** Last-resort disabled placeholder when the caller supplies no reason. Says only that sending is
+ *  unavailable — it never speculates about why. */
+export declare const SEND_DISABLED_FALLBACK = "Sending is unavailable.";
+/**
+ * Placeholder copy. Disabled ⇒ the caller's honest reason (or the neutral fallback); enabled ⇒ the
+ * design's named prompt `Message {name}… (⏎ send · ⇧⏎ newline)` when a target name is supplied,
+ * otherwise the nameless form. A disabled bar NEVER shows the enabled prompt.
+ */
+export declare function sendPlaceholder(disabled: boolean, disabledReason?: string, targetName?: string): string;
+/** Send is possible only with non-blank text, when enabled and not mid-send. */
+export declare function canSend(text: string, disabled: boolean, busy: boolean): boolean;
+/**
+ * The ASAP/ON-DONE semantics line renders ONLY where the delivery controls are actually usable — a
+ * disabled bar surfaces just the truthful reason (through the placeholder), never per-class
+ * semantics for controls the user cannot operate.
+ */
+export declare function showDeliveryHint(disabled: boolean): boolean;
+/**
+ * Single-flight gate for the send action. `canSend`'s `busy` argument covers the case where the
+ * CALLER tracks the in-flight state, but `onSend` may be async and a caller that flips `busy` in a
+ * later tick (or not at all) leaves a window in which two clicks — or a click racing an Enter —
+ * both call `onSend` and deliver the same message twice. The gate closes that window inside the
+ * component: it is synchronous, so the second attempt in the same tick is refused before any state
+ * update can land.
+ *
+ * Lives here rather than in a binding so both bindings get identical semantics, and so the race is
+ * testable without a DOM.
+ */
+export interface SendGate {
+    /** Takes the lock and returns true; returns false when a send is already in flight. */
+    tryAcquire(): boolean;
+    /** Releases the lock. Safe to call when not held. */
+    release(): void;
+    inFlight(): boolean;
+}
+export declare function makeSendGate(): SendGate;
+/**
+ * Resolve one send attempt to a plain success/failure.
+ *
+ * `onSend` is contracted to resolve a boolean, but it is caller code and may REJECT. Letting that
+ * rejection escape an async event handler surfaces it as an unhandled rejection — an application
+ * error, in many apps a full error overlay — for what is really just a send that did not land. So a
+ * rejection is treated as a FAILED send: nothing was delivered, the draft is kept, and the failure
+ * is handed to `onError` so the caller can still see it. It is never swallowed silently AND never
+ * reported as a success: anything other than a resolved `true` is a failure.
+ *
+ * Lives here so both bindings behave identically and so the rejection path is testable without a
+ * DOM.
+ */
+export declare function resolveSend(attempt: () => boolean | Promise<boolean>, onError?: (error: unknown) => void): Promise<boolean>;
+/**
+ * The draft clears ONLY on a delivered/queued success AND only when the field still holds exactly
+ * the submitted body — the field stays editable while the request is in flight, so text typed
+ * meanwhile is a NEWER draft a completing send must not erase. A failed send keeps the text either
+ * way, so the user retries without retyping.
+ */
+export declare function clearDraftOnSend(sent: boolean, submitted: string, current: string): boolean;
+/** Textarea key semantics: Enter=send, Shift/Alt-Enter=newline, IME composition suppressed. */
+export type KeyAction = "send" | "newline" | "none";
+/**
+ * HONESTY INVARIANT: an in-progress IME composition NEVER sends — `isComposing` short-circuits to
+ * `none` so a CJK/dead-key commit press can't fire a delivery the user did not ask for.
+ */
+export declare function keyAction(ev: unknown): KeyAction;
+/** The send button's label. */
+export declare const SEND_BUTTON_LABEL = "Send";
+/**
+ * Every structural class the send bar renders. Named here — not typed literally in a binding — so
+ * the Preact and React bindings cannot drift.
+ *
+ * DEVIATION FROM THE DESIGN CARD (deliberate, carried over from the shipped implementation this was
+ * extracted from): the card draws the delivery class as a `<select>`. The shipped bar uses a
+ * two-button segmented control with `aria-pressed`, because with exactly two mutually exclusive
+ * options both are visible at once — the current class is readable without opening a menu, which is
+ * what a delivery decision needs. Everything else in the bar follows the card.
+ */
+export declare const SENDBAR_CLASSES: {
+    readonly wrap: "my-sendbar-wrap";
+    readonly segment: "my-sendbar__seg";
+    readonly input: "my-sendbar__input";
+    readonly send: "my-sendbar__send";
+    readonly hint: "my-sendbar__hint";
+    readonly notice: "my-sendbar__notice";
+};
+/** The bar wrapper: `my-sendbar`, plus `is-disabled` when the whole bar is unusable. */
+export declare function sendBarClass(disabled: boolean): string;
+/** One delivery-class segment button; `is-on` marks the current selection. */
+export declare function deliveryClassButtonClass(selected: boolean): string;

package/dist/logic/sendbar.js

@@ -0,0 +1,136 @@
+// @mythicalos/ui-core — the send bar half of the terminal set (ds/components-terminal, spec v2):
+// delivery-class selection, draft/keyboard semantics, and the honest per-class hint. Pure — both
+// the Preact and React bindings derive every class string and every user-visible string from here,
+// so the two bindings (and any future one) cannot drift on the copy that carries the honesty.
+export const DELIVERY_CLASSES = ["asap", "on-done"];
+/** The class a bar starts on when the caller expresses no preference. One definition, so the two
+ *  bindings cannot ship different defaults. */
+export const DEFAULT_DELIVERY_CLASS = "asap";
+/** Verbatim badge/button label for a delivery class. */
+export function deliveryClassLabel(cls) {
+    return cls === "asap" ? "ASAP" : "ON-DONE";
+}
+/**
+ * HONESTY INVARIANT (binding, do not reword): delivery ALWAYS waits for a turn boundary. The design
+ * card's older per-class wording — "ASAP interrupts · ON-DONE waits" — is FALSE: nothing about ASAP
+ * interrupts a turn in flight, it merely takes the FIRST gap between turns. This one combined line
+ * replaces both of the card's per-class hints. Never reintroduce "interrupts" here.
+ */
+export const DELIVERY_HINT = "ASAP takes the first turn gap · ON-DONE waits for full idle.";
+/** Enabled placeholder when the caller supplies no target name. */
+export const SEND_PLACEHOLDER = "Message… (⏎ send · ⇧⏎ newline)";
+/** Last-resort disabled placeholder when the caller supplies no reason. Says only that sending is
+ *  unavailable — it never speculates about why. */
+export const SEND_DISABLED_FALLBACK = "Sending is unavailable.";
+/**
+ * Placeholder copy. Disabled ⇒ the caller's honest reason (or the neutral fallback); enabled ⇒ the
+ * design's named prompt `Message {name}… (⏎ send · ⇧⏎ newline)` when a target name is supplied,
+ * otherwise the nameless form. A disabled bar NEVER shows the enabled prompt.
+ */
+export function sendPlaceholder(disabled, disabledReason, targetName) {
+    if (disabled)
+        return disabledReason ?? SEND_DISABLED_FALLBACK;
+    const name = targetName?.trim();
+    return name ? `Message ${name}… (⏎ send · ⇧⏎ newline)` : SEND_PLACEHOLDER;
+}
+/** Send is possible only with non-blank text, when enabled and not mid-send. */
+export function canSend(text, disabled, busy) {
+    return !disabled && !busy && text.trim().length > 0;
+}
+/**
+ * The ASAP/ON-DONE semantics line renders ONLY where the delivery controls are actually usable — a
+ * disabled bar surfaces just the truthful reason (through the placeholder), never per-class
+ * semantics for controls the user cannot operate.
+ */
+export function showDeliveryHint(disabled) {
+    return !disabled;
+}
+export function makeSendGate() {
+    let held = false;
+    return {
+        tryAcquire() {
+            if (held)
+                return false;
+            held = true;
+            return true;
+        },
+        release() {
+            held = false;
+        },
+        inFlight() {
+            return held;
+        },
+    };
+}
+/**
+ * Resolve one send attempt to a plain success/failure.
+ *
+ * `onSend` is contracted to resolve a boolean, but it is caller code and may REJECT. Letting that
+ * rejection escape an async event handler surfaces it as an unhandled rejection — an application
+ * error, in many apps a full error overlay — for what is really just a send that did not land. So a
+ * rejection is treated as a FAILED send: nothing was delivered, the draft is kept, and the failure
+ * is handed to `onError` so the caller can still see it. It is never swallowed silently AND never
+ * reported as a success: anything other than a resolved `true` is a failure.
+ *
+ * Lives here so both bindings behave identically and so the rejection path is testable without a
+ * DOM.
+ */
+export async function resolveSend(attempt, onError) {
+    try {
+        return (await attempt()) === true;
+    }
+    catch (error) {
+        onError?.(error);
+        return false;
+    }
+}
+/**
+ * The draft clears ONLY on a delivered/queued success AND only when the field still holds exactly
+ * the submitted body — the field stays editable while the request is in flight, so text typed
+ * meanwhile is a NEWER draft a completing send must not erase. A failed send keeps the text either
+ * way, so the user retries without retyping.
+ */
+export function clearDraftOnSend(sent, submitted, current) {
+    return sent === true && submitted === current;
+}
+/**
+ * HONESTY INVARIANT: an in-progress IME composition NEVER sends — `isComposing` short-circuits to
+ * `none` so a CJK/dead-key commit press can't fire a delivery the user did not ask for.
+ */
+export function keyAction(ev) {
+    const e = ev;
+    if (!e || e.key !== "Enter" || e.isComposing)
+        return "none";
+    if (e.shiftKey || e.altKey)
+        return "newline";
+    return "send";
+}
+// ── class derivation ──
+/** The send button's label. */
+export const SEND_BUTTON_LABEL = "Send";
+/**
+ * Every structural class the send bar renders. Named here — not typed literally in a binding — so
+ * the Preact and React bindings cannot drift.
+ *
+ * DEVIATION FROM THE DESIGN CARD (deliberate, carried over from the shipped implementation this was
+ * extracted from): the card draws the delivery class as a `<select>`. The shipped bar uses a
+ * two-button segmented control with `aria-pressed`, because with exactly two mutually exclusive
+ * options both are visible at once — the current class is readable without opening a menu, which is
+ * what a delivery decision needs. Everything else in the bar follows the card.
+ */
+export const SENDBAR_CLASSES = {
+    wrap: "my-sendbar-wrap",
+    segment: "my-sendbar__seg",
+    input: "my-sendbar__input",
+    send: "my-sendbar__send",
+    hint: "my-sendbar__hint",
+    notice: "my-sendbar__notice",
+};
+/** The bar wrapper: `my-sendbar`, plus `is-disabled` when the whole bar is unusable. */
+export function sendBarClass(disabled) {
+    return disabled ? "my-sendbar is-disabled" : "my-sendbar";
+}
+/** One delivery-class segment button; `is-on` marks the current selection. */
+export function deliveryClassButtonClass(selected) {
+    return selected ? "my-sendbar__cls is-on" : "my-sendbar__cls";
+}