nudge-ui 0.2.3 → 0.2.4

package/dist/inspector/comments/element.js

@@ -1,17 +1,24 @@
 import { resolveRenderedInstance } from "../projection/renderedInstance.js";
-import { sourceSiteSelector } from "../selection/sourceSite.js";
+import { relocateSourceSite, sourceSiteSelector } from "../selection/sourceSite.js";
 /** Retains a changed target only when its source site still identifies one output. */
 export function resolveCommentElement(doc, target) {
     const exact = resolveRenderedInstance(doc, target);
     if (exact.status === "resolved")
         return exact.element;
-    const selector = sourceSiteSelector(target.sourceSite.cid, target.sourceSite.src);
+    const { props, ariaLabel } = target.locator;
+    const sourceSite = relocateSourceSite(doc, target.sourceSite, (element) => element.getAttribute("data-cprops") === props && element.getAttribute("aria-label") === (ariaLabel ?? null));
+    if (sourceSite) {
+        const moved = resolveRenderedInstance(doc, { ...target, sourceSite });
+        if (moved.status === "resolved")
+            return moved.element;
+    }
+    const site = sourceSite ?? target.sourceSite;
+    const selector = sourceSiteSelector(site.cid, site.src);
     if (!selector)
         return null;
     const candidates = Array.from(doc.querySelectorAll(selector));
     if (candidates.length === 1)
         return candidates[0];
-    const { props, ariaLabel } = target.locator;
     if (!props && !ariaLabel)
         return null;
     const matching = candidates.filter((element) => element.getAttribute("data-cprops") === props

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

@@ -1,7 +1,12 @@
-import type { ComponentOverride, ComponentRuntimeAdapter, EditableComponentTarget, RuntimeComponentTarget } from "./types.js";
+import type { ComponentOverride, ComponentRootInvocation, ComponentRuntimeAdapter, EditableComponentTarget, RuntimeComponentTarget } from "./types.js";
 /** Register a framework adapter without coupling semantic resolution to React. */
 export declare function registerComponentRuntimeAdapter(adapter: ComponentRuntimeAdapter): () => void;
 export declare function inspectComponentTargets(element: HTMLElement): RuntimeComponentTarget[];
+/**
+ * Returns the invocations, nearest first, whose entire rendered output is this
+ * element. Null means no enabled runtime could read the element's ancestry.
+ */
+export declare function inspectRootInvocations(element: HTMLElement): ComponentRootInvocation[] | null;
 /**
  * Resolve multiplicity through the owning runtime Adapter. The inspector does
  * not infer it from DOM order or retain a React fiber as durable identity.

package/dist/inspector/componentSemantics/adapterRegistry.js

@@ -1,5 +1,5 @@
 import { getNudgeUiRuntimeConfig } from "../runtime/runtimeConfig.js";
-import { copyComponentOverrides, copyRuntimeTarget, getHostRuntimeAdapters, registerHostRuntimeAdapter, replaceHostRuntimeAdapterOverrides, } from "./runtimeBridge.js";
+import { copyComponentOverrides, copyRootInvocations, copyRuntimeTarget, getHostRuntimeAdapters, registerHostRuntimeAdapter, replaceHostRuntimeAdapterOverrides, } from "./runtimeBridge.js";
 const diagnosedAdapters = new WeakSet();
 function enabledRuntimeAdapters(ownerGlobal) {
     if (!getNudgeUiRuntimeConfig().capabilities.componentSemantics)
@@ -42,6 +42,28 @@ export function inspectComponentTargets(element) {
     }
     return targets;
 }
+/**
+ * Returns the invocations, nearest first, whose entire rendered output is this
+ * element. Null means no enabled runtime could read the element's ancestry.
+ */
+export function inspectRootInvocations(element) {
+    let invocations = null;
+    const ownerGlobal = element.ownerDocument.defaultView ?? globalThis;
+    for (const adapter of enabledRuntimeAdapters(ownerGlobal)) {
+        if (!adapter.rootInvocations)
+            continue;
+        try {
+            const inspected = adapter.rootInvocations(element);
+            if (inspected === null || inspected === undefined)
+                continue;
+            invocations = [...(invocations ?? []), ...copyRootInvocations(inspected)];
+        }
+        catch (error) {
+            diagnoseAdapter(adapter, error instanceof Error ? error.message : String(error));
+        }
+    }
+    return invocations;
+}
 function diagnoseAdapter(adapter, detail) {
     if (diagnosedAdapters.has(adapter))
         return;

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

@@ -1,10 +1,11 @@
 import { type ReactElement } from "react";
-import type { ComponentInvocationMeta, ComponentOverride, ComponentRuntimeAdapter, RuntimeComponentTarget } from "./types.js";
+import type { ComponentInvocationMeta, ComponentOverride, ComponentRootInvocation, ComponentRuntimeAdapter, RuntimeComponentTarget } from "./types.js";
 /** Returns null when this runtime has no mounted boundary for the callsite. */
 export declare function getReactCallsiteMultiplicity(callsiteId: string): number | null;
 /** Test/runtime teardown hook; canonical changes never depend on this state. */
 export declare function resetReactComponentRuntime(): void;
 export declare function instrumentReactComponent(element: ReactElement<Record<string, unknown>>, meta: ComponentInvocationMeta): ReactElement;
 export declare function inspectReactComponentTargets(element: HTMLElement): RuntimeComponentTarget[];
+export declare function inspectReactRootInvocations(element: HTMLElement): ComponentRootInvocation[] | null;
 export declare function replaceReactComponentOverrides(overrides: ComponentOverride[]): void;
 export declare const reactComponentRuntimeAdapter: ComponentRuntimeAdapter;

package/dist/inspector/componentSemantics/reactRuntime.js

@@ -4,6 +4,9 @@ import { getNudgeUiRuntimeConfig } from "../runtime/runtimeConfig.js";
 const BOUNDARY_MARKER = Symbol.for("nudge-ui.react-component-boundary");
 const EMPTY_OVERRIDE = Object.freeze({});
 const REACT_MAJOR_VERSION = Number.parseInt(reactVersion, 10);
+/** React work tags for host output that has no string element type. */
+const HOST_PORTAL_TAG = 4;
+const HOST_TEXT_TAG = 6;
 let overridesByCallsite = new Map();
 const listeners = new Set();
 /**
@@ -161,6 +164,40 @@ export function inspectReactComponentTargets(element) {
     }
     return targets;
 }
+function isHostOutput(fiber) {
+    return typeof fiber.type === "string" || fiber.tag === HOST_TEXT_TAG || fiber.tag === HOST_PORTAL_TAG;
+}
+/** Counts top-level host outputs below a fiber, stopping once there are two. */
+function hostOutputCount(fiber) {
+    let count = 0;
+    const visit = (parent) => {
+        for (let child = parent.child ?? null; child && count < 2; child = child.sibling ?? null) {
+            if (isHostOutput(child))
+                count += 1;
+            else
+                visit(child);
+        }
+    };
+    visit(fiber);
+    return count;
+}
+export function inspectReactRootInvocations(element) {
+    if (!getNudgeUiRuntimeConfig().capabilities.componentSemantics)
+        return null;
+    const host = findFiber(element);
+    if (!host)
+        return null;
+    const invocations = [];
+    for (let fiber = host.return ?? null; fiber && !isHostOutput(fiber); fiber = fiber.return ?? null) {
+        if (!isBoundaryType(fiber.type) || !fiber.memoizedProps?.meta)
+            continue;
+        if (hostOutputCount(fiber) !== 1)
+            break;
+        const { callsiteId, componentName } = fiber.memoizedProps.meta;
+        invocations.push({ callsiteId, componentName });
+    }
+    return invocations;
+}
 export function replaceReactComponentOverrides(overrides) {
     if (!getNudgeUiRuntimeConfig().capabilities.componentSemantics)
         return;
@@ -182,5 +219,6 @@ export const reactComponentRuntimeAdapter = {
     inspect: inspectReactComponentTargets,
     replaceOverrides: replaceReactComponentOverrides,
     getCallsiteMultiplicity: getReactCallsiteMultiplicity,
+    rootInvocations: inspectReactRootInvocations,
 };
 registerHostRuntimeAdapter(reactComponentRuntimeAdapter);

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

@@ -1,5 +1,5 @@
-import type { ComponentOverride, ComponentRuntimeAdapter, RuntimeComponentTarget } from "./types.js";
-export type { ComponentFramework, ComponentInvocationMeta, ComponentOverride, ComponentRuntimeAdapter, RuntimeComponentTarget, } from "./types.js";
+import type { ComponentOverride, ComponentRootInvocation, ComponentRuntimeAdapter, RuntimeComponentTarget } from "./types.js";
+export type { ComponentFramework, ComponentInvocationMeta, ComponentOverride, ComponentRootInvocation, ComponentRuntimeAdapter, RuntimeComponentTarget, } from "./types.js";
 /** Version of the page-global host runtime Adapter Interface. */
 export declare const NUDGE_UI_HOST_RUNTIME_VERSION = 1;
 /**
@@ -21,5 +21,7 @@ export declare function replaceHostRuntimeAdapterOverrides(overrides: readonly C
  * the host/client seam.
  */
 export declare function copyRuntimeTarget(target: RuntimeComponentTarget): RuntimeComponentTarget;
+/** Copies a host Adapter's root invocations into plain protocol data. */
+export declare function copyRootInvocations(invocations: readonly ComponentRootInvocation[]): ComponentRootInvocation[];
 /** Copies override commands before dispatching them into a host Adapter. */
 export declare function copyComponentOverrides(overrides: readonly ComponentOverride[]): ComponentOverride[];

package/dist/inspector/componentSemantics/runtimeBridge.js

@@ -104,6 +104,23 @@ export function copyRuntimeTarget(target) {
         ...(target.mountedCount === undefined ? {} : { mountedCount: target.mountedCount }),
     };
 }
+/** Copies a host Adapter's root invocations into plain protocol data. */
+export function copyRootInvocations(invocations) {
+    if (!Array.isArray(invocations)) {
+        throw new TypeError("Nudge UI received invalid root invocations from a host Adapter.");
+    }
+    return invocations.map((invocation) => {
+        if (invocation === null
+            || typeof invocation !== "object"
+            || typeof invocation.callsiteId !== "string"
+            || invocation.callsiteId.length === 0
+            || typeof invocation.componentName !== "string"
+            || invocation.componentName.length === 0) {
+            throw new TypeError("Nudge UI received an invalid root invocation from a host Adapter.");
+        }
+        return { callsiteId: invocation.callsiteId, componentName: invocation.componentName };
+    });
+}
 /** Copies override commands before dispatching them into a host Adapter. */
 export function copyComponentOverrides(overrides) {
     return overrides.map((override) => {

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

@@ -61,6 +61,11 @@ export interface RuntimeComponentTarget {
     /** Adapter-reported mounted invocation count for this callsite. */
     mountedCount?: number;
 }
+/** A component invocation whose entire rendered output is one DOM element. */
+export interface ComponentRootInvocation {
+    callsiteId: string;
+    componentName: string;
+}
 export interface ComponentPropContract {
     name: string;
     control: "select" | "boolean" | "text";
@@ -93,4 +98,10 @@ export interface ComponentRuntimeAdapter {
      * fail closed instead of broadening a semantic override.
      */
     getCallsiteMultiplicity?(callsiteId: string): number | null | undefined;
+    /**
+     * Return, nearest first, the invocations whose entire rendered output is
+     * this element. A runtime that cannot read the element's ancestry must
+     * return null so structural identity fails closed.
+     */
+    rootInvocations?(element: HTMLElement): ComponentRootInvocation[] | null;
 }

package/dist/inspector/iterations/capture.js

@@ -1,4 +1,5 @@
 import { HTML_ARTIFACT_REVISION_ATTRIBUTE } from "../../transport/artifacts.js";
+import { FRAME_SCROLLBAR_STYLE_ID } from "../canvas/frameScrollbarStyles.js";
 /** Captures the visible DOM of a same-origin frame as a script-free HTML iteration. */
 export async function captureHtmlIteration(frame) {
     const source = frame.contentDocument;
@@ -52,7 +53,7 @@ export async function captureHtmlIteration(frame) {
     copy.querySelectorAll("base").forEach((element) => element.remove());
     (copy.querySelector("head") ?? copy).prepend(base);
     copy.querySelectorAll('script, iframe, object, embed, meta[http-equiv="refresh"], meta[http-equiv="Content-Security-Policy"], link[rel=modulepreload], link[rel=preload]').forEach((element) => element.remove());
-    copy.querySelectorAll("[data-nudge-ui-mount], #nudge-ui-root").forEach((element) => element.remove());
+    copy.querySelectorAll(`[data-nudge-ui-mount], #nudge-ui-root, #${FRAME_SCROLLBAR_STYLE_ID}`).forEach((element) => element.remove());
     copy.querySelectorAll("a, form").forEach((element) => {
         element.removeAttribute("href");
         element.removeAttribute("action");

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

@@ -23,10 +23,23 @@ export declare function captureRenderedInstance(el: HTMLElement): RenderedInstan
 /**
  * Resolves exactly one element, or declines to apply. Occurrence documents the
  * captured placement, but structural previews can legitimately change it.
- * Evidence must therefore identify one current candidate before an edit can
- * be applied.
+ * Evidence, narrowed by a recorded invocation when present, must therefore
+ * identify one current candidate before an edit can be applied.
  */
 export declare function resolveRenderedInstance(doc: Document, ref: RenderedInstanceRef): ResolutionResult;
+/**
+ * Resolves a reference whose source position may have moved since capture.
+ * A relocated site still renders matching authored evidence, so an evidence
+ * miss there is reported as ambiguous rather than as proof of absence.
+ */
+export declare function resolveMovedRenderedInstance(doc: Document, ref: RenderedInstanceRef): ResolutionResult;
+/**
+ * Captures identity for a structural target. When evidence matches several
+ * identical outputs, the nearest component invocation whose entire output is
+ * this element can still identify it. Otherwise the evidence-only reference
+ * is returned and resolves as ambiguous.
+ */
+export declare function captureStructuralTarget(el: HTMLElement): RenderedInstanceRef | null;
 /** Checks stable source/evidence fields without treating a post-move ordinal as identity. */
 export declare function matchesRenderedInstanceEvidence(el: HTMLElement, ref: RenderedInstanceRef): boolean;
 /** Builds an instance override without changing the element's transient edit scope. */

package/dist/inspector/projection/renderedInstance.js

@@ -1,7 +1,8 @@
 import { getActiveDraftChanges, getDraftChanges } from "../changes/draftChanges.js";
+import { inspectRootInvocations } from "../componentSemantics/adapterRegistry.js";
 import { escapeAttrValue } from "./cssEscapes.js";
 import { isNudgeUiDev } from "../runtime/devFlag.js";
-import { sourceSiteSelector } from "../selection/sourceSite.js";
+import { relocateSourceSite, sourceSiteSelector } from "../selection/sourceSite.js";
 import { isRenderedInstanceOverride } from "../changes/editModel.js";
 export { isRenderedInstanceOverride, isRenderedInstanceRef } from "../changes/editModel.js";
 const PROJECTION_ATTR = "data-projection-instance";
@@ -50,19 +51,31 @@ export function captureRenderedInstance(el) {
 /**
  * Resolves exactly one element, or declines to apply. Occurrence documents the
  * captured placement, but structural previews can legitimately change it.
- * Evidence must therefore identify one current candidate before an edit can
- * be applied.
+ * Evidence, narrowed by a recorded invocation when present, must therefore
+ * identify one current candidate before an edit can be applied.
  */
 export function resolveRenderedInstance(doc, ref) {
     const sourceCandidates = candidates(doc, ref.sourceSite);
-    const { props, text, ariaLabel = null } = ref.locator;
+    const { props, text, ariaLabel = null, invocation } = ref.locator;
     // An ordinal alone is not an identity for a repeated source site.
-    if (sourceCandidates.length > 1 && props === null && text === null && ariaLabel === null) {
+    if (!invocation && sourceCandidates.length > 1 && props === null && text === null && ariaLabel === null) {
         return { status: "ambiguous" };
     }
-    const matchingEvidence = sourceCandidates.filter((element) => element.getAttribute("data-cprops") === props
+    let matchingEvidence = sourceCandidates.filter((element) => element.getAttribute("data-cprops") === props
         && normalizedText(element) === text
         && element.getAttribute("aria-label") === ariaLabel);
+    if (invocation) {
+        const scoped = [];
+        for (const element of matchingEvidence) {
+            const invocations = inspectRootInvocations(element);
+            // Without readable ancestry, absence of the invocation proves nothing.
+            if (invocations === null)
+                return { status: "ambiguous" };
+            if (invocations.some((candidate) => candidate.callsiteId === invocation.callsiteId))
+                scoped.push(element);
+        }
+        matchingEvidence = scoped;
+    }
     if (matchingEvidence.length === 0)
         return { status: "missing" };
     // Evidence alone is never enough to choose between two identical rendered
@@ -72,6 +85,40 @@ export function resolveRenderedInstance(doc, ref) {
         return { status: "ambiguous" };
     return { status: "resolved", element: matchingEvidence[0] };
 }
+/**
+ * Resolves a reference whose source position may have moved since capture.
+ * A relocated site still renders matching authored evidence, so an evidence
+ * miss there is reported as ambiguous rather than as proof of absence.
+ */
+export function resolveMovedRenderedInstance(doc, ref) {
+    const exact = resolveRenderedInstance(doc, ref);
+    if (exact.status !== "missing")
+        return exact;
+    const { props, ariaLabel = null } = ref.locator;
+    const sourceSite = relocateSourceSite(doc, ref.sourceSite, (element) => element.getAttribute("data-cprops") === props && element.getAttribute("aria-label") === ariaLabel);
+    if (!sourceSite)
+        return exact;
+    const moved = resolveRenderedInstance(doc, { ...ref, sourceSite });
+    return moved.status === "missing" ? { status: "ambiguous" } : moved;
+}
+/**
+ * Captures identity for a structural target. When evidence matches several
+ * identical outputs, the nearest component invocation whose entire output is
+ * this element can still identify it. Otherwise the evidence-only reference
+ * is returned and resolves as ambiguous.
+ */
+export function captureStructuralTarget(el) {
+    const ref = captureRenderedInstance(el);
+    if (!ref || resolveRenderedInstance(el.ownerDocument, ref).status !== "ambiguous")
+        return ref;
+    for (const invocation of inspectRootInvocations(el) ?? []) {
+        const scoped = { ...ref, locator: { ...ref.locator, invocation } };
+        const resolved = resolveRenderedInstance(el.ownerDocument, scoped);
+        if (resolved.status === "resolved" && resolved.element === el)
+            return scoped;
+    }
+    return ref;
+}
 /** Checks stable source/evidence fields without treating a post-move ordinal as identity. */
 export function matchesRenderedInstanceEvidence(el, ref) {
     const { props, text, ariaLabel = null } = ref.locator;

package/dist/inspector/projection/structuralProjection.js

@@ -1,5 +1,5 @@
 import { getActiveDraftChanges, getDraftChanges } from "../changes/draftChanges.js";
-import { captureRenderedInstance, matchesRenderedInstanceEvidence, resolveRenderedInstance, } from "./renderedInstance.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";
@@ -182,7 +182,7 @@ function projectStructuralChanges(snapshot) {
 }
 /** 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);

package/dist/inspector/projection/textProjection.js

@@ -49,6 +49,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)
@@ -411,7 +444,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 +459,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 +502,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 +519,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 +529,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 +553,7 @@ function getDocumentState(doc) {
     if (existing)
         return existing;
     const state = {
+        doc,
         applied: new Map(),
         emptyAffordances: new Map(),
         snapshotKey: null,
@@ -524,7 +562,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 +612,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 +620,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 +644,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 +752,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,11 @@ 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>;
 export declare function startClipboardHandoffController(doc?: Document): () => void;
 export {};

package/dist/inspector/prompt/clipboardHandoff.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) {

package/dist/inspector/prompt/generatePrompt.js

@@ -232,7 +232,10 @@ function renderedInstanceDescription(ref) {
 function structuralChangeLine(change) {
     const target = renderedInstanceDescription(change.target);
     if (change.kind === "delete") {
-        return `- Remove ${target} from the source.`;
+        const invocation = change.target.locator.invocation;
+        return invocation
+            ? `- Remove the ${promptText(`<${invocation.componentName}>`)} invocation at ${invocation.callsiteId} from the source; keep its other invocations. It renders ${target}.`
+            : `- Remove ${target} from the source.`;
     }
     const before = change.destination.before;
     const sourceParent = sourceSiteLabel(change.source.parent);
@@ -254,6 +257,7 @@ function renderedInstanceKey(ref) {
         locator.props,
         locator.text,
         locator.ariaLabel ?? null,
+        locator.invocation?.callsiteId ?? null,
     ]);
 }
 /** Export final intent, not the gesture history required to replay the preview. */

package/dist/inspector/selection/sourceSite.d.ts

@@ -1,2 +1,14 @@
 /** Stable JSX instrumentation selector, shared by source and instance edits. */
 export declare function sourceSiteSelector(cid: string, src: string): string | null;
+/**
+ * Finds a source site whose position moved because its file gained or lost
+ * lines. It returns a site only when the original renders nothing and exactly
+ * one other position in the same file and component renders matching elements.
+ */
+export declare function relocateSourceSite(doc: Document, site: {
+    readonly cid: string;
+    readonly src: string;
+}, matches: (element: HTMLElement) => boolean): {
+    cid: string;
+    src: string;
+} | null;

package/dist/inspector/selection/sourceSite.js

@@ -1,4 +1,5 @@
 import { escapeAttrValue } from "../projection/cssEscapes.js";
+const SOURCE_POSITION = /^(.+):\d+:\d+$/;
 /** Stable JSX instrumentation selector, shared by source and instance edits. */
 export function sourceSiteSelector(cid, src) {
     if (!cid)
@@ -10,3 +11,30 @@ export function sourceSiteSelector(cid, src) {
     // single formatted line share a managed rule.
     return `[data-cid="${escapeAttrValue(cid)}"][data-src="${escapeAttrValue(src)}"]`;
 }
+/**
+ * Finds a source site whose position moved because its file gained or lost
+ * lines. It returns a site only when the original renders nothing and exactly
+ * one other position in the same file and component renders matching elements.
+ */
+export function relocateSourceSite(doc, site, matches) {
+    const file = SOURCE_POSITION.exec(site.src)?.[1];
+    const exact = sourceSiteSelector(site.cid, site.src);
+    if (!file || !exact)
+        return null;
+    try {
+        if (doc.querySelector(exact))
+            return null;
+        const sites = new Set();
+        const sameFile = `[data-cid="${escapeAttrValue(site.cid)}"][data-src^="${escapeAttrValue(`${file}:`)}"]`;
+        for (const element of doc.querySelectorAll(sameFile)) {
+            const src = element.getAttribute("data-src") ?? "";
+            if (SOURCE_POSITION.exec(src)?.[1] === file && matches(element))
+                sites.add(src);
+        }
+        const [src] = sites;
+        return sites.size === 1 && src ? { cid: site.cid, src } : null;
+    }
+    catch {
+        return null;
+    }
+}