nudge-ui 0.2.4 → 0.2.5

package/dist/inspector/drafts/draftStore.d.ts

@@ -0,0 +1,109 @@
+import { type ChangeRecord } from "../changes/types.js";
+import type { StructuralChange } from "../changes/structuralTypes.js";
+import type { SketchDocument } from "../sketch/model.js";
+import type { Timeline } from "../workspace/timeline.js";
+import { type Draft, type DraftContents, type DraftSnapshot } from "./model.js";
+export interface DraftChangesSnapshot extends DraftContents {
+    readonly draftId: string;
+    readonly revision: number;
+    readonly canUndo: boolean;
+    readonly canRedo: boolean;
+}
+/** A canonical write result. `blocked` means the lease or a save lock refused the write. */
+export type CommitResult = "applied" | "unchanged" | "blocked";
+/** Why the active draft's preview must be rebuilt. */
+export type DraftProjectionEvent = 
+/** The active draft's contents changed through an edit, revert, undo, or redo. */
+{
+    readonly kind: "edit";
+    readonly verificationTargets?: ReadonlyMap<string, HTMLElement | null>;
+}
+/** Source verification removed these records from the active draft. */
+ | {
+    readonly kind: "reconcile";
+    readonly structuralIds: ReadonlySet<string>;
+}
+/** Another draft became active, or drafts were loaded. */
+ | {
+    readonly kind: "switch";
+}
+/** The active draft was cleared; every earlier preview diagnostic is void. */
+ | {
+    readonly kind: "reset";
+};
+export type DraftDiscardTarget = {
+    readonly kind: "selector";
+    readonly selector: string;
+} | {
+    readonly kind: "instance-override";
+    readonly id: string;
+};
+export interface DraftStorage {
+    read(key: string): string | null;
+    write(key: string, value: string): void;
+    remove(key: string): void;
+}
+export interface DraftSketchSource {
+    getSnapshot(): {
+        readonly ready: boolean;
+        readonly documents: readonly SketchDocument[];
+    };
+    subscribe(listener: () => void): () => void;
+}
+export interface DraftStoreSeams {
+    /** Whether this tab holds the workspace write lease. */
+    canWrite(): boolean;
+    readonly timeline: Timeline;
+    readonly storage: DraftStorage;
+    readonly sketches: DraftSketchSource;
+    /** Rebuilds the active draft's preview. Called after subscribers see the new snapshot. */
+    project(snapshot: DraftChangesSnapshot, event: DraftProjectionEvent): void;
+}
+/**
+ * The Workspace's drafts. A draft's identity is its target key (ADR-0030):
+ * every frame that shows one page or iteration edits the same draft. Every
+ * write is lease-gated, every change to the active draft is projected, and
+ * reconciliation removes only verified records, including from history.
+ */
+export interface DraftStore {
+    getActive(): DraftChangesSnapshot;
+    /** Fires for any draft content change, active-draft switch, or history change. */
+    subscribeActive(listener: () => void): () => void;
+    get(id: string): DraftChangesSnapshot;
+    ids(): readonly string[];
+    getDraft(id: string): Draft | null;
+    getSnapshot(): DraftSnapshot;
+    subscribe(listener: () => void): () => void;
+    canEdit(id?: string): boolean;
+    isLocked(id?: string): boolean;
+    /** Blocks writes to one draft until the returned release runs. */
+    lock(id: string): () => void;
+    /** Makes a draft active; `reveal` brings its frame back when history replays an edit. */
+    activate(id: string, reveal?: () => void): void;
+    commitChanges(incoming: readonly ChangeRecord[], verificationTargets?: ReadonlyMap<string, HTMLElement | null>): CommitResult;
+    revertChange(change: ChangeRecord): boolean;
+    discardChanges(target: DraftDiscardTarget): boolean;
+    commitStructuralChange(change: StructuralChange): boolean;
+    revertStructuralChange(changeId: string): boolean;
+    /** Replaces the active draft as one undoable edit. */
+    commitContents(next: DraftContents): boolean;
+    undo(): boolean;
+    redo(): boolean;
+    /** Removes source-verified records so no undo step can resurrect them. */
+    reconcile(id: string, verifiedKeys: ReadonlySet<string>, verifiedStructuralIds: ReadonlySet<string>): number;
+    clear(id: string, expectedRevision?: number): boolean;
+    clearActive(): boolean;
+    /** Drops a draft whose content no longer exists, such as a deleted iteration. */
+    forget(id: string): void;
+    sketchOwner(document: SketchDocument): string | null;
+    assignSketch(draftId: string, sketchId: string): void;
+    /** Replaces every in-memory draft with the stored drafts, so a tab that takes over never writes stale edits. */
+    load(projectId: string, options?: {
+        persistent?: boolean;
+    }): void;
+    persist(): void;
+    /** Discards stored and in-memory drafts for the current project. */
+    discardAll(): void;
+    reset(): void;
+}
+export declare function createDraftStore(seams: DraftStoreSeams): DraftStore;

