nudge-ui 0.2.3 → 0.2.5

package/dist/inspector/comments/store.js

@@ -1,3 +1,4 @@
+import { inspectorStorage } from "../runtime/inspectorStorage.js";
 import { useSyncExternalStore } from "react";
 import { isRenderedInstanceRef } from "../changes/editModel.js";
 import { useCanvasCards, useFocusedCardId, useSelectedCardId } from "../canvas/canvasStore.js";
@@ -29,7 +30,7 @@ export function getComments() {
         loadedKey = key;
         loadedDemo = demo;
         try {
-            const saved = demo ? [] : JSON.parse(localStorage.getItem(key) ?? "[]");
+            const saved = demo ? [] : JSON.parse(inspectorStorage()?.getItem(key) ?? "[]");
             comments = Array.isArray(saved) ? saved.filter(isComment) : [];
         }
         catch {
@@ -51,7 +52,7 @@ function publish(next) {
     comments = next;
     if (getNudgeUiRuntimeConfig().demo !== true) {
         try {
-            localStorage.setItem(storageKey(), JSON.stringify(next));
+            inspectorStorage()?.setItem(storageKey(), JSON.stringify(next));
         }
         catch { }
     }

package/dist/inspector/comments/verification.js

@@ -1,4 +1,4 @@
-import { getDraftChanges } from "../changes/draftChanges.js";
+import { getDraftChanges } from "../drafts/store.js";
 import { documentTarget, targetKey } from "../drafts/model.js";
 import { isCanvasProjectionRevisionCurrent, projectDraftToDocument } from "../canvas/projection.js";
 import { commentFingerprint, commentViewport, resolveCommentElement } from "./element.js";

package/dist/inspector/componentSemantics/ComponentPropsSection.js

@@ -1,5 +1,6 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { isComponentChange, useChanges } from "../changes/changesLog.js";
+import { isComponentChange } from "../changes/types.js";
+import { useChanges } from "../drafts/store.js";
 import { FieldRow } from "../ui/FieldRow.js";
 import { Select } from "../ui/Select.js";
 import { SegmentedControl } from "../ui/SegmentedControl.js";

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/changeAction.js

@@ -1,4 +1,4 @@
-import { appendChange } from "../changes/changesLog.js";
+import { appendChange } from "../drafts/store.js";
 import { createComponentPropChange } from "./changeModel.js";
 export { createComponentPropChange } from "./changeModel.js";
 export function setComponentProp(target, prop, value) {

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/textBinding.d.ts

@@ -1,6 +1,5 @@
 import type { ComponentChangeTarget, EditableComponentTarget } from "./types.js";
-import type { TextProjectionTarget } from "../inline-text/textChangeBoundary.js";
-import type { TextBindingEvidence, TextProjectionScope } from "../inline-text/textChangeBoundary.js";
+import type { TextBindingEvidence, TextProjectionScope, TextProjectionTarget } from "../changes/editModel.js";
 /** The order used when more than one visible prop has the same value. */
 export declare const VISIBLE_TEXT_PROP_PRIORITY: readonly ["children", "label", "text", "caption", "description", "title"];
 export type TextEditRejectionReason = "no-text" | "no-binding" | "ambiguous-binding" | "editing-active" | "unsafe-target";

package/dist/inspector/componentSemantics/textBinding.js

@@ -1,5 +1,5 @@
 import { callsiteMultiplicity, editableComponentTargets, inspectComponentTargets, } from "./adapterRegistry.js";
-import { captureTextProjectionTarget, resolveTextProjectionTextNode, textProjectionSelector, } from "../projection/textProjection.js";
+import { captureTextProjectionTarget, hasSafeMixedDescendants, isInApplicationEditingHost, isUnsafeTextHost, resolveTextProjectionTextNode, textProjectionSelector, } from "../projection/textProjection.js";
 /** The order used when more than one visible prop has the same value. */
 export const VISIBLE_TEXT_PROP_PRIORITY = [
     "children",
@@ -17,24 +17,6 @@ const STRUCTURAL_TEXT_PROPS = new Set([
     "role",
     "style",
 ]);
-const UNSAFE_TEXT_TAGS = new Set(["SCRIPT", "STYLE", "TEXTAREA", "OPTION"]);
-const UNSAFE_MIXED_DESCENDANT_TAGS = new Set([
-    ...UNSAFE_TEXT_TAGS,
-    "INPUT",
-    "SELECT",
-    "BUTTON",
-    "A",
-    "B",
-    "STRONG",
-    "I",
-    "EM",
-    "U",
-    "MARK",
-    "CODE",
-    "S",
-    "DEL",
-    "INS",
-]);
 function isStructuralTextProp(name) {
     return STRUCTURAL_TEXT_PROPS.has(name)
         || name.startsWith("data")
@@ -62,9 +44,6 @@ function isApplicationEditingTextNode(element, textNode) {
         && editingHost.getAttribute("contenteditable") !== "false"
         && (editingHost === element || element.contains(editingHost) || editingHost.contains(element));
 }
-function isUnsafeSemanticHost(element) {
-    return UNSAFE_TEXT_TAGS.has(element.tagName);
-}
 function isVisibleTextProp(name) {
     return VISIBLE_TEXT_PROP_PRIORITY.some((candidate) => candidate === name);
 }
@@ -107,33 +86,13 @@ function textNodesFor(element) {
     return nodes;
 }
 function isSafeRenderedTextHost(element, textNode) {
-    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 (element.children.length === 0) {
         const directTextNodes = Array.from(element.childNodes).filter((node) => node.nodeType === 3);
         return directTextNodes.length === 1 && directTextNodes[0] === textNode;
     }
-    if (!element.contains(textNode))
-        return false;
-    // A line break is layout structure, not rich text content. When the exact
-    // text node is captured, wrapping that node leaves the <br> in place and
-    // preserves both lines. Other inline formatting remains rejected because
-    // replacing text inside it would silently flatten authored markup.
-    for (const descendant of Array.from(element.querySelectorAll("*"))) {
-        if (UNSAFE_MIXED_DESCENDANT_TAGS.has(descendant.tagName))
-            return false;
-        const descendantEditingHost = descendant.closest("[contenteditable]");
-        if (descendantEditingHost
-            && descendantEditingHost.getAttribute("data-inline-editor") !== "true"
-            && descendantEditingHost.getAttribute("contenteditable") !== "false")
-            return false;
-    }
-    return true;
+    return element.contains(textNode) && hasSafeMixedDescendants(element);
 }
 function textNodeAtPoint(element, point) {
     const nodes = textNodesFor(element);
@@ -383,7 +342,7 @@ export function resolveTextBinding(element, point) {
     // markup is intentionally not included: a confident semantic component
     // binding may still own a nested text node, while rendered fallback keeps
     // its stricter direct-leaf requirement.
-    if (isUnsafeSemanticHost(element)) {
+    if (isUnsafeTextHost(element)) {
         return {
             kind: "rejected",
             reason: "unsafe-target",

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/drafts/draftStore.d.ts

@@ -0,0 +1,109 @@
+import { type ChangeRecord } from "../changes/types.js";
+import type { StructuralChange } from "../changes/structuralTypes.js";
+import type { SketchDocument } from "../sketch/model.js";
+import type { Timeline } from "../workspace/timeline.js";
+import { type Draft, type DraftContents, type DraftSnapshot } from "./model.js";
+export interface DraftChangesSnapshot extends DraftContents {
+    readonly draftId: string;
+    readonly revision: number;
+    readonly canUndo: boolean;
+    readonly canRedo: boolean;
+}
+/** A canonical write result. `blocked` means the lease or a save lock refused the write. */
+export type CommitResult = "applied" | "unchanged" | "blocked";
+/** Why the active draft's preview must be rebuilt. */
+export type DraftProjectionEvent = 
+/** The active draft's contents changed through an edit, revert, undo, or redo. */
+{
+    readonly kind: "edit";
+    readonly verificationTargets?: ReadonlyMap<string, HTMLElement | null>;
+}
+/** Source verification removed these records from the active draft. */
+ | {
+    readonly kind: "reconcile";
+    readonly structuralIds: ReadonlySet<string>;
+}
+/** Another draft became active, or drafts were loaded. */
+ | {
+    readonly kind: "switch";
+}
+/** The active draft was cleared; every earlier preview diagnostic is void. */
+ | {
+    readonly kind: "reset";
+};
+export type DraftDiscardTarget = {
+    readonly kind: "selector";
+    readonly selector: string;
+} | {
+    readonly kind: "instance-override";
+    readonly id: string;
+};
+export interface DraftStorage {
+    read(key: string): string | null;
+    write(key: string, value: string): void;
+    remove(key: string): void;
+}
+export interface DraftSketchSource {
+    getSnapshot(): {
+        readonly ready: boolean;
+        readonly documents: readonly SketchDocument[];
+    };
+    subscribe(listener: () => void): () => void;
+}
+export interface DraftStoreSeams {
+    /** Whether this tab holds the workspace write lease. */
+    canWrite(): boolean;
+    readonly timeline: Timeline;
+    readonly storage: DraftStorage;
+    readonly sketches: DraftSketchSource;
+    /** Rebuilds the active draft's preview. Called after subscribers see the new snapshot. */
+    project(snapshot: DraftChangesSnapshot, event: DraftProjectionEvent): void;
+}
+/**
+ * The Workspace's drafts. A draft's identity is its target key (ADR-0030):
+ * every frame that shows one page or iteration edits the same draft. Every
+ * write is lease-gated, every change to the active draft is projected, and
+ * reconciliation removes only verified records, including from history.
+ */
+export interface DraftStore {
+    getActive(): DraftChangesSnapshot;
+    /** Fires for any draft content change, active-draft switch, or history change. */
+    subscribeActive(listener: () => void): () => void;
+    get(id: string): DraftChangesSnapshot;
+    ids(): readonly string[];
+    getDraft(id: string): Draft | null;
+    getSnapshot(): DraftSnapshot;
+    subscribe(listener: () => void): () => void;
+    canEdit(id?: string): boolean;
+    isLocked(id?: string): boolean;
+    /** Blocks writes to one draft until the returned release runs. */
+    lock(id: string): () => void;
+    /** Makes a draft active; `reveal` brings its frame back when history replays an edit. */
+    activate(id: string, reveal?: () => void): void;
+    commitChanges(incoming: readonly ChangeRecord[], verificationTargets?: ReadonlyMap<string, HTMLElement | null>): CommitResult;
+    revertChange(change: ChangeRecord): boolean;
+    discardChanges(target: DraftDiscardTarget): boolean;
+    commitStructuralChange(change: StructuralChange): boolean;
+    revertStructuralChange(changeId: string): boolean;
+    /** Replaces the active draft as one undoable edit. */
+    commitContents(next: DraftContents): boolean;
+    undo(): boolean;
+    redo(): boolean;
+    /** Removes source-verified records so no undo step can resurrect them. */
+    reconcile(id: string, verifiedKeys: ReadonlySet<string>, verifiedStructuralIds: ReadonlySet<string>): number;
+    clear(id: string, expectedRevision?: number): boolean;
+    clearActive(): boolean;
+    /** Drops a draft whose content no longer exists, such as a deleted iteration. */
+    forget(id: string): void;
+    sketchOwner(document: SketchDocument): string | null;
+    assignSketch(draftId: string, sketchId: string): void;
+    /** Replaces every in-memory draft with the stored drafts, so a tab that takes over never writes stale edits. */
+    load(projectId: string, options?: {
+        persistent?: boolean;
+    }): void;
+    persist(): void;
+    /** Discards stored and in-memory drafts for the current project. */
+    discardAll(): void;
+    reset(): void;
+}
+export declare function createDraftStore(seams: DraftStoreSeams): DraftStore;