phibelle-kit 1.0.0

package/dist/lib/folder.js

@@ -0,0 +1,33 @@
+import { spawn } from "node:child_process";
+import os from "node:os";
+import * as fs from "fs";
+export function openFolder(folderPath) {
+    const platform = os.platform();
+    let command;
+    let args;
+    if (platform === "win32") {
+        command = "explorer.exe";
+        args = [folderPath];
+    }
+    else if (platform === "darwin") {
+        command = "open";
+        args = [folderPath];
+    }
+    else {
+        command = "xdg-open";
+        args = [folderPath];
+    }
+    const child = spawn(command, args, {
+        detached: true,
+        stdio: "ignore",
+    });
+    child.unref();
+}
+export function folderExists(folderPath) {
+    return fs.existsSync(folderPath);
+}
+export function createFolder(folderPath) {
+    if (!folderExists(folderPath)) {
+        fs.mkdirSync(folderPath, { recursive: true });
+    }
+}

package/dist/lib/public-env.d.ts

@@ -0,0 +1,3 @@
+export declare const isDev: boolean;
+export declare const BASE_URL: string;
+export declare const CONVEX_URL: string;

package/dist/lib/public-env.js

@@ -0,0 +1,3 @@
+export const isDev = process.env.NODE_ENV === "development";
+export const BASE_URL = isDev ? "http://localhost:3131" : "https://phibelle.studio";
+export const CONVEX_URL = isDev ? "https://mellow-toad-676.convex.cloud" : "https://keen-dove-500.convex.cloud";

package/dist/lib/scene-packaging.d.ts

@@ -0,0 +1,6 @@
+/** Matches entity script filenames; group 1 is engine id. Use in both .test() and .match(). */
+export declare const ENTITY_FILE_RE: RegExp;
+export declare function unpackageScene(sceneId: string, sceneDir: string): Promise<void>;
+export declare function pushScriptChange(sceneId: string, sceneDir: string, changedFile: string): Promise<void>;
+/** Add a new entity to the scene when user creates entity-<engineId>.tsx locally. */
+export declare function pushNewEntity(sceneId: string, sceneDir: string, engineId: number): Promise<void>;

package/dist/lib/scene-packaging.js