package/dist/inspector/drafts/draftStore.js

@@ -0,0 +1,451 @@
+import { deserializeChange, isSerializableChange, serializeChange, } from "../changes/codecs.js";
+import { changeKey, mergeChange, sameEffectiveChanges, selectorForChange } from "../changes/model.js";
+import { isElementChange } from "../changes/types.js";
+import { isStructuralChange } from "../projection/structuralProjectionBoundary.js";
+import { applicationTarget, documentTarget, isDraftTarget, targetFromKey, targetKey, } from "./model.js";
+const EMPTY = { changes: [], structuralChanges: [] };
+const PROJECTION_RANK = { edit: 1, reconcile: 2, switch: 3, reset: 4 };
+function cloneValue(value, key) {
+    if (key === "oldToken" || key === "newToken")
+        return value;
+    if (Array.isArray(value))
+        return value.map((item) => cloneValue(item));
+    if (value !== null && typeof value === "object") {
+        const clone = {};
+        for (const [childKey, child] of Object.entries(value))
+            clone[childKey] = cloneValue(child, childKey);
+        return clone;
+    }
+    return value;
+}
+function freezeValue(value, key) {
+    if (key === "oldToken" || key === "newToken")
+        return value;
+    if (value !== null && typeof value === "object" && !Object.isFrozen(value)) {
+        for (const [childKey, child] of Object.entries(value))
+            freezeValue(child, childKey);
+        Object.freeze(value);
+    }
+    return value;
+}
+function frozenContents(value) {
+    return freezeValue({
+        changes: value.changes.map((change) => cloneValue(change)),
+        structuralChanges: value.structuralChanges.map((change) => cloneValue(change)),
+    });
+}
+function sameDraftContents(left, right) {
+    return sameEffectiveChanges([...left.changes], [...right.changes])
+        && JSON.stringify(left.structuralChanges) === JSON.stringify(right.structuralChanges);
+}
+function mergeProjection(current, next) {
+    return current && PROJECTION_RANK[current.kind] > PROJECTION_RANK[next.kind] ? current : next;
+}
+function isPersistedDrafts(value, projectId) {
+    if (!value || typeof value !== "object")
+        return false;
+    const candidate = value;
+    if (candidate.schemaVersion !== 2 || candidate.projectId !== projectId || !Array.isArray(candidate.drafts))
+        return false;
+    const targets = new Set();
+    for (const draft of candidate.drafts) {
+        if (!draft || !isDraftTarget(draft.target) || targets.has(targetKey(draft.target))
+            || !Number.isSafeInteger(draft.revision) || draft.revision < 1
+            || !draft.contents || !Array.isArray(draft.contents.changes) || !draft.contents.changes.every(isSerializableChange)
+            || !Array.isArray(draft.contents.structuralChanges) || !draft.contents.structuralChanges.every(isStructuralChange))
+            return false;
+        const textIds = draft.contents.changes
+            .filter((change) => change.kind === "text-content")
+            .map((change) => "id" in change ? change.id : "");
+        if (new Set(textIds).size !== textIds.length)
+            return false;
+        targets.add(targetKey(draft.target));
+    }
+    return !!candidate.sketchOwners && typeof candidate.sketchOwners === "object" && !Array.isArray(candidate.sketchOwners)
+        && Object.values(candidate.sketchOwners).every((id) => typeof id === "string" && targetFromKey(id) !== null);
+}
+export function createDraftStore(seams) {
+    const drafts = new Map();
+    const locked = new Set();
+    /** Overrides the capture-URL owner for sketches drawn while another draft was active. */
+    const sketchOwners = new Map();
+    const activeListeners = new Set();
+    const draftListeners = new Set();
+    /** Until a frame is activated, edits belong to the current page's draft. */
+    let activeDraftId = null;
+    let projectId = "";
+    let persistent = true;
+    let activeSnapshot = null;
+    let draftsSnapshot = null;
+    let depth = 0;
+    let activePending = false;
+    let draftsPending = false;
+    let pendingProjection = null;
+    const activeId = () => activeDraftId ??= targetKey(applicationTarget());
+    const storageKey = () => `nudge-ui-drafts:${projectId}:v2`;
+    function draftState(id = activeId()) {
+        let draft = drafts.get(id);
+        if (!draft) {
+            draft = { id, revision: 0, contents: EMPTY };
+            drafts.set(id, draft);
+        }
+        return draft;
+    }
+    function flush() {
+        if (activePending) {
+            activePending = false;
+            for (const listener of activeListeners)
+                listener();
+        }
+        if (draftsPending) {
+            draftsPending = false;
+            for (const listener of draftListeners)
+                listener();
+        }
+        if (pendingProjection) {
+            const event = pendingProjection;
+            pendingProjection = null;
+            seams.project(getActive(), event);
+        }
+    }
+    /** Subscribers and the projector observe only complete, settled state. */
+    function mutate(operation) {
+        depth += 1;
+        try {
+            return operation();
+        }
+        finally {
+            depth -= 1;
+            if (depth === 0)
+                flush();
+        }
+    }
+    function activeChanged() {
+        activeSnapshot = null;
+        activePending = true;
+        if (depth === 0)
+            flush();
+    }
+    function draftsChanged() {
+        draftsSnapshot = null;
+        draftsPending = true;
+        if (depth === 0)
+            flush();
+    }
+    function contentsChanged() {
+        draftsSnapshot = null;
+        draftsPending = true;
+        activeChanged();
+    }
+    function project(event) {
+        pendingProjection = mergeProjection(pendingProjection, event);
+    }
+    function replaceContents(draft, next) {
+        draft.contents = frozenContents(next);
+        draft.revision += 1;
+        contentsChanged();
+    }
+    function resetContents() {
+        drafts.clear();
+        locked.clear();
+        activeDraftId = null;
+        seams.timeline.clear();
+    }
+    function canEdit(id = activeId()) {
+        return seams.canWrite() && !locked.has(id);
+    }
+    function commitActive(next, event = { kind: "edit" }) {
+        if (!canEdit())
+            return false;
+        return mutate(() => {
+            const draft = draftState();
+            const before = draft.contents;
+            replaceContents(draft, next);
+            seams.timeline.recordEdit({ draftId: draft.id, activate: draft.activate, before, after: draft.contents }, sameDraftContents);
+            project(event);
+            return true;
+        });
+    }
+    function activate(id, reveal) {
+        mutate(() => {
+            draftState(id).activate = reveal;
+            if (activeId() === id)
+                return;
+            activeDraftId = id;
+            activeChanged();
+            project({ kind: "switch" });
+        });
+    }
+    function replay(direction) {
+        if (locked.size > 0 || !seams.canWrite())
+            return false;
+        return mutate(() => {
+            const replayed = seams.timeline.replay(direction, (entry, next) => {
+                replaceContents(draftState(entry.draftId), next);
+                entry.activate?.();
+                if (!entry.activate)
+                    activate(entry.draftId);
+            });
+            if (replayed)
+                project({ kind: "edit" });
+            return replayed;
+        });
+    }
+    function clear(id, event, expectedRevision) {
+        const draft = draftState(id);
+        if (!canEdit(id) || (expectedRevision !== undefined && draft.revision !== expectedRevision))
+            return false;
+        mutate(() => {
+            replaceContents(draft, EMPTY);
+            seams.timeline.discardDraftHistory(id);
+            if (id === activeId())
+                project(event);
+        });
+        return true;
+    }
+    function get(id) {
+        const draft = drafts.get(id);
+        return {
+            draftId: id,
+            revision: draft?.revision ?? 0,
+            changes: draft?.contents.changes ?? [],
+            structuralChanges: draft?.contents.structuralChanges ?? [],
+            ...seams.timeline.status(),
+        };
+    }
+    function getActive() {
+        if (!activeSnapshot) {
+            const draft = draftState();
+            activeSnapshot = Object.freeze({ draftId: draft.id, revision: draft.revision, ...draft.contents, ...seams.timeline.status() });
+        }
+        return activeSnapshot;
+    }
+    function sketchOwner(document) {
+        const owner = sketchOwners.get(document.id);
+        if (owner)
+            return owner;
+        try {
+            return targetKey(documentTarget(document.capture.url));
+        }
+        catch {
+            return null;
+        }
+    }
+    function getDraft(id) {
+        const target = targetFromKey(id);
+        if (!target)
+            return null;
+        const { revision, changes, structuralChanges } = get(id);
+        return {
+            id,
+            target,
+            revision,
+            contents: { changes, structuralChanges },
+            sketchIds: seams.sketches.getSnapshot().documents.filter((document) => sketchOwner(document) === id).map((document) => document.id),
+        };
+    }
+    function persisted() {
+        const sketches = seams.sketches.getSnapshot();
+        const liveSketches = new Set(sketches.documents.map((document) => document.id));
+        return {
+            schemaVersion: 2,
+            projectId,
+            drafts: [...drafts.values()].flatMap(({ id, revision, contents }) => {
+                const target = targetFromKey(id);
+                if (!target || contents.changes.length + contents.structuralChanges.length === 0)
+                    return [];
+                return [{
+                        target,
+                        revision,
+                        contents: {
+                            changes: contents.changes.flatMap((change) => {
+                                const serialized = serializeChange(change);
+                                return serialized ? [serialized] : [];
+                            }),
+                            structuralChanges: contents.structuralChanges,
+                        },
+                    }];
+            }),
+            sketchOwners: Object.fromEntries([...sketchOwners].filter(([id]) => !sketches.ready || liveSketches.has(id))),
+        };
+    }
+    function restore() {
+        const raw = persistent ? seams.storage.read(storageKey()) : null;
+        const stored = raw ? JSON.parse(raw) : null;
+        if (!isPersistedDrafts(stored, projectId))
+            return;
+        for (const draft of stored.drafts) {
+            const state = draftState(targetKey(draft.target));
+            state.contents = frozenContents({
+                changes: draft.contents.changes.map(deserializeChange),
+                structuralChanges: draft.contents.structuralChanges,
+            });
+            state.revision = draft.revision;
+        }
+        for (const [sketchId, draftId] of Object.entries(stored.sketchOwners))
+            sketchOwners.set(sketchId, draftId);
+    }
+    seams.timeline.subscribe(activeChanged);
+    seams.sketches.subscribe(draftsChanged);
+    return {
+        getActive,
+        subscribeActive(listener) {
+            activeListeners.add(listener);
+            return () => activeListeners.delete(listener);
+        },
+        get,
+        ids: () => [...drafts.keys()],
+        getDraft,
+        getSnapshot() {
+            if (!draftsSnapshot) {
+                const ids = new Set([
+                    ...drafts.keys(),
+                    ...seams.sketches.getSnapshot().documents.flatMap((document) => sketchOwner(document) ?? []),
+                ]);
+                draftsSnapshot = { projectId, drafts: [...ids].flatMap((id) => getDraft(id) ?? []) };
+            }
+            return draftsSnapshot;
+        },
+        subscribe(listener) {
+            draftListeners.add(listener);
+            return () => draftListeners.delete(listener);
+        },
+        canEdit,
+        isLocked: (id) => id === undefined ? locked.size > 0 : locked.has(id),
+        lock(id) {
+            if (locked.has(id))
+                throw new Error("This iteration is already saving.");
+            locked.add(id);
+            return () => { locked.delete(id); };
+        },
+        activate,
+        commitChanges(incoming, verificationTargets) {
+            if (incoming.length === 0)
+                return "unchanged";
+            const contents = draftState().contents;
+            const changes = incoming.reduce((current, change) => mergeChange(current, change), [...contents.changes]);
+            if (sameEffectiveChanges([...contents.changes], changes))
+                return "unchanged";
+            return commitActive({ ...contents, changes }, { kind: "edit", verificationTargets }) ? "applied" : "blocked";
+        },
+        revertChange(change) {
+            const contents = draftState().contents;
+            const changes = contents.changes.filter((candidate) => changeKey(candidate) !== changeKey(change));
+            return changes.length !== contents.changes.length && commitActive({ ...contents, changes });
+        },
+        discardChanges(target) {
+            const contents = draftState().contents;
+            const changes = contents.changes.filter((change) => target.kind === "selector"
+                ? selectorForChange(change) !== target.selector
+                : !isElementChange(change) || change.instanceOverride?.id !== target.id);
+            return changes.length !== contents.changes.length && commitActive({ ...contents, changes });
+        },
+        commitStructuralChange(change) {
+            const contents = draftState().contents;
+            if (contents.structuralChanges.some((candidate) => candidate.id === change.id))
+                return false;
+            return commitActive({ ...contents, structuralChanges: [...contents.structuralChanges, change] });
+        },
+        revertStructuralChange(changeId) {
+            const contents = draftState().contents;
+            const structuralChanges = contents.structuralChanges.filter((change) => change.id !== changeId);
+            return structuralChanges.length !== contents.structuralChanges.length && commitActive({ ...contents, structuralChanges });
+        },
+        commitContents: (next) => !sameDraftContents(draftState().contents, next) && commitActive(next),
+        undo: () => replay("undo"),
+        redo: () => replay("redo"),
+        reconcile(id, verifiedKeys, verifiedStructuralIds) {
+            if (!canEdit(id))
+                return 0;
+            const draft = draftState(id);
+            const retain = (value) => ({
+                changes: value.changes.filter((change) => !verifiedKeys.has(changeKey(change))),
+                structuralChanges: value.structuralChanges.filter((change) => !verifiedStructuralIds.has(change.id)),
+            });
+            const next = retain(draft.contents);
+            const removed = draft.contents.changes.length - next.changes.length
+                + draft.contents.structuralChanges.length - next.structuralChanges.length;
+            if (removed === 0)
+                return 0;
+            mutate(() => {
+                replaceContents(draft, next);
+                seams.timeline.pruneDraftHistory(id, retain, sameDraftContents);
+                if (id === activeId())
+                    project({ kind: "reconcile", structuralIds: verifiedStructuralIds });
+            });
+            return removed;
+        },
+        clear: (id, expectedRevision) => clear(id, { kind: "edit" }, expectedRevision),
+        clearActive: () => clear(activeId(), { kind: "reset" }),
+        forget(id) {
+            if (!drafts.has(id) || locked.has(id))
+                return;
+            mutate(() => {
+                seams.timeline.discardDraftHistory(id);
+                drafts.delete(id);
+                contentsChanged();
+                if (id === activeId())
+                    project({ kind: "edit" });
+            });
+        },
+        sketchOwner,
+        assignSketch(draftId, sketchId) {
+            if (sketchOwners.get(sketchId) === draftId || !targetFromKey(draftId))
+                return;
+            sketchOwners.set(sketchId, draftId);
+            draftsChanged();
+        },
+        load(nextProjectId, options = {}) {
+            mutate(() => {
+                projectId = nextProjectId;
+                persistent = options.persistent ?? true;
+                sketchOwners.clear();
+                resetContents();
+                try {
+                    restore();
+                }
+                catch {
+                    resetContents();
+                    sketchOwners.clear();
+                }
+                contentsChanged();
+                project({ kind: "switch" });
+            });
+        },
+        persist() {
+            if (!projectId || !persistent || !seams.canWrite())
+                return;
+            try {
+                seams.storage.write(storageKey(), JSON.stringify(persisted()));
+            }
+            catch {
+                return;
+            }
+        },
+        discardAll() {
+            if (projectId && persistent && seams.canWrite()) {
+                try {
+                    seams.storage.remove(storageKey());
+                }
+                catch {
+                    return;
+                }
+            }
+            mutate(() => {
+                sketchOwners.clear();
+                resetContents();
+                contentsChanged();
+                project({ kind: "reset" });
+            });
+        },
+        reset() {
+            mutate(() => {
+                projectId = "";
+                persistent = true;
+                sketchOwners.clear();
+                resetContents();
+                contentsChanged();
+            });
+        },
+    };
+}

