@thewhateverapp/tile-sdk 0.15.3 → 0.15.4

package/dist/excalibur/index.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Excalibur.js game components for tile-sdk
+ *
+ * Import from '@thewhateverapp/tile-sdk/excalibur' to use Excalibur.js features.
+ * Excalibur is a modern 2D game engine with built-in physics, collision detection,
+ * and a robust entity-component system.
+ *
+ * @example
+ * ```tsx
+ * import { ExcaliburGame, useEngine, useGameLoop } from '@thewhateverapp/tile-sdk/excalibur';
+ * import { Actor, Color, Vector } from 'excalibur';
+ *
+ * function MyGame() {
+ *   return (
+ *     <ExcaliburGame width={256} height={554}>
+ *       <GameContent />
+ *     </ExcaliburGame>
+ *   );
+ * }
+ *
+ * function GameContent() {
+ *   const engine = useEngine();
+ *
+ *   useEffect(() => {
+ *     if (!engine) return;
+ *     const actor = new Actor({
+ *       pos: new Vector(100, 100),
+ *       width: 50,
+ *       height: 50,
+ *       color: Color.Red
+ *     });
+ *     engine.currentScene.add(actor);
+ *     return () => {
+ *       engine.currentScene.remove(actor);
+ *     };
+ *   }, [engine]);
+ *
+ *   useGameLoop((delta) => {
+ *     // Game logic runs every frame (delta is in milliseconds)
+ *   });
+ *
+ *   return null;
+ * }
+ * ```
+ */
+export { ExcaliburGame, useEngine, useScene, useGameLoop, useGameState, useGameInput, Actor, Vector, Color, Rectangle, Circle, Label, Text, Sprite, TILE_WIDTH, TILE_HEIGHT, } from '../react/ExcaliburGame.js';
+export type { ExcaliburGameProps } from '../react/ExcaliburGame.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/excalibur/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/excalibur/index.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AAEH,OAAO,EACL,aAAa,EACb,SAAS,EACT,QAAQ,EACR,WAAW,EACX,YAAY,EACZ,YAAY,EAEZ,KAAK,EACL,MAAM,EACN,KAAK,EACL,SAAS,EACT,MAAM,EACN,KAAK,EACL,IAAI,EACJ,MAAM,EAEN,UAAU,EACV,WAAW,GACZ,MAAM,2BAA2B,CAAC;AACnC,YAAY,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC"}

package/dist/excalibur/index.js

@@ -0,0 +1,51 @@
+'use client';
+/**
+ * Excalibur.js game components for tile-sdk
+ *
+ * Import from '@thewhateverapp/tile-sdk/excalibur' to use Excalibur.js features.
+ * Excalibur is a modern 2D game engine with built-in physics, collision detection,
+ * and a robust entity-component system.
+ *
+ * @example
+ * ```tsx
+ * import { ExcaliburGame, useEngine, useGameLoop } from '@thewhateverapp/tile-sdk/excalibur';
+ * import { Actor, Color, Vector } from 'excalibur';
+ *
+ * function MyGame() {
+ *   return (
+ *     <ExcaliburGame width={256} height={554}>
+ *       <GameContent />
+ *     </ExcaliburGame>
+ *   );
+ * }
+ *
+ * function GameContent() {
+ *   const engine = useEngine();
+ *
+ *   useEffect(() => {
+ *     if (!engine) return;
+ *     const actor = new Actor({
+ *       pos: new Vector(100, 100),
+ *       width: 50,
+ *       height: 50,
+ *       color: Color.Red
+ *     });
+ *     engine.currentScene.add(actor);
+ *     return () => {
+ *       engine.currentScene.remove(actor);
+ *     };
+ *   }, [engine]);
+ *
+ *   useGameLoop((delta) => {
+ *     // Game logic runs every frame (delta is in milliseconds)
+ *   });
+ *
+ *   return null;
+ * }
+ * ```
+ */
+export { ExcaliburGame, useEngine, useScene, useGameLoop, useGameState, useGameInput, 
+// Re-exported Excalibur classes
+Actor, Vector, Color, Rectangle, Circle, Label, Text, Sprite, 
+// Constants
+TILE_WIDTH, TILE_HEIGHT, } from '../react/ExcaliburGame.js';

package/dist/react/ExcaliburGame.d.ts

