handler-playable-sdk 0.3.2 → 0.3.4

package/dist/index.d.cts

@@ -0,0 +1,892 @@
+import { Graphics } from 'pixi.js';
+import { O as ObjectCentricConfig } from './loader-object-centric-Ce6MVkQw.cjs';
+export { g as applyDefaults, c as loadAllObjectConfigs, a as loadComponentSchemas, d as loadEngineConfig, e as loadGamePromptConfig, l as loadObjectCentricConfig, b as loadObjectConfig, f as loadSceneConfig, t as toLegacyFormat, v as validateObjectConfig } from './loader-object-centric-Ce6MVkQw.cjs';
+
+type TelemetryConfig = {
+    endpoint: string;
+    transport?: 'beacon' | 'fetch';
+    batchSize?: number;
+    flushIntervalMs?: number;
+    maxQueue?: number;
+    debug?: boolean;
+};
+
+declare global {
+    interface Window {
+        cachedContainerSize?: {
+            width: number;
+            height: number;
+        };
+    }
+}
+declare function setBootstrapDependencies(deps: {
+    initGame: any;
+    CustomAssets: any;
+    updateScreenState: any;
+    globalResponsiveMultipliers: any;
+    layout: any;
+    clearResponsiveElements: any;
+}): void;
+/**
+ * Bootstrap the Handler game
+ */
+declare const bootstrap: () => Promise<void>;
+
+/**
+ * Device Presets for Preview System
+ *
+ * Real device resolutions organized by category.
+ * The preview system will scale-to-fit these within the browser window.
+ */
+interface DevicePreset {
+    id: string;
+    label: string;
+    width: number;
+    height: number;
+    category: DeviceCategory;
+    ratio: string;
+    mraidScale?: number;
+}
+type DeviceCategory = 'iphone' | 'android' | 'tablet' | 'playable' | 'social';
+interface DeviceGroup {
+    category: DeviceCategory;
+    label: string;
+    devices: DevicePreset[];
+}
+declare const devicePresets: DevicePreset[];
+declare const deviceGroups: DeviceGroup[];
+declare const defaultPreset: DevicePreset;
+declare function getPresetById(id: string): DevicePreset;
+declare function getPresetsByCategory(category: DeviceCategory): DevicePreset[];
+
+/**
+ * Preview Shell
+ * Google Ads & Meta Style Preview System.
+ * Uses CSS transform scaling for device frame preview,
+ * and emits resize events so PIXI can reflow reliably.
+ */
+
+interface PreviewOptions {
+    defaultDevice?: string;
+    onDeviceChange?: (preset: DevicePreset) => void;
+    onRefresh?: () => void;
+    onRestart?: () => void;
+}
+declare class PreviewShell {
+    private container;
+    private previewContainer;
+    private singleStage;
+    private compareStage;
+    private frameDragger;
+    private frameWrapper;
+    private deviceFrame;
+    private gameContainer;
+    private currentPreset;
+    private isLandscape;
+    private autoScale;
+    private userScaleMultiplier;
+    private options;
+    private viewMode;
+    private lastSinglePresetId;
+    private comparePresets;
+    private activeCompareId;
+    private compareViewports;
+    private resizeObserver;
+    private rafFitHandle;
+    private ignoreNextWindowResize;
+    private frameDragOffsetX;
+    private frameDragOffsetY;
+    private frameDragActive;
+    private frameDragStartX;
+    private frameDragStartY;
+    private frameDragOriginX;
+    private frameDragOriginY;
+    private consolePanel;
+    private consoleMessages;
+    private isConsoleOpen;
+    private debugPanel;
+    private hasInitialFit;
+    private isMounted;
+    private isInitialized;
+    private gameReady;
+    private resizeListenersDisabled;
+    private compareSnapshotTimer;
+    constructor(options?: PreviewOptions);
+    mount(target?: HTMLElement): void;
+    destroy(): void;
+    getGameContainer(): HTMLElement;
+    getScreen(): {
+        width: number;
+        height: number;
+    };
+    getEffectivePreset(): DevicePreset;
+    notifyGameLoaded(): void;
+    notifyGameDestroyed(): void;
+    private disableResizeListeners;
+    private enableResizeListeners;
+    refresh(): void;
+    setDevice(deviceId: string, opts?: {
+        suppressCallback?: boolean;
+    }): void;
+    private createShell;
+    private setupEventListeners;
+    private applyDeviceFrameStyles;
+    private setupObserversAndListeners;
+    private onWindowResize;
+    private scheduleFit;
+    private applyPresetDimensions;
+    private fitToScreen;
+    private applyTransform;
+    private applyFrameDrag;
+    private setupFrameDragging;
+    private onFrameDragMove;
+    private onFrameDragEnd;
+    private adjustUserZoom;
+    private toggleRotation;
+    private emitScreenChange;
+    private safeStringify;
+    private setupConsoleInterceptor;
+    private appendConsoleMessage;
+    private escapeHtml;
+    private toggleConsole;
+    private clearConsole;
+    private setupCompareViewports;
+    private setViewMode;
+    private updateViewToggleUI;
+    private activateCompareViewport;
+    private applyCompareDimensions;
+    private fitCompareGhosts;
+    private captureCompareSnapshot;
+    private refreshCompareSnapshots;
+    private startCompareSnapshots;
+    private stopCompareSnapshots;
+    private getFitBounds;
+    private mustQuery;
+}
+declare function createPreviewShell(options?: PreviewOptions): PreviewShell;
+
+type SceneObjectsPanelOptions = {
+    onSelect: (objectId: string) => void;
+};
+declare class SceneObjectsPanel {
+    private root;
+    private listContainer;
+    private searchInput;
+    private selectedId;
+    private options;
+    private retryTimer;
+    private filterMode;
+    render(): string;
+    initialize(container: HTMLElement, options: SceneObjectsPanelOptions): void;
+    setSelected(objectId: string | null): void;
+    refreshObjects(): void;
+    /**
+     * Format display name: removes json. prefix, converts underscores to spaces, title case
+     */
+    private formatDisplayName;
+    /**
+     * Get object type for icon display
+     */
+    private getObjectType;
+    private renderGroup;
+    private getTypeIconByType;
+    private getTypeIcon;
+    private getAssetPreview;
+    private getColorIndicator;
+    private getMetadata;
+    private scheduleRetry;
+    private select;
+}
+
+type SceneToolsPanelOptions = {
+    onHighlightObject: (enabled: boolean) => void;
+    onHighlightAnchor: (enabled: boolean) => void;
+    onNudge: (dx: number, dy: number) => void;
+    onShowSplash?: () => void;
+    onUpdateSplash?: (patch: Record<string, any>) => void;
+};
+declare class SceneToolsPanel {
+    private root;
+    private infoEls;
+    private options;
+    render(): string;
+    initialize(container: HTMLElement, options: SceneToolsPanelOptions): void;
+    getNudgeStep(): number;
+    updateInfo(info: {
+        instanceId: string;
+        worldX: number;
+        worldY: number;
+        anchorX: number | null;
+        anchorY: number | null;
+    } | null): void;
+}
+
+type LibraryPanelOptions = {
+    onApply: (objectId: string, assetPath: string, category: string) => Promise<void>;
+    onReset: (objectId: string, defaultAsset: string, category: string) => Promise<void>;
+};
+declare class LibraryPanel {
+    private root;
+    private slotsContainer;
+    private options;
+    private registry;
+    private expandedSlot;
+    private mergeRegistries;
+    /**
+     * Render the library panel HTML template (called by DebugPanel)
+     */
+    render(): string;
+    initialize(container: HTMLElement, options: LibraryPanelOptions): void;
+    /**
+     * Re-renders the slots using the current in-memory registry.
+     * Useful when registry is updated locally (e.g. after conversion)
+     */
+    reRender(): void;
+    refresh(): Promise<void>;
+    private loadAssetRegistry;
+    private renderSlots;
+    private createSlotElement;
+    private createLibraryElement;
+    private fetchFolderAssets;
+    private handleApply;
+    private handleReset;
+    private formatCategoryName;
+    /**
+     * Handle AI Edit for existing asset
+     */
+    private handleAIEdit;
+    /**
+     * Handle Create with AI (new asset from scratch)
+     */
+    private handleCreateWithAI;
+    /**
+     * Highlights and scrolls to a specific slot
+     */
+    highlightSlot(objectId: string, category?: string): void;
+}
+
+type InspectorPanelOptions = {
+    onPropertyChange?: (objectId: string, path: string, value: any) => void;
+};
+declare class InspectorPanel {
+    private root;
+    private contentContainer;
+    private selectedObjectId;
+    private options;
+    private showAdvanced;
+    private rendererRegistry;
+    private updateManager;
+    private quickActions;
+    constructor();
+    render(): string;
+    initialize(container: HTMLElement, options: InspectorPanelOptions): void;
+    loadObject(objectId: string): void;
+    private renderProperties;
+    private renderConversionButtons;
+    private renderFooter;
+    private renderSection;
+    private attachEventListeners;
+    private addComponent;
+    private isSectionMeaningful;
+    private showError;
+    private formatLabel;
+    private getSectionIcon;
+    clear(): void;
+}
+
+/**
+ * Brand Vision Mapper Panel
+ *
+ * Three-tab UI for importing brand assets and mapping them to game objects:
+ * - Tab 1: Upload manifest + assets + flat design
+ * - Tab 2: Review AI-generated mappings (APPLY / GENERATE / KEEP)
+ * - Tab 3: Generation progress + Apply all
+ *
+ * Pipeline logic is handled by brandVisionPipeline.ts
+ * Prompts are defined in brandVisionPrompts.ts
+ */
+
+declare class BrandVisionPanel {
+    private root;
+    private currentTab;
+    private onClose?;
+    private uploadMethod;
+    private uploadedJsons;
+    private normalizedManifest;
+    private flatDesignDataUrl;
+    private assetFiles;
+    private zipFile;
+    private mappingResult;
+    private analysisRawResponse;
+    private analysisParsedOk;
+    private analysisParseError;
+    private isAnalyzing;
+    private isGenerating;
+    private get manifest();
+    render(): string;
+    initialize(container: HTMLElement, onClose?: () => void): void;
+    private attachEventListeners;
+    private switchTab;
+    private switchUploadMethod;
+    private handleZipUpload;
+    private processZipFile;
+    private fileToDataUrl;
+    private blobToDataUrl;
+    private inferAssetCategory;
+    private addAssetsToRegistry;
+    private refreshLibrary;
+    private handleManifestUpload;
+    private handleAssetsUpload;
+    private handleFlatDesignUpload;
+    private runAnalysis;
+    private generateAllMissing;
+    private renderMappings;
+    private applyAll;
+    private getEngineAssets;
+    private getPreviewValueForMapping;
+    private stageOverridesFromMappings;
+    private applyOne;
+    private saveAndApplyOne;
+    private openEditorForOne;
+    private generateOne;
+    private stageEngineAssetOverride;
+    private saveToLibraryAndReturnPath;
+    private inferCategoryFromAssetKey;
+    private copyRawAnalysis;
+    private setStatus;
+    private getGameObjects;
+    private getGamePrompt;
+    private setupResizeHandle;
+    refresh(): void;
+}
+
+type CustomizeSettingsPanelOptions = {
+    onApply: (payload: {
+        assets: Record<string, string>;
+        runtime: {
+            theme: Record<string, string>;
+            ui: Record<string, string>;
+            fonts: Record<string, string>;
+            audio: Record<string, string | number>;
+        };
+    }, options?: {
+        source?: 'manual' | 'auto';
+    }) => void;
+};
+declare class CustomizeSettingsPanel {
+    private root;
+    private assetsContainer;
+    private colorsContainer;
+    private fontsContainer;
+    private textsContainer;
+    private audioContainer;
+    private options;
+    private previewModal;
+    private autoApplyTimer;
+    private activePreviewKey;
+    private activePreviewValue;
+    private activePreviewFileInput;
+    private retryTimer;
+    private aiModal;
+    private aiTargetKey;
+    private aiKeyInput;
+    private aiPromptInput;
+    private aiStrengthInput;
+    private aiStrengthValue;
+    private aiModelSelect;
+    private aiModalSubtitle;
+    private aiGalleryToggle;
+    private aiGalleryEl;
+    private aiGalleryGrid;
+    private aiReferenceInput;
+    private aiReferenceName;
+    private aiReferenceFile;
+    private aiRemoveBgToggle;
+    private aiUseOutputToggle;
+    private aiGenerateBtn;
+    private aiApplyBtn;
+    private aiSaveLibraryBtn;
+    private aiCropBtn;
+    private aiDownloadBtn;
+    private aiPreviewImg;
+    private aiStatusEl;
+    private aiOutputDataUrl;
+    private aiBaseDataUrl;
+    private aiBaseValue;
+    private aiOutputKey;
+    private aiContext;
+    private aiBgToleranceInput;
+    private aiBgToleranceValue;
+    private aiRawOutputDataUrl;
+    private aiLoadingEl;
+    render(): string;
+    initialize(container: HTMLElement, options: CustomizeSettingsPanelOptions): void;
+    private setupRenderModeHandlers;
+    private applyEndgamePngMode;
+    private applySplashPngMode;
+    openAiEditor(assetKey: string, prompt?: string, initialValue?: string, context?: {
+        objectId?: string;
+        path?: string;
+    }): void;
+    refresh(): void;
+    private getEngineSnapshot;
+    private renderAssets;
+    private renderColors;
+    private renderFonts;
+    private renderTexts;
+    private renderAudio;
+    private readUiValue;
+    private getObjectTextValue;
+    private getObjectPropertyValue;
+    private handleApply;
+    private handleApplyWithSource;
+    private setupAiPanel;
+    private setAiStatus;
+    private getSelectedAssetKey;
+    private getSelectedAssetInput;
+    private getImageDataFromAsset;
+    private updateAiBasePreview;
+    private updateAiPreview;
+    private updateAiModalPreview;
+    private setAiLoading;
+    private toggleAiGallery;
+    private renderAiGallery;
+    private getAiGalleryEntries;
+    private isAiGalleryImage;
+    private selectAiGalleryAsset;
+    private openAiModal;
+    private closeAiModal;
+    private handleAiGenerate;
+    private refreshAiOutputFromRaw;
+    private setAiOutput;
+    private setAiOutputButtonsEnabled;
+    private handleAiApply;
+    private handleAiSaveToLibrary;
+    private inferCategoryFromAssetKey;
+    private inferObjectIdFromAssetKey;
+    private inferPathFromAssetKey;
+    private getFilenameFromPath;
+    private handleAiCrop;
+    private handleAiDownload;
+    private handleAssetValueChange;
+    private handleAssetUpload;
+    private scheduleAutoApply;
+    private previewAsset;
+    private resolveAssetUrls;
+    private guessMimeType;
+    private openPreviewModal;
+    private loadWithFallback;
+    private fetchWithFallback;
+    private applyObjectPropertyValue;
+    private applyTextColorToObject;
+    private closePreviewModal;
+    private updatePreviewIfOpen;
+    private scheduleRetry;
+    private clearRetry;
+    private setupResizeHandle;
+    private getImageDimensions;
+    private loadImage;
+    private showManualCropModal;
+    private loadImageForValue;
+}
+
+type WorkbenchTab = 'hierarchy' | 'inspector' | 'library' | 'ai' | 'changes';
+/**
+ * DebugPanel context interface - used to pass 'this' context to modular functions
+ */
+interface DebugPanelContext {
+    container: HTMLElement | null;
+    debugOverlay: HTMLElement | null;
+    configViewer: HTMLElement | null;
+    isDebugOpen: boolean;
+    selectedObjectId: string | null;
+    activeTab: WorkbenchTab;
+    highlightObject: boolean;
+    highlightAnchor: boolean;
+    objectAutoApplyTimer: number | null;
+    objectDebugRaf: number | null;
+    objectBoundsGfx: Graphics | null;
+    objectAnchorGfx: Graphics | null;
+    sceneObjectsPanel: SceneObjectsPanel;
+    sceneToolsPanel: SceneToolsPanel;
+    inspectorPanel: InspectorPanel;
+    libraryPanel: LibraryPanel;
+    brandVisionPanel: BrandVisionPanel;
+    customizeSettingsPanel: CustomizeSettingsPanel;
+}
+
+declare class ConfigPersistencePanel {
+    private container;
+    initialize(container: HTMLElement): void;
+    render(): string;
+    private formatValue;
+    setupEventListeners(): void;
+    private showSuccessNotification;
+    refreshPanel(): void;
+}
+
+/**
+ * DebugPanel - Refactored using modular functions
+ * Original methods are now in separate modules under ./debug/
+ */
+declare class DebugPanel implements DebugPanelContext {
+    debugOverlay: HTMLElement | null;
+    isDebugOpen: boolean;
+    selectedObjectId: string | null;
+    configViewer: HTMLElement | null;
+    container: HTMLElement | null;
+    objectAutoApplyTimer: number | null;
+    objectDebugRaf: number | null;
+    objectBoundsGfx: Graphics | null;
+    objectAnchorGfx: Graphics | null;
+    highlightObject: boolean;
+    highlightAnchor: boolean;
+    activeTab: WorkbenchTab;
+    sceneObjectsPanel: SceneObjectsPanel;
+    sceneToolsPanel: SceneToolsPanel;
+    inspectorPanel: InspectorPanel;
+    libraryPanel: LibraryPanel;
+    brandVisionPanel: BrandVisionPanel;
+    customizeSettingsPanel: CustomizeSettingsPanel;
+    configPersistencePanel: ConfigPersistencePanel;
+    private applyAssetChange;
+    private resetAsset;
+    private applySlotAsset;
+    private resetSlotAsset;
+    private startObjectVisuals;
+    private stopObjectVisuals;
+    private shouldRunObjectVisuals;
+    private updateObjectVisuals;
+    private getSelectedInstanceId;
+    private getDisplayObjectById;
+    private getSelectedObjectConfig;
+    private getConfigAnchorWorldPoint;
+    private getScreenSize;
+    private ensureBoundsGfx;
+    private ensureAnchorGfx;
+    private drawBounds;
+    private drawAnchor;
+    private clearBounds;
+    private clearAnchor;
+    private clearObjectVisuals;
+    private updateObjectInfo;
+    private resetDebugConfig;
+    private applyDebugConfig;
+    private exportDebugConfig;
+    private loadObjectConfig;
+    private fillConfigViewer;
+    private copyConfigValues;
+    private applyObjectConfig;
+    private applyCustomizeSettings;
+    private scheduleObjectAutoApply;
+    setupDebugEventListeners(): void;
+    private setupDebugInputListeners;
+    private setupPanelLayout;
+    private setupCollapsiblePanels;
+    private setupRangeInput;
+    private updateWorkbenchTabs;
+    private saveWorkbenchState;
+    private loadWorkbenchState;
+    initialize(container: HTMLElement): void;
+    selectObject(objectId: string): void;
+    private highlightChangesTab;
+    getDebugOverlayHTML(): string;
+    refresh(): void;
+    toggleDebug(force?: boolean): void;
+    updateDebugBadge(): void;
+    private handleObjectSelect;
+    private nudgeSelectedObject;
+}
+
+/**
+ * Preview Live-Edit Bridge (SDK)
+ *
+ * Provides the window hooks used by preview panels + hot-reload systems.
+ * This is intentionally small and defensive: it does not assume any specific
+ * GameObject implementation beyond "getDisplayObject" or common PIXI fields.
+ */
+type LiveEditBridge = {
+    /** Apply a full object config (usually after reloading from disk) */
+    applyObjectConfig: (objectId: string, nextConfig: any) => Promise<void>;
+    /** Rebuild lookup tables used by panels */
+    rebuildIndexes: () => void;
+};
+type SetupLiveEditBridgeOptions = {
+    getConfig: () => any;
+    gameObjectManager: any;
+    assets?: any;
+    onObjectConfigApplied?: (objectId: string, nextConfig: any, instanceIds: string[]) => void;
+};
+/**
+ * Setup the live-edit bridge.
+ *
+ * Call this after you have a loaded config and an initialized gameObjectManager.
+ */
+declare function setupLiveEditBridge(options: SetupLiveEditBridgeOptions): LiveEditBridge;
+
+/**
+ * Hot-Reload System for Object-Centric Config
+ *
+ * Enables live config editing during development.
+ * Edit your config JSON files and see changes instantly!
+ */
+interface HotReloadWatcher {
+    watch(configPath: string, callback: (event: ConfigChangeEvent) => void): void;
+    unwatch(configPath: string): void;
+    stop(): void;
+}
+interface ConfigChangeEvent {
+    type: 'object' | 'component' | 'engine' | 'scene';
+    path: string;
+    objectId?: string;
+    componentName?: string;
+}
+interface ReloadStrategy {
+    shouldFullReload(event: ConfigChangeEvent): boolean;
+    getAffectedObjects(event: ConfigChangeEvent): string[];
+}
+/**
+ * Determines reload strategy based on config change type
+ */
+declare class DefaultReloadStrategy implements ReloadStrategy {
+    shouldFullReload(event: ConfigChangeEvent): boolean;
+    getAffectedObjects(event: ConfigChangeEvent): string[];
+}
+/**
+ * File watcher for config hot-reload
+ */
+declare class ConfigWatcher implements HotReloadWatcher {
+    private pollingInterval;
+    private fileHashes;
+    private callbacks;
+    private intervalMs;
+    constructor(intervalMs?: number);
+    watch(configPath: string, callback: (event: ConfigChangeEvent) => void): void;
+    private checkAllFiles;
+    private determineEventType;
+    private hashString;
+    unwatch(configPath: string): void;
+    stop(): void;
+}
+/**
+ * Diff utility for comparing configs
+ */
+declare function diffConfigs(oldConfig: any, newConfig: any): string[];
+/**
+ * Rehydrate object with new config
+ */
+declare function rehydrateObject(objectId: string, oldConfig: any, newConfig: any, schemas: Map<string, any>): any;
+
+interface HotReloadDependencies {
+    activeConfig: ObjectCentricConfig;
+    setActiveConfig: (config: ObjectCentricConfig) => void;
+    gameObjectManager: any;
+    CustomAssets: any;
+    audioSystem: any;
+    setAudioSystem: (audioSystem: any) => void;
+    liveEditBridge: any;
+    createAudioSystem: (config: ObjectCentricConfig) => any;
+}
+/**
+ * Setup hot reload for config files.
+ *
+ * SDK-owned plumbing so demo projects only provide dependencies.
+ */
+declare function setupHotReload(deps: HotReloadDependencies): void;
+
+/**
+ * Config Override System
+ *
+ * Allows preview panel to override config values at runtime.
+ * Changes are applied immediately and can be:
+ * - persisted across restarts (in-memory, via window)
+ * - exported (diff/patch/json) via ConfigExport
+ *
+ * NOTE:
+ * In a pure-browser environment we cannot write back to disk.
+ * "Apply (real changes)" should be implemented via an optional dev-server endpoint
+ * (e.g. Vite plugin) that receives exported patches and writes config files.
+ */
+interface ConfigOverride {
+    objectId?: string;
+    sceneId?: string;
+    path: string;
+    value: any;
+}
+interface ConfigChange {
+    objectId?: string;
+    path: string;
+    oldValue: any;
+    newValue: any;
+    ts: number;
+}
+interface ConfigOverrideOptions {
+    silent?: boolean;
+    persist?: boolean;
+}
+declare function getOverrideMode(): boolean;
+declare function setOverrideMode(enabled: boolean): void;
+/**
+ * Apply a config override
+ */
+declare function applyConfigOverride(override: ConfigOverride, options?: ConfigOverrideOptions): void;
+/**
+ * Apply multiple config overrides
+ */
+declare function applyConfigOverrides(overrides: ConfigOverride[], options?: ConfigOverrideOptions): void;
+/**
+ * Clear all config overrides
+ */
+declare function clearConfigOverrides(): void;
+declare function clearConfigOverridesForObject(objectId: string): void;
+declare function removeConfigOverride(objectId: string | undefined, path: string): void;
+/**
+ * Get all active overrides
+ */
+declare function getConfigOverrides(): ConfigOverride[];
+/**
+ * SDK-facing manager used by ConfigExport.
+ * Kept minimal to avoid forcing consumers into a specific persistence strategy.
+ */
+declare const configOverrideManager: {
+    getCurrentConfig(): any | null;
+    getChanges(): ConfigChange[];
+    clearChanges(): void;
+};
+/**
+ * Deep clone utility for baseline copying
+ */
+declare function deepClone(obj: any): any;
+/**
+ * Export full config snapshots (Safeguard #1)
+ * CRITICAL: Must start from loader-resolved baseline, never from scratch
+ * Must output full object trees, never just changed keys
+ */
+declare function exportConfigsAsJSON(): Record<string, any>;
+/**
+ * Get summary of config state (for UI display)
+ */
+declare function getConfigStateSummary(): {
+    modifiedObjects: string[];
+    overrideCount: number;
+    hasChanges: boolean;
+    overrides: ConfigOverride[];
+};
+/**
+ * Apply configs to disk (Safeguard #2)
+ * CRITICAL: Clear cache ONLY after successful API response
+ */
+declare function applyConfigsToDisk(): Promise<void>;
+/**
+ * Reset to applied state (clear cache, reload)
+ */
+declare function resetToApplied(): void;
+/**
+ * Reset to original configs (restore from backup)
+ */
+declare function resetToOriginal(): Promise<void>;
+
+/**
+ * Base Layer - Lottie Instance
+ *
+ * Provides isolated lottie-web instance for base layer.
+ * Prevents conflicts with student layer's lottie instance.
+ *
+ * DO NOT EDIT - Base Layer
+ */
+declare const baseLottie: any;
+
+declare global {
+    const mraid: any;
+    const dapi: any;
+    const AD_PROTOCOL: string;
+    const AD_NETWORK: string;
+}
+type IDs = {
+    mechanic_id: string;
+    variant_id: string;
+    deployment_id: string;
+    export_id: string;
+    profile_id: string;
+    instance_id: string;
+};
+type Consent = {
+    analytics?: boolean;
+    personalization?: boolean;
+};
+type InitOptions = {
+    rootEl?: HTMLElement;
+    ids?: Partial<IDs>;
+    profile?: 'web_embed' | 'mraid' | string;
+    consent?: Consent;
+    destinationUrl?: string;
+    telemetry?: TelemetryConfig;
+};
+type Envelope = {
+    event_name: string;
+    ts: number;
+    session_id: string;
+    deployment_id: string;
+    variant_id: string;
+    export_profile_id: string;
+    instance_id: string;
+    env: 'web' | 'mraid' | 'native';
+    attribution?: {
+        campaign_id?: string;
+        placement_id?: string;
+        experiment_id?: string;
+    };
+    payload?: any;
+};
+declare const Handler: {
+    init(options?: InitOptions, callback?: (w: number, h: number) => void): void;
+    getRoot(): HTMLElement;
+    readonly version: string;
+    readonly maxWidth: number;
+    readonly maxHeight: number;
+    readonly isLandscape: boolean;
+    readonly isReady: boolean;
+    readonly isStarted: boolean;
+    readonly isPaused: boolean;
+    readonly isFinished: boolean;
+    readonly volume: number;
+    readonly interactions: number;
+    on(event: string, fn: (...args: any[]) => void): void;
+    off(event: string, fn?: (...args: any[]) => void): void;
+    start(): void;
+    finish(): void;
+    install(url?: string): void;
+    emit(name: string, payload?: any): void;
+    gameStart(): void;
+    gameEnd(): void;
+    ctaClick(url?: string, options?: {
+        open?: boolean;
+    }): void;
+    ctaShow(meta?: any): void;
+    ctaDismiss(meta?: any): void;
+    getGameTimeMs(): number | null;
+    endSession(reason?: "complete" | "cta" | "manual"): void;
+    setAttribution(attribution?: Envelope["attribution"]): void;
+    abTest(experimentId: string, variants: string[]): string;
+    levelStart(levelId: string | number, meta?: any): void;
+    levelComplete(levelId: string | number, meta?: any): void;
+    levelFail(levelId: string | number, meta?: any): void;
+    checkpoint(checkpointId: string | number, meta?: any): void;
+    reward(rewardId: string, meta?: any): void;
+    tutorialStart(stepId?: string | number, meta?: any): void;
+    tutorialComplete(stepId?: string | number, meta?: any): void;
+    tutorialSkip(stepId?: string | number, meta?: any): void;
+    timerStart(key: string): void;
+    timerEnd(key: string, eventName?: "load_time" | "level_time" | "custom", meta?: any): void;
+    fps(value: number, meta?: any): void;
+    memory(bytes: number, meta?: any): void;
+    assetLoadStart(assetId: string, meta?: any): void;
+    assetLoadComplete(assetId: string, meta?: any): void;
+    reportError(code: string, message: string, meta?: any): void;
+    retry(): void;
+    pause(): void;
+    resume(): void;
+    resize(width?: number, height?: number): void;
+};
+
+export { type ConfigChange, type ConfigChangeEvent, type ConfigOverride, type ConfigOverrideOptions, ConfigWatcher, DebugPanel, DefaultReloadStrategy, type DeviceCategory, type DeviceGroup, type DevicePreset, Handler, type HotReloadDependencies, type HotReloadWatcher, type LiveEditBridge, ObjectCentricConfig, type PreviewOptions, PreviewShell, type ReloadStrategy, type SetupLiveEditBridgeOptions, applyConfigOverride, applyConfigOverrides, applyConfigsToDisk, baseLottie, bootstrap, clearConfigOverrides, clearConfigOverridesForObject, configOverrideManager, createPreviewShell, deepClone, Handler as default, defaultPreset, deviceGroups, devicePresets, diffConfigs, exportConfigsAsJSON, getConfigOverrides, getConfigStateSummary, getOverrideMode, getPresetById, getPresetsByCategory, rehydrateObject, removeConfigOverride, resetToApplied, resetToOriginal, setBootstrapDependencies, setOverrideMode, setupHotReload, setupLiveEditBridge };