nudge-ui 0.2.4 → 0.2.5

package/dist/inspector/drafts/store.js

@@ -1,28 +1,142 @@
+import { inspectorStorage } from "../runtime/inspectorStorage.js";
 import { useSyncExternalStore } from "react";
 import { getCanvasCards, selectCard, focusCanvasCards, activateIframeWorkspace } from "../canvas/canvasStore.js";
 import { contentEditTarget } from "../canvas/frameContent.js";
-import { deserializeChange, isSerializableChange, serializeChange, } from "../changes/codecs.js";
-import { getActiveDraftChanges, getDraftChanges, restoreDraftChanges, subscribeDraftChanges, setActiveDraft, clearDraftChanges, listDraftIds, resetDraftChanges, } from "../changes/draftChanges.js";
-import { refreshDraftPreview } from "../changes/changesLog.js";
-import { isStructuralChange } from "../projection/structuralProjection.js";
 import { canWriteWorkspace } from "../canvas/workspaceLease.js";
+import { createDraftPreview } from "../changes/draftPreview.js";
+import { buildManagedStyleRules } from "../changes/managedStyleProjection.js";
+import { cancelInlineTextForClear } from "../inline-text/inlineTextLifecycle.js";
 import { getSketchStoreSnapshot, subscribeSketchStore } from "../sketch/store.js";
-import { documentTarget, isDraftTarget, targetFromKey, targetKey } from "./model.js";
-let projectId = "";
-let persistent = true;
-/** Overrides the capture-URL owner for sketches drawn while another draft was active. */
-const sketchOwners = new Map();
+import { sessionTimeline } from "../workspace/timeline.js";
+import { createDraftStore } from "./draftStore.js";
+import { targetFromKey, targetKey } from "./model.js";
+const preview = createDraftPreview(() => drafts.getActive());
+/** The Workspace's drafts, wired to the Canvas lease, session timeline, local storage, and host preview. */
+const drafts = createDraftStore({
+    canWrite: () => canWriteWorkspace(),
+    timeline: sessionTimeline,
+    storage: {
+        read: (key) => inspectorStorage()?.getItem(key) ?? null,
+        write: (key, value) => inspectorStorage()?.setItem(key, value),
+        remove: (key) => inspectorStorage()?.removeItem(key),
+    },
+    sketches: { getSnapshot: () => getSketchStoreSnapshot(), subscribe: (listener) => subscribeSketchStore(listener) },
+    project: (snapshot, event) => preview.project(snapshot, event),
+});
 const contentDrafts = new WeakMap();