@@ -0,0 +1,109 @@
+/**
+ * ExcaliburGame - Excalibur.js integration for React
+ *
+ * This component creates an Excalibur Engine imperatively and provides
+ * it via React context for game development.
+ *
+ * @example
+ * ```tsx
+ * import { ExcaliburGame, useEngine, useGameLoop } from '@thewhateverapp/tile-sdk/excalibur';
+ * import { Actor, Color, Vector } from 'excalibur';
+ *
+ * function MyGame() {
+ *   return (
+ *     <ExcaliburGame>
+ *       <GameContent />
+ *     </ExcaliburGame>
+ *   );
+ * }
+ *
+ * function GameContent() {
+ *   const engine = useEngine();
+ *
+ *   useEffect(() => {
+ *     if (!engine) return;
+ *     const actor = new Actor({
+ *       pos: new Vector(100, 100),
+ *       width: 50,
+ *       height: 50,
+ *       color: Color.Red
+ *     });
+ *     engine.currentScene.add(actor);
+ *     return () => {
+ *       engine.currentScene.remove(actor);
+ *     };
+ *   }, [engine]);
+ *
+ *   useGameLoop((delta) => {
+ *     // Game logic runs every frame
+ *   });
+ *
+ *   return null; // No React children needed - Excalibur manages rendering
+ * }
+ * ```
+ */
+import React, { type ReactNode } from 'react';
+import { Engine, DisplayMode, type Scene } from 'excalibur';
+export { Actor, Vector, Color, Rectangle, Circle, Label, Text, Sprite } from 'excalibur';
+/**
+ * Tile dimensions - standard tile size
+ */
+export declare const TILE_WIDTH = 256;
+export declare const TILE_HEIGHT = 554;
+/**
+ * Hook to get the Excalibur Engine
+ */
+export declare function useEngine(): Engine | null;
+/**
+ * Hook to get the current scene
+ */
+export declare function useScene(): Scene | null;
+/**
+ * useGameLoop - Run a callback every frame
+ *
+ * @param callback - Function called every frame with delta time (in ms)
+ * @param enabled - Whether the loop is active (default: true)
+ */
+export declare function useGameLoop(callback: (delta: number) => void, enabled?: boolean): void;
+export interface ExcaliburGameProps {
+    children: ReactNode;
+    /** Width in pixels (default: 256 for tile) */
+    width?: number;
+    /** Height in pixels (default: 554 for tile) */
+    height?: number;
+    /** Background color (CSS color string, default: black) */
+    backgroundColor?: string;
+    /** Display mode (default: FitScreen) */
+    displayMode?: DisplayMode;
+    /** Game options */
+    options?: {
+        antialiasing?: boolean;
+        pixelArt?: boolean;
+        suppressPlayButton?: boolean;
+    };
+    /** Whether game is paused */
+    paused?: boolean;
+    /** Callback when Engine is ready */
+    onMount?: (engine: Engine) => void;
+}
+/**
+ * ExcaliburGame - Main wrapper component for Excalibur.js games
+ *
+ * Creates an Excalibur Engine and provides it via context.
+ * Children can use useEngine() to access the engine and add actors/entities.
+ */
+export declare function ExcaliburGame({ children, width, height, backgroundColor, displayMode, options, paused, onMount, }: ExcaliburGameProps): React.JSX.Element;
+/**
+ * useGameState - Helper for managing game state with refs
+ *
+ * Returns a ref and a forceUpdate function for when you need to trigger re-renders.
+ * Use refs for continuous game state (position, velocity) to avoid re-render loops.
+ */
+export declare function useGameState<T extends object>(initialState: T): [React.MutableRefObject<T>, () => void];
+/**
+ * useGameInput - Simple keyboard input hook for games
+ *
+ * Returns a ref with currently pressed keys.
+ */
+export declare function useGameInput(): React.MutableRefObject<Record<string, boolean>>;
+//# sourceMappingURL=ExcaliburGame.d.ts.map

