nudge-ui 0.2.0

package/dist/inspector/changes/managedStyleProjection.js

@@ -0,0 +1,109 @@
+import { verifyPreview } from "../projection/managedStylesheet.js";
+import { getSelectedElement } from "../selection/selectionStore.js";
+import { instanceSelector } from "../projection/renderedInstance.js";
+import { selectorForInteractionState } from "../shell/styleState.js";
+import { isComponentChange, isTextContentChange, isTokenChange, } from "./types.js";
+import { tokenReference } from "./model.js";
+function requestedStyleValue(change) {
+    if (isTokenChange(change))
+        return change.rawValue;
+    if (change.newToken)
+        return tokenReference(change.newToken);
+    return change.rawValue ?? "";
+}
+function projectedStyleValue(change) {
+    const value = requestedStyleValue(change);
+    return isTokenChange(change) && change.important && !/!\s*important\s*$/i.test(value)
+        ? `${value} !important`
+        : value;
+}
+function ruleKey(change) {
+    const context = isTokenChange(change) ? JSON.stringify(change.context) : "";
+    return `${selectorForManagedChange(change) ?? change.selector}\u0000${change.property}\u0000${context}`;
+}
+/** The source selector stays canonical; the projection marker is document-local. */
+export function selectorForManagedChange(change) {
+    if (!isTokenChange(change) && change.scope === "rendered-instance") {
+        if (!change.instanceOverride)
+            return null;
+        const selector = instanceSelector(change.instanceOverride);
+        return selector ? selectorForInteractionState(selector, change.state ?? "base") : null;
+    }
+    return change.selector;
+}
+export function buildManagedStyleRules(changes) {
+    const sourceRules = new Map();
+    const instanceRules = new Map();
+    for (const change of changes) {
+        if (isComponentChange(change) || isTextContentChange(change))
+            continue;
+        const value = projectedStyleValue(change);
+        if (!value)
+            continue;
+        const selector = selectorForManagedChange(change);
+        if (!selector)
+            continue;
+        const key = ruleKey(change);
+        const map = !isTokenChange(change) && change.scope === "rendered-instance"
+            ? instanceRules
+            : sourceRules;
+        const existing = map.get(key);
+        if (existing) {
+            existing.declarations[change.property] = value;
+        }
+        else {
+            map.set(key, {
+                selector,
+                declarations: { [change.property]: value },
+                context: isTokenChange(change) ? change.context : undefined,
+            });
+        }
+    }
+    // Source-site rules remain the default; exact rendered-instance rules are
+    // emitted afterwards so their additional marker specificity wins.
+    return [...sourceRules.values(), ...instanceRules.values()];
+}
+export function verifyManagedStyleProjection(change, selectedElement) {
+    // Deferred verification must use the selection that existed when the
+    // projection was committed. Reading the live selection here can make a
+    // host-document change verify against a later canvas selection (or vice
+    // versa) and manufacture a conflict for the wrong document.
+    const selected = selectedElement === undefined
+        ? getSelectedElement()?.domElement ?? null
+        : selectedElement;
+    const requestedValue = requestedStyleValue(change);
+    // A Canvas-only selection belongs to an iframe. The controller stylesheet
+    // cannot verify it synchronously; leave its result unknown until the frame
+    // has received the canonical projection rather than claiming it is stale.
+    if (selected && selected.ownerDocument !== document) {
+        return null;
+    }
+    let targets = [];
+    try {
+        const selector = selectorForManagedChange(change);
+        targets = selector ? Array.from(document.querySelectorAll(selector)) : [];
+    }
+    catch {
+        targets = [];
+    }
+    // Probe targets lazily in DOM order and stop at the first conflicting
+    // preview: the reported result is exactly "first conflict ?? first target",
+    // so probing the remaining instances cannot change the outcome. A
+    // source-site selector matched by many rendered instances (one callsite,
+    // hundreds of nodes) otherwise pays a probe + important-rule scan per match.
+    let firstApplied = null;
+    let previewResult = null;
+    for (const target of targets) {
+        const result = verifyPreview(target, change.property, requestedValue);
+        if (result.status === "conflict") {
+            previewResult = result;
+            break;
+        }
+        if (!firstApplied)
+            firstApplied = result;
+    }
+    if (previewResult === null) {
+        previewResult = firstApplied ?? verifyPreview(null, change.property, requestedValue);
+    }
+    return previewResult;
+}

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

