nudge-ui 0.2.0

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

@@ -0,0 +1,2 @@
+export declare function registerInlineTextClearHandler(handler: () => void): () => void;
+export declare function cancelInlineTextForClear(): void;

package/dist/inspector/inline-text/inlineTextLifecycle.js

@@ -0,0 +1,17 @@
+/**
+ * A tiny lifecycle seam keeps canonical-history clearing independent from the
+ * editor implementation. The editor registers its active-session disposer;
+ * changesLog can then cancel it without importing the editor back through a
+ * circular module edge.
+ */
+let clearHandler = null;
+export function registerInlineTextClearHandler(handler) {
+    clearHandler = handler;
+    return () => {
+        if (clearHandler === handler)
+            clearHandler = null;
+    };
+}
+export function cancelInlineTextForClear() {
+    clearHandler?.();
+}

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

@@ -0,0 +1,6 @@
+/**
+ * Compatibility seam for the former inline-text model owner. The shared
+ * vocabulary and guards now live in `changes/editModel.ts`.
+ */
+export type { TextBindingEvidence, TextContentChangeRecord, TextProjectionScope, TextProjectionSourceSite, TextProjectionTarget, } from "../changes/editModel.js";
+export { isTextContentChangeListValue, isTextContentChangeValue, isTextProjectionTargetValue, } from "../changes/editModel.js";

package/dist/inspector/inline-text/textChangeBoundary.js

@@ -0,0 +1 @@
+export { isTextContentChangeListValue, isTextContentChangeValue, isTextProjectionTargetValue, } from "../changes/editModel.js";

package/dist/inspector/inspection/bridge.d.ts

@@ -0,0 +1,72 @@
+import type { TokenDefinition, TokenEntry } from "../../css/model/index.js";
+import { getChangesList, getPendingRules } from "../changes/changesLog.js";
+import type { InspectorProjection } from "../spacing/projection.js";
+import type { ResolvedProperty } from "../../css/model/index.js";
+export declare const NUDGE_UI_INSPECTION_VERSION: 1;
+export interface InspectionCatalogEntry {
+    name: string;
+    cssName: string;
+    adapter?: string;
+    origin?: TokenEntry["origin"];
+    editable?: boolean;
+    declarations: Array<{
+        value: string;
+        source: string;
+        important: boolean;
+        context: TokenDefinition["declarations"][number]["context"];
+    }>;
+}
+export interface InspectionControl {
+    property: string;
+    kind: "token" | "raw";
+    activeToken: string | null;
+    suggestions: string[];
+}
+export interface ElementInspection {
+    version: typeof NUDGE_UI_INSPECTION_VERSION;
+    identity: {
+        cid: string | null;
+        src: string;
+        file: string;
+        line: number;
+        column: number;
+    };
+    catalog: InspectionCatalogEntry[];
+    availableTokens: TokenEntry[];
+    properties: ResolvedProperty[];
+    projection: InspectorProjection;
+    controls: InspectionControl[];
+    changes: ReturnType<typeof getChangesList>;
+    managedPreview: {
+        rules: ReturnType<typeof getPendingRules>;
+        results: Array<{
+            property: string;
+            requestedValue: string;
+            computedValue: string;
+            status: "applied" | "conflict";
+            reason?: string;
+        }>;
+    };
+    prompt: string | null;
+}
+export interface InspectElementOptions {
+    catalog?: readonly TokenDefinition[];
+    tokens?: readonly TokenEntry[];
+}
+/**
+ * Returns the inspector's stable, read-only facts for one rendered element.
+ * Compatibility tests and the React UI cross the same resolver/projection seam;
+ * this function deliberately performs no selection or edit side effects.
+ */
+export declare function inspectElement(element: HTMLElement, options?: InspectElementOptions): ElementInspection;
+export interface NudgeUiInspectionBridge {
+    version: typeof NUDGE_UI_INSPECTION_VERSION;
+    inspect(selector: string): ElementInspection | null;
+}
+declare global {
+    interface Window {
+        __nudgeUi?: NudgeUiInspectionBridge;
+    }
+}
+/** Installs the dev-only browser seam used by compatibility applications. */
+export declare function installInspectionBridge(target?: Window): () => void;

package/dist/inspector/inspection/bridge.js