package/dist/react/ExcaliburGame.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExcaliburGame.d.ts","sourceRoot":"","sources":["../../src/react/ExcaliburGame.tsx"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AAEH,OAAO,KAAK,EAAE,EAOZ,KAAK,SAAS,EACf,MAAM,OAAO,CAAC;AACf,OAAO,EAAE,MAAM,EAAE,WAAW,EAAoB,KAAK,KAAK,EAAE,MAAM,WAAW,CAAC;AAG9E,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAEzF;;GAEG;AACH,eAAO,MAAM,UAAU,MAAM,CAAC;AAC9B,eAAO,MAAM,WAAW,MAAM,CAAC;AAY/B;;GAEG;AACH,wBAAgB,SAAS,IAAI,MAAM,GAAG,IAAI,CAMzC;AAED;;GAEG;AACH,wBAAgB,QAAQ,IAAI,KAAK,GAAG,IAAI,CAGvC;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CACzB,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,EACjC,OAAO,GAAE,OAAc,QAexB;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,EAAE,SAAS,CAAC;IACpB,8CAA8C;IAC9C,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,+CAA+C;IAC/C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,0DAA0D;IAC1D,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,wCAAwC;IACxC,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,mBAAmB;IACnB,OAAO,CAAC,EAAE;QACR,YAAY,CAAC,EAAE,OAAO,CAAC;QACvB,QAAQ,CAAC,EAAE,OAAO,CAAC;QACnB,kBAAkB,CAAC,EAAE,OAAO,CAAC;KAC9B,CAAC;IACF,6BAA6B;IAC7B,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,oCAAoC;IACpC,OAAO,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;CACpC;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,EAC5B,QAAQ,EACR,KAAkB,EAClB,MAAoB,EACpB,eAA2B,EAC3B,WAA+B,EAC/B,OAAY,EACZ,MAAc,EACd,OAAO,GACR,EAAE,kBAAkB,qBA+FpB;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,CAAC,SAAS,MAAM,EAC3C,YAAY,EAAE,CAAC,GACd,CAAC,KAAK,CAAC,gBAAgB,CAAC,CAAC,CAAC,EAAE,MAAM,IAAI,CAAC,CASzC;AAED;;;;GAIG;AACH,wBAAgB,YAAY,oDAwB3B"}

package/dist/react/ExcaliburGame.js

