@woosh/meep-engine 2.169.6 → 2.170.0

package/editor/persistence/SceneMetadata.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Descriptive record stored beside each scene slot.
+ */
+export class SceneMetadata {
+    /**
+     *
+     * @param {string} name
+     * @param {number} timestamp
+     * @param {number} byte_size
+     * @returns {SceneMetadata}
+     */
+    static from({ name, timestamp, byte_size }: string): SceneMetadata;
+    /**
+     * @type {string}
+     */
+    name: string;
+    /**
+     * Unix time of the save, ms
+     * @type {number}
+     */
+    timestamp: number;
+    /**
+     * Size of the scene payload, bytes
+     * @type {number}
+     */
+    byte_size: number;
+    toJSON(): {
+        name: string;
+        timestamp: number;
+        byte_size: number;
+    };
+    fromJSON({ name, timestamp, byte_size }: {
+        name: any;
+        timestamp: any;
+        byte_size: any;
+    }): void;
+}
+//# sourceMappingURL=SceneMetadata.d.ts.map

package/editor/persistence/SceneMetadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SceneMetadata.d.ts","sourceRoot":"","sources":["SceneMetadata.js"],"names":[],"mappings":"AAAA;;GAEG;AACH;IAkBI;;;;;;OAMG;IACH,4CALW,MAAM,GAGJ,aAAa,CAUzB;IAhCD;;OAEG;IACH,MAFU,MAAM,CAEN;IAEV;;;OAGG;IACH,WAFU,MAAM,CAEF;IAEd;;;OAGG;IACH,WAFU,MAAM,CAEF;IAmBd;;;;MAMC;IAED;;;;aAIC;CACJ"}

package/editor/persistence/SceneMetadata.js

@@ -0,0 +1,52 @@
+/**
+ * Descriptive record stored beside each scene slot.
+ */
+export class SceneMetadata {
+    /**
+     * @type {string}
+     */
+    name = "";
+
+    /**
+     * Unix time of the save, ms
+     * @type {number}
+     */
+    timestamp = 0;
+
+    /**
+     * Size of the scene payload, bytes
+     * @type {number}
+     */
+    byte_size = 0;
+
+    /**
+     *
+     * @param {string} name
+     * @param {number} timestamp
+     * @param {number} byte_size
+     * @returns {SceneMetadata}
+     */
+    static from({ name, timestamp, byte_size }) {
+        const r = new SceneMetadata();
+
+        r.name = name;
+        r.timestamp = timestamp;
+        r.byte_size = byte_size;
+
+        return r;
+    }
+
+    toJSON() {
+        return {
+            name: this.name,
+            timestamp: this.timestamp,
+            byte_size: this.byte_size
+        };
+    }
+
+    fromJSON({ name, timestamp, byte_size }) {
+        this.name = name;
+        this.timestamp = timestamp;
+        this.byte_size = byte_size;
+    }
+}

package/editor/persistence/SceneSlotManager.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Named scene slots over an engine {@link Storage} backend (IndexedDB in the browser,
+ * InMemoryStorage in tests). Each slot is a scene payload plus a {@link SceneMetadata}
+ * record; a slot list is maintained under a fixed key.
+ */
+export class SceneSlotManager {
+    /**
+     *
+     * @param {Storage} storage
+     */
+    constructor(storage: Storage);
+    /**
+     *
+     * @returns {Promise<SceneMetadata[]>}
+     */
+    list(): Promise<SceneMetadata[]>;
+    /**
+     *
+     * @param {string} name
+     * @param {ArrayBuffer} payload serialized scene
+     * @param {number} timestamp Unix time, ms
+     * @returns {Promise}
+     */
+    save(name: string, payload: ArrayBuffer, timestamp: number): Promise<any>;
+    /**
+     *
+     * @param {string} name
+     * @returns {Promise<ArrayBuffer>}
+     */
+    load(name: string): Promise<ArrayBuffer>;
+    /**
+     *
+     * @param {string} name
+     * @returns {Promise}
+     */
+    remove(name: string): Promise<any>;
+    #private;
+}
+import { SceneMetadata } from "./SceneMetadata.js";
+//# sourceMappingURL=SceneSlotManager.d.ts.map