@@ -0,0 +1,196 @@
+import * as fs from "fs/promises";
+import * as path from "path";
+import { queryOnce, mutateOnce } from "./convex-client.js";
+import { api } from "../convex/_generated/api.js";
+import { getSessionId } from "./conf.js";
+async function getSceneFileContent(sceneId) {
+    const fileUrl = await queryOnce(api.scenes.getSceneFileUrl, { sceneId });
+    if (fileUrl == null) {
+        throw new Error("Scene file not found (scene may be missing or have no file yet)");
+    }
+    const response = await fetch(fileUrl);
+    if (!response.ok) {
+        throw new Error(`Failed to download scene file: ${response.status} ${response.statusText}`);
+    }
+    return response.text();
+}
+function parseSceneJson(content) {
+    try {
+        return JSON.parse(content);
+    }
+    catch {
+        throw new Error("Invalid scene file: not valid JSON");
+    }
+}
+/** Matches entity script filenames; group 1 is engine id. Use in both .test() and .match(). */
+export const ENTITY_FILE_RE = /^entity-(\d+)\.tsx$/;
+async function uploadSceneJsonAndUpdate(sceneId, json) {
+    const uploadUrl = await mutateOnce(api.storage.generateUploadUrl, {});
+    if (typeof uploadUrl !== "string") {
+        throw new Error("Invalid upload URL response");
+    }
+    const uploadResult = await fetch(uploadUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: json,
+    });
+    if (!uploadResult.ok) {
+        throw new Error(`Failed to upload scene file: ${uploadResult.status} ${uploadResult.statusText}`);
+    }
+    const uploadResponse = (await uploadResult.json());
+    const storageId = uploadResponse.storageId;
+    if (!storageId) {
+        throw new Error("Upload response missing storageId");
+    }
+    const sceneByteLength = Buffer.byteLength(json, "utf8");
+    await mutateOnce(api.scenes.update, {
+        id: sceneId,
+        sceneFileId: storageId,
+        sceneByteLength,
+        lastModifiedSessionId: getSessionId(),
+    });
+}
+export async function unpackageScene(sceneId, sceneDir) {
+    const content = await getSceneFileContent(sceneId);
+    const parsed = parseSceneJson(content);
+    await fs.mkdir(sceneDir, { recursive: true });
+    // Remove existing entity files so entities deleted in the editor are removed from disk
+    try {
+        const entries = await fs.readdir(sceneDir, { withFileTypes: true });
+        for (const ent of entries) {
+            if (ent.isFile() && ENTITY_FILE_RE.test(ent.name)) {
+                await fs.unlink(path.join(sceneDir, ent.name));
+            }
+        }
+    }
+    catch {
+        // Directory might not exist or be empty; ignore
+    }
+    const entities = parsed.entityStore?.entities ?? {};
+    const manifest = {
+        sceneScript: "scene.tsx",
+        entities: {},
+    };
+    await fs.writeFile(path.join(sceneDir, "scene.tsx"), parsed.sceneScriptStore?.sceneScript ?? "", "utf8");
+    for (const idStr of Object.keys(entities)) {
+        const entity = entities[idStr];
+        if (!entity || typeof entity.script !== "string")
+            continue;
+        const engineId = String(entity.engineId ?? idStr);
+        const fileName = `entity-${engineId}.tsx`;
+        manifest.entities[engineId] = fileName;
+        await fs.writeFile(path.join(sceneDir, fileName), entity.script, "utf8");
+    }
+    await fs.writeFile(path.join(sceneDir, "manifest.json"), JSON.stringify(manifest, null, 2), "utf8");
+}
+export async function pushScriptChange(sceneId, sceneDir, changedFile) {
+    const manifestPath = path.join(sceneDir, "manifest.json");
+    let manifestRaw;
+    try {
+        manifestRaw = await fs.readFile(manifestPath, "utf8");
+    }
+    catch {
+        throw new Error("manifest.json not found; run watch-scene to unpackage first");
+    }
+    const manifest = JSON.parse(manifestRaw);
+    const content = await getSceneFileContent(sceneId);
+    const parsed = parseSceneJson(content);
+    const filePath = path.join(sceneDir, changedFile);
+    let fileContent;
+    try {
+        fileContent = await fs.readFile(filePath, "utf8");
+    }
+    catch {
+        throw new Error(`Could not read file: ${changedFile}`);
+    }
+    const isSceneScript = manifest.sceneScript === changedFile;
+    if (isSceneScript) {
+        if (!parsed.sceneScriptStore)
+            parsed.sceneScriptStore = { sceneScript: "", sceneProperties: [], lastModifiedSceneScript: 0 };
+        parsed.sceneScriptStore.sceneScript = fileContent;
+        if (typeof parsed.sceneScriptStore.lastModifiedSceneScript === "number") {
+            parsed.sceneScriptStore.lastModifiedSceneScript = Date.now();
+        }
+    }
+    else {
+        const entityId = Object.entries(manifest.entities).find(([, f]) => f === changedFile)?.[0];
+        if (entityId == null) {
+            throw new Error(`Unknown script file: ${changedFile}`);
+        }
+        const entities = parsed.entityStore?.entities ?? {};
+        const entity = entities[entityId];
+        if (!entity) {
+            throw new Error(`Entity ${entityId} no longer in scene; skip or sync from app`);
+        }
+        entity.script = fileContent;
+        entity.scriptVersion = (entity.scriptVersion ?? 0) + 1;
+    }
+    const json = JSON.stringify(parsed);
+    await uploadSceneJsonAndUpdate(sceneId, json);
+}
+const DEFAULT_POSITION = '{"x":0,"y":0,"z":0}';
+const DEFAULT_ROTATION = '{"isEuler":true,"_x":0,"_y":0,"_z":0,"_order":"XYZ"}';
+const DEFAULT_SCALE = '{"x":1,"y":1,"z":1}';
+/** Add a new entity to the scene when user creates entity-<engineId>.tsx locally. */
+export async function pushNewEntity(sceneId, sceneDir, engineId) {
+    const manifestPath = path.join(sceneDir, "manifest.json");
+    let manifestRaw;
+    try {
+        manifestRaw = await fs.readFile(manifestPath, "utf8");
+    }
+    catch {
+        throw new Error("manifest.json not found; run watch-scene to unpackage first");
+    }
+    const manifest = JSON.parse(manifestRaw);
+    const idStr = String(engineId);
+    if (manifest.entities[idStr]) {
+        throw new Error(`Entity ${engineId} already exists in manifest`);
+    }
+    const content = await getSceneFileContent(sceneId);
+    const parsed = parseSceneJson(content);
+    const fileName = `entity-${engineId}.tsx`;
+    const filePath = path.join(sceneDir, fileName);
+    let script;
+    try {
+        script = await fs.readFile(filePath, "utf8");
+    }
+    catch {
+        throw new Error(`Could not read file: ${fileName}`);
+    }
+    if (!parsed.entityStore) {
+        parsed.entityStore = {
+            _currId: 0,
+            rootEntities: [],
+            entities: {},
+            rootRenderVersion: 0,
+            lastRenderedVersion: 0,
+            selectedEntityIds: [],
+        };
+    }
+    const store = parsed.entityStore;
+    store._currId = Math.max(store._currId, engineId);
+    if (!store.rootEntities.includes(engineId)) {
+        store.rootEntities.push(engineId);
+    }
+    store.entities[idStr] = {
+        name: `Entity-${engineId}`,
+        engineId,
+        childrenIdsSet: [],
+        childrenIds: [],
+        isNodeOpen: false,
+        script,
+        scriptVersion: 0,
+        transform: {
+            position: DEFAULT_POSITION,
+            rotation: DEFAULT_ROTATION,
+            scale: DEFAULT_SCALE,
+        },
+        renderVersion: 0,
+        properties: [],
+        threeId: 0,
+    };
+    manifest.entities[idStr] = fileName;
+    await fs.writeFile(manifestPath, JSON.stringify(manifest, null, 2), "utf8");
+    const json = JSON.stringify(parsed);
+    await uploadSceneJsonAndUpdate(sceneId, json);
+}

