@buoy-gg/core 1.7.2

package/lib/typescript/module/floatingMenu/AppHost.d.ts

@@ -0,0 +1,39 @@
+import React, { ReactNode } from "react";
+import { AppInstance } from "./AppHostLogic";
+import { ModalRestoreState } from "./MinimizedToolsContext";
+type AppHostContextValue = {
+    openApps: AppInstance[];
+    isAnyOpen: boolean;
+    open: (def: Omit<AppInstance, "instanceId">) => string;
+    close: (instanceId?: string) => void;
+    closeAll: () => void;
+    registerApps?: (apps: any[]) => void;
+    /** Minimize a tool - hides the modal but keeps state */
+    minimize: (instanceId: string) => void;
+    /** Restore a minimized tool to visible state, optionally with saved modal state */
+    restore: (instanceId: string, restoreState?: ModalRestoreState) => void;
+    /** Check if a specific tool is minimized */
+    isMinimized: (instanceId: string) => boolean;
+};
+/**
+ * Provides the floating dev tools application host. Tracks open tool instances, restores
+ * persisted state, and exposes imperative helpers used by `FloatingMenu` and friends.
+ */
+export declare const AppHostProvider: ({ children }: {
+    children: ReactNode;
+}) => React.JSX.Element;
+/**
+ * Accessor hook for the dev tools app host. Components can open/close tools or inspect
+ * the active stack. Falls back to a no-op implementation when rendered outside the provider.
+ */
+export declare const useAppHost: () => AppHostContextValue;
+/**
+ * Renders all dev tool surfaces. Keeps minimized apps mounted but hidden
+ * so their state and listeners are preserved (similar to React Navigation screens).
+ *
+ * Supports multiple simultaneous modals - each modal gets a z-index based on
+ * its position in the stack (later opened modals appear on top).
+ */
+export declare const AppOverlay: () => React.JSX.Element | null;
+export {};
+//# sourceMappingURL=AppHost.d.ts.map

package/lib/typescript/module/floatingMenu/AppHost.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AppHost.d.ts","sourceRoot":"","sources":["../../../../src/floatingMenu/AppHost.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,EAQZ,SAAS,EACV,MAAM,OAAO,CAAC;AAEf,OAAO,EACL,WAAW,EAIZ,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAEL,iBAAiB,EAClB,MAAM,yBAAyB,CAAC;AAGjC,KAAK,mBAAmB,GAAG;IACzB,QAAQ,EAAE,WAAW,EAAE,CAAC;IACxB,SAAS,EAAE,OAAO,CAAC;IACnB,IAAI,EAAE,CAAC,GAAG,EAAE,IAAI,CAAC,WAAW,EAAE,YAAY,CAAC,KAAK,MAAM,CAAC;IACvD,KAAK,EAAE,CAAC,UAAU,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IACrC,QAAQ,EAAE,MAAM,IAAI,CAAC;IACrB,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,CAAC;IACrC,wDAAwD;IACxD,QAAQ,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,IAAI,CAAC;IACvC,mFAAmF;IACnF,OAAO,EAAE,CAAC,UAAU,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,iBAAiB,KAAK,IAAI,CAAC;IACxE,4CAA4C;IAC5C,WAAW,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,OAAO,CAAC;CAC9C,CAAC;AAaF;;;GAGG;AACH,eAAO,MAAM,eAAe,GAAI,cAAc;IAAE,QAAQ,EAAE,SAAS,CAAA;CAAE,sBA2NpE,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,UAAU,2BAgBtB,CAAC;AAgGF;;;;;;GAMG;AACH,eAAO,MAAM,UAAU,gCAgFtB,CAAC"}

package/lib/typescript/module/floatingMenu/AppHostLogic.d.ts

@@ -0,0 +1,37 @@
+import type { ComponentType, ReactNode } from "react";
+import type { ModalRestoreState } from "./MinimizedToolsContext";
+export type LaunchMode = "self-modal" | "host-modal" | "inline" | "toggle-only";
+export type AppInstance = {
+    instanceId: string;
+    id: string;
+    title?: string;
+    component: ComponentType<any>;
+    props?: Record<string, unknown>;
+    launchMode: LaunchMode;
+    singleton?: boolean;
+    /** Whether this app instance is currently minimized */
+    minimized?: boolean;
+    /** Icon to display when minimized */
+    icon?: ReactNode;
+    /** Accent color for the tool */
+    color?: string;
+    /** Modal state to restore when un-minimizing */
+    restoreState?: ModalRestoreState;
+};
+export type OpenDefinition = Omit<AppInstance, "instanceId">;
+/**
+ * Computes the new list of open tool instances when a user launches a dev app. Singleton
+ * tools reuse their existing instance while non-singletons create a new entry using the
+ * provided `generateId` helper.
+ *
+ * @param current - Current stack of open app instances.
+ * @param def - Descriptor of the tool to launch (without runtime instance id).
+ * @param generateId - Callback used to generate a unique instance identifier.
+ * @returns Updated instance list alongside the resolved instance id.
+ */
+export declare const resolveOpenAppsState: (current: AppInstance[], def: OpenDefinition, generateId: () => string) => {
+    apps: AppInstance[];
+    instanceId: string;
+    wasMinimized: boolean;
+};
+//# sourceMappingURL=AppHostLogic.d.ts.map

