nudge-ui 0.2.2 → 0.2.3

package/dist/inspector/canvas/useCanvasLayoutAnimation.js

@@ -0,0 +1,107 @@
+import { iterationId } from "./frameContent.js";
+import { useEffect, useLayoutEffect, useRef } from "react";
+import {} from "./canvasStore.js";
+import { setCanvasLayoutTransitioning } from "./viewStore.js";
+const SLIDE_OPTIONS = { duration: 300, easing: "ease-out" };
+const CAMERA_OPTIONS = { duration: 150, easing: "ease-out" };
+/** Animates frame creation and layout changes without delaying direct manipulation. */
+export function useCanvasLayoutAnimation(boardRef, cards, camera, presentation) {
+    const previous = useRef({ cards, camera, presentation });
+    const animations = useRef([]);
+    const generation = useRef(0);
+    useEffect(() => {
+        const board = boardRef.current;
+        const cancel = () => {
+            generation.current += 1;
+            setCanvasLayoutTransitioning(false);
+            for (const animation of animations.current)
+                animation.cancel();
+            animations.current = [];
+        };
+        const cancelWheel = (event) => {
+            if (board && event.composedPath().includes(board))
+                cancel();
+        };
+        board?.addEventListener("pointerdown", cancel, true);
+        window.addEventListener("wheel", cancelWheel, true);
+        return () => {
+            cancel();
+            board?.removeEventListener("pointerdown", cancel, true);
+            window.removeEventListener("wheel", cancelWheel, true);
+        };
+    }, [boardRef]);
+    useLayoutEffect(() => {
+        const before = previous.current;
+        previous.current = { cards, camera, presentation };
+        const oldCards = new Map(before.cards.map((card) => [card.id, card]));
+        const layoutChanged = cards.some((card) => {
+            const old = oldCards.get(card.id);
+            return (!old && card.animateEntrance !== false && (card.entrance === "linked" || iterationId(card.content))) || (old && iterationId(card.content) && iterationId(old.content) !== iterationId(card.content));
+        });
+        const cameraChanged = camera.x !== before.camera.x || camera.y !== before.camera.y || camera.zoom !== before.camera.zoom;
+        const shouldAnimate = (layoutChanged || (cameraChanged && animations.current.length > 0))
+            && presentation === "canvas" && before.presentation === "canvas"
+            && !window.matchMedia?.("(prefers-reduced-motion: reduce)").matches;
+        const board = boardRef.current;
+        const animate = (element, frames, options = SLIDE_OPTIONS) => {
+            if (shouldAnimate && typeof element.animate === "function") {
+                animations.current.push(element.animate(frames, options));
+            }
+        };
+        if (shouldAnimate) {
+            generation.current += 1;
+            setCanvasLayoutTransitioning(true);
+            if (layoutChanged) {
+                for (const animation of animations.current)
+                    animation.cancel();
+                animations.current = [];
+            }
+            for (const element of board?.querySelectorAll(".canvas-card") ?? []) {
+                const card = cards.find((item) => item.id === element.dataset.cardId);
+                if (!card)
+                    continue;
+                const old = oldCards.get(card.id);
+                if (!old) {
+                    if (card.animateEntrance === false)
+                        continue;
+                    const slideRight = Boolean(card.entrance === "linked");
+                    animate(element, [
+                        { left: `${card.x - (slideRight ? 200 : 0)}px`, top: `${card.y - (slideRight ? 0 : 200)}px`, opacity: 0 },
+                        { left: `${card.x}px`, top: `${card.y}px`, opacity: 1 },
+                    ]);
+                }
+                else if (old.x !== card.x || old.y !== card.y) {
+                    animate(element, [{ left: `${old.x}px`, top: `${old.y}px` }, { left: `${card.x}px`, top: `${card.y}px` }]);
+                }
+            }
+            const content = board?.querySelector(".canvas-workspace__board-content");
+            if (content && cameraChanged) {
+                const current = animations.current.find((animation) => animation.playState === "running"
+                    && animation.effect?.target === content);
+                const from = current ? getComputedStyle(content).transform
+                    : `translate(${before.camera.x}px, ${before.camera.y}px) scale(${before.camera.zoom})`;
+                current?.cancel();
+                animate(content, [
+                    { transform: from },
+                    { transform: `translate(${camera.x}px, ${camera.y}px) scale(${camera.zoom})` },
+                ], CAMERA_OPTIONS);
+            }
+        }
+        if (shouldAnimate) {
+            const current = generation.current;
+            void Promise.all(animations.current.map((animation) => animation.finished.catch(() => undefined))).then(() => {
+                if (generation.current !== current)
+                    return;
+                animations.current = [];
+                setCanvasLayoutTransitioning(false);
+            });
+        }
+        else if (presentation !== before.presentation) {
+            generation.current += 1;
+            for (const animation of animations.current)
+                animation.cancel();
+            animations.current = [];
+            setCanvasLayoutTransitioning(false);
+        }
+    }, [boardRef, cards, camera, presentation]);
+}