@@ -0,0 +1,134 @@
+import { getChangesList, getPendingRules, isPreviewableChange } from "../changes/changesLog.js";
+import { changeKey } from "../changes/model.js";
+import { getAnyPreviewDiagnostic } from "../changes/previewDiagnostics.js";
+import { detectFramework } from "../prompt/detectFramework.js";
+import { generatePrompt } from "../prompt/generatePrompt.js";
+import { loadCustomInstructions } from "../prompt/promptSettings.js";
+import { resolveSelectionFromElement } from "../selection/resolveSelection.js";
+import { projectInspectorValues } from "../spacing/projection.js";
+import { selectTokens } from "../../css/value-semantics/index.js";
+import { createBrowserCssInspection } from "./browserCssInspection.js";
+import { getBrowserCssInspection } from "./browserCssInspectionRegistry.js";
+import { getNudgeUiRuntimeConfig } from "../runtime/runtimeConfig.js";
+export const NUDGE_UI_INSPECTION_VERSION = 1;
+function inspectBrowserFacts(element, definitions, entries) {
+    const doc = element.ownerDocument ?? document;
+    if (definitions === getNudgeUiRuntimeConfig().tokenCatalog && entries === undefined) {
+        const session = getBrowserCssInspection(doc);
+        return {
+            element: session.inspect(element, { cascade: "live" }),
+            tokens: session.inspectTokens(element),
+        };
+    }
+    // Compatibility callers may provide a fixture-local catalog. Keep that
+    // Adapter isolated from the document registry so one caller cannot replace
+    // the token knowledge used by the live inspector session.
+    const session = createBrowserCssInspection({
+        document: doc,
+        tokenKnowledge: { definitions, entries, generation: "compatibility" },
+    });
+    try {
+        return {
+            element: session.inspect(element, { cascade: "live" }),
+            tokens: session.inspectTokens(element),
+        };
+    }
+    finally {
+        session.dispose();
+    }
+}
+function catalogEntry(definition) {
+    return {
+        name: definition.name,
+        cssName: definition.cssName,
+        adapter: definition.adapter,
+        origin: definition.origin,
+        editable: definition.editable,
+        declarations: definition.declarations.map((declaration) => ({
+            value: declaration.value,
+            source: declaration.source,
+            important: declaration.important,
+            context: declaration.context,
+        })),
+    };
+}
+/**
+ * Returns the inspector's stable, read-only facts for one rendered element.
+ * Compatibility tests and the React UI cross the same resolver/projection seam;
+ * this function deliberately performs no selection or edit side effects.
+ */
+export function inspectElement(element, options = {}) {
+    const runtimeConfig = getNudgeUiRuntimeConfig();
+    const definitions = options.catalog ?? runtimeConfig.tokenCatalog;
+    const frameworkHints = options.tokens
+        ? detectFramework(options.tokens)
+        : {
+            framework: runtimeConfig.framework,
+            stylingSystem: runtimeConfig.stylingSystem,
+        };
+    const browserFacts = inspectBrowserFacts(element, definitions, options.tokens);
+    const availableTokens = options.tokens ? [...options.tokens] : [...browserFacts.element.availableTokens];
+    const properties = [...browserFacts.element.properties];
+    const selection = resolveSelectionFromElement(element);
+    const changes = getChangesList();
+    const customInstructions = loadCustomInstructions(runtimeConfig.projectId);
+    const managedPreview = {
+        rules: getPendingRules(),
+        results: changes.flatMap((change) => {
+            if (!isPreviewableChange(change))
+                return [];
+            const diagnostic = getAnyPreviewDiagnostic(changeKey(change));
+            return diagnostic ? [{ property: change.property, ...diagnostic.result }] : [];
+        }),
+    };
+    // Local vanilla-extract themes attach contract variables to a theme class,
+    // not necessarily :root. The selected element is therefore the correct
+    // availability context for an element inspection.
+    const controls = properties
+        .filter((property) => !property.property.startsWith("--"))
+        .map((property) => ({
+        property: property.property,
+        kind: property.tokenName ? "token" : "raw",
+        activeToken: property.tokenName,
+        suggestions: Array.from(new Set(selectTokens({
+            property: property.property,
+            entries: availableTokens,
+            currentToken: property.tokenName,
+        }).candidates.map((candidate) => candidate.entry.name))),
+    }));
+    return {
+        version: NUDGE_UI_INSPECTION_VERSION,
+        identity: {
+            cid: selection?.cid ?? element.getAttribute("data-cid"),
+            src: selection?.src ?? element.getAttribute("data-src") ?? "",
+            file: selection?.file ?? "",
+            line: selection?.line ?? 0,
+            column: selection?.column ?? 0,
+        },
+        catalog: browserFacts.tokens.tokens.map((row) => catalogEntry(row.definition)),
+        availableTokens,
+        properties,
+        projection: projectInspectorValues(element, properties),
+        controls,
+        changes,
+        managedPreview,
+        prompt: changes.length > 0
+            ? generatePrompt(changes, frameworkHints, [], customInstructions)
+            : null,
+    };
+}
+/** Installs the dev-only browser seam used by compatibility applications. */
+export function installInspectionBridge(target = window) {
+    const bridge = {
+        version: NUDGE_UI_INSPECTION_VERSION,
+        inspect(selector) {
+            const element = target.document.querySelector(selector);
+            return element instanceof HTMLElement ? inspectElement(element) : null;
+        },
+    };
+    target.__nudgeUi = bridge;
+    return () => {
+        if (target.__nudgeUi === bridge)
+            delete target.__nudgeUi;
+    };
+}