@@ -0,0 +1,13 @@
+import type { TokenEntry } from "../../css/model/index.js";
+import { type ChangeRecord } from "./types.js";
+/**
+ * The CSS value a token swap writes into the managed stylesheet and the
+ * prompt must describe: an adapter-provided literal when present, otherwise a
+ * var() reference on the authored cssName (falling back to the entry name).
+ */
+export declare function tokenReference(token: TokenEntry): string;
+export declare function changeKey(change: ChangeRecord): string;
+export declare function mergeChange(current: ChangeRecord[], incoming: ChangeRecord): ChangeRecord[];
+export declare function canonicalizeChanges(incoming: ChangeRecord[]): ChangeRecord[];
+export declare function sameEffectiveChanges(left: ChangeRecord[], right: ChangeRecord[]): boolean;
+export declare function selectorForChange(change: ChangeRecord): string | undefined;

package/dist/inspector/changes/model.js

@@ -0,0 +1,163 @@
+import { isComponentChange, isElementChange, isTextContentChange, isTokenChange, } from "./types.js";
+/**
+ * The CSS value a token swap writes into the managed stylesheet and the
+ * prompt must describe: an adapter-provided literal when present, otherwise a
+ * var() reference on the authored cssName (falling back to the entry name).
+ */
+export function tokenReference(token) {
+    return token.cssValue ?? `var(${token.cssName ?? token.name})`;
+}
+export function changeKey(change) {
+    if (isTokenChange(change)) {
+        return [
+            "token",
+            change.tokenName,
+            change.file,
+            change.line,
+            change.selector,
+            JSON.stringify(change.context),
+        ].join("\u0000");
+    }
+    if (isComponentChange(change)) {
+        return [
+            "component-prop",
+            change.target.framework,
+            change.target.callsiteId,
+            change.property,
+        ].join("\u0000");
+    }
+    if (isTextContentChange(change)) {
+        // The marker id is document-local projection identity. `beforeText` is
+        // part of the durable evidence: two outputs at one source site may have
+        // different initial copy and must remain distinct canonical intents.
+        return [
+            "text-content",
+            change.target.sourceSite.cid,
+            change.target.sourceSite.src,
+            change.target.props ?? "",
+            change.target.ariaLabel ?? "",
+            change.target.beforeText,
+            change.target.textNodePath?.join(",") ?? "",
+        ].join("\u0000");
+    }
+    return [
+        change.cid,
+        change.file,
+        change.line,
+        change.scope === "rendered-instance"
+            ? change.instanceOverride?.id ?? "missing-instance-override"
+            : change.selector,
+        change.scope ?? "source-site",
+        change.state ?? "base",
+        change.property,
+    ].join("\u0000");
+}
+function effectiveValue(change) {
+    if (isTokenChange(change))
+        return change.rawValue;
+    if (isComponentChange(change))
+        return JSON.stringify(change.after);
+    if (isTextContentChange(change))
+        return change.after;
+    if (change.newToken)
+        return tokenReference(change.newToken);
+    return change.rawValue ?? "";
+}
+function isAtBaseline(change) {
+    if (isTokenChange(change))
+        return change.rawValue === change.oldRawValue;
+    if (isComponentChange(change)) {
+        return change.before.kind === "value"
+            && Object.is(change.after, change.before.value);
+    }
+    if (isTextContentChange(change))
+        return change.after === change.before;
+    const baseline = change.oldToken
+        ? tokenReference(change.oldToken)
+        : change.oldRawValue ?? "";
+    return effectiveValue(change) === baseline;
+}
+function mergeWithExisting(incoming, existing) {
+    if (existing && isTokenChange(incoming) && isTokenChange(existing)) {
+        return { ...incoming, oldRawValue: existing.oldRawValue };
+    }
+    if (existing && isComponentChange(incoming) && isComponentChange(existing)) {
+        return {
+            ...incoming,
+            before: existing.before,
+            scope: incoming.scope ?? existing.scope,
+            evidence: incoming.evidence ?? existing.evidence,
+        };
+    }
+    if (existing && isTextContentChange(incoming) && isTextContentChange(existing)) {
+        return {
+            ...incoming,
+            id: existing.id,
+            target: existing.target,
+            source: existing.source,
+            selector: existing.selector,
+            before: existing.before,
+            authoredAs: existing.authoredAs,
+            scope: incoming.scope ?? existing.scope,
+            evidence: incoming.evidence ?? existing.evidence,
+        };
+    }
+    if (existing && isElementChange(incoming) && isElementChange(existing)) {
+        return {
+            ...incoming,
+            oldToken: existing.oldToken,
+            oldRawValue: existing.oldRawValue,
+        };
+    }
+    return incoming;
+}
+function textStableIdentity(change) {
+    if (!isTextContentChange(change))
+        return null;
+    return [
+        change.target.sourceSite.cid,
+        change.target.sourceSite.src,
+        change.target.props ?? "",
+        change.target.ariaLabel ?? "",
+        change.target.textNodePath?.join(",") ?? "",
+    ].join("\u0000");
+}
+function compatibleTextExisting(current, incoming) {
+    if (!isTextContentChange(incoming))
+        return undefined;
+    const exact = current.filter((candidate) => changeKey(candidate) === changeKey(incoming));
+    if (exact.length === 1)
+        return exact[0];
+    if (exact.length > 1)
+        return undefined;
+    const identity = textStableIdentity(incoming);
+    const compatible = current.filter((candidate) => isTextContentChange(candidate)
+        && textStableIdentity(candidate) === identity
+        && incoming.before === candidate.after);
+    return compatible.length === 1 ? compatible[0] : undefined;
+}
+export function mergeChange(current, incoming) {
+    const key = changeKey(incoming);
+    const existing = isTextContentChange(incoming)
+        ? compatibleTextExisting(current, incoming)
+        : current.find((candidate) => changeKey(candidate) === key);
+    const canonical = mergeWithExisting(incoming, existing);
+    const next = existing
+        ? current.filter((candidate) => candidate !== existing)
+        : isTextContentChange(incoming)
+            ? current
+            : current.filter((candidate) => changeKey(candidate) !== key);
+    return isAtBaseline(canonical) ? next : [...next, canonical];
+}
+export function canonicalizeChanges(incoming) {
+    return incoming.reduce((current, change) => mergeChange(current, change), []);
+}
+export function sameEffectiveChanges(left, right) {
+    if (left.length !== right.length)
+        return false;
+    const values = new Map(left.map((change) => [changeKey(change), effectiveValue(change)]));
+    return right.every((change) => values.get(changeKey(change)) === effectiveValue(change));
+}
+export function selectorForChange(change) {
+    return isComponentChange(change) || isTextContentChange(change) ? undefined : change.selector;
+}

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

