@babylonjs/inspector 9.8.0 → 9.9.1

package/lib/index.js

@@ -1,4 +1,4 @@
-export { A as Accordion, i as AccordionSection, l as AccordionSectionItem, m as AttachDebugLayer, n as BooleanBadgePropertyLine, o as BoundProperty, p as BridgeCommandRegistryIdentity, q as BuiltInsExtensionFeed, B as Button, j as ButtonLine, r as Checkbox, C as CheckboxPropertyLine, s as ChildWindow, t as Collapse, v as Color3GradientComponent, w as Color3GradientList, x as Color3PropertyLine, y as Color4GradientComponent, z as Color4GradientList, D as Color4PropertyLine, E as ColorPickerPopup, F as ColorStepGradientComponent, G as ComboBox, H as ComboBoxPropertyLine, I as ConstructorFactory, J as ConvertOptions, K as DebugServiceIdentity, O as DetachDebugLayer, Q as DraggableLine, R as Dropdown, U as EntitySelector, W as ErrorBoundary, X as ExtensibleAccordion, Y as FactorGradientComponent, Z as FactorGradientList, _ as FileUploadLine, $ as GetPropertyDescriptor, a0 as GizmoServiceIdentity, a1 as HexPropertyLine, a2 as InfoLabel, a3 as InputHexField, a4 as InputHsvField, a5 as Inspector, a6 as InterceptFunction, a7 as InterceptProperty, a8 as IsPropertyReadonly, a9 as LineContainer, L as Link, aa as LinkPropertyLine, c as LinkToEntity, ab as LinkToEntityPropertyLine, ac as List, ad as MakeDialogTeachingMoment, ae as MakeLazyComponent, af as MakeModularBridge, ag as MakeModularTool, ah as MakePopoverTeachingMoment, ai as MakePropertyHook, aj as MakeTeachingMoment, ak as MaterialSelector, M as MessageBar, al as NodeSelector, am as NumberDropdown, an as NumberDropdownPropertyLine, N as NumberInputPropertyLine, ao as ObservableCollection, ap as Pane, aq as PlaceholderPropertyLine, P as Popover, ar as PositionedPopover, as as PropertiesServiceIdentity, at as Property, au as PropertyContext, av as PropertyLine, aw as QuaternionPropertyLine, ax as RotationVectorPropertyLine, f as SceneContextIdentity, ay as SceneExplorerServiceIdentity, az as SearchBar, aA as SearchBox, aB as SelectionServiceDefinition, g as SelectionServiceIdentity, aC as SettingsServiceIdentity, aD as SettingsStore, aE as SettingsStoreIdentity, S as ShellServiceIdentity, aF as ShowInspector, aG as SidePaneContainer, aH as SkeletonSelector, aI as Slider, aJ as SpinButton, d as SpinButtonPropertyLine, aK as StartInspectable, aL as StatsServiceIdentity, aM as StringDropdown, aN as StringDropdownPropertyLine, aO as StringifiedPropertyLine, aP as Switch, aQ as SwitchPropertyLine, aR as SyncedSliderInput, aS as SyncedSliderPropertyLine, aT as TeachingMoment, aU as TextAreaPropertyLine, aV as TextInput, T as TextInputPropertyLine, aW as TextPropertyLine, aX as Textarea, aY as TextureSelector, aZ as TextureUpload, a_ as Theme, a$ as ThemeServiceIdentity, b0 as ToastProvider, b1 as ToggleButton, k as ToolsServiceIdentity, b2 as Tooltip, b3 as UploadButton, b4 as Vector2PropertyLine, V as Vector3PropertyLine, b5 as Vector4PropertyLine, b6 as WatcherServiceIdentity, b7 as inspectorAssetNotFoundHandler, b8 as useAngleConverters, b9 as useAsyncResource, ba as useColor3Property, bb as useColor4Property, bc as useEventListener, bd as useEventfulState, b as useInterceptObservable, be as useKeyListener, bf as useKeyState, bg as useObservableCollection, h as useObservableState, bh as useOrderedObservableCollection, bi as usePollingObservable, e as useProperty, bj as usePropertyChangedNotifier, bk as useQuaternionProperty, bl as useResource, bm as useTheme, bn as useThemeMode, a as useToast, bo as useVector3Property } from './index-PYblOaAV.js';
+export { A as Accordion, i as AccordionSection, l as AccordionSectionItem, m as AttachDebugLayer, n as BooleanBadgePropertyLine, o as BoundProperty, p as BridgeCommandRegistryIdentity, q as BuiltInsExtensionFeed, B as Button, j as ButtonLine, r as Checkbox, C as CheckboxPropertyLine, s as ChildWindow, t as Collapse, v as Color3GradientComponent, w as Color3GradientList, x as Color3PropertyLine, y as Color4GradientComponent, z as Color4GradientList, D as Color4PropertyLine, E as ColorPickerPopup, F as ColorStepGradientComponent, G as ComboBox, H as ComboBoxPropertyLine, I as ConstructorFactory, J as ConvertOptions, K as DebugServiceIdentity, O as DetachDebugLayer, Q as DraggableLine, R as Dropdown, U as EntitySelector, W as ErrorBoundary, X as ExtensibleAccordion, Y as FactorGradientComponent, Z as FactorGradientList, _ as FileUploadLine, $ as GetPropertyDescriptor, a0 as GizmoServiceIdentity, a1 as HexPropertyLine, a2 as InfoLabel, a3 as InputHexField, a4 as InputHsvField, a5 as Inspector, a6 as InterceptFunction, a7 as InterceptProperty, a8 as IsPropertyReadonly, a9 as LineContainer, L as Link, aa as LinkPropertyLine, c as LinkToEntity, ab as LinkToEntityPropertyLine, ac as List, ad as MakeDialogTeachingMoment, ae as MakeLazyComponent, af as MakeModularBridge, ag as MakeModularTool, ah as MakePopoverTeachingMoment, ai as MakePropertyHook, aj as MakeTeachingMoment, ak as MaterialSelector, M as MessageBar, al as NodeSelector, am as NumberDropdown, an as NumberDropdownPropertyLine, N as NumberInputPropertyLine, ao as ObservableCollection, ap as Pane, aq as PlaceholderPropertyLine, P as Popover, ar as PositionedPopover, as as PropertiesServiceIdentity, at as Property, au as PropertyContext, av as PropertyLine, aw as QuaternionPropertyLine, ax as RotationVectorPropertyLine, f as SceneContextIdentity, ay as SceneExplorerServiceIdentity, az as SearchBar, aA as SearchBox, aB as SelectionServiceDefinition, g as SelectionServiceIdentity, aC as SettingsServiceIdentity, aD as SettingsStore, aE as SettingsStoreIdentity, S as ShellServiceIdentity, aF as ShowInspector, aG as SidePaneContainer, aH as SkeletonSelector, aI as Slider, aJ as SpinButton, d as SpinButtonPropertyLine, aK as StartInspectable, aL as StatsServiceIdentity, aM as StringDropdown, aN as StringDropdownPropertyLine, aO as StringifiedPropertyLine, aP as Switch, aQ as SwitchPropertyLine, aR as SyncedSliderInput, aS as SyncedSliderPropertyLine, aT as TeachingMoment, aU as TextAreaPropertyLine, aV as TextInput, T as TextInputPropertyLine, aW as TextPropertyLine, aX as Textarea, aY as TextureSelector, aZ as TextureUpload, a_ as Theme, a$ as ThemeServiceIdentity, b0 as ToastProvider, b1 as ToggleButton, k as ToolsServiceIdentity, b2 as Tooltip, b3 as UploadButton, b4 as Vector2PropertyLine, V as Vector3PropertyLine, b5 as Vector4PropertyLine, b6 as WatcherServiceIdentity, b7 as inspectorAssetNotFoundHandler, b8 as useAngleConverters, b9 as useAsyncResource, ba as useColor3Property, bb as useColor4Property, bc as useEventListener, bd as useEventfulState, b as useInterceptObservable, be as useKeyListener, bf as useKeyState, bg as useObservableCollection, h as useObservableState, bh as useOrderedObservableCollection, bi as usePollingObservable, e as useProperty, bj as usePropertyChangedNotifier, bk as useQuaternionProperty, bl as useResource, bm as useTheme, bn as useThemeMode, a as useToast, bo as useVector3Property } from './index-UoPnMkyH.js';
 import 'react/jsx-runtime';
 import 'react';
 import '@fluentui/react-components';