@@ -0,0 +1,215 @@
+'use client';
+/**
+ * ExcaliburGame - Excalibur.js integration for React
+ *
+ * This component creates an Excalibur Engine imperatively and provides
+ * it via React context for game development.
+ *
+ * @example
+ * ```tsx
+ * import { ExcaliburGame, useEngine, useGameLoop } from '@thewhateverapp/tile-sdk/excalibur';
+ * import { Actor, Color, Vector } from 'excalibur';
+ *
+ * function MyGame() {
+ *   return (
+ *     <ExcaliburGame>
+ *       <GameContent />
+ *     </ExcaliburGame>
+ *   );
+ * }
+ *
+ * function GameContent() {
+ *   const engine = useEngine();
+ *
+ *   useEffect(() => {
+ *     if (!engine) return;
+ *     const actor = new Actor({
+ *       pos: new Vector(100, 100),
+ *       width: 50,
+ *       height: 50,
+ *       color: Color.Red
+ *     });
+ *     engine.currentScene.add(actor);
+ *     return () => {
+ *       engine.currentScene.remove(actor);
+ *     };
+ *   }, [engine]);
+ *
+ *   useGameLoop((delta) => {
+ *     // Game logic runs every frame
+ *   });
+ *
+ *   return null; // No React children needed - Excalibur manages rendering
+ * }
+ * ```
+ */
+import React, { createContext, useContext, useRef, useEffect, useState, useCallback, } from 'react';
+import { Engine, DisplayMode, Color as ExColor } from 'excalibur';
+// Re-export Excalibur classes for convenience
+export { Actor, Vector, Color, Rectangle, Circle, Label, Text, Sprite } from 'excalibur';
+/**
+ * Tile dimensions - standard tile size
+ */
+export const TILE_WIDTH = 256;
+export const TILE_HEIGHT = 554;
+const ExcaliburContext = createContext(null);
+/**
+ * Hook to get the Excalibur Engine
+ */
+export function useEngine() {
+    const context = useContext(ExcaliburContext);
+    if (!context) {
+        throw new Error('useEngine must be used within an ExcaliburGame component');
+    }
+    return context.engine;
+}
+/**
+ * Hook to get the current scene
+ */
+export function useScene() {
+    const engine = useEngine();
+    return engine?.currentScene || null;
+}
+/**
+ * useGameLoop - Run a callback every frame
+ *
+ * @param callback - Function called every frame with delta time (in ms)
+ * @param enabled - Whether the loop is active (default: true)
+ */
+export function useGameLoop(callback, enabled = true) {
+    const context = useContext(ExcaliburContext);
+    const callbackRef = useRef(callback);
+    callbackRef.current = callback;
+    useEffect(() => {
+        if (!context || !enabled)
+            return;
+        const wrappedCallback = (delta) => {
+            callbackRef.current(delta);
+        };
+        return context.addUpdateCallback(wrappedCallback);
+    }, [context, enabled]);
+}
+/**
+ * ExcaliburGame - Main wrapper component for Excalibur.js games
+ *
+ * Creates an Excalibur Engine and provides it via context.
+ * Children can use useEngine() to access the engine and add actors/entities.
+ */
+export function ExcaliburGame({ children, width = TILE_WIDTH, height = TILE_HEIGHT, backgroundColor = '#000000', displayMode = DisplayMode.Fixed, options = {}, paused = false, onMount, }) {
+    const containerRef = useRef(null);
+    const engineRef = useRef(null);
+    const updateCallbacksRef = useRef(new Set());
+    const [isReady, setIsReady] = useState(false);
+    // Create Excalibur Engine
+    useEffect(() => {
+        if (!containerRef.current)
+            return;
+        const engine = new Engine({
+            width,
+            height,
+            displayMode,
+            backgroundColor: ExColor.fromHex(backgroundColor),
+            canvasElementId: undefined,
+            antialiasing: options.antialiasing ?? true,
+            pixelArt: options.pixelArt ?? false,
+            suppressPlayButton: options.suppressPlayButton ?? true,
+        });
+        // Mount canvas to container
+        containerRef.current.appendChild(engine.canvas);
+        engineRef.current = engine;
+        // Hook into update cycle to call registered callbacks
+        engine.on('preupdate', (evt) => {
+            const delta = evt.delta;
+            for (const callback of updateCallbacksRef.current) {
+                callback(delta);
+            }
+        });
+        // Start the engine
+        engine.start().then(() => {
+            setIsReady(true);
+            onMount?.(engine);
+        });
+        return () => {
+            setIsReady(false);
+            updateCallbacksRef.current.clear();
+            engine.stop();
+            if (containerRef.current?.contains(engine.canvas)) {
+                containerRef.current.removeChild(engine.canvas);
+            }
+            engineRef.current = null;
+        };
+    }, []); // Only run once on mount
+    // Handle size changes
+    useEffect(() => {
+        if (engineRef.current && engineRef.current.screen) {
+            engineRef.current.screen.resolution = { width, height };
+        }
+    }, [width, height]);
+    // Handle background color changes
+    useEffect(() => {
+        if (engineRef.current) {
+            engineRef.current.backgroundColor = ExColor.fromHex(backgroundColor);
+        }
+    }, [backgroundColor]);
+    // Handle pause state
+    useEffect(() => {
+        if (engineRef.current) {
+            if (paused) {
+                engineRef.current.stop();
+            }
+            else {
+                engineRef.current.start();
+            }
+        }
+    }, [paused]);
+    // Context value with engine and update registration
+    const contextValue = {
+        engine: engineRef.current,
+        addUpdateCallback: useCallback((callback) => {
+            updateCallbacksRef.current.add(callback);
+            return () => {
+                updateCallbacksRef.current.delete(callback);
+            };
+        }, []),
+    };
+    return (React.createElement("div", { ref: containerRef, style: { width, height, overflow: 'hidden' } }, isReady && (React.createElement(ExcaliburContext.Provider, { value: contextValue }, children))));
+}
+/**
+ * useGameState - Helper for managing game state with refs
+ *
+ * Returns a ref and a forceUpdate function for when you need to trigger re-renders.
+ * Use refs for continuous game state (position, velocity) to avoid re-render loops.
+ */
+export function useGameState(initialState) {
+    const stateRef = useRef(initialState);
+    const [, setTick] = useState(0);
+    const forceUpdate = useCallback(() => {
+        setTick((t) => t + 1);
+    }, []);
+    return [stateRef, forceUpdate];
+}
+/**
+ * useGameInput - Simple keyboard input hook for games
+ *
+ * Returns a ref with currently pressed keys.
+ */
+export function useGameInput() {
+    const keysRef = useRef({});
+    useEffect(() => {
+        const handleKeyDown = (e) => {
+            keysRef.current[e.key] = true;
+            keysRef.current[e.code] = true;
+        };
+        const handleKeyUp = (e) => {
+            keysRef.current[e.key] = false;
+            keysRef.current[e.code] = false;
+        };
+        window.addEventListener('keydown', handleKeyDown);
+        window.addEventListener('keyup', handleKeyUp);
+        return () => {
+            window.removeEventListener('keydown', handleKeyDown);
+            window.removeEventListener('keyup', handleKeyUp);
+        };
+    }, []);
+    return keysRef;
+}

