nudge-ui 0.2.3 → 0.2.5

package/dist/inspector/projection/structuralProjection.js

@@ -1,7 +1,6 @@
-import { getActiveDraftChanges, getDraftChanges } from "../changes/draftChanges.js";
-import { captureRenderedInstance, matchesRenderedInstanceEvidence, resolveRenderedInstance, } from "./renderedInstance.js";
+import { commitStructuralChange, getActiveDraftChanges, getDraftChanges, revertStructuralChange as revertDraftStructuralChange, subscribeActiveDraftChanges, } from "../drafts/store.js";
+import { captureRenderedInstance, captureStructuralTarget, matchesRenderedInstanceEvidence, resolveRenderedInstance, } from "./renderedInstance.js";
 import { isStructuralProjectionReport } from "./structuralProjectionBoundary.js";
-import { resetDraftChanges, draftChangeStore, } from "../changes/draftChanges.js";
 export { isStructuralChange, isStructuralDelete, isStructuralMove, isStructuralProjectionReport, } from "./structuralProjectionBoundary.js";
 const VOID_PARENT_TAGS = new Set([
     "area", "base", "br", "col", "embed", "hr", "img", "input", "link", "meta", "param", "source", "track", "wbr",
@@ -177,12 +176,15 @@ function cloneSnapshot(snapshot) {
     // array is enough: no operation mutates a change or its nested references.
     return [...snapshot];
 }
-function projectStructuralChanges(snapshot) {
-    reprojectKnownDocuments(snapshot.structuralChanges);
+/** The Draft store already re-projected the host; this covers every other known document. */
+function projectStructuralChanges() {
+    const changes = getStructuralChanges();
+    for (const doc of documentStates.keys())
+        applyStructuralProjection(doc, changes);
 }
 /** Captures a delete intent once, in the controller, at the user gesture. */
 export function createStructuralDelete(element, id = structuralId()) {
-    const target = captureRenderedInstance(element);
+    const target = captureStructuralTarget(element);
     if (!target)
         return null;
     const route = documentRoute(element.ownerDocument);
@@ -194,9 +196,9 @@ export function createStructuralDelete(element, id = structuralId()) {
         ...(route ? { route } : {}),
         ...(state ? { state } : {}),
     };
-    if (!draftChangeStore.commitStructuralChange(change))
+    if (!commitStructuralChange(change))
         return null;
-    projectStructuralChanges(draftChangeStore.getSnapshot());
+    projectStructuralChanges();
     return change;
 }
 /**
@@ -237,51 +239,27 @@ export function createStructuralMove(element, destination, id = structuralId())
                 : destinationChildren.length - (sameParent ? 1 : 0),
         },
     };
-    if (!draftChangeStore.commitStructuralChange(change))
+    if (!commitStructuralChange(change))
         return null;
-    projectStructuralChanges(draftChangeStore.getSnapshot());
+    projectStructuralChanges();
     return change;
 }
 export function getStructuralChanges() {
-    return draftChangeStore.getSnapshot().structuralChanges;
+    return getActiveDraftChanges().structuralChanges;
 }
 export function getStructuralDeletes() {
     return getStructuralChanges().filter((change) => change.kind === "delete");
 }
 /** Revert removes one canonical intent and leaves every other intent intact. */
 export function revertStructuralChange(changeId) {
-    const changed = draftChangeStore.revertStructuralChangeRecord(changeId);
+    const changed = revertDraftStructuralChange(changeId);
     if (changed)
-        projectStructuralChanges(draftChangeStore.getSnapshot());
+        projectStructuralChanges();
     return changed;
 }
-/**
- * Removes source-verified structural intents without leaving an undo path that
- * can recreate their browser-only previews.
- *
- * Agent completion can verify a subset of one dispatched snapshot. The
- * remaining records and their useful history stay intact while every verified
- * ID is pruned from canonical state, undo/redo snapshots, and Canvas reports.
- */
-export function reconcileVerifiedStructuralChanges(verifiedIds) {
-    if (verifiedIds.size === 0)
-        return 0;
-    const removed = draftChangeStore.reconcileActiveDraftChanges(new Set(), verifiedIds);
-    if (removed === 0)
-        return 0;
-    projectStructuralChanges(draftChangeStore.getSnapshot());
-    for (const [cardId, canvasReports] of reportsByCanvasCard) {
-        reportsByCanvasCard.set(cardId, {
-            ...canvasReports,
-            reports: canvasReports.reports.filter((report) => !verifiedIds.has(report.changeId)),
-        });
-    }
-    notifyDiagnostics();
-    return removed;
-}
 /** State changes drive controller-to-renderer projection. Diagnostics do not. */
 export function subscribeStructuralChanges(listener) {
-    return draftChangeStore.subscribe(listener);
+    return subscribeActiveDraftChanges(listener);
 }
 /** Compatibility name retained while the controller moved to a full union. */
 export const subscribeStructuralDeletes = subscribeStructuralChanges;
@@ -503,13 +481,6 @@ function validationStatus(local) {
         ? "applied"
         : "overridden";
 }
-/** Rebuild already-mounted document adapters from canonical data only. */
-function reprojectKnownDocuments(changes = getStructuralChanges()) {
-    for (const [doc, state] of documentStates) {
-        rebuildForSnapshot(doc, state, changes);
-        storeReports(doc, reportsForSnapshot(state, state.snapshot));
-    }
-}
 function validateAppliedPreview(doc, state) {
     let changed = false;
     for (const local of state.applied.values()) {
@@ -619,7 +590,6 @@ export function resetStructuralDeleteProjection() {
     reportsByCanvasCard.clear();
     nextStructuralId = 1;
     diagnosticRevision = 0;
-    resetDraftChanges();
     notifyDiagnostics();
 }
 /**

package/dist/inspector/projection/textProjection.d.ts

@@ -1,8 +1,8 @@
 import type { FrameProjection } from "../canvas/projection.js";
-import { isTextProjectionTargetValue, type TextContentChangeRecord, type TextProjectionTarget, type TextProjectionScope, type TextBindingEvidence } from "../inline-text/textChangeBoundary.js";
+import { isTextProjectionTargetValue, type TextContentChangeRecord, type TextProjectionTarget, type TextProjectionScope, type TextBindingEvidence } from "../changes/editModel.js";
 /** Strict JSON boundary guard for a text projection target. */
 export declare const isTextProjectionTarget: typeof isTextProjectionTargetValue;
-export type { TextProjectionTarget } from "../inline-text/textChangeBoundary.js";
+export type { TextProjectionTarget } from "../changes/editModel.js";
 export type TextProjectionStatus = "applied" | "missing" | "ambiguous" | "overridden";
 export interface TextProjectionReport {
     changeId: string;
@@ -30,6 +30,12 @@ export type TextProjectionResolution = {
 /** Find the exact text node represented by a target, tolerating a changed
  * child path only when one bounded before/after text node remains unique. */
 export declare function resolveTextProjectionTextNode(element: HTMLElement, target: Pick<TextProjectionTarget, "textNodePath"> & Partial<Pick<TextProjectionTarget, "beforeText">>, expectedText?: string | undefined): Text | null;
+/** Whether an element's text is code, form state, or other non-prose content. */
+export declare function isUnsafeTextHost(element: Element): boolean;
+/** Whether an application-owned editing region contains the element. */
+export declare function isInApplicationEditingHost(element: Element): boolean;
+/** Whether replacing one text node inside the element keeps its authored markup. */
+export declare function hasSafeMixedDescendants(element: HTMLElement): boolean;
 /** Capture stable source/evidence identity without retaining a DOM reference. */
 export declare function captureTextProjectionTarget(element: HTMLElement, beforeText?: string, selectedTextNode?: Text): TextProjectionTarget | null;
 /**

package/dist/inspector/projection/textProjection.js

@@ -1,7 +1,8 @@
-import { getActiveDraftChanges, getDraftChanges } from "../changes/draftChanges.js";
+import { boundRuntimeEvidence, normalizeRuntimeTag, runtimeDomPath } from "../runtime/staticHtmlRuntimeIdentity.js";
+import { getActiveDraftChanges, getDraftChanges } from "../drafts/store.js";
 import { sourceSiteSelector } from "../selection/sourceSite.js";
 import { isNudgeUiDev } from "../runtime/devFlag.js";
-import { isTextContentChangeValue, isTextProjectionTargetValue, } from "../inline-text/textChangeBoundary.js";
+import { isTextContentChangeValue, isTextProjectionTargetValue, } from "../changes/editModel.js";
 import { isInteractionStylesInstalled } from "../overlay/interactionStyles.js";
 /** Strict JSON boundary guard for a text projection target. */
 export const isTextProjectionTarget = isTextProjectionTargetValue;
@@ -49,6 +50,39 @@ function isEmptyTextAffordance(node) {
 function hasInlineTextEditor(element) {
     return element.querySelector('[data-inline-editor="true"]') !== null;
 }
+/**
+ * What the application last rendered into each projected Text node. A source
+ * update can render the projected value itself, so restoring `before` would
+ * overwrite real application output that the framework will not repaint.
+ */
+let applicationText = new WeakMap();
+function isInlineEditorNode(node) {
+    return node.nodeType === 1 && (node.matches('[data-inline-editor="true"]')
+        || hasInlineTextEditor(node));
+}
+function recordApplicationWrites(records) {
+    // The inline editor swaps its wrapper back for the original node, writing
+    // the draft, in one task. That write belongs to the editor.
+    if (records.some((record) => record.type === "childList"
+        && [...record.addedNodes, ...record.removedNodes].some(isInlineEditorNode)))
+        return;
+    for (const record of records) {
+        if (record.type !== "characterData" || !isTextNode(record.target))
+            continue;
+        if (applicationText.has(record.target))
+            applicationText.set(record.target, record.target.nodeValue ?? "");
+    }
+}
+/** Writes projection-owned text without mistaking it for an application render. */
+function writeProjectedText(state, node, value) {
+    const pending = state.observer?.takeRecords() ?? [];
+    if (pending.length > 0) {
+        recordApplicationWrites(pending);
+        scheduleValidation(state.doc, state);
+    }
+    node.nodeValue = value;
+    state.observer?.takeRecords();
+}
 function readProjectionMarkers(element) {
     const raw = element.getAttribute(TEXT_PROJECTION_ATTR);
     if (!raw)
@@ -157,28 +191,32 @@ export function resolveTextProjectionTextNode(element, target, expectedText = ta
     }
     return matches.length === 1 ? matches[0] : null;
 }
-function hasSafeMixedDescendants(element) {
+/** Whether an element's text is code, form state, or other non-prose content. */
+export function isUnsafeTextHost(element) {
+    return UNSAFE_TEXT_TAGS.has(element.tagName);
+}
+/** Whether an application-owned editing region contains the element. */
+export function isInApplicationEditingHost(element) {
+    const editingHost = element.closest("[contenteditable]");
+    return Boolean(editingHost
+        && editingHost.getAttribute("data-inline-editor") !== "true"
+        && editingHost.getAttribute("contenteditable") !== "false");
+}
+/** Whether replacing one text node inside the element keeps its authored markup. */
+export function hasSafeMixedDescendants(element) {
     // <br> only controls line layout. The projection targets one exact text
     // node, so keeping the break while changing that node is safe; formatting
     // descendants below still reject a flattening text projection.
     for (const descendant of Array.from(element.querySelectorAll("*"))) {
         if (UNSAFE_MIXED_DESCENDANT_TAGS.has(descendant.tagName))
             return false;
-        const editingHost = descendant.closest("[contenteditable]");
-        if (editingHost
-            && editingHost.getAttribute("data-inline-editor") !== "true"
-            && editingHost.getAttribute("contenteditable") !== "false")
+        if (isInApplicationEditingHost(descendant))
             return false;
     }
     return true;
 }
 function textHostIsSafe(element, allowEmpty = false, target) {
-    if (UNSAFE_TEXT_TAGS.has(element.tagName))
-        return false;
-    const editingHost = element.closest("[contenteditable]");
-    if (editingHost
-        && editingHost.getAttribute("data-inline-editor") !== "true"
-        && editingHost.getAttribute("contenteditable") !== "false")
+    if (isUnsafeTextHost(element) || isInApplicationEditingHost(element))
         return false;
     if (allowEmpty && element.childNodes.length === 0)
         return true;
@@ -262,6 +300,9 @@ export function captureTextProjectionTarget(element, beforeText = element.textCo
         props: element.getAttribute("data-cprops"),
         ariaLabel: element.getAttribute("aria-label"),
         beforeText,
+        tagName: normalizeRuntimeTag(element.tagName),
+        elementId: boundRuntimeEvidence(element.id || null),
+        domPath: runtimeDomPath(element),
         ...pathTarget,
     };
 }
@@ -411,7 +452,7 @@ function textProjectionIdentityMatches(element, change) {
         && element.getAttribute("data-cprops") === change.target.props
         && element.getAttribute("aria-label") === change.target.ariaLabel;
 }
-function restoreAppliedProjection(applied) {
+function restoreAppliedProjection(state, applied) {
     const element = applied.element;
     if (!element || !element.isConnected)
         return;
@@ -426,7 +467,9 @@ function restoreAppliedProjection(applied) {
     if (!textHostIsSafe(element, applied.change.after.length === 0, applied.change.target))
         return;
     if (textNode) {
-        textNode.nodeValue = applied.change.before;
+        const rendered = applicationText.get(textNode);
+        applicationText.delete(textNode);
+        writeProjectedText(state, textNode, rendered ?? applied.change.before);
     }
     else if (applied.change.target.textNodePath === undefined
         && applied.change.after.length === 0
@@ -467,7 +510,7 @@ function validationStatus(applied) {
  * mutates; an overridden projection remains authoritative and is never
  * re-applied.
  */
-function resolvePendingProjection(doc, applied) {
+function resolvePendingProjection(doc, state, applied) {
     if (applied.status !== "missing" && applied.status !== "ambiguous") {
         return validationStatus(applied);
     }
@@ -484,7 +527,9 @@ function resolvePendingProjection(doc, applied) {
         element.textContent = applied.change.after;
     }
     else {
-        textNode.nodeValue = applied.change.after;
+        if (!applicationText.has(textNode))
+            applicationText.set(textNode, textNode.nodeValue ?? "");
+        writeProjectedText(state, textNode, applied.change.after);
     }
     applied.element = element;
     return "applied";
@@ -492,7 +537,7 @@ function resolvePendingProjection(doc, applied) {
 function validateAppliedProjection(doc, state) {
     let changed = false;
     for (const applied of state.applied.values()) {
-        const status = resolvePendingProjection(doc, applied);
+        const status = resolvePendingProjection(doc, state, applied);
         if (status !== applied.status) {
             applied.status = status;
             changed = true;
@@ -516,6 +561,7 @@ function getDocumentState(doc) {
     if (existing)
         return existing;
     const state = {
+        doc,
         applied: new Map(),
         emptyAffordances: new Map(),
         snapshotKey: null,
@@ -524,7 +570,10 @@ function getDocumentState(doc) {
     };
     const Observer = doc.defaultView?.MutationObserver;
     if (Observer && doc.documentElement) {
-        state.observer = new Observer(() => scheduleValidation(doc, state));
+        state.observer = new Observer((records) => {
+            recordApplicationWrites(records);
+            scheduleValidation(doc, state);
+        });
         state.observer.observe(doc.documentElement, {
             childList: true,
             subtree: true,
@@ -571,7 +620,7 @@ export function applyTextContentProjection(doc, changes) {
         if (incomingIds.has(id))
             continue;
         removeEmptyTextAffordance(state, id);
-        restoreAppliedProjection(applied);
+        restoreAppliedProjection(state, applied);
         if (applied.element)
             removeProjectionMarker(applied.element, applied.change.target, id);
     }
@@ -579,13 +628,13 @@ export function applyTextContentProjection(doc, changes) {
     for (const change of changes) {
         const existing = previous.get(change.id);
         if (existing && JSON.stringify(existing.change) === JSON.stringify(change)) {
-            existing.status = resolvePendingProjection(doc, existing);
+            existing.status = resolvePendingProjection(doc, state, existing);
             next.set(change.id, existing);
             continue;
         }
         if (existing) {
             removeEmptyTextAffordance(state, change.id);
-            restoreAppliedProjection(existing);
+            restoreAppliedProjection(state, existing);
             if (existing.element)
                 removeProjectionMarker(existing.element, existing.change.target, change.id);
         }
@@ -603,8 +652,11 @@ export function applyTextContentProjection(doc, changes) {
             next.set(change.id, { change, element: null, status: "missing" });
             continue;
         }
-        if (textNode)
-            textNode.nodeValue = change.after;
+        if (textNode) {
+            if (!applicationText.has(textNode))
+                applicationText.set(textNode, textNode.nodeValue ?? "");
+            writeProjectedText(state, textNode, change.after);
+        }
         else
             element.textContent = change.after;
         next.set(change.id, { change, element, status: "applied" });
@@ -708,6 +760,7 @@ export function resetTextProjectionState() {
         }
     }
     documentStates = new Map();
+    applicationText = new WeakMap();
     canonicalChanges = new Map();
     reportsByDocument = new WeakMap();
     reportsByCanvasCard.clear();

package/dist/inspector/prompt/clipboardHandoff.d.ts

@@ -21,6 +21,20 @@ export declare function clearClipboardHandoff(): void;
 export declare function subscribeClipboardHandoff(listener: () => void): () => void;
 export declare function getClipboardHandoffRevision(): number;
 export declare function getLastClipboardReconciledCount(): number;
+/** Records in one draft that still equal its copied, unverified snapshot. */
+export declare function getClipboardHandoffRecords(draftId: string): {
+    changes: ChangeRecord[];
+    structuralChanges: StructuralChange[];
+};
 export declare function reconcileClipboardHandoff(doc?: Document): Promise<number>;
+/**
+ * Verifies copied edits after the document changes. Each check briefly removes
+ * the copied preview, so a check that reconciles nothing doubles the minimum
+ * interval before the next one: a page that mutates continuously (clocks,
+ * carousels) would otherwise flash the preview every few hundred milliseconds.
+ * Later changes never postpone a pending check, so a busy page is still
+ * checked once per interval. Returning to the page or copying a new prompt
+ * resets the interval.
+ */
 export declare function startClipboardHandoffController(doc?: Document): () => void;
 export {};

package/dist/inspector/prompt/clipboardHandoff.js

@@ -1,5 +1,5 @@
 import { changeKey } from "../changes/model.js";
-import { getDraftChanges, getActiveDraftChanges, subscribeActiveDraftChanges } from "../changes/draftChanges.js";
+import { getDraftChanges, getActiveDraftChanges, subscribeActiveDraftChanges } from "../drafts/store.js";
 import { documentRevisions, subscribeDocumentRevision } from "../tokens/resolution/cssomCollector.js";
 import { captureHandoffOwner, handoffChangeFingerprint, handoffStructuralFingerprint, verifyAndReconcileHandoff, } from "../agent/verification.js";
 import { isDraftTarget } from "../drafts/model.js";
@@ -87,6 +87,11 @@ function matchingRecords(snapshot) {
         structuralChanges: workspace.structuralChanges.filter((change) => structures.get(change.id) === handoffStructuralFingerprint(change)),
     };
 }
+/** Records in one draft that still equal its copied, unverified snapshot. */
+export function getClipboardHandoffRecords(draftId) {
+    const snapshot = checkpoints.get(draftId);
+    return snapshot ? matchingRecords(snapshot) : { changes: [], structuralChanges: [] };
+}
 function pruneCheckpoints() {
     let changed = false;
     for (const [id, snapshot] of checkpoints) {
@@ -119,33 +124,58 @@ export async function reconcileClipboardHandoff(doc = document) {
     }
     return removed;
 }
+const CHECK_DELAY_MS = 450;
+const MAX_CHECK_DELAY_MS = 8_000;
+/**
+ * Verifies copied edits after the document changes. Each check briefly removes
+ * the copied preview, so a check that reconciles nothing doubles the minimum
+ * interval before the next one: a page that mutates continuously (clocks,
+ * carousels) would otherwise flash the preview every few hundred milliseconds.
+ * Later changes never postpone a pending check, so a busy page is still
+ * checked once per interval. Returning to the page or copying a new prompt
+ * resets the interval.
+ */
 export function startClipboardHandoffController(doc = document) {
     const view = doc.defaultView;
     let timer = null;
     let checking = false;
     let stopped = false;
-    const schedule = () => {
+    let interval = CHECK_DELAY_MS;
+    let lastCheckEndedAt = -Infinity;
+    const run = () => {
+        timer = null;
         if (stopped || checking || !checkpoints.size)
             return;
+        checking = true;
+        void reconcileClipboardHandoff(doc).then((removed) => {
+            interval = removed > 0 ? CHECK_DELAY_MS : Math.min(interval * 2, MAX_CHECK_DELAY_MS);
+        }, () => undefined).finally(() => {
+            lastCheckEndedAt = Date.now();
+            setTimeout(() => { checking = false; }, 0);
+        });
+    };
+    const schedule = () => {
+        if (stopped || checking || !checkpoints.size || timer !== null)
+            return;
+        // Let the change that triggered this settle, and keep the backoff interval.
+        timer = setTimeout(run, Math.max(CHECK_DELAY_MS, lastCheckEndedAt + interval - Date.now()));
+    };
+    const returned = () => {
+        interval = CHECK_DELAY_MS;
+        lastCheckEndedAt = -Infinity;
         if (timer !== null)
             clearTimeout(timer);
-        timer = setTimeout(() => {
-            timer = null;
-            if (stopped || checking || !checkpoints.size)
-                return;
-            checking = true;
-            void reconcileClipboardHandoff(doc).catch(() => undefined).finally(() => {
-                setTimeout(() => { checking = false; }, 0);
-            });
-        }, 450);
+        timer = null;
+        schedule();
     };
     const visible = () => { if (doc.visibilityState === "visible")
-        schedule(); };
+        returned(); };
     documentRevisions(doc);
     const stopRevision = subscribeDocumentRevision(doc, schedule);
     const stopChanges = subscribeActiveDraftChanges(pruneCheckpoints);
-    view?.addEventListener("focus", schedule);
-    view?.addEventListener("pageshow", schedule);
+    const stopHandoff = subscribeClipboardHandoff(() => { interval = CHECK_DELAY_MS; });
+    view?.addEventListener("focus", returned);
+    view?.addEventListener("pageshow", returned);
     doc.addEventListener("visibilitychange", visible);
     schedule();
     return () => {
@@ -154,8 +184,9 @@ export function startClipboardHandoffController(doc = document) {
             clearTimeout(timer);
         stopRevision();
         stopChanges();
-        view?.removeEventListener("focus", schedule);
-        view?.removeEventListener("pageshow", schedule);
+        stopHandoff();
+        view?.removeEventListener("focus", returned);
+        view?.removeEventListener("pageshow", returned);
         doc.removeEventListener("visibilitychange", visible);
     };
 }

package/dist/inspector/prompt/generatePrompt.d.ts

@@ -1,4 +1,4 @@
-import type { ChangeRecord } from "../changes/changesLog.js";
+import type { ChangeRecord } from "../changes/types.js";
 import type { StructuralChange } from "../projection/structuralProjection.js";
 import type { AgentSketchMetadata } from "../agent/protocol.js";
 import { type ElementComment } from "../comments/store.js";