package/dist/inspector/canvas/viewStore.d.ts

@@ -0,0 +1,38 @@
+export type CanvasMode = "inspect" | "canvas";
+export type CanvasPresentation = "focus" | "canvas";
+export interface CanvasCamera {
+    x: number;
+    y: number;
+    zoom: number;
+}
+export declare const MIN_CAMERA_ZOOM = 0.25;
+export declare const MAX_CAMERA_ZOOM = 3;
+export declare const DEFAULT_CAMERA: CanvasCamera;
+export declare function subscribeCanvasView(listener: () => void): () => void;
+export declare function getCanvasMode(): CanvasMode;
+export declare function setCanvasMode(next: CanvasMode): void;
+export declare function getCanvasPresentation(): CanvasPresentation;
+export declare function setCanvasPresentation(next: CanvasPresentation): void;
+/** Holding A temporarily enables app interaction without changing the selected tool. */
+export declare function setTemporaryAppInteraction(value: boolean): void;
+/** Element interactions pause while frame and camera geometry are animated. */
+export declare function setCanvasLayoutTransitioning(value: boolean): void;
+export declare function getCanvasLayoutTransitioning(): boolean;
+export declare function getBoardCamera(): CanvasCamera;
+export declare function setBoardCamera(next: CanvasCamera): void;
+export declare function updateBoardCamera(partial: Partial<CanvasCamera>): void;
+/** Moves the camera to frame content; the initial fit-all then no longer runs. */
+export declare function placeBoardCamera(next: CanvasCamera): void;
+export declare function hasFitAllRan(): boolean;
+export declare function resetFitAllFlag(): void;
+export declare function restoreCanvasView(next: {
+    mode: CanvasMode;
+    presentation: CanvasPresentation;
+    camera: CanvasCamera;
+}): void;
+export declare function useCanvasMode(): CanvasMode;
+export declare function useCanvasPresentation(): CanvasPresentation;
+export declare function useCanvasPresentationTransitioning(): boolean;
+export declare function useTemporaryAppInteraction(): boolean;
+export declare function useCanvasLayoutTransitioning(): boolean;
+export declare function useBoardCamera(): CanvasCamera;

package/dist/inspector/canvas/viewStore.js