@@ -146,6 +146,8 @@ import '@babylonjs/core/Misc/videoRecorder.js';
 import '@babylonjs/core/Misc/sceneSerializer.js';
 import '@babylonjs/core/Misc/environmentTextureTools.js';
 import '@babylonjs/core/SmartAssets/smartAssetManager.js';
+import '@babylonjs/core/Loading/Plugins/babylonFileLoader.js';
+import '@babylonjs/core/SmartAssets/smartAssetSerializer.js';
 import '@babylonjs/core/Loading/sceneLoader.js';
 import '@babylonjs/core/Misc/filesInput.js';
 import '@babylonjs/loaders/glTF/2.0/glTFLoaderExtensionRegistry.js';

package/lib/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/lib/projects/overrideEntry.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Defines the shape of an override entry — a property diff applied to a
+ * scene object identified by name. Overrides target any object in the
+ * scene's standard collections (meshes, materials, lights, etc.) regardless
+ * of how that object was created.
+ */
+export interface IOverrideEntry {
+    /** The type of object to target (e.g., "meshes", "materials", "lights"). */
+    readonly targetType: OverrideTargetType;
+    /** The name of the target object. Use "" for scene-level overrides. */
+    readonly targetName: string;
+    /**
+     * Disambiguator for when multiple objects in `scene[targetType]` share the
+     * same `targetName`. The override applies to the N-th match (0-based) at
+     * apply time. When names are unique, use 0.
+     */
+    readonly targetIndex: number;
+    /** Dot-separated property path on the target (e.g., "albedoColor", "position.x"). */
+    readonly propertyPath: string;
+    /** The override value. */
+    readonly value: OverrideValue;
+}
+/**
+ * The types of scene objects that can be targeted by overrides.
+ */
+export type OverrideTargetType = "meshes" | "materials" | "textures" | "lights" | "cameras" | "animationGroups" | "scene";
+/**
+ * An override value. Supports scalars, color/vector arrays, object references,
+ * and null (used to clear a slot, e.g. removing a material assignment).
+ * - number: scalar property (e.g., intensity, alpha)
+ * - string: string property, or "ref:name" / "samTexture:key" / "texture:name" object reference
+ * - boolean: boolean property
+ * - number[]: array property mapped to Vector3, Color3, Color4, etc.
+ * - null: explicitly clear an object-typed slot
+ */
+export type OverrideValue = number | string | boolean | number[] | null;

