@ahoo-wang/wow-view-engine 9.2.0-rc.0

package/dist/react/workbench/handOver.d.ts

@@ -0,0 +1,73 @@
+import { ViewConfig, ViewKind } from '../../model/index.js';
+import { AnyViewRuntime, SavedViewTarget, ViewEngine, ViewHandOver } from '../../runtime/index.js';
+import { FilterEditorController } from '../useFilterEditor.js';
+import { HeldView } from '../useWorkbench.js';
+/**
+ * Opens each new `handOver` once, through the leave guard (D22 H, D26 Q30):
+ * a view a dashboard or an embed sent through the host's route.
+ *
+ * - One nobody saved (`unsaved`) — a follow-up on a group, a board's own
+ *   analysis — opens as a view made from nothing does: unsaved, under its
+ *   title until its first save, which is a create; held as `handed`, so the
+ *   shell opens it with its editor folded. One of a kind the workbench does
+ *   not draw is left alone.
+ * - A saved one (`view`) is opened by its id (`open`), which is what makes
+ *   it that view — listed, saved in place, routed by its id.
+ *
+ * Either runs under the handed `scopeFilter` as its scope. The same object
+ * again opens nothing — a host re-rendering with the route it already
+ * followed must not open a second copy — so a host opens the same view
+ * twice by handing a new object, or by handing none in between (Back to
+ * the entry that holds it, after a switch that handed nothing).
+ *
+ * Opening is an effect, so StrictMode's rehearsal of the unmount closes the
+ * view the first run opened (the workbench lets its held views go on the way
+ * out); what was seen is forgotten with it, and the second run opens it
+ * again.
+ */
+export declare function useHandOver(handOver: ViewHandOver | null | undefined, context: {
+    engine: ViewEngine;
+    definitionId: string;
+    kinds: readonly ViewKind[];
+    request(proceed: () => void): void;
+    hold(view: HeldView): void;
+    open(target: SavedViewTarget): void;
+}): void;
+/**
+ * A saved view handed over (`SavedViewTarget`), once it is open by its id:
+ * what the reader set on the board goes onto its own conditions and runs —
+ * so it opens 「已修改」, the conditions on 「正在显示」 each removable,
+ * and 「还原」 takes them back off. They go onto what the view was saved
+ * with, not onto whatever draft it had: the leave guard already asked
+ * before that draft went.
+ *
+ * Answers the draft it was left with, once, until the reader touches it:
+ * leaving an untouched hand-over asks nothing, as leaving an untouched view
+ * made from nothing asks nothing. Once per hand-over and runtime: a runtime
+ * opened again for the same hand-over (StrictMode's rehearsal closes the
+ * first) takes the conditions again, since it opened on the saved view.
+ *
+ * Landing edits the runtime, which is an effect; what it left is read on
+ * render, so the effect writes it into a store `useSyncExternalStore`
+ * reads (`landingStore`) rather than calling `setState` from its body.
+ */
+export declare function useHandedConditions(handed: SavedViewTarget | null, runtime: AnyViewRuntime | null): ViewConfig | null;
+/**
+ * The filter editor of a saved view handed over (`SavedViewTarget`), whose
+ * ✕ on 「正在显示」 takes a condition the board handed it **off** rather
+ * than blanking it (D26 Q30). ✕ elsewhere clears a condition's value and
+ * leaves its field in the editor for the next question — the reader put the
+ * field there. A handed condition is no row the reader built: blanked, it
+ * stayed behind as a field-without-a-value the saved view never had, so
+ * taking every handed condition off still read 「已修改」 with 保存 offered
+ * (walk of #1882). So one is removed outright, and once the tree is the
+ * saved one again — the "all of" `drillFilter` wrapped an advanced tree in
+ * included — the saved filter and its mode come back as they were, and the
+ * view is clean.
+ *
+ * A handed condition is a child of the root "all of" (`withHandedFilter`
+ * puts them there) equal to one handed; one the saved view holds as well is
+ * the view's own, and cleared as any other. The same controller otherwise.
+ */
+export declare function useHandedRemoval(filter: FilterEditorController, handed: SavedViewTarget | null, runtime: AnyViewRuntime | null): FilterEditorController;
+//# sourceMappingURL=handOver.d.ts.map