package/dist/lib/script-watcher.d.ts

@@ -0,0 +1,9 @@
+export type ScriptWatcher = {
+    close: () => void;
+};
+export type WatchCallbacks = {
+    onPushed: (file: string) => void;
+    onNewEntity: (engineId: number) => void;
+    onError: (file: string, err: Error) => void;
+};
+export declare function createScriptWatcher(sceneId: string, sceneDir: string, onPushed: (file: string) => void, onNewEntity: (engineId: number) => void, onError: (file: string, err: Error) => void): ScriptWatcher;

package/dist/lib/script-watcher.js

@@ -0,0 +1,90 @@
+import * as path from "path";
+import * as fs from "fs";
+import chokidar from "chokidar";
+import { pushScriptChange, pushNewEntity, ENTITY_FILE_RE } from "./scene-packaging.js";
+const DEBOUNCE_MS = 600;
+export function createScriptWatcher(sceneId, sceneDir, onPushed, onNewEntity, onError) {
+    const manifestPath = path.join(sceneDir, "manifest.json");
+    function readManifest() {
+        try {
+            const raw = fs.readFileSync(manifestPath, "utf8");
+            return JSON.parse(raw);
+        }
+        catch {
+            return null;
+        }
+    }
+    let debounceTimer = null;
+    let lastEvent = null;
+    function schedule(type, file) {
+        lastEvent = { type, file };
+        if (debounceTimer)
+            clearTimeout(debounceTimer);
+        debounceTimer = setTimeout(async () => {
+            debounceTimer = null;
+            const ev = lastEvent;
+            lastEvent = null;
+            if (!ev)
+                return;
+            const manifest = readManifest();
+            if (!manifest)
+                return;
+            const basename = ev.file;
+            if (basename === manifest.sceneScript) {
+                try {
+                    await pushScriptChange(sceneId, sceneDir, basename);
+                    onPushed(basename);
+                }
+                catch (err) {
+                    onError(basename, err instanceof Error ? err : new Error(String(err)));
+                }
+                return;
+            }
+            const entityMatch = basename.match(ENTITY_FILE_RE);
+            if (entityMatch) {
+                const engineId = parseInt(entityMatch[1], 10);
+                const isNew = !manifest.entities[String(engineId)];
+                if (isNew) {
+                    try {
+                        await pushNewEntity(sceneId, sceneDir, engineId);
+                        onNewEntity(engineId);
+                    }
+                    catch (err) {
+                        onError(basename, err instanceof Error ? err : new Error(String(err)));
+                    }
+                }
+                else {
+                    try {
+                        await pushScriptChange(sceneId, sceneDir, basename);
+                        onPushed(basename);
+                    }
+                    catch (err) {
+                        onError(basename, err instanceof Error ? err : new Error(String(err)));
+                    }
+                }
+            }
+        }, DEBOUNCE_MS);
+    }
+    const watcher = chokidar.watch(sceneDir, { ignoreInitial: true });
+    watcher.on("change", (filePath) => {
+        const basename = path.basename(filePath);
+        if (basename === "manifest.json")
+            return;
+        if (basename === "scene.tsx" || ENTITY_FILE_RE.test(basename)) {
+            schedule("change", basename);
+        }
+    });
+    watcher.on("add", (filePath) => {
+        const basename = path.basename(filePath);
+        if (basename === "scene.tsx" || ENTITY_FILE_RE.test(basename)) {
+            schedule("add", basename);
+        }
+    });
+    return {
+        close: () => {
+            if (debounceTimer)
+                clearTimeout(debounceTimer);
+            watcher.close();
+        },
+    };
+}