package/lib/projects/overrideManager.d.ts

@@ -0,0 +1,176 @@
+import { type Scene } from "@babylonjs/core/scene.js";
+import { Observable, type Observer } from "@babylonjs/core/Misc/observable.js";
+import { type IOverrideEntry, type OverrideTargetType } from "./overrideEntry";
+/**
+ * Stateful handle for a scene's property override registry.
+ *
+ * Override behavior is exposed through module-level functions rather than
+ * class methods so callers can import only the operations they need.
+ *
+ * Overrides are property diffs applied to scene objects identified by name.
+ * They persist across reloads and are typically saved alongside a project
+ * file. The override manager is fully independent of any other scene
+ * subsystem (SmartAssetManager, loaders, etc.) — it works with any object
+ * in the scene's standard collections (meshes, materials, lights, …)
+ * regardless of how that object was created.
+ *
+ * When multiple objects share a name (e.g. two materials both called
+ * "Default" loaded from different glTFs), {@link IOverrideEntry.targetIndex}
+ * disambiguates: it stores the object's position among same-named siblings
+ * at capture time and is used to pick the correct one at apply time.
+ *
+ * @example
+ * ```typescript
+ * AddOverride(scene, {
+ *     targetType: "materials",
+ *     targetName: "canPaint",
+ *     targetIndex: 0,
+ *     propertyPath: "albedoColor",
+ *     value: [1, 0, 0],
+ * });
+ * ```
+ */
+export type OverrideManager = {
+    /**
+     * The scene this manager is attached to.
+     */
+    readonly scene: Scene;
+    /**
+     * Fires whenever the override registry or applied state changes.
+     */
+    readonly onChangedObservable: Observable<void>;
+};
+/**
+ * Returns the OverrideManager attached to the given scene, creating and
+ * attaching one if none exists.
+ * @param scene - The scene to look up or attach a manager to.
+ * @returns The existing or newly created OverrideManager.
+ */
+export declare function GetOverrideManager(scene: Scene): OverrideManager;
+/**
+ * Adds an observer that is notified whenever an OverrideManager is created.
+ * @param callback - The callback to invoke with each newly created manager.
+ * @returns The observer registration.
+ */
+export declare function AddOverrideManagerCreatedObserver(callback: (manager: OverrideManager) => void): Observer<OverrideManager>;
+/**
+ * Options for {@link AddOverride}.
+ */
+export type AddOverrideOptions = {
+    /**
+     * If the `originalValue` field is present, the override is recorded *without*
+     * re-applying it (the caller is presumed to have already mutated the entity)
+     * and the field's content is captured as the property's pre-override
+     * "original" so {@link RemoveOverride} can restore it later.
+     *
+     * Inspector-driven edits use this: by the time `onPropertyChanged` fires,
+     * the binding has already written the new value, but it still has the prior
+     * value in hand. Without this seeding path, an override created via
+     * Inspector could never be reverted (the manager would have no record of
+     * the pre-edit value).
+     *
+     * If the field is absent, the override is applied normally and the original
+     * is captured by reading the property's current value on first apply.
+     */
+    readonly originalValue?: unknown;
+};
+/**
+ * Adds an override entry and immediately applies it.
+ * If an override with the same target coordinates already exists, it is replaced.
+ *
+ * When the caller has already mutated the target (e.g. an Inspector edit),
+ * pass `{ originalValue }` containing the property's prior value — this seeds
+ * the original-value map (so {@link RemoveOverride} can restore it) and skips
+ * the redundant apply step.
+ * @param scene - The scene whose override registry to update.
+ * @param entry - The override to add.
+ * @param options - Optional behavior modifiers; see {@link AddOverrideOptions}.
+ */
+export declare function AddOverride(scene: Scene, entry: IOverrideEntry, options?: AddOverrideOptions): void;
+/**
+ * Removes a single override matching the given coordinates. Restores the
+ * original value if one was captured.
+ * @param scene - The scene whose override registry to update.
+ * @param targetType - The target type.
+ * @param targetName - The target object name.
+ * @param targetIndex - The target index among same-named siblings.
+ * @param propertyPath - The property path to un-override.
+ * @returns True if an override was removed.
+ */
+export declare function RemoveOverride(scene: Scene, targetType: OverrideTargetType, targetName: string, targetIndex: number, propertyPath: string): boolean;
+/**
+ * Returns all overrides currently registered with the scene.
+ * @param scene - The scene whose override registry to read.
+ * @returns A read-only array of override entries.
+ */
+export declare function GetOverrides(scene: Scene): readonly IOverrideEntry[];
+/**
+ * Removes all overrides, optionally restoring original values.
+ * @param scene - The scene whose override registry to clear.
+ * @param restoreOriginals - If true, restores all captured original values.
+ */
+export declare function ClearOverrides(scene: Scene, restoreOriginals?: boolean): void;
+/**
+ * Updates the target coordinates on the override matching a specific (type,
+ * old-name, old-index) so it follows an entity rename. Used by capture services
+ * to keep overrides attached to a specific object after the user renames it.
+ *
+ * Only the override at the exact `(targetType, oldName, oldIndex)` slot is
+ * updated, so other same-named siblings keep their own overrides untouched.
+ *
+ * @param scene - The scene whose override registry to update.
+ * @param targetType - The target type.
+ * @param oldName - The previous name of the renamed entity.
+ * @param oldIndex - The previous index of the renamed entity among same-named siblings.
+ * @param newName - The new name of the renamed entity.
+ * @param newIndex - The new index of the renamed entity among same-named siblings.
+ */
+export declare function RenameOverrideTarget(scene: Scene, targetType: OverrideTargetType, oldName: string, oldIndex: number, newName: string, newIndex: number): void;
+/**
+ * Rewrites override *values* that reference an entity by name when that entity
+ * has been renamed. Mirrors {@link RenameOverrideTarget} but operates on the
+ * `value` field rather than the `targetName` field, so overrides whose value
+ * is `"ref:oldName"` (material/light/camera references) or `"texture:oldName"`
+ * (non-SmartAsset texture references) follow the rename instead of silently
+ * pointing at a non-existent entity.
+ *
+ * SmartAsset texture references (`"samTexture:<key>"`) are unaffected because
+ * the SmartAsset key is decoupled from the texture's runtime `name` field.
+ *
+ * @param scene - The scene whose override registry to update.
+ * @param valueScheme - Which encoded-reference prefix to rewrite: `"ref"` for
+ * material/light/camera references, `"texture"` for non-SAM textures.
+ * @param oldName - The previous name embedded in the reference.
+ * @param newName - The new name embedded in the reference.
+ */
+export declare function RenameOverrideValueReferences(scene: Scene, valueScheme: "ref" | "texture", oldName: string, newName: string): void;
+/**
+ * Applies all overrides to their current targets in the scene.
+ *
+ * Call this after any scene mutation that might have invalidated previously
+ * applied state (asset reload, object recreation, project load). The override
+ * manager does not auto-subscribe to other scene subsystems — coordination is
+ * the caller's responsibility, which keeps the override system independent.
+ * @param scene - The scene whose overrides to apply.
+ */
+export declare function ApplyAllOverrides(scene: Scene): void;
+/**
+ * Serializes all overrides to a JSON-compatible array.
+ * The on-disk shape is identical to the in-memory `IOverrideEntry`.
+ * @param scene - The scene whose overrides to serialize.
+ * @returns An array of override entries (shallow copies).
+ */
+export declare function SerializeOverrides(scene: Scene): IOverrideEntry[];
+/**
+ * Loads overrides from a serialized array and applies them.
+ * @param scene - The scene whose override registry to populate.
+ * @param data - Array of override entries.
+ */
+export declare function DeserializeAndApplyOverrides(scene: Scene, data: IOverrideEntry[]): void;
+/**
+ * Disposes the manager, clearing all overrides and detaching it from its scene.
+ * Safe to call multiple times; subsequent calls are no-ops. Automatically invoked when the
+ * owning scene is disposed.
+ * @param manager - The override manager state.
+ */
+export declare function DisposeOverrideManager(manager: OverrideManager): void;