package/lib/typescript/module/floatingMenu/AppHostLogic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AppHostLogic.d.ts","sourceRoot":"","sources":["../../../../src/floatingMenu/AppHostLogic.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AACtD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAEjE,MAAM,MAAM,UAAU,GAAG,YAAY,GAAG,YAAY,GAAG,QAAQ,GAAG,aAAa,CAAC;AAEhF,MAAM,MAAM,WAAW,GAAG;IACxB,UAAU,EAAE,MAAM,CAAC;IACnB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,aAAa,CAAC,GAAG,CAAC,CAAC;IAC9B,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAChC,UAAU,EAAE,UAAU,CAAC;IACvB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,uDAAuD;IACvD,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,qCAAqC;IACrC,IAAI,CAAC,EAAE,SAAS,CAAC;IACjB,gCAAgC;IAChC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,gDAAgD;IAChD,YAAY,CAAC,EAAE,iBAAiB,CAAC;CAClC,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG,IAAI,CAAC,WAAW,EAAE,YAAY,CAAC,CAAC;AAE7D;;;;;;;;;GASG;AACH,eAAO,MAAM,oBAAoB,GAC/B,SAAS,WAAW,EAAE,EACtB,KAAK,cAAc,EACnB,YAAY,MAAM,MAAM,KACvB;IAAE,IAAI,EAAE,WAAW,EAAE,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,OAAO,CAAA;CAuBlE,CAAC"}

package/lib/typescript/module/floatingMenu/DefaultConfigContext.d.ts

@@ -0,0 +1,27 @@
+import React, { ReactNode } from 'react';
+import type { DefaultFloatingConfig, DefaultDialConfig } from './defaultConfig';
+/**
+ * Context value for default configuration settings.
+ */
+export interface DefaultConfigContextValue {
+    /** Default tools to enable in the floating bubble when no user settings exist. */
+    defaultFloatingTools?: DefaultFloatingConfig;
+    /** Default tools to enable in the dial menu when no user settings exist (max 6). */
+    defaultDialTools?: DefaultDialConfig;
+}
+/**
+ * Provider for default configuration that can be consumed by the settings system.
+ * This allows teams to set default tool configurations without prop drilling.
+ *
+ * @internal Used by FloatingDevTools to provide defaults to the settings hook.
+ */
+export declare function DefaultConfigProvider({ children, defaultFloatingTools, defaultDialTools, }: DefaultConfigContextValue & {
+    children: ReactNode;
+}): React.JSX.Element;
+/**
+ * Hook to access the default configuration from context.
+ *
+ * @internal Used by useDevToolsSettings to apply defaults.
+ */
+export declare function useDefaultConfig(): DefaultConfigContextValue;
+//# sourceMappingURL=DefaultConfigContext.d.ts.map

package/lib/typescript/module/floatingMenu/DefaultConfigContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DefaultConfigContext.d.ts","sourceRoot":"","sources":["../../../../src/floatingMenu/DefaultConfigContext.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAA6B,SAAS,EAAE,MAAM,OAAO,CAAC;AACpE,OAAO,KAAK,EAAE,qBAAqB,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAEhF;;GAEG;AACH,MAAM,WAAW,yBAAyB;IACxC,kFAAkF;IAClF,oBAAoB,CAAC,EAAE,qBAAqB,CAAC;IAC7C,oFAAoF;IACpF,gBAAgB,CAAC,EAAE,iBAAiB,CAAC;CACtC;AAID;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,EACpC,QAAQ,EACR,oBAAoB,EACpB,gBAAgB,GACjB,EAAE,yBAAyB,GAAG;IAAE,QAAQ,EAAE,SAAS,CAAA;CAAE,qBAcrD;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,IAAI,yBAAyB,CAE5D"}

package/lib/typescript/module/floatingMenu/DevToolsSettingsModal.d.ts

@@ -0,0 +1,57 @@
+import { FC } from "react";
+/**
+ * Global settings that apply to all dev tools.
+ * These settings override individual tool configurations.
+ */
+export interface GlobalDevToolsSettings {
+    /**
+     * When true, all modals share the same dimensions/position.
+     * When false (default), each modal has its own independent persistence.
+     * Priority: Settings UI > Prop override > Default (false)
+     */
+    enableSharedModalDimensions?: boolean;
+}
+/**
+ * Serialized preferences that power the floating dev tools UI. Values persist across sessions
+ * via AsyncStorage so teams can tailor which tools appear in the dial or floating row.
+ */
+export interface DevToolsSettings {
+    /** Map of dial tool ids to enabled state (max slots enforced elsewhere). */
+    dialTools: Record<string, boolean>;
+    /** Map of floating tool ids to enabled state plus the environment indicator toggle. */
+    floatingTools: Record<string, boolean> & {
+        environment: boolean;
+    };
+    /** Global settings that apply to all dev tools */
+    globalSettings?: GlobalDevToolsSettings;
+}
+interface DevToolsSettingsModalProps {
+    visible: boolean;
+    onClose: () => void;
+    onSettingsChange?: (settings: DevToolsSettings) => void;
+    initialSettings?: DevToolsSettings;
+    availableApps?: {
+        id: string;
+        name: string;
+        description?: string;
+        slot?: "dial" | "row" | "both";
+    }[];
+}
+/**
+ * Configurable modal surface that lets engineers pick which dev tools appear in the dial and
+ * floating row. Persists preferences and enforces slot limits for a consistent UX.
+ */
+export declare const DevToolsSettingsModal: FC<DevToolsSettingsModalProps>;
+/**
+ * Convenience hook for accessing persisted dev tools settings. Subscribes to the internal
+ * event bus so all surfaces stay in sync when the modal saves new preferences.
+ *
+ * When no saved settings exist, the hook uses the default configuration from
+ * the DefaultConfigProvider (if available) to determine initial tool states.
+ */
+export declare const useDevToolsSettings: () => {
+    settings: DevToolsSettings;
+    refreshSettings: () => void;
+};
+export {};
+//# sourceMappingURL=DevToolsSettingsModal.d.ts.map