@@ -0,0 +1,14 @@
+import { type ChangeRecord } from "./types.js";
+import type { EditScope } from "../editScope.js";
+export interface ChangePresentation {
+    groupKey: string;
+    groupLabel: string;
+    file: string;
+    property: string;
+    propertyLabel: string;
+    before: string;
+    after: string;
+    scope?: EditScope;
+    evidence?: string;
+}
+export declare function presentChange(change: ChangeRecord): ChangePresentation;

package/dist/inspector/changes/presentation.js

@@ -0,0 +1,81 @@
+import { formatComponentPropBaseline, formatComponentPropValue, } from "../componentSemantics/changeModel.js";
+import { isComponentChange, isTokenChange, isTextContentChange, } from "./types.js";
+import { formatInspectorLabel } from "../ui/labels.js";
+export function presentChange(change) {
+    if (isTokenChange(change)) {
+        return {
+            groupKey: [
+                "token",
+                change.tokenName,
+                change.file,
+                change.line,
+                change.contextLabel,
+            ].join("\u0000"),
+            groupLabel: `Global token · ${change.tokenName}`,
+            file: change.file,
+            property: change.property,
+            propertyLabel: change.contextLabel,
+            before: change.oldRawValue,
+            after: change.rawValue,
+        };
+    }
+    if (isComponentChange(change)) {
+        return {
+            groupKey: [
+                "component-prop",
+                change.target.framework,
+                change.target.callsiteId,
+            ].join("\u0000"),
+            groupLabel: `${change.target.componentName} · Component`,
+            file: change.target.file,
+            property: change.property,
+            propertyLabel: formatInspectorLabel(change.property),
+            before: formatComponentPropBaseline(change.before),
+            after: formatComponentPropValue(change.after),
+            scope: change.scope ?? "source-site",
+            evidence: change.evidence
+                ? `occurrence ${change.evidence.occurrence + 1} · ${change.evidence.mountedCount} mounted outputs`
+                : undefined,
+        };
+    }
+    if (isTextContentChange(change)) {
+        return {
+            groupKey: [
+                "text-content",
+                change.target.sourceSite.cid,
+                change.target.sourceSite.src,
+                change.target.occurrence,
+                change.target.props ?? "",
+                change.target.ariaLabel ?? "",
+            ].join("\u0000"),
+            groupLabel: `${change.source.component || change.target.sourceSite.cid} · Rendered text`,
+            file: change.source.file,
+            property: "text-content",
+            propertyLabel: "Rendered text",
+            before: change.before,
+            after: change.after,
+            scope: change.scope ?? "rendered-instance",
+            evidence: change.evidence
+                ? `${change.evidence.componentName}.${change.evidence.property} · ${change.evidence.mountedCount} mounted outputs`
+                : undefined,
+        };
+    }
+    return {
+        groupKey: [
+            change.cid,
+            change.file,
+            change.line,
+            change.selector,
+            change.scope ?? "source-site",
+        ].join("\u0000"),
+        groupLabel: change.cid,
+        file: change.file,
+        property: change.property,
+        propertyLabel: formatInspectorLabel(change.property),
+        before: change.oldToken?.name
+            ?? (change.rawValue !== undefined && change.newToken
+                ? change.rawValue
+                : "(original)"),
+        after: change.newToken?.name ?? change.rawValue ?? "",
+    };
+}

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