package/dist/react/workbench/handOver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handOver.d.ts","sourceRoot":"","sources":["../../../src/react/workbench/handOver.ts"],"names":[],"mappings":"AAoBA,OAAO,KAAK,EAKV,UAAU,EACV,QAAQ,EACT,MAAM,sBAAsB,CAAC;AAQ9B,OAAO,KAAK,EACV,cAAc,EAEd,eAAe,EACf,UAAU,EACV,YAAY,EACb,MAAM,wBAAwB,CAAC;AAMhC,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAC;AACpE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAEnD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,WAAW,CACzB,QAAQ,EAAE,YAAY,GAAG,IAAI,GAAG,SAAS,EACzC,OAAO,EAAE;IACP,MAAM,EAAE,UAAU,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,KAAK,EAAE,SAAS,QAAQ,EAAE,CAAC;IAC3B,OAAO,CAAC,OAAO,EAAE,MAAM,IAAI,GAAG,IAAI,CAAC;IACnC,IAAI,CAAC,IAAI,EAAE,QAAQ,GAAG,IAAI,CAAC;IAC3B,IAAI,CAAC,MAAM,EAAE,eAAe,GAAG,IAAI,CAAC;CACrC,GACA,IAAI,CA0CN;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,eAAe,GAAG,IAAI,EAC9B,OAAO,EAAE,cAAc,GAAG,IAAI,GAC7B,UAAU,GAAG,IAAI,CA8BnB;AAuBD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,sBAAsB,EAC9B,MAAM,EAAE,eAAe,GAAG,IAAI,EAC9B,OAAO,EAAE,cAAc,GAAG,IAAI,GAC7B,sBAAsB,CAuCxB"}

package/dist/react/workbench/instanceSync.d.ts

@@ -0,0 +1,55 @@
+import { ViewHandOver } from '../../runtime/index.js';
+/** What the sync watches, and what it does about a disagreement. */
+export interface InstanceSyncOptions {
+    /**
+     * The value the host holds, or `undefined` when it holds none.
+     *
+     * `undefined` is the uncontrolled form and the only thing that means it: a
+     * host that passes `null` is holding a value, and the value is "whichever
+     * view is the effective default".
+     */
+    instanceId?: string | null;
+    /** The pin the workbench holds now — `useWorkbench`'s own `chosen`. */
+    chosen: string | null;
+    /** Opens another view, through the leave guard. */
+    choose(id: string | null): void;
+    /** True while the guard's question is still on screen. */
+    asking: boolean;
+    /** Told what is open, in the same vocabulary `instanceId` is written in. */
+    onInstanceChange?(id: string | null): void;
+    /**
+     * The hand-over the host passes (`WorkbenchOptions.handOver`). A host that
+     * keeps one with its history entry names the handed view and hands it over
+     * in one move — Back to that entry from another view does both — and the
+     * hand-over opens it, under what it carries (`useHandOver`); opening it
+     * here as well would open it bare, and the later of the two would win.
+     */
+    handOver?: ViewHandOver | null;
+}
+/**
+ * Keeps the host's value and the open view in agreement.
+ *
+ * `instanceId` is controlled in the sense `value` is on an input — the host
+ * is the one that says which view is open — but a view is not a string: it
+ * holds an unsaved draft, and swapping it out is a loss the leave guard has
+ * to ask about first. So a pushed value cannot simply be rendered. The
+ * workbench *converges* on it instead: whichever side moved last is the side
+ * that speaks, and the other one follows.
+ *
+ * - the host named a view that is not open → it is opened, through the same
+ *   guard a click on the sidebar goes through;
+ * - the workbench moved on its own — a user's switch, the copy a save-as
+ *   opened, a rename, a pin released with its deleted view — → the host is
+ *   told, and its route follows;
+ * - the guard refused the push and the user stayed → the host is told what is
+ *   open, so its route is never left naming a view that is not on screen.
+ *
+ * What is reported is exactly what may be passed back in: `null` means the
+ * effective default in the report as it does in the prop, so a host can store
+ * one and hand it over on the next mount without translating it.
+ *
+ * Switching between the two forms mid-life is unsupported, as it is on an
+ * input: the first value decides which side owns the open view.
+ */
+export declare function useInstanceSync({ instanceId, chosen, choose, asking, onInstanceChange, handOver, }: InstanceSyncOptions): void;
+//# sourceMappingURL=instanceSync.d.ts.map

