nudge-ui 0.2.0

package/dist/inspector/conformance/typographyCases.js

@@ -0,0 +1,174 @@
+function token(cssName, value, source) {
+    return {
+        cssName,
+        name: cssName,
+        declarations: [{ value, source, important: false, context: { selector: ":root" } }],
+    };
+}
+const TYPE_SIZE = token("--type-size-body", "1rem", "fixtures/typography.css:2");
+const TYPE_WEIGHT = token("--type-weight-strong", "650", "fixtures/typography.css:3");
+const TYPE_LEADING = token("--type-leading-body", "1.5", "fixtures/typography.css:4");
+const TYPE_TRACKING = token("--type-tracking-tight", "-0.018em", "fixtures/typography.css:5");
+const TYPE_FAMILY = token("--type-family-body", 'Inter, ui-sans-serif, system-ui, sans-serif', "fixtures/typography.css:6");
+/**
+ * Framework-neutral typography corpus. The fixture runner asserts authored
+ * CSS and capability independently from browser-computed output; the gallery
+ * lets a human exercise the same cases through the real inspector.
+ */
+export const TYPOGRAPHY_CASES = [
+    {
+        id: "type-direct-literals",
+        css: `.subject {
+  font-family: "Aster Display", Georgia, serif;
+  font-size: .875rem;
+  font-weight: 650;
+  line-height: 1.45;
+  letter-spacing: -.0125em;
+}`,
+        markup: '<p class="subject" data-cid="TypographyCase" data-src="fixtures/typography.tsx:1:1">Measured type makes a dense interface feel calm.</p>',
+        selected: ".subject",
+        catalog: [],
+        expected: {
+            catalog: [],
+            properties: {
+                "font-family": { authored: '"Aster Display", Georgia, serif', capability: "composite" },
+                "font-size": { authored: ".875rem", capability: "atomic" },
+                "font-weight": { authored: "650", capability: "atomic" },
+                "line-height": { authored: "1.45", capability: "atomic" },
+                "letter-spacing": { authored: "-.0125em", capability: "atomic" },
+            },
+        },
+    },
+    {
+        id: "type-tokenized-longhands",
+        css: `:root {
+  --type-size-body: 1rem;
+  --type-weight-strong: 650;
+  --type-leading-body: 1.5;
+  --type-tracking-tight: -0.018em;
+  --type-family-body: Inter, ui-sans-serif, system-ui, sans-serif;
+}
+.subject {
+  font-family: var(--type-family-body);
+  font-size: var(--type-size-body);
+  font-weight: var(--type-weight-strong);
+  line-height: var(--type-leading-body);
+  letter-spacing: var(--type-tracking-tight);
+}`,
+        markup: '<p class="subject" data-cid="TypographyCase" data-src="fixtures/typography.tsx:2:1">A token-backed paragraph keeps its rhythm across surfaces.</p>',
+        selected: ".subject",
+        catalog: [TYPE_SIZE, TYPE_WEIGHT, TYPE_LEADING, TYPE_TRACKING, TYPE_FAMILY],
+        expected: {
+            catalog: [
+                { name: "--type-size-body", value: "1rem" },
+                { name: "--type-weight-strong", value: "650" },
+                { name: "--type-leading-body", value: "1.5" },
+                { name: "--type-tracking-tight", value: "-0.018em" },
+                { name: "--type-family-body", value: "Inter, ui-sans-serif, system-ui, sans-serif" },
+            ],
+            properties: {
+                "font-family": { authored: "var(--type-family-body)", tokens: ["--type-family-body"], capability: "atomic" },
+                "font-size": { authored: "var(--type-size-body)", tokens: ["--type-size-body"], capability: "atomic" },
+                "font-weight": { authored: "var(--type-weight-strong)", tokens: ["--type-weight-strong"], capability: "atomic" },
+                "line-height": { authored: "var(--type-leading-body)", tokens: ["--type-leading-body"], capability: "atomic" },
+                "letter-spacing": { authored: "var(--type-tracking-tight)", tokens: ["--type-tracking-tight"], capability: "atomic" },
+            },
+        },
+    },
+    {
+        id: "type-functional-raw",
+        css: `.subject {
+  font-size: clamp(1rem, 1vw + .78rem, 1.35rem);
+  font-weight: var(--type-weight-strong, 600);
+  line-height: calc(1em + .5rem);
+  letter-spacing: max(-.03em, calc(-.012em - .08vw));
+}`,
+        markup: '<p class="subject" data-cid="TypographyCase" data-src="fixtures/typography.tsx:3:1">Functional values remain editable as declared CSS expressions.</p>',
+        selected: ".subject",
+        catalog: [TYPE_WEIGHT],
+        expected: {
+            catalog: [{ name: "--type-weight-strong", value: "650" }],
+            properties: {
+                "font-size": { authored: "clamp(1rem, 1vw + .78rem, 1.35rem)", capability: "raw" },
+                "font-weight": { authored: "var(--type-weight-strong, 600)", tokens: ["--type-weight-strong"], capability: "atomic" },
+                "line-height": { authored: "calc(1em + .5rem)", capability: "raw" },
+                "letter-spacing": { authored: "max(-.03em, calc(-.012em - .08vw))", capability: "raw" },
+            },
+        },
+    },
+    {
+        id: "type-font-shorthand",
+        css: '.subject { font: italic 700 1.25rem / 1.4 "Aster Display", Georgia, serif; }',
+        markup: '<p class="subject" data-cid="TypographyCase" data-src="fixtures/typography.tsx:4:1">A shorthand still yields safe longhand controls.</p>',
+        selected: ".subject",
+        catalog: [],
+        expected: {
+            catalog: [],
+            properties: {
+                "font-family": { authored: '"Aster Display", Georgia, serif', capability: "composite" },
+                "font-size": { authored: "1.25rem", capability: "atomic" },
+                "font-weight": { authored: "700", capability: "atomic" },
+                "line-height": { authored: "1.4", capability: "atomic" },
+            },
+        },
+    },
+    {
+        id: "type-font-shorthand-resets",
+        css: `.subject {
+  font-style: italic;
+  font-weight: 700;
+  line-height: 2;
+  font: 16px Arial, sans-serif;
+}`,
+        markup: '<p class="subject" data-cid="TypographyCase" data-src="fixtures/typography.tsx:5:1">An omitted shorthand component still resets an earlier longhand.</p>',
+        selected: ".subject",
+        catalog: [],
+        expected: {
+            catalog: [],
+            properties: {
+                "font-family": { authored: "Arial, sans-serif", capability: "composite" },
+                "font-size": { authored: "16px", capability: "atomic" },
+                "font-style": { authored: "normal", capability: "raw" },
+                "font-weight": { authored: "normal", capability: "raw" },
+                "line-height": { authored: "normal", capability: "raw" },
+            },
+        },
+    },
+    {
+        id: "type-keywords-and-negative-tracking",
+        css: `.subject {
+  font-family: ui-monospace, SFMono-Regular, Consolas, monospace;
+  font-size: larger;
+  font-weight: bold;
+  line-height: normal;
+  letter-spacing: -1px;
+}`,
+        markup: '<p class="subject" data-cid="TypographyCase" data-src="fixtures/typography.tsx:6:1">Keywords should not be normalised into guessed values.</p>',
+        selected: ".subject",
+        catalog: [],
+        expected: {
+            catalog: [],
+            properties: {
+                "font-family": { authored: "ui-monospace, SFMono-Regular, Consolas, monospace", capability: "composite" },
+                "font-size": { authored: "larger", capability: "raw" },
+                "font-weight": { authored: "bold", capability: "raw" },
+                "line-height": { authored: "normal", capability: "raw" },
+                "letter-spacing": { authored: "-1px", capability: "atomic" },
+            },
+        },
+    },
+    {
+        id: "type-var-fallback-family",
+        css: '.subject { font-family: var(--type-family-body, Georgia, serif); font-size: 16px; }',
+        markup: '<p class="subject" data-cid="TypographyCase" data-src="fixtures/typography.tsx:7:1">A family fallback retains commas inside the raw authored value.</p>',
+        selected: ".subject",
+        catalog: [TYPE_FAMILY],
+        expected: {
+            catalog: [{ name: "--type-family-body", value: "Inter, ui-sans-serif, system-ui, sans-serif" }],
+            properties: {
+                "font-family": { authored: "var(--type-family-body, Georgia, serif)", tokens: ["--type-family-body"], capability: "atomic" },
+                "font-size": { authored: "16px", capability: "atomic" },
+            },
+        },
+    },
+];