package/lib/typescript/module/floatingMenu/DevToolsSettingsModal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DevToolsSettingsModal.d.ts","sourceRoot":"","sources":["../../../../src/floatingMenu/DevToolsSettingsModal.tsx"],"names":[],"mappings":"AAAA,OAAO,EAA6C,EAAE,EAAE,MAAM,OAAO,CAAC;AA8MtE;;;GAGG;AACH,MAAM,WAAW,sBAAsB;IACrC;;;;OAIG;IACH,2BAA2B,CAAC,EAAE,OAAO,CAAC;CACvC;AAED;;;GAGG;AACH,MAAM,WAAW,gBAAgB;IAC/B,4EAA4E;IAC5E,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACnC,uFAAuF;IACvF,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG;QACvC,WAAW,EAAE,OAAO,CAAC;KACtB,CAAC;IACF,kDAAkD;IAClD,cAAc,CAAC,EAAE,sBAAsB,CAAC;CACzC;AAED,UAAU,0BAA0B;IAClC,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,MAAM,IAAI,CAAC;IACpB,gBAAgB,CAAC,EAAE,CAAC,QAAQ,EAAE,gBAAgB,KAAK,IAAI,CAAC;IACxD,eAAe,CAAC,EAAE,gBAAgB,CAAC;IACnC,aAAa,CAAC,EAAE;QACd,EAAE,EAAE,MAAM,CAAC;QACX,IAAI,EAAE,MAAM,CAAC;QACb,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,IAAI,CAAC,EAAE,MAAM,GAAG,KAAK,GAAG,MAAM,CAAC;KAChC,EAAE,CAAC;CACL;AAsDD;;;GAGG;AACH,eAAO,MAAM,qBAAqB,EAAE,EAAE,CAAC,0BAA0B,CAgrChE,CAAC;AAiDF;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB;;;CAuD/B,CAAC"}

package/lib/typescript/module/floatingMenu/DevToolsVisibilityContext.d.ts

@@ -0,0 +1,25 @@
+/**
+ * DevToolsVisibilityContext
+ *
+ * Tracks when DevTools UI is visible (dial menu, modals, etc.)
+ * Used by other tools (like debug borders) to hide when DevTools are active
+ */
+import { ReactNode } from "react";
+interface DevToolsVisibilityContextValue {
+    /** True when dial menu is open */
+    isDialOpen: boolean;
+    /** True when any DevTools modal/tool is open */
+    isToolOpen: boolean;
+    /** True when either dial or any tool is open */
+    isDevToolsActive: boolean;
+    /** Set dial open state */
+    setDialOpen: (open: boolean) => void;
+    /** Set tool open state */
+    setToolOpen: (open: boolean) => void;
+}
+export declare function DevToolsVisibilityProvider({ children, }: {
+    children: ReactNode;
+}): import("react").JSX.Element;
+export declare function useDevToolsVisibility(): DevToolsVisibilityContextValue;
+export {};
+//# sourceMappingURL=DevToolsVisibilityContext.d.ts.map

package/lib/typescript/module/floatingMenu/DevToolsVisibilityContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DevToolsVisibilityContext.d.ts","sourceRoot":"","sources":["../../../../src/floatingMenu/DevToolsVisibilityContext.tsx"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAGL,SAAS,EAKV,MAAM,OAAO,CAAC;AAEf,UAAU,8BAA8B;IACtC,kCAAkC;IAClC,UAAU,EAAE,OAAO,CAAC;IACpB,gDAAgD;IAChD,UAAU,EAAE,OAAO,CAAC;IACpB,gDAAgD;IAChD,gBAAgB,EAAE,OAAO,CAAC;IAC1B,0BAA0B;IAC1B,WAAW,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,CAAC;IACrC,0BAA0B;IAC1B,WAAW,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,CAAC;CACtC;AAKD,wBAAgB,0BAA0B,CAAC,EACzC,QAAQ,GACT,EAAE;IACD,QAAQ,EAAE,SAAS,CAAC;CACrB,+BAyBA;AAED,wBAAgB,qBAAqB,mCAapC"}