package/dist/lib/types.d.ts

@@ -0,0 +1,62 @@
+/** Scene document from Convex (scenes.getById / listMyScenes) */
+export type Scene = {
+    _id: string;
+    name: string;
+    updatedAt: number;
+    ownerId: string;
+    sceneFileId: string;
+    createdAt: number;
+    sceneByteLength?: number;
+    screenshotFileId?: string;
+    /** Set when scene file is updated; used to avoid re-unpack when this CLI saved. */
+    lastModifiedSessionId?: string;
+};
+export type PhibelleScene = {
+    entityStore: {
+        _currId: number;
+        rootEntities: number[];
+        entities: {
+            [id: string]: {
+                name: string;
+                engineId: number;
+                childrenIdsSet: number[];
+                childrenIds: number[];
+                isNodeOpen: boolean;
+                script: string;
+                scriptVersion: number;
+                transform: {
+                    position: string;
+                    rotation: string;
+                    scale: string;
+                };
+                renderVersion: number;
+                properties: Array<{
+                    name: string;
+                    type: string;
+                    value: any;
+                }>;
+                threeId: number;
+            };
+        };
+        rootRenderVersion: number;
+        lastRenderedVersion: number;
+        selectedEntityIds: number[];
+    };
+    editorCameraStore: {
+        orthographic: boolean;
+        cameraPosition: [number, number, number];
+        cameraRotation: [number, number, number, string];
+        targetPosition: [number, number, number];
+    };
+    errorStore: Record<string, unknown>;
+    sceneScriptStore: {
+        sceneScript: string;
+        sceneProperties: any[];
+        lastModifiedSceneScript: number;
+    };
+    engineModeStore: {
+        engineMode: string;
+        transformMode: string;
+    };
+    version: string;
+};

package/dist/lib/types.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/utils.d.ts

@@ -0,0 +1 @@
+export declare function toErrorMessage(err: unknown): string;

package/dist/lib/utils.js

@@ -0,0 +1,3 @@
+export function toErrorMessage(err) {
+    return err instanceof Error ? err.message : String(err);
+}

package/dist/lib/wait-for-token.d.ts