@@ -0,0 +1,39 @@
+import type { PreviewResult } from "../projection/managedStylesheet.js";
+/** A logical document is stable while its live document may be replaced. */
+export interface PreviewDocument {
+    readonly logicalDocument: string;
+    readonly sessionId: string;
+}
+export interface PreviewAttempt extends PreviewDocument {
+    readonly workspaceRevision: number;
+    readonly attempt: number;
+}
+export interface PreviewDiagnostic extends PreviewAttempt {
+    readonly changeKey: string;
+    readonly result: PreviewResult;
+}
+/** Returns the stable host-document identity for this inspector lifetime. */
+export declare function getHostPreviewDocument(): PreviewDocument;
+/** Starts or replaces the live session for one logical document. */
+export declare function startPreviewDocumentSession(document: PreviewDocument): void;
+/** Invalidates a live document session and rejects all of its late results. */
+export declare function invalidatePreviewDocumentSession(logicalDocument: string, sessionId?: string): void;
+/** Opens a verification attempt for the currently active document session. */
+export declare function beginPreviewAttempt(document: PreviewDocument, revision?: number): PreviewAttempt | null;
+/** Publishes only a result from the active revision, session, and attempt. */
+export declare function publishPreviewDiagnostic(attempt: PreviewAttempt, changeKey: string, result: PreviewResult): boolean;
+/** Removes diagnostics for the supplied canonical keys across live documents. */
+export declare function clearPreviewDiagnostics(changeKeys?: Iterable<string>): void;
+/** Notifies consumers when verification state changes without a result. */
+export declare function notifyPreviewDiagnostics(): void;
+export declare function getPreviewDiagnostic(changeKey: string, logicalDocument?: string): PreviewDiagnostic | undefined;
+/**
+ * Host-first read across live documents. The per-document store is observable
+ * here so a Canvas-only conflict is not write-only; host remains the default
+ * for single-document consumers.
+ */
+export declare function getAnyPreviewDiagnostic(changeKey: string): PreviewDiagnostic | undefined;
+export declare function subscribePreviewDiagnostics(listener: () => void): () => void;
+export declare function getPreviewDiagnosticRevision(): number;
+/** Test and teardown reset; it does not alter canonical workspace state. */
+export declare function resetPreviewDiagnostics(): void;

package/dist/inspector/changes/previewDiagnostics.js