package/lib/typescript/module/floatingMenu/DraggableHeader.d.ts

@@ -0,0 +1,30 @@
+import { type ReactNode } from 'react';
+import { Animated, type ViewStyle, type StyleProp } from 'react-native';
+interface DraggableHeaderProps {
+    children: ReactNode;
+    position: Animated.ValueXY;
+    onDragStart?: () => void;
+    onDragEnd?: (finalPosition: {
+        x: number;
+        y: number;
+    }) => void;
+    onTap?: () => void;
+    containerBounds?: {
+        width: number;
+        height: number;
+    };
+    elementSize?: {
+        width: number;
+        height: number;
+    };
+    minPosition?: {
+        x: number;
+        y: number;
+    };
+    style?: StyleProp<ViewStyle>;
+    enabled?: boolean;
+    maxOverflowX?: number;
+}
+export declare const DraggableHeader: import("react").NamedExoticComponent<DraggableHeaderProps>;
+export {};
+//# sourceMappingURL=DraggableHeader.d.ts.map

package/lib/typescript/module/floatingMenu/DraggableHeader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DraggableHeader.d.ts","sourceRoot":"","sources":["../../../../src/floatingMenu/DraggableHeader.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAyB,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAC9D,OAAO,EAAsB,QAAQ,EAAc,KAAK,SAAS,EAAE,KAAK,SAAS,EAAE,MAAM,cAAc,CAAC;AAExG,UAAU,oBAAoB;IAC5B,QAAQ,EAAE,SAAS,CAAC;IACpB,QAAQ,EAAE,QAAQ,CAAC,OAAO,CAAC;IAC3B,WAAW,CAAC,EAAE,MAAM,IAAI,CAAC;IACzB,SAAS,CAAC,EAAE,CAAC,aAAa,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,KAAK,IAAI,CAAC;IAC9D,KAAK,CAAC,EAAE,MAAM,IAAI,CAAC;IACnB,eAAe,CAAC,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;IACpD,WAAW,CAAC,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;IAChD,WAAW,CAAC,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IACvC,KAAK,CAAC,EAAE,SAAS,CAAC,SAAS,CAAC,CAAC;IAC7B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,eAAO,MAAM,eAAe,4DA4F1B,CAAC"}

package/lib/typescript/module/floatingMenu/FloatingDevTools.d.ts