package/dist/react/workbench/instanceSync.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instanceSync.d.ts","sourceRoot":"","sources":["../../../src/react/workbench/instanceSync.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAE3D,oEAAoE;AACpE,MAAM,WAAW,mBAAmB;IAClC;;;;;;OAMG;IACH,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,uEAAuE;IACvE,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,mDAAmD;IACnD,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAAC;IAChC,0DAA0D;IAC1D,MAAM,EAAE,OAAO,CAAC;IAChB,4EAA4E;IAC5E,gBAAgB,CAAC,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAAC;IAC3C;;;;;;OAMG;IACH,QAAQ,CAAC,EAAE,YAAY,GAAG,IAAI,CAAC;CAChC;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,eAAe,CAAC,EAC9B,UAAU,EACV,MAAM,EACN,MAAM,EACN,MAAM,EACN,gBAAgB,EAChB,QAAe,GAChB,EAAE,mBAAmB,GAAG,IAAI,CA6C5B"}

package/dist/react/workbench/leaveGuard.d.ts

@@ -0,0 +1,65 @@
+import { WriteState } from '../../runtime/index.js';
+/**
+ * What the guard reads off the open view. Both facts are losses, and they are
+ * different ones: edits that were never sent, and a write whose result never
+ * came back — leaving takes the first away and takes away the chance to
+ * settle the second.
+ */
+export interface LeaveGuardState {
+    dirty: boolean;
+    write: WriteState | null;
+}
+/**
+ * Leave protection with no dialog in it: the question, and the two answers.
+ *
+ * A host renders whatever it likes from `asking` — `/ui` renders
+ * `LeaveDialog` — so the rule about *when* work would be lost lives in one
+ * place and is not retold by every surface that has to obey it.
+ */
+export interface LeaveGuard {
+    /** True while a switch is waiting for an answer. */
+    asking: boolean;
+    /** Runs `next` now, or after the user says it is all right to lose this. */
+    request(next: () => void): void;
+    /** Yes: settles the pending write, then runs what was held. */
+    confirm(): void;
+    /** No: drops what was held and stays where it is. */
+    cancel(): void;
+}
+export interface LeaveGuardOptions {
+    /**
+     * Called on confirm, before the switch. Leaving disposes the runtime, and
+     * an unsettled write outlives it inside the engine: the handle would point
+     * at a runtime nobody can reach, and `engine.pendingWrites()` would hold it
+     * for the rest of the session with nothing on screen able to retry,
+     * overwrite or abandon it. `useWorkbench` passes `commands.abandon` here.
+     */
+    onLeave?(): void;
+    /**
+     * Whether closing the tab or navigating away is guarded too, on top of the
+     * switch this hook asks about itself. On by default, and only a host that
+     * owns the whole page should be turning it off: the prompt belongs to the
+     * document, so a workbench that puts it up is speaking for every other
+     * thing on that page (D18 Ⅸ).
+     */
+    guardUnload?: boolean;
+}
+/**
+ * The confirmation that stands between an open view and the next one.
+ *
+ * Opening another view releases this one's runtime, and a runtime is where
+ * the unsaved draft lives — there is nowhere else it is kept. So leaving is
+ * the deletion of work, asked about once, and a view with nothing to lose is
+ * never asked about at all: a guard that interrupts every switch is one
+ * people learn to dismiss without reading.
+ *
+ * The switch inside the page and the way out of the page are the same rule,
+ * so they are read off the same `blocking`: the sidebar, the switcher and a
+ * pushed `instanceId` come through `request`, and the tab's own close button
+ * comes through `beforeunload` (D18 Ⅸ). An embedded view has neither — it
+ * has no editor, no draft and no save, and `EmbeddedView` never calls this
+ * hook — so a business page that shows one is never argued with on the way
+ * out.
+ */
+export declare function useLeaveGuard(state: LeaveGuardState | null, { onLeave, guardUnload }?: LeaveGuardOptions): LeaveGuard;
+//# sourceMappingURL=leaveGuard.d.ts.map