package/editor/persistence/SceneSlotManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SceneSlotManager.d.ts","sourceRoot":"","sources":["SceneSlotManager.js"],"names":[],"mappings":"AAuBA;;;;GAIG;AACH;IAMI;;;OAGG;IACH,qBAFW,OAAO,EAIjB;IA2BD;;;OAGG;IACH,QAFa,QAAQ,aAAa,EAAE,CAAC,CAkBpC;IAED;;;;;;OAMG;IACH,WALW,MAAM,WACN,WAAW,aACX,MAAM,gBAoBhB;IAED;;;;OAIG;IACH,WAHW,MAAM,GACJ,QAAQ,WAAW,CAAC,CAIhC;IAED;;;;OAIG;IACH,aAHW,MAAM,gBAgBhB;;CACJ;8BA/I6B,oBAAoB"}

package/editor/persistence/SceneSlotManager.js

@@ -0,0 +1,144 @@
+import { SceneMetadata } from "./SceneMetadata.js";
+import { decode_string, encode_string } from "./string_buffer_codec.js";
+
+const KEY_LIST = 'meep-editor-scene:list';
+
+/**
+ *
+ * @param {string} name
+ * @returns {string}
+ */
+function dataKey(name) {
+    return `meep-editor-scene:data:${name}`;
+}
+
+/**
+ *
+ * @param {string} name
+ * @returns {string}
+ */
+function metaKey(name) {
+    return `meep-editor-scene:meta:${name}`;
+}
+
+/**
+ * Named scene slots over an engine {@link Storage} backend (IndexedDB in the browser,
+ * InMemoryStorage in tests). Each slot is a scene payload plus a {@link SceneMetadata}
+ * record; a slot list is maintained under a fixed key.
+ */
+export class SceneSlotManager {
+    /**
+     * @type {Storage}
+     */
+    #storage;
+
+    /**
+     *
+     * @param {Storage} storage
+     */
+    constructor(storage) {
+        this.#storage = storage;
+    }
+
+    /**
+     *
+     * @returns {Promise<string[]>} slot names
+     */
+    async #loadNames() {
+        const exists = await this.#storage.promiseContains(KEY_LIST);
+
+        if (!exists) {
+            return [];
+        }
+
+        const buffer = await this.#storage.promiseLoadBinary(KEY_LIST);
+
+        return JSON.parse(decode_string(buffer));
+    }
+
+    /**
+     *
+     * @param {string[]} names
+     * @returns {Promise}
+     */
+    #storeNames(names) {
+        return this.#storage.promiseStoreBinary(KEY_LIST, encode_string(JSON.stringify(names)));
+    }
+
+    /**
+     *
+     * @returns {Promise<SceneMetadata[]>}
+     */
+    async list() {
+        const names = await this.#loadNames();
+
+        const result = [];
+
+        for (const name of names) {
+            const buffer = await this.#storage.promiseLoadBinary(metaKey(name));
+
+            const metadata = new SceneMetadata();
+
+            metadata.fromJSON(JSON.parse(decode_string(buffer)));
+
+            result.push(metadata);
+        }
+
+        return result;
+    }
+
+    /**
+     *
+     * @param {string} name
+     * @param {ArrayBuffer} payload serialized scene
+     * @param {number} timestamp Unix time, ms
+     * @returns {Promise}
+     */
+    async save(name, payload, timestamp) {
+        const metadata = SceneMetadata.from({
+            name,
+            timestamp,
+            byte_size: payload.byteLength
+        });
+
+        await this.#storage.promiseStoreBinary(dataKey(name), payload);
+        await this.#storage.promiseStoreBinary(metaKey(name), encode_string(JSON.stringify(metadata.toJSON())));
+
+        const names = await this.#loadNames();
+
+        if (!names.includes(name)) {
+            names.push(name);
+
+            await this.#storeNames(names);
+        }
+    }
+
+    /**
+     *
+     * @param {string} name
+     * @returns {Promise<ArrayBuffer>}
+     */
+    load(name) {
+        return this.#storage.promiseLoadBinary(dataKey(name));
+    }
+
+    /**
+     *
+     * @param {string} name
+     * @returns {Promise}
+     */
+    async remove(name) {
+        await this.#storage.promiseRemove(dataKey(name));
+        await this.#storage.promiseRemove(metaKey(name));
+
+        const names = await this.#loadNames();
+
+        const index = names.indexOf(name);
+
+        if (index !== -1) {
+            names.splice(index, 1);
+
+            await this.#storeNames(names);
+        }
+    }
+}