@@ -0,0 +1,226 @@
+import React from "react";
+import { type FloatingMenuProps } from "./FloatingMenu";
+import type { InstalledApp } from "./types";
+import { type DefaultFloatingConfig, type DefaultDialConfig } from "./defaultConfig";
+/**
+ * Environment variable configuration
+ *
+ * This type is compatible with RequiredEnvVar from @buoy-gg/env
+ *
+ * @example
+ * ```tsx
+ * // Simple string (just check existence)
+ * "API_URL"
+ *
+ * // Check for specific type
+ * { key: "DEBUG_MODE", expectedType: "boolean" }
+ *
+ * // Check for specific value
+ * { key: "ENVIRONMENT", expectedValue: "development" }
+ * ```
+ */
+export type EnvVarConfig = string | {
+    key: string;
+    expectedValue: string;
+    description?: string;
+} | {
+    key: string;
+    expectedType: "string" | "number" | "boolean" | "object" | "array" | "url";
+    description?: string;
+};
+/**
+ * Storage key configuration for monitoring
+ */
+export interface StorageKeyConfig {
+    key: string;
+    expectedType?: "string" | "number" | "boolean" | "object";
+    expectedValue?: string;
+    description?: string;
+    storageType: "async" | "secure" | "mmkv";
+}
+/**
+ * Props for FloatingDevTools component.
+ * Apps prop is optional - if not provided, all installed dev tools are auto-discovered.
+ */
+export interface FloatingDevToolsProps extends Omit<FloatingMenuProps, "apps"> {
+    /**
+     * Optional array of custom dev tool apps or overrides.
+     * Use this ONLY for custom tools or to override built-in tool behavior.
+     * Auto-discovered tools will be merged with these apps.
+     * Apps with matching IDs will override auto-discovered ones.
+     */
+    apps?: InstalledApp[];
+    /**
+     * Optional environment variables to validate.
+     * Just pass the array directly - no wrapper function needed!
+     *
+     * @example
+     * ```tsx
+     * <FloatingDevTools
+     *   requiredEnvVars={[
+     *     "API_URL",  // Just check if exists
+     *     { key: "DEBUG_MODE", expectedType: "boolean" },
+     *     { key: "ENVIRONMENT", expectedValue: "development" },
+     *   ]}
+     * />
+     * ```
+     */
+    requiredEnvVars?: EnvVarConfig[];
+    /**
+     * Optional storage keys to monitor.
+     * Just pass the array directly!
+     *
+     * @example
+     * ```tsx
+     * <FloatingDevTools
+     *   requiredStorageKeys={[
+     *     { key: "@app/session", expectedType: "string", storageType: "async" },
+     *   ]}
+     * />
+     * ```
+     */
+    requiredStorageKeys?: StorageKeyConfig[];
+    /**
+     * Optional children to render within the DevToolsVisibilityProvider context.
+     * Useful for tools that need to react to DevTools visibility (like DebugBordersStandaloneOverlay).
+     *
+     * @example
+     * ```tsx
+     * <FloatingDevTools>
+     *   <DebugBordersStandaloneOverlay />
+     * </FloatingDevTools>
+     * ```
+     */
+    children?: React.ReactNode;
+    /**
+     * Disable all onboarding hints and tooltips.
+     * Set to true if you don't want to show any first-time user hints.
+     *
+     * @default false
+     * @example
+     * ```tsx
+     * <FloatingDevTools disableHints />
+     * ```
+     */
+    disableHints?: boolean;
+    /**
+     * Default tools to enable in the floating bubble row when no user settings exist.
+     * Teams can use this to pre-configure which tools appear by default.
+     * User settings (once saved) will override these defaults.
+     *
+     * Type-safe: Only valid tool IDs are allowed with full autocomplete support.
+     *
+     * @example
+     * ```tsx
+     * <FloatingDevTools
+     *   defaultFloatingTools={['env', 'environment', 'network', 'query-wifi-toggle']}
+     * />
+     * ```
+     */
+    defaultFloatingTools?: DefaultFloatingConfig;
+    /**
+     * Default tools to enable in the dial menu when no user settings exist.
+     * Teams can use this to pre-configure which tools appear by default.
+     * User settings (once saved) will override these defaults.
+     *
+     * Type-safe: Only valid tool IDs are allowed with full autocomplete support.
+     * Maximum 6 tools allowed - validation will throw a helpful error if exceeded.
+     *
+     * @example
+     * ```tsx
+     * <FloatingDevTools
+     *   defaultDialTools={['env', 'network', 'storage', 'query', 'route-events', 'debug-borders']}
+     * />
+     * ```
+     */
+    defaultDialTools?: DefaultDialConfig;
+    /**
+     * List of environments available for switching.
+     * When provided along with onEnvironmentSwitch, the environment badge becomes
+     * interactive and allows users to switch between environments.
+     *
+     * @example
+     * ```tsx
+     * <FloatingDevTools
+     *   environment="dev"
+     *   availableEnvironments={['dev', 'qa', 'staging', 'prod']}
+     *   onEnvironmentSwitch={(env) => {
+     *     // Handle environment switch - update your app's environment
+     *     setCurrentEnvironment(env);
+     *   }}
+     * />
+     * ```
+     */
+    availableEnvironments?: import("@buoy-gg/shared-ui").Environment[];
+    /**
+     * Callback fired when the user selects an environment from the switcher.
+     * The app is responsible for actually switching environments and updating
+     * the `environment` prop - we just notify you of the user's selection.
+     *
+     * @example
+     * ```tsx
+     * onEnvironmentSwitch={(env) => {
+     *   // Your logic here - e.g., update API base URL, clear caches, etc.
+     *   console.log(`User wants to switch to ${env}`);
+     *   setCurrentEnvironment(env);
+     * }}
+     * ```
+     */
+    onEnvironmentSwitch?: (environment: import("@buoy-gg/shared-ui").Environment) => void;
+}
+/**
+ * Unified floating development tools component with automatic preset discovery.
+ *
+ * This component combines AppHostProvider, FloatingMenu, and AppOverlay
+ * into a single component for simplified setup and better developer experience.
+ *
+ * **Zero-Config Usage:**
+ * ```tsx
+ * <FloatingDevTools environment="local" userRole="admin" />
+ * // All installed dev tools automatically appear!
+ * ```
+ *
+ * **With Team Default Configuration (Type-Safe!):**
+ * ```tsx
+ * // Set which tools are enabled by default for your team
+ * <FloatingDevTools
+ *   // Floating bubble: ENV badge + WiFi toggle
+ *   defaultFloatingTools={['env', 'environment', 'query-wifi-toggle']}
+ *   // Dial menu: your team's 6 favorite tools (max 6!)
+ *   defaultDialTools={['env', 'network', 'storage', 'query', 'route-events', 'debug-borders']}
+ *   environment="local"
+ *   userRole="admin"
+ * />
+ * ```
+ *
+ * **With Validation (Super Simple!):**
+ * ```tsx
+ * <FloatingDevTools
+ *   requiredEnvVars={[
+ *     "API_URL",  // Just check existence
+ *     { key: "DEBUG_MODE", expectedType: "boolean" },
+ *   ]}
+ *   requiredStorageKeys={[
+ *     { key: "@app/session", storageType: "async" },
+ *   ]}
+ *   environment="local"
+ *   userRole="admin"
+ * />
+ * ```
+ *
+ * **With Custom Tools:**
+ * ```tsx
+ * <FloatingDevTools
+ *   apps={[myCustomTool]}
+ *   environment="local"
+ *   userRole="admin"
+ * />
+ * ```
+ *
+ * The component is absolutely positioned to float on top of your application
+ * regardless of where it's placed in the component tree.
+ *
+ * @param props - FloatingDevTools props
+ */
+export declare const FloatingDevTools: ({ apps, requiredEnvVars, requiredStorageKeys, children, disableHints, defaultFloatingTools, defaultDialTools, ...props }: FloatingDevToolsProps) => React.JSX.Element;
+//# sourceMappingURL=FloatingDevTools.d.ts.map

