nudge-ui 0.2.1 → 0.2.3

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;

package/dist/inspector/changes/draftChanges.js

@@ -0,0 +1,300 @@
+import { canWriteWorkspace } from "../canvas/workspaceLease.js";
+import { applicationTarget, targetKey } from "../drafts/model.js";
+import { changeKey, mergeChange, sameEffectiveChanges, selectorForChange } from "./model.js";
+import { isElementChange } from "./types.js";
+import { recordEdit, replayTimeline, pruneDraftHistory, timelineStatus, subscribeTimeline, clearSessionUndoHistory, discardDraftHistory, } from "../workspace/timeline.js";
+export { recordCanvasChange, discardCanvasHistory, discardDraftHistory, clearSessionUndoHistory, createChangeHistoryGroup, } from "../workspace/timeline.js";
+const drafts = new Map();
+const lockedDrafts = new Set();
+const listeners = new Set();
+const draftListeners = new Set();
+/** Until a frame is activated, edits belong to the current page's draft. */
+let activeDraftId = null;
+function activeId() {
+    return activeDraftId ??= targetKey(applicationTarget());
+}
+function draftState(id = activeId()) {
+    let draft = drafts.get(id);
+    if (!draft) {
+        draft = { id, revision: 0, contents: { changes: [], structuralChanges: [] } };
+        drafts.set(id, draft);
+    }
+    return draft;
+}
+export function lockDraft(id) {
+    if (lockedDrafts.has(id))
+        throw new Error("This iteration is already saving.");
+    lockedDrafts.add(id);
+    return () => { lockedDrafts.delete(id); };
+}
+export function isDraftLocked(id) {
+    return id === undefined ? lockedDrafts.size > 0 : lockedDrafts.has(id);
+}
+export function canEditDraft(id = activeId()) {
+    return canWriteWorkspace() && !lockedDrafts.has(id);
+}
+export function setActiveDraft(id, activate) {
+    draftState(id).activate = activate;
+    if (activeId() === id)
+        return;
+    activeDraftId = id;
+    publishSelection();
+}
+let snapshot = null;
+function cloneContents(value) {
+    return {
+        changes: value.changes.map((change) => cloneValue(change)),
+        structuralChanges: value.structuralChanges.map((change) => cloneValue(change)),
+    };
+}
+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 [key, child] of Object.entries(value)) {
+            clone[key] = cloneValue(child, key);
+        }
+        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 createSnapshot() {
+    const draft = draftState();
+    return Object.freeze({ draftId: draft.id, revision: draft.revision, ...draft.contents, ...timelineStatus() });
+}
+let notificationDepth = 0;
+let notificationPending = false;
+function mutate(operation) {
+    notificationDepth += 1;
+    try {
+        return operation();
+    }
+    finally {
+        notificationDepth -= 1;
+        if (notificationDepth === 0 && notificationPending) {
+            notificationPending = false;
+            publishSelection();
+        }
+    }
+}
+function publishSelection() {
+    if (notificationDepth > 0) {
+        notificationPending = true;
+        return;
+    }
+    snapshot = null;
+    for (const listener of listeners)
+        listener();
+}
+subscribeTimeline(publishSelection);
+function replaceContents(draft, next) {
+    draft.contents = freezeValue(cloneContents(next));
+    draft.revision += 1;
+    for (const listener of draftListeners)
+        listener(draft.id);
+    publishSelection();
+}
+export function subscribeDraftChanges(listener) {
+    draftListeners.add(listener);
+    return () => draftListeners.delete(listener);
+}
+export function getDraftChanges(id) {
+    const draft = drafts.get(id);
+    return {
+        draftId: id,
+        revision: draft?.revision ?? 0,
+        changes: draft?.contents.changes ?? [],
+        structuralChanges: draft?.contents.structuralChanges ?? [],
+        ...timelineStatus(),
+    };
+}
+export function restoreDraftChanges(id, next, revision = 1) {
+    const draft = draftState(id);
+    draft.contents = freezeValue(cloneContents(next));
+    draft.revision = revision;
+    publishSelection();
+}
+function commit(next) {
+    if (!canEditDraft())
+        return false;
+    const draft = draftState();
+    const before = draft.contents;
+    mutate(() => {
+        replaceContents(draft, next);
+        recordEdit({ draftId: draft.id, activate: draft.activate, before, after: draft.contents }, sameDraftContents);
+    });
+    return true;
+}
+function getSnapshot() { return snapshot ??= createSnapshot(); }
+function subscribe(listener) {
+    listeners.add(listener);
+    return () => listeners.delete(listener);
+}
+function commitChangeRecordsImpl(incoming) {
+    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 commit({ ...contents, changes }) ? "applied" : "blocked";
+}
+function revertChangeRecordImpl(change) {
+    const contents = draftState().contents;
+    const changes = contents.changes.filter((candidate) => changeKey(candidate) !== changeKey(change));
+    return changes.length !== contents.changes.length && commit({ ...contents, changes });
+}
+function discardChangeRecordsImpl(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 && commit({ ...contents, changes });
+}
+function commitStructuralChangeImpl(change) {
+    const contents = draftState().contents;
+    if (contents.structuralChanges.some((candidate) => candidate.id === change.id))
+        return false;
+    return commit({ ...contents, structuralChanges: [...contents.structuralChanges, change] });
+}
+function revertStructuralChangeRecordImpl(changeId) {
+    const contents = draftState().contents;
+    const structuralChanges = contents.structuralChanges.filter((change) => change.id !== changeId);
+    return structuralChanges.length !== contents.structuralChanges.length && commit({ ...contents, structuralChanges });
+}
+export function reconcileDraftChanges(id, verifiedKeys, verifiedStructuralIds) {
+    if (!canEditDraft(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);
+        pruneDraftHistory(id, retain, sameDraftContents);
+    });
+    return removed;
+}
+function reconcileActiveDraftChangesImpl(keys, ids) {
+    return reconcileDraftChanges(activeId(), keys, ids);
+}
+function sameDraftContents(left, right) {
+    return sameEffectiveChanges([...left.changes], [...right.changes])
+        && JSON.stringify(left.structuralChanges) === JSON.stringify(right.structuralChanges);
+}
+function replay(direction) {
+    if (isDraftLocked() || !canWriteWorkspace())
+        return false;
+    return mutate(() => replayTimeline(direction, (entry, next) => {
+        replaceContents(draftState(entry.draftId), next);
+        entry.activate?.();
+        if (!entry.activate)
+            setActiveDraft(entry.draftId);
+    }));
+}
+function restoreActiveDraftChangesImpl(next, preserveHistory = false) {
+    mutate(() => {
+        replaceContents(draftState(), next);
+        if (!preserveHistory)
+            clearSessionUndoHistory();
+    });
+}
+export function clearDraftChanges(id, expectedRevision) {
+    const draft = draftState(id);
+    if (!canEditDraft(id) || (expectedRevision !== undefined && draft.revision !== expectedRevision))
+        return false;
+    mutate(() => {
+        replaceContents(draft, { changes: [], structuralChanges: [] });
+        discardDraftHistory(id);
+    });
+    return true;
+}
+export function listDraftIds() {
+    return [...drafts.keys()];
+}
+/** Drops a draft whose content no longer exists, such as a deleted iteration. */
+export function forgetDraft(id) {
+    if (!drafts.has(id) || lockedDrafts.has(id))
+        return;
+    discardDraftHistory(id);
+    drafts.delete(id);
+    for (const listener of draftListeners)
+        listener(id);
+    publishSelection();
+}
+function clearActiveDraftChangesImpl() { clearDraftChanges(activeId()); }
+function resetDraftChangesImpl() {
+    drafts.clear();
+    lockedDrafts.clear();
+    activeDraftId = null;
+    clearSessionUndoHistory();
+    publishSelection();
+}
+export const draftChangeStore = {
+    getSnapshot, subscribe,
+    commitChangeRecords: commitChangeRecordsImpl,
+    revertChangeRecord: revertChangeRecordImpl,
+    discardChangeRecords: discardChangeRecordsImpl,
+    commitStructuralChange: commitStructuralChangeImpl,
+    revertStructuralChangeRecord: revertStructuralChangeRecordImpl,
+    reconcileActiveDraftChanges: reconcileActiveDraftChangesImpl,
+    undoChange: () => replay("undo"),
+    redoChange: () => replay("redo"),
+    restoreActiveDraftChanges: restoreActiveDraftChangesImpl,
+    clearActiveDraftChanges: clearActiveDraftChangesImpl,
+};
+export function getActiveDraftChanges() {
+    return draftChangeStore.getSnapshot();
+}
+export function subscribeActiveDraftChanges(listener) {
+    return draftChangeStore.subscribe(listener);
+}
+export function commitChangeRecords(incoming, project) {
+    const result = draftChangeStore.commitChangeRecords(incoming);
+    if (result === "applied")
+        project(draftChangeStore.getSnapshot());
+    return result;
+}
+export function commitStructuralChange(change, project) {
+    const changed = draftChangeStore.commitStructuralChange(change);
+    if (changed)
+        project(draftChangeStore.getSnapshot());
+    return changed;
+}
+export function undoChange(project) {
+    const changed = draftChangeStore.undoChange();
+    if (changed)
+        project(draftChangeStore.getSnapshot());
+    return changed;
+}
+export function redoChange(project) {
+    const changed = draftChangeStore.redoChange();
+    if (changed)
+        project(draftChangeStore.getSnapshot());
+    return changed;
+}
+export function restoreActiveDraftChanges(next, project) {
+    draftChangeStore.restoreActiveDraftChanges(next);
+    project(draftChangeStore.getSnapshot());
+}
+export function resetDraftChanges() {
+    resetDraftChangesImpl();
+}

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

@@ -3,9 +3,11 @@ import type { PreviewResult } from "../projection/managedStylesheet.js";
 export interface PreviewDocument {
     readonly logicalDocument: string;
     readonly sessionId: string;
+    readonly draftId?: string;
 }
 export interface PreviewAttempt extends PreviewDocument {
-    readonly workspaceRevision: number;
+    readonly draftId: string;
+    readonly draftRevision: number;
     readonly attempt: number;
 }
 export interface PreviewDiagnostic extends PreviewAttempt {
@@ -26,7 +28,7 @@ export declare function publishPreviewDiagnostic(attempt: PreviewAttempt, change
 export declare function clearPreviewDiagnostics(changeKeys?: Iterable<string>): void;
 /** Notifies consumers when verification state changes without a result. */
 export declare function notifyPreviewDiagnostics(): void;
-export declare function getPreviewDiagnostic(changeKey: string, logicalDocument?: string): PreviewDiagnostic | undefined;
+export declare function getPreviewDiagnostic(changeKey: string, logicalDocument?: string, draftId?: string): PreviewDiagnostic | undefined;
 /**
  * Host-first read across live documents. The per-document store is observable
  * here so a Canvas-only conflict is not write-only; host remains the default