package/dist/inspector/editScope.d.ts

@@ -0,0 +1,4 @@
+export declare const EDIT_SCOPES: readonly ["source-site", "rendered-instance"];
+export type EditScope = (typeof EDIT_SCOPES)[number];
+/** Returns whether a host value names a supported edit scope. */
+export declare function isEditScope(value: unknown): value is EditScope;

package/dist/inspector/editScope.js

@@ -0,0 +1,5 @@
+export const EDIT_SCOPES = ["source-site", "rendered-instance"];
+/** Returns whether a host value names a supported edit scope. */
+export function isEditScope(value) {
+    return EDIT_SCOPES.some((scope) => scope === value);
+}

package/dist/inspector/index.d.ts

@@ -0,0 +1,20 @@
+export declare function bootstrapNudgeUi(inspectorHost: HTMLElement): void;
+export declare function mountInspector(host: HTMLElement): void;
+export declare function unmountInspector(): void;
+export { toggleInspector, setInspectorOpen } from "./shell/InspectorShell.js";
+export { 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 { 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";
+export type { InlineTextEditor, InlineTextDiagnostic, InlineTextSession, InlineTextInputRejectionReason, InlineTextSessionEndReason, TextBindingCandidate, TextEditBinding, TextEditRejection, } from "./inline-text/inlineTextEditor.js";
+export { projectInspectorValues, projectionSides } from "./spacing/projection.js";
+export type { InspectorAxisProjection, InspectorFieldProjection, InspectorProjection, InspectorSpacingProjection, ProjectionAxis, ProjectionGroup, ProjectionSide, ProjectionState } from "./spacing/projection.js";
+export { createBrowserCssInspection } from "./inspection/browserCssInspection.js";
+export { configureNudgeUiRuntime, getNudgeUiRuntimeConfig, normalizeNudgeUiRuntimeConfig, subscribeNudgeUiRuntime, } from "./runtime/runtimeConfig.js";
+export { useNudgeUiRuntimeConfig } from "./runtime/useRuntimeConfig.js";
+export { isNudgeUiDev, setNudgeUiHostDevFlag } from "./runtime/devFlag.js";
+export type { NudgeUiRuntimeConfig, NudgeUiRuntimeCapabilities, NudgeUiRuntimeFramework, NudgeUiRuntimeHost, } from "./runtime/runtimeConfig.js";
+export type { BrowserCssInspection, BrowserCssInspectionConfig, BrowserCssInspectionOptions, BrowserTokenKnowledge, DocumentTokenInspectionSnapshot, InspectionCascade, InspectionDiagnostic, InspectionDiagnosticCode, InspectionRevision, InspectionSnapshot, InspectionTargetStatus, } from "./inspection/browserCssInspection.js";

package/dist/inspector/index.js

@@ -0,0 +1,236 @@
+import { createElement } from "react";
+import { createRoot } from "react-dom/client";
+import { InspectorShell, toggleInspector, setInspectorOpen, setInspectorHost } 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 { isCanvasRenderer } from "./canvas/roleDetection.js";
+import { bootstrapRenderer } from "./canvas/rendererBootstrap.js";
+import { hydrateSession, enableAutoSave, scheduleAutoSave, scheduleCanvasSave, setRestoreCount, } from "./canvas/sessionStore.js";
+import { subscribeChanges, getChangesList } from "./changes/changesLog.js";
+import { subscribe as subscribeCanvas } from "./canvas/canvasStore.js";
+import { acquireLease, enableWriteGuard, hasWriteLease, releaseLease, subscribeOwnership, } from "./canvas/workspaceLease.js";
+import { cancelStaleDetection, startStaleDetection } from "./canvas/staleChangeDetector.js";
+import { LockedWorkspaceNotice } from "./canvas/LockedWorkspaceNotice.js";
+import { AppShell } from "./shell/AppShell.js";
+import { installInspectionBridge } from "./inspection/bridge.js";
+import { disposeBrowserCssInspection } from "./inspection/browserCssInspectionRegistry.js";
+import { releaseDocumentProjection } 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 { createWorkspace, InspectorSessionProvider, } from "./session/index.js";
+let hostElement = null;
+let reactRoot = null;
+let lockedRoot = null;
+const workspace = createWorkspace();
+let inspectorSession = null;
+let rendererBootstrapHandle = null;
+let beforeUnloadAttached = false;
+let persistenceSubscribed = false;
+let unsubscribeOwnership = null;
+let removeInspectionBridge = null;
+let stopClipboardHandoffController = null;
+function onKeydown(e) {
+    if (isInspectorToggleShortcut(e)) {
+        toggleInspector();
+        e.preventDefault();
+    }
+}
+function disposeInspectorSession() {
+    const session = inspectorSession;
+    inspectorSession = null;
+    session?.dispose();
+}
+export function bootstrapNudgeUi(inspectorHost) {
+    const runtimeConfig = getNudgeUiRuntimeConfig();
+    const explicitDemo = isDemoRuntime();
+    if (!isNudgeUiDev() && !explicitDemo)
+        return;
+    if (explicitDemo) {
+        rendererBootstrapHandle?.teardown();
+        rendererBootstrapHandle = null;
+        // ADR-0014: only the configured demo runtime opens the shared dev gate
+        // for its own document. The bundle mode name alone must never flip it,
+        // so every build without both opt-ins stays governed by ADR-0002.
+        setNudgeUiHostDevFlag(true);
+        // 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");
+        mountInspector(inspectorHost);
+        return;
+    }
+    if (!runtimeConfig.capabilities.canvas) {
+        // A project can be reopened with a runtime that does not expose Canvas.
+        // Clear any stale in-memory mode before mounting the static inspector.
+        setCanvasMode("inspect");
+    }
+    rendererBootstrapHandle?.teardown();
+    rendererBootstrapHandle = null;
+    removeInspectionBridge?.();
+    removeInspectionBridge = installInspectionBridge();
+    if (getNudgeUiRuntimeConfig().capabilities.canvas && isCanvasRenderer()) {
+        rendererBootstrapHandle = bootstrapRenderer() ?? null;
+        return;
+    }
+    enableWriteGuard();
+    const leaseGranted = acquireLease();
+    if (!leaseGranted) {
+        mountLockedNotice(inspectorHost);
+        return;
+    }
+    startController(inspectorHost);
+}
+function startController(inspectorHost) {
+    if (!hasWriteLease()) {
+        mountLockedNotice(inspectorHost);
+        return;
+    }
+    if (lockedRoot) {
+        lockedRoot.unmount();
+        lockedRoot = null;
+    }
+    unsubscribeOwnership?.();
+    unsubscribeOwnership = subscribeOwnership((hasLease) => {
+        if (!hasLease)
+            mountLockedNotice(inspectorHost);
+    });
+    const result = hydrateSession();
+    if (result.restored) {
+        setRestoreCount(result.changeCount);
+        const restored = getChangesList();
+        if (restored.length > 0) {
+            startStaleDetection(restored);
+        }
+    }
+    mountInspector(inspectorHost);
+    stopClipboardHandoffController?.();
+    stopClipboardHandoffController = startClipboardHandoffController(document);
+    enableAutoSave();
+    if (!beforeUnloadAttached) {
+        // enableAutoSave registers its flush listener first. Release the lease only
+        // after the pending session write has had a chance to pass the ownership
+        // gate during beforeunload.
+        window.addEventListener("beforeunload", releaseLease);
+        beforeUnloadAttached = true;
+    }
+    if (!persistenceSubscribed) {
+        subscribeChanges(() => scheduleAutoSave());
+        subscribeClipboardHandoff(() => scheduleAutoSave());
+        subscribeCanvas(() => scheduleCanvasSave());
+        persistenceSubscribed = true;
+    }
+}
+function mountLockedNotice(host) {
+    stopClipboardHandoffController?.();
+    stopClipboardHandoffController = null;
+    if (reactRoot) {
+        reactRoot.unmount();
+        reactRoot = null;
+    }
+    try {
+        disposeInspectorSession();
+    }
+    finally {
+        cancelStaleDetection();
+        setInspectorOpen(false);
+        cancelInlineTextEdit();
+        setSelectedElement(null);
+        clearInspectorLayout();
+        removeManagedSheet();
+        releaseDocumentProjection(document);
+        hostElement = null;
+        unsubscribeOwnership?.();
+        unsubscribeOwnership = null;
+    }
+    const shadow = host.shadowRoot ?? host.attachShadow({ mode: "open" });
+    if (!lockedRoot) {
+        lockedRoot = createRoot(shadow);
+    }
+    lockedRoot.render(createElement(LockedWorkspaceNotice, {
+        onTakeover: () => startController(host),
+    }));
+}
+export function mountInspector(host) {
+    const demo = isDemoRuntime();
+    if (!demo && !hasWriteLease())
+        return;
+    if (host.dataset.nudgeUiDebug === "true") {
+        const runtimeConfig = getNudgeUiRuntimeConfig();
+        if (runtimeConfig.capabilities.domNavigation !== true) {
+            configureNudgeUiRuntime({
+                ...runtimeConfig,
+                capabilities: { ...runtimeConfig.capabilities, domNavigation: true },
+            });
+        }
+    }
+    if (lockedRoot) {
+        lockedRoot.unmount();
+        lockedRoot = null;
+    }
+    if (!hostElement)
+        hostElement = host;
+    const shadow = host.shadowRoot ?? host.attachShadow({ mode: "open" });
+    if (!reactRoot) {
+        reactRoot = createRoot(shadow);
+        inspectorSession = workspace.createInspectorSession(host);
+        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)));
+        window.addEventListener("keydown", onKeydown);
+    }
+    setInspectorOpen(true);
+}
+export function unmountInspector() {
+    rendererBootstrapHandle?.teardown();
+    rendererBootstrapHandle = null;
+    stopClipboardHandoffController?.();
+    stopClipboardHandoffController = null;
+    unsubscribeOwnership?.();
+    unsubscribeOwnership = null;
+    if (lockedRoot) {
+        lockedRoot.unmount();
+        lockedRoot = null;
+    }
+    cancelStaleDetection();
+    cancelInlineTextEdit();
+    setSelectedElement(null);
+    if (reactRoot) {
+        reactRoot.unmount();
+        reactRoot = null;
+    }
+    try {
+        disposeInspectorSession();
+    }
+    finally {
+        // Document-session cleanup already releases host projection when a
+        // session exists; release directly as well so projection applied outside
+        // a session (gestures, workspace projection) cannot leak across unmount.
+        releaseDocumentProjection(document);
+        clearClipboardHandoff();
+        removeManagedSheet();
+        clearInspectorLayout();
+        removeInspectionBridge?.();
+        removeInspectionBridge = null;
+        hostElement = null;
+    }
+}
+export { toggleInspector, setInspectorOpen } from "./shell/InspectorShell.js";
+export { InspectorShell } from "./shell/InspectorShell.js";
+export { detectFramework } from "./prompt/detectFramework.js";
+export { installStaticHtmlRuntimeIdentity, isRuntimeGeneratedSource, RUNTIME_ELEMENT_CID_PREFIX, RUNTIME_UNKNOWN_SOURCE_PREFIX, } from "./runtime/staticHtmlRuntimeIdentity.js";
+export { isCanvasRenderer } from "./canvas/roleDetection.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";
+export { createBrowserCssInspection } from "./inspection/browserCssInspection.js";
+export { configureNudgeUiRuntime, getNudgeUiRuntimeConfig, normalizeNudgeUiRuntimeConfig, subscribeNudgeUiRuntime, } from "./runtime/runtimeConfig.js";
+export { useNudgeUiRuntimeConfig } from "./runtime/useRuntimeConfig.js";
+export { isNudgeUiDev, setNudgeUiHostDevFlag } from "./runtime/devFlag.js";

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