package/dist/react/index.js

@@ -5,8 +5,8 @@ export { useKeyboard } from './useKeyboard.js';
 export { TileContainer } from './TileContainer.js';
 export { withTile } from './withTile.js';
 // TileInitializer removed - router should be injected directly into TileProvider
-// NOTE: PixiGame and pixi-related exports are in a SEPARATE entry point
-// to avoid loading pixi.js when not needed. Import from:
-// import { PixiGame, useGameLoop, ... } from '@thewhateverapp/tile-sdk/pixi'
+// NOTE: ExcaliburGame and excalibur-related exports are in a SEPARATE entry point
+// to avoid loading excalibur when not needed. Import from:
+// import { ExcaliburGame, useEngine, useGameLoop, ... } from '@thewhateverapp/tile-sdk/excalibur'
 // Overlay components for hybrid tiles (video/image with interactive overlays)
 export * from './overlay/index.js';

package/dist/scene/index.d.ts

@@ -1,46 +1,8 @@
 /**
  * Scene SDK - Runtime renderer for SceneSpecV1
  *
- * Import from '@thewhateverapp/tile-sdk/scene' to use the scene renderer.
- *
- * @example
- * ```tsx
- * // RECOMMENDED: Use SceneFromJson with a JSON file
- * import { SceneFromJson } from '@thewhateverapp/tile-sdk/scene';
- * import sceneJson from './scene.json';
- *
- * export default function TilePage() {
- *   return <SceneFromJson json={sceneJson} />;
- * }
- * ```
- *
- * @example
- * ```tsx
- * // Alternative: Use SceneRenderer with a spec object (for computed values)
- * import { SceneRenderer } from '@thewhateverapp/tile-sdk/scene';
- * import type { SceneSpecV1 } from '@thewhateverapp/scene-sdk';
- *
- * function MyGame() {
- *   const spec: SceneSpecV1 = { version: 1, entities: [...] };
- *   return <SceneRenderer spec={spec} />;
- * }
- * ```
+ * NOTE: Scene rendering is temporarily disabled pending migration from Pixi.js to Excalibur.
+ * Use @thewhateverapp/tile-sdk/excalibur for game development instead.
  */
-export { SceneFromJson } from './SceneFromJson.js';
-export type { SceneFromJsonProps } from './SceneFromJson.js';
-export { SceneRenderer, useScene } from './SceneRenderer.js';
-export type { SceneRendererProps } from './SceneRenderer.js';
-export { SceneContext, createEntityState, createPlayerState, createCameraState, createInputState, createTimelineState, } from './SceneContext.js';
-export type { SceneContextValue, EntityState, PlayerState, CameraState, InputState, TimelineState, ActiveTween, } from './SceneContext.js';
-export { createEntityGraphics, updateEntityGraphics, } from './entities/EntityGraphics.js';
-export type { EntityGraphics } from './entities/EntityGraphics.js';
-export { usePhysicsEngine, applyImpulse, setVelocity, } from './physics/PhysicsEngine.js';
-export { useInputManager, isJumpPressed, isKeyPressed, isTouching, } from './input/InputManager.js';
-export { useComponentRunner, registerComponent, } from './components/ComponentRunner.js';
-export { useTimelineExecutor } from './timeline/TimelineExecutor.js';
-export { useCameraController } from './camera/CameraController.js';
-export { createGlowOptions, parseColor, isGlowFilterAvailable, createGlowShadow, } from './effects/GlowFilter.js';
-export type { GlowOptions } from './effects/GlowFilter.js';
-export { createEmitter, updateEmitter, drawParticles, burstEmit, } from './effects/ParticleSystem.js';
-export type { Particle, ParticleEmitter } from './effects/ParticleSystem.js';
+export {};
 //# sourceMappingURL=index.d.ts.map