package/lib/projects/projectFile.d.ts

@@ -0,0 +1,143 @@
+import "@babylonjs/core/Loading/Plugins/babylonFileLoader.js";
+import { type Scene } from "@babylonjs/core/scene.js";
+import { type ISerializedSmartAssetMap } from "@babylonjs/core/SmartAssets/smartAssetSerializer.js";
+import { type IOverrideEntry } from "./overrideEntry";
+/**
+ * ## `.babylonproj` project file format
+ *
+ * The `.babylonproj` zip on disk packages three layers:
+ * 1. **SmartAsset registry** — URL references to external assets (glb/gltf/textures
+ *    loaded via SAM). Local blob/data assets are bundled inside the zip and
+ *    extracted to fresh blob URLs on load.
+ * 2. **OverrideManager state** — declarative property overrides applied after load.
+ * 3. **Companion `.babylon`** — meshes, lights, cameras, transform nodes, and
+ *    materials that are *not* tracked by SAM (i.e. user-created scene content).
+ *    Plus a `companionBindings` side table mapping material texture slots back
+ *    to SAM-tracked textures so re-attachment works without embedding texture
+ *    bytes in the companion.
+ *
+ * ### What round-trips cleanly
+ * - SAM-tracked assets (re-fetched from their URLs or extracted from the zip)
+ * - User-created `Mesh` geometry, `Material`s (Standard/PBR/Multi/Node), and
+ *   `*Texture` slot bindings to SAM textures
+ * - `Light`s, `Camera`s, `TransformNode`s, scene/material image processing,
+ *   clear color, fog, environment intensity
+ * - Property overrides on any of the above
+ *
+ * ### Known gaps (not preserved on save/load)
+ * - `PostProcess` attachments to cameras (a post-process attaches to a *specific*
+ *   camera instance; we dispose+recreate cameras, leaving post-processes orphaned).
+ * - `AdvancedDynamicTexture` GUI controls — not in `.babylon` format.
+ * - Audio (`Sound` / `AudioEngine` state).
+ * - Particle systems with runtime state, baked vertex animations.
+ * - Complex shader-driven content like GaussianSplatting: the mesh round-trips
+ *   but its companion utility materials (`gaussianSplattingDepth`, `ProxyMaterial`)
+ *   get duplicated on each load cycle.
+ * - Skeleton animation playback state.
+ *
+ * If you hit a "the scene looks different after load" issue, it's almost
+ * certainly one of the gaps above rather than camera or mesh state drift.
+ */
+/**
+ * Reserved smart asset key for user-created objects (materials, lights, cameras)
+ * that are persisted as a companion `.babylon` file alongside the project JSON.
+ */
+export declare const ProjectLocalsKey = "__project_locals__";
+/**
+ * The result of serializing a project. Contains the project JSON and,
+ * if the scene has user-created objects, a companion `.babylon` blob.
+ */
+export interface IProjectBundle {
+    /** The project JSON document (assets + overrides, no embedded scene data). */
+    readonly project: ISerializedProject;
+    /**
+     * A companion `.babylon` file containing user-created objects not owned by
+     * any smart asset. Undefined if there are no such objects.
+     */
+    readonly companionBabylon?: Blob;
+}
+/**
+ * Maps each user-created material (by name) to its texture-slot bindings.
+ * A binding records "this `*Texture` slot on this material should be
+ * re-attached to the SmartAsset registered under this key" so that texture
+ * references survive a save/load round-trip without embedding the texture
+ * data inside the companion `.babylon`.
+ */
+export type CompanionTextureBindings = Record<string, Record<string, string>>;
+/**
+ * A versioned project file that composes a smart asset map with overrides.
+ * This is the unified on-disk format for persisting a complete project.
+ */
+export interface ISerializedProject {
+    /** Schema version. Must be 2 for the current version. */
+    readonly version: 2;
+    /** Smart asset key→URL mappings (from SmartAssetManager). */
+    readonly assets: ISerializedSmartAssetMap["assets"];
+    /** Property overrides (from OverrideManager). */
+    readonly overrides: IOverrideEntry[];
+    /**
+     * Optional bindings that re-attach SmartAsset-tracked textures to
+     * user-created material slots after the companion `.babylon` loads.
+     * Omitted when no user-created material references a SmartAsset texture.
+     */
+    readonly companionBindings?: CompanionTextureBindings;
+}
+/**
+ * Serializes a scene's smart asset map and override registry into a project
+ * bundle. User-created objects (materials, lights, cameras not owned by any
+ * smart asset) are serialized into a companion `.babylon` file rather than
+ * embedded in the project JSON.
+ *
+ * Both managers are looked up (and created if missing) via their respective
+ * `Get…Manager(scene)` accessors, so this function can be called on any scene.
+ *
+ * @param scene - The scene to serialize.
+ * @param baseUrl - Optional base URL for making asset paths relative.
+ * @returns A project bundle containing the JSON document and optional companion file.
+ */
+export declare function SerializeProject(scene: Scene, baseUrl?: string): IProjectBundle;
+/**
+ * Loads a project file from a URL, File, or pre-parsed object.
+ * Registers all asset entries on the scene's SmartAssetManager, loads all
+ * assets (including the companion `.babylon` for user-created objects), then
+ * applies all overrides via the OverrideManager.
+ *
+ * For loading the `.babylonproj` zip on-disk format, use {@link LoadProjectFileAsync}
+ * instead — it extracts the zip and then calls this function with the embedded
+ * JSON document.
+ *
+ * @param scene - The scene to populate.
+ * @param source - A URL string, File object, or pre-parsed ISerializedProject.
+ * @param rootUrl - Optional root URL for resolving relative asset paths.
+ */
+export declare function LoadProjectAsync(scene: Scene, source: string | File | ISerializedProject, rootUrl?: string): Promise<void>;
+/**
+ * Validates and parses a serialized project document.
+ * @param data - The raw data to validate (typically parsed JSON).
+ * @returns The validated project document.
+ * @throws If the data does not conform to the expected schema.
+ */
+export declare function DeserializeProject(data: unknown): ISerializedProject;
+/**
+ * Serializes a scene's project (smart assets + overrides) into a `.babylonproj`
+ * zip bundle.
+ *
+ * The zip contains:
+ * - `project.json` — the project document (assets + overrides)
+ * - `__project_locals__.babylon` — companion file for user-created objects (if any)
+ * - Bundled local asset files (blobs the user dragged in from disk)
+ *
+ * Remote URLs (http/https) are left as references and not bundled.
+ *
+ * @param scene - The scene to serialize.
+ * @returns A Blob containing the zip bundle.
+ */
+export declare function SaveProjectFileAsync(scene: Scene): Promise<Blob>;
+/**
+ * Loads a `.babylonproj` zip bundle into a scene. Extracts all files, creates
+ * blob URLs for bundled assets, and loads the project through SAM.
+ *
+ * @param scene - The scene to load the project into.
+ * @param zipFile - The `.babylonproj` zip file to load.
+ */
+export declare function LoadProjectFileAsync(scene: Scene, zipFile: File): Promise<void>;

