@fiddle-digital/string-tune 1.1.54 → 1.2.0

package/dist/index.d.mts

@@ -407,6 +407,22 @@ declare class EventManager {
     clearAll(): void;
 }
 
+type StringTokenModeSpec = {
+    kind: "default";
+    values: [];
+} | {
+    kind: "all";
+    values: [];
+} | {
+    kind: "include";
+    values: ScrollMode[];
+};
+interface StringToken {
+    raw: string;
+    key: string;
+    modeSpec: StringTokenModeSpec;
+}
+
 type MirrorEasingFn = (value: number) => number;
 /**
  * Lightweight wrapper that mirrors a primary StringObject while keeping
@@ -448,38 +464,18 @@ declare class StringObject {
      * Space-separated list of all attribute keys associated with this object.
      */
     keys: string[];
+    tokens: StringToken[];
     /**
      * Mirror objects linked via `string-copy-from`.
      */
     private mirrors;
+    private _cachedMirrorObjects;
+    private _cachedConnects;
+    private _mirrorsDirty;
     /**
      * Internal key-value store of dynamic object properties (like offsets, progress, etc.).
      */
     private properties;
-    private eventNameCache;
-    private eventNameSuffixCache;
-    /**
-     * Direct properties for extremely hot, per-frame accessed metrics
-     * to avoid going through the Map and incurring overhead.
-     */
-    progress: number;
-    progressRaw: number;
-    startPosition: number;
-    differencePosition: number;
-    transformValue: {
-        transform: string;
-    } | null;
-    eventProgressName: string | null;
-    lerp: number;
-    glide: number;
-    isMagneting: boolean;
-    magneticX: number;
-    magneticY: number;
-    magneticTargetX: number;
-    magneticTargetY: number;
-    eventLerpName: string | null;
-    eventGlideName: string | null;
-    eventMagneticName: string | null;
     /**
      * Modules currently connected to this object.
      */