package/dist/scene/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/scene/index.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAGH,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,YAAY,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAG7D,OAAO,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAC7D,YAAY,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAG7D,OAAO,EACL,YAAY,EACZ,iBAAiB,EACjB,iBAAiB,EACjB,iBAAiB,EACjB,gBAAgB,EAChB,mBAAmB,GACpB,MAAM,mBAAmB,CAAC;AAC3B,YAAY,EACV,iBAAiB,EACjB,WAAW,EACX,WAAW,EACX,WAAW,EACX,UAAU,EACV,aAAa,EACb,WAAW,GACZ,MAAM,mBAAmB,CAAC;AAG3B,OAAO,EACL,oBAAoB,EACpB,oBAAoB,GACrB,MAAM,8BAA8B,CAAC;AACtC,YAAY,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAGnE,OAAO,EACL,gBAAgB,EAChB,YAAY,EACZ,WAAW,GACZ,MAAM,4BAA4B,CAAC;AAGpC,OAAO,EACL,eAAe,EACf,aAAa,EACb,YAAY,EACZ,UAAU,GACX,MAAM,yBAAyB,CAAC;AAGjC,OAAO,EACL,kBAAkB,EAClB,iBAAiB,GAClB,MAAM,iCAAiC,CAAC;AAGzC,OAAO,EAAE,mBAAmB,EAAE,MAAM,gCAAgC,CAAC;AAGrE,OAAO,EAAE,mBAAmB,EAAE,MAAM,8BAA8B,CAAC;AAGnE,OAAO,EACL,iBAAiB,EACjB,UAAU,EACV,qBAAqB,EACrB,gBAAgB,GACjB,MAAM,yBAAyB,CAAC;AACjC,YAAY,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAE3D,OAAO,EACL,aAAa,EACb,aAAa,EACb,aAAa,EACb,SAAS,GACV,MAAM,6BAA6B,CAAC;AACrC,YAAY,EAAE,QAAQ,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/scene/index.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AAKH,OAAO,EAAE,CAAC"}

package/dist/scene/index.js

@@ -1,50 +1,2 @@
 'use client';
-/**
- * Scene SDK - Runtime renderer for SceneSpecV1
- *
- * Import from '@thewhateverapp/tile-sdk/scene' to use the scene renderer.
- *
- * @example
- * ```tsx
- * // RECOMMENDED: Use SceneFromJson with a JSON file
- * import { SceneFromJson } from '@thewhateverapp/tile-sdk/scene';
- * import sceneJson from './scene.json';
- *
- * export default function TilePage() {
- *   return <SceneFromJson json={sceneJson} />;
- * }
- * ```
- *
- * @example
- * ```tsx
- * // Alternative: Use SceneRenderer with a spec object (for computed values)
- * import { SceneRenderer } from '@thewhateverapp/tile-sdk/scene';
- * import type { SceneSpecV1 } from '@thewhateverapp/scene-sdk';
- *
- * function MyGame() {
- *   const spec: SceneSpecV1 = { version: 1, entities: [...] };
- *   return <SceneRenderer spec={spec} />;
- * }
- * ```
- */
-// Main components - JSON-first approach
-export { SceneFromJson } from './SceneFromJson.js';
-// SceneRenderer for advanced use (computed specs)
-export { SceneRenderer, useScene } from './SceneRenderer.js';
-// Context and types
-export { SceneContext, createEntityState, createPlayerState, createCameraState, createInputState, createTimelineState, } from './SceneContext.js';
-// Entity graphics (imperative pixi creation)
-export { createEntityGraphics, updateEntityGraphics, } from './entities/EntityGraphics.js';
-// Physics
-export { usePhysicsEngine, applyImpulse, setVelocity, } from './physics/PhysicsEngine.js';
-// Input
-export { useInputManager, isJumpPressed, isKeyPressed, isTouching, } from './input/InputManager.js';
-// Components
-export { useComponentRunner, registerComponent, } from './components/ComponentRunner.js';
-// Timeline
-export { useTimelineExecutor } from './timeline/TimelineExecutor.js';
-// Camera
-export { useCameraController } from './camera/CameraController.js';
-// Effects
-export { createGlowOptions, parseColor, isGlowFilterAvailable, createGlowShadow, } from './effects/GlowFilter.js';
-export { createEmitter, updateEmitter, drawParticles, burstEmit, } from './effects/ParticleSystem.js';
+export {};