@@ -0,0 +1 @@
+export declare function waitForToken(): Promise<string>;

package/dist/lib/wait-for-token.js

@@ -0,0 +1,30 @@
+import http from "node:http";
+import { setToken } from "./conf.js";
+import { BASE_URL } from "./public-env.js";
+import open from "open";
+const PORT = 13131;
+export function waitForToken() {
+    return new Promise((resolve) => {
+        const server = http.createServer((req, res) => {
+            const url = new URL(req.url, `http://localhost`);
+            const token = url.searchParams.get("token");
+            res.setHeader("Access-Control-Allow-Origin", "*");
+            res.setHeader("Access-Control-Allow-Methods", "GET");
+            if (token) {
+                res.writeHead(200, { "Content-Type": "text/html" });
+                res.end("Token received");
+                server.close();
+                resolve(token);
+                setToken(token);
+            }
+            else {
+                res.writeHead(400);
+                res.end("Missing token");
+            }
+        });
+        server.listen(PORT, () => {
+            console.log("Opening browser to authenticate...");
+            open(`${BASE_URL}/cli-token`);
+        });
+    });
+}

package/dist/package/global-module.d.ts

@@ -0,0 +1 @@
+export declare const GLOBAL_MODULE = "\nimport type React from \"react\";\nimport type * as THREE_IMPORT from \"three\";\nimport type * as DREI_IMPORT from \"@react-three/drei\";\nimport type * as R3F_IMPORT from \"@react-three/fiber\";\nimport type * as UIKIT_IMPORT from \"@react-three/uikit\";\nimport type * as RAPIER_IMPORT from \"@react-three/rapier\";\n\ndeclare global {\n  const THREE: typeof THREE_IMPORT;\n  const DREI: typeof DREI_IMPORT;\n  const R3F: typeof R3F_IMPORT;\n  const UIKIT: typeof UIKIT_IMPORT;\n  const RAPIER: typeof RAPIER_IMPORT;\n\n  namespace PHI {\n    type Transform = {\n      position: THREE_IMPORT.Vector3;\n      rotation: THREE_IMPORT.Euler;\n      scale: THREE_IMPORT.Vector3;\n    };\n\n    type PropertyType = string;\n\n    type Property = {\n      name: string;\n      type: PropertyType;\n      value: unknown;\n    };\n\n    type EntityData = {\n      name: string;\n      engineId: number;\n      threeId?: number;\n      parentId?: number;\n      childrenIds: number[];\n      transform: Transform;\n      properties: Property[];\n    };\n\n    type GamepadInfo = {\n      connected: boolean;\n      buttonA: boolean;\n      buttonB: boolean;\n      buttonX: boolean;\n      buttonY: boolean;\n      joystick: [number, number];\n      joystickRight: [number, number];\n      RB: boolean;\n      LB: boolean;\n      RT: boolean;\n      LT: boolean;\n      start: boolean;\n      select: boolean;\n      up: boolean;\n      down: boolean;\n      left: boolean;\n      right: boolean;\n    };\n\n    type EngineMode = {\n      editMode: boolean;\n      playMode: boolean;\n    };\n\n    type SceneScriptState = {\n      sceneProperties: Record<string, unknown>;\n    };\n\n    type EntityRenderRegistry = Record<\n      string,\n      React.FC<{ entityData: EntityData }>\n    >;\n  }\n\n  const PHI: {\n    globalStore: Record<string, any>;\n\n    PROPERTY_TYPES: ReadonlyArray<{\n      type: PHI.PropertyType;\n      defaultValue: unknown;\n    }>;\n\n    phibelleResetSelectedEntityIds(): void;\n\n    useEntityThreeObject(\n      entityData: PHI.EntityData,\n      threeScene: THREE_IMPORT.Scene\n    ): THREE_IMPORT.Object3D | null;\n\n    useGamepad(): PHI.GamepadInfo;\n\n    usePlayModeFrame(\n      callback: (state: R3F_IMPORT.RootState, delta: number) => void\n    ): void;\n\n    useEngineMode(): PHI.EngineMode;\n\n    useSceneScriptStore(): PHI.SceneScriptState;\n    useSceneScriptStore<T>(\n      selector: (state: PHI.SceneScriptState) => T\n    ): T;\n\n    editEntities(\n      edits: Array<{ id: number; newData: Partial<PHI.EntityData> }>\n    ): void;\n\n    useEntity(entityId: number): { entityData: PHI.EntityData };\n\n    PhibelleRoot: React.FC<{\n      entityRenderRegistry: PHI.EntityRenderRegistry;\n    }>;\n  };\n}\n\nexport {};\n";