package/dist/inspector/inspection/browserCssInspection.d.ts

@@ -0,0 +1,74 @@
+import type { TokenDefinition, TokenEntry } from "../../css/model/index.js";
+import type { ResolvedProperty } from "../../css/model/index.js";
+import type { InteractionState } from "../shell/styleState.js";
+import { type TokenCatalogRow } from "../tokens/catalog.js";
+export interface BrowserTokenKnowledge {
+    /** Build-time definitions normalized by a build-tool Adapter. */
+    definitions: readonly TokenDefinition[];
+    /** Optional compiler entries used to resolve authored references that are
+     * intentionally not mounted as custom properties in the current document. */
+    entries?: readonly TokenEntry[];
+    /** Changes whenever the Adapter publishes a new token inventory. */
+    generation: string | number;
+}
+export interface BrowserCssInspectionConfig {
+    document: Document;
+    tokenKnowledge: BrowserTokenKnowledge;
+}
+/**
+ * Cascade transform owned exclusively by this module:
+ * - authored: interaction-state attribution (default; state defaults to base)
+ * - live: raw CSSOM matching as currently painted
+ * - stable: drops transient pseudo-class rules for editor token linking
+ */
+export type InspectionCascade = "authored" | "live" | "stable";
+export interface BrowserCssInspectionOptions {
+    state?: InteractionState;
+    cascade?: InspectionCascade;
+}
+export type InspectionTargetStatus = "attached" | "detached" | "foreign-document" | "unsupported" | "disabled" | "disposed";
+export type InspectionDiagnosticCode = "target-document-mismatch" | "target-detached" | "target-unsupported" | "state-unavailable" | "inspection-failed" | "production-disabled" | "session-disposed";
+export interface InspectionDiagnostic {
+    code: InspectionDiagnosticCode;
+    message: string;
+}
+export interface InspectionRevision {
+    element: number;
+    stylesheet: number;
+    tokenGeneration: string | number;
+}
+export interface InspectionSnapshot {
+    target: {
+        status: InspectionTargetStatus;
+    };
+    cascade: InspectionCascade;
+    requestedState: InteractionState;
+    authoredState: InteractionState;
+    /** Computed values describe what the browser is currently painting. */
+    paintedState: "current";
+    properties: readonly ResolvedProperty[];
+    availableTokens: readonly TokenEntry[];
+    availableStates: readonly InteractionState[];
+    revision: InspectionRevision;
+    diagnostics: readonly InspectionDiagnostic[];
+}
+export interface DocumentTokenInspectionSnapshot {
+    /** Complete authored inventory supplied by the build-tool Adapter. */
+    inventory: readonly TokenCatalogRow[];
+    /** Tokens currently available below the inspected document root. */
+    tokens: readonly TokenCatalogRow[];
+    revision: InspectionRevision;
+    diagnostics: readonly InspectionDiagnostic[];
+}
+export interface BrowserCssInspection {
+    inspect(element: HTMLElement, options?: BrowserCssInspectionOptions): InspectionSnapshot;
+    inspectTokens(root?: HTMLElement): DocumentTokenInspectionSnapshot;
+    subscribe(listener: (revision: InspectionRevision) => void): () => void;
+    /** Integration hook for managed CSSOM writes. */
+    notifyStylesheetChange(): void;
+    /** Optional: warms the CSSOM rule snapshot so the next inspect does not pay
+     * the stylesheet walk inside its own budget. Cheap when already warm. */
+    prewarmRules?(): void;
+    dispose(): void;
+}
+export declare function createBrowserCssInspection(config: BrowserCssInspectionConfig): BrowserCssInspection;