package/dist/react/workbench/leaveGuard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"leaveGuard.d.ts","sourceRoot":"","sources":["../../../src/react/workbench/leaveGuard.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAGzD;;;;;GAKG;AACH,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,OAAO,CAAC;IACf,KAAK,EAAE,UAAU,GAAG,IAAI,CAAC;CAC1B;AAED;;;;;;GAMG;AACH,MAAM,WAAW,UAAU;IACzB,oDAAoD;IACpD,MAAM,EAAE,OAAO,CAAC;IAChB,4EAA4E;IAC5E,OAAO,CAAC,IAAI,EAAE,MAAM,IAAI,GAAG,IAAI,CAAC;IAChC,+DAA+D;IAC/D,OAAO,IAAI,IAAI,CAAC;IAChB,qDAAqD;IACrD,MAAM,IAAI,IAAI,CAAC;CAChB;AAED,MAAM,WAAW,iBAAiB;IAChC;;;;;;OAMG;IACH,OAAO,CAAC,IAAI,IAAI,CAAC;IACjB;;;;;;OAMG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAkDD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,eAAe,GAAG,IAAI,EAC7B,EAAE,OAAO,EAAE,WAAkB,EAAE,GAAE,iBAAsB,GACtD,UAAU,CA6BZ"}

package/dist/react/workbench/newView.d.ts

@@ -0,0 +1,35 @@
+import { RuntimeLimits, ViewAudience, ViewConfig, ViewDefinition, ViewKind } from '../../model/index.js';
+import { ViewPermissions } from '../../store/index.js';
+/**
+ * What a workbench needs before it can make a view from nothing.
+ *
+ * The title is required because the engine refuses a view without one, and
+ * it is the UI's to word — this layer carries no catalogue — so a workbench
+ * that gives none simply offers no new view. A template is the host's own
+ * first view of one kind; a kind without one starts from the default built
+ * from the definition.
+ */
+export interface NewViewOptions {
+    /** The name a new view opens under, until the first save names it. */
+    title: string;
+    /**
+     * What a new view of each kind starts from; the kind's own default when
+     * its entry is left out. A template of the wrong kind is refused as no
+     * template: it is a mistake at the call site, and a workbench that then
+     * offered the default instead would hide it.
+     */
+    templates?: Partial<Record<ViewKind, ViewConfig>>;
+}
+/** What `create` will hand the engine, or null where no view can be made. */
+export interface Blank {
+    scope: ViewAudience;
+    config: ViewConfig;
+}
+/**
+ * The view `create` would make, decided once from the definition, the
+ * permissions and the host's template — or null, which is what turns every
+ * "new view" control off: a definition that has no such kind, a user who
+ * may create nowhere, or a workbench that gave no title to open one under.
+ */
+export declare function blankView(definition: ViewDefinition | undefined, kind: ViewKind, permissions: ViewPermissions, limits: RuntimeLimits, newView: NewViewOptions | undefined): Blank | null;
+//# sourceMappingURL=newView.d.ts.map