@@ -0,0 +1,172 @@
+import { getWorkspaceChanges, subscribeWorkspaceChanges } from "./workspaceChanges.js";
+const HOST_DOCUMENT = {
+    logicalDocument: "host",
+    sessionId: "host-document",
+};
+let workspaceRevision = getWorkspaceChanges().revision;
+let activeSessions = new Map([[HOST_DOCUMENT.logicalDocument, HOST_DOCUMENT.sessionId]]);
+let attemptsBySession = new Map();
+let diagnostics = new Map();
+let diagnosticRevision = 0;
+const listeners = new Set();
+function storageKey(document, changeKey) {
+    return `${document.logicalDocument}\u0000${document.sessionId}\u0000${changeKey}`;
+}
+function sessionKey(document) {
+    return `${document.logicalDocument}\u0000${document.sessionId}`;
+}
+function sameResult(left, right) {
+    return left.status === right.status
+        && left.reason === right.reason
+        && left.requestedValue === right.requestedValue
+        && left.computedValue === right.computedValue;
+}
+function notify() {
+    diagnosticRevision += 1;
+    for (const listener of listeners)
+        listener();
+}
+function syncWorkspaceRevision() {
+    const nextRevision = getWorkspaceChanges().revision;
+    if (nextRevision === workspaceRevision)
+        return;
+    // Track the revision so late publishes are rejected per key. Do not clear
+    // here: a new commit must preserve earlier diagnostics until they are
+    // re-verified, otherwise every edit deletes every other change's status.
+    workspaceRevision = nextRevision;
+}
+subscribeWorkspaceChanges(syncWorkspaceRevision);
+/** Returns the stable host-document identity for this inspector lifetime. */
+export function getHostPreviewDocument() {
+    return HOST_DOCUMENT;
+}
+/** Starts or replaces the live session for one logical document. */
+export function startPreviewDocumentSession(document) {
+    syncWorkspaceRevision();
+    const previousSession = activeSessions.get(document.logicalDocument);
+    if (previousSession === document.sessionId)
+        return;
+    activeSessions.set(document.logicalDocument, document.sessionId);
+    attemptsBySession.set(sessionKey(document), 0);
+    let changed = false;
+    for (const [key, diagnostic] of diagnostics) {
+        if (diagnostic.logicalDocument === document.logicalDocument) {
+            diagnostics.delete(key);
+            changed = true;
+        }
+    }
+    if (changed || previousSession !== undefined)
+        notify();
+}
+/** Invalidates a live document session and rejects all of its late results. */
+export function invalidatePreviewDocumentSession(logicalDocument, sessionId) {
+    const activeSession = activeSessions.get(logicalDocument);
+    if (activeSession === undefined || (sessionId !== undefined && activeSession !== sessionId))
+        return;
+    activeSessions.delete(logicalDocument);
+    attemptsBySession.delete(sessionKey({ logicalDocument, sessionId: activeSession }));
+    let changed = false;
+    for (const [key, diagnostic] of diagnostics) {
+        if (diagnostic.logicalDocument === logicalDocument && diagnostic.sessionId === activeSession) {
+            diagnostics.delete(key);
+            changed = true;
+        }
+    }
+    if (changed || activeSession !== undefined)
+        notify();
+}
+/** Opens a verification attempt for the currently active document session. */
+export function beginPreviewAttempt(document, revision = getWorkspaceChanges().revision) {
+    syncWorkspaceRevision();
+    if (revision !== workspaceRevision || activeSessions.get(document.logicalDocument) !== document.sessionId) {
+        return null;
+    }
+    const attempt = (attemptsBySession.get(sessionKey(document)) ?? 0) + 1;
+    attemptsBySession.set(sessionKey(document), attempt);
+    // Do not delete existing diagnostics here. The attempt stamp already
+    // rejects late publishes per key; wiping would drop every other change's
+    // status before it is re-verified (and drop all host status when Canvas
+    // verification returns null).
+    return { ...document, workspaceRevision: revision, attempt };
+}
+/** Publishes only a result from the active revision, session, and attempt. */
+export function publishPreviewDiagnostic(attempt, changeKey, result) {
+    syncWorkspaceRevision();
+    if (attempt.workspaceRevision !== workspaceRevision
+        || activeSessions.get(attempt.logicalDocument) !== attempt.sessionId
+        || attemptsBySession.get(sessionKey(attempt)) !== attempt.attempt) {
+        return false;
+    }
+    const key = storageKey(attempt, changeKey);
+    const previous = diagnostics.get(key);
+    if (previous
+        && previous.changeKey === changeKey
+        && previous.workspaceRevision === attempt.workspaceRevision
+        && previous.attempt === attempt.attempt
+        && sameResult(previous.result, result)) {
+        return true;
+    }
+    diagnostics.set(key, { ...attempt, changeKey, result });
+    notify();
+    return true;
+}
+/** Removes diagnostics for the supplied canonical keys across live documents. */
+export function clearPreviewDiagnostics(changeKeys) {
+    const keys = changeKeys ? new Set(changeKeys) : null;
+    let changed = false;
+    for (const [key, diagnostic] of diagnostics) {
+        if (!keys || keys.has(diagnostic.changeKey)) {
+            diagnostics.delete(key);
+            changed = true;
+        }
+    }
+    if (changed)
+        notify();
+}
+/** Notifies consumers when verification state changes without a result. */
+export function notifyPreviewDiagnostics() {
+    notify();
+}
+export function getPreviewDiagnostic(changeKey, logicalDocument = HOST_DOCUMENT.logicalDocument) {
+    // Pure getter: never sync or notify. It runs on the React render path via
+    // StaleChangeIndicator, so side effects here would clear state mid-render.
+    // Diagnostics survive workspace revisions until overwritten or explicitly
+    // cleared; publish-time stamps reject stale results per key.
+    const sessionId = activeSessions.get(logicalDocument);
+    if (!sessionId)
+        return undefined;
+    return diagnostics.get(storageKey({ logicalDocument, sessionId }, changeKey));
+}
+/**
+ * Host-first read across live documents. The per-document store is observable
+ * here so a Canvas-only conflict is not write-only; host remains the default
+ * for single-document consumers.
+ */
+export function getAnyPreviewDiagnostic(changeKey) {
+    const host = getPreviewDiagnostic(changeKey, HOST_DOCUMENT.logicalDocument);
+    if (host)
+        return host;
+    for (const logicalDocument of activeSessions.keys()) {
+        if (logicalDocument === HOST_DOCUMENT.logicalDocument)
+            continue;
+        const diagnostic = getPreviewDiagnostic(changeKey, logicalDocument);
+        if (diagnostic)
+            return diagnostic;
+    }
+    return undefined;
+}
+export function subscribePreviewDiagnostics(listener) {
+    listeners.add(listener);
+    return () => listeners.delete(listener);
+}
+export function getPreviewDiagnosticRevision() {
+    return diagnosticRevision;
+}
+/** Test and teardown reset; it does not alter canonical workspace state. */
+export function resetPreviewDiagnostics() {
+    workspaceRevision = getWorkspaceChanges().revision;
+    activeSessions = new Map([[HOST_DOCUMENT.logicalDocument, HOST_DOCUMENT.sessionId]]);
+    attemptsBySession = new Map();
+    diagnostics = new Map();
+    notify();
+}

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