package/dist/inspector/drafts/model.d.ts

@@ -1,4 +1,10 @@
-import type { DraftContents } from "../changes/draftChanges.js";
+import type { ChangeRecord } from "../changes/types.js";
+import type { StructuralChange } from "../changes/structuralTypes.js";
+/** The canonical intent of one draft: ordinary records and structural records. */
+export interface DraftContents {
+    readonly changes: readonly ChangeRecord[];
+    readonly structuralChanges: readonly StructuralChange[];
+}
 export type DraftTarget = {
     readonly kind: "application";
     readonly route: string;
@@ -28,6 +34,8 @@ export declare function htmlTarget(artifactId: string): {
     artifactId: string;
     path: string;
 };
+/** The HTML iteration artifact ID when the URL addresses an iteration document. */
+export declare function artifactIdFromUrl(url: string): string | null;
 /** Maps a captured document URL to the draft that owns it: an iteration preview or an application page. */
 export declare function documentTarget(url: string): DraftTarget;
 export declare function targetKey(target: DraftTarget): string;

package/dist/inspector/drafts/model.js

@@ -10,9 +10,13 @@ export function applicationTarget(url = window.location.href) {
 export function htmlTarget(artifactId) {
     return { kind: "html", artifactId, path: `.nudge/artifacts/${artifactId}/document.html` };
 }
+/** The HTML iteration artifact ID when the URL addresses an iteration document. */
+export function artifactIdFromUrl(url) {
+    return ARTIFACT_PATH.exec(new URL(url, window.location.href).pathname)?.[1] ?? null;
+}
 /** Maps a captured document URL to the draft that owns it: an iteration preview or an application page. */
 export function documentTarget(url) {
-    const artifactId = ARTIFACT_PATH.exec(new URL(url, window.location.href).pathname)?.[1];
+    const artifactId = artifactIdFromUrl(url);
     return artifactId ? htmlTarget(artifactId) : applicationTarget(url);
 }
 export function targetKey(target) {

package/dist/inspector/drafts/store.d.ts

@@ -1,28 +1,66 @@
 import { type FrameContent } from "../canvas/frameContent.js";
-import { type DraftContents } from "../changes/draftChanges.js";
+import type { ChangeRecord } from "../changes/types.js";
+import type { StructuralChange } from "../changes/structuralTypes.js";
+import type { StyleRule } from "../projection/managedStylesheet.js";
 import type { SketchDocument } from "../sketch/model.js";
-import { type Draft, type DraftSnapshot } from "./model.js";
+import { type CommitResult, type DraftChangesSnapshot } from "./draftStore.js";
+import { type Draft, type DraftContents, type DraftSnapshot } from "./model.js";
+export declare function getActiveDraftChanges(): DraftChangesSnapshot;
+export declare function subscribeActiveDraftChanges(listener: () => void): () => void;
+export declare function getDraftChanges(id: string): DraftChangesSnapshot;
+export declare function listDraftIds(): readonly string[];
+export declare function getDraft(id: string): Draft | null;
+export declare function getDraftsSnapshot(): DraftSnapshot;
+export declare function subscribeDrafts(listener: () => void): () => void;
+export declare function useDrafts(): DraftSnapshot;
+export declare function canEditDraft(id?: string): boolean;
+export declare function isDraftLocked(id?: string): boolean;
+export declare function lockDraft(id: string): () => void;
+export declare function useChanges(): ChangeRecord[];
+export declare function getChangesList(): ChangeRecord[];
+export declare function getPendingRules(): StyleRule[];
+export interface AppendChangesOptions {
+    /** The rendered target captured for each change key at commit time. */
+    verificationTargets?: ReadonlyMap<string, HTMLElement | null>;
+}
+/** Appends records and reports whether canonical workspace state changed. */
+export declare function appendChanges(incoming: readonly ChangeRecord[], options?: AppendChangesOptions): CommitResult;
+export declare function appendChange(change: ChangeRecord): CommitResult;
+export declare function revertChange(change: ChangeRecord): void;
+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;
+export declare function commitStructuralChange(change: StructuralChange): boolean;
+export declare function revertStructuralChange(changeId: string): boolean;
+/** Replaces ordinary and structural intent as one undoable edit. */
+export declare function commitDraftContents(changes: readonly ChangeRecord[], structuralChanges: readonly StructuralChange[]): boolean;
+export declare function undo(): boolean;
+export declare function redo(): boolean;
+/**
+ * Removes source-verified records without letting older undo snapshots
+ * resurrect their previews. Newer, unsent edits and their history survive.
+ */
+export declare function reconcileDraftChanges(id: string, verifiedKeys: ReadonlySet<string>, verifiedStructuralIds: ReadonlySet<string>): number;
+/** Clears the active draft and its edit steps, preserving other session history. */
+export declare function clearActiveDraft(): void;
+/** Drops a draft whose content no longer exists, such as a deleted iteration. */
+export declare function forgetDraft(id: string): void;
+export declare function loadDrafts(projectId: string, options?: {
+    persistent?: boolean;
+}): void;
+export declare function persistDrafts(): void;
+/** Discards stored and in-memory drafts for the current project. */
+export declare function clearDrafts(): void;
+export declare function resetDrafts(): void;
 export declare function draftIdForContent(content: FrameContent): string;
 export declare function draftIdForCard(cardId: string): string | null;
-export declare function sketchOwner(document: SketchDocument): string | null;
-export declare function getDraft(id: string): Draft | null;
 export declare function getDraftForCard(cardId: string): Draft | null;
 export declare function getDraftContentsForCard(cardId: string): DraftContents | null;
-export declare function persistDrafts(): void;
-/** Replaces every in-memory draft with the stored drafts, so a tab that takes over never writes stale edits. */
-export declare function loadDrafts(nextProjectId: string, options?: {
-    persistent?: boolean;
-}): void;
 export declare function activateDraftForCard(cardId: string): void;
 export declare function activateDraft(draftId: string, preferredCardId?: string): void;
 export declare function clearSavedIterationDraft(cardId: string, expectedRevision?: number): boolean;
 /** Returns the first preferred frame that exists, then the first frame. */
 export declare function getEditableCardId(...preferredCardIds: readonly (string | null | undefined)[]): string | null;
+export declare function sketchOwner(document: SketchDocument): string | null;
 export declare function assignSketchToDraft(draftId: string, sketchId: string): void;
 export declare function sketchBelongsToCard(document: SketchDocument, cardId: string | null): boolean;
-export declare function subscribeDrafts(listener: () => void): () => void;
-export declare function getDraftsSnapshot(): DraftSnapshot;
-export declare function useDrafts(): DraftSnapshot;
-/** Discards stored and in-memory drafts for the current project. */
-export declare function clearDrafts(): void;
-export declare function resetDrafts(): void;