@@ -0,0 +1,74 @@
+import { type TextBindingChoice, type TextEditBinding, type TextEditRejection } 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";
+export type { TextBindingCandidate } from "../componentSemantics/textBinding.js";
+export interface InlineTextSession {
+    readonly binding: TextEditBinding;
+    readonly bindingChoices: readonly TextBindingChoice[];
+    readonly selectedBindingIndex: number | null;
+    readonly scope: TextProjectionScope;
+    readonly scopeChoices: readonly TextProjectionScope[];
+    readonly host: HTMLElement;
+    readonly before: string;
+    chooseBinding(index: number): void;
+    chooseScope(scope: TextProjectionScope): void;
+    commit(reason?: InlineTextSessionEndReason): ChangeRecord | null;
+    cancel(reason?: InlineTextSessionEndReason): void;
+}
+export interface InlineTextEditor {
+    begin(element: HTMLElement, point?: {
+        x: number;
+        y: number;
+    }): InlineTextSession | TextEditRejection;
+}
+export type InlineTextInteractionDisposition = "pass-through" | "stop-propagation" | "suppress";
+export type InlineTextSessionEndReason = "start" | "commit" | "cancel" | "blur" | "route-disposed" | "frame-disposed" | "app-reconciled" | "selection-removed" | "host-removed";
+export type InlineTextInputRejectionReason = "cross-host-range" | "rich-input" | "paragraph-input" | "multiline-paste" | "invalid-input-type" | "clipboard-unavailable" | "invalid-selection";
+export interface InlineTextDiagnostic {
+    kind: "inline-text";
+    status: "started" | "committed" | "cancelled" | "rejected";
+    reason: InlineTextSessionEndReason | InlineTextInputRejectionReason;
+    before: string;
+    after?: string;
+}
+export declare function getInlineTextDiagnostics(): readonly InlineTextDiagnostic[];
+export declare function getInlineTextDiagnostic(): InlineTextDiagnostic | null;
+export declare function subscribeInlineTextDiagnostics(listener: () => void): () => void;
+export declare function getInlineTextSession(): InlineTextSession | null;
+export declare function useInlineTextSession(): InlineTextSession | null;
+export declare function isInlineTextEditingActive(): boolean;
+export declare function cancelInlineTextEdit(): void;
+/** End a session owned by a document/frame that is about to be disposed. */
+export declare function disposeInlineTextEdit(reason?: "frame-disposed" | "route-disposed", ownerDocument?: Document): void;
+export type InlineTextEditIntent = {
+    kind: "pointer-down";
+    target: Element;
+    point: {
+        x: number;
+        y: number;
+    };
+    clickCount: number;
+} | {
+    kind: "double-click";
+    target: Element;
+    point: {
+        x: number;
+        y: number;
+    };
+};
+/**
+ * Handle one native interaction while keeping session-transition policy
+ * local. Pointer-down preserves double-click intent across the first click's
+ * blur commit, even when canonical projection replaces the target DOM.
+ */
+export declare function handleInlineTextEditIntent(intent: InlineTextEditIntent): InlineTextInteractionDisposition;
+export declare const inlineTextEditor: InlineTextEditor;
+/** Re-enter an existing canonical rendered-text projection through its empty
+ * inspector affordance. This never guesses a new DOM target or source node. */
+export declare function beginInlineTextEditFromEmptyProjection(marker: HTMLElement): InlineTextSession | TextEditRejection;
+export declare function beginInlineTextEdit(element: HTMLElement, point?: {
+    x: number;
+    y: number;
+}): InlineTextSession | TextEditRejection;
+export { resolveTextBinding } from "../componentSemantics/textBinding.js";