package/editor/persistence/buildNewSceneDataset.d.ts

@@ -0,0 +1,10 @@
+/**
+ * A minimal usable scene: an active camera, a sun and an ambient light. A completely
+ * empty dataset would export a scene without a camera, which no host could present.
+ *
+ * @param {Engine} engine supplies the component type map
+ * @returns {EntityComponentDataset}
+ */
+export function buildNewSceneDataset(engine: Engine): EntityComponentDataset;
+import { EntityComponentDataset } from "../../src/engine/ecs/EntityComponentDataset.js";
+//# sourceMappingURL=buildNewSceneDataset.d.ts.map

package/editor/persistence/buildNewSceneDataset.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildNewSceneDataset.d.ts","sourceRoot":"","sources":["buildNewSceneDataset.js"],"names":[],"mappings":"AASA;;;;;;GAMG;AACH,sDAFa,sBAAsB,CAoDlC;uCAhEsC,gDAAgD"}

package/editor/persistence/buildNewSceneDataset.js

@@ -0,0 +1,67 @@
+import { Color } from "../../src/core/color/Color.js";
+import Vector3 from "../../src/core/geom/Vector3.js";
+import { EntityComponentDataset } from "../../src/engine/ecs/EntityComponentDataset.js";
+import { Name } from "../../src/engine/ecs/name/Name.js";
+import { Transform } from "../../src/engine/ecs/transform/Transform.js";
+import Entity from "../../src/engine/ecs/Entity.js";
+import { Camera } from "../../src/engine/graphics/ecs/camera/Camera.js";
+import { Light } from "../../src/engine/graphics/ecs/light/Light.js";
+
+/**
+ * A minimal usable scene: an active camera, a sun and an ambient light. A completely
+ * empty dataset would export a scene without a camera, which no host could present.
+ *
+ * @param {Engine} engine supplies the component type map
+ * @returns {EntityComponentDataset}
+ */
+export function buildNewSceneDataset(engine) {
+    const ecd = new EntityComponentDataset();
+
+    ecd.setComponentTypeMap(engine.entityManager.getComponentTypeMap());
+
+    for (const type of [Transform, Name, Camera, Light]) {
+        if (!ecd.isComponentTypeRegistered(type)) {
+            ecd.registerComponentType(type);
+        }
+    }
+
+    const camera = new Camera();
+    camera.active.set(true);
+
+    const camera_transform = new Transform();
+    camera_transform.position.set(10, 10, 10);
+
+    new Entity()
+        .add(camera)
+        .add(camera_transform)
+        .add(new Name('Camera'))
+        .build(ecd);
+
+    const sun = new Light();
+    sun.type.set(Light.Type.DIRECTION);
+    sun.intensity.set(0.9);
+    sun.castShadow.set(true);
+
+    const sun_transform = new Transform();
+    sun_transform.position.set(30, 70, 30);
+    sun_transform.rotation.lookRotation(new Vector3(0.17, -1, 0.17));
+
+    new Entity()
+        .add(sun)
+        .add(sun_transform)
+        .add(new Name('Sun'))
+        .build(ecd);
+
+    const ambient = new Light();
+    ambient.type.set(Light.Type.AMBIENT);
+    ambient.color.copy(Color.white);
+    ambient.intensity.set(0.07);
+
+    new Entity()
+        .add(ambient)
+        .add(new Transform())
+        .add(new Name('Ambient'))
+        .build(ecd);
+
+    return ecd;
+}

