babylon.quarks-editor 0.26.0 → 0.28.0

package/dist/core/effectTree.d.ts

@@ -1,12 +1,17 @@
-import { TransformNode } from '@babylonjs/core/Meshes/transformNode';
+import { TransformNode } from '@babylonjs/core/Meshes/transformNode.js';
 import type { ParticleSystem } from 'babylon.quarks';
 /** A node in the editor's effect hierarchy: a Group (organizational) or a ParticleEmitter. */
+/** One node of an effect's tree: a group, or an emitter with its system. */
 export interface EffectTreeNode {
+    /** The node. */
     node: TransformNode;
+    /** The node's name, or a readable stand-in when it has none. */
     name: string;
     /** Present when the node is a ParticleEmitter. */
     system?: ParticleSystem;
+    /** How deep the node sits; the root is 0. */
     depth: number;
+    /** The node's child groups and emitters. */
     children: EffectTreeNode[];
 }
 /** Walks a loaded root TransformNode into the editor tree (groups + emitters). */

package/dist/core/effectTree.js

@@ -1,7 +1,6 @@
-import { Matrix, Quaternion } from '@babylonjs/core/Maths/math.vector';
-import { TransformNode } from '@babylonjs/core/Meshes/transformNode';
-import { ParticleEmitter } from 'babylon.quarks';
-import { isEditorSceneNode } from './editorScene';
+import { TransformNode } from '@babylonjs/core/Meshes/transformNode.js';
+import { ParticleEmitter, serializeEffect } from 'babylon.quarks';
+import { isEditorSceneNode } from './editorScene.js';
 /** Walks a loaded root TransformNode into the editor tree (groups + emitters). */
 export function buildEffectTree(root, depth = 0) {
     const system = root instanceof ParticleEmitter ? root.system : undefined;
@@ -31,100 +30,26 @@ export function collectSystems(tree) {
     walk(tree);
     return out;
 }
-function localMatrix(node) {
-    const rotation = node.rotationQuaternion ?? Quaternion.FromEulerVector(node.rotation);
-    return Matrix.Compose(node.scaling, rotation, node.position).asArray().slice();
-}
-function serializeNode(tree, meta, fallbackUuid) {
-    // Emitter nodes must serialize with the ParticleEmitter's own `.uuid` — that is exactly
-    // what EmitSubParticleSystem.toJSON writes as its target reference, so the two match and
-    // QuarksLoader.linkReferences can re-resolve sub-emitters on reimport.
-    const uuid = tree.system
-        ? tree.node.uuid
-        : (tree.node._quarksUUID ?? fallbackUuid);
-    const children = tree.children.map((child, i) => serializeNode(child, meta, `${fallbackUuid}-${i}`));
-    const base = {
-        uuid,
-        name: tree.name,
-        layers: 1,
-        matrix: localMatrix(tree.node),
-        children: children.length > 0 ? children : undefined,
-    };
-    if (tree.system) {
-        return {
-            ...base,
-            type: 'ParticleEmitter',
-            ps: tree.system.toJSON(meta, { useUrlForImage: true }),
-        };
-    }
-    return { ...base, type: 'Group' };
+/** Writes the effect under `roots`, leaving out the editor's own helper nodes. */
+function serialize(roots, name) {
+    const json = serializeEffect(roots, {
+        name,
+        generator: 'babylon.quarks-editor',
+        filter: (node) => !isEditorSceneNode(node),
+    });
+    return JSON.stringify(json, null, 2);
 }
 /**
  * Serializes an effect tree into the Quarks JSON envelope understood by QuarksLoader,
  * preserving the group/emitter hierarchy (not flattened).
  */
 export function serializeEffectTree(root, name = 'effect') {
-    const meta = { textures: {}, materials: {}, geometries: {} };
-    const object = serializeNode(buildEffectTree(root), meta, `${name}-node`);
-    return finishEnvelope(object, meta);
+    return serialize(root, name);
 }
 /**
  * Serializes several effect roots as children of a synthetic group — used when an effect
  * spans multiple top-level trees (e.g. a demo running several loaded effects at once).
  */
 export function serializeEffectForest(roots, name = 'effect') {
-    if (roots.length === 1) {
-        return serializeEffectTree(roots[0], name);
-    }
-    const meta = { textures: {}, materials: {}, geometries: {} };
-    const children = roots.map((root, i) => serializeNode(buildEffectTree(root), meta, `${name}-node-${i}`));
-    const object = {
-        uuid: `${name}-root`,
-        name,
-        type: 'Group',
-        layers: 1,
-        matrix: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1],
-        children,
-    };
-    return finishEnvelope(object, meta);
-}
-/** Flattens accumulated meta and wraps the serialized object into the Quarks envelope. */
-function finishEnvelope(object, meta) {
-    // toJSON stashes live Texture instances and material records in meta; flatten them into
-    // the serializable images/textures/materials arrays QuarksLoader expects.
-    const images = [];
-    const textures = [];
-    for (const [uuid, tex] of Object.entries(meta.textures)) {
-        const url = tex?.url ?? tex?.name;
-        const invertY = typeof tex?.invertY === 'boolean' ? tex.invertY : undefined;
-        const isEnvAtlas = tex?.name === 'quarksEnvAtlas' || (typeof tex?.name === 'string' && tex.name.endsWith('_envAtlas'));
-        if (url) {
-            const imageUuid = `${uuid}-image`;
-            images.push({ uuid: imageUuid, url });
-            const entry = {
-                uuid,
-                image: imageUuid,
-            };
-            if (invertY === false || isEnvAtlas) {
-                entry.invertY = false;
-                entry.noMipmap = true;
-            }
-            textures.push(entry);
-        }
-        else {
-            textures.push({ uuid });
-        }
-    }
-    const materials = Object.values(meta.materials).map((material) => {
-        const { sourceMaterial: _sourceMaterial, ...serializable } = material;
-        return serializable;
-    });
-    return JSON.stringify({
-        metadata: { version: 4.5, type: 'Object3D', generator: 'babylon.quarks-editor' },
-        geometries: Object.values(meta.geometries),
-        materials,
-        textures,
-        images,
-        object,
-    }, null, 2);
+    return serialize(roots.length === 1 ? roots[0] : roots, name);
 }

package/dist/core/emitterShapeWireframe.d.ts

@@ -1,6 +1,6 @@
-import type { Scene } from '@babylonjs/core/scene';
+import type { Scene } from '@babylonjs/core/scene.js';
 import type { ParticleSystem } from 'babylon.quarks';
-import './lineShaders';
+import './lineShaders.js';
 /**
  * Optional wireframe overlays for every emitter shape in the current effect.
  * Geometry follows quarks.core spawn math (local XY spawn plane, +Z emit axis).

package/dist/core/emitterShapeWireframe.js

@@ -1,10 +1,10 @@
-import { Color3 } from '@babylonjs/core/Maths/math.color';
-import { Vector3 } from '@babylonjs/core/Maths/math.vector';
-import { MeshBuilder } from '@babylonjs/core/Meshes/meshBuilder';
-import { TransformNode } from '@babylonjs/core/Meshes/transformNode';
-import { EDITOR_SCENE_NODE_METADATA } from './editorScene';
-import './lineShaders';
-import { getShapeType, readShapeParams } from './shapes';
+import { Color3 } from '@babylonjs/core/Maths/math.color.js';
+import { Vector3 } from '@babylonjs/core/Maths/math.vector.js';
+import { MeshBuilder } from '@babylonjs/core/Meshes/meshBuilder.js';
+import { TransformNode } from '@babylonjs/core/Meshes/transformNode.js';
+import { EDITOR_SCENE_NODE_METADATA } from './editorScene.js';
+import './lineShaders.js';
+import { getShapeType, readShapeParams } from './shapes.js';
 const LINE_COLOR = new Color3(0.45, 0.82, 1);
 const DIRECTION_COLOR = new Color3(0.75, 0.92, 1);
 /**
@@ -204,6 +204,38 @@ function buildEmitterWireframe(system, scene) {
             }
             break;
         }
+        case 'box': {
+            // Spawn anywhere in the box (volume), on its faces (shell) or along its edges;
+            // velocity straight +Z, like Unity's Box shape.
+            const halfW = params.width / 2;
+            const halfH = params.height / 2;
+            const halfD = params.depth / 2;
+            lines('wf-box-front', xyRect(params.width, params.height, halfD));
+            lines('wf-box-back', xyRect(params.width, params.height, -halfD));
+            const corners = [
+                [-halfW, -halfH],
+                [halfW, -halfH],
+                [halfW, halfH],
+                [-halfW, halfH],
+            ];
+            corners.forEach(([x, y], i) => {
+                lines(`wf-box-side-${i}`, [new Vector3(x, y, -halfD), new Vector3(x, y, halfD)]);
+            });
+            const ray = Math.max(halfD * 2, 0.25);
+            lines('wf-box-dir', [new Vector3(0, 0, halfD), new Vector3(0, 0, halfD + ray)], DIRECTION_COLOR);
+            break;
+        }
+        case 'edge': {
+            // Spawn on a line along X of half-length `radius`; velocity straight +Y.
+            const radius = Math.max(params.radius, 0.001);
+            lines('wf-edge', [new Vector3(-radius, 0, 0), new Vector3(radius, 0, 0)]);
+            const ray = Math.max(radius * 0.5, 0.25);
+            for (let i = 0; i <= 4; i++) {
+                const x = -radius + (i / 4) * radius * 2;
+                lines(`wf-edge-ray-${i}`, [new Vector3(x, 0, 0), new Vector3(x, ray, 0)], DIRECTION_COLOR);
+            }
+            break;
+        }
         case 'mesh_surface': {
             const source = params.mesh;
             if (source && !source.isDisposed()) {
@@ -305,15 +337,15 @@ function xyArc(radius, arc, segments = 48, z = 0) {
 function arcPoint(radius, theta, z = 0) {
     return new Vector3(Math.cos(theta) * radius, Math.sin(theta) * radius, z);
 }
-function xyRect(width, height) {
+function xyRect(width, height, z = 0) {
     const halfW = width / 2;
     const halfH = height / 2;
     return [
-        new Vector3(-halfW, -halfH, 0),
-        new Vector3(halfW, -halfH, 0),
-        new Vector3(halfW, halfH, 0),
-        new Vector3(-halfW, halfH, 0),
-        new Vector3(-halfW, -halfH, 0),
+        new Vector3(-halfW, -halfH, z),
+        new Vector3(halfW, -halfH, z),
+        new Vector3(halfW, halfH, z),
+        new Vector3(-halfW, halfH, z),
+        new Vector3(-halfW, -halfH, z),
     ];
 }
 function clampArc(arc) {

package/dist/core/galleryDropMarker.d.ts

@@ -1,5 +1,5 @@
-import { Vector3 } from '@babylonjs/core/Maths/math.vector';
-import type { Scene } from '@babylonjs/core/scene';
+import { Vector3 } from '@babylonjs/core/Maths/math.vector.js';
+import type { Scene } from '@babylonjs/core/scene.js';
 /** Ground decal shown while dragging gallery items over the viewport. */
 export declare class GalleryDropMarker {
     private readonly root;

package/dist/core/galleryDropMarker.js

@@ -1,9 +1,9 @@
-import { StandardMaterial } from '@babylonjs/core/Materials/standardMaterial';
-import { Color3 } from '@babylonjs/core/Maths/math.color';
-import { Mesh } from '@babylonjs/core/Meshes/mesh';
-import { MeshBuilder } from '@babylonjs/core/Meshes/meshBuilder';
-import { TransformNode } from '@babylonjs/core/Meshes/transformNode';
-import { DEFAULT_GALLERY_SPACING, gallerySpan } from './galleryLayout';
+import { StandardMaterial } from '@babylonjs/core/Materials/standardMaterial.js';
+import { Color3 } from '@babylonjs/core/Maths/math.color.js';
+import { Mesh } from '@babylonjs/core/Meshes/mesh.js';
+import { MeshBuilder } from '@babylonjs/core/Meshes/meshBuilder.js';
+import { TransformNode } from '@babylonjs/core/Meshes/transformNode.js';
+import { DEFAULT_GALLERY_SPACING, gallerySpan } from './galleryLayout.js';
 /** Ground decal shown while dragging gallery items over the viewport. */
 export class GalleryDropMarker {
     constructor(scene) {

package/dist/core/galleryLayout.d.ts

@@ -1,6 +1,6 @@
-import type { ArcRotateCamera } from '@babylonjs/core/Cameras/arcRotateCamera';
-import type { Mesh } from '@babylonjs/core/Meshes/mesh';
-import type { TransformNode } from '@babylonjs/core/Meshes/transformNode';
+import type { ArcRotateCamera } from '@babylonjs/core/Cameras/arcRotateCamera.js';
+import type { Mesh } from '@babylonjs/core/Meshes/mesh.js';
+import type { TransformNode } from '@babylonjs/core/Meshes/transformNode.js';
 /** Default gap between neighbouring effects in a folder gallery import. */
 export declare const DEFAULT_GALLERY_SPACING = 4;
 /** Square-grid column count for `count` items. */

package/dist/core/galleryLayout.js

@@ -1,4 +1,4 @@
-import { Vector3 } from '@babylonjs/core/Maths/math.vector';
+import { Vector3 } from '@babylonjs/core/Maths/math.vector.js';
 /** Default gap between neighbouring effects in a folder gallery import. */
 export const DEFAULT_GALLERY_SPACING = 4;
 /** Square-grid column count for `count` items. */

package/dist/core/galleryPlayback.d.ts

@@ -1,4 +1,4 @@
-import type { SceneEntry } from './sceneEntries';
+import type { SceneEntry } from './sceneEntries.js';
 /** Freezes every scene entry; unpauses the visible ones (the preview set) when transport is playing. */
 export declare function applyGalleryPlayback(entries: SceneEntry[], previewRootIds: ReadonlySet<number>, transportPlaying: boolean, focusFinishedRootIds?: ReadonlySet<number>): void;
 /** Whether any preview effect on stage should keep simulating. */

package/dist/core/galleryPlayback.js

@@ -20,7 +20,8 @@ export function applyGalleryPlayback(entries, previewRootIds, transportPlaying,
             continue;
         }
         for (const system of entry.systems) {
-            system.play();
+            // Undoes the pause above; a finished effect stays finished.
+            system.resume();
         }
     }
 }

package/dist/core/galleryScene.d.ts

@@ -1,8 +1,8 @@
-import '@babylonjs/core/Culling/ray';
-import { Vector3 } from '@babylonjs/core/Maths/math.vector';
-import type { Scene } from '@babylonjs/core/scene';
+import '@babylonjs/core/Culling/ray.js';
+import { Vector3 } from '@babylonjs/core/Maths/math.vector.js';
+import type { Scene } from '@babylonjs/core/scene.js';
 import type { BatchedRenderer } from 'babylon.quarks';
-import type { SceneEntry } from './sceneEntries';
+import type { SceneEntry } from './sceneEntries.js';
 /** Clears live particles and freezes simulation for one scene entry. */
 export declare function clearSceneEntrySimulation(entry: SceneEntry, renderer: BatchedRenderer): void;
 /**

package/dist/core/galleryScene.js

@@ -1,6 +1,6 @@
-import '@babylonjs/core/Culling/ray';
-import { Vector3 } from '@babylonjs/core/Maths/math.vector';
-import { DEFAULT_GALLERY_SPACING, galleryGridPosition } from './galleryLayout';
+import '@babylonjs/core/Culling/ray.js';
+import { Vector3 } from '@babylonjs/core/Maths/math.vector.js';
+import { DEFAULT_GALLERY_SPACING, galleryGridPosition } from './galleryLayout.js';
 /** Clears live particles and freezes simulation for one scene entry. */
 export function clearSceneEntrySimulation(entry, renderer) {
     for (const system of entry.systems) {

package/dist/core/gallerySelectionMarker.d.ts

@@ -1,7 +1,7 @@
-import { Color3 } from '@babylonjs/core/Maths/math.color';
-import { TransformNode } from '@babylonjs/core/Meshes/transformNode';
-import type { Scene } from '@babylonjs/core/scene';
-import './lineShaders';
+import { Color3 } from '@babylonjs/core/Maths/math.color.js';
+import { TransformNode } from '@babylonjs/core/Meshes/transformNode.js';
+import type { Scene } from '@babylonjs/core/scene.js';
+import './lineShaders.js';
 export declare const GROUND_RING_RADIUS = 1.2;
 /** Flat ground ring that tracks a transform on the XZ plane. */
 declare class GroundRingMarker {

package/dist/core/gallerySelectionMarker.js

@@ -1,8 +1,8 @@
-import { Color3 } from '@babylonjs/core/Maths/math.color';
-import { Vector3 } from '@babylonjs/core/Maths/math.vector';
-import { MeshBuilder } from '@babylonjs/core/Meshes/meshBuilder';
-import { TransformNode } from '@babylonjs/core/Meshes/transformNode';
-import './lineShaders';
+import { Color3 } from '@babylonjs/core/Maths/math.color.js';
+import { Vector3 } from '@babylonjs/core/Maths/math.vector.js';
+import { MeshBuilder } from '@babylonjs/core/Meshes/meshBuilder.js';
+import { TransformNode } from '@babylonjs/core/Meshes/transformNode.js';
+import './lineShaders.js';
 export const GROUND_RING_RADIUS = 1.2;
 const RING_SEGMENTS = 64;
 const RING_Y = 0.03;

package/dist/core/groups.d.ts

@@ -1,4 +1,4 @@
-import { TransformNode } from '@babylonjs/core/Meshes/transformNode';
+import { TransformNode } from '@babylonjs/core/Meshes/transformNode.js';
 /**
  * Groups the given nodes under a new organizational TransformNode. Each node's world
  * transform is preserved via `setParent` — grouping never moves anything visually, it only

package/dist/core/groups.js

@@ -1,4 +1,4 @@
-import { TransformNode } from '@babylonjs/core/Meshes/transformNode';
+import { TransformNode } from '@babylonjs/core/Meshes/transformNode.js';
 /**
  * Groups the given nodes under a new organizational TransformNode. Each node's world
  * transform is preserved via `setParent` — grouping never moves anything visually, it only

package/dist/core/history.d.ts

@@ -1,7 +1,9 @@
-import type { EffectBinding } from './binding';
+import type { EffectBinding } from './binding.js';
 /** Undo/redo stacks of one effect, kept by the host while another effect is focused. */
 export interface HistoryStacks {
+    /** Snapshots to undo to, oldest first. */
     undo: string[];
+    /** Snapshots to redo to, most recent undo last. */
     redo: string[];
 }
 /**
@@ -18,11 +20,15 @@ export declare class EffectHistory {
     private binding;
     /** Points the history at the active binding and hooks snapshot capture. */
     attach(binding: EffectBinding): void;
+    /** There is a change to undo. */
     get canUndo(): boolean;
+    /** There is an undone change to redo. */
     get canRedo(): boolean;
+    /** Forgets every snapshot. */
     clear(): void;
     /** The current stacks, to hand back to `restoreStacks` when this effect is focused again. */
     saveStacks(): HistoryStacks;
+    /** Puts back stacks from `saveStacks`; undefined starts empty. */
     restoreStacks(stacks: HistoryStacks | undefined): void;
     /**
      * Pushes an undo snapshot. A burst of edits — typing a number, dragging a curve handle or a

package/dist/core/history.js

@@ -19,12 +19,15 @@ export class EffectHistory {
         this.binding = binding;
         binding.onBeforeChange = () => this.capture();
     }
+    /** There is a change to undo. */
     get canUndo() {
         return this.undoStack.length > 0;
     }
+    /** There is an undone change to redo. */
     get canRedo() {
         return this.redoStack.length > 0;
     }
+    /** Forgets every snapshot. */
     clear() {
         this.undoStack = [];
         this.redoStack = [];
@@ -34,6 +37,7 @@ export class EffectHistory {
     saveStacks() {
         return { undo: this.undoStack, redo: this.redoStack };
     }
+    /** Puts back stacks from `saveStacks`; undefined starts empty. */
     restoreStacks(stacks) {
         this.undoStack = stacks?.undo ?? [];
         this.redoStack = stacks?.redo ?? [];

package/dist/core/indexedDbProjectStore.d.ts

@@ -1,4 +1,4 @@
-import type { ProjectMeta, ProjectStore, StorageEstimate, StoredAsset, StoredScene } from './projectStore';
+import type { ProjectMeta, ProjectStore, StorageEstimate, StoredAsset, StoredScene } from './projectStore.js';
 /**
  * Projects in the browser's IndexedDB. Texture data URIs are pulled out of the effect JSON into
  * a per-project file store keyed by content hash — 50 effects sharing a texture store it once —
@@ -11,18 +11,31 @@ export declare class IndexedDbProjectStore implements ProjectStore {
     /** `${projectId}/${hash}` → data URI, so every effect sharing a file gets the same string. */
     private readonly dataUrlByFile;
     private db;
+    /** {@inheritDoc ProjectStore.listProjects} */
     listProjects(): Promise<ProjectMeta[]>;
+    /** {@inheritDoc ProjectStore.getProject} */
     getProject(id: string): Promise<ProjectMeta | null>;
+    /** {@inheritDoc ProjectStore.createProject} */
     createProject(name: string): Promise<ProjectMeta>;
+    /** {@inheritDoc ProjectStore.renameProject} */
     renameProject(id: string, name: string): Promise<void>;
+    /** {@inheritDoc ProjectStore.duplicateProject} */
     duplicateProject(id: string, name: string): Promise<ProjectMeta>;
+    /** {@inheritDoc ProjectStore.deleteProject} */
     deleteProject(id: string): Promise<void>;
+    /** {@inheritDoc ProjectStore.loadAssets} */
     loadAssets(projectId: string): Promise<StoredAsset[]>;
+    /** {@inheritDoc ProjectStore.putAssets} */
     putAssets(projectId: string, assets: StoredAsset[]): Promise<void>;
+    /** {@inheritDoc ProjectStore.deleteAssets} */
     deleteAssets(projectId: string, paths: string[]): Promise<void>;
+    /** {@inheritDoc ProjectStore.loadScene} */
     loadScene(projectId: string): Promise<StoredScene | null>;
+    /** {@inheritDoc ProjectStore.saveScene} */
     saveScene(projectId: string, scene: StoredScene): Promise<void>;
+    /** {@inheritDoc ProjectStore.estimate} */
     estimate(): Promise<StorageEstimate>;
+    /** {@inheritDoc ProjectStore.requestPersistence} */
     requestPersistence(): Promise<boolean>;
     /** Clones `json` with each texture data URI replaced by a `quarks-file:<hash>` reference. */
     private pack;

package/dist/core/indexedDbProjectStore.js

@@ -84,15 +84,18 @@ export class IndexedDbProjectStore {
         return this.dbPromise;
     }
     // ---- projects -------------------------------------------------------------------------
+    /** {@inheritDoc ProjectStore.listProjects} */
     async listProjects() {
         const db = await this.db();
         const all = await request(db.transaction('projects').objectStore('projects').getAll());
         return all.sort((a, b) => b.updatedAt - a.updatedAt);
     }
+    /** {@inheritDoc ProjectStore.getProject} */
     async getProject(id) {
         const db = await this.db();
         return ((await request(db.transaction('projects').objectStore('projects').get(id))) ?? null);
     }
+    /** {@inheritDoc ProjectStore.createProject} */
     async createProject(name) {
         const now = Date.now();
         const meta = { id: newId(), name, createdAt: now, updatedAt: now, assetCount: 0, sizeBytes: 0 };
@@ -102,6 +105,7 @@ export class IndexedDbProjectStore {
         await done(tx);
         return meta;
     }
+    /** {@inheritDoc ProjectStore.renameProject} */
     async renameProject(id, name) {
         const meta = await this.getProject(id);
         if (!meta)
@@ -111,6 +115,7 @@ export class IndexedDbProjectStore {
         tx.objectStore('projects').put({ ...meta, name, updatedAt: Date.now() });
         await done(tx);
     }
+    /** {@inheritDoc ProjectStore.duplicateProject} */
     async duplicateProject(id, name) {
         const source = await this.getProject(id);
         if (!source)
@@ -135,6 +140,7 @@ export class IndexedDbProjectStore {
         await done(tx);
         return meta;
     }
+    /** {@inheritDoc ProjectStore.deleteProject} */
     async deleteProject(id) {
         const db = await this.db();
         const tx = db.transaction(['projects', 'assets', 'files', 'scenes'], 'readwrite');
@@ -152,6 +158,7 @@ export class IndexedDbProjectStore {
         }
     }
     // ---- assets ---------------------------------------------------------------------------
+    /** {@inheritDoc ProjectStore.loadAssets} */
     async loadAssets(projectId) {
         const db = await this.db();
         const records = await request(db.transaction('assets').objectStore('assets').index('projectId').getAll(projectId));
@@ -162,6 +169,7 @@ export class IndexedDbProjectStore {
             missingFiles,
         })));
     }
+    /** {@inheritDoc ProjectStore.putAssets} */
     async putAssets(projectId, assets) {
         const files = new Map();
         const packed = await Promise.all(assets.map(async (asset) => ({ ...asset, projectId, json: await this.pack(asset.json, files) })));
@@ -173,6 +181,7 @@ export class IndexedDbProjectStore {
         await done(tx);
         await this.refresh(projectId);
     }
+    /** {@inheritDoc ProjectStore.deleteAssets} */
     async deleteAssets(projectId, paths) {
         const db = await this.db();
         const tx = db.transaction('assets', 'readwrite');
@@ -182,6 +191,7 @@ export class IndexedDbProjectStore {
         await this.refresh(projectId);
     }
     // ---- scene ----------------------------------------------------------------------------
+    /** {@inheritDoc ProjectStore.loadScene} */
     async loadScene(projectId) {
         const db = await this.db();
         const record = await request(db.transaction('scenes').objectStore('scenes').get(projectId));
@@ -190,6 +200,7 @@ export class IndexedDbProjectStore {
         const entries = await Promise.all(record.entries.map(async (entry) => ({ ...entry, json: await this.unpack(projectId, entry.json) })));
         return { entries, savedAt: record.savedAt };
     }
+    /** {@inheritDoc ProjectStore.saveScene} */
     async saveScene(projectId, scene) {
         const files = new Map();
         const entries = await Promise.all(scene.entries.map(async (entry) => ({ ...entry, json: await this.pack(entry.json, files) })));
@@ -201,12 +212,14 @@ export class IndexedDbProjectStore {
         await this.refresh(projectId);
     }
     // ---- storage ----------------------------------------------------------------------------
+    /** {@inheritDoc ProjectStore.estimate} */
     async estimate() {
         const storage = typeof navigator !== 'undefined' ? navigator.storage : undefined;
         const estimate = storage?.estimate ? await storage.estimate() : undefined;
         const persisted = storage?.persisted ? await storage.persisted() : false;
         return { usage: estimate?.usage ?? null, quota: estimate?.quota ?? null, persisted };
     }
+    /** {@inheritDoc ProjectStore.requestPersistence} */
     async requestPersistence() {
         const storage = typeof navigator !== 'undefined' ? navigator.storage : undefined;
         return storage?.persist ? storage.persist() : false;

package/dist/core/lineShaders.d.ts

@@ -1,2 +1,2 @@
-import '@babylonjs/core/Shaders/color.fragment';
-import '@babylonjs/core/Shaders/color.vertex';
+import '@babylonjs/core/Shaders/color.fragment.js';
+import '@babylonjs/core/Shaders/color.vertex.js';

package/dist/core/lineShaders.js

@@ -3,5 +3,5 @@
 // Babylon never looks, it falls back to fetching `src/Shaders/color.fragment.fx`, gets the
 // page's HTML back and the selection rings never render. Registering the shader up front, from
 // the same module graph as the rest of the editor, makes the lookup succeed either way.
-import '@babylonjs/core/Shaders/color.fragment';
-import '@babylonjs/core/Shaders/color.vertex';
+import '@babylonjs/core/Shaders/color.fragment.js';
+import '@babylonjs/core/Shaders/color.vertex.js';

package/dist/core/loadEffect.d.ts

@@ -1,5 +1,5 @@
-import { TransformNode } from '@babylonjs/core/Meshes/transformNode';
-import type { Scene } from '@babylonjs/core/scene';
+import { TransformNode } from '@babylonjs/core/Meshes/transformNode.js';
+import type { Scene } from '@babylonjs/core/scene.js';
 import type { BatchedRenderer, ParticleSystem } from 'babylon.quarks';
 export interface LoadEffectOptions {
     /** Registers systems with the batched renderer (default true). */

package/dist/core/loadEffect.js

@@ -1,4 +1,4 @@
-import { TransformNode } from '@babylonjs/core/Meshes/transformNode';
+import { TransformNode } from '@babylonjs/core/Meshes/transformNode.js';
 import { ParticleEmitter, QuarksLoader, QuarksUtil } from 'babylon.quarks';
 /** `ParticleEmitter`'s constructor default (see babylon.quarks/src/ParticleEmitter.ts) — the
  * name every emitter gets when the source JSON didn't give it one of its own. */

package/dist/core/material.d.ts

@@ -1,13 +1,23 @@
+import type { BaseTexture } from '@babylonjs/core/Materials/Textures/baseTexture.js';
+import type { Texture } from '@babylonjs/core/Materials/Textures/texture.js';
 import type { ParticleSystem } from 'babylon.quarks';
+/** Material settings the Renderer module changes; fields left out keep their value. */
 export interface RendererMaterialPatch {
+    /** The blend mode, see `ParticleSystem.blending`. */
     blendMode?: number;
+    /** Draws with alpha blending. */
     transparent?: boolean;
+    /** Tests against the depth buffer. */
     depthTest?: boolean;
+    /** Writes to the depth buffer. */
     depthWrite?: boolean;
+    /** Discards pixels whose alpha is below this. */
     alphaTest?: number;
-    texture?: unknown;
+    /** The main texture, or null for none. */
+    texture?: Texture | null;
     /** A 3×2 cube-face atlas mesh particles reflect, or null for none. */
-    reflectionAtlas?: unknown;
+    reflectionAtlas?: BaseTexture | null;
+    /** How strongly mesh particles reflect the atlas, 0..1. */
     reflectionLevel?: number;
 }
 /** Applies renderer material settings and keeps imported QuarksMaterial JSON in sync for export. */

package/dist/core/pickAssetFiles.js

@@ -1,4 +1,4 @@
-import { isAssetImportFile, relativePathOf } from './assets';
+import { isAssetImportFile, relativePathOf } from './assets.js';
 /**
  * Recursively collects effect `.json` files and the image files they may reference from a
  * directory handle (File System Access API).

package/dist/core/playback.d.ts

@@ -2,11 +2,17 @@
 export interface PlaybackState {
     /** When true, all in-scene preview effects simulate. */
     stagePlaying: boolean;
+    /** Root `uniqueId` of the focused effect, whose time the timeline shows. */
     focusRootId: number | null;
+    /** Each effect's timeline time, in seconds, by root `uniqueId`. */
     focusElapsedByRoot: Map<number, number>;
+    /** Effects parked at their end, by root `uniqueId`; Play restarts them. */
     focusFinishedByRoot: Set<number>;
+    /** Playback speed, 1 for real time. */
     speed: number;
+    /** While paused: advance one frame on the next render. */
     stepQueued: boolean;
+    /** The timeline is being scrubbed; the render loop does not simulate. */
     scrubbing: boolean;
 }
 /** Default playback state for a new editor session. */