@@ -489,6 +485,8 @@ declare class StringObject {
      * Provides functionality to register, trigger, and manage event listeners.
      */
     events: EventManager;
+    private eventNameCache;
+    private eventNameSuffixCache;
     constructor(id: string, element: HTMLElement);
     /**
      * Returns a cached event name in one of these forms:
@@ -526,6 +524,8 @@ declare class StringObject {
     remove(): void;
     setInviewAutoBlocked(blocked: boolean): void;
     isInviewAutoBlocked(): boolean;
+    setInviewManualActive(active: boolean): void;
+    isInviewManualActive(): boolean;
     syncInviewClass(): void;
     /**
      * Shows the object, applies visual class and notifies connected modules.
@@ -540,6 +540,11 @@ declare class StringObject {
      * @param module - The module to connect
      */
     connect(module: IStringModule): boolean;
+    disconnect(module: IStringModule): boolean;
+    isConnectedTo(module: IStringModule): boolean;
+    setTokens(tokens: StringToken[]): void;
+    getToken(key: string): StringToken | null;
+    private updateMirrorsCache;
     addMirror(mirror: StringMirrorObject): void;
     removeMirror(id: string): void;
     get mirrorObjects(): StringMirrorObject[];
@@ -1062,6 +1067,7 @@ interface ISplitOptionItem {
  */
 interface ISplitOptions {
     fit?: boolean;
+    trimInlineGaps?: boolean;
     line?: ISplitOptionItem[];
     word?: ISplitOptionItem[];
     char?: ISplitOptionItem[];
@@ -1238,6 +1244,12 @@ type AttributeMapping = {
     transform?: (value: any) => any;
 };
 
+interface ParseContext {
+    element?: HTMLElement;
+    boundingRect?: DOMRect;
+    viewportHeight?: number;
+    baseRem?: number;
+}
 /**
  * Base class for a module used in the string-tune system.
  * Extend this class to create custom modules that respond to scroll, resize, input, etc.
@@ -1265,23 +1277,28 @@ declare class StringModule implements IStringModule {
      * This map is used to manage and track `StringObject` instances on a page.
      */
     protected objectMapOnPage: Map<string, StringObject>;
+    protected allObjectMapOnPage: Map<string, StringObject>;
     /**
      * A protected array that holds the collection of `StringObject` instances
      * currently present on the page.
      */
     protected objectsOnPage: StringObject[];
+    protected allObjectsOnPage: StringObject[];
     /**
      * A map of all entered objects by their unique ID.
      */
     protected objectMap: Map<string, StringObject>;
+    protected allObjectMap: Map<string, StringObject>;
     /**
      * A flat array of all connected objects.
      */
     protected objects: StringObject[];
+    protected allObjects: StringObject[];
     /**
      * The HTML attribute key that identifies objects this module is responsible for.
      */
     protected htmlKey: string;
+    protected defaultModeScope: "all" | ScrollMode[];
     /**
      * Module type ID used internally to categorize module behavior.
      */
@@ -1291,6 +1308,7 @@ declare class StringModule implements IStringModule {
      * Type 1 = core module, type 2 = UI module.
      */
     get type(): number;
+    get key(): string;
     /**
      * Tools container providing utilities for attribute parsing, unit conversion, etc.
      * Acts as a dependency injection hub for core IStringTool implementations.
@@ -1365,12 +1383,7 @@ declare class StringModule implements IStringModule {
      * @param context Optional helper values like element or viewport size.
      * @returns The parsed and transformed value.
      */
-    protected parseAttribute(value: string | null, type: AttributeType, context?: {
-        element?: HTMLElement;
-        boundingRect?: DOMRect;
-        viewportHeight?: number;
-        baseRem?: number;
-    }): any;
+    protected parseAttribute(value: string | null, type: AttributeType, context?: ParseContext): any;
     /**
      * Determines whether the module should attach to a given object,
      * based on the presence of the module's `htmlKey` in the object keys.
@@ -1379,6 +1392,9 @@ declare class StringModule implements IStringModule {
      * @returns `true` if the module can connect, `false` otherwise.
      */
     canConnect(object: StringObject): boolean;
+    protected isTokenEnabledInCurrentMode(token: StringToken): boolean;
+    protected isObjectEnabledInCurrentMode(object: StringObject): boolean;
+    disconnectObject(object: StringObject): void;
     /**
      * Registers the module on a given object, adds the object to internal list,
      * and triggers connection logic.
@@ -1390,6 +1406,7 @@ declare class StringModule implements IStringModule {
      * Registers the object internally when it enters the module’s scope.
      */
     enterObject(id: string, object: StringObject): void;
+    protected fastRemoveFromArray<T>(array: T[], index: number): void;
     /**
      * Unregisters the object when it leaves the module’s scope.
      */
@@ -1428,6 +1445,8 @@ declare class StringModule implements IStringModule {
      * @param object The disconnected object.
      */
     onObjectDisconnected(object: StringObject): void;
+    protected get respectSelfDisable(): boolean;
+    protected isPrimaryElementEnabled(object: StringObject): boolean;
     /**
      * Applies a style or callback to both the main element and all its connected elements.
      *
@@ -1455,6 +1474,10 @@ declare class StringModule implements IStringModule {
      * Returns a cached per-object event name to avoid building strings in hot paths.
      */
     protected getObjectEventName(object: StringObject, prefix: string, suffix?: string): string;
+    protected clearManagedStyles(object: StringObject): void;
+    protected onObjectModeActivated(object: StringObject): void;
+    protected onObjectModeDeactivated(object: StringObject): void;
+    protected rebuildActiveObjectsForCurrentMode(): void;
     /**
      * Cleans up internal state and detaches the module from the system.
      */
@@ -1572,6 +1595,8 @@ declare class ObjectManager {
     add(el: HTMLElement): void;
     setDOMBatcherEnabled(enabled: boolean): void;
     setIntersectionObserverEnabled(enabled: boolean): void;
+    attachModule(module: StringModule): void;
+    refreshModuleConnectionsForCurrentMode(): void;
     invalidateInviewIndex(): void;
     refreshLayoutForRoot(root: HTMLElement): void;
     /**
@@ -1642,6 +1667,8 @@ declare class ObjectManager {
     private rebuildInviewIndex;
     private upperBound;
     private splitPipeAndTrim;
+    private parseStringTokens;
+    private splitTopLevelPipe;
     destroy(): void;
 }
 
@@ -1890,6 +1917,7 @@ declare class StringAnchor extends StringModule {
  * to create a smooth scrolling effect for objects.
  */
 declare class StringGlide extends StringModule {
+    protected defaultModeScope: string[];
     private previousLerp;
     private displacement;
     private acceleration;
@@ -1902,9 +1930,8 @@ declare class StringGlide extends StringModule {
     constructor(context: StringContext);
     initializeObject(globalId: number, object: StringObject, element: HTMLElement, attributes: Record<string, any>): void;
     private setupItem;
-    private onUpdateDesktopEvent;
-    private onUpdateMobileEvent;
-    private onUpdateEvent;
+    private updateTransforms;
+    private resetObjectStyles;
     private calcExpanderFactor;
     onStart(): void;
     onResize(): void;
@@ -1912,7 +1939,9 @@ declare class StringGlide extends StringModule {
     onScrollStart(): void;
     onScrollStop(): void;
     onFrame(data: StringData): void;
+    protected onObjectModeDeactivated(object: StringObject): void;
     onMutate(): void;
+    private applyPendingGlideStylesForObject;
     private applyPendingGlideStyles;
     private flushPendingGlideStyles;
 }
@@ -1923,6 +1952,7 @@ declare class StringGlide extends StringModule {
  */
 declare class StringLerp extends StringModule {
     private hasInitializedCSS;
+    protected defaultModeScope: string[];
     constructor(context: StringContext);
     /**
      * Initialize lerp value when object connects.
@@ -1986,6 +2016,7 @@ declare class StringProgress extends StringModule {
  * necessary transformations based on scroll progress and viewport size.
  */
 declare class StringParallax extends StringProgress {
+    protected defaultModeScope: string[];
     private updateScheduledTransform;
     private calculateParallaxForObject;
     constructor(context: StringContext);
@@ -1995,11 +2026,9 @@ declare class StringParallax extends StringProgress {
     initializeObject(globalId: number, object: StringObject, element: HTMLElement, attributes: Record<string, any>): void;
     calculatePositions(object: StringObject, windowSize: number): void;
     onScroll(data: StringData): void;
-    onResize(): void;
     onScrollMeasure(data: StringData): void;
     onMutate(): void;
-    private calculateDesktopParallax;
-    private calculateMobileParallax;
+    private calculateParallax;
 }
 
 declare class StringScrollbar extends StringModule {
@@ -2035,11 +2064,31 @@ declare class StringScrollbar extends StringModule {
  * computes alignment/random values, and applies CSS vars.
  */
 declare class StringSplit extends StringModule {
+    /** Last content-width (px) at which each element was split. Keyed by element itself. */
+    private lastSplitWidth;
     constructor(context: StringContext);
     onInit(): void;
+    onObjectDisconnected(object: StringObject): void;
     onResizeWidth(): void;
     onObjectConnected(object: StringObject): void;
-    split(element: HTMLElement, options: ISplitOptions): {
+    private extractTextContent;
+    private getSplitOptions;
+    private hasLineDrivenSplit;
+    private needsWidthRebuild;
+    private needsForcedRebuildOnFontLoad;
+    private getDebugStoreKey;
+    private writeDebugRecord;
+    private isDebugEnabled;
+    private getDebugLabel;
+    private logConnectionStart;
+    private captureBaselineSnapshot;
+    private logSplitAnalysis;
+    private getTokenDebugText;
+    private logRenderedState;
+    private applyFlexLineBreaks;
+    private getBlockContainerContentWidth;
+    private getElementContentWidth;
+    split(element: HTMLElement, options: ISplitOptions, debugEnabled?: boolean): {
         fragment: DocumentFragment;
         result: DocumentFragment;
         extraProps: Map<string, string>;
@@ -2573,104 +2622,36 @@ declare class StringRandom extends StringModule {
     onObjectConnected(object: StringObject): void;
 }
 
-/**
- * Base class for managing scroll behavior in the system.
- * Handles abstract scroll state and updates, intended for extension.
- */
 declare class ScrollController {
-    /** Shared context containing data and tools */
     protected context: StringContext;
-    /** Reference to the document object */
     protected document: Document;
-    /** Name of the scroll mode (e.g. 'default', 'smooth', etc.) */
     name: string;
-    /** Whether the system is in programmatic scroll mode */
     isProg: boolean;
-    /** Whether parallax-related logic should be active */
     isParallaxEnabled: boolean;
-    /** Scroll direction: vertical or horizontal */
-    protected _scrollDirection: "vertical" | "horizontal";
-    /**
-     * Current scroll direction.
-     * - `true` — scrolling down
-     * - `false` — scrolling up
-     * - `null` — unknown (initial state)
-     */
-    protected isBottomScrollDirection: boolean | null;
+    protected _isVertical: boolean;
+    protected _scrollDirState: number;
+    protected _lastAppliedDirState: number;
     protected isLastBottomScrollDirection: boolean;
     protected scrollTriggerRules: Array<ScrollMarkRule>;
-    /** Tracks whether this controller is currently active */
     protected isActive: boolean;
-    /** Last direction applied to DOM classes (for global-class toggles) */
-    protected lastAppliedDirection: boolean | null;
-    /**
-     * Sets scroll direction and updates internal scroll logic.
-     * @param scrollDirection Either 'vertical' or 'horizontal'.
-     */
-    set scrollDirection(scrollDirection: "vertical" | "horizontal");
-    /**
-     * Creates a new ScrollController instance.
-     * @param context Shared context containing data and settings.
-     */
+    set scrollDirection(dir: "vertical" | "horizontal");
     constructor(context: StringContext);
-    /**
-     * Called when scroll direction changes (up ↔ down).
-     * Override this callback in subclasses or instances.
-     */
     onChangeDirection: () => void;
-    /**
-     * Called when scroll starts (user input).
-     * Override this callback in subclasses or instances.
-     */
     onScrollStart: () => void;
-    /**
-     * Called when scroll ends.
-     * Override this callback in subclasses or instances.
-     */
     onScrollStop: () => void;
-    /**
-     * Scroll-to function called on each frame.
-     * This will be reassigned depending on scroll direction.
-     */
-    onCalcUpdate: () => void;
-    /**
-     * Called every animation frame.
-     * Intended to be overridden in subclasses.
-     */
+    onCalcUpdate(): void;
     onFrame(): void;
-    /**
-     * Called when wheel event is fired.
-     * Override to implement custom scroll interaction.
-     * @param e Wheel event.
-     */
     onWheel(e: any): void;
-    /**
-     * Called when native scroll event is fired.
-     * Override to track native scroll position.
-     * @param e Scroll event.
-     */
     onScroll(e: any): void;
+    onTouchStart(e: TouchEvent): void;
+    onTouchMove(e: TouchEvent): void;
+    onTouchEnd(e: TouchEvent): void;
     disableScrollEvents(): void;
     enableScrollEvents(): void;
-    /**
-     * Called when this controller becomes the active scroll engine.
-     * Ensures event bindings are attached only once.
-     */
     activate(): void;
-    /**
-     * Called when this controller is deactivated.
-     * Ensures event bindings are detached only once.
-     */
     deactivate(): void;
-    /**
-     * Allows controllers to clean up resources on global destroy.
-     */
     destroy(): void;
-    /**
-     * Updates scroll direction state, emits events, and toggles global classes.
-     * Intended for reuse by custom scroll adapters.
-     */
-    protected updateScrollDirection(newDirection: boolean): void;
+    protected updateScrollDirection(isDown: boolean): void;
     protected clearScrollingClasses(): void;
     protected triggerScrollRules(): void;
     addScrollMark(rule: ScrollMarkRule): void;
@@ -2678,12 +2659,257 @@ declare class ScrollController {
     scrollTo(position: number, immediate?: boolean): void;
 }
 
+interface StringDevtoolState {
+    active: boolean;
+}
+interface StringDevtoolHotkey {
+    key: string;
+    shiftKey?: boolean;
+    ctrlKey?: boolean;
+    altKey?: boolean;
+    metaKey?: boolean;
+}
+interface StringDevtoolSubBadge {
+    id: string;
+    icon: string;
+    label: string;
+    /** Extra attribute used as a CSS selector hook (e.g. "data-string-grid-global-toggle"). */
+    selectorAttribute?: string;
+    /** Additional data-* attributes applied to the badge button. */
+    attributes?: Record<string, string | boolean | number | null | undefined>;
+    onClick: (anchorElement?: HTMLElement) => void;
+}
+interface StringDevtoolDefinition {
+    id: string;
+    label: string;
+    icon: string;
+    order?: number;
+    group?: number;
+    hotkey?: StringDevtoolHotkey;
+    subBadges?: StringDevtoolSubBadge[];
+    getState: () => StringDevtoolState;
+    setActive: (active: boolean) => void;
+    subscribe?: (listener: (state: StringDevtoolState) => void) => () => void;
+}
+interface StringDevtoolProvider {
+    getDevtoolDefinition(): StringDevtoolDefinition | null;
+}
+
+declare class StringDevViewportLayer {
+    private readonly id;
+    private readonly zIndex;
+    private screenRoot;
+    private world;
+    private screen;
+    private worldHost;
+    private hostPositionWasPatched;
+    private hostPositionInlineValue;
+    constructor(id: string, zIndex: number);
+    ensure(host?: HTMLElement | null): HTMLDivElement;
+    getElement(): HTMLDivElement | null;
+    getWorldElement(host?: HTMLElement | null): HTMLDivElement;
+    getScreenElement(): HTMLDivElement;
+    destroy(): void;
+    private attachWorldToHost;
+    private restoreHostPosition;
+}
+
+declare class StringDevOverlayRegistry {
+    private static instance;
+    private readonly layers;
+    static getInstance(): StringDevOverlayRegistry;
+    acquire(id: string, zIndex: number): StringDevViewportLayer;
+    release(id: string): void;
+}
+
+interface StringDevModuleDefinitionConfig {
+    id: string;
+    label: string;
+    icon: string;
+    order?: number;
+    group?: number;
+    hotkey?: StringDevtoolHotkey;
+}
+interface StringDevConnectsConfig {
+    /** If true, connects to every StringObject (overlay default). If false, only explicit matches below + dev-inspect fallback. */
+    global?: boolean;
+    /** Connect to objects whose string="…" token list includes any of these keys. */
+    keys?: string[];
+    /** Connect to objects whose DOM element has any of these attributes present. */
+    attributes?: string[];
+}
+interface StringDevOverlayConfig {
+    /** Unique layer name, e.g. "devtools-progress" */
+    layerName: string;
+    /** Z-index for the viewport layer */
+    zIndex: number;
+    /** Data-attribute added to the layer root, e.g. "data-string-progress-layer" */
+    layerAttribute?: string;
+    /** Overlay ID used for the anchor/collision system. Omit if not needed. */
+    overlayId?: string;
+    /** Whether the overlay starts enabled before dock preferences apply. Default: false */
+    defaultEnabled?: boolean;
+    /** For badge overlay modules: data-attribute placed on each badge element */
+    badgeAttribute?: string;
+}
+interface StringDevModuleConfig extends StringDevModuleDefinitionConfig {
+    /** Declare CSS styles to inject once. Can be a string or a lazy getter. */
+    styles?: string | (() => string);
+    /** Overlay layer configuration. Declare for any module that uses a viewport layer. */
+    overlay?: StringDevOverlayConfig;
+    /** Declare which StringObjects this module connects to. Replaces htmlKey assignment in constructor. */
+    connects?: StringDevConnectsConfig;
+}
+declare class StringDevModule extends StringModule implements StringDevtoolProvider {
+    /** Declare module metadata statically. Subclasses override this. */
+    static devtool: StringDevModuleConfig | null;
+    protected readonly overlayRegistry: StringDevOverlayRegistry;
+    private readonly acquiredViewportLayers;
+    private readonly devtoolListeners;
+    private hotkeyHandler;
+    protected devtoolConfig: StringDevModuleDefinitionConfig | null;
+    constructor(context: StringContext);
+    protected get respectSelfDisable(): boolean;
+    protected get connectsConfig(): StringDevConnectsConfig | undefined;
+    canConnect(object: StringObject): boolean;
+    protected getStyleScopeId(stylesText: string): string;
+    protected getStyles(): string | null;
+    getDevtoolDefinition(): StringDevtoolDefinition | null;
+    protected getDevtoolSubBadges(): StringDevtoolSubBadge[];
+    protected configureDevtool(config: StringDevModuleDefinitionConfig): void;
+    protected bindDevtoolHotkey(hotkey?: StringDevtoolHotkey): void;
+    protected emitDevtoolState(active?: boolean): void;
+    protected acquireViewportLayer(id: string, zIndex: number): StringDevViewportLayer;
+    protected releaseViewportLayer(id: string): void;
+    protected ensureStyle(styleId: string, cssText: string): HTMLStyleElement;
+    protected getWorldHost(): HTMLElement;
+    protected getDevtoolActiveState(): boolean;
+    protected setDevtoolActiveState(_active: boolean): void;
+    destroy(): void;
+}
+
+declare function buildGridCSS(): string;
+
+/**
+ * StringDevLayout — developer utility module for layout overlays.
+ *
+ * Usage:
+ *   <div string="layout">...</div>
+ *
+ * No configuration attributes needed. All configuration happens
+ * through the interactive HUD panel (hover top-right corner).
+ *
+ * Supports multiple grid types via the adapter pattern:
+ * - Columns, Rows, Center
+ * - Rule of Thirds, Phi Grid, Golden Rectangle, Harmonic Armature
+ * - Extensible via `st.use(StringDevLayout, { adapters: [MyAdapter] })`
+ */
+declare class StringDevLayout extends StringDevModule {
+    private gridManager;
+    private viewportLayer;
+    private overlayLayer;
+    private overlays;
+    private huds;
+    private elementMap;
+    private triggerEntries;
+    private triggerMeasurements;
+    private enabled;
+    private needsMeasure;
+    private hasPendingMutate;
+    private globalHost;
+    private globalOverlay;
+    private globalHUD;
+    private globalSubBadge;
+    static devtool: {
+        id: string;
+        label: string;
+        icon: string;
+        order: number;
+        group: number;
+        hotkey: {
+            key: string;
+            shiftKey: boolean;
+        };
+        styles: typeof buildGridCSS;
+        connects: {
+            global: boolean;
+            keys: string[];
+        };
+    };
+    constructor(context: StringContext);
+    onInit(): void;
+    protected getDevtoolSubBadges(): StringDevtoolSubBadge[];
+    onObjectConnected(object: StringObject): void;
+    onObjectDisconnected(object: StringObject): void;
+    onResize(): void;
+    onScroll(): void;
+    onScrollMeasure(): void;
+    onMutate(): void;
+    onDOMRebuild(): void;
+    destroy(): void;
+    setEnabled(enabled: boolean): void;
+    isEnabled(): boolean;
+    protected getDevtoolActiveState(): boolean;
+    protected setDevtoolActiveState(active: boolean): void;
+    private handleAdd;
+    private handleRemove;
+    private handleToggle;
+    private handleSettingChange;
+    private handleReorder;
+    private handleMoveToEnd;
+    private handleSelectLayout;
+    private handleUpdateLayoutMinWidth;
+    private handleAddLayout;
+    private handleRemoveLayout;
+    private handleRenameInstance;
+    private handleRenamePanelTitle;
+    private handleHUDOpen;
+    private handleHUDClose;
+    private handleLayoutPanelOpen;
+    private handleLayoutPanelClose;
+    private handleExport;
+    private handleImport;
+    private renderElement;
+    private syncToResolved;
+    private syncSelectedLayoutToViewport;
+    private refreshHUD;
+    private ensureGlobalGrid;
+    private syncGlobalHostSize;
+    private renderGlobal;
+    private refreshGlobalHUD;
+    private toggleGlobalPanel;
+    private syncGlobalSubBadgeState;
+    private positionGlobalHudAtAnchor;
+    private destroyGlobalGrid;
+    private destroyElement;
+    private ensureTriggerLayer;
+    private applyTriggerLayerState;
+    private scheduleTriggerSync;
+    private collectTriggerMeasurements;
+    private measureTrigger;
+    private applyTriggerMeasurement;
+    protected getWorldHost(): HTMLElement;
+    private getObjectDocY;
+    private getViewportScrollLeft;
+    private getViewportScrollTop;
+    private resolveTriggerStackOffset;
+    private registerBuiltInAdapters;
+    private registerExternalAdapters;
+}
+
 /**
  * Discriminated union of all UI field descriptors.
  * Each devtool module returns an array of these to describe its settings panel.
  */
 type StringDevUIFieldDescriptor = StringDevUIFieldNumber | StringDevUIFieldRange | StringDevUIFieldColor | StringDevUIFieldSelect | StringDevUIFieldToggle | StringDevUIFieldDivider;
-interface StringDevUIFieldNumber {
+interface StringDevUIFieldDisabledWhen {
+    readonly key: string;
+    readonly equals: string | number | boolean;
+}
+interface StringDevUIFieldBase {
+    readonly disabledWhen?: StringDevUIFieldDisabledWhen;
+}
+interface StringDevUIFieldNumber extends StringDevUIFieldBase {
     readonly type: "number";
     readonly key: string;
     readonly label: string;
@@ -2692,7 +2918,7 @@ interface StringDevUIFieldNumber {
     readonly max?: number;
     readonly step?: number;
 }
-interface StringDevUIFieldRange {
+interface StringDevUIFieldRange extends StringDevUIFieldBase {
     readonly type: "range";
     readonly key: string;
     readonly label: string;
@@ -2700,6 +2926,12 @@ interface StringDevUIFieldRange {
     readonly min: number;
     readonly max: number;
     readonly step?: number;
+    /** Multiplies the stored value for display/editing in the UI. */
+    readonly displayMultiplier?: number;
+    /** Optional UI step in display-space (e.g. 10 for 0..100 opacity UX). */
+    readonly displayStep?: number;
+    /** Optional display-only suffix rendered next to the numeric value. */
+    readonly suffix?: string;
     /** When provided, a compact unit dropdown is shown next to the value input. */
     readonly units?: ReadonlyArray<{
         value: string;
@@ -2708,13 +2940,13 @@ interface StringDevUIFieldRange {
     /** Default unit value (used when no persisted unit exists). */
     readonly defaultUnit?: string;
 }
-interface StringDevUIFieldColor {
+interface StringDevUIFieldColor extends StringDevUIFieldBase {
     readonly type: "color";
     readonly key: string;
     readonly label: string;
     readonly default: string;
 }
-interface StringDevUIFieldSelect {
+interface StringDevUIFieldSelect extends StringDevUIFieldBase {
     readonly type: "select";
     readonly key: string;
     readonly label: string;
@@ -2724,7 +2956,7 @@ interface StringDevUIFieldSelect {
         label: string;
     }>;
 }
-interface StringDevUIFieldToggle {
+interface StringDevUIFieldToggle extends StringDevUIFieldBase {
     readonly type: "toggle";
     readonly key: string;
     readonly label: string;
@@ -2804,7 +3036,502 @@ declare abstract class GridAdapter {
     protected createPath(d: string, stroke: string, opacity: number, strokeWidth?: number, fill?: string): SVGPathElement;
 }
 
-declare function resolveDevtoolsIcon(iconOrId: string): string;
+/**
+ * StringDevRulers — developer utility module for guide-line rulers.
+ *
+ * Usage:
+ *   st.use(StringDevRulers)
+ *   st.use(StringDevRulers, { triggers: [...], grid: { type: "columns", count: 12, ... } })
+ *
+ * Default trigger: Shift + R
+ *
+ * Settings:
+ *   triggers               — array of trigger descriptors (keyboard / element / event)
+ *   rulers-snap            — grid step in px (0 = off)
+ *   rulers-snap-elements   — snap to [string] element edges (default: true)
+ *   rulers-snap-threshold  — snap pull radius in px (default: 8)
+ *   rulers-snap-selector   — CSS selector for snap targets
+ *   grid                   — RulersLayoutGrid | RulersLayoutGrid[]
+ *
+ * Snap visual feedback:
+ *   amber → snapping to a DOM element edge / center
+ *   green → snapping to a layout-grid line
+ */
+declare class StringDevRulers extends StringDevModule {
+    private manager;
+    private overlay;
+    private visible;
+    private dockDisabled;
+    private currentModeId;
+    private readonly modeStore;
+    private readonly viewportLayer;
+    private _kbHandlers;
+    private _elHandlers;
+    private _evHandlers;
+    static devtool: {
+        id: string;
+        label: string;
+        icon: string;
+        order: number;
+        group: number;
+        hotkey: {
+            key: string;
+            shiftKey: boolean;
+        };
+        styles: string;
+        connects: {
+            global: boolean;
+            keys: string[];
+        };
+    };
+    constructor(context: StringContext);
+    onInit(): void;
+    onSettingsChange(): void;
+    onSubscribe(): void;
+    onUnsubscribe(): void;
+    onFrame(data: StringData): void;
+    onResize(): void;
+    destroy(): void;
+    toggle(): void;
+    show(): void;
+    hide(): void;
+    clear(): void;
+    isVisible(): boolean;
+    protected getDevtoolActiveState(): boolean;
+    protected setDevtoolActiveState(active: boolean): void;
+    protected getDevtoolSubBadges(): StringDevtoolSubBadge[];
+    private _bindTriggers;
+    private _unbindTriggers;
+    private _applyAction;
+    private setVisible;
+    private setDockActive;
+    private mountOverlay;
+    private cycleMode;
+    private switchMode;
+    private applyStyleSettings;
+    private clearStyleSettings;
+    /** Normalises the `grid` setting to RulersLayoutGrid[] (or undefined). */
+    private _resolveGrids;
+    private syncOverlayMetrics;
+    private pushScrollToOverlay;
+}
+
+type StringDevtoolsOverlayId = string;
+interface AnchorPoint {
+    docX: number;
+    docY: number;
+}
+
+type OverlayAxis = "y" | "x";
+type OverlayAnchor = "start" | "end";
+interface OverlayBaseMetrics {
+    visible: boolean;
+    contentX: number;
+    contentY: number;
+    width: number;
+    height: number;
+    isOffscreen: boolean;
+    baseAnchorX: number;
+    baseAnchorY: number;
+    collisionOffset: number;
+    axis: OverlayAxis;
+    primarySize: number;
+    crossSize: number;
+    primaryContentOffset: number;
+    viewportPrimarySize: number;
+}
+interface OverlayObjectGeometry {
+    contentX: number;
+    contentY: number;
+    width: number;
+    height: number;
+}
+interface StringDevOverlayBadgeInit {
+    targetId: string;
+    selectorAttribute?: string;
+    depth?: number;
+    attributes?: Record<string, string | boolean | number | null | undefined>;
+}
+interface StringDevOverlayBadgeState {
+    visible?: boolean;
+    active?: boolean;
+    disabled?: boolean;
+    title?: string;
+    html?: string;
+    label?: string;
+    attributes?: Record<string, string | boolean | number | null | undefined>;
+}
+declare abstract class StringDevOverlayModule<TEntry = unknown, TMeasurement = unknown> extends StringDevModule {
+    private _viewportLayer?;
+    private _badgeLayer?;
+    private _hudLayer?;
+    protected get viewportLayer(): StringDevViewportLayer;
+    protected get badgeLayer(): StringDevViewportLayer;
+    protected get hudLayer(): StringDevViewportLayer;
+    protected readonly entries: Map<string, TEntry>;
+    protected readonly measurements: Map<string, TMeasurement>;
+    protected enabled: boolean;
+    protected needsMeasure: boolean;
+    protected hasPendingMutate: boolean;
+    private _rafId;
+    private _pendingSingleIds;
+    private readonly onOverlayLayoutChangeBind;
+    private get _overlayConfig();
+    /** Override to provide the overlay ID for the anchor/collision system. */
+    protected get overlayId(): StringDevtoolsOverlayId | null;
+    /** Override to declare how many badge slots this overlay occupies. */
+    protected get overlayBadgeCount(): number;
+    /** Override to define your viewport layer name. Falls back to devtool.overlay.layerName. */
+    protected get layerName(): string;
+    /** Override to define your viewport layer z-index. Falls back to devtool.overlay.zIndex. */
+    protected get layerZIndex(): number;
+    /** Override to define the data-attribute added to the layer root. Falls back to devtool.overlay.layerAttribute. */
+    protected get layerAttribute(): string;
+    /** Override when an overlay module should start enabled before dock preferences apply. Falls back to devtool.overlay.defaultEnabled. */
+    protected get defaultEnabled(): boolean;
+    constructor(context: StringContext);
+    onInit(): void;
+    onObjectConnected(object: StringObject): void;
+    onObjectDisconnected(object: StringObject): void;
+    setEnabled(enabled: boolean): void;
+    isEnabled(): boolean;
+    protected getDevtoolActiveState(): boolean;
+    protected setDevtoolActiveState(active: boolean): void;
+    /** Create DOM and return state for the given element */
+    protected abstract createOverlayEntry(object: StringObject): TEntry | null;
+    /** Clean up DOM and listeners for the given element */
+    protected abstract destroyOverlayEntry(entry: TEntry): void;
+    /** Produce a custom measurement state utilizing the provided base metrics */
+    protected abstract measureEntry(entry: TEntry, baseMetrics: OverlayBaseMetrics): TMeasurement;
+    /** Render DOM efficiently utilizing `styleTxn` */
+    protected abstract applyMeasurement(entry: TEntry, measurement: TMeasurement | undefined): void;
+    /** Called when `setEnabled` state flips, allowing subclasses to show/hide specific entries */
+    protected onEnabledChange(_enabled: boolean): void;
+    onScroll(): void;
+    onScrollMeasure(): void;
+    onMutate(): void;
+    onResize(): void;
+    onDOMRebuild(): void;
+    /**
+     * Immediate synchronous full sync — use only when instant visual response
+     * is required (e.g. setEnabled). For everything else prefer scheduleSync().
+     */
+    protected scheduleFullSync(): void;
+    /**
+     * Deferred full sync — batches multiple calls within the same animation
+     * frame into a single measure+flush pass. Use for resize, layout changes,
+     * object connected, and any other non-immediate triggers.
+     */
+    protected scheduleSync(): void;
+    /**
+     * Deferred single-entry sync — measures and flushes only the given entry.
+     * Multiple calls for different entries within the same frame are batched
+     * together into one styleTxn flush. Use for per-object events like
+     * object:inview or slider input where only one entry changes.
+     */
+    protected scheduleSingleSync(entry: TEntry): void;
+    protected collectMeasurements(): void;
+    protected flushMeasurements(): void;
+    protected ensureLayer(): HTMLDivElement;
+    protected applyEnabledState(): void;
+    private syncSlotRegistration;
+    protected resolveOverlayTargetId(object: StringObject): string;
+    protected resolveOverlayObjectDepth(element: HTMLElement): number;
+    protected createOverlayBadge(init: StringDevOverlayBadgeInit): HTMLButtonElement;
+    protected applyOverlayBadgeState(badge: HTMLElement, state: StringDevOverlayBadgeState): void;
+    protected applyOverlayBadgePosition(badge: HTMLElement, measurement: {
+        visible: boolean;
+        docX: number;
+        docY: number;
+        translate?: string;
+    } | undefined): void;
+    protected getOverlayTargetLabel(object: StringObject): string;
+    protected getViewportAnchorOffset(anchor: OverlayAnchor, metrics: OverlayBaseMetrics): number;
+    protected getOverlayAnchorAdjustment(_object: StringObject, _anchor: AnchorPoint, _metrics?: {
+        contentX: number;
+        contentY: number;
+        width: number;
+        height: number;
+    }): AnchorPoint;
+    protected resolveRulerPanelOffset(contentX: number, contentY: number): {
+        x: number;
+        y: number;
+    };
+    protected computeBaseMetrics(entry: any): OverlayBaseMetrics;
+    protected getHiddenMetrics(): OverlayBaseMetrics;
+    protected getObjectDocY(object: StringObject): number;
+    protected resolveOverlayObjectGeometry(object: StringObject, element?: HTMLElement): OverlayObjectGeometry;
+    protected getViewportScrollLeft(): number;
+    protected getViewportScrollTop(): number;
+    protected resolveLiveElementMetrics(element: HTMLElement, rect: DOMRect): {
+        docLeft?: number;
+        docTop?: number;
+        width: number;
+        height: number;
+    };
+    destroy(): void;
+}
+
+type StringDevBadgeSlot = "top-left" | "top-right" | "bottom-right" | "bottom-left";
+interface StringDevBadgeSlotConfig {
+    gap?: number;
+    offsetX?: number;
+    offsetY?: number;
+}
+interface StringDevBadgeDescriptor {
+    id: string;
+    slot?: StringDevBadgeSlot;
+    group?: string;
+    selectorAttribute?: string;
+    depth?: number;
+    attributes?: Record<string, string | boolean | number | null | undefined>;
+    gap?: number;
+    offsetX?: number;
+    offsetY?: number;
+}
+interface StringDevManagedBadge {
+    id: string;
+    descriptor: StringDevBadgeDescriptor;
+    element: HTMLButtonElement;
+}
+interface StringDevBadgePositionMeasurement {
+    visible: boolean;
+    docX: number;
+    docY: number;
+    translate?: string;
+}
+interface StringDevBadgeMeasurement {
+    visible: boolean;
+    badges: Record<string, StringDevBadgePositionMeasurement>;
+}
+interface StringDevBadgeEntry<TExtra = undefined> {
+    object: StringObject;
+    targetId: string;
+    badge: HTMLButtonElement;
+    depth: number;
+    extra: TExtra;
+    cleanup: Array<() => void>;
+    badges: Map<string, StringDevManagedBadge>;
+    groups: Map<string, HTMLDivElement>;
+}
+declare abstract class StringDevBadgeOverlayModule<TExtra = undefined, TMeasurement extends StringDevBadgeMeasurement = StringDevBadgeMeasurement> extends StringDevOverlayModule<StringDevBadgeEntry<TExtra>, TMeasurement> {
+    protected get badgeAttribute(): string;
+    protected createOverlayEntry(object: StringObject): StringDevBadgeEntry<TExtra>;
+    protected destroyOverlayEntry(entry: StringDevBadgeEntry<TExtra>): void;
+    protected measureEntry(entry: StringDevBadgeEntry<TExtra>, metrics: OverlayBaseMetrics): TMeasurement;
+    protected applyMeasurement(entry: StringDevBadgeEntry<TExtra>, measurement: TMeasurement | undefined): void;
+    protected onEnabledChange(_enabled: boolean): void;
+    protected createBadgeExtra(_object: StringObject, _badge: HTMLButtonElement, _targetId: string, _depth: number): TExtra;
+    protected destroyBadgeExtra(_entry: StringDevBadgeEntry<TExtra>): void;
+    protected bindBadge(_entry: StringDevBadgeEntry<TExtra>): Array<() => void> | void;
+    protected resolveBadgeDepth(object: StringObject): number;
+    protected getBadgeSlotConfig(): Partial<Record<StringDevBadgeSlot, StringDevBadgeSlotConfig>>;
+    protected getBadgeDescriptors(object: StringObject, targetId: string, depth: number): Array<StringDevBadgeDescriptor>;
+    protected getInitialBadgeAttributes(_object: StringObject, _targetId: string, _depth: number): Record<string, string | boolean | number | null | undefined> | undefined;
+    protected applyBadgeEnabledState(entry: StringDevBadgeEntry<TExtra>): void;
+    protected renderBadge(entry: StringDevBadgeEntry<TExtra>): void;
+    protected afterBadgeMeasurement(_entry: StringDevBadgeEntry<TExtra>, _measurement: TMeasurement | undefined): void;
+    protected abstract onBadgeClick(entry: StringDevBadgeEntry<TExtra>, event: MouseEvent, badge: StringDevManagedBadge): void;
+    protected abstract getBadgeState(entry: StringDevBadgeEntry<TExtra>, badge?: StringDevManagedBadge): StringDevOverlayBadgeState;
+    private resolveBadgeSlotConfig;
+    private resolveBadgePosition;
+}
+
+interface InviewExtra {
+    outline: HTMLDivElement;
+    enterConnector: HTMLDivElement;
+    exitConnector: HTMLDivElement;
+    enterMarker: HTMLDivElement;
+    exitMarker: HTMLDivElement;
+    enterMarkerLabel: HTMLSpanElement;
+    exitMarkerLabel: HTMLSpanElement;
+}
+interface InviewMeasurement extends StringDevBadgeMeasurement {
+    overlayVisible: boolean;
+    badgeVisible: boolean;
+    markersVisible: boolean;
+    inview: boolean;
+    outlineDocX: number;
+    outlineDocY: number;
+    outlineWidth: number;
+    outlineHeight: number;
+    enterConnectorDocX: number;
+    enterConnectorDocY: number;
+    enterConnectorWidth: number;
+    enterConnectorHeight: number;
+    exitConnectorDocX: number;
+    exitConnectorDocY: number;
+    exitConnectorWidth: number;
+    exitConnectorHeight: number;
+    enterMarkerDocX: number;
+    enterMarkerDocY: number;
+    enterMarkerFlippedY: boolean;
+    exitMarkerDocX: number;
+    exitMarkerDocY: number;
+    exitMarkerFlippedY: boolean;
+}
+declare class StringDevInview extends StringDevBadgeOverlayModule<InviewExtra, InviewMeasurement> {
+    static devtool: {
+        id: string;
+        label: string;
+        icon: string;
+        order: number;
+        group: number;
+        hotkey: {
+            key: string;
+            shiftKey: boolean;
+        };
+        styles: string;
+        overlay: {
+            layerName: string;
+            zIndex: number;
+            layerAttribute: string;
+            overlayId: string;
+            defaultEnabled: boolean;
+        };
+        connects: {
+            global: boolean;
+        };
+    };
+    protected get overlayBadgeCount(): number;
+    protected getDevtoolSubBadges(): StringDevtoolSubBadge[];
+    private entryEnabled;
+    private markerSizeCache;
+    private readonly disabledStore;
+    private readonly markerStore;
+    private disabledTargetIds;
+    private markerOffsets;
+    private stableCoarseViewportWidth;
+    private stableCoarseViewportHeight;
+    protected getBadgeDescriptors(_object: StringObject, _targetId: string, _depth: number): Array<StringDevBadgeDescriptor>;
+    protected createBadgeExtra(object: StringObject, _badge: HTMLButtonElement, targetId: string, _depth: number): InviewExtra;
+    protected destroyBadgeExtra(entry: StringDevBadgeEntry<InviewExtra>): void;
+    protected bindBadge(entry: StringDevBadgeEntry<InviewExtra>): Array<() => void>;
+    protected measureEntry(entry: StringDevBadgeEntry<InviewExtra>, metrics: OverlayBaseMetrics): InviewMeasurement;
+    protected afterBadgeMeasurement(entry: StringDevBadgeEntry<InviewExtra>, measurement: InviewMeasurement | undefined): void;
+    protected onBadgeClick(entry: StringDevBadgeEntry<InviewExtra>, _event: MouseEvent, badge: StringDevManagedBadge): void;
+    protected getBadgeState(entry: StringDevBadgeEntry<InviewExtra>, badge?: StringDevManagedBadge): StringDevOverlayBadgeState;
+    private hiddenMeasurement;
+    private getInviewBadgeState;
+    private toggleInview;
+    private isInviewBadgeActive;
+    private isEntryEnabled;
+    private setEntryEnabled;
+    private disableAllOffsets;
+    private bindMarkerDrag;
+    private getMarkerOffset;
+    private setMarkerOffset;
+    private syncMarkerContent;
+    private getViewportMarkerLabel;
+    private measureMarkerSize;
+    private resolveLiveStickyGeometry;
+    private clampMarkerPercentInViewport;
+    private clampMarkerPercentInClientViewport;
+    private syncCompactMode;
+    private syncCompactModeForExtra;
+    private setAttributeIfChanged;
+    private getStableViewportHeight;
+}
+
+interface ProgressEntry {
+    object: StringObject;
+    hud: HTMLDivElement;
+    badge: HTMLButtonElement;
+    onBadgeClick: (event: MouseEvent) => void;
+}
+interface ProgressMeasurement {
+    visible: boolean;
+    docX: number;
+    docY: number;
+    targetId: string;
+    progress: number;
+    rawProgress: number;
+    startPosition: number;
+    endPosition: number;
+    currentScroll: number;
+    key: string;
+}
+declare class StringDevProgress extends StringDevOverlayModule<ProgressEntry, ProgressMeasurement> {
+    static devtool: {
+        id: string;
+        label: string;
+        icon: string;
+        order: number;
+        group: number;
+        hotkey: {
+            key: string;
+            shiftKey: boolean;
+        };
+        styles: string;
+        overlay: {
+            layerName: string;
+            zIndex: number;
+            layerAttribute: string;
+            overlayId: string;
+        };
+        connects: {
+            keys: string[];
+        };
+    };
+    private openTargetLabel;
+    private panelRoot;
+    private panelTitle;
+    private panelSlider;
+    private panelValue;
+    private panelEasedValue;
+    private panelPlayForwardButton;
+    private panelPlayBackwardButton;
+    private autoplayRaf;
+    private autoplayDirection;
+    private autoplayProgress;
+    private readonly onPanelSliderInputBind;
+    private unbindOutsideClick;
+    constructor(context: StringContext);
+    onInit(): void;
+    destroy(): void;
+    protected createOverlayEntry(object: StringObject): ProgressEntry;
+    protected destroyOverlayEntry(entry: ProgressEntry): void;
+    protected measureEntry(entry: ProgressEntry, metrics: OverlayBaseMetrics): ProgressMeasurement;
+    protected applyMeasurement(entry: ProgressEntry, measurement: ProgressMeasurement | undefined): void;
+    protected onEnabledChange(enabled: boolean): void;
+    private applyEntryEnabledState;
+    private openPanel;
+    private closePanel;
+    private closeAllPanels;
+    private collectEntryHuds;
+    private startAutoplay;
+    private stopAutoplay;
+    private syncPlayButtonState;
+    private getEntryRange;
+    private resolveEntryRawProgress;
+    private resolveEasedProgress;
+    private setEntryProgressOverride;
+    private clearEntryProgressOverride;
+    private clearAllProgressOverrides;
+    private applyObjectProgress;
+    private ensurePanel;
+    private onPanelSliderInput;
+    private renderPanel;
+    private findEntryByTargetLabel;
+}
+
+interface DevtoolsIconDef {
+    id: string;
+    viewBox: string;
+    content: string;
+}
+
+type DevtoolsIconSize = 12 | 16 | 20;
+declare class StringDevIconRegistry {
+    private static instance;
+    private spriteRoot;
+    private constructor();
+    static getInstance(): StringDevIconRegistry;
+    register(icon: DevtoolsIconDef): void;
+    resolve(size: DevtoolsIconSize, name: string, ...modifiers: string[]): string;
+    private ensureSprite;
+}
+declare function resolveDevtoolsIcon(size: DevtoolsIconSize, name: string, ...modifiers: string[]): string;
 
 type StringDevStyleTokens = Record<string, string>;
 declare function buildDevtoolsThemeBlock(selectors: string | string[], overrides?: StringDevStyleTokens): string;
@@ -2911,22 +3638,6 @@ interface RowsLayoutGrid {
 }
 type RulersLayoutGrid = ColumnsLayoutGrid | RowsLayoutGrid;
 
-interface StringDevtoolState {
-    active: boolean;
-}
-interface StringDevtoolDefinition {
-    id: string;
-    label: string;
-    icon: string;
-    order?: number;
-    getState: () => StringDevtoolState;
-    setActive: (active: boolean) => void;
-    subscribe?: (listener: (state: StringDevtoolState) => void) => () => void;
-}
-interface StringDevtoolProvider {
-    getDevtoolDefinition(): StringDevtoolDefinition | null;
-}
-
 interface ModuleBatchContext {
     module: StringModule;
     object: StringObject;
@@ -2959,12 +3670,17 @@ declare class DOMBatcher {
 }
 
 declare class StringTune {
+    private static readonly DEVTOOLS_ACCESS_URL;
+    private static readonly DEVTOOLS_LOG_PREFIX;
+    private static readonly DEVTOOLS_ARTIFACT_SELECTORS;
     /** Bound handler for the scroll start event */
     private onScrollStartBind;
     /** Bound handler for the scroll stop event */
     private onScrollStopBind;
     /** Bound handler for the scroll direction change event */
     private onDirectionChangeBind;
+    /** Bound handler for scroll mode/config changes */
+    private onScrollConfigChangeBind;
     /** Bound wheel event handler */
     private onWheelBind;
     /** Bound scroll event handler */
@@ -3019,6 +3735,12 @@ declare class StringTune {
     private devtoolsFpsLastSampleTime;
     private devtoolsFpsFrameCount;
     private observerContainerResize;
+    private devtoolsAccessToken;
+    private devtoolsAccessState;
+    private devtoolsAccessRequestId;
+    private pendingDevtoolUses;
+    private hasStarted;
+    private devtoolsAccessLastMessage;
     canRebuild: boolean;
     /**
      * Sets the scroll position manually.
@@ -3028,6 +3750,7 @@ declare class StringTune {
      * @param value The new scroll position in pixels.
      */
     set scrollPosition(value: number);
+    set accessDevtoolToken(value: string);
     /**
      * Configures the container element(s) used for scroll tracking.
      * Accepts either the `Window` object or an `HTMLElement`.
@@ -3095,6 +3818,12 @@ declare class StringTune {
      * @param settings Optional settings specific to this module.
      */
     use(objectClass: typeof StringModule, settings?: any): void;
+    private cleanupExistingDevtoolsArtifacts;
+    private instantiateModule;
+    private shouldDeferDevtoolModule;
+    private validateDevtoolsAccess;
+    private logDevtoolsAccess;
+    private resolveDevtoolsAccessResponse;
     /**
      * Registers a new scroll mode (provider) to the system.
      * Allows integrating custom scroll implementations (e.g. Lenis, Locomotive).
@@ -3198,6 +3927,8 @@ declare class StringTune {
      * Triggers module scroll stop lifecycle hook.
      */
     private onDirectionChange;
+    private onScrollConfigChange;
+    private syncDebugScrollState;
     /**
      * Called when global or module settings are updated.
      * Notifies all managers and modules to re-read new settings.
@@ -3244,4 +3975,4 @@ declare class StringTune {
     destroy(): void;
 }
 
-export { CursorReactiveModule, DOMBatcher, GridAdapter, type RulersLayoutGrid, type RulersTriggerAction, ScrollController, type ScrollMarkRule as ScrollTriggerRule, StringAnchor, type StringContext, StringCursor, StringData, StringDelayLerpTracker, type StringDevStyleTokens, type StringDevtoolDefinition, type StringDevtoolProvider, type StringDevtoolState, StringFPSTracker, StringForm, StringGlide, StringImpulse, StringLazy, StringLerp, StringLerpTracker, StringLoading, StringMagnetic, StringMasonry, StringModule, StringObject, StringParallax, StringPositionTracker, StringProgress, StringProgressPart, StringRandom, StringResponsive, type StringRulersTrigger, StringScrollContainer, StringScrollbar, StringScroller, StringSequence, StringSplit, StringSpotlight, StringTune, StringVideoAutoplay, buildDevtoolsThemeBlock, StringTune as default, ensureStringDevtoolsSharedStyles, frameDOM, resolveDevtoolsIcon, styleTxn };
+export { CursorReactiveModule, DOMBatcher, GridAdapter, type RulersLayoutGrid, type RulersTriggerAction, ScrollController, type ScrollMarkRule as ScrollTriggerRule, StringAnchor, type StringContext, StringCursor, StringData, StringDelayLerpTracker, StringDevIconRegistry, StringDevInview, StringDevLayout, StringDevModule, StringDevOverlayRegistry, StringDevProgress, StringDevRulers, type StringDevStyleTokens, type StringDevtoolDefinition, type StringDevtoolProvider, type StringDevtoolState, StringFPSTracker, StringForm, StringGlide, StringImpulse, StringLazy, StringLerp, StringLerpTracker, StringLoading, StringMagnetic, StringMasonry, StringModule, StringObject, StringParallax, StringPositionTracker, StringProgress, StringProgressPart, StringRandom, StringResponsive, type StringRulersTrigger, StringScrollContainer, StringScrollbar, StringScroller, StringSequence, StringSplit, StringSpotlight, StringTune, StringVideoAutoplay, buildDevtoolsThemeBlock, StringTune as default, ensureStringDevtoolsSharedStyles, frameDOM, resolveDevtoolsIcon, styleTxn };