package/dist/react/workbench/newView.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"newView.d.ts","sourceRoot":"","sources":["../../../src/react/workbench/newView.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EACV,aAAa,EACb,YAAY,EACZ,UAAU,EACV,cAAc,EACd,QAAQ,EACT,MAAM,sBAAsB,CAAC;AAE9B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAE5D;;;;;;;;GAQG;AACH,MAAM,WAAW,cAAc;IAC7B,sEAAsE;IACtE,KAAK,EAAE,MAAM,CAAC;IACd;;;;;OAKG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAC,CAAC;CACnD;AAED,6EAA6E;AAC7E,MAAM,WAAW,KAAK;IACpB,KAAK,EAAE,YAAY,CAAC;IACpB,MAAM,EAAE,UAAU,CAAC;CACpB;AAuCD;;;;;GAKG;AACH,wBAAgB,SAAS,CACvB,UAAU,EAAE,cAAc,GAAG,SAAS,EACtC,IAAI,EAAE,QAAQ,EACd,WAAW,EAAE,eAAe,EAC5B,MAAM,EAAE,aAAa,EACrB,OAAO,EAAE,cAAc,GAAG,SAAS,GAClC,KAAK,GAAG,IAAI,CAOd"}

package/dist/react/workbench/releaseDeleted.d.ts

@@ -0,0 +1,19 @@
+import { OpenViewState } from '../useViewEngine.js';
+/**
+ * Lets the pinned view go once it is gone.
+ *
+ * A delete from the manager disposes the runtime; `useOpenView` asks for the
+ * id again and is told there is no such view. That is the cue — and only for
+ * a view that was open, never for an id the host asked for and the store
+ * never had, which is a mistake to report rather than to navigate away from.
+ *
+ * Every workbench needs it, and for the same reason: a `chosen` id left
+ * pinned to a deleted view answers "not found" for as long as the page is
+ * open, so the page would never move on to the view that is still there.
+ */
+export declare function useReleaseDeleted(
+/** The id actually being opened: the pin, or the list's default. */
+openId: string | null, 
+/** The pin alone; only a pinned id is this hook's to release. */
+chosen: string | null, opened: OpenViewState, setChosen: (id: string | null) => void): void;
+//# sourceMappingURL=releaseDeleted.d.ts.map

package/dist/react/workbench/releaseDeleted.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"releaseDeleted.d.ts","sourceRoot":"","sources":["../../../src/react/workbench/releaseDeleted.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEzD;;;;;;;;;;;GAWG;AACH,wBAAgB,iBAAiB;AAC/B,oEAAoE;AACpE,MAAM,EAAE,MAAM,GAAG,IAAI;AACrB,iEAAiE;AACjE,MAAM,EAAE,MAAM,GAAG,IAAI,EACrB,MAAM,EAAE,aAAa,EACrB,SAAS,EAAE,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,KAAK,IAAI,GACrC,IAAI,CAaN"}

package/dist/react/writes.d.ts

