phibelle-kit 1.0.22 → 1.0.24

package/dist/lib/scene/scene-packaging.js

@@ -1,24 +1,10 @@
 import * as fs from "fs/promises";
 import * as path from "path";
 import { getSceneAppDir } from "./file-system.js";
-import { queryOnce, mutateOnce } from "../api/convex-client.js";
-import { api } from "../../convex/_generated/api.js";
-import { getSessionId } from "../auth/conf.js";
 /** Scene-level file names in app/. */
 export const SCENE_SCRIPT_FILE = "scene-script.tsx";
 export const SCENE_PROPERTIES_FILE = "scene-properties.json";
-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) {
+export function parseSceneJson(content) {
     try {
         return JSON.parse(content);
     }
@@ -43,11 +29,6 @@ export function slugToEntityName(slug) {
         .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
         .join(" ");
 }
-/**
- * Matches entity folder names: <entity-name>-<engineId> (e.g. main-enemy-1).
- * Group 1 = slug, group 2 = engine id.
- */
-export const ENTITY_FOLDER_RE = /^([a-z0-9]+(?:-[a-z0-9]+)*)-(\d+)$/;
 /** Entity filenames inside an entity folder. */
 export const ENTITY_SCRIPT_FILE = "script.tsx";
 export const ENTITY_PROPERTIES_FILE = "properties.json";
@@ -55,57 +36,41 @@ export const ENTITY_TRANSFORMS_FILE = "transforms.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}';
-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);
+/** Unpackage scene JSON to filesystem. No DB; accepts full scene JSON string. */
+export async function unpackageScene(sceneJson, sceneDir, sceneId) {
+    const parsed = parseSceneJson(sceneJson);
+    const parsedSceneId = typeof parsed._id === "string"
+        ? parsed._id
+        : "";
     const appDir = getSceneAppDir(sceneDir);
     await fs.mkdir(appDir, { recursive: true });
-    // Remove existing entity files/folders and legacy scene.tsx so entities deleted in the editor are removed from disk
     try {
         const entries = await fs.readdir(appDir, { withFileTypes: true });
         for (const ent of entries) {
             if (ent.isFile()) {
                 if (ent.name === "scene.tsx")
                     await fs.unlink(path.join(appDir, ent.name));
-                else if (ENTITY_FOLDER_RE.test(ent.name.replace(/\.tsx$/, "")))
+                else if (ent.name.endsWith(".tsx") && ent.name !== SCENE_SCRIPT_FILE)
                     await fs.unlink(path.join(appDir, ent.name));
             }
-            if (ent.isDirectory() && ENTITY_FOLDER_RE.test(ent.name)) {
-                await fs.rm(path.join(appDir, ent.name), { recursive: true });
+            if (ent.isDirectory()) {
+                const scriptPath = path.join(appDir, ent.name, ENTITY_SCRIPT_FILE);
+                try {
+                    await fs.access(scriptPath);
+                    await fs.rm(path.join(appDir, ent.name), { recursive: true });
+                }
+                catch {
+                    /* no script.tsx, leave dir alone */
+                }
             }
         }
     }
     catch {
-        // Directory might not exist or be empty; ignore
+        /* directory might not exist or be empty */
     }
     const entities = parsed.entityStore?.entities ?? {};
     const manifest = {
+        sceneId: sceneId?.trim() || parsedSceneId,
         sceneScript: SCENE_SCRIPT_FILE,
         sceneProperties: SCENE_PROPERTIES_FILE,
         entities: {},
@@ -113,25 +78,28 @@ export async function unpackageScene(sceneId, sceneDir) {
     await fs.writeFile(path.join(appDir, SCENE_SCRIPT_FILE), parsed.sceneScriptStore?.sceneScript ?? "", "utf8");
     const scenePropertiesJson = JSON.stringify(parsed.sceneScriptStore?.sceneProperties ?? [], null, 2);
     await fs.writeFile(path.join(appDir, SCENE_PROPERTIES_FILE), scenePropertiesJson, "utf8");
+    const usedFolderNames = new Set();
     for (const idStr of Object.keys(entities)) {
         const entity = entities[idStr];
         if (!entity || typeof entity.script !== "string")
             continue;
         const engineId = String(entity.engineId ?? idStr);
-        let slug = entityNameToSlug(entity.name ?? "Entity");
-        const redundantPrefix = `entity-${engineId}`;
-        if (slug === redundantPrefix)
-            slug = "entity";
-        else if (slug.startsWith(redundantPrefix + "-"))
-            slug = slug.slice((redundantPrefix + "-").length);
-        const folderName = `${slug}-${engineId}`;
+        const baseName = entity.name ?? "Entity";
+        let folderName = baseName;
+        if (usedFolderNames.has(folderName))
+            folderName = `${baseName}-${engineId}`;
+        usedFolderNames.add(folderName);
         const entityDir = path.join(appDir, folderName);
         await fs.mkdir(entityDir, { recursive: true });
         manifest.entities[engineId] = folderName;
         await fs.writeFile(path.join(entityDir, ENTITY_SCRIPT_FILE), entity.script, "utf8");
         const propertiesJson = JSON.stringify(entity.properties ?? [], null, 2);
         await fs.writeFile(path.join(entityDir, ENTITY_PROPERTIES_FILE), propertiesJson, "utf8");
-        const transform = entity.transform ?? { position: DEFAULT_POSITION, rotation: DEFAULT_ROTATION, scale: DEFAULT_SCALE };
+        const transform = entity.transform ?? {
+            position: DEFAULT_POSITION,
+            rotation: DEFAULT_ROTATION,
+            scale: DEFAULT_SCALE,
+        };
         const transformsData = {
             position: JSON.parse(transform.position),
             rotation: JSON.parse(transform.rotation),
@@ -142,10 +110,6 @@ export async function unpackageScene(sceneId, sceneDir) {
     await fs.mkdir(sceneDir, { recursive: true });
     await fs.writeFile(path.join(sceneDir, "manifest.json"), JSON.stringify(manifest, null, 2), "utf8");
 }
-/**
- * Resolve entity id from a path like "main-enemy-1/script.tsx" or "main-enemy-1/properties.json".
- * Accepts both / and \ as separators. Returns the engineId (string) if the path is an entity file, otherwise null.
- */
 function getEntityIdFromRelativePath(manifest, relativePath) {
     const normalized = relativePath.replace(/\\/g, "/");
     const match = normalized.match(/^([^/]+)\/(.+)$/);
@@ -155,229 +119,123 @@ function getEntityIdFromRelativePath(manifest, relativePath) {
     const entityId = Object.entries(manifest.entities).find(([, folder]) => folder === folderName)?.[0];
     return entityId ?? null;
 }
-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");
-    }
+/**
+ * Apply a single file change to the in-memory scene and return updated JSON.
+ * Used by script watcher to produce scene snapshot to send to FE.
+ */
+export async function patchSceneFromFile(sceneJson, sceneDir, relativePath, eventType) {
+    const manifestRaw = await fs.readFile(path.join(sceneDir, "manifest.json"), "utf8");
     const manifest = JSON.parse(manifestRaw);
-    const content = await getSceneFileContent(sceneId);
-    const parsed = parseSceneJson(content);
+    const parsed = parseSceneJson(sceneJson);
     const appDir = getSceneAppDir(sceneDir);
-    const filePath = path.join(appDir, 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) {
+    const filePath = path.join(appDir, relativePath);
+    if (relativePath === manifest.sceneScript || relativePath === SCENE_SCRIPT_FILE) {
+        const fileContent = await fs.readFile(filePath, "utf8");
         if (!parsed.sceneScriptStore)
             parsed.sceneScriptStore = { sceneScript: "", sceneProperties: [], lastModifiedSceneScript: 0 };
         parsed.sceneScriptStore.sceneScript = fileContent;
-        if (typeof parsed.sceneScriptStore.lastModifiedSceneScript === "number") {
-            parsed.sceneScriptStore.lastModifiedSceneScript = Date.now();
-        }
+        parsed.sceneScriptStore.lastModifiedSceneScript = Date.now();
+        return JSON.stringify(parsed);
     }
-    else {
-        const entityId = getEntityIdFromRelativePath(manifest, changedFile);
-        if (entityId == null) {
-            throw new Error(`Unknown script file: ${changedFile}`);
+    if (relativePath === (manifest.sceneProperties ?? SCENE_PROPERTIES_FILE)) {
+        const fileContent = await fs.readFile(filePath, "utf8");
+        const sceneProperties = JSON.parse(fileContent);
+        if (!parsed.sceneScriptStore)
+            parsed.sceneScriptStore = { sceneScript: "", sceneProperties: [], lastModifiedSceneScript: 0 };
+        parsed.sceneScriptStore.sceneProperties = Array.isArray(sceneProperties) ? sceneProperties : [];
+        return JSON.stringify(parsed);
+    }
+    const scriptMatch = relativePath.match(new RegExp(`^([^/]+)\\/${ENTITY_SCRIPT_FILE.replace(".", "\\.")}$`));
+    if (scriptMatch) {
+        const folderName = scriptMatch[1];
+        const fileContent = await fs.readFile(filePath, "utf8");
+        const existingId = Object.entries(manifest.entities).find(([, f]) => f === folderName)?.[0];
+        if (existingId != null) {
+            const entities = parsed.entityStore?.entities ?? {};
+            const entity = entities[existingId];
+            if (!entity)
+                return sceneJson;
+            entity.script = fileContent;
+            entity.scriptVersion = (entity.scriptVersion ?? 0) + 1;
+            return JSON.stringify(parsed);
         }
+        if (eventType === "add") {
+            return addNewEntityFromFolder(parsed, manifest, sceneDir, folderName, appDir);
+        }
+        return sceneJson;
+    }
+    const propsMatch = relativePath.match(new RegExp(`^([^/]+)\\/${ENTITY_PROPERTIES_FILE.replace(".", "\\.")}$`));
+    if (propsMatch) {
+        const entityId = getEntityIdFromRelativePath(manifest, relativePath);
+        if (entityId == null)
+            return sceneJson;
+        const fileContent = await fs.readFile(filePath, "utf8");
+        const properties = JSON.parse(fileContent);
         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);
-}
-/** Push entity properties from app/<folder>/properties.json to the scene. */
-export async function pushPropertiesChange(sceneId, sceneDir, relativePath) {
-    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 entityId = getEntityIdFromRelativePath(manifest, relativePath);
-    if (entityId == null) {
-        throw new Error(`Unknown properties file: ${relativePath}`);
-    }
-    const content = await getSceneFileContent(sceneId);
-    const parsed = parseSceneJson(content);
-    const appDir = getSceneAppDir(sceneDir);
-    const filePath = path.join(appDir, relativePath);
-    let fileContent;
-    try {
-        fileContent = await fs.readFile(filePath, "utf8");
-    }
-    catch {
-        throw new Error(`Could not read file: ${relativePath}`);
-    }
-    let properties;
-    try {
-        properties = JSON.parse(fileContent);
-        if (!Array.isArray(properties))
-            properties = [];
-    }
-    catch {
-        throw new Error(`Invalid JSON in ${relativePath}`);
-    }
-    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.properties = properties;
-    const json = JSON.stringify(parsed);
-    await uploadSceneJsonAndUpdate(sceneId, json);
-}
-/** Push scene properties from app/scene-properties.json to the scene. */
-export async function pushScenePropertiesChange(sceneId, sceneDir) {
-    const content = await getSceneFileContent(sceneId);
-    const parsed = parseSceneJson(content);
-    const appDir = getSceneAppDir(sceneDir);
-    const filePath = path.join(appDir, SCENE_PROPERTIES_FILE);
-    let fileContent;
-    try {
-        fileContent = await fs.readFile(filePath, "utf8");
-    }
-    catch {
-        throw new Error(`Could not read ${SCENE_PROPERTIES_FILE}`);
-    }
-    let sceneProperties;
-    try {
-        const parsedProps = JSON.parse(fileContent);
-        sceneProperties = Array.isArray(parsedProps) ? parsedProps : [];
-    }
-    catch {
-        throw new Error(`Invalid JSON in ${SCENE_PROPERTIES_FILE}`);
-    }
-    if (!parsed.sceneScriptStore) {
-        parsed.sceneScriptStore = { sceneScript: "", sceneProperties: [], lastModifiedSceneScript: 0 };
-    }
-    parsed.sceneScriptStore.sceneProperties = sceneProperties;
-    const json = JSON.stringify(parsed);
-    await uploadSceneJsonAndUpdate(sceneId, json);
-}
-/** Push entity transform from app/<folder>/transforms.json to the scene. */
-export async function pushTransformsChange(sceneId, sceneDir, relativePath) {
-    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 entityId = getEntityIdFromRelativePath(manifest, relativePath);
-    if (entityId == null) {
-        throw new Error(`Unknown transforms file: ${relativePath}`);
-    }
-    const content = await getSceneFileContent(sceneId);
-    const parsed = parseSceneJson(content);
-    const appDir = getSceneAppDir(sceneDir);
-    const filePath = path.join(appDir, relativePath);
-    let fileContent;
-    try {
-        fileContent = await fs.readFile(filePath, "utf8");
-    }
-    catch {
-        throw new Error(`Could not read file: ${relativePath}`);
-    }
-    let data;
-    try {
-        data = JSON.parse(fileContent);
-    }
-    catch {
-        throw new Error(`Invalid JSON in ${relativePath}`);
-    }
-    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`);
-    }
-    if (!entity.transform) {
-        entity.transform = { position: DEFAULT_POSITION, rotation: DEFAULT_ROTATION, scale: DEFAULT_SCALE };
-    }
-    if (data.position !== undefined)
-        entity.transform.position = JSON.stringify(data.position);
-    if (data.rotation !== undefined)
-        entity.transform.rotation = JSON.stringify(data.rotation);
-    if (data.scale !== undefined)
-        entity.transform.scale = JSON.stringify(data.scale);
-    const json = JSON.stringify(parsed);
-    await uploadSceneJsonAndUpdate(sceneId, json);
+        if (!entity)
+            return sceneJson;
+        entity.properties = Array.isArray(properties) ? properties : [];
+        return JSON.stringify(parsed);
+    }
+    const transformsMatch = relativePath.match(new RegExp(`^([^/]+)\\/${ENTITY_TRANSFORMS_FILE.replace(".", "\\.")}$`));
+    if (transformsMatch) {
+        const entityId = getEntityIdFromRelativePath(manifest, relativePath);
+        if (entityId == null)
+            return sceneJson;
+        const fileContent = await fs.readFile(filePath, "utf8");
+        const data = JSON.parse(fileContent);
+        const entities = parsed.entityStore?.entities ?? {};
+        const entity = entities[entityId];
+        if (!entity)
+            return sceneJson;
+        if (!entity.transform)
+            entity.transform = { position: DEFAULT_POSITION, rotation: DEFAULT_ROTATION, scale: DEFAULT_SCALE };
+        if (data.position !== undefined)
+            entity.transform.position = JSON.stringify(data.position);
+        if (data.rotation !== undefined)
+            entity.transform.rotation = JSON.stringify(data.rotation);
+        if (data.scale !== undefined)
+            entity.transform.scale = JSON.stringify(data.scale);
+        return JSON.stringify(parsed);
+    }
+    return sceneJson;
 }
-/** Add a new entity to the scene when user creates <entity-name>-<engineId>/ with script.tsx (and optional properties.json, transforms.json). */
-export async function pushNewEntity(sceneId, sceneDir, engineId, folderName) {
-    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 appDir = getSceneAppDir(sceneDir);
+async function addNewEntityFromFolder(parsed, manifest, sceneDir, folderName, appDir) {
+    if (Object.values(manifest.entities).includes(folderName))
+        return JSON.stringify(parsed);
     const scriptPath = path.join(appDir, folderName, ENTITY_SCRIPT_FILE);
     let script;
     try {
         script = await fs.readFile(scriptPath, "utf8");
     }
     catch {
-        throw new Error(`Could not read ${folderName}/${ENTITY_SCRIPT_FILE}`);
+        return JSON.stringify(parsed);
     }
     let properties = [];
-    const propertiesPath = path.join(appDir, folderName, ENTITY_PROPERTIES_FILE);
     try {
-        const raw = await fs.readFile(propertiesPath, "utf8");
+        const raw = await fs.readFile(path.join(appDir, folderName, ENTITY_PROPERTIES_FILE), "utf8");
         const parsedProps = JSON.parse(raw);
         if (Array.isArray(parsedProps))
             properties = parsedProps;
     }
     catch {
-        // properties.json optional; default to []
+        /* optional */
     }
     let transform = { position: DEFAULT_POSITION, rotation: DEFAULT_ROTATION, scale: DEFAULT_SCALE };
-    const transformsPath = path.join(appDir, folderName, ENTITY_TRANSFORMS_FILE);
     try {
-        const raw = await fs.readFile(transformsPath, "utf8");
-        const parsedTransform = JSON.parse(raw);
-        if (parsedTransform.position !== undefined)
-            transform.position = JSON.stringify(parsedTransform.position);
-        if (parsedTransform.rotation !== undefined)
-            transform.rotation = JSON.stringify(parsedTransform.rotation);
-        if (parsedTransform.scale !== undefined)
-            transform.scale = JSON.stringify(parsedTransform.scale);
+        const raw = await fs.readFile(path.join(appDir, folderName, ENTITY_TRANSFORMS_FILE), "utf8");
+        const t = JSON.parse(raw);
+        if (t.position !== undefined)
+            transform.position = JSON.stringify(t.position);
+        if (t.rotation !== undefined)
+            transform.rotation = JSON.stringify(t.rotation);
+        if (t.scale !== undefined)
+            transform.scale = JSON.stringify(t.scale);
     }
     catch {
-        // transforms.json optional; use defaults
+        /* optional */
     }
-    const match = folderName.match(ENTITY_FOLDER_RE);
-    const slug = match ? match[1] : "entity";
-    const entityDisplayName = slugToEntityName(slug);
     if (!parsed.entityStore) {
         parsed.entityStore = {
             _currId: 0,
@@ -389,12 +247,14 @@ export async function pushNewEntity(sceneId, sceneDir, engineId, folderName) {
         };
     }
     const store = parsed.entityStore;
+    const existingIds = [...Object.keys(manifest.entities).map(Number), store._currId];
+    const engineId = existingIds.length ? Math.max(...existingIds) + 1 : 1;
+    const idStr = String(engineId);
     store._currId = Math.max(store._currId, engineId);
-    if (!store.rootEntities.includes(engineId)) {
+    if (!store.rootEntities.includes(engineId))
         store.rootEntities.push(engineId);
-    }
     store.entities[idStr] = {
-        name: entityDisplayName,
+        name: folderName,
         engineId,
         childrenIdsSet: [],
         childrenIds: [],
@@ -407,7 +267,6 @@ export async function pushNewEntity(sceneId, sceneDir, engineId, folderName) {
         threeId: 0,
     };
     manifest.entities[idStr] = folderName;
-    await fs.writeFile(manifestPath, JSON.stringify(manifest, null, 2), "utf8");
-    const json = JSON.stringify(parsed);
-    await uploadSceneJsonAndUpdate(sceneId, json);
+    await fs.writeFile(path.join(sceneDir, "manifest.json"), JSON.stringify(manifest, null, 2), "utf8");
+    return JSON.stringify(parsed);
 }

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

@@ -0,0 +1,42 @@
+export type EntityTransformInput = {
+    position?: unknown;
+    rotation?: unknown;
+    scale?: unknown;
+};
+export type NewEntityData = {
+    name: string;
+    script: string;
+    properties: Array<{
+        name: string;
+        type: string;
+        value: unknown;
+    }>;
+    transform: {
+        position: string;
+        rotation: string;
+        scale: string;
+    };
+};
+/**
+ * In-memory scene state for WebSocket mode. Holds a PhibelleScene and provides
+ * update methods that mirror the push logic without touching the network.
+ */
+export declare class SceneState {
+    private scene;
+    constructor(initialJson: string);
+    getJson(): string;
+    /** Current max entity id used in entityStore (for computing next engineId). */
+    getCurrId(): number;
+    /** Replace in-memory scene with the given JSON (e.g. from FE over WebSocket). */
+    replaceScene(json: string): void;
+    updateSceneScript(script: string): void;
+    updateSceneProperties(properties: unknown[]): void;
+    updateEntityScript(entityId: string, script: string): void;
+    updateEntityProperties(entityId: string, properties: Array<{
+        name: string;
+        type: string;
+        value: unknown;
+    }>): void;
+    updateEntityTransforms(entityId: string, data: EntityTransformInput): void;
+    addEntity(engineId: number, data: NewEntityData): void;
+}

package/dist/lib/scene/scene-state.js

@@ -0,0 +1,125 @@
+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}';
+/**
+ * In-memory scene state for WebSocket mode. Holds a PhibelleScene and provides
+ * update methods that mirror the push logic without touching the network.
+ */
+export class SceneState {
+    scene;
+    constructor(initialJson) {
+        try {
+            this.scene = JSON.parse(initialJson);
+        }
+        catch {
+            throw new Error("Invalid scene file: not valid JSON");
+        }
+    }
+    getJson() {
+        return JSON.stringify(this.scene);
+    }
+    /** Current max entity id used in entityStore (for computing next engineId). */
+    getCurrId() {
+        return this.scene.entityStore?._currId ?? 0;
+    }
+    /** Replace in-memory scene with the given JSON (e.g. from FE over WebSocket). */
+    replaceScene(json) {
+        try {
+            this.scene = JSON.parse(json);
+        }
+        catch {
+            throw new Error("Invalid scene file: not valid JSON");
+        }
+    }
+    updateSceneScript(script) {
+        if (!this.scene.sceneScriptStore) {
+            this.scene.sceneScriptStore = {
+                sceneScript: "",
+                sceneProperties: [],
+                lastModifiedSceneScript: 0,
+            };
+        }
+        this.scene.sceneScriptStore.sceneScript = script;
+        if (typeof this.scene.sceneScriptStore.lastModifiedSceneScript === "number") {
+            this.scene.sceneScriptStore.lastModifiedSceneScript = Date.now();
+        }
+    }
+    updateSceneProperties(properties) {
+        if (!this.scene.sceneScriptStore) {
+            this.scene.sceneScriptStore = {
+                sceneScript: "",
+                sceneProperties: [],
+                lastModifiedSceneScript: 0,
+            };
+        }
+        this.scene.sceneScriptStore.sceneProperties = properties;
+    }
+    updateEntityScript(entityId, script) {
+        const entities = this.scene.entityStore?.entities ?? {};
+        const entity = entities[entityId];
+        if (!entity) {
+            throw new Error(`Entity ${entityId} no longer in scene`);
+        }
+        entity.script = script;
+        entity.scriptVersion = (entity.scriptVersion ?? 0) + 1;
+    }
+    updateEntityProperties(entityId, properties) {
+        const entities = this.scene.entityStore?.entities ?? {};
+        const entity = entities[entityId];
+        if (!entity) {
+            throw new Error(`Entity ${entityId} no longer in scene`);
+        }
+        entity.properties = properties;
+    }
+    updateEntityTransforms(entityId, data) {
+        const entities = this.scene.entityStore?.entities ?? {};
+        const entity = entities[entityId];
+        if (!entity) {
+            throw new Error(`Entity ${entityId} no longer in scene`);
+        }
+        if (!entity.transform) {
+            entity.transform = {
+                position: DEFAULT_POSITION,
+                rotation: DEFAULT_ROTATION,
+                scale: DEFAULT_SCALE,
+            };
+        }
+        if (data.position !== undefined)
+            entity.transform.position = JSON.stringify(data.position);
+        if (data.rotation !== undefined)
+            entity.transform.rotation = JSON.stringify(data.rotation);
+        if (data.scale !== undefined)
+            entity.transform.scale = JSON.stringify(data.scale);
+    }
+    addEntity(engineId, data) {
+        if (!this.scene.entityStore) {
+            this.scene.entityStore = {
+                _currId: 0,
+                rootEntities: [],
+                entities: {},
+                rootRenderVersion: 0,
+                lastRenderedVersion: 0,
+                selectedEntityIds: [],
+            };
+        }
+        const store = this.scene.entityStore;
+        const idStr = String(engineId);
+        store._currId = Math.max(store._currId, engineId);
+        if (!store.rootEntities.includes(engineId)) {
+            store.rootEntities.push(engineId);
+        }
+        store.entities[idStr] = {
+            name: data.name,
+            engineId,
+            childrenIdsSet: [],
+            childrenIds: [],
+            isNodeOpen: false,
+            script: data.script,
+            scriptVersion: 0,
+            transform: data.transform,
+            renderVersion: 0,
+            properties: data.properties,
+            threeId: 0,
+        };
+    }
+}