package/lib/{quickCreateToolsService-8d6rBO-A.js → quickCreateToolsService-CXUBvaDf.js}

@@ -1,5 +1,5 @@
 import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
-import { P as Popover, a as useToast, b as useInterceptObservable, B as Button, c as LinkToEntity, T as TextInputPropertyLine, d as SpinButtonPropertyLine, C as CheckboxPropertyLine, V as Vector3PropertyLine, e as useProperty, M as MessageBar, S as ShellServiceIdentity, f as SceneContextIdentity, g as SelectionServiceIdentity, h as useObservableState, A as Accordion, i as AccordionSection } from './index-PYblOaAV.js';
+import { P as Popover, a as useToast, b as useInterceptObservable, B as Button, c as LinkToEntity, T as TextInputPropertyLine, d as SpinButtonPropertyLine, C as CheckboxPropertyLine, V as Vector3PropertyLine, e as useProperty, M as MessageBar, S as ShellServiceIdentity, f as SceneContextIdentity, g as SelectionServiceIdentity, h as useObservableState, A as Accordion, i as AccordionSection } from './index-UoPnMkyH.js';
 import { SettingsRegular, CollectionsAdd20Regular } from '@fluentui/react-icons';
 import '@babylonjs/core/Particles/webgl2ParticleSystem.js';
 import '@babylonjs/core/Rendering/prePassRendererSceneComponent.js';
@@ -156,6 +156,8 @@ import '@babylonjs/core/Misc/videoRecorder.js';
 import '@babylonjs/core/Misc/sceneSerializer.js';
 import '@babylonjs/core/Misc/environmentTextureTools.js';
 import '@babylonjs/core/SmartAssets/smartAssetManager.js';
+import '@babylonjs/core/Loading/Plugins/babylonFileLoader.js';
+import '@babylonjs/core/SmartAssets/smartAssetSerializer.js';
 import '@babylonjs/loaders/glTF/2.0/glTFLoaderExtensionRegistry.js';
 import '@babylonjs/loaders/glTF/glTFFileLoader.js';
 import '@babylonjs/loaders/glTF/glTFValidation.js';
@@ -776,4 +778,4 @@ var quickCreateToolsService = {
 };
 
 export { CreateToolsServiceDefinition, quickCreateToolsService as default };
-//# sourceMappingURL=quickCreateToolsService-8d6rBO-A.js.map
+//# sourceMappingURL=quickCreateToolsService-CXUBvaDf.js.map