@@ -0,0 +1,134 @@
+import { Issue, ViewInstance, ViewPreferences } from '../model/index.js';
+import { WriteAction, WriteHandle, WritePayload, WriteState } from '../runtime/index.js';
+/**
+ * The revision and the request id of a write that never left. A refusal is
+ * recorded so the caller can say why it did not happen, and its payload is the
+ * intent rather than anything sent, so it quotes neither.
+ */
+export declare const UNSENT = "";
+/**
+ * What a command ended as, and the address of the write behind it.
+ *
+ * The handle is absent when there is nothing left to replay: a command the
+ * engine refused before dispatching, or a conflict it has already settled.
+ */
+export interface SettledWrite {
+    state: WriteState;
+    handle: WriteHandle | null;
+}
+/**
+ * A refusal, in the shape the caller already renders. `ViewCommandError` means
+ * nothing was sent, which is exactly a rejection with no outcome to recover.
+ */
+export declare function refused(payload: WritePayload, issue: Issue): WriteState;
+/**
+ * What a command threw, as the outcome it is: a `ViewWriteError` carries its
+ * own state and handle, and anything else never left, so it becomes a
+ * rejection quoting the intent and the Issue {@link toIssue} made of it.
+ */
+export declare function settle(caught: unknown, code: string, intent: WritePayload): SettledWrite;
+/** What replaying a write answered: whether it landed, and what it made. */
+export interface RecoveredWrite {
+    /** The command is done: the outcome it was raised against is settled. */
+    landed: boolean;
+    /**
+     * Whether it saved this view — a `create` or a `save` that reached the
+     * store. That is what a "Saved" moment is about, and two other landings
+     * are not it: a conflict resolved by `reload` takes the stored state and
+     * drops the draft, so it writes nothing at all; and a recovered `rename` or
+     * `delete` does write, but not the config on screen — announcing "View
+     * saved" after a retried rename would tell the user their unsaved edits are
+     * safe when they are not.
+     */
+    written: boolean;
+    /** The instance a recovered create, save or rename produced, if any. */
+    instance: ViewInstance | null;
+}
+/** Nothing was replayed: no target, or no outcome to recover through. */
+export declare const UNRECOVERED: RecoveredWrite;
+/**
+ * What a replay or a conflict choice resolved with, as a {@link
+ * RecoveredWrite}. Reaching this at all means the command landed; preferences
+ * resolve too, and carry no instance.
+ */
+export declare function recovered(result: ViewInstance | ViewPreferences | void, written: boolean): RecoveredWrite;
+/**
+ * Whether recovering this write saves the view itself. A `rename` and a
+ * `delete` reach the store as much as a `save` does, but neither is the
+ * config on screen: "View saved" after a retried rename says the edits are
+ * safe when nothing of them has been written. A write the runtime no longer
+ * holds — the outcome settled between the render and the click — answers no,
+ * which is the quiet way to be wrong.
+ */
+export declare function savesView(action: WriteAction | undefined): boolean;
+/**
+ * Whether the engine is still answering for this write.
+ *
+ * A `conflict` and an `unknown` are both unsettled, for two different
+ * reasons: one is waiting for the user to choose which version wins, the
+ * other for a retry or an abandon. A `rejected` is the definite answer — the
+ * store never took it, and there is nothing left outstanding.
+ *
+ * This is the coarse question, and it is not the same as either of the two
+ * below: {@link blocksNewIntent} is narrower (only an `unknown` refuses a new
+ * write from an open runtime), and {@link holdsHandle} adds the handle to it.
+ */
+export declare function unsettled(state: WriteState | null | undefined): boolean;
+/**
+ * Whether the one outcome an open runtime reports refuses a new write.
+ *
+ * Only `unknown` does: the request left and nothing came back, so a second
+ * attempt might be a second write, and the engine refuses it outright. A
+ * `conflict` and a `rejected` are definite answers, and what resolves them is
+ * often a new intent — "Save my copy" after somebody else moved the baseline,
+ * "correct it and save again" after a refusal — which this would disable.
+ *
+ * A row of the view manager holds one outcome per key rather than one
+ * altogether, and a `conflict` costs it the handle it would need to answer
+ * for; {@link holdsHandle} is that stricter rule.
+ */
+export declare function blocksNewIntent(state: WriteState | null | undefined): boolean;
+/**
+ * Whether the outcome a key holds still addresses a write the engine will
+ * answer for, and so refuses a new intent altogether.
+ *
+ * A row holds one outcome, so a new command for a key whose outcome is still
+ * the engine's to answer for has nowhere to put its own: recording it would
+ * drop the handle, and the write it addresses would be left in
+ * `engine.pendingWrites()` with nothing on screen able to retry, overwrite or
+ * abandon it. The engine refuses a second command against an `unknown`
+ * outright; a `conflict` it would dispatch over, which is the same problem one
+ * step later. A `rejected` outcome is a definite answer with nothing
+ * outstanding, so management.md's "correct it and save again" goes through as
+ * the new intent it is — which is {@link unsettled}, plus the handle that
+ * makes it this key's to answer for.
+ */
+export declare function holdsHandle(outcome: SettledWrite | null | undefined): boolean;
+/**
+ * The handle a new command for this key would strand, or null when it strands
+ * none.
+ *
+ * A `rejected` outcome that still holds a handle is the one unsettled outcome
+ * a new command is allowed past ({@link holdsHandle}), and that command is
+ * about to take its slot. Abandoning this handle first is what keeps the write
+ * it addresses from being left in `engine.pendingWrites()` with nothing on
+ * screen able to reach it.
+ */
+export declare function strandedHandle(outcome: SettledWrite | null | undefined): WriteHandle | null;
+/**
+ * Whether the slot is free for an outcome that has nothing to replay.
+ *
+ * A refusal never left, so letting it take the place of an outcome that still
+ * holds a handle would drop the only way to retry or abandon that write —
+ * which is exactly what the engine refusing a second command against an
+ * `unknown` outcome would otherwise do to it.
+ */
+export declare function mayRefuse(existing: SettledWrite | null | undefined): boolean;
+/**
+ * Whether `incoming` may be recorded over whatever the key holds. An outcome
+ * that carries its own handle always may — it is a write the store has, and
+ * the engine only dispatched it because the slot was open to it. One that
+ * carries none is a refusal, and {@link mayRefuse} decides.
+ */
+export declare function mayReplace(existing: SettledWrite | null | undefined, incoming: SettledWrite): boolean;
+//# sourceMappingURL=writes.d.ts.map