@@ -0,0 +1,104 @@
+import { useSyncExternalStore } from "react";
+export const MIN_CAMERA_ZOOM = 0.25;
+export const MAX_CAMERA_ZOOM = 3;
+export const DEFAULT_CAMERA = { x: 0, y: 0, zoom: 1 };
+/** How the canvas is viewed. Frames, groups, and selection live in the canvas store. */
+let mode = "inspect";
+let presentation = "focus";
+let presentationTransitioning = false;
+let presentationTransitionTimer = null;
+let layoutTransitioning = false;
+let temporaryAppInteraction = false;
+let camera = { ...DEFAULT_CAMERA };
+let cameraPlaced = false;
+const listeners = new Set();
+function notify() {
+    for (const listener of listeners)
+        listener();
+}
+export function subscribeCanvasView(listener) {
+    listeners.add(listener);
+    return () => listeners.delete(listener);
+}
+function clampZoom(zoom) {
+    return Math.max(MIN_CAMERA_ZOOM, Math.min(MAX_CAMERA_ZOOM, zoom));
+}
+export function getCanvasMode() { return mode; }
+export function setCanvasMode(next) {
+    if (mode === next)
+        return;
+    mode = next;
+    notify();
+}
+export function getCanvasPresentation() { return presentation; }
+export function setCanvasPresentation(next) {
+    if (presentation === next)
+        return;
+    presentation = next;
+    presentationTransitioning = !window.matchMedia?.("(prefers-reduced-motion: reduce)").matches;
+    if (presentationTransitionTimer !== null)
+        window.clearTimeout(presentationTransitionTimer);
+    presentationTransitionTimer = presentationTransitioning
+        ? window.setTimeout(() => {
+            presentationTransitionTimer = null;
+            presentationTransitioning = false;
+            notify();
+        }, 220)
+        : null;
+    notify();
+}
+/** Holding A temporarily enables app interaction without changing the selected tool. */
+export function setTemporaryAppInteraction(value) {
+    if (temporaryAppInteraction === value)
+        return;
+    temporaryAppInteraction = value;
+    notify();
+}
+/** Element interactions pause while frame and camera geometry are animated. */
+export function setCanvasLayoutTransitioning(value) {
+    if (layoutTransitioning === value)
+        return;
+    layoutTransitioning = value;
+    notify();
+}
+export function getCanvasLayoutTransitioning() { return layoutTransitioning; }
+export function getBoardCamera() { return camera; }
+export function setBoardCamera(next) {
+    camera = { x: next.x, y: next.y, zoom: clampZoom(next.zoom) };
+    notify();
+}
+export function updateBoardCamera(partial) {
+    setBoardCamera({ ...camera, ...partial });
+}
+/** Moves the camera to frame content; the initial fit-all then no longer runs. */
+export function placeBoardCamera(next) {
+    cameraPlaced = true;
+    setBoardCamera(next);
+}
+export function hasFitAllRan() { return cameraPlaced; }
+export function resetFitAllFlag() { cameraPlaced = false; }
+export function restoreCanvasView(next) {
+    mode = next.mode;
+    presentation = next.presentation;
+    camera = { ...next.camera };
+    cameraPlaced = true;
+    notify();
+}
+export function useCanvasMode() {
+    return useSyncExternalStore(subscribeCanvasView, getCanvasMode, getCanvasMode);
+}
+export function useCanvasPresentation() {
+    return useSyncExternalStore(subscribeCanvasView, getCanvasPresentation, getCanvasPresentation);
+}
+export function useCanvasPresentationTransitioning() {
+    return useSyncExternalStore(subscribeCanvasView, () => presentationTransitioning, () => presentationTransitioning);
+}
+export function useTemporaryAppInteraction() {
+    return useSyncExternalStore(subscribeCanvasView, () => temporaryAppInteraction, () => temporaryAppInteraction);
+}
+export function useCanvasLayoutTransitioning() {
+    return useSyncExternalStore(subscribeCanvasView, getCanvasLayoutTransitioning, getCanvasLayoutTransitioning);
+}
+export function useBoardCamera() {
+    return useSyncExternalStore(subscribeCanvasView, getBoardCamera, getBoardCamera);
+}

package/dist/inspector/canvas/wheelPan.d.ts

@@ -0,0 +1,8 @@
+/** Converts wheel units to pixel distances for consistent canvas panning. */
+export declare function wheelPanDelta(event: Pick<WheelEvent, "deltaX" | "deltaY" | "deltaMode" | "shiftKey">, viewport: {
+    width: number;
+    height: number;
+}): {
+    x: number;
+    y: number;
+};

package/dist/inspector/canvas/wheelPan.js

