nudge-ui 0.2.0 → 0.2.1

package/dist/inspector/canvas/staleChangeDetector.js

@@ -4,7 +4,7 @@ import { beginPreviewAttempt, clearPreviewDiagnostics, getHostPreviewDocument, n
 import { getWorkspaceChanges } from "../changes/workspaceChanges.js";
 import { getCanvasPreviewDocument, getRegisteredFrames } from "./projection.js";
 import { findCanvasFrameBySource, PROJECT_ID, WORKSPACE_ID } from "./projection.js";
-import { getCanvasCards } from "./canvasStore.js";
+import { getCanvasCards, getCanvasMode } from "./canvasStore.js";
 import { isRendererMessageFor } from "./frameProtocol.js";
 import { getNudgeUiRuntimeConfig } from "../runtime/runtimeConfig.js";
 const VERIFICATION_TIMEOUT_MS = 5000;
@@ -79,7 +79,7 @@ function checkTokenDrift(change) {
     return null;
 }
 function getPreviewDocuments() {
-    const documents = [getHostPreviewDocument()];
+    const documents = getCanvasMode() === "canvas" ? [] : [getHostPreviewDocument()];
     const frames = getRegisteredFrames();
     for (const card of getCanvasCards()) {
         if (frames.has(card.id))
@@ -99,15 +99,17 @@ function beginPreviewAttempts() {
 }
 function gatherMatchEvidence(changes) {
     const evidence = new Map();
-    const hostDocument = getHostPreviewDocument();
-    for (let i = 0; i < changes.length; i++) {
-        const change = changes[i];
-        if (isTokenChange(change))
-            continue;
-        if (checkSelectorInDocument(document, change.selector)) {
-            const routes = evidence.get(i) ?? [];
-            routes.push(hostDocument);
-            evidence.set(i, routes);
+    if (getCanvasMode() !== "canvas") {
+        const hostDocument = getHostPreviewDocument();
+        for (let i = 0; i < changes.length; i++) {
+            const change = changes[i];
+            if (isTokenChange(change))
+                continue;
+            if (checkSelectorInDocument(document, change.selector)) {
+                const routes = evidence.get(i) ?? [];
+                routes.push(hostDocument);
+                evidence.set(i, routes);
+            }
         }
     }
     const frames = getRegisteredFrames();
@@ -131,13 +133,13 @@ function gatherMatchEvidence(changes) {
 }
 function applyStaleResults(changes, attempts) {
     const evidence = gatherMatchEvidence(changes);
-    const hostAttempt = attempts.get(getHostPreviewDocument().logicalDocument);
+    const tokenAttempt = attempts.values().next().value;
     for (let i = 0; i < changes.length; i++) {
         const change = changes[i];
         if (isTokenChange(change)) {
             const drift = checkTokenDrift(change);
-            if (drift && hostAttempt)
-                publishPreviewDiagnostic(hostAttempt, changeKey(change), drift);
+            if (drift && tokenAttempt)
+                publishPreviewDiagnostic(tokenAttempt, changeKey(change), drift);
             continue;
         }
         const routes = evidence.get(i);

package/dist/inspector/changes/changesLog.js

@@ -8,6 +8,8 @@ import { workspaceChangeStore, } from "./workspaceChanges.js";
 import { beginPreviewAttempt, clearPreviewDiagnostics, getHostPreviewDocument, publishPreviewDiagnostic, } from "./previewDiagnostics.js";
 import { clearStructuralProjectionReports, pruneStructuralProjectionReports } from "../projection/structuralProjection.js";
 import { applyHostWorkspaceProjection, compileWorkspaceProjection, } from "../projection/workspaceProjection.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
@@ -28,14 +30,28 @@ export function getPendingRules() {
     return buildManagedStyleRules(getChangesSnapshot());
 }
 function reapply(workspace) {
-    applyHostWorkspaceProjection(compileWorkspaceProjection(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())
+        applyHostWorkspaceProjection(compileWorkspaceProjection(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(), workspaceChangeStore.getSnapshot().revision);
     if (!attempt)
@@ -93,6 +109,20 @@ function markForVerification(keys, verificationTargets) {
     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 = workspaceChangeStore.commitChangeRecords(incoming);

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

@@ -3,4 +3,4 @@ import { type ChangeRecord, type PreviewableChangeRecord } from "./types.js";
 /** The source selector stays canonical; the projection marker is document-local. */
 export declare function selectorForManagedChange(change: PreviewableChangeRecord): string | null;
 export declare function buildManagedStyleRules(changes: ChangeRecord[]): StyleRule[];
-export declare function verifyManagedStyleProjection(change: PreviewableChangeRecord, selectedElement?: HTMLElement | null): PreviewResult | null;
+export declare function verifyManagedStyleProjection(change: PreviewableChangeRecord, selectedElement?: HTMLElement | null, ownerDocument?: Document): PreviewResult | null;

package/dist/inspector/changes/managedStyleProjection.js

@@ -63,7 +63,7 @@ export function buildManagedStyleRules(changes) {
     // emitted afterwards so their additional marker specificity wins.
     return [...sourceRules.values(), ...instanceRules.values()];
 }
-export function verifyManagedStyleProjection(change, selectedElement) {
+export function verifyManagedStyleProjection(change, selectedElement, ownerDocument = document) {
     // Deferred verification must use the selection that existed when the
     // projection was committed. Reading the live selection here can make a
     // host-document change verify against a later canvas selection (or vice
@@ -75,13 +75,13 @@ export function verifyManagedStyleProjection(change, selectedElement) {
     // A Canvas-only selection belongs to an iframe. The controller stylesheet
     // cannot verify it synchronously; leave its result unknown until the frame
     // has received the canonical projection rather than claiming it is stale.
-    if (selected && selected.ownerDocument !== document) {
+    if (selected && selected.ownerDocument !== ownerDocument) {
         return null;
     }
     let targets = [];
     try {
         const selector = selectorForManagedChange(change);
-        targets = selector ? Array.from(document.querySelectorAll(selector)) : [];
+        targets = selector ? Array.from(ownerDocument.querySelectorAll(selector)) : [];
     }
     catch {
         targets = [];

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

@@ -4,6 +4,10 @@ export interface StructuralDelete {
     id: string;
     kind: "delete";
     target: RenderedInstanceRef;
+    /** Hash-independent route where the target was captured. */
+    route?: string;
+    /** Bounded view identity where the target was captured. */
+    state?: string;
 }
 /** Controller-owned intent to move one rendered instance. */
 export interface StructuralMove {

package/dist/inspector/clientManifest.d.ts

@@ -8,6 +8,11 @@ export interface NudgeUiClientManifest {
     readonly version: typeof NUDGE_UI_CLIENT_MANIFEST_VERSION;
     readonly revision: number;
     readonly runtime: NudgeUiRuntimeConfig;
+    /** Project-owned, loopback-only agent bridge started by the dev host. */
+    readonly agentBridge?: {
+        readonly baseUrl: string;
+        readonly autoConnect?: boolean;
+    };
     /** Optional document preparation requested by the host Adapter. */
     readonly document?: {
         readonly runtimeIdentity?: "static-html";

package/dist/inspector/clientManifest.js

@@ -20,6 +20,7 @@ value) {
             version: NUDGE_UI_CLIENT_MANIFEST_VERSION,
             revision: value.revision,
             runtime: normalizeNudgeUiRuntimeConfig(value.runtime),
+            ...(isAgentBridge(value.agentBridge) ? { agentBridge: value.agentBridge } : {}),
             ...(value.document === undefined ? {} : { document: value.document }),
             ...(value.reload === undefined ? {} : { reload: value.reload }),
         };
@@ -28,6 +29,16 @@ value) {
         return null;
     }
 }
+function isAgentBridge(value) {
+    if (value === undefined)
+        return false;
+    if (!isRecord(value))
+        return false;
+    const candidate = value;
+    if (typeof candidate.baseUrl !== "string" || candidate.baseUrl.length === 0)
+        return false;
+    return candidate.autoConnect === undefined || typeof candidate.autoConnect === "boolean";
+}
 function isDocumentOptions(
 // Optional manifest capability is parsed before use.
 // oxlint-disable-next-line anti-slop/no-unknown-parameters

package/dist/inspector/componentSemantics/adapterRegistry.js

@@ -1,10 +1,10 @@
 import { getNudgeUiRuntimeConfig } from "../runtime/runtimeConfig.js";
 import { copyComponentOverrides, copyRuntimeTarget, getHostRuntimeAdapters, registerHostRuntimeAdapter, replaceHostRuntimeAdapterOverrides, } from "./runtimeBridge.js";
 const diagnosedAdapters = new WeakSet();
-function enabledRuntimeAdapters() {
+function enabledRuntimeAdapters(ownerGlobal) {
     if (!getNudgeUiRuntimeConfig().capabilities.componentSemantics)
         return [];
-    return [...getHostRuntimeAdapters()];
+    return [...getHostRuntimeAdapters(ownerGlobal)];
 }
 /** Register a framework adapter without coupling semantic resolution to React. */
 export function registerComponentRuntimeAdapter(adapter) {
@@ -12,7 +12,8 @@ export function registerComponentRuntimeAdapter(adapter) {
 }
 export function inspectComponentTargets(element) {
     const targets = [];
-    for (const adapter of enabledRuntimeAdapters()) {
+    const ownerGlobal = element.ownerDocument.defaultView ?? globalThis;
+    for (const adapter of enabledRuntimeAdapters(ownerGlobal)) {
         let inspected;
         try {
             inspected = adapter.inspect(element);

package/dist/inspector/componentSemantics/runtimeBridge.d.ts

@@ -11,8 +11,8 @@ export declare const NUDGE_UI_HOST_RUNTIME_VERSION = 1;
  * not accumulate stale implementations.
  */
 export declare function registerHostRuntimeAdapter(adapter: ComponentRuntimeAdapter): () => void;
-/** Returns the active host runtime Adapters for this browser realm. */
-export declare function getHostRuntimeAdapters(): readonly ComponentRuntimeAdapter[];
+/** Returns the active host runtime Adapters for the requested browser realm. */
+export declare function getHostRuntimeAdapters(ownerGlobal?: typeof globalThis): readonly ComponentRuntimeAdapter[];
 /** Stores the latest projection and sends it to every registered host Adapter. */
 export declare function replaceHostRuntimeAdapterOverrides(overrides: readonly ComponentOverride[]): void;
 /**

package/dist/inspector/componentSemantics/runtimeBridge.js

@@ -42,9 +42,22 @@ export function registerHostRuntimeAdapter(adapter) {
         }
     };
 }
-/** Returns the active host runtime Adapters for this browser realm. */
-export function getHostRuntimeAdapters() {
-    return [...registry().adapters.values()];
+/** Returns the active host runtime Adapters for the requested browser realm. */
+export function getHostRuntimeAdapters(ownerGlobal = globalThis) {
+    if (ownerGlobal === globalThis)
+        return [...registry().adapters.values()];
+    const current = ownerGlobal[HOST_RUNTIME_KEY];
+    if (current === undefined)
+        return [];
+    const mapConstructor = Reflect.get(ownerGlobal, "Map");
+    if (!mapConstructor
+        || typeof current !== "object"
+        || current === null
+        || current.version !== NUDGE_UI_HOST_RUNTIME_VERSION
+        || !(current.adapters instanceof mapConstructor)) {
+        throw new Error(`Nudge UI host runtime is incompatible with version ${NUDGE_UI_HOST_RUNTIME_VERSION}.`);
+    }
+    return [...(current.adapters.values())];
 }
 /** Stores the latest projection and sends it to every registered host Adapter. */
 export function replaceHostRuntimeAdapterOverrides(overrides) {

package/dist/inspector/index.d.ts

@@ -1,3 +1,4 @@
+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;
@@ -6,6 +7,7 @@ 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";
 export { isCanvasRenderer } from "./canvas/roleDetection.js";
+export { createNudgeUiEditorUrl, hasNudgeUiDirectTabIntent, isNudgeUiDirectUrl, readNudgeUiEditorTarget, rememberNudgeUiDirectTabIntent, } from "../transport/editor.js";
 export { NUDGE_UI_INSPECTION_VERSION, inspectElement, installInspectionBridge } from "./inspection/bridge.js";
 export type { NudgeUiInspectionBridge, ElementInspection, InspectElementOptions, InspectionCatalogEntry, InspectionControl } from "./inspection/bridge.js";
 export { beginInlineTextEdit, cancelInlineTextEdit, disposeInlineTextEdit, getInlineTextDiagnostic, getInlineTextDiagnostics, getInlineTextSession, inlineTextEditor, isInlineTextEditingActive, subscribeInlineTextDiagnostics, resolveTextBinding, useInlineTextSession, } from "./inline-text/inlineTextEditor.js";

package/dist/inspector/index.js

@@ -1,11 +1,12 @@
 import { createElement } from "react";
 import { createRoot } from "react-dom/client";
-import { InspectorShell, toggleInspector, setInspectorOpen, setInspectorHost } from "./shell/InspectorShell.js";
+import { InspectorShell, toggleInspector, setInspectorOpen } from "./shell/InspectorShell.js";
 import { setSelectedElement } from "./selection/selectionStore.js";
 import { removeManagedSheet } from "./projection/managedStylesheet.js";
-import { isInspectorToggleShortcut } from "./shell/shortcuts.js";
-import { clearInspectorLayout } from "./shell/panelLayout.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 { hydrateSession, enableAutoSave, scheduleAutoSave, scheduleCanvasSave, setRestoreCount, } from "./canvas/sessionStore.js";
 import { subscribeChanges, getChangesList } from "./changes/changesLog.js";
@@ -15,14 +16,18 @@ import { cancelStaleDetection, startStaleDetection } from "./canvas/staleChangeD
 import { LockedWorkspaceNotice } from "./canvas/LockedWorkspaceNotice.js";
 import { AppShell } from "./shell/AppShell.js";
 import { installInspectionBridge } from "./inspection/bridge.js";
-import { disposeBrowserCssInspection } from "./inspection/browserCssInspectionRegistry.js";
-import { releaseDocumentProjection } from "./projection/structuralProjection.js";
+import { releaseDocumentProjection, subscribeStructuralChanges } from "./projection/structuralProjection.js";
 import { cancelInlineTextEdit } from "./inline-text/inlineTextEditor.js";
 import { configureNudgeUiRuntime, getNudgeUiRuntimeConfig, isDemoRuntime } from "./runtime/runtimeConfig.js";
 import { setCanvasMode } from "./canvas/canvasStore.js";
 import { isNudgeUiDev, setNudgeUiHostDevFlag } from "./runtime/devFlag.js";
-import { clearClipboardHandoff, startClipboardHandoffController, subscribeClipboardHandoff, } from "./prompt/clipboardHandoff.js";
+import { clearClipboardHandoff, subscribeClipboardHandoff, } 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 { resolveNudgeUiClientEntry } from "../transport/editor.js";
 let hostElement = null;
 let reactRoot = null;
 let lockedRoot = null;
@@ -33,11 +38,47 @@ let beforeUnloadAttached = false;
 let persistenceSubscribed = false;
 let unsubscribeOwnership = null;
 let removeInspectionBridge = null;
-let stopClipboardHandoffController = 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() {
@@ -57,11 +98,15 @@ export function bootstrapNudgeUi(inspectorHost) {
         // 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);
-        // Public demo builds intentionally expose only the static inspector. The
-        // Canvas workspace, write lease, persistence, and agent bridge stay out
-        // of the embedded frame.
-        setCanvasMode("inspect");
+        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");
         mountInspector(inspectorHost);
+        setInspectorOpen(false);
         return;
     }
     if (!runtimeConfig.capabilities.canvas) {
@@ -94,6 +139,7 @@ function startController(inspectorHost) {
         lockedRoot.unmount();
         lockedRoot = null;
     }
+    void initializeSketchStore(getNudgeUiRuntimeConfig().projectId).catch(() => undefined);
     unsubscribeOwnership?.();
     unsubscribeOwnership = subscribeOwnership((hasLease) => {
         if (!hasLease)
@@ -107,9 +153,12 @@ function startController(inspectorHost) {
             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);
-    stopClipboardHandoffController?.();
-    stopClipboardHandoffController = startClipboardHandoffController(document);
     enableAutoSave();
     if (!beforeUnloadAttached) {
         // enableAutoSave registers its flush listener first. Release the lease only
@@ -120,14 +169,13 @@ function startController(inspectorHost) {
     }
     if (!persistenceSubscribed) {
         subscribeChanges(() => scheduleAutoSave());
+        subscribeStructuralChanges(() => scheduleAutoSave());
         subscribeClipboardHandoff(() => scheduleAutoSave());
         subscribeCanvas(() => scheduleCanvasSave());
         persistenceSubscribed = true;
     }
 }
 function mountLockedNotice(host) {
-    stopClipboardHandoffController?.();
-    stopClipboardHandoffController = null;
     if (reactRoot) {
         reactRoot.unmount();
         reactRoot = null;
@@ -139,8 +187,9 @@ function mountLockedNotice(host) {
         cancelStaleDetection();
         setInspectorOpen(false);
         cancelInlineTextEdit();
+        cancelSketchInteraction();
+        clearSketchClipboardHandoff();
         setSelectedElement(null);
-        clearInspectorLayout();
         removeManagedSheet();
         releaseDocumentProjection(document);
         hostElement = null;
@@ -178,21 +227,20 @@ export function mountInspector(host) {
     if (!reactRoot) {
         reactRoot = createRoot(shadow);
         inspectorSession = workspace.createInspectorSession(host);
-        const documentSession = inspectorSession.createDocumentSession(document);
-        documentSession.registerCleanup(() => disposeBrowserCssInspection(document));
-        documentSession.registerCleanup(() => releaseDocumentProjection(document));
         inspectorSession.registerCleanup(() => window.removeEventListener("keydown", onKeydown));
-        setInspectorHost(host);
-        reactRoot.render(createElement(InspectorSessionProvider, { inspector: inspectorSession, documentSession }, createElement(demo ? InspectorShell : AppShell)));
+        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;
-    stopClipboardHandoffController?.();
-    stopClipboardHandoffController = null;
     unsubscribeOwnership?.();
     unsubscribeOwnership = null;
     if (lockedRoot) {
@@ -201,6 +249,7 @@ export function unmountInspector() {
     }
     cancelStaleDetection();
     cancelInlineTextEdit();
+    cancelSketchInteraction();
     setSelectedElement(null);
     if (reactRoot) {
         reactRoot.unmount();
@@ -215,8 +264,8 @@ export function unmountInspector() {
         // a session (gestures, workspace projection) cannot leak across unmount.
         releaseDocumentProjection(document);
         clearClipboardHandoff();
+        clearSketchClipboardHandoff();
         removeManagedSheet();
-        clearInspectorLayout();
         removeInspectionBridge?.();
         removeInspectionBridge = null;
         hostElement = null;
@@ -227,6 +276,7 @@ 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";
 export { isCanvasRenderer } from "./canvas/roleDetection.js";
+export { createNudgeUiEditorUrl, hasNudgeUiDirectTabIntent, isNudgeUiDirectUrl, readNudgeUiEditorTarget, rememberNudgeUiDirectTabIntent, } from "../transport/editor.js";
 export { NUDGE_UI_INSPECTION_VERSION, inspectElement, installInspectionBridge } from "./inspection/bridge.js";
 export { beginInlineTextEdit, cancelInlineTextEdit, disposeInlineTextEdit, getInlineTextDiagnostic, getInlineTextDiagnostics, getInlineTextSession, inlineTextEditor, isInlineTextEditingActive, subscribeInlineTextDiagnostics, resolveTextBinding, useInlineTextSession, } from "./inline-text/inlineTextEditor.js";
 export { projectInspectorValues, projectionSides } from "./spacing/projection.js";

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

@@ -0,0 +1,10 @@
+import type { InlineTextDiagnostic } from "./inlineTextEditor.js";
+export declare function recordInlineTextDiagnostic(diagnostic: InlineTextDiagnostic, ownerDocument?: Document, target?: Element): void;
+export declare function getInlineTextDiagnostics(): readonly InlineTextDiagnostic[];
+export declare function getInlineTextDiagnostic(): InlineTextDiagnostic | null;
+export declare function subscribeInlineTextDiagnostics(listener: () => void): () => void;
+export declare function useInlineTextDiagnostic(): InlineTextDiagnostic | null;
+/** Clear the current diagnostic, optionally only when it belongs to a frame. */
+export declare function clearInlineTextDiagnostics(ownerDocument?: Document): void;
+/** Keep feedback for the target that was just selected, but clear stale feedback. */
+export declare function clearInlineTextDiagnosticsForSelection(selectedElements: readonly HTMLElement[]): void;

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

@@ -0,0 +1,65 @@
+import { useSyncExternalStore } from "react";
+const listeners = new Set();
+let diagnostics = [];
+let revision = 0;
+function notify() {
+    revision += 1;
+    for (const listener of listeners)
+        listener();
+}
+function sameDiagnostic(left, right) {
+    return left.kind === right.kind
+        && left.status === right.status
+        && left.reason === right.reason
+        && left.before === right.before
+        && left.after === right.after;
+}
+export function recordInlineTextDiagnostic(diagnostic, ownerDocument, target) {
+    const resolvedDocument = ownerDocument ?? target?.ownerDocument;
+    const previous = diagnostics.at(-1);
+    if (previous
+        && previous.ownerDocument === resolvedDocument
+        && previous.target === target
+        && sameDiagnostic(previous.diagnostic, diagnostic)) {
+        return;
+    }
+    diagnostics = [
+        ...diagnostics.slice(-31),
+        { diagnostic, ownerDocument: resolvedDocument, target },
+    ];
+    notify();
+}
+export function getInlineTextDiagnostics() {
+    return diagnostics.map(({ diagnostic }) => diagnostic);
+}
+export function getInlineTextDiagnostic() {
+    return diagnostics.at(-1)?.diagnostic ?? null;
+}
+export function subscribeInlineTextDiagnostics(listener) {
+    listeners.add(listener);
+    return () => listeners.delete(listener);
+}
+export function useInlineTextDiagnostic() {
+    useSyncExternalStore(subscribeInlineTextDiagnostics, () => revision, () => revision);
+    return getInlineTextDiagnostic();
+}
+/** Clear the current diagnostic, optionally only when it belongs to a frame. */
+export function clearInlineTextDiagnostics(ownerDocument) {
+    const current = diagnostics.at(-1);
+    if (!current)
+        return;
+    if (ownerDocument && current.ownerDocument !== ownerDocument)
+        return;
+    diagnostics = [];
+    notify();
+}
+/** Keep feedback for the target that was just selected, but clear stale feedback. */
+export function clearInlineTextDiagnosticsForSelection(selectedElements) {
+    const current = diagnostics.at(-1);
+    if (!current)
+        return;
+    const target = current.target;
+    if (target && selectedElements.length === 1 && selectedElements[0] === target)
+        return;
+    clearInlineTextDiagnostics();
+}

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

@@ -1,4 +1,4 @@
-import { type TextBindingChoice, type TextEditBinding, type TextEditRejection } from "../componentSemantics/textBinding.js";
+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";
 export type { TextEditBinding, TextEditRejection } from "../componentSemantics/textBinding.js";
@@ -28,13 +28,11 @@ export type InlineTextInputRejectionReason = "cross-host-range" | "rich-input" |
 export interface InlineTextDiagnostic {
     kind: "inline-text";
     status: "started" | "committed" | "cancelled" | "rejected";
-    reason: InlineTextSessionEndReason | InlineTextInputRejectionReason;
+    reason: InlineTextSessionEndReason | InlineTextInputRejectionReason | TextEditRejectionReason;
     before: string;
     after?: string;
 }
-export declare function getInlineTextDiagnostics(): readonly InlineTextDiagnostic[];
-export declare function getInlineTextDiagnostic(): InlineTextDiagnostic | null;
-export declare function subscribeInlineTextDiagnostics(listener: () => void): () => void;
+export { clearInlineTextDiagnostics, getInlineTextDiagnostic, getInlineTextDiagnostics, subscribeInlineTextDiagnostics, useInlineTextDiagnostic, } from "./inlineTextDiagnostics.js";
 export declare function getInlineTextSession(): InlineTextSession | null;
 export declare function useInlineTextSession(): InlineTextSession | null;
 export declare function isInlineTextEditingActive(): boolean;