package/dist/spec/schema.d.ts

@@ -28,10 +28,10 @@ declare const ActionSchema: z.ZodObject<{
     $action: z.ZodEnum<["emit", "setState", "sequence", "openTile", "openFull", "navigate", "dismiss", "fx"]>;
     payload: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, "strip", z.ZodTypeAny, {
-    $action: "navigate" | "setState" | "emit" | "fx" | "sequence" | "openTile" | "openFull" | "dismiss";
+    $action: "navigate" | "setState" | "emit" | "sequence" | "openTile" | "openFull" | "dismiss" | "fx";
     payload?: Record<string, unknown> | undefined;
 }, {
-    $action: "navigate" | "setState" | "emit" | "fx" | "sequence" | "openTile" | "openFull" | "dismiss";
+    $action: "navigate" | "setState" | "emit" | "sequence" | "openTile" | "openFull" | "dismiss" | "fx";
     payload?: Record<string, unknown> | undefined;
 }>;
 declare const PropValueSchema: z.ZodType<unknown>;
@@ -347,11 +347,11 @@ export declare const OverlaySpecSchema: z.ZodObject<{
             offsetMs: z.ZodOptional<z.ZodNumber>;
             scale: z.ZodOptional<z.ZodNumber>;
         }, "strip", z.ZodTypeAny, {
-            scale?: number | undefined;
             offsetMs?: number | undefined;
-        }, {
             scale?: number | undefined;
+        }, {
             offsetMs?: number | undefined;
+            scale?: number | undefined;
         }>>;
         freezeWhen: z.ZodOptional<z.ZodType<unknown, z.ZodTypeDef, unknown>>;
     }, "strip", z.ZodTypeAny, {
@@ -360,8 +360,8 @@ export declare const OverlaySpecSchema: z.ZodObject<{
         toleranceMs: number;
         onSeek: "recompute";
         transform?: {
-            scale?: number | undefined;
             offsetMs?: number | undefined;
+            scale?: number | undefined;
         } | undefined;
         freezeWhen?: unknown;
     }, {
@@ -370,8 +370,8 @@ export declare const OverlaySpecSchema: z.ZodObject<{
         toleranceMs: number;
         onSeek: "recompute";
         transform?: {
-            scale?: number | undefined;
             offsetMs?: number | undefined;
+            scale?: number | undefined;
         } | undefined;
         freezeWhen?: unknown;
     }>;
@@ -702,14 +702,14 @@ export declare const OverlaySpecSchema: z.ZodObject<{
         transform: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
         id: string;
-        type: "realtime" | "keyspace" | "host";
         target: string;
+        type: "realtime" | "keyspace" | "host";
         channel: string;
         transform?: string | undefined;
     }, {
         id: string;
-        type: "realtime" | "keyspace" | "host";
         target: string;
+        type: "realtime" | "keyspace" | "host";
         channel: string;
         transform?: string | undefined;
     }>, "many">>;
@@ -726,8 +726,8 @@ export declare const OverlaySpecSchema: z.ZodObject<{
         toleranceMs: number;
         onSeek: "recompute";
         transform?: {
-            scale?: number | undefined;
             offsetMs?: number | undefined;
+            scale?: number | undefined;
         } | undefined;
         freezeWhen?: unknown;
     };
@@ -787,8 +787,8 @@ export declare const OverlaySpecSchema: z.ZodObject<{
     } | undefined;
     subscriptions?: {
         id: string;
-        type: "realtime" | "keyspace" | "host";
         target: string;
+        type: "realtime" | "keyspace" | "host";
         channel: string;
         transform?: string | undefined;
     }[] | undefined;
@@ -805,8 +805,8 @@ export declare const OverlaySpecSchema: z.ZodObject<{
         toleranceMs: number;
         onSeek: "recompute";
         transform?: {
-            scale?: number | undefined;
             offsetMs?: number | undefined;
+            scale?: number | undefined;
         } | undefined;
         freezeWhen?: unknown;
     };
@@ -866,8 +866,8 @@ export declare const OverlaySpecSchema: z.ZodObject<{
     } | undefined;
     subscriptions?: {
         id: string;
-        type: "realtime" | "keyspace" | "host";
         target: string;
+        type: "realtime" | "keyspace" | "host";
         channel: string;
         transform?: string | undefined;
     }[] | undefined;