package/dist/inspector/inspection/browserCssInspection.js

@@ -0,0 +1,317 @@
+import { isNudgeUiDev } from "../runtime/devFlag.js";
+import { buildTokenTable, getAvailableInteractionStates, getAvailableTokenCatalog, getAvailableTokenEntriesForElement, getResolvedProperties, getResolvedPropertiesForState, getResolvedPropertiesStable, invalidateStyleResolutionCache, prewarmCssomRuleSnapshot, } from "../tokens/resolution.js";
+import { buildTokenCatalogRows } from "../tokens/catalog.js";
+import { documentRevisions, registerResolutionElement, retainDocumentResolution, subscribeDocumentRevision, } from "../tokens/resolution/cssomCollector.js";
+function revisionSnapshot(revisions, tokenGeneration) {
+    return {
+        element: revisions.element,
+        stylesheet: revisions.stylesheet,
+        tokenGeneration,
+    };
+}
+function targetStatus(element, doc) {
+    if (element.ownerDocument !== doc)
+        return "foreign-document";
+    const HTMLElementConstructor = doc.defaultView?.HTMLElement;
+    if (HTMLElementConstructor && !(element instanceof HTMLElementConstructor))
+        return "unsupported";
+    return element.isConnected ? "attached" : "detached";
+}
+function targetDiagnostic(status) {
+    if (status === "foreign-document") {
+        return {
+            code: "target-document-mismatch",
+            message: "The inspected element belongs to a different document than this session.",
+        };
+    }
+    if (status === "unsupported") {
+        return {
+            code: "target-unsupported",
+            message: "Browser CSS inspection currently supports HTMLElement targets only.",
+        };
+    }
+    if (status === "detached") {
+        return {
+            code: "target-detached",
+            message: "The inspected element is detached; browser evidence may be incomplete.",
+        };
+    }
+    return null;
+}
+function emptySnapshot(status, cascade, state, revision, diagnostics) {
+    return {
+        target: { status },
+        cascade,
+        requestedState: state,
+        authoredState: cascade === "authored" ? state : "base",
+        paintedState: "current",
+        properties: [],
+        availableTokens: [],
+        availableStates: ["base"],
+        revision,
+        diagnostics,
+    };
+}
+function cloneProperties(properties) {
+    return properties.map((property) => ({
+        ...property,
+        tokens: property.tokens?.map((token) => ({ ...token })),
+        modifiers: property.modifiers?.map((modifier) => ({ ...modifier })),
+        opacity: property.opacity ? { ...property.opacity, token: property.opacity.token && { ...property.opacity.token } } : undefined,
+        color: property.color && { ...property.color },
+        structure: property.structure && { ...property.structure },
+        atRules: property.atRules?.map((atRule) => ({ ...atRule })),
+        atRuleCandidates: property.atRuleCandidates?.map((candidate) => ({ ...candidate })),
+        evidence: { ...property.evidence },
+    }));
+}
+function cloneEntries(entries) {
+    return entries.map((entry) => ({ ...entry }));
+}
+function cloneCatalogRows(rows) {
+    return rows.map((row) => {
+        const activeIndex = row.activeDeclaration
+            ? row.definition.declarations.indexOf(row.activeDeclaration)
+            : -1;
+        const definition = {
+            ...row.definition,
+            declarations: row.definition.declarations.map((declaration) => ({
+                ...declaration,
+                context: {
+                    ...declaration.context,
+                    wrappers: declaration.context.wrappers?.map((wrapper) => ({ ...wrapper })),
+                },
+            })),
+        };
+        return {
+            ...row,
+            definition,
+            activeDeclaration: activeIndex >= 0 ? definition.declarations[activeIndex] ?? null : null,
+            styleContext: {
+                ...row.styleContext,
+                wrappers: row.styleContext.wrappers?.map((wrapper) => ({ ...wrapper })),
+            },
+        };
+    });
+}
+function disabledInspection(config) {
+    const revision = {
+        element: 0,
+        stylesheet: 0,
+        tokenGeneration: config.tokenKnowledge.generation,
+    };
+    const diagnostics = [{
+            code: "production-disabled",
+            message: "Browser CSS inspection is disabled outside development.",
+        }];
+    return {
+        inspect(_element, options = {}) {
+            return emptySnapshot("disabled", options.cascade ?? "authored", options.state ?? "base", revision, diagnostics);
+        },
+        inspectTokens() {
+            return { inventory: [], tokens: [], revision, diagnostics };
+        },
+        subscribe() { return () => undefined; },
+        notifyStylesheetChange() { },
+        dispose() { },
+    };
+}
+function notifyRevision(listener, revisions, tokenGeneration) {
+    listener(revisionSnapshot(revisions, tokenGeneration));
+}
+function resolveCascadeProperties(element, table, cascade, state) {
+    if (cascade === "live")
+        return getResolvedProperties(element, table);
+    if (cascade === "stable")
+        return getResolvedPropertiesStable(element, table);
+    return getResolvedPropertiesForState(element, table, state);
+}
+export function createBrowserCssInspection(config) {
+    if (!isNudgeUiDev())
+        return disabledInspection(config);
+    const definitions = [...config.tokenKnowledge.definitions];
+    const knowledgeEntries = [...(config.tokenKnowledge.entries ?? [])];
+    const tokenGeneration = config.tokenKnowledge.generation;
+    let disposed = false;
+    const releaseDocumentResolution = retainDocumentResolution(config.document);
+    const revisionUnsubscribers = new Set();
+    const elementTables = new WeakMap();
+    // When compiler entries are merged ahead of runtime availability, keep one
+    // table per availableTokens identity so resolver caches stay warm.
+    const mergedTables = new WeakMap();
+    const mediaCleanup = [];
+    const mediaQueries = new Set(definitions.flatMap((definition) => definition.declarations.flatMap((declaration) => (declaration.context.wrappers ?? [])
+        .filter((wrapper) => wrapper.kind === "media")
+        .map((wrapper) => wrapper.params))));
+    const ownerWindow = config.document.defaultView;
+    if (ownerWindow && typeof ownerWindow.matchMedia === "function") {
+        for (const query of mediaQueries) {
+            const media = ownerWindow.matchMedia(query);
+            const onChange = () => {
+                if (!disposed)
+                    invalidateStyleResolutionCache(config.document);
+            };
+            if (typeof media.addEventListener === "function") {
+                media.addEventListener("change", onChange);
+                mediaCleanup.push(() => media.removeEventListener("change", onChange));
+            }
+            else if (typeof media.addListener === "function") {
+                media.addListener(onChange);
+                mediaCleanup.push(() => media.removeListener(onChange));
+            }
+        }
+    }
+    const currentRevision = () => revisionSnapshot(documentRevisions(config.document), tokenGeneration);
+    function tokenTableFor(element) {
+        const availableTokens = getAvailableTokenEntriesForElement(element, definitions);
+        const revisions = documentRevisions(config.document);
+        const cached = elementTables.get(element);
+        if (cached
+            && cached.elementRevision === revisions.element
+            && cached.stylesheetRevision === revisions.stylesheet
+            && cached.availableTokens === availableTokens) {
+            return { availableTokens: cached.availableTokens, table: cached.table };
+        }
+        let table;
+        if (knowledgeEntries.length === 0) {
+            // Same array identity as the availability cache → buildTokenTable hits.
+            table = buildTokenTable(availableTokens);
+        }
+        else {
+            const merged = mergedTables.get(availableTokens);
+            if (merged) {
+                table = merged;
+            }
+            else {
+                table = buildTokenTable([...knowledgeEntries, ...availableTokens]);
+                mergedTables.set(availableTokens, table);
+            }
+        }
+        elementTables.set(element, {
+            elementRevision: revisions.element,
+            stylesheetRevision: revisions.stylesheet,
+            availableTokens,
+            table,
+        });
+        return { availableTokens, table };
+    }
+    const session = {
+        inspect(element, options = {}) {
+            const state = options.state ?? "base";
+            const cascade = options.cascade ?? "authored";
+            const status = disposed ? "disposed" : targetStatus(element, config.document);
+            const diagnostics = [];
+            if (disposed)
+                diagnostics.push({ code: "session-disposed", message: "This inspection session has been disposed." });
+            else {
+                const diagnostic = targetDiagnostic(status);
+                if (diagnostic)
+                    diagnostics.push(diagnostic);
+            }
+            const revision = currentRevision();
+            if (status !== "attached" && status !== "detached") {
+                return emptySnapshot(status, cascade, state, revision, diagnostics);
+            }
+            try {
+                const { availableTokens, table } = tokenTableFor(element);
+                // Only the authored cascade reports which interaction states have
+                // authored rules (the panel's state selector reads it there). Stable
+                // and live consumers project properties only, so skip the O(rules)
+                // per-state matching sweep for them.
+                const availableStates = cascade === "stable"
+                    ? ["base"]
+                    : getAvailableInteractionStates(element);
+                if (cascade === "authored" && state !== "base" && !availableStates.includes(state)) {
+                    diagnostics.push({
+                        code: "state-unavailable",
+                        message: `The ${state} interaction state has no matching authored rule for this element.`,
+                    });
+                }
+                const properties = resolveCascadeProperties(element, table, cascade, state);
+                return {
+                    target: { status },
+                    cascade,
+                    requestedState: state,
+                    authoredState: cascade === "authored" ? state : "base",
+                    paintedState: "current",
+                    properties: cloneProperties(properties),
+                    availableTokens: cloneEntries(availableTokens),
+                    availableStates: [...availableStates],
+                    revision,
+                    diagnostics,
+                };
+            }
+            catch (error) {
+                diagnostics.push({
+                    code: "inspection-failed",
+                    message: error instanceof Error ? error.message : "Browser CSS inspection failed.",
+                });
+                return emptySnapshot(status, cascade, state, revision, diagnostics);
+            }
+        },
+        inspectTokens(root = config.document.documentElement) {
+            const diagnostics = [];
+            const revision = currentRevision();
+            if (disposed) {
+                diagnostics.push({ code: "session-disposed", message: "This inspection session has been disposed." });
+                return { inventory: [], tokens: [], revision, diagnostics };
+            }
+            if (root.ownerDocument !== config.document) {
+                diagnostics.push({
+                    code: "target-document-mismatch",
+                    message: "The token inspection root belongs to a different document than this session.",
+                });
+                return { inventory: [], tokens: [], revision, diagnostics };
+            }
+            try {
+                registerResolutionElement(root);
+                const catalog = getAvailableTokenCatalog(root, definitions);
+                return {
+                    inventory: cloneCatalogRows(buildTokenCatalogRows(definitions, root)),
+                    tokens: cloneCatalogRows(buildTokenCatalogRows(catalog, root)),
+                    revision,
+                    diagnostics,
+                };
+            }
+            catch (error) {
+                diagnostics.push({
+                    code: "inspection-failed",
+                    message: error instanceof Error ? error.message : "Browser token inspection failed.",
+                });
+                return { inventory: [], tokens: [], revision, diagnostics };
+            }
+        },
+        subscribe(listener) {
+            if (disposed)
+                return () => undefined;
+            const unsubscribe = subscribeDocumentRevision(config.document, (revisions) => {
+                if (!disposed)
+                    notifyRevision(listener, revisions, tokenGeneration);
+            });
+            revisionUnsubscribers.add(unsubscribe);
+            return () => {
+                unsubscribe();
+                revisionUnsubscribers.delete(unsubscribe);
+            };
+        },
+        notifyStylesheetChange() {
+            if (!disposed)
+                invalidateStyleResolutionCache(config.document);
+        },
+        prewarmRules() {
+            if (!disposed)
+                prewarmCssomRuleSnapshot(config.document);
+        },
+        dispose() {
+            if (disposed)
+                return;
+            disposed = true;
+            revisionUnsubscribers.forEach((unsubscribe) => unsubscribe());
+            revisionUnsubscribers.clear();
+            mediaCleanup.forEach((cleanup) => cleanup());
+            mediaCleanup.length = 0;
+            releaseDocumentResolution();
+        },
+    };
+    return session;
+}

package/dist/inspector/inspection/browserCssInspectionRegistry.d.ts

@@ -0,0 +1,12 @@
+import { type BrowserCssInspection, type BrowserTokenKnowledge } from "./browserCssInspection.js";
+/**
+ * Binds a document to token knowledge. When generation changes, the previous
+ * session is disposed and replaced so callers never keep a stale catalog.
+ */
+export declare function bindBrowserCssInspection(doc: Document, knowledge: BrowserTokenKnowledge): BrowserCssInspection;
+/** Returns the one browser inspection session owned by a document. */
+export declare function getBrowserCssInspection(doc?: Document): BrowserCssInspection;
+/** Invalidates every browser-inspection snapshot affected by a CSSOM write. */
+export declare function notifyBrowserStylesheetChange(doc?: Document): void;
+/** Releases a document session when its inspector/Canvas lifecycle ends. */
+export declare function disposeBrowserCssInspection(doc: Document): void;