package/lib/typescript/module/floatingMenu/FloatingDevTools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FloatingDevTools.d.ts","sourceRoot":"","sources":["../../../../src/floatingMenu/FloatingDevTools.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAqD,MAAM,OAAO,CAAC;AAG1E,OAAO,EAAgB,KAAK,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAMtE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAI5C,OAAO,EACL,KAAK,qBAAqB,EAC1B,KAAK,iBAAiB,EAEvB,MAAM,iBAAiB,CAAC;AAIzB;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,YAAY,GACpB,MAAM,GACN;IACE,GAAG,EAAE,MAAM,CAAC;IACZ,aAAa,EAAE,MAAM,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,GACD;IACE,GAAG,EAAE,MAAM,CAAC;IACZ,YAAY,EACR,QAAQ,GACR,QAAQ,GACR,SAAS,GACT,QAAQ,GACR,OAAO,GACP,KAAK,CAAC;IACV,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC;AAEN;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,GAAG,EAAE,MAAM,CAAC;IACZ,YAAY,CAAC,EAAE,QAAQ,GAAG,QAAQ,GAAG,SAAS,GAAG,QAAQ,CAAC;IAC1D,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,OAAO,GAAG,QAAQ,GAAG,MAAM,CAAC;CAC1C;AAED;;;GAGG;AACH,MAAM,WAAW,qBAAsB,SAAQ,IAAI,CAAC,iBAAiB,EAAE,MAAM,CAAC;IAC5E;;;;;OAKG;IACH,IAAI,CAAC,EAAE,YAAY,EAAE,CAAC;IAEtB;;;;;;;;;;;;;;OAcG;IACH,eAAe,CAAC,EAAE,YAAY,EAAE,CAAC;IAEjC;;;;;;;;;;;;OAYG;IACH,mBAAmB,CAAC,EAAE,gBAAgB,EAAE,CAAC;IAEzC;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;IAE3B;;;;;;;;;OASG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;IAEvB;;;;;;;;;;;;;OAaG;IACH,oBAAoB,CAAC,EAAE,qBAAqB,CAAC;IAE7C;;;;;;;;;;;;;;OAcG;IACH,gBAAgB,CAAC,EAAE,iBAAiB,CAAC;IAErC;;;;;;;;;;;;;;;;OAgBG;IACH,qBAAqB,CAAC,EAAE,OAAO,oBAAoB,EAAE,WAAW,EAAE,CAAC;IAEnE;;;;;;;;;;;;;OAaG;IACH,mBAAmB,CAAC,EAAE,CAAC,WAAW,EAAE,OAAO,oBAAoB,EAAE,WAAW,KAAK,IAAI,CAAC;CAEvF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH,eAAO,MAAM,gBAAgB,GAAI,0HAS9B,qBAAqB,sBAuIvB,CAAC"}

package/lib/typescript/module/floatingMenu/FloatingMenu.d.ts

@@ -0,0 +1,39 @@
+import { FC } from "react";
+import { UserRole } from "./floatingTools";
+import type { InstalledApp, FloatingMenuActions, FloatingMenuState } from "./types";
+import type { DefaultFloatingConfig, DefaultDialConfig } from "./defaultConfig";
+import type { Environment } from "@buoy-gg/shared-ui";
+/**
+ * Props for the floating developer tools launcher. Controls which apps are shown and
+ * how the menu integrates with the current host environment.
+ */
+export interface FloatingMenuProps {
+    /** Dev tool apps that can be opened from the floating menu. */
+    apps: InstalledApp[];
+    /** Shared state object passed to app renderers (e.g. icons) and the dial. */
+    state?: FloatingMenuState;
+    /** Shared action callbacks exposed to app renderers for interacting with the menu. */
+    actions?: FloatingMenuActions;
+    /** When true, hides the floating row (used when another dev app takes focus). */
+    hidden?: boolean;
+    /** Active environment metadata displayed via the environment indicator, if enabled. */
+    environment?: Environment;
+    /** Optional role that determines which user status badge is rendered. */
+    userRole?: UserRole;
+    /** Default tools to enable in the floating bubble when no user settings exist. */
+    defaultFloatingTools?: DefaultFloatingConfig;
+    /** Default tools to enable in the dial menu when no user settings exist (max 6). */
+    defaultDialTools?: DefaultDialConfig;
+    /**
+     * List of environments available for switching.
+     * When provided along with onEnvironmentSwitch, the environment badge becomes interactive.
+     */
+    availableEnvironments?: Environment[];
+    /**
+     * Callback fired when the user selects an environment from the switcher.
+     * The app is responsible for actually switching environments and updating the `environment` prop.
+     */
+    onEnvironmentSwitch?: (environment: Environment) => void;
+}
+export declare const FloatingMenu: FC<FloatingMenuProps>;
+//# sourceMappingURL=FloatingMenu.d.ts.map