package/dist/react/writes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"writes.d.ts","sourceRoot":"","sources":["../../src/react/writes.ts"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAC9E,OAAO,EAEL,KAAK,WAAW,EAChB,KAAK,WAAW,EAChB,KAAK,YAAY,EACjB,KAAK,UAAU,EAChB,MAAM,qBAAqB,CAAC;AAG7B;;;;GAIG;AACH,eAAO,MAAM,MAAM,KAAK,CAAC;AAEzB;;;;;GAKG;AACH,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,UAAU,CAAC;IAClB,MAAM,EAAE,WAAW,GAAG,IAAI,CAAC;CAC5B;AAED;;;GAGG;AACH,wBAAgB,OAAO,CAAC,OAAO,EAAE,YAAY,EAAE,KAAK,EAAE,KAAK,GAAG,UAAU,CAEvE;AAED;;;;GAIG;AACH,wBAAgB,MAAM,CACpB,MAAM,EAAE,OAAO,EACf,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,YAAY,GACnB,YAAY,CAId;AAED,4EAA4E;AAC5E,MAAM,WAAW,cAAc;IAC7B,yEAAyE;IACzE,MAAM,EAAE,OAAO,CAAC;IAChB;;;;;;;;OAQG;IACH,OAAO,EAAE,OAAO,CAAC;IACjB,wEAAwE;IACxE,QAAQ,EAAE,YAAY,GAAG,IAAI,CAAC;CAC/B;AAED,yEAAyE;AACzE,eAAO,MAAM,WAAW,EAAE,cAIzB,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,SAAS,CACvB,MAAM,EAAE,YAAY,GAAG,eAAe,GAAG,IAAI,EAC7C,OAAO,EAAE,OAAO,GACf,cAAc,CAShB;AAED;;;;;;;GAOG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,WAAW,GAAG,SAAS,GAAG,OAAO,CAElE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,CAEvE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,CAE7E;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,YAAY,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,CAE7E;AAED;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,YAAY,GAAG,IAAI,GAAG,SAAS,GACvC,WAAW,GAAG,IAAI,CAEpB;AAED;;;;;;;GAOG;AACH,wBAAgB,SAAS,CAAC,QAAQ,EAAE,YAAY,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,CAE5E;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CACxB,QAAQ,EAAE,YAAY,GAAG,IAAI,GAAG,SAAS,EACzC,QAAQ,EAAE,YAAY,GACrB,OAAO,CAET"}