package/dist/package/global-module.js

@@ -0,0 +1,117 @@
+export const GLOBAL_MODULE = `
+import type React from "react";
+import type * as THREE_IMPORT from "three";
+import type * as DREI_IMPORT from "@react-three/drei";
+import type * as R3F_IMPORT from "@react-three/fiber";
+import type * as UIKIT_IMPORT from "@react-three/uikit";
+import type * as RAPIER_IMPORT from "@react-three/rapier";
+
+declare global {
+  const THREE: typeof THREE_IMPORT;
+  const DREI: typeof DREI_IMPORT;
+  const R3F: typeof R3F_IMPORT;
+  const UIKIT: typeof UIKIT_IMPORT;
+  const RAPIER: typeof RAPIER_IMPORT;
+
+  namespace PHI {
+    type Transform = {
+      position: THREE_IMPORT.Vector3;
+      rotation: THREE_IMPORT.Euler;
+      scale: THREE_IMPORT.Vector3;
+    };
+
+    type PropertyType = string;
+
+    type Property = {
+      name: string;
+      type: PropertyType;
+      value: unknown;
+    };
+
+    type EntityData = {
+      name: string;
+      engineId: number;
+      threeId?: number;
+      parentId?: number;
+      childrenIds: number[];
+      transform: Transform;
+      properties: Property[];
+    };
+
+    type GamepadInfo = {
+      connected: boolean;
+      buttonA: boolean;
+      buttonB: boolean;
+      buttonX: boolean;
+      buttonY: boolean;
+      joystick: [number, number];
+      joystickRight: [number, number];
+      RB: boolean;
+      LB: boolean;
+      RT: boolean;
+      LT: boolean;
+      start: boolean;
+      select: boolean;
+      up: boolean;
+      down: boolean;
+      left: boolean;
+      right: boolean;
+    };
+
+    type EngineMode = {
+      editMode: boolean;
+      playMode: boolean;
+    };
+
+    type SceneScriptState = {
+      sceneProperties: Record<string, unknown>;
+    };
+
+    type EntityRenderRegistry = Record<
+      string,
+      React.FC<{ entityData: EntityData }>
+    >;
+  }
+
+  const PHI: {
+    globalStore: Record<string, any>;
+
+    PROPERTY_TYPES: ReadonlyArray<{
+      type: PHI.PropertyType;
+      defaultValue: unknown;
+    }>;
+
+    phibelleResetSelectedEntityIds(): void;
+
+    useEntityThreeObject(
+      entityData: PHI.EntityData,
+      threeScene: THREE_IMPORT.Scene
+    ): THREE_IMPORT.Object3D | null;
+
+    useGamepad(): PHI.GamepadInfo;
+
+    usePlayModeFrame(
+      callback: (state: R3F_IMPORT.RootState, delta: number) => void
+    ): void;
+
+    useEngineMode(): PHI.EngineMode;
+
+    useSceneScriptStore(): PHI.SceneScriptState;
+    useSceneScriptStore<T>(
+      selector: (state: PHI.SceneScriptState) => T
+    ): T;
+
+    editEntities(
+      edits: Array<{ id: number; newData: Partial<PHI.EntityData> }>
+    ): void;
+
+    useEntity(entityId: number): { entityData: PHI.EntityData };
+
+    PhibelleRoot: React.FC<{
+      entityRenderRegistry: PHI.EntityRenderRegistry;
+    }>;
+  };
+}
+
+export {};
+`;