package/lib/typescript/module/floatingMenu/FloatingMenu.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FloatingMenu.d.ts","sourceRoot":"","sources":["../../../../src/floatingMenu/FloatingMenu.tsx"],"names":[],"mappings":"AAAA,OAAc,EAAE,EAAE,EAAqD,MAAM,OAAO,CAAC;AASrF,OAAO,EAAiB,QAAQ,EAAc,MAAM,iBAAiB,CAAC;AACtE,OAAO,KAAK,EACV,YAAY,EACZ,mBAAmB,EACnB,iBAAiB,EAClB,MAAM,SAAS,CAAC;AACjB,OAAO,KAAK,EAAE,qBAAqB,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAEhF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAetD;;;GAGG;AACH,MAAM,WAAW,iBAAiB;IAChC,+DAA+D;IAC/D,IAAI,EAAE,YAAY,EAAE,CAAC;IACrB,6EAA6E;IAC7E,KAAK,CAAC,EAAE,iBAAiB,CAAC;IAC1B,sFAAsF;IACtF,OAAO,CAAC,EAAE,mBAAmB,CAAC;IAC9B,iFAAiF;IACjF,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,uFAAuF;IACvF,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,yEAAyE;IACzE,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB,kFAAkF;IAClF,oBAAoB,CAAC,EAAE,qBAAqB,CAAC;IAC7C,oFAAoF;IACpF,gBAAgB,CAAC,EAAE,iBAAiB,CAAC;IACrC;;;OAGG;IACH,qBAAqB,CAAC,EAAE,WAAW,EAAE,CAAC;IACtC;;;OAGG;IACH,mBAAmB,CAAC,EAAE,CAAC,WAAW,EAAE,WAAW,KAAK,IAAI,CAAC;CAC1D;AAYD,eAAO,MAAM,YAAY,EAAE,EAAE,CAAC,iBAAiB,CAoU9C,CAAC"}

package/lib/typescript/module/floatingMenu/MinimizedToolsContext.d.ts

@@ -0,0 +1,95 @@
+import React, { ReactNode } from "react";
+/**
+ * Modal state to restore when reopening a minimized tool
+ */
+export interface ModalRestoreState {
+    /** Modal display mode */
+    mode: "bottomSheet" | "floating";
+    /** Panel height for bottom sheet mode */
+    panelHeight?: number;
+    /** Position for floating mode */
+    floatingPosition?: {
+        x: number;
+        y: number;
+    };
+    /** Dimensions for floating mode */
+    floatingDimensions?: {
+        width: number;
+        height: number;
+    };
+}
+/**
+ * Represents a minimized tool that can be restored
+ */
+export interface MinimizedTool {
+    /** Unique instance ID for this minimized tool */
+    instanceId: string;
+    /** Tool identifier (e.g., "storage", "network") */
+    id: string;
+    /** Display name for the tool */
+    title: string;
+    /** Icon component or element to display in the minimized stack */
+    icon: ReactNode;
+    /** Accent color for the tool */
+    color?: string;
+    /** Timestamp when the tool was minimized */
+    minimizedAt: number;
+    /** Modal state to restore when reopening */
+    modalState?: ModalRestoreState;
+}
+/**
+ * Position for a minimized tool icon in the stack
+ */
+export interface IconPosition {
+    x: number;
+    y: number;
+}
+/**
+ * Calculate the position of a minimized tool icon in the stack
+ * Icons stack upward from bottom-right corner
+ */
+export declare function getIconPosition(index: number): IconPosition;
+/**
+ * Get the icon size constant
+ */
+export declare function getIconSize(): number;
+/**
+ * Context value for minimized tools management
+ */
+interface MinimizedToolsContextValue {
+    /** List of currently minimized tools */
+    minimizedTools: MinimizedTool[];
+    /** Minimize a tool - removes from open apps and adds to minimized stack */
+    minimize: (tool: Omit<MinimizedTool, "minimizedAt">) => void;
+    /** Restore a minimized tool - removes from stack and triggers reopen */
+    restore: (instanceId: string) => MinimizedTool | null;
+    /** Check if a tool is currently minimized */
+    isMinimized: (id: string) => boolean;
+    /** Get a minimized tool by its instance ID */
+    getMinimizedTool: (instanceId: string) => MinimizedTool | undefined;
+    /** Clear all minimized tools */
+    clearAll: () => void;
+    /** Number of minimized tools */
+    count: number;
+    /** Get the target position for a new minimized icon (for animation) */
+    getNextIconPosition: () => IconPosition;
+    /** Get position of an existing minimized tool's icon */
+    getToolIconPosition: (instanceId: string) => IconPosition | null;
+}
+interface MinimizedToolsProviderProps {
+    children: ReactNode;
+    /** Callback to get icon for a tool by its id (used for restoration from storage) */
+    getToolIcon?: (id: string) => ReactNode;
+}
+/**
+ * Provider component for minimized tools management.
+ * Handles state, persistence, and provides context to children.
+ */
+export declare function MinimizedToolsProvider({ children, getToolIcon, }: MinimizedToolsProviderProps): React.JSX.Element;
+/**
+ * Hook to access minimized tools context.
+ * Must be used within a MinimizedToolsProvider.
+ */
+export declare function useMinimizedTools(): MinimizedToolsContextValue;
+export {};
+//# sourceMappingURL=MinimizedToolsContext.d.ts.map