@@ -0,0 +1,35 @@
+import type { RenderedInstanceRef } from "./editModel.js";
+/** Controller-owned intent to remove one rendered instance. */
+export interface StructuralDelete {
+    id: string;
+    kind: "delete";
+    target: RenderedInstanceRef;
+}
+/** Controller-owned intent to move one rendered instance. */
+export interface StructuralMove {
+    id: string;
+    kind: "move";
+    target: RenderedInstanceRef;
+    source: {
+        parent: RenderedInstanceRef;
+    };
+    destination: {
+        parent: RenderedInstanceRef;
+        before: RenderedInstanceRef | null;
+    };
+    presentation: {
+        sourceParentTag: string;
+        destinationParentTag: string;
+        fromIndex: number;
+        toIndex: number;
+    };
+}
+export type StructuralChange = StructuralDelete | StructuralMove;
+export type StructuralProjectionStatus = "applied" | "missing" | "ambiguous" | "overridden";
+export type StructuralProjectionReason = "target" | "source-parent" | "destination-parent" | "anchor" | "illegal-destination" | "react-override";
+export interface StructuralProjectionReport {
+    changeId: string;
+    status: StructuralProjectionStatus;
+    /** Bounded diagnostic data; it never changes canonical structural intent. */
+    reason?: StructuralProjectionReason;
+}

package/dist/inspector/changes/structuralTypes.js

@@ -0,0 +1 @@
+export {};