package/dist/package/npm-package.d.ts

@@ -0,0 +1 @@
+export declare const getNpmPackage: (sceneId: string) => string;

package/dist/package/npm-package.js

@@ -0,0 +1,16 @@
+export const getNpmPackage = (sceneId) => {
+    return `{
+  "scripts": {
+    "watch": "phibelle-kit watch ${sceneId}"
+  },
+  "dependencies": {
+    "@react-three/drei": "^10.7.7",
+    "@react-three/fiber": "^9.5.0",
+    "@react-three/rapier": "^2.2.0",
+    "@react-three/uikit": "^1.0.61",
+    "react": "^19.1.1",
+    "react-dom": "19.1.1",
+    "three": "^0.179.1"
+  }
+}`;
+};

package/dist/package/phibelle-module.d.ts

@@ -0,0 +1 @@
+export declare const PHIBELLE_MODULE = "\n// node_modules/phibelle/index.d.ts\nimport { RootState } from \"@react-three/fiber\";\nimport type * as THREE from \"three\";\n\ndeclare module \"phibelle\" {\n  // ----------------------------\n  // Global window store\n  // ----------------------------\n  export const globalStore: {\n    [key: string]: any;\n  };\n\n  // ----------------------------\n  // Types used by scripts\n  // ----------------------------\n  export type Transform = {\n    position: THREE.Vector3;\n    rotation: THREE.Euler;\n    scale: THREE.Vector3;\n  };\n\n  export type PropertyType = string;\n\n  export type Property = {\n    name: string;\n    type: PropertyType;\n    value: string | number | boolean | [number, number, number];\n  };\n\n  export type EntityData = {\n    name: string;\n    engineId: number;\n    threeId?: number;\n    parentId?: number;\n    childrenIds: number[];\n    transform: Transform;\n    properties: Property[];\n  };\n\n  export const PROPERTY_TYPES: ReadonlyArray<{\n    type: PropertyType;\n    defaultValue: unknown;\n  }>;\n\n  // ----------------------------\n  // Engine / editor functions\n  // ----------------------------\n  export function phibelleResetSelectedEntityIds(): void;\n\n  // ----------------------------\n  // Hooks exposed to scripts\n  // ----------------------------\n  export function useEntityThreeObject(\n    entityData: EntityData,\n    threeScene: THREE.Scene\n  ): THREE.Object3D | null;\n\n  export type GamepadInfo = {\n    connected: boolean;\n    buttonA: boolean;\n    buttonB: boolean;\n    buttonX: boolean;\n    buttonY: boolean;\n    joystick: [number, number];\n    joystickRight: [number, number];\n    RB: boolean;\n    LB: boolean;\n    RT: boolean;\n    LT: boolean;\n    start: boolean;\n    select: boolean;\n    up: boolean;\n    down: boolean;\n    left: boolean;\n    right: boolean;\n  };\n\n  export function useGamepad(): GamepadInfo;\n\n  export function usePlayModeFrame(\n    callback: (state: RootState, delta: number) => void\n  ): void;\n\n  export type EngineMode = {\n    editMode: boolean;\n    playMode: boolean;\n  };\n\n  export function useEngineMode(): EngineMode;\n\n  // Zustand-like store stub you generate\n  export type SceneScriptState = {\n    sceneProperties: Record<string, unknown>;\n  };\n\n  export function useSceneScriptStore(): SceneScriptState;\n  export function useSceneScriptStore<T>(\n    selector: (state: SceneScriptState) => T\n  ): T;\n\n  export function editEntities(\n    edits: Array<{ id: number; newData: Partial<EntityData> }>\n  ): void;\n\n  export function useEntity(entityId: number): { entityData: EntityData };\n\n  // ----------------------------\n  // Components\n  // ----------------------------\n  export type EntityRenderRegistry = Record<\n    string,\n    React.FC<{ entityData: EntityData }>\n  >;\n\n  export const PhibelleRoot: React.FC<{\n    entityRenderRegistry: EntityRenderRegistry;\n  }>;\n}\n\nexport {};\n";