-const listeners = new Set();
-let snapshot = null;
-function publish() {
-    snapshot = null;
-    for (const listener of listeners)
-        listener();
-}
-subscribeDraftChanges(publish);
-subscribeSketchStore(publish);
-function storageKey() { return `nudge-ui-drafts:${projectId}:v2`; }
+export function getActiveDraftChanges() {
+    return drafts.getActive();
+}
+export function subscribeActiveDraftChanges(listener) {
+    return drafts.subscribeActive(listener);
+}
+export function getDraftChanges(id) {
+    return drafts.get(id);
+}
+export function listDraftIds() {
+    return drafts.ids();
+}
+export function getDraft(id) {
+    return drafts.getDraft(id);
+}
+export function getDraftsSnapshot() {
+    return drafts.getSnapshot();
+}
+export function subscribeDrafts(listener) {
+    return drafts.subscribe(listener);
+}
+export function useDrafts() {
+    return useSyncExternalStore(subscribeDrafts, getDraftsSnapshot, getDraftsSnapshot);
+}
+export function canEditDraft(id) {
+    return drafts.canEdit(id);
+}
+export function isDraftLocked(id) {
+    return drafts.isLocked(id);
+}
+export function lockDraft(id) {
+    return drafts.lock(id);
+}
+function activeChanges() {
+    // SAFETY: The public change model is the concrete record union stored by
+    // the workspace snapshot; React consumers keep the mutable array type.
+    return drafts.getActive().changes;
+}
+export function useChanges() {
+    return useSyncExternalStore(subscribeActiveDraftChanges, activeChanges, activeChanges);
+}
+export function getChangesList() {
+    return [...activeChanges()];
+}
+export function getPendingRules() {
+    return buildManagedStyleRules(activeChanges());
+}
+/** Appends records and reports whether canonical workspace state changed. */
+export function appendChanges(incoming, options = {}) {
+    return drafts.commitChanges(incoming, options.verificationTargets);
+}
+export function appendChange(change) {
+    return drafts.commitChanges([change]);
+}
+export function revertChange(change) {
+    drafts.revertChange(change);
+}
+export function discardChangesForSelector(selector) {
+    drafts.discardChanges({ kind: "selector", selector });
+}
+/** Relink removes every CSS declaration owned by one durable rendered target. */
+export function discardChangesForInstanceOverride(overrideId) {
+    drafts.discardChanges({ kind: "instance-override", id: overrideId });
+}
+export function commitStructuralChange(change) {
+    return drafts.commitStructuralChange(change);
+}
+export function revertStructuralChange(changeId) {
+    return drafts.revertStructuralChange(changeId);
+}
+/** Replaces ordinary and structural intent as one undoable edit. */
+export function commitDraftContents(changes, structuralChanges) {
+    return drafts.commitContents({ changes, structuralChanges });
+}
+export function undo() {
+    return drafts.undo();
+}
+export function redo() {
+    return drafts.redo();
+}
+/**
+ * Removes source-verified records without letting older undo snapshots
+ * resurrect their previews. Newer, unsent edits and their history survive.
+ */
+export function reconcileDraftChanges(id, verifiedKeys, verifiedStructuralIds) {
+    return drafts.reconcile(id, verifiedKeys, verifiedStructuralIds);
+}
+/** Clears the active draft and its edit steps, preserving other session history. */
+export function clearActiveDraft() {
+    if (!drafts.canEdit())
+        return;
+    // A pending blur/composition timer must not be able to append a draft after
+    // the canonical set has been cleared.
+    cancelInlineTextForClear();
+    drafts.clearActive();
+}
+/** Drops a draft whose content no longer exists, such as a deleted iteration. */
+export function forgetDraft(id) {
+    drafts.forget(id);
+}
+export function loadDrafts(projectId, options = {}) {
+    drafts.load(projectId, options);
+}
+export function persistDrafts() {
+    drafts.persist();
+}
+/** Discards stored and in-memory drafts for the current project. */
+export function clearDrafts() {
+    drafts.discardAll();
+}
+export function resetDrafts() {
+    drafts.reset();
+}
 export function draftIdForContent(content) {
     let id = contentDrafts.get(content);
     if (id === undefined) {
@@ -35,116 +149,12 @@ export function draftIdForCard(cardId) {
     const card = getCanvasCards().find((candidate) => candidate.id === cardId);
     return card ? draftIdForContent(card.content) : null;
 }
-export function sketchOwner(document) {
-    const owner = sketchOwners.get(document.id);
-    if (owner)
-        return owner;
-    try {
-        return targetKey(documentTarget(document.capture.url));
-    }
-    catch {
-        return null;
-    }
-}
-function readDraft(id, target) {
-    const workspace = getDraftChanges(id);
-    return {
-        id,
-        target,
-        revision: workspace.revision,
-        contents: { changes: workspace.changes, structuralChanges: workspace.structuralChanges },
-        sketchIds: getSketchStoreSnapshot().documents.filter((document) => sketchOwner(document) === id).map((document) => document.id),
-    };
-}
-export function getDraft(id) {
-    const target = targetFromKey(id);
-    return target ? readDraft(id, target) : null;
-}
 export function getDraftForCard(cardId) {
     const id = draftIdForCard(cardId);
-    return id ? getDraft(id) : null;
+    return id ? drafts.getDraft(id) : null;
 }
 export function getDraftContentsForCard(cardId) {
-    const draft = getDraftForCard(cardId);
-    return draft ? { changes: draft.contents.changes, structuralChanges: draft.contents.structuralChanges } : null;
-}
-export function persistDrafts() {
-    if (!projectId || !persistent || !canWriteWorkspace())
-        return;
-    const sketches = getSketchStoreSnapshot();
-    const liveSketches = new Set(sketches.documents.map((document) => document.id));
-    const value = {
-        schemaVersion: 2, projectId,
-        drafts: listDraftIds().flatMap((id) => {
-            const target = targetFromKey(id);
-            const workspace = getDraftChanges(id);
-            if (!target || workspace.changes.length + workspace.structuralChanges.length === 0)
-                return [];
-            return [{
-                    target,
-                    revision: workspace.revision,
-                    contents: {
-                        changes: workspace.changes.flatMap((change) => {
-                            const serialized = serializeChange(change);
-                            return serialized ? [serialized] : [];
-                        }),
-                        structuralChanges: workspace.structuralChanges,
-                    },
-                }];
-        }),
-        sketchOwners: Object.fromEntries([...sketchOwners].filter(([id]) => !sketches.ready || liveSketches.has(id))),
-    };
-    try {
-        localStorage.setItem(storageKey(), JSON.stringify(value));
-    }
-    catch {
-        return;
-    }
-}
-function validPersisted(value) {
-    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);
-}
-/** Replaces every in-memory draft with the stored drafts, so a tab that takes over never writes stale edits. */
-export function loadDrafts(nextProjectId, options = {}) {
-    projectId = nextProjectId;
-    persistent = options.persistent ?? true;
-    sketchOwners.clear();
-    resetDraftChanges();
-    try {
-        const raw = persistent ? localStorage.getItem(storageKey()) : null;
-        const stored = raw ? JSON.parse(raw) : null;
-        if (validPersisted(stored)) {
-            for (const draft of stored.drafts) {
-                restoreDraftChanges(targetKey(draft.target), { changes: draft.contents.changes.map(deserializeChange), structuralChanges: draft.contents.structuralChanges }, draft.revision);
-            }
-            for (const [sketchId, draftId] of Object.entries(stored.sketchOwners))
-                sketchOwners.set(sketchId, draftId);
-        }
-    }
-    catch {
-        resetDraftChanges();
-        sketchOwners.clear();
-    }
-    publish();
-    refreshDraftPreview();
+    return getDraftForCard(cardId)?.contents ?? null;
 }
 export function activateDraftForCard(cardId) {
     const draftId = draftIdForCard(cardId);
@@ -152,10 +162,7 @@ export function activateDraftForCard(cardId) {
         activateDraft(draftId, cardId);
 }
 export function activateDraft(draftId, preferredCardId) {
-    const previous = getActiveDraftChanges().draftId;
-    setActiveDraft(draftId, () => revealDraft(draftId, preferredCardId));
-    if (previous !== draftId)
-        refreshDraftPreview();
+    drafts.activate(draftId, () => revealDraft(draftId, preferredCardId));
 }
 function revealDraft(draftId, preferredCardId) {
     const cards = getCanvasCards();
@@ -177,55 +184,22 @@ function revealDraft(draftId, preferredCardId) {
 }
 export function clearSavedIterationDraft(cardId, expectedRevision) {
     const draftId = draftIdForCard(cardId);
-    return !!draftId && clearDraftChanges(draftId, expectedRevision);
+    return !!draftId && drafts.clear(draftId, expectedRevision);
 }
 /** Returns the first preferred frame that exists, then the first frame. */
 export function getEditableCardId(...preferredCardIds) {
     const cards = getCanvasCards();
     return preferredCardIds.find((id) => !!id && cards.some((card) => card.id === id)) ?? cards[0]?.id ?? null;
 }
+export function sketchOwner(document) {
+    return drafts.sketchOwner(document);
+}
 export function assignSketchToDraft(draftId, sketchId) {
-    if (sketchOwners.get(sketchId) === draftId || !targetFromKey(draftId))
-        return;
-    sketchOwners.set(sketchId, draftId);
-    publish();
+    drafts.assignSketch(draftId, sketchId);
 }
 export function sketchBelongsToCard(document, cardId) {
-    if (!projectId || !cardId)
+    if (!drafts.getSnapshot().projectId || !cardId)
         return true;
     const draftId = draftIdForCard(cardId);
-    return !!draftId && sketchOwner(document) === draftId;
-}
-export function subscribeDrafts(listener) {
-    listeners.add(listener);
-    return () => listeners.delete(listener);
-}
-export function getDraftsSnapshot() {
-    if (!snapshot) {
-        const ids = new Set([...listDraftIds(), ...getSketchStoreSnapshot().documents.flatMap((document) => sketchOwner(document) ?? [])]);
-        snapshot = { projectId, drafts: [...ids].flatMap((id) => getDraft(id) ?? []) };
-    }
-    return snapshot;
-}
-export function useDrafts() { return useSyncExternalStore(subscribeDrafts, getDraftsSnapshot, getDraftsSnapshot); }
-/** Discards stored and in-memory drafts for the current project. */
-export function clearDrafts() {
-    if (projectId && persistent && canWriteWorkspace()) {
-        try {
-            localStorage.removeItem(storageKey());
-        }
-        catch {
-            return;
-        }
-    }
-    sketchOwners.clear();
-    resetDraftChanges();
-    publish();
-}
-export function resetDrafts() {
-    projectId = "";
-    persistent = true;
-    sketchOwners.clear();
-    resetDraftChanges();
-    publish();
+    return !!draftId && drafts.sketchOwner(document) === draftId;
 }

package/dist/inspector/index.d.ts

@@ -1,8 +1,6 @@
+export { bootstrapNudgeUi, mountInspector, unmountInspector } from "./boot.js";
 export { resolveNudgeUiClientEntry } from "../transport/editor.js";
-export declare function bootstrapNudgeUi(inspectorHost: HTMLElement): void;
-export declare function mountInspector(host: HTMLElement): void;
-export declare function unmountInspector(): void;
-export { toggleInspector, setInspectorOpen } from "./shell/InspectorShell.js";
+export { toggleInspector, setInspectorOpen } from "./shell/openStore.js";
 export { InspectorShell } from "./shell/InspectorShell.js";
 export { detectFramework } from "./prompt/detectFramework.js";
 export { installStaticHtmlRuntimeIdentity, isRuntimeGeneratedSource, RUNTIME_ELEMENT_CID_PREFIX, RUNTIME_UNKNOWN_SOURCE_PREFIX, } from "./runtime/staticHtmlRuntimeIdentity.js";

package/dist/inspector/index.js

@@ -1,268 +1,6 @@
-import { startWorkspaceController } from "./workspace/controller.js";
-import { createElement } from "react";
-import { createRoot } from "react-dom/client";
-import { InspectorShell, toggleInspector, setInspectorOpen } from "./shell/InspectorShell.js";
-import { setSelectedElement } from "./selection/selectionStore.js";
-import { removeManagedSheet } from "./projection/managedStylesheet.js";
-import { isInspectorToggleShortcut, isOriginalPreviewShortcut, SEND_PROMPT_HOTKEY_EVENT, } from "./shell/shortcuts.js";
-import { isCanvasRenderer } from "./canvas/roleDetection.js";
-import { isKeyboardShortcutMessage } from "./canvas/frameProtocol.js";
-import { subscribeCanvasRendererMessages } from "./canvas/rendererMessageRouter.js";
-import { bootstrapRenderer } from "./canvas/rendererBootstrap.js";
-import { setRestoreCount, } from "./canvas/sessionStore.js";
-import { getChangesList } from "./changes/changesLog.js";
-import { acquireLease, enableWriteGuard, hasWriteLease, subscribeOwnership, } from "./canvas/workspaceLease.js";
-import { cancelStaleDetection, startStaleDetection } from "./canvas/staleChangeDetector.js";
-import { LockedWorkspaceNotice } from "./canvas/LockedWorkspaceNotice.js";
-import { AppShell } from "./shell/AppShell.js";
-import { installInspectionBridge } from "./inspection/bridge.js";
-import { releaseDocumentProjection, getStructuralChanges } from "./projection/structuralProjection.js";
-import { cancelInlineTextEdit } from "./inline-text/inlineTextEditor.js";
-import { configureNudgeUiRuntime, getNudgeUiRuntimeConfig, isDemoRuntime } from "./runtime/runtimeConfig.js";
-import { setCanvasMode } from "./canvas/viewStore.js";
-import { isNudgeUiDev, setNudgeUiHostDevFlag } from "./runtime/devFlag.js";
-import { clearClipboardHandoff, } from "./prompt/clipboardHandoff.js";
-import { createWorkspace, InspectorSessionProvider, } from "./session/index.js";
-import { clearSketchClipboardHandoff } from "./sketch/handoff.js";
-import { cancelSketchInteraction, isSketchInteractionActive } from "./sketch/interaction.js";
-import { setOriginalPreviewActive } from "./shell/originalPreview.js";
-import { initializeSketchStore } from "./sketch/store.js";
+export { bootstrapNudgeUi, mountInspector, unmountInspector } from "./boot.js";
 export { resolveNudgeUiClientEntry } from "../transport/editor.js";
-let hostElement = null;
-let reactRoot = null;
-let lockedRoot = null;
-const workspace = createWorkspace();
-let inspectorSession = null;
-let rendererBootstrapHandle = null;
-let workspaceController = null;
-let unsubscribeOwnership = null;
-let removeInspectionBridge = null;
-let keyboardPeekHeld = false;
-function onKeydown(e) {
-    if (isSketchInteractionActive())
-        return;
-    if (isInspectorToggleShortcut(e)) {
-        toggleInspector();
-        e.preventDefault();
-        return;
-    }
-    if (isOriginalPreviewShortcut(e)) {
-        keyboardPeekHeld = true;
-        setOriginalPreviewActive(true);
-        e.preventDefault();
-    }
-}
-function onKeyup(e) {
-    // Release only a keyboard-started peek so a button-held preview survives
-    // unrelated Backslash keyups (e.g. the panel-toggle shortcuts pressed
-    // mid-hold). A guarded keydown never sets the flag, so this stays a no-op
-    // for keyups without a matching hold.
-    if (e.code === "Backslash" && keyboardPeekHeld) {
-        keyboardPeekHeld = false;
-        setOriginalPreviewActive(false);
-    }
-}
-function onRendererKeyboardShortcut(message, identity) {
-    if (!isKeyboardShortcutMessage(message, identity))
-        return;
-    if (message.code === "KeyS" && message.phase === "keydown") {
-        window.dispatchEvent(new Event(SEND_PROMPT_HOTKEY_EVENT));
-        return;
-    }
-    if (message.code !== "Backslash")
-        return;
-    if (message.phase === "keydown") {
-        keyboardPeekHeld = true;
-        setOriginalPreviewActive(true);
-    }
-    else if (keyboardPeekHeld) {
-        keyboardPeekHeld = false;
-        setOriginalPreviewActive(false);
-    }
-}
-function disposeInspectorSession() {
-    const session = inspectorSession;
-    inspectorSession = null;
-    session?.dispose();
-}
-export function bootstrapNudgeUi(inspectorHost) {
-    const runtimeConfig = getNudgeUiRuntimeConfig();
-    const explicitDemo = isDemoRuntime();
-    if (!isNudgeUiDev() && !explicitDemo)
-        return;
-    if (explicitDemo) {
-        rendererBootstrapHandle?.teardown();
-        rendererBootstrapHandle = null;
-        // ADR-0014: only the configured demo runtime opens the shared dev gate
-        // for its own document. The bundle mode name alone must never flip it,
-        // so every build without both opt-ins stays governed by ADR-0002.
-        setNudgeUiHostDevFlag(true);
-        if (runtimeConfig.capabilities.canvas && isCanvasRenderer()) {
-            rendererBootstrapHandle = bootstrapRenderer() ?? null;
-            return;
-        }
-        // The public demo shares the iframe editor while keeping the write lease,
-        // persistence, and agent bridge disabled.
-        setCanvasMode("canvas");
-        workspaceController?.dispose();
-        workspaceController = startWorkspaceController();
-        mountInspector(inspectorHost);
-        setInspectorOpen(false);
-        return;
-    }
-    if (!runtimeConfig.capabilities.canvas) {
-        // A project can be reopened with a runtime that does not expose Canvas.
-        // Clear any stale in-memory mode before mounting the static inspector.
-        setCanvasMode("inspect");
-    }
-    rendererBootstrapHandle?.teardown();
-    rendererBootstrapHandle = null;
-    removeInspectionBridge?.();
-    removeInspectionBridge = installInspectionBridge();
-    if (getNudgeUiRuntimeConfig().capabilities.canvas && isCanvasRenderer()) {
-        rendererBootstrapHandle = bootstrapRenderer() ?? null;
-        return;
-    }
-    enableWriteGuard();
-    const leaseGranted = acquireLease();
-    if (!leaseGranted) {
-        mountLockedNotice(inspectorHost);
-        return;
-    }
-    startController(inspectorHost);
-}
-function startController(inspectorHost) {
-    if (!hasWriteLease()) {
-        mountLockedNotice(inspectorHost);
-        return;
-    }
-    if (lockedRoot) {
-        lockedRoot.unmount();
-        lockedRoot = null;
-    }
-    void initializeSketchStore(getNudgeUiRuntimeConfig().projectId).catch(() => undefined);
-    unsubscribeOwnership?.();
-    unsubscribeOwnership = subscribeOwnership((hasLease) => {
-        if (!hasLease) {
-            workspaceController?.dispose();
-            workspaceController = null;
-            mountLockedNotice(inspectorHost);
-        }
-    });
-    workspaceController?.dispose();
-    const result = startWorkspaceController();
-    workspaceController = result;
-    if (result.restored) {
-        setRestoreCount(getChangesList().length + getStructuralChanges().length);
-        const restored = getChangesList();
-        if (restored.length > 0) {
-            startStaleDetection(restored);
-        }
-    }
-    if (getNudgeUiRuntimeConfig().capabilities.canvas) {
-        // Normal controllers always host the iframe workspace. Hydration runs
-        // first so this mode change cannot discard cards, camera, or edits.
-        setCanvasMode("canvas");
-    }
-    mountInspector(inspectorHost);
-}
-function mountLockedNotice(host) {
-    if (reactRoot) {
-        reactRoot.unmount();
-        reactRoot = null;
-    }
-    try {
-        disposeInspectorSession();
-    }
-    finally {
-        cancelStaleDetection();
-        setInspectorOpen(false);
-        cancelInlineTextEdit();
-        cancelSketchInteraction();
-        clearSketchClipboardHandoff();
-        setSelectedElement(null);
-        removeManagedSheet();
-        releaseDocumentProjection(document);
-        hostElement = null;
-        unsubscribeOwnership?.();
-        unsubscribeOwnership = null;
-    }
-    const shadow = host.shadowRoot ?? host.attachShadow({ mode: "open" });
-    if (!lockedRoot) {
-        lockedRoot = createRoot(shadow);
-    }
-    lockedRoot.render(createElement(LockedWorkspaceNotice, {
-        onTakeover: () => startController(host),
-    }));
-}
-export function mountInspector(host) {
-    const demo = isDemoRuntime();
-    if (!demo && !hasWriteLease())
-        return;
-    const runtimeConfig = getNudgeUiRuntimeConfig();
-    if (runtimeConfig.capabilities.domNavigation !== true) {
-        configureNudgeUiRuntime({
-            ...runtimeConfig,
-            capabilities: { ...runtimeConfig.capabilities, domNavigation: true },
-        });
-    }
-    if (lockedRoot) {
-        lockedRoot.unmount();
-        lockedRoot = null;
-    }
-    if (!hostElement)
-        hostElement = host;
-    const shadow = host.shadowRoot ?? host.attachShadow({ mode: "open" });
-    if (!reactRoot) {
-        reactRoot = createRoot(shadow);
-        inspectorSession = workspace.createInspectorSession(host);
-        inspectorSession.registerCleanup(() => window.removeEventListener("keydown", onKeydown));
-        inspectorSession.registerCleanup(() => window.removeEventListener("keyup", onKeyup));
-        inspectorSession.registerCleanup(subscribeCanvasRendererMessages(({ identity, message }) => {
-            onRendererKeyboardShortcut(message, identity);
-        }));
-        reactRoot.render(createElement(InspectorSessionProvider, { inspector: inspectorSession, documentSession: null }, createElement(AppShell)));
-        window.addEventListener("keydown", onKeydown);
-        window.addEventListener("keyup", onKeyup);
-    }
-    setInspectorOpen(true);
-}
-export function unmountInspector() {
-    rendererBootstrapHandle?.teardown();
-    rendererBootstrapHandle = null;
-    workspaceController?.dispose();
-    workspaceController = null;
-    unsubscribeOwnership?.();
-    unsubscribeOwnership = null;
-    if (lockedRoot) {
-        lockedRoot.unmount();
-        lockedRoot = null;
-    }
-    cancelStaleDetection();
-    cancelInlineTextEdit();
-    cancelSketchInteraction();
-    setSelectedElement(null);
-    if (reactRoot) {
-        reactRoot.unmount();
-        reactRoot = null;
-    }
-    try {
-        disposeInspectorSession();
-    }
-    finally {
-        // Document-session cleanup already releases host projection when a
-        // session exists; release directly as well so projection applied outside
-        // a session (gestures, workspace projection) cannot leak across unmount.
-        releaseDocumentProjection(document);
-        clearClipboardHandoff();
-        clearSketchClipboardHandoff();
-        removeManagedSheet();
-        removeInspectionBridge?.();
-        removeInspectionBridge = null;
-        hostElement = null;
-    }
-}
-export { toggleInspector, setInspectorOpen } from "./shell/InspectorShell.js";
+export { toggleInspector, setInspectorOpen } from "./shell/openStore.js";
 export { InspectorShell } from "./shell/InspectorShell.js";
 export { detectFramework } from "./prompt/detectFramework.js";
 export { installStaticHtmlRuntimeIdentity, isRuntimeGeneratedSource, RUNTIME_ELEMENT_CID_PREFIX, RUNTIME_UNKNOWN_SOURCE_PREFIX, } from "./runtime/staticHtmlRuntimeIdentity.js";

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

@@ -1,6 +1,6 @@
 import { type TextBindingChoice, type TextEditBinding, type TextEditRejection, type TextEditRejectionReason } from "../componentSemantics/textBinding.js";
 import type { ChangeRecord } from "../changes/types.js";
-import type { TextProjectionScope } from "./textChangeBoundary.js";
+import type { TextProjectionScope } from "../changes/editModel.js";
 export type { TextEditBinding, TextEditRejection } from "../componentSemantics/textBinding.js";
 export type { TextBindingCandidate } from "../componentSemantics/textBinding.js";
 export interface InlineTextSession {

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

@@ -1,6 +1,5 @@
-import { canEditDraft } from "../changes/draftChanges.js";
+import { appendChange, canEditDraft } from "../drafts/store.js";
 import { useSyncExternalStore } from "react";
-import { appendChange } from "../changes/changesLog.js";
 import { registerInlineTextClearHandler } from "./inlineTextLifecycle.js";
 import { isNudgeUiDev } from "../runtime/devFlag.js";
 import { initialTextEditDecision, chooseTextEditBinding, getTextEditScopeChoices, getTextEditBinding, prepareTextEditChange, } from "./textEditChange.js";

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

@@ -1,6 +1,6 @@
 import type { TextBindingCandidate, TextEditBinding } from "../componentSemantics/textBinding.js";
 import type { ChangeRecord } from "../changes/types.js";
-import type { TextProjectionScope, TextProjectionTarget } from "./textChangeBoundary.js";
+import type { TextProjectionScope, TextProjectionTarget } from "../changes/editModel.js";
 /** Binding and scope decisions, independent of native editor lifecycle state. */
 export interface TextEditDecision {
     bindingIndex: number | null;

package/dist/inspector/inspection/bridge.d.ts

@@ -1,5 +1,5 @@
 import type { TokenDefinition, TokenEntry } from "../../css/model/index.js";
-import { getChangesList, getPendingRules } from "../changes/changesLog.js";
+import { getChangesList, getPendingRules } from "../drafts/store.js";
 import type { InspectorProjection } from "../spacing/projection.js";
 import type { ResolvedProperty } from "../../css/model/index.js";
 export declare const NUDGE_UI_INSPECTION_VERSION: 1;

package/dist/inspector/inspection/bridge.js

@@ -1,4 +1,5 @@
-import { getChangesList, getPendingRules, isPreviewableChange } from "../changes/changesLog.js";
+import { getChangesList, getPendingRules } from "../drafts/store.js";
+import { isPreviewableChange } from "../changes/types.js";
 import { changeKey } from "../changes/model.js";
 import { getAnyPreviewDiagnostic } from "../changes/previewDiagnostics.js";
 import { detectFramework } from "../prompt/detectFramework.js";