package/editor/persistence/files.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Prompt the user for a scene file and read it.
+ *
+ * @returns {Promise<ArrayBuffer|null>} null when the picker is dismissed
+ */
+export function pickSceneFile(): Promise<ArrayBuffer | null>;
+/**
+ * Fetch a scene file, bypassing every cache — the same URL may just have been written by
+ * {@link putSceneToUrl}.
+ *
+ * @param {string} url
+ * @returns {Promise<ArrayBuffer>}
+ */
+export function fetchSceneFromUrl(url: string): Promise<ArrayBuffer>;
+/**
+ * Write a scene file back to its source over HTTP PUT. Requires a server that accepts
+ * writes (the dev server exposes one for `data/levels/**`).
+ *
+ * @param {string} url
+ * @param {ArrayBuffer|Uint8Array} payload
+ * @returns {Promise}
+ */
+export function putSceneToUrl(url: string, payload: ArrayBuffer | Uint8Array): Promise<any>;
+//# sourceMappingURL=files.d.ts.map

package/editor/persistence/files.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"files.d.ts","sourceRoot":"","sources":["files.js"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,iCAFa,QAAQ,WAAW,GAAC,IAAI,CAAC,CA2BrC;AAED;;;;;;GAMG;AACH,uCAHW,MAAM,GACJ,QAAQ,WAAW,CAAC,CAUhC;AAED;;;;;;;GAOG;AACH,mCAJW,MAAM,WACN,WAAW,GAAC,UAAU,gBAahC"}

package/editor/persistence/files.js

@@ -0,0 +1,68 @@
+/**
+ * Prompt the user for a scene file and read it.
+ *
+ * @returns {Promise<ArrayBuffer|null>} null when the picker is dismissed
+ */
+export function pickSceneFile() {
+    return new Promise(resolve => {
+        const input = document.createElement('input');
+
+        input.type = 'file';
+        input.accept = '.bin';
+
+        input.addEventListener('change', () => {
+            const file = input.files[0];
+
+            if (file === undefined) {
+                resolve(null);
+                return;
+            }
+
+            const reader = new FileReader();
+
+            reader.addEventListener('load', () => resolve(reader.result));
+            reader.readAsArrayBuffer(file);
+        });
+
+        input.addEventListener('cancel', () => resolve(null));
+
+        input.click();
+    });
+}
+
+/**
+ * Fetch a scene file, bypassing every cache — the same URL may just have been written by
+ * {@link putSceneToUrl}.
+ *
+ * @param {string} url
+ * @returns {Promise<ArrayBuffer>}
+ */
+export async function fetchSceneFromUrl(url) {
+    const response = await fetch(url, { cache: 'no-store' });
+
+    if (!response.ok) {
+        throw new Error(`Failed to fetch scene from '${url}': ${response.status} ${response.statusText}`);
+    }
+
+    return response.arrayBuffer();
+}
+
+/**
+ * Write a scene file back to its source over HTTP PUT. Requires a server that accepts
+ * writes (the dev server exposes one for `data/levels/**`).
+ *
+ * @param {string} url
+ * @param {ArrayBuffer|Uint8Array} payload
+ * @returns {Promise}
+ */
+export async function putSceneToUrl(url, payload) {
+    const response = await fetch(url, {
+        method: 'PUT',
+        headers: { 'Content-Type': 'application/octet-stream' },
+        body: payload
+    });
+
+    if (!response.ok) {
+        throw new Error(`Failed to save scene to '${url}': ${response.status} ${response.statusText}`);
+    }
+}

package/editor/persistence/scene_import.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Deserialize a level-file buffer into the given dataset.
+ *
+ * @param {Engine} engine
+ * @param {ArrayBuffer} arrayBuffer
+ * @param {EntityComponentDataset} ecd
+ * @returns {Promise}
+ */
+export function deserializeSceneBuffer(engine: Engine, arrayBuffer: ArrayBuffer, ecd: EntityComponentDataset): Promise<any>;
+/**
+ * Replace the active scene with one holding the given dataset. The scene is recreated
+ * under its own name, which is the manager's only wholesale-content-swap path.
+ *
+ * @param {Engine} engine
+ * @param {EntityComponentDataset} ecd
+ */
+export function swapSceneDataset(engine: Engine, ecd: EntityComponentDataset): void;
+/**
+ * Replace the current scene's content with the deserialized buffer. Entity ids from the
+ * file apply onto a clean slate.
+ *
+ * The caller is responsible for detaching the editor before and re-attaching it after —
+ * see Editor#openSceneFromBuffer.
+ *
+ * @param {Engine} engine
+ * @param {ArrayBuffer} arrayBuffer
+ * @returns {Promise}
+ */
+export function importSceneFromBuffer(engine: Engine, arrayBuffer: ArrayBuffer): Promise<any>;
+/**
+ * Merge the deserialized buffer into the live scene ("compose"): every entity from the
+ * file is recreated under a fresh id, as one undoable group.
+ *
+ * Entity ids are remapped wholesale; serialized engine components carry no entity
+ * references, so their data transfers verbatim. Cameras arrive deactivated — the live
+ * scene already has an active one.
+ *
+ * @param {Engine} engine
+ * @param {ArrayBuffer} arrayBuffer
+ * @param {Editor} editor undo/selection context
+ * @returns {Promise<number[]>} created entities
+ */
+export function importSceneAdditive(engine: Engine, arrayBuffer: ArrayBuffer, editor: Editor): Promise<number[]>;
+import { EntityComponentDataset } from "../../src/engine/ecs/EntityComponentDataset.js";
+//# sourceMappingURL=scene_import.d.ts.map

package/editor/persistence/scene_import.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scene_import.d.ts","sourceRoot":"","sources":["scene_import.js"],"names":[],"mappings":"AAUA;;;;;;;GAOG;AACH,oEAJW,WAAW,OACX,sBAAsB,gBAgBhC;AAED;;;;;;GAMG;AACH,sDAFW,sBAAsB,QAoBhC;AAED;;;;;;;;;;GAUG;AACH,mEAHW,WAAW,gBAYrB;AAED;;;;;;;;;;;;GAYG;AACH,iEAJW,WAAW,mBAET,QAAQ,MAAM,EAAE,CAAC,CAiD7B;uCA5IsC,gDAAgD"}

package/editor/persistence/scene_import.js

@@ -0,0 +1,143 @@
+import { EncodingBinaryBuffer } from "../../src/core/binary/EncodingBinaryBuffer.js";
+import { EndianType } from "../../src/core/binary/EndianType.js";
+import { EntityComponentDataset } from "../../src/engine/ecs/EntityComponentDataset.js";
+import BinaryBufferDeSerializer from "../../src/engine/ecs/storage/BinaryBufferDeSerializer.js";
+import { Camera } from "../../src/engine/graphics/ecs/camera/Camera.js";
+import ComponentAddAction from "../actions/concrete/ComponentAddAction.js";
+import EntityCreateAction from "../actions/concrete/EntityCreateAction.js";
+import SelectionAddAction from "../actions/concrete/SelectionAddAction.js";
+import SelectionClearAction from "../actions/concrete/SelectionClearAction.js";
+
+/**
+ * Deserialize a level-file buffer into the given dataset.
+ *
+ * @param {Engine} engine
+ * @param {ArrayBuffer} arrayBuffer
+ * @param {EntityComponentDataset} ecd
+ * @returns {Promise}
+ */
+export function deserializeSceneBuffer(engine, arrayBuffer, ecd) {
+    const deSerializer = new BinaryBufferDeSerializer();
+    deSerializer.registry = engine.binarySerializationRegistry;
+
+    const buffer = new EncodingBinaryBuffer();
+    buffer.endianness = EndianType.BigEndian;
+    buffer.fromArrayBuffer(arrayBuffer);
+
+    const task = deSerializer.process(buffer, engine, ecd);
+
+    engine.executor.run(task);
+
+    return task.promise();
+}
+
+/**
+ * Replace the active scene with one holding the given dataset. The scene is recreated
+ * under its own name, which is the manager's only wholesale-content-swap path.
+ *
+ * @param {Engine} engine
+ * @param {EntityComponentDataset} ecd
+ */
+export function swapSceneDataset(engine, ecd) {
+    const sceneManager = engine.sceneManager;
+
+    const current = sceneManager.current_scene;
+
+    if (current === null) {
+        throw new Error('No active scene to replace');
+    }
+
+    const name = current.name;
+
+    sceneManager.remove(name);
+
+    const fresh = sceneManager.create(name);
+
+    fresh.dataset = ecd;
+
+    sceneManager.set(name);
+}
+
+/**
+ * Replace the current scene's content with the deserialized buffer. Entity ids from the
+ * file apply onto a clean slate.
+ *
+ * The caller is responsible for detaching the editor before and re-attaching it after —
+ * see Editor#openSceneFromBuffer.
+ *
+ * @param {Engine} engine
+ * @param {ArrayBuffer} arrayBuffer
+ * @returns {Promise}
+ */
+export async function importSceneFromBuffer(engine, arrayBuffer) {
+    const em = engine.entityManager;
+
+    const ecd = new EntityComponentDataset();
+    ecd.setComponentTypeMap(em.getComponentTypeMap());
+
+    await deserializeSceneBuffer(engine, arrayBuffer, ecd);
+
+    swapSceneDataset(engine, ecd);
+}
+
+/**
+ * Merge the deserialized buffer into the live scene ("compose"): every entity from the
+ * file is recreated under a fresh id, as one undoable group.
+ *
+ * Entity ids are remapped wholesale; serialized engine components carry no entity
+ * references, so their data transfers verbatim. Cameras arrive deactivated — the live
+ * scene already has an active one.
+ *
+ * @param {Engine} engine
+ * @param {ArrayBuffer} arrayBuffer
+ * @param {Editor} editor undo/selection context
+ * @returns {Promise<number[]>} created entities
+ */
+export async function importSceneAdditive(engine, arrayBuffer, editor) {
+    const em = engine.entityManager;
+
+    const scratch = new EntityComponentDataset();
+    scratch.setComponentTypeMap(em.getComponentTypeMap());
+
+    await deserializeSceneBuffer(engine, arrayBuffer, scratch);
+
+    const actions = editor.actions;
+
+    actions.mark('merge scene');
+
+    const created = [];
+
+    const scratch_entities = [];
+
+    scratch.traverseEntityIndices(id => {
+        scratch_entities.push(id);
+    });
+
+    for (const scratch_entity of scratch_entities) {
+        const create = new EntityCreateAction();
+
+        await actions.do(create);
+
+        const components = scratch.getAllComponents(scratch_entity);
+
+        for (const component of components) {
+            if (component === undefined) {
+                continue;
+            }
+
+            if (component instanceof Camera) {
+                // the live scene's camera stays in charge
+                component.active.set(false);
+            }
+
+            await actions.do(new ComponentAddAction(create.entity, component));
+        }
+
+        created.push(create.entity);
+    }
+
+    await actions.do(new SelectionClearAction());
+    await actions.do(new SelectionAddAction(created));
+
+    return created;
+}

package/editor/persistence/scene_serialization.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Editing-state dataset reduced to what a scene file should contain: editor-owned
+ * entities are stripped and every camera is replaced by an activated clone (the clone
+ * keeps the live scene's component instances untouched — the editing session continues
+ * with its own camera state).
+ *
+ * The copy shares component instances with the live dataset; callers must not mutate
+ * components of the returned dataset.
+ *
+ * @param {Engine} engine
+ * @returns {EntityComponentDataset}
+ */
+export function buildExportDataset(engine: Engine): EntityComponentDataset;
+/**
+ * Serialize a dataset into a level-file buffer (big-endian, string-interned).
+ * Throws when serialization itself fails — a truncated file is never produced silently.
+ * Component types without a registered adapter are skipped with a logged error
+ * (engine serializer behavior); register adapters for every type the scene must keep.
+ *
+ * @param {Engine} engine
+ * @param {EntityComponentDataset} dataset
+ * @returns {EncodingBinaryBuffer}
+ */
+export function serializeDataset(engine: Engine, dataset: EntityComponentDataset): EncodingBinaryBuffer;
+/**
+ * The standard scene export: {@link buildExportDataset} followed by
+ * {@link serializeDataset}. Hosts wanting extra scrubbing call the two primitives
+ * around their own step.
+ *
+ * @param {Engine} engine
+ * @returns {EncodingBinaryBuffer}
+ */
+export function exportSceneToBuffer(engine: Engine): EncodingBinaryBuffer;
+import { EntityComponentDataset } from "../../src/engine/ecs/EntityComponentDataset.js";
+import { EncodingBinaryBuffer } from "../../src/core/binary/EncodingBinaryBuffer.js";
+//# sourceMappingURL=scene_serialization.d.ts.map