@@ -0,0 +1,8 @@
+/** Converts wheel units to pixel distances for consistent canvas panning. */
+export function wheelPanDelta(event, viewport) {
+    const xUnit = event.deltaMode === 1 ? 16 : event.deltaMode === 2 ? viewport.width : 1;
+    const yUnit = event.deltaMode === 1 ? 16 : event.deltaMode === 2 ? viewport.height : 1;
+    const x = event.deltaX * xUnit;
+    const y = event.deltaY * yUnit;
+    return event.shiftKey && x === 0 ? { x: y, y: 0 } : { x, y };
+}

package/dist/inspector/changes/changesLog.d.ts

@@ -1,6 +1,6 @@
 import type { StyleRule } from "../projection/managedStylesheet.js";
 import type { ChangeRecord } from "./types.js";
-import { type CommitResult } from "./workspaceChanges.js";
+import { type CommitResult } from "./draftChanges.js";
 import type { StructuralChange } from "./structuralTypes.js";
 export { isComponentChange, isElementChange, isTextContentChange, isTextContentChangeValue, isPreviewableChange, isTokenChange, } from "./types.js";
 export type { ChangeRecord, ComponentChangeRecord, ElementChangeRecord, PreviewableChangeRecord, TextContentChangeRecord, TokenChangeRecord, RuntimeElementEvidence, } from "./types.js";
@@ -25,7 +25,7 @@ export declare function revertChange(change: ChangeRecord): void;
  */
 export declare function reconcileVerifiedChanges(verifiedKeys: ReadonlySet<string>): number;
 /** Atomically reconciles ordinary and structural intent from one agent handoff. */
-export declare function reconcileVerifiedWorkspaceChanges(verifiedKeys: ReadonlySet<string>, verifiedStructuralIds: ReadonlySet<string>): number;
+export declare function reconcileVerifiedDraftChanges(verifiedKeys: ReadonlySet<string>, verifiedStructuralIds: ReadonlySet<string>): number;
 export declare function discardChangesForSelector(selector: string): void;
 /** Relink removes every CSS declaration owned by one durable rendered target. */
 export declare function discardChangesForInstanceOverride(overrideId: string): void;
@@ -38,9 +38,10 @@ export declare function redo(): boolean;
  */
 export declare function restoreChangeRecords(incoming: ChangeRecord[]): void;
 /** Restores every canonical workspace intent as one subscriber-visible snapshot. */
-export declare function loadWorkspaceChanges(incoming: readonly ChangeRecord[], structuralChanges: readonly StructuralChange[]): void;
-/** Clears all workspace intent and its unified undo/redo timeline. */
-export declare function clearWorkspace(): void;
+export declare function loadActiveDraftChanges(incoming: readonly ChangeRecord[], structuralChanges: readonly StructuralChange[], preserveHistory?: boolean): void;
+/** Clears the active draft and its edit steps, preserving other session history. */
+export declare function clearActiveDraft(): void;
 export declare function getChangesList(): ChangeRecord[];
 export { subscribe as subscribeChanges, getChangesSnapshot as getChanges };
 export declare function useChanges(): ChangeRecord[];
+export declare function refreshDraftPreview(): void;

package/dist/inspector/changes/changesLog.js

@@ -1,13 +1,14 @@
+import { canEditDraft } from "./draftChanges.js";
 import { useSyncExternalStore } from "react";
 import { getSelectedElement } from "../selection/selectionStore.js";
 import { changeKey, } from "./model.js";
 import { buildManagedStyleRules, verifyManagedStyleProjection, } from "./managedStyleProjection.js";
 import { isPreviewableChange } from "./types.js";
 import { cancelInlineTextForClear } from "../inline-text/inlineTextLifecycle.js";
-import { workspaceChangeStore, } from "./workspaceChanges.js";
+import { draftChangeStore, } from "./draftChanges.js";
 import { beginPreviewAttempt, clearPreviewDiagnostics, getHostPreviewDocument, publishPreviewDiagnostic, } from "./previewDiagnostics.js";
 import { clearStructuralProjectionReports, pruneStructuralProjectionReports } from "../projection/structuralProjection.js";
