@nice2dev/game-engine 1.3.15 → 1.3.17

package/dist/esm/import/NdgFormat.js

@@ -1,482 +1,436 @@
-import { SceneImporter } from './SceneImporter.js';
-
-/**
- * @file NdgFormat.ts
- * @description Nice2Dev Game (.ndg) Universal Format - Import/Export
- * PRO-1.3: Scene Format Interoperability
- *
- * The .ndg format is Nice2Dev's native scene interchange format.
- * Designed for:
- * - Lossless round-trip conversion
- * - Human-readable JSON structure
- * - Full feature preservation
- * - Version compatibility
- *
- * File Types:
- * - .ndg - Single scene
- * - .ndgp - Project with multiple scenes
- * - .ndga - Asset bundle
- */
-// ============================================================
-// NDG Format Version
-// ============================================================
-const NDG_FORMAT_VERSION = '1.0.0';
-const NDG_MAGIC = 'NDG1';
-// ============================================================
-// NDG Importer
-// ============================================================
+import { SceneImporter } from "./SceneImporter.js";
+const NDG_FORMAT_VERSION = "1.0.0";
+const NDG_MAGIC = "NDG1";
 class NdgImporter extends SceneImporter {
-    constructor() {
-        super('unity'); // Use unity as base, but this handles .ndg files
-        this.ndgFile = null;
-    }
-    canHandle(filePath) {
-        const ext = filePath.substring(filePath.lastIndexOf('.')).toLowerCase();
-        return ['.ndg', '.ndgp', '.ndga'].includes(ext);
-    }
-    async import(options) {
-        const startTime = Date.now();
-        this.options = options;
-        this.clearMessages();
-        const scenes = [];
-        const assets = [];
-        try {
-            const content = await this.readFile(options.sourcePath);
-            this.ndgFile = JSON.parse(content);
-            // Validate format
-            if (this.ndgFile.magic !== NDG_MAGIC) {
-                this.addError('INVALID_MAGIC', 'Invalid NDG file magic', options.sourcePath, undefined, true);
-                return { ...this.createEmptyResult(), errors: this.errors };
-            }
-            // Convert based on file type
-            if (this.ndgFile.type === 'scene') {
-                const scene = this.convertNdgSceneToNice(this.ndgFile.content);
-                scenes.push(scene);
-            }
-            else if (this.ndgFile.type === 'project') {
-                const project = this.ndgFile.content;
-                for (const ndgScene of project.scenes) {
-                    scenes.push(this.convertNdgSceneToNice(ndgScene));
-                }
-                for (const ndgAsset of project.assets) {
-                    assets.push(this.convertNdgAssetToNice(ndgAsset));
-                }
-            }
-            else if (this.ndgFile.type === 'asset-bundle') {
-                const bundle = this.ndgFile.content;
-                for (const ndgAsset of bundle.assets) {
-                    assets.push(this.convertNdgAssetToNice(ndgAsset));
-                }
-            }
-        }
-        catch (error) {
-            this.addError('IMPORT_ERROR', `Failed to import: ${error}`, options.sourcePath, undefined, true);
-        }
-        return this.createResult(scenes, assets, startTime);
-    }
-    async parseFile(content, _filePath) {
-        const stringContent = typeof content === 'string' ? content : new TextDecoder().decode(content);
-        try {
-            const ndgFile = JSON.parse(stringContent);
-            if (ndgFile.type === 'scene') {
-                const scene = ndgFile.content;
-                return this.convertNdgSceneToParsed(scene);
-            }
+  constructor() {
+    super("unity");
+    this.ndgFile = null;
+  }
+  canHandle(filePath) {
+    const ext = filePath.substring(filePath.lastIndexOf(".")).toLowerCase();
+    return [".ndg", ".ndgp", ".ndga"].includes(ext);
+  }
+  async import(options) {
+    const startTime = Date.now();
+    this.options = options;
+    this.clearMessages();
+    const scenes = [];
+    const assets = [];
+    try {
+      const content = await this.readFile(options.sourcePath);
+      this.ndgFile = JSON.parse(content);
+      if (this.ndgFile.magic !== NDG_MAGIC) {
+        this.addError(
+          "INVALID_MAGIC",
+          "Invalid NDG file magic",
+          options.sourcePath,
+          void 0,
+          true
+        );
+        return { ...this.createEmptyResult(), errors: this.errors };
+      }
+      if (this.ndgFile.type === "scene") {
+        const scene = this.convertNdgSceneToNice(this.ndgFile.content);
+        scenes.push(scene);
+      } else if (this.ndgFile.type === "project") {
+        const project = this.ndgFile.content;
+        for (const ndgScene of project.scenes) {
+          scenes.push(this.convertNdgSceneToNice(ndgScene));
         }
-        catch {
-            return null;
+        for (const ndgAsset of project.assets) {
+          assets.push(this.convertNdgAssetToNice(ndgAsset));
         }
-        return null;
-    }
-    async validate(sourcePath) {
-        const errors = [];
-        if (!this.canHandle(sourcePath)) {
-            errors.push({
-                code: 'INVALID_FORMAT',
-                message: `File ${sourcePath} is not a valid NDG file`,
-                file: sourcePath,
-                fatal: true,
-            });
+      } else if (this.ndgFile.type === "asset-bundle") {
+        const bundle = this.ndgFile.content;
+        for (const ndgAsset of bundle.assets) {
+          assets.push(this.convertNdgAssetToNice(ndgAsset));
         }
-        return errors;
-    }
-    // ----------------------------------------
-    // Conversion
-    // ----------------------------------------
-    convertNdgSceneToNice(ndgScene) {
-        return {
-            id: ndgScene.id,
-            name: ndgScene.name,
-            entities: ndgScene.entities.map((e) => this.convertNdgEntityToNice(e)),
-            settings: {
-                width: ndgScene.settings.width,
-                height: ndgScene.settings.height,
-                backgroundColor: ndgScene.settings.backgroundColor,
-                gravity: ndgScene.settings.gravity,
-                ...ndgScene.metadata,
-            },
-        };
+      }
+    } catch (error) {
+      this.addError(
+        "IMPORT_ERROR",
+        `Failed to import: ${error}`,
+        options.sourcePath,
+        void 0,
+        true
+      );
     }
-    convertNdgEntityToNice(ndgEntity) {
-        return {
-            id: ndgEntity.id,
-            name: ndgEntity.name,
-            components: [
-                {
-                    type: 'Transform',
-                    data: {
-                        position: ndgEntity.transform.position,
-                        rotation: ndgEntity.transform.rotation,
-                        scale: ndgEntity.transform.scale,
-                    },
-                },
-                ...ndgEntity.components.map((c) => ({
-                    type: c.type,
-                    data: c.data,
-                })),
-            ],
-            children: ndgEntity.children.map((c) => this.convertNdgEntityToNice(c)),
-            tags: ndgEntity.tags,
-            active: ndgEntity.active,
-        };
-    }
-    convertNdgAssetToNice(ndgAsset) {
-        return {
-            id: ndgAsset.id,
-            name: ndgAsset.name,
-            type: ndgAsset.type,
-            path: ndgAsset.path,
-            data: ndgAsset.data || {},
-        };
-    }
-    convertNdgSceneToParsed(ndgScene) {
-        return {
-            name: ndgScene.name,
-            width: ndgScene.settings.width,
-            height: ndgScene.settings.height,
-            backgroundColor: ndgScene.settings.backgroundColor,
-            layers: ndgScene.layers?.map((l, _i) => ({
-                name: l.name,
-                type: 'object',
-                visible: l.visible,
-                opacity: 1,
-                offsetX: 0,
-                offsetY: 0,
-                zIndex: l.zIndex,
-                properties: l.properties || {},
-            })) || [],
-            entities: ndgScene.entities.map((e) => this.convertNdgEntityToParsed(e)),
-            properties: {
-                ...ndgScene.settings,
-                ...ndgScene.metadata,
-            },
-        };
+    return this.createResult(scenes, assets, startTime);
+  }
+  async parseFile(content, _filePath) {
+    const stringContent = typeof content === "string" ? content : new TextDecoder().decode(content);
+    try {
+      const ndgFile = JSON.parse(stringContent);
+      if (ndgFile.type === "scene") {
+        const scene = ndgFile.content;
+        return this.convertNdgSceneToParsed(scene);
+      }
+    } catch {
+      return null;
     }
-    convertNdgEntityToParsed(ndgEntity) {
-        return {
-            id: ndgEntity.id,
-            name: ndgEntity.name,
-            type: ndgEntity.tags[0] || 'Entity',
-            x: ndgEntity.transform.position.x,
-            y: ndgEntity.transform.position.y,
-            width: 1,
-            height: 1,
-            rotation: typeof ndgEntity.transform.rotation === 'number'
-                ? ndgEntity.transform.rotation
-                : ndgEntity.transform.rotation.z,
-            scaleX: ndgEntity.transform.scale.x,
-            scaleY: ndgEntity.transform.scale.y,
-            visible: ndgEntity.active,
-            components: ndgEntity.components.map((c) => ({
-                type: c.type,
-                data: c.data,
-            })),
-            children: ndgEntity.children.map((c) => this.convertNdgEntityToParsed(c)),
-            properties: {
-                tags: ndgEntity.tags,
-                layer: ndgEntity.layer,
-                ...ndgEntity.metadata,
-            },
-        };
+    return null;
+  }
+  async validate(sourcePath) {
+    const errors = [];
+    if (!this.canHandle(sourcePath)) {
+      errors.push({
+        code: "INVALID_FORMAT",
+        message: `File ${sourcePath} is not a valid NDG file`,
+        file: sourcePath,
+        fatal: true
+      });
     }
-    async readFile(path) {
-        if (typeof globalThis.process !== 'undefined' && globalThis.process.versions?.node) {
-            const fs = await import('fs');
-            return fs.readFileSync(path, 'utf-8');
-        }
-        else if (typeof fetch !== 'undefined') {
-            const response = await fetch(path);
-            return response.text();
-        }
-        throw new Error('Unable to read file in current environment');
+    return errors;
+  }
+  // ----------------------------------------
+  // Conversion
+  // ----------------------------------------
+  convertNdgSceneToNice(ndgScene) {
+    return {
+      id: ndgScene.id,
+      name: ndgScene.name,
+      entities: ndgScene.entities.map((e) => this.convertNdgEntityToNice(e)),
+      settings: {
+        width: ndgScene.settings.width,
+        height: ndgScene.settings.height,
+        backgroundColor: ndgScene.settings.backgroundColor,
+        gravity: ndgScene.settings.gravity,
+        ...ndgScene.metadata
+      }
+    };
+  }
+  convertNdgEntityToNice(ndgEntity) {
+    return {
+      id: ndgEntity.id,
+      name: ndgEntity.name,
+      components: [
+        {
+          type: "Transform",
+          data: {
+            position: ndgEntity.transform.position,
+            rotation: ndgEntity.transform.rotation,
+            scale: ndgEntity.transform.scale
+          }
+        },
+        ...ndgEntity.components.map((c) => ({
+          type: c.type,
+          data: c.data
+        }))
+      ],
+      children: ndgEntity.children.map((c) => this.convertNdgEntityToNice(c)),
+      tags: ndgEntity.tags,
+      active: ndgEntity.active
+    };
+  }
+  convertNdgAssetToNice(ndgAsset) {
+    return {
+      id: ndgAsset.id,
+      name: ndgAsset.name,
+      type: ndgAsset.type,
+      path: ndgAsset.path,
+      data: ndgAsset.data || {}
+    };
+  }
+  convertNdgSceneToParsed(ndgScene) {
+    return {
+      name: ndgScene.name,
+      width: ndgScene.settings.width,
+      height: ndgScene.settings.height,
+      backgroundColor: ndgScene.settings.backgroundColor,
+      layers: ndgScene.layers?.map((l, _i) => ({
+        name: l.name,
+        type: "object",
+        visible: l.visible,
+        opacity: 1,
+        offsetX: 0,
+        offsetY: 0,
+        zIndex: l.zIndex,
+        properties: l.properties || {}
+      })) || [],
+      entities: ndgScene.entities.map((e) => this.convertNdgEntityToParsed(e)),
+      properties: {
+        ...ndgScene.settings,
+        ...ndgScene.metadata
+      }
+    };
+  }
+  convertNdgEntityToParsed(ndgEntity) {
+    return {
+      id: ndgEntity.id,
+      name: ndgEntity.name,
+      type: ndgEntity.tags[0] || "Entity",
+      x: ndgEntity.transform.position.x,
+      y: ndgEntity.transform.position.y,
+      width: 1,
+      height: 1,
+      rotation: typeof ndgEntity.transform.rotation === "number" ? ndgEntity.transform.rotation : ndgEntity.transform.rotation.z,
+      scaleX: ndgEntity.transform.scale.x,
+      scaleY: ndgEntity.transform.scale.y,
+      visible: ndgEntity.active,
+      components: ndgEntity.components.map((c) => ({
+        type: c.type,
+        data: c.data
+      })),
+      children: ndgEntity.children.map((c) => this.convertNdgEntityToParsed(c)),
+      properties: {
+        tags: ndgEntity.tags,
+        layer: ndgEntity.layer,
+        ...ndgEntity.metadata
+      }
+    };
+  }
+  async readFile(path) {
+    if (typeof globalThis.process !== "undefined" && globalThis.process.versions?.node) {
+      const fs = await import("fs");
+      return fs.readFileSync(path, "utf-8");
+    } else if (typeof fetch !== "undefined") {
+      const response = await fetch(path);
+      return response.text();
     }
+    throw new Error("Unable to read file in current environment");
+  }
 }
-// ============================================================
-// NDG Exporter
-// ============================================================
 class NdgExporter {
-    constructor() {
-        this.generatorName = 'Nice2Dev';
-        this.generatorVersion = '1.0.0';
-    }
-    /**
-     * Export a single scene to NDG format
-     */
-    exportScene(scene, source) {
-        const now = new Date().toISOString();
-        return {
-            magic: NDG_MAGIC,
-            version: NDG_FORMAT_VERSION,
-            type: 'scene',
-            created: now,
-            modified: now,
-            generator: {
-                name: this.generatorName,
-                version: this.generatorVersion,
-            },
-            source,
-            content: this.convertNiceSceneToNdg(scene),
-        };
-    }
-    /**
-     * Export a full project to NDG format
-     */
-    exportProject(project) {
-        const now = new Date().toISOString();
-        return {
-            magic: NDG_MAGIC,
-            version: NDG_FORMAT_VERSION,
-            type: 'project',
-            created: now,
-            modified: now,
-            generator: {
-                name: this.generatorName,
-                version: this.generatorVersion,
-            },
-            content: this.convertNiceProjectToNdg(project),
-        };
-    }
-    /**
-     * Export an asset bundle to NDG format
-     */
-    exportAssetBundle(name, assets) {
-        const now = new Date().toISOString();
-        return {
-            magic: NDG_MAGIC,
-            version: NDG_FORMAT_VERSION,
-            type: 'asset-bundle',
-            created: now,
-            modified: now,
-            generator: {
-                name: this.generatorName,
-                version: this.generatorVersion,
-            },
-            content: {
-                name,
-                assets: assets.map((a) => this.convertNiceAssetToNdg(a)),
-            },
-        };
-    }
-    /**
-     * Serialize NDG file to JSON string
-     */
-    serialize(ndgFile, pretty = true) {
-        return JSON.stringify(ndgFile, null, pretty ? 2 : undefined);
-    }
-    // ----------------------------------------
-    // Conversion
-    // ----------------------------------------
-    convertNiceSceneToNdg(scene) {
-        const settings = scene.settings || {};
-        return {
-            id: scene.id,
-            name: scene.name,
-            settings: {
-                width: settings.width || 1920,
-                height: settings.height || 1080,
-                backgroundColor: settings.backgroundColor || '#1a1a2e',
-                gravity: settings.gravity,
-            },
-            entities: scene.entities.map((e) => this.convertNiceEntityToNdg(e)),
-            metadata: this.extractMetadata(settings),
-        };
-    }
-    convertNiceEntityToNdg(entity) {
-        const transformComp = entity.components.find((c) => c.type === 'Transform');
-        const transform = transformComp?.data || {};
-        return {
-            id: entity.id,
-            name: entity.name,
-            active: entity.active ?? true,
-            tags: entity.tags || [],
-            transform: {
-                position: transform.position || { x: 0, y: 0 },
-                rotation: transform.rotation || 0,
-                scale: transform.scale || { x: 1, y: 1 },
-            },
-            components: entity.components
-                .filter((c) => c.type !== 'Transform')
-                .map((c) => ({
-                type: c.type,
-                enabled: true,
-                data: c.data ?? {},
-            })),
-            children: (entity.children || []).map((c) => this.convertNiceEntityToNdg(c)),
-        };
-    }
-    convertNiceProjectToNdg(project) {
-        return {
-            name: project.name,
-            description: project.description,
-            settings: {
-                width: project.settings?.width || 1920,
-                height: project.settings?.height || 1080,
-                physics: project.settings?.physics
-                    ? {
-                        gravity: project.settings.physics.gravity,
-                        velocityIterations: project.settings.physics.velocityIterations ?? 8,
-                        positionIterations: project.settings.physics.positionIterations ?? 3,
-                        timeStep: project.settings.physics.timeStep ?? 1 / 60,
-                    }
-                    : undefined,
-                audio: project.settings?.audio
-                    ? {
-                        masterVolume: project.settings.audio.masterVolume,
-                        musicVolume: project.settings.audio.musicVolume ?? 1,
-                        sfxVolume: project.settings.audio.sfxVolume ?? 1,
-                        audioChannels: project.settings.audio.audioChannels ?? 32,
-                    }
-                    : undefined,
-                rendering: project.settings?.rendering
-                    ? {
-                        pixelPerfect: project.settings.rendering.pixelPerfect ?? project.settings.rendering.pixelArt,
-                        antialiasing: project.settings.rendering.antialiasing ?? project.settings.rendering.antialias,
-                        vsync: project.settings.rendering.vsync ?? true,
-                        backgroundColor: project.settings.rendering.backgroundColor ?? '#000000',
-                    }
-                    : undefined,
-                input: project.settings?.input,
-            },
-            scenes: project.scenes.map((s) => this.convertNiceSceneToNdg(s)),
-            assets: project.assets.map((a) => this.convertNiceAssetToNdg(a)),
-        };
-    }
-    convertNiceAssetToNdg(asset) {
-        return {
-            id: asset.id,
-            name: asset.name,
-            type: asset.type,
-            path: asset.path,
-            data: asset.data,
-        };
-    }
-    extractMetadata(settings) {
-        const knownKeys = ['width', 'height', 'backgroundColor', 'gravity'];
-        const metadata = {};
-        for (const [key, value] of Object.entries(settings)) {
-            if (!knownKeys.includes(key)) {
-                metadata[key] = value;
-            }
-        }
-        return Object.keys(metadata).length > 0 ? metadata : {};
+  constructor() {
+    this.generatorName = "Nice2Dev";
+    this.generatorVersion = "1.0.0";
+  }
+  /**
+   * Export a single scene to NDG format
+   */
+  exportScene(scene, source) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    return {
+      magic: NDG_MAGIC,
+      version: NDG_FORMAT_VERSION,
+      type: "scene",
+      created: now,
+      modified: now,
+      generator: {
+        name: this.generatorName,
+        version: this.generatorVersion
+      },
+      source,
+      content: this.convertNiceSceneToNdg(scene)
+    };
+  }
+  /**
+   * Export a full project to NDG format
+   */
+  exportProject(project) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    return {
+      magic: NDG_MAGIC,
+      version: NDG_FORMAT_VERSION,
+      type: "project",
+      created: now,
+      modified: now,
+      generator: {
+        name: this.generatorName,
+        version: this.generatorVersion
+      },
+      content: this.convertNiceProjectToNdg(project)
+    };
+  }
+  /**
+   * Export an asset bundle to NDG format
+   */
+  exportAssetBundle(name, assets) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    return {
+      magic: NDG_MAGIC,
+      version: NDG_FORMAT_VERSION,
+      type: "asset-bundle",
+      created: now,
+      modified: now,
+      generator: {
+        name: this.generatorName,
+        version: this.generatorVersion
+      },
+      content: {
+        name,
+        assets: assets.map((a) => this.convertNiceAssetToNdg(a))
+      }
+    };
+  }
+  /**
+   * Serialize NDG file to JSON string
+   */
+  serialize(ndgFile, pretty = true) {
+    return JSON.stringify(ndgFile, null, pretty ? 2 : void 0);
+  }
+  // ----------------------------------------
+  // Conversion
+  // ----------------------------------------
+  convertNiceSceneToNdg(scene) {
+    const settings = scene.settings || {};
+    return {
+      id: scene.id,
+      name: scene.name,
+      settings: {
+        width: settings.width || 1920,
+        height: settings.height || 1080,
+        backgroundColor: settings.backgroundColor || "#1a1a2e",
+        gravity: settings.gravity
+      },
+      entities: scene.entities.map((e) => this.convertNiceEntityToNdg(e)),
+      metadata: this.extractMetadata(settings)
+    };
+  }
+  convertNiceEntityToNdg(entity) {
+    const transformComp = entity.components.find((c) => c.type === "Transform");
+    const transform = transformComp?.data || {};
+    return {
+      id: entity.id,
+      name: entity.name,
+      active: entity.active ?? true,
+      tags: entity.tags || [],
+      transform: {
+        position: transform.position || { x: 0, y: 0 },
+        rotation: transform.rotation || 0,
+        scale: transform.scale || { x: 1, y: 1 }
+      },
+      components: entity.components.filter((c) => c.type !== "Transform").map((c) => ({
+        type: c.type,
+        enabled: true,
+        data: c.data ?? {}
+      })),
+      children: (entity.children || []).map((c) => this.convertNiceEntityToNdg(c))
+    };
+  }
+  convertNiceProjectToNdg(project) {
+    return {
+      name: project.name,
+      description: project.description,
+      settings: {
+        width: project.settings?.width || 1920,
+        height: project.settings?.height || 1080,
+        physics: project.settings?.physics ? {
+          gravity: project.settings.physics.gravity,
+          velocityIterations: project.settings.physics.velocityIterations ?? 8,
+          positionIterations: project.settings.physics.positionIterations ?? 3,
+          timeStep: project.settings.physics.timeStep ?? 1 / 60
+        } : void 0,
+        audio: project.settings?.audio ? {
+          masterVolume: project.settings.audio.masterVolume,
+          musicVolume: project.settings.audio.musicVolume ?? 1,
+          sfxVolume: project.settings.audio.sfxVolume ?? 1,
+          audioChannels: project.settings.audio.audioChannels ?? 32
+        } : void 0,
+        rendering: project.settings?.rendering ? {
+          pixelPerfect: project.settings.rendering.pixelPerfect ?? project.settings.rendering.pixelArt,
+          antialiasing: project.settings.rendering.antialiasing ?? project.settings.rendering.antialias,
+          vsync: project.settings.rendering.vsync ?? true,
+          backgroundColor: project.settings.rendering.backgroundColor ?? "#000000"
+        } : void 0,
+        input: project.settings?.input
+      },
+      scenes: project.scenes.map((s) => this.convertNiceSceneToNdg(s)),
+      assets: project.assets.map((a) => this.convertNiceAssetToNdg(a))
+    };
+  }
+  convertNiceAssetToNdg(asset) {
+    return {
+      id: asset.id,
+      name: asset.name,
+      type: asset.type,
+      path: asset.path,
+      data: asset.data
+    };
+  }
+  extractMetadata(settings) {
+    const knownKeys = ["width", "height", "backgroundColor", "gravity"];
+    const metadata = {};
+    for (const [key, value] of Object.entries(settings)) {
+      if (!knownKeys.includes(key)) {
+        metadata[key] = value;
+      }
     }
+    return Object.keys(metadata).length > 0 ? metadata : {};
+  }
 }
-// ============================================================
-// Bidirectional Sync Helper
-// ============================================================
 class NdgBidirectionalSync {
-    constructor() {
-        this.importer = new NdgImporter();
-        this.exporter = new NdgExporter();
-    }
-    /**
-     * Import and track original data for round-trip
-     */
-    async importWithTracking(sourcePath, sourceType) {
-        const result = await this.importer.import({ sourcePath });
-        const source = {
-            type: sourceType,
-            path: sourcePath,
-            importedAt: new Date().toISOString(),
-            // Could also preserve original data here for lossless round-trip
-        };
-        return {
-            scenes: result.scenes,
-            assets: result.assets,
-            source,
-        };
-    }
-    /**
-     * Export with source tracking for later re-import
-     */
-    exportWithTracking(scene, source) {
-        const ndgFile = this.exporter.exportScene(scene, source);
-        return this.exporter.serialize(ndgFile);
-    }
-    /**
-     * Check if NDG file has modifications compared to source
-     */
-    hasModifications(ndgFile) {
-        return ndgFile.created !== ndgFile.modified;
-    }
-    /**
-     * Update the modified timestamp
-     */
-    touch(ndgFile) {
-        return {
-            ...ndgFile,
-            modified: new Date().toISOString(),
-        };
-    }
+  constructor() {
+    this.importer = new NdgImporter();
+    this.exporter = new NdgExporter();
+  }
+  /**
+   * Import and track original data for round-trip
+   */
+  async importWithTracking(sourcePath, sourceType) {
+    const result = await this.importer.import({ sourcePath });
+    const source = {
+      type: sourceType,
+      path: sourcePath,
+      importedAt: (/* @__PURE__ */ new Date()).toISOString()
+      // Could also preserve original data here for lossless round-trip
+    };
+    return {
+      scenes: result.scenes,
+      assets: result.assets,
+      source
+    };
+  }
+  /**
+   * Export with source tracking for later re-import
+   */
+  exportWithTracking(scene, source) {
+    const ndgFile = this.exporter.exportScene(scene, source);
+    return this.exporter.serialize(ndgFile);
+  }
+  /**
+   * Check if NDG file has modifications compared to source
+   */
+  hasModifications(ndgFile) {
+    return ndgFile.created !== ndgFile.modified;
+  }
+  /**
+   * Update the modified timestamp
+   */
+  touch(ndgFile) {
+    return {
+      ...ndgFile,
+      modified: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
 }
-// ============================================================
-// Factory Functions
-// ============================================================
-/**
- * Create NDG importer
- */
 function createNdgImporter() {
-    return new NdgImporter();
+  return new NdgImporter();
 }
-/**
- * Create NDG exporter
- */
 function createNdgExporter() {
-    return new NdgExporter();
+  return new NdgExporter();
 }
-/**
- * Create bidirectional sync helper
- */
 function createBidirectionalSync() {
-    return new NdgBidirectionalSync();
+  return new NdgBidirectionalSync();
 }
-/**
- * Quick export scene to NDG JSON string
- */
 function sceneToNdg(scene, pretty = true) {
-    const exporter = new NdgExporter();
-    const ndgFile = exporter.exportScene(scene);
-    return exporter.serialize(ndgFile, pretty);
+  const exporter = new NdgExporter();
+  const ndgFile = exporter.exportScene(scene);
+  return exporter.serialize(ndgFile, pretty);
 }
-/**
- * Quick import NDG JSON string to scene
- */
 async function ndgToScene(ndgJson) {
-    try {
-        const ndgFile = JSON.parse(ndgJson);
-        if (ndgFile.magic !== NDG_MAGIC || ndgFile.type !== 'scene') {
-            return null;
-        }
-        const importer = new NdgImporter();
-        const result = await importer.parseFile(ndgJson, 'inline.ndg');
-        if (result && 'name' in result) {
-            return importer['convertParsedToNiceScene'](result);
-        }
-        return null;
+  try {
+    const ndgFile = JSON.parse(ndgJson);
+    if (ndgFile.magic !== NDG_MAGIC || ndgFile.type !== "scene") {
+      return null;
     }
-    catch {
-        return null;
+    const importer = new NdgImporter();
+    const result = await importer.parseFile(ndgJson, "inline.ndg");
+    if (result && "name" in result) {
+      return importer["convertParsedToNiceScene"](result);
     }
+    return null;
+  } catch {
+    return null;
+  }
 }
-
-export { NdgBidirectionalSync, NdgExporter, NdgImporter, createBidirectionalSync, createNdgExporter, createNdgImporter, ndgToScene, sceneToNdg };
+export {
+  NdgBidirectionalSync,
+  NdgExporter,
+  NdgImporter,
+  createBidirectionalSync,
+  createNdgExporter,
+  createNdgImporter,
+  ndgToScene,
+  sceneToNdg
+};