package/lib/typescript/module/floatingMenu/MinimizedToolsContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MinimizedToolsContext.d.ts","sourceRoot":"","sources":["../../../../src/floatingMenu/MinimizedToolsContext.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAOZ,SAAS,EAEV,MAAM,OAAO,CAAC;AAQf;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,yBAAyB;IACzB,IAAI,EAAE,aAAa,GAAG,UAAU,CAAC;IACjC,yCAAyC;IACzC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,iCAAiC;IACjC,gBAAgB,CAAC,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAC5C,mCAAmC;IACnC,kBAAkB,CAAC,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;CACxD;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,iDAAiD;IACjD,UAAU,EAAE,MAAM,CAAC;IACnB,mDAAmD;IACnD,EAAE,EAAE,MAAM,CAAC;IACX,gCAAgC;IAChC,KAAK,EAAE,MAAM,CAAC;IACd,kEAAkE;IAClE,IAAI,EAAE,SAAS,CAAC;IAChB,gCAAgC;IAChC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,4CAA4C;IAC5C,WAAW,EAAE,MAAM,CAAC;IACpB,4CAA4C;IAC5C,UAAU,CAAC,EAAE,iBAAiB,CAAC;CAChC;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX;AAWD;;;GAGG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,YAAY,CAY3D;AAED;;GAEG;AACH,wBAAgB,WAAW,IAAI,MAAM,CAEpC;AAED;;GAEG;AACH,UAAU,0BAA0B;IAClC,wCAAwC;IACxC,cAAc,EAAE,aAAa,EAAE,CAAC;IAChC,2EAA2E;IAC3E,QAAQ,EAAE,CAAC,IAAI,EAAE,IAAI,CAAC,aAAa,EAAE,aAAa,CAAC,KAAK,IAAI,CAAC;IAC7D,wEAAwE;IACxE,OAAO,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,aAAa,GAAG,IAAI,CAAC;IACtD,6CAA6C;IAC7C,WAAW,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,OAAO,CAAC;IACrC,8CAA8C;IAC9C,gBAAgB,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,aAAa,GAAG,SAAS,CAAC;IACpE,gCAAgC;IAChC,QAAQ,EAAE,MAAM,IAAI,CAAC;IACrB,gCAAgC;IAChC,KAAK,EAAE,MAAM,CAAC;IACd,uEAAuE;IACvE,mBAAmB,EAAE,MAAM,YAAY,CAAC;IACxC,wDAAwD;IACxD,mBAAmB,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,YAAY,GAAG,IAAI,CAAC;CAClE;AAkCD,UAAU,2BAA2B;IACnC,QAAQ,EAAE,SAAS,CAAC;IACpB,oFAAoF;IACpF,WAAW,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,SAAS,CAAC;CACzC;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,EACrC,QAAQ,EACR,WAAW,GACZ,EAAE,2BAA2B,qBAwJ7B;AAMD;;;GAGG;AACH,wBAAgB,iBAAiB,IAAI,0BAA0B,CAmB9D"}

package/lib/typescript/module/floatingMenu/MinimizedToolsStack.d.ts

@@ -0,0 +1,10 @@
+import React from "react";
+import { MinimizedTool } from "./MinimizedToolsContext";
+export interface MinimizedToolsStackProps {
+    /** Callback when a tool should be restored */
+    onRestore?: (tool: MinimizedTool) => void;
+    /** Width of the parent container (for matching widths) */
+    containerWidth?: number;
+}
+export declare function MinimizedToolsStack({ onRestore, containerWidth, }: MinimizedToolsStackProps): React.JSX.Element;
+//# sourceMappingURL=MinimizedToolsStack.d.ts.map

package/lib/typescript/module/floatingMenu/MinimizedToolsStack.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MinimizedToolsStack.d.ts","sourceRoot":"","sources":["../../../../src/floatingMenu/MinimizedToolsStack.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAyC,MAAM,OAAO,CAAC;AAS9D,OAAO,EAAqB,aAAa,EAAE,MAAM,yBAAyB,CAAC;AA+K3E,MAAM,WAAW,wBAAwB;IACvC,8CAA8C;IAC9C,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,aAAa,KAAK,IAAI,CAAC;IAC1C,0DAA0D;IAC1D,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAMD,wBAAgB,mBAAmB,CAAC,EAClC,SAAS,EACT,cAA8B,GAC/B,EAAE,wBAAwB,qBA8C1B"}

package/lib/typescript/module/floatingMenu/ToggleStateManager.d.ts

@@ -0,0 +1,21 @@
+/**
+ * ToggleStateManager
+ *
+ * Global event emitter for toggle-only dev tools to notify when their state changes.
+ * This allows FloatingMenu to re-render and update icon colors.
+ */
+type Listener = () => void;
+declare class ToggleStateManager {
+    private listeners;
+    /**
+     * Subscribe to any toggle state change
+     */
+    subscribe(listener: Listener): () => void;
+    /**
+     * Notify all subscribers that a toggle state changed
+     */
+    notify(): void;
+}
+export declare const toggleStateManager: ToggleStateManager;
+export {};
+//# sourceMappingURL=ToggleStateManager.d.ts.map