-import { applyHostWorkspaceProjection, compileWorkspaceProjection, } from "../projection/workspaceProjection.js";
+import { applyHostDraftProjection, compileDraftProjection, } from "../projection/draftProjection.js";
 import { isEditorShellDocument } from "../runtime/editorShell.js";
 import { isOriginalPreviewActive, subscribeOriginalPreview, } from "../shell/originalPreview.js";
 export { isComponentChange, isElementChange, isTextContentChange, isTextContentChangeValue, isPreviewableChange, isTokenChange, } from "./types.js";
@@ -19,12 +20,12 @@ export { isComponentChange, isElementChange, isTextContentChange, isTextContentC
 let pendingVerificationTargets = new Map();
 let verificationHandle = null;
 function subscribe(cb) {
-    return workspaceChangeStore.subscribe(cb);
+    return draftChangeStore.subscribe(cb);
 }
 function getChangesSnapshot() {
     // SAFETY: The public change model is the concrete record union stored by
     // the workspace snapshot; this module preserves the mutable array facade.
-    return workspaceChangeStore.getSnapshot().changes;
+    return draftChangeStore.getSnapshot().changes;
 }
 export function getPendingRules() {
     return buildManagedStyleRules(getChangesSnapshot());
@@ -36,7 +37,7 @@ function reapply(workspace) {
     if (isOriginalPreviewActive())
         return;
     if (!isEditorShellDocument())
-        applyHostWorkspaceProjection(compileWorkspaceProjection(workspace));
+        applyHostDraftProjection(compileDraftProjection(workspace));
 }
 function flushVerification() {
     verificationHandle = null;
@@ -53,7 +54,7 @@ function flushVerification() {
     if (isEditorShellDocument())
         return;
     const current = getChangesSnapshot();
-    const attempt = beginPreviewAttempt(getHostPreviewDocument(), workspaceChangeStore.getSnapshot().revision);
+    const attempt = beginPreviewAttempt(getHostPreviewDocument(), draftChangeStore.getSnapshot().revision);
     if (!attempt)
         return;
     for (let i = 0; i < current.length; i++) {
@@ -125,10 +126,10 @@ subscribeOriginalPreview(() => {
 });
 /** Append records and report whether canonical workspace state changed. */
 export function appendChanges(incoming, options = {}) {
-    const result = workspaceChangeStore.commitChangeRecords(incoming);
+    const result = draftChangeStore.commitChangeRecords(incoming);
     if (result !== "applied")
         return result;
-    reapply(workspaceChangeStore.getSnapshot());
+    reapply(draftChangeStore.getSnapshot());
     // Re-verify the full surviving set so earlier diagnostics are refreshed at
     // the new revision instead of being orphaned at the old one.
     markForVerification(getChangesSnapshot().map(changeKey), options.verificationTargets);
@@ -138,9 +139,9 @@ export function appendChange(change) {
     return appendChanges([change]);
 }
 export function revertChange(change) {
-    if (!workspaceChangeStore.revertChangeRecord(change))
+    if (!draftChangeStore.revertChangeRecord(change))
         return;
-    reapply(workspaceChangeStore.getSnapshot());
+    reapply(draftChangeStore.getSnapshot());
     markForVerification(getChangesSnapshot().map(changeKey));
 }
 /**
@@ -152,46 +153,46 @@ export function revertChange(change) {
  * preserving newer, unsent edits and their remaining undo history.
  */
 export function reconcileVerifiedChanges(verifiedKeys) {
-    const removed = reconcileVerifiedWorkspaceChanges(verifiedKeys, new Set());
+    const removed = reconcileVerifiedDraftChanges(verifiedKeys, new Set());
     if (removed === 0)
         return 0;
     return removed;
 }
 /** Atomically reconciles ordinary and structural intent from one agent handoff. */
-export function reconcileVerifiedWorkspaceChanges(verifiedKeys, verifiedStructuralIds) {
-    const removed = workspaceChangeStore.reconcileWorkspaceChanges(verifiedKeys, verifiedStructuralIds);
+export function reconcileVerifiedDraftChanges(verifiedKeys, verifiedStructuralIds) {
+    const removed = draftChangeStore.reconcileActiveDraftChanges(verifiedKeys, verifiedStructuralIds);
     if (removed === 0)
         return 0;
-    reapply(workspaceChangeStore.getSnapshot());
+    reapply(draftChangeStore.getSnapshot());
     pruneStructuralProjectionReports(verifiedStructuralIds);
     markForVerification(getChangesSnapshot().map(changeKey));
     return removed;
 }
 export function discardChangesForSelector(selector) {
-    if (!workspaceChangeStore.discardChangeRecords({ kind: "selector", selector }))
+    if (!draftChangeStore.discardChangeRecords({ kind: "selector", selector }))
         return;
-    reapply(workspaceChangeStore.getSnapshot());
+    reapply(draftChangeStore.getSnapshot());
     markForVerification(getChangesSnapshot().map(changeKey));
 }
 /** Relink removes every CSS declaration owned by one durable rendered target. */
 export function discardChangesForInstanceOverride(overrideId) {
-    if (!workspaceChangeStore.discardChangeRecords({ kind: "instance-override", id: overrideId }))
+    if (!draftChangeStore.discardChangeRecords({ kind: "instance-override", id: overrideId }))
         return;
-    reapply(workspaceChangeStore.getSnapshot());
+    reapply(draftChangeStore.getSnapshot());
     markForVerification(getChangesSnapshot().map(changeKey));
 }
 export function undo() {
-    const undone = workspaceChangeStore.undoWorkspaceChange();
+    const undone = draftChangeStore.undoChange();
     if (undone)
-        reapply(workspaceChangeStore.getSnapshot());
+        reapply(draftChangeStore.getSnapshot());
     if (undone)
         markForVerification(getChangesSnapshot().map(changeKey));
     return undone;
 }
 export function redo() {
-    const redone = workspaceChangeStore.redoWorkspaceChange();
+    const redone = draftChangeStore.redoChange();
     if (redone)
-        reapply(workspaceChangeStore.getSnapshot());
+        reapply(draftChangeStore.getSnapshot());
     if (redone)
         markForVerification(getChangesSnapshot().map(changeKey));
     return redone;
@@ -207,28 +208,30 @@ export function restoreChangeRecords(incoming) {
     // inspect a newly loaded record with its old selection context.
     pendingVerificationTargets.clear();
     clearPreviewDiagnostics();
-    const workspace = workspaceChangeStore.getSnapshot();
-    workspaceChangeStore.restoreWorkspaceChanges({ changes: incoming, structuralChanges: workspace.structuralChanges });
-    reapply(workspaceChangeStore.getSnapshot());
+    const workspace = draftChangeStore.getSnapshot();
+    draftChangeStore.restoreActiveDraftChanges({ changes: incoming, structuralChanges: workspace.structuralChanges });
+    reapply(draftChangeStore.getSnapshot());
 }
 /** Restores every canonical workspace intent as one subscriber-visible snapshot. */
-export function loadWorkspaceChanges(incoming, structuralChanges) {
+export function loadActiveDraftChanges(incoming, structuralChanges, preserveHistory = false) {
     pendingVerificationTargets.clear();
     clearPreviewDiagnostics();
     clearStructuralProjectionReports();
-    workspaceChangeStore.restoreWorkspaceChanges({ changes: incoming, structuralChanges });
-    reapply(workspaceChangeStore.getSnapshot());
+    draftChangeStore.restoreActiveDraftChanges({ changes: incoming, structuralChanges }, preserveHistory);
+    reapply(draftChangeStore.getSnapshot());
 }
-/** Clears all workspace intent and its unified undo/redo timeline. */
-export function clearWorkspace() {
+/** Clears the active draft and its edit steps, preserving other session history. */
+export function clearActiveDraft() {
+    if (!canEditDraft())
+        return;
     // A pending blur/composition timer must not be able to append a draft after
     // the canonical set has been cleared.
     cancelInlineTextForClear();
     pendingVerificationTargets.clear();
     clearPreviewDiagnostics();
     clearStructuralProjectionReports();
-    workspaceChangeStore.clearWorkspaceChanges();
-    reapply(workspaceChangeStore.getSnapshot());
+    draftChangeStore.clearActiveDraftChanges();
+    reapply(draftChangeStore.getSnapshot());
 }
 export function getChangesList() {
     return [...getChangesSnapshot()];
@@ -237,3 +240,8 @@ export { subscribe as subscribeChanges, getChangesSnapshot as getChanges };
 export function useChanges() {
     return useSyncExternalStore(subscribe, getChangesSnapshot, getChangesSnapshot);
 }
+export function refreshDraftPreview() {
+    pendingVerificationTargets.clear();
+    reapply(draftChangeStore.getSnapshot());
+    markForVerification(getChangesSnapshot().map(changeKey));
+}

package/dist/inspector/changes/draftChanges.d.ts

@@ -0,0 +1,56 @@
+import { type ChangeRecord } from "./types.js";
+import type { StructuralChange } from "./structuralTypes.js";
+export { recordCanvasChange, discardCanvasHistory, discardDraftHistory, clearSessionUndoHistory, createChangeHistoryGroup, } from "../workspace/timeline.js";
+export interface DraftContents {
+    readonly changes: readonly ChangeRecord[];
+    readonly structuralChanges: readonly StructuralChange[];
+}
+export interface DraftChangesSnapshot extends DraftContents {
+    readonly draftId: string;
+    readonly revision: number;
+    readonly canUndo: boolean;
+    readonly canRedo: boolean;
+}
+export declare function lockDraft(id: string): () => void;
+export declare function isDraftLocked(id?: string): boolean;
+export declare function canEditDraft(id?: string): boolean;
+export declare function setActiveDraft(id: string, activate?: () => void): void;
+export type DraftProjector = (snapshot: DraftChangesSnapshot) => void;
+export type CommitResult = "applied" | "unchanged" | "blocked";
+export interface DraftChangeStore {
+    getSnapshot(): DraftChangesSnapshot;
+    subscribe(listener: () => void): () => void;
+    commitChangeRecords(incoming: readonly ChangeRecord[]): CommitResult;
+    revertChangeRecord(change: ChangeRecord): boolean;
+    discardChangeRecords(target: {
+        kind: "selector";
+        selector: string;
+    } | {
+        kind: "instance-override";
+        id: string;
+    }): boolean;
+    commitStructuralChange(change: StructuralChange): boolean;
+    revertStructuralChangeRecord(changeId: string): boolean;
+    reconcileActiveDraftChanges(verifiedKeys: ReadonlySet<string>, verifiedStructuralIds: ReadonlySet<string>): number;
+    undoChange(): boolean;
+    redoChange(): boolean;
+    restoreActiveDraftChanges(next: DraftContents, preserveHistory?: boolean): void;
+    clearActiveDraftChanges(): void;
+}
+export declare function subscribeDraftChanges(listener: (draftId: string) => void): () => void;
+export declare function getDraftChanges(id: string): DraftChangesSnapshot;
+export declare function restoreDraftChanges(id: string, next: DraftContents, revision?: number): void;
+export declare function reconcileDraftChanges(id: string, verifiedKeys: ReadonlySet<string>, verifiedStructuralIds: ReadonlySet<string>): number;
+export declare function clearDraftChanges(id: string, expectedRevision?: number): boolean;
+export declare function listDraftIds(): readonly string[];
+/** Drops a draft whose content no longer exists, such as a deleted iteration. */
+export declare function forgetDraft(id: string): void;
+export declare const draftChangeStore: DraftChangeStore;
+export declare function getActiveDraftChanges(): DraftChangesSnapshot;
+export declare function subscribeActiveDraftChanges(listener: () => void): () => void;
+export declare function commitChangeRecords(incoming: readonly ChangeRecord[], project: DraftProjector): CommitResult;
+export declare function commitStructuralChange(change: StructuralChange, project: DraftProjector): boolean;
+export declare function undoChange(project: DraftProjector): boolean;
+export declare function redoChange(project: DraftProjector): boolean;
+export declare function restoreActiveDraftChanges(next: DraftContents, project: DraftProjector): void;
+export declare function resetDraftChanges(): void;