nudge-ui 0.2.4 → 0.2.5

package/dist/inspector/changes/changesLog.js

@@ -1,255 +0,0 @@
-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 { draftChangeStore, } from "./draftChanges.js";
-import { beginPreviewAttempt, clearPreviewDiagnostics, getHostPreviewDocument, publishPreviewDiagnostic, } from "./previewDiagnostics.js";
-import { clearStructuralProjectionReports, pruneStructuralProjectionReports } from "../projection/structuralProjection.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";
-/**
- * Deferred delta verification (0044). Only the keys touched by a mutation are
- * re-verified, and the probe work runs coalesced off the synchronous commit
- * path (requestIdleCallback, falling back to rAF / a macrotask).
- */
-let pendingVerificationTargets = new Map();
-let verificationHandle = null;
-function 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 draftChangeStore.getSnapshot().changes;
-}
-export function getPendingRules() {
-    return buildManagedStyleRules(getChangesSnapshot());
-}
-function reapply(workspace) {
-    // While hold-to-view-original is active the host document intentionally
-    // shows the page without inspector changes. Commits still land in the
-    // canonical store; the release path re-projects the latest snapshot.
-    if (isOriginalPreviewActive())
-        return;
-    if (!isEditorShellDocument())
-        applyHostDraftProjection(compileDraftProjection(workspace));
-}
-function flushVerification() {
-    verificationHandle = null;
-    // Probing the original preview would report the held-back changes as
-    // conflicts. Keep the pending targets; releasing re-verifies them.
-    if (isOriginalPreviewActive())
-        return;
-    const targets = pendingVerificationTargets;
-    pendingVerificationTargets = new Map();
-    if (targets.size === 0)
-        return;
-    // The editor shell has no application document. Renderer diagnostics are
-    // owned by renderer projection reports.
-    if (isEditorShellDocument())
-        return;
-    const current = getChangesSnapshot();
-    const attempt = beginPreviewAttempt(getHostPreviewDocument(), draftChangeStore.getSnapshot().revision);
-    if (!attempt)
-        return;
-    for (let i = 0; i < current.length; i++) {
-        const change = current[i];
-        if (!isPreviewableChange(change))
-            continue;
-        const key = changeKey(change);
-        if (!targets.has(key))
-            continue;
-        const result = verifyManagedStyleProjection(change, targets.get(key) ?? null);
-        if (result) {
-            publishPreviewDiagnostic(attempt, key, result);
-        }
-    }
-}
-function scheduleVerification() {
-    if (verificationHandle !== null)
-        return;
-    const view = typeof window !== "undefined" ? window : undefined;
-    if (view && typeof view.requestIdleCallback === "function") {
-        verificationHandle = view.requestIdleCallback(() => {
-            flushVerification();
-        }, { timeout: 200 });
-    }
-    else if (view && typeof view.requestAnimationFrame === "function") {
-        verificationHandle = view.requestAnimationFrame(() => {
-            flushVerification();
-        });
-    }
-    else {
-        verificationHandle = setTimeout(() => {
-            flushVerification();
-        }, 0);
-    }
-}
-/**
- * Marks the given change keys for deferred re-verification. Undo/redo/revert
- * re-verify the surviving set (their sheet projection changed globally).
- * A plain commit re-verifies the full surviving set as well: a new rule can
- * change cascade/specificity for earlier changes, so verifying only incoming
- * records would drop their conflict warnings.
- */
-function markForVerification(keys, verificationTargets) {
-    const selectedElement = getSelectedElement()?.domElement ?? null;
-    let added = false;
-    for (const key of keys) {
-        if (!pendingVerificationTargets.has(key))
-            added = true;
-        // Keep the latest commit context for a merged key. The element may be in
-        // an iframe, so this is also the document boundary for verification.
-        pendingVerificationTargets.set(key, verificationTargets?.get(key) ?? selectedElement);
-    }
-    if (added)
-        scheduleVerification();
-}
-/**
- * Releasing hold-to-view-original restores the edited preview; re-verify the
- * surviving set against the restored DOM instead of leaving peek-era state.
- * The retry is forced: a flush that ran during the hold retains its targets
- * without scheduling, so markForVerification alone would see every key
- * already present and schedule nothing.
- */
-subscribeOriginalPreview(() => {
-    if (isOriginalPreviewActive())
-        return;
-    markForVerification(getChangesSnapshot().map(changeKey));
-    if (pendingVerificationTargets.size > 0)
-        scheduleVerification();
-});
-/** Append records and report whether canonical workspace state changed. */
-export function appendChanges(incoming, options = {}) {
-    const result = draftChangeStore.commitChangeRecords(incoming);
-    if (result !== "applied")
-        return result;
-    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);
-    return result;
-}
-export function appendChange(change) {
-    return appendChanges([change]);
-}
-export function revertChange(change) {
-    if (!draftChangeStore.revertChangeRecord(change))
-        return;
-    reapply(draftChangeStore.getSnapshot());
-    markForVerification(getChangesSnapshot().map(changeKey));
-}
-/**
- * Removes source-verified records without allowing older undo snapshots to
- * resurrect their managed previews.
- *
- * Agent handoff revisions identify records by the same stable key used by the
- * canonical change model. Verification can therefore reconcile a subset while
- * preserving newer, unsent edits and their remaining undo history.
- */
-export function reconcileVerifiedChanges(verifiedKeys) {
-    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 reconcileVerifiedDraftChanges(verifiedKeys, verifiedStructuralIds) {
-    const removed = draftChangeStore.reconcileActiveDraftChanges(verifiedKeys, verifiedStructuralIds);
-    if (removed === 0)
-        return 0;
-    reapply(draftChangeStore.getSnapshot());
-    pruneStructuralProjectionReports(verifiedStructuralIds);
-    markForVerification(getChangesSnapshot().map(changeKey));
-    return removed;
-}
-/** Replaces ordinary and structural intent as one undoable edit. */
-export function commitDraftContents(changes, structuralChanges) {
-    if (!draftChangeStore.commitContents({ changes: [...changes], structuralChanges: [...structuralChanges] }))
-        return false;
-    reapply(draftChangeStore.getSnapshot());
-    markForVerification(getChangesSnapshot().map(changeKey));
-    return true;
-}
-export function discardChangesForSelector(selector) {
-    if (!draftChangeStore.discardChangeRecords({ kind: "selector", selector }))
-        return;
-    reapply(draftChangeStore.getSnapshot());
-    markForVerification(getChangesSnapshot().map(changeKey));
-}
-/** Relink removes every CSS declaration owned by one durable rendered target. */
-export function discardChangesForInstanceOverride(overrideId) {
-    if (!draftChangeStore.discardChangeRecords({ kind: "instance-override", id: overrideId }))
-        return;
-    reapply(draftChangeStore.getSnapshot());
-    markForVerification(getChangesSnapshot().map(changeKey));
-}
-export function undo() {
-    const undone = draftChangeStore.undoChange();
-    if (undone)
-        reapply(draftChangeStore.getSnapshot());
-    if (undone)
-        markForVerification(getChangesSnapshot().map(changeKey));
-    return undone;
-}
-export function redo() {
-    const redone = draftChangeStore.redoChange();
-    if (redone)
-        reapply(draftChangeStore.getSnapshot());
-    if (redone)
-        markForVerification(getChangesSnapshot().map(changeKey));
-    return redone;
-}
-/**
- * Replaces ordinary records while preserving structural intent. Restoring any
- * dimension is terminal for the unified workspace timeline, so undo and redo
- * history are reset for both dimensions.
- */
-export function restoreChangeRecords(incoming) {
-    // A restored session replaces the change set and may also switch the active
-    // document. Do not let a deferred verification from the previous session
-    // inspect a newly loaded record with its old selection context.
-    pendingVerificationTargets.clear();
-    clearPreviewDiagnostics();
-    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 loadActiveDraftChanges(incoming, structuralChanges, preserveHistory = false) {
-    pendingVerificationTargets.clear();
-    clearPreviewDiagnostics();
-    clearStructuralProjectionReports();
-    draftChangeStore.restoreActiveDraftChanges({ changes: incoming, structuralChanges }, preserveHistory);
-    reapply(draftChangeStore.getSnapshot());
-}
-/** 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();
-    draftChangeStore.clearActiveDraftChanges();
-    reapply(draftChangeStore.getSnapshot());
-}
-export function getChangesList() {
-    return [...getChangesSnapshot()];
-}
-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

@@ -1,58 +0,0 @@
-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;
-    /** Replaces the active draft as one undoable edit. */
-    commitContents(next: DraftContents): 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

@@ -1,304 +0,0 @@
-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 });
-}
-function commitContentsImpl(next) {
-    return !sameDraftContents(draftState().contents, next) && commit(next);
-}
-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,
-    commitContents: commitContentsImpl,
-    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/conformance/projection.d.ts

@@ -1,2 +0,0 @@
-export { projectInspectorValues, projectionSides, } from "../spacing/projection.js";
-export type { InspectorAxisProjection, InspectorFieldProjection, InspectorProjection, InspectorSpacingProjection, ProjectionAxis, ProjectionGroup, ProjectionSide, ProjectionState, } from "../spacing/projection.js";

package/dist/inspector/conformance/projection.js

@@ -1,3 +0,0 @@
-// Compatibility re-export. Production callers use the spacing module directly;
-// existing conformance consumers can keep their import while the seam moves.
-export { projectInspectorValues, projectionSides, } from "../spacing/projection.js";

package/dist/inspector/inline-text/textChangeBoundary.d.ts

@@ -1,6 +0,0 @@
-/**
- * Compatibility seam for the former inline-text model owner. The shared
- * vocabulary and guards now live in `changes/editModel.ts`.
- */
-export type { TextBindingEvidence, TextContentChangeRecord, TextProjectionScope, TextProjectionSourceSite, TextProjectionTarget, } from "../changes/editModel.js";
-export { isTextContentChangeListValue, isTextContentChangeValue, isTextProjectionTargetValue, } from "../changes/editModel.js";

package/dist/inspector/inline-text/textChangeBoundary.js

@@ -1 +0,0 @@
-export { isTextContentChangeListValue, isTextContentChangeValue, isTextProjectionTargetValue, } from "../changes/editModel.js";

package/dist/inspector/overlay/InspectorOverlay.d.ts

@@ -1,5 +0,0 @@
-import type { ReactElement } from "react";
-export { getMarginFills, getMarginGuides, type MarginFill, type MarginGuide, type MarginGuideSide, } from "./overlayGeometry.js";
-export declare function InspectorOverlay({ host }: {
-    host: HTMLElement;
-}): ReactElement;