babylon.quarks-editor 0.18.1 → 0.20.0

package/dist/core/loadEffect.js

@@ -1,5 +1,5 @@
-import { ParticleEmitter, QuarksLoader, QuarksUtil } from 'babylon.quarks';
 import { TransformNode } from '@babylonjs/core/Meshes/transformNode';
+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. */
 const DEFAULT_EMITTER_NAME = 'particleEmitter';

package/dist/core/pickAssetFiles.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Opens a native folder picker when the host supports it. Returns `null` when the user
+ * cancels, or `undefined` when the API is unavailable (caller should fall back to
+ * `<input webkitdirectory>`).
+ */
+export declare function pickAssetFolderFiles(): Promise<File[] | null | undefined>;

package/dist/core/{pickGalleryFiles.js → pickAssetFiles.js}

@@ -1,10 +1,13 @@
-import { collectJsonFiles } from './loadEffectGallery';
-/** Recursively collects `.json` files from a directory handle (File System Access API). */
-async function readJsonFilesFromDirectory(dir, prefix = '') {
+import { isAssetImportFile, relativePathOf } from './assets';
+/**
+ * Recursively collects effect `.json` files and the image files they may reference from a
+ * directory handle (File System Access API).
+ */
+async function readAssetFilesFromDirectory(dir, prefix = '') {
     const files = [];
     for await (const [name, entry] of dir.entries()) {
         if (entry.kind === 'file') {
-            if (!name.toLowerCase().endsWith('.json'))
+            if (!isAssetImportFile(name))
                 continue;
             const file = await entry.getFile();
             Object.defineProperty(file, 'webkitRelativePath', {
@@ -15,23 +18,25 @@ async function readJsonFilesFromDirectory(dir, prefix = '') {
             continue;
         }
         if (entry.kind === 'directory') {
-            files.push(...(await readJsonFilesFromDirectory(entry, `${prefix}${name}/`)));
+            files.push(...(await readAssetFilesFromDirectory(entry, `${prefix}${name}/`)));
         }
     }
     return files;
 }
 /**
  * Opens a native folder picker when the host supports it. Returns `null` when the user
- * cancels, or when the API is unavailable (caller should fall back to `<input webkitdirectory>`).
+ * cancels, or `undefined` when the API is unavailable (caller should fall back to
+ * `<input webkitdirectory>`).
  */
-export async function pickGalleryJsonFiles() {
+export async function pickAssetFolderFiles() {
     const picker = window.showDirectoryPicker;
     if (typeof picker !== 'function') {
         return undefined;
     }
     try {
         const dir = (await picker.call(window, { mode: 'read' }));
-        return collectJsonFiles(await readJsonFilesFromDirectory(dir));
+        const files = await readAssetFilesFromDirectory(dir);
+        return files.sort((a, b) => relativePathOf(a).localeCompare(relativePathOf(b)));
     }
     catch (err) {
         if (err instanceof DOMException && err.name === 'AbortError') {

package/dist/core/projectStore.d.ts

@@ -0,0 +1,61 @@
+/** One editor project: a library of effect assets plus the scene built from them. */
+export interface ProjectMeta {
+    id: string;
+    name: string;
+    createdAt: number;
+    updatedAt: number;
+    assetCount: number;
+    /** Approximate bytes the project takes in storage (JSON + texture files). */
+    sizeBytes: number;
+}
+/** An effect asset as the store keeps it. `json` is a self-contained Quarks effect. */
+export interface StoredAsset {
+    /** Relative path inside the project (`Fire/Explosion.json`) — the asset's key. */
+    path: string;
+    name: string;
+    json: unknown;
+    missingFiles: string[];
+}
+/** One effect instance in a saved scene. */
+export interface StoredSceneEntry {
+    name: string;
+    /** Path of the asset it was made from, if any. */
+    assetPath: string | null;
+    /** The instance's own (possibly edited) effect, root transform included. */
+    json: unknown;
+    visible: boolean;
+}
+export interface StoredScene {
+    entries: StoredSceneEntry[];
+    savedAt: number;
+}
+export interface StorageEstimate {
+    /** Bytes the whole site uses (all projects), when the browser reports it. */
+    usage: number | null;
+    /** Bytes the browser lets the site use, when it reports it. */
+    quota: number | null;
+    /** True when the browser promised not to evict the data under storage pressure. */
+    persisted: boolean;
+}
+/**
+ * Where projects live. The editor only talks to this interface; `IndexedDbProjectStore` keeps
+ * everything in the browser, and an embedding host can supply its own (e.g. on disk).
+ */
+export interface ProjectStore {
+    listProjects(): Promise<ProjectMeta[]>;
+    getProject(id: string): Promise<ProjectMeta | null>;
+    createProject(name: string): Promise<ProjectMeta>;
+    renameProject(id: string, name: string): Promise<void>;
+    duplicateProject(id: string, name: string): Promise<ProjectMeta>;
+    deleteProject(id: string): Promise<void>;
+    loadAssets(projectId: string): Promise<StoredAsset[]>;
+    /** Adds or replaces assets by path. */
+    putAssets(projectId: string, assets: StoredAsset[]): Promise<void>;
+    deleteAssets(projectId: string, paths: string[]): Promise<void>;
+    loadScene(projectId: string): Promise<StoredScene | null>;
+    saveScene(projectId: string, scene: StoredScene): Promise<void>;
+    estimate(): Promise<StorageEstimate>;
+    /** Asks the browser to keep the data even under storage pressure; resolves to the result. */
+    requestPersistence(): Promise<boolean>;
+}
+export declare function formatBytes(bytes: number | null | undefined): string;

package/dist/core/projectStore.js

@@ -0,0 +1,14 @@
+export function formatBytes(bytes) {
+    if (bytes == null)
+        return '—';
+    if (bytes < 1024)
+        return `${bytes} B`;
+    const units = ['KB', 'MB', 'GB', 'TB'];
+    let value = bytes / 1024;
+    let unit = 0;
+    while (value >= 1024 && unit < units.length - 1) {
+        value /= 1024;
+        unit++;
+    }
+    return `${value < 10 ? value.toFixed(1) : Math.round(value)} ${units[unit]}`;
+}

package/dist/core/sceneEntries.d.ts

@@ -0,0 +1,35 @@
+import type { TransformNode } from '@babylonjs/core/Meshes/transformNode';
+import type { Scene } from '@babylonjs/core/scene';
+import type { BatchedRenderer, ParticleSystem } from 'babylon.quarks';
+import type { EffectAsset } from './assets';
+import { EffectBinding } from './binding';
+/**
+ * One effect instance placed in the scene. Every instance is live (its systems are registered
+ * with the renderer) and independent: dropping the same asset three times gives three entries
+ * that are edited separately.
+ */
+export interface SceneEntry {
+    name: string;
+    /** Path of the asset it came from, or a synthetic `_created/…` path for new effects. */
+    path: string;
+    /** Asset this instance was made from, if any. */
+    assetId: number | null;
+    root: TransformNode;
+    systems: ParticleSystem[];
+}
+/** `name`, or `name (2)`, `name (3)`… when an entry already uses it. */
+export declare function uniqueEntryName(name: string, existing: SceneEntry[]): string;
+/**
+ * Parses an asset into a new scene instance with its systems registered (paused). Returns null
+ * when the JSON holds no particle systems.
+ */
+export declare function instantiateSceneEntry(scene: Scene, renderer: BatchedRenderer, asset: EffectAsset, existing: SceneEntry[]): SceneEntry | null;
+/** Builds an edit binding for one scene entry. */
+export declare function bindingFromSceneEntry(entry: SceneEntry): EffectBinding;
+/**
+ * Unregisters and disposes one scene entry — including systems the inspector added after the
+ * entry was created, which only the live emitter tree knows about.
+ */
+export declare function disposeSceneEntry(entry: SceneEntry, renderer: BatchedRenderer): void;
+/** Number of scene instances per asset id. */
+export declare function countInstancesByAsset(entries: SceneEntry[]): Map<number, number>;

package/dist/core/sceneEntries.js

@@ -0,0 +1,62 @@
+import { QuarksUtil } from 'babylon.quarks';
+import { EffectBinding } from './binding';
+import { disposeLoadedEffect, parseEffectFromJson } from './loadEffect';
+/** `name`, or `name (2)`, `name (3)`… when an entry already uses it. */
+export function uniqueEntryName(name, existing) {
+    const taken = new Set(existing.map((entry) => entry.name));
+    if (!taken.has(name)) {
+        return name;
+    }
+    let n = 2;
+    while (taken.has(`${name} (${n})`)) {
+        n++;
+    }
+    return `${name} (${n})`;
+}
+function isPlaceholderName(name) {
+    return !name || name === 'Effect' || name === 'Object3D' || name === 'Group';
+}
+/**
+ * Parses an asset into a new scene instance with its systems registered (paused). Returns null
+ * when the JSON holds no particle systems.
+ */
+export function instantiateSceneEntry(scene, renderer, asset, existing) {
+    const { root, systems } = parseEffectFromJson(scene, renderer, asset.json, {
+        registerRenderer: true,
+        autoplay: false,
+    });
+    if (systems.length === 0) {
+        disposeLoadedEffect(root, systems, renderer, true);
+        return null;
+    }
+    const name = uniqueEntryName(isPlaceholderName(root.name) ? asset.name : root.name, existing);
+    root.name = name;
+    root.parent = null;
+    return { name, path: asset.path, assetId: asset.id, root, systems };
+}
+/** Builds an edit binding for one scene entry. */
+export function bindingFromSceneEntry(entry) {
+    const main = entry.systems.find((s) => !s.onlyUsedByOther) ?? entry.systems[0];
+    return new EffectBinding(main, entry.systems.filter((s) => s !== main), entry.root);
+}
+/**
+ * Unregisters and disposes one scene entry — including systems the inspector added after the
+ * entry was created, which only the live emitter tree knows about.
+ */
+export function disposeSceneEntry(entry, renderer) {
+    const systems = new Set(entry.systems);
+    QuarksUtil.runOnAllParticleEmitters(entry.root, (emitter) => {
+        systems.add(emitter.system);
+    });
+    disposeLoadedEffect(entry.root, [...systems], renderer, true);
+}
+/** Number of scene instances per asset id. */
+export function countInstancesByAsset(entries) {
+    const counts = new Map();
+    for (const entry of entries) {
+        if (entry.assetId != null) {
+            counts.set(entry.assetId, (counts.get(entry.assetId) ?? 0) + 1);
+        }
+    }
+    return counts;
+}

package/dist/core/shapes.d.ts

@@ -1,6 +1,6 @@
+import type { Mesh } from '@babylonjs/core/Meshes/mesh';
 import type { EmitterShape } from 'babylon.quarks';
 import { EmitterMode } from 'babylon.quarks';
-import type { Mesh } from '@babylonjs/core/Meshes/mesh';
 export type ShapeType = 'point' | 'sphere' | 'hemisphere' | 'cone' | 'circle' | 'donut' | 'rectangle' | 'grid' | 'mesh_surface';
 export declare const SHAPE_TYPES: Array<{
     value: ShapeType;

package/dist/core/shapes.js

@@ -1,5 +1,4 @@
-import { CircleEmitter, ConeEmitter, DonutEmitter, GridEmitter, HemisphereEmitter, MeshSurfaceEmitter, PointEmitter, RectangleEmitter, SphereEmitter, } from 'babylon.quarks';
-import { EmitterMode } from 'babylon.quarks';
+import { CircleEmitter, ConeEmitter, DonutEmitter, EmitterMode, GridEmitter, HemisphereEmitter, MeshSurfaceEmitter, PointEmitter, RectangleEmitter, SphereEmitter, } from 'babylon.quarks';
 export const SHAPE_TYPES = [
     { value: 'cone', label: 'Cone' },
     { value: 'sphere', label: 'Sphere' },
@@ -31,7 +30,7 @@ export function getShapeType(shape) {
 }
 export function readShapeParams(shape) {
     const anyShape = shape;
-    const num = (key, fallback) => (typeof anyShape[key] === 'number' ? anyShape[key] : fallback);
+    const num = (key, fallback) => typeof anyShape[key] === 'number' ? anyShape[key] : fallback;
     return {
         radius: num('radius', DEFAULT_SHAPE_PARAMS.radius),
         mode: num('mode', DEFAULT_SHAPE_PARAMS.mode),
@@ -65,9 +64,21 @@ export function createShape(type, params) {
         case 'point':
             return new PointEmitter();
         case 'sphere':
-            return new SphereEmitter({ radius: params.radius, arc: params.arc, thickness: params.thickness, mode: params.mode, spread: params.spread });
+            return new SphereEmitter({
+                radius: params.radius,
+                arc: params.arc,
+                thickness: params.thickness,
+                mode: params.mode,
+                spread: params.spread,
+            });
         case 'hemisphere':
-            return new HemisphereEmitter({ radius: params.radius, arc: params.arc, thickness: params.thickness, mode: params.mode, spread: params.spread });
+            return new HemisphereEmitter({
+                radius: params.radius,
+                arc: params.arc,
+                thickness: params.thickness,
+                mode: params.mode,
+                spread: params.spread,
+            });
         case 'cone':
             return new ConeEmitter({
                 radius: params.radius,
@@ -78,7 +89,13 @@ export function createShape(type, params) {
                 spread: params.spread,
             });
         case 'circle':
-            return new CircleEmitter({ radius: params.radius, arc: params.arc, thickness: params.thickness, mode: params.mode, spread: params.spread });
+            return new CircleEmitter({
+                radius: params.radius,
+                arc: params.arc,
+                thickness: params.thickness,
+                mode: params.mode,
+                spread: params.spread,
+            });
         case 'donut':
             return new DonutEmitter({
                 radius: params.radius,
@@ -89,9 +106,19 @@ export function createShape(type, params) {
                 spread: params.spread,
             });
         case 'rectangle':
-            return new RectangleEmitter({ width: params.width, height: params.height, mode: params.mode, spread: params.spread });
+            return new RectangleEmitter({
+                width: params.width,
+                height: params.height,
+                mode: params.mode,
+                spread: params.spread,
+            });
         case 'grid':
-            return new GridEmitter({ width: params.width, height: params.height, column: params.column, row: params.row });
+            return new GridEmitter({
+                width: params.width,
+                height: params.height,
+                column: params.column,
+                row: params.row,
+            });
         case 'mesh_surface':
             return new MeshSurfaceEmitter(params.mesh);
     }

package/dist/core/systems.d.ts

@@ -1,5 +1,5 @@
-import { ParticleSystem } from 'babylon.quarks';
 import type { TransformNode } from '@babylonjs/core/Meshes/transformNode';
+import { ParticleSystem } from 'babylon.quarks';
 import type { EffectBinding } from './binding';
 export interface ChildSystemOptions {
     name?: string;

package/dist/core/systems.js

@@ -15,7 +15,9 @@ export function createChildSystem(parent, options = {}) {
         startSize: new IntervalValue(0.05, 0.2),
         startColor: new ConstantColor(new Vector4(1, 0.9, 0.6, 1)),
         emissionOverTime: new ConstantValue(oneShot ? 0 : 30),
-        emissionBursts: oneShot ? [{ time: 0, count: new ConstantValue(8), cycle: 1, interval: 0.01, probability: 1 }] : [],
+        emissionBursts: oneShot
+            ? [{ time: 0, count: new ConstantValue(8), cycle: 1, interval: 0.01, probability: 1 }]
+            : [],
         shape: new ConeEmitter({ radius: 0.1, angle: Math.PI / 3 }),
         renderMode: RenderMode.BillBoard,
         texture: parent.texture ?? undefined,

package/dist/core/timeline.d.ts

@@ -1,6 +1,5 @@
-import type { ParticleSystem } from 'babylon.quarks';
-import type { FunctionValueGenerator, ValueGenerator } from 'babylon.quarks';
 import type { TransformNode } from '@babylonjs/core/Meshes/transformNode';
+import type { FunctionValueGenerator, ParticleSystem, ValueGenerator } from 'babylon.quarks';
 import type { EffectBinding } from './binding';
 export type TimelineRow = {
     kind: 'group';

package/dist/core/transport.d.ts

@@ -0,0 +1,12 @@
+import type { Scene } from '@babylonjs/core/scene';
+import type { BatchedRenderer } from 'babylon.quarks';
+import type { EffectBinding } from './binding';
+import { type PlaybackState } from './playback';
+/**
+ * Stage Play/Pause shared by the viewport transport bar and the timeline. Pressing Play on a
+ * one-shot focus that already parked at its end replays it from the start.
+ */
+export declare function toggleStagePlayback(binding: EffectBinding | null, scene: Scene, playback: PlaybackState, stagePlaying: boolean, setStagePlaying: (playing: boolean) => void): void;
+/** Restarts the focused effect only; other visible effects keep playing. */
+export declare function restartFocusPlayback(binding: EffectBinding, renderer: BatchedRenderer, scene: Scene, playback: PlaybackState): void;
+export declare const PLAYBACK_SPEEDS: number[];

package/dist/core/transport.js

@@ -0,0 +1,36 @@
+import { clearFocusFinished, isFocusFinished, setFocusElapsed } from './playback';
+import { playFocus, scrubFocusTo } from './scrub';
+/**
+ * Stage Play/Pause shared by the viewport transport bar and the timeline. Pressing Play on a
+ * one-shot focus that already parked at its end replays it from the start.
+ */
+export function toggleStagePlayback(binding, scene, playback, stagePlaying, setStagePlaying) {
+    if (stagePlaying) {
+        playback.stagePlaying = false;
+        setStagePlaying(false);
+        return;
+    }
+    if (binding) {
+        const rootId = binding.root.uniqueId;
+        if (isFocusFinished(playback, rootId)) {
+            binding.restart();
+            clearFocusFinished(playback, rootId);
+            setFocusElapsed(playback, rootId, 0);
+            scene.render();
+        }
+    }
+    playback.stagePlaying = true;
+    setStagePlaying(true);
+}
+/** Restarts the focused effect only; other visible effects keep playing. */
+export function restartFocusPlayback(binding, renderer, scene, playback) {
+    const rootId = binding.root.uniqueId;
+    scrubFocusTo(binding, renderer, 0);
+    setFocusElapsed(playback, rootId, 0);
+    clearFocusFinished(playback, rootId);
+    if (playback.stagePlaying) {
+        playFocus(binding);
+    }
+    scene.render();
+}
+export const PLAYBACK_SPEEDS = [0.1, 0.25, 0.5, 1, 2, 4];

package/dist/core/values.d.ts

@@ -1,5 +1,5 @@
-import { PiecewiseBezier } from 'babylon.quarks';
 import type { FunctionValueGenerator, ValueGenerator } from 'babylon.quarks';
+import { PiecewiseBezier } from 'babylon.quarks';
 export type ScalarGenerator = ValueGenerator | FunctionValueGenerator;
 export type ScalarMode = 'constant' | 'random' | 'curve';
 /** Editable snapshot of a scalar value generator. */

package/dist/core/viewportPicker.d.ts

@@ -1,8 +1,8 @@
 import { TransformNode } from '@babylonjs/core/Meshes/transformNode';
 import type { Scene } from '@babylonjs/core/scene';
-import type { GalleryEntry } from './loadEffectGallery';
+import type { SceneEntry } from './sceneEntries';
 /**
- * Viewport pick/hover for in-scene gallery effect roots only (not child emitters).
+ * Viewport pick/hover for visible scene effect roots only (not child emitters).
  * Hover uses the same ground ring as focus selection, in yellow.
  */
 export declare class GalleryViewportPicker {
@@ -12,8 +12,8 @@ export declare class GalleryViewportPicker {
     private hoveredRoot;
     private syncKey;
     constructor(scene: Scene);
-    /** Rebuilds root pick colliders when the gallery changes. */
-    sync(entries: GalleryEntry[], soloRoot: TransformNode | null, syncKey: string): void;
+    /** Rebuilds root pick colliders when the scene changes. */
+    sync(entries: SceneEntry[], soloRoot: TransformNode | null, syncKey: string): void;
     /** Yellow focus-style ring under the hovered effect root. */
     setHover(effectRoot: TransformNode | null): void;
     follow(): void;

package/dist/core/viewportPicker.js

@@ -4,7 +4,7 @@ import { GROUND_RING_RADIUS, GalleryHoverMarker } from './gallerySelectionMarker
 /** Invisible pick proxy size — matches the ground ring footprint. */
 const PICK_DIAMETER = GROUND_RING_RADIUS * 2;
 /**
- * Viewport pick/hover for in-scene gallery effect roots only (not child emitters).
+ * Viewport pick/hover for visible scene effect roots only (not child emitters).
  * Hover uses the same ground ring as focus selection, in yellow.
  */
 export class GalleryViewportPicker {
@@ -15,7 +15,7 @@ export class GalleryViewportPicker {
         this.scene = scene;
         this.hoverMarker = new GalleryHoverMarker(scene);
     }
-    /** Rebuilds root pick colliders when the gallery changes. */
+    /** Rebuilds root pick colliders when the scene changes. */
     sync(entries, soloRoot, syncKey) {
         if (syncKey === this.syncKey) {
             return;
@@ -24,7 +24,7 @@ export class GalleryViewportPicker {
         this.clearHandles();
         if (entries.length > 0) {
             for (const entry of entries) {
-                if (!entry.inScene || entry.root.isDisposed()) {
+                if (entry.root.isDisposed() || !entry.root.isEnabled(false)) {
                     continue;
                 }
                 this.createHandle(entry.root);

package/dist/index.d.ts

@@ -1,17 +1,21 @@
 export { EffectBinding } from './core/binding';
 export type { EditorListener } from './core/binding';
-export { EffectHistory } from './core/history';
-export { createChildSystem } from './core/systems';
-export { buildEffectTree, collectSystems, serializeEffectTree, serializeEffectForest } from './core/effectTree';
-export type { EffectTreeNode } from './core/effectTree';
-export type { ChildSystemOptions } from './core/systems';
-export { readScalar, buildScalar, sampleCurve, readPieces, buildCurve, splitPieces, mergePieces } from './core/values';
-export type { ScalarGenerator, ScalarMode, ScalarValueState, CurvePiece } from './core/values';
-export { DEFAULT_GRADIENT_STOPS, buildGradient, buildColorOverLife, rgbaToVector4, stopToCss, stopsToCssGradient, hexToRgb, rgbToHex, findBehavior, } from './core/colors';
-export type { GradientStop } from './core/colors';
-export { SHAPE_TYPES, SHAPE_PARAM_KEYS, DEFAULT_SHAPE_PARAMS, getShapeType, readShapeParams, createShape, } from './core/shapes';
-export type { ShapeType, ShapeParams } from './core/shapes';
 export { GroundPlaneResolver, ensureGroundResolver } from './core/collision';
+export { DEFAULT_GRADIENT_STOPS, buildColorOverLife, buildGradient, findBehavior, hexToRgb, rgbToHex, rgbaToVector4, stopToCss, stopsToCssGradient, } from './core/colors';
+export type { GradientStop } from './core/colors';
+export { buildEffectTree, collectSystems, serializeEffectForest, serializeEffectTree } from './core/effectTree';
+export type { EffectTreeNode } from './core/effectTree';
+export { EffectHistory } from './core/history';
+export type { HistoryStacks } from './core/history';
+export { IndexedDbProjectStore } from './core/indexedDbProjectStore';
 export { applyRendererMaterial, getMaterialLabel } from './core/material';
 export type { RendererMaterialPatch } from './core/material';
+export { formatBytes } from './core/projectStore';
+export type { ProjectMeta, ProjectStore, StorageEstimate, StoredAsset, StoredScene, StoredSceneEntry, } from './core/projectStore';
+export { DEFAULT_SHAPE_PARAMS, SHAPE_PARAM_KEYS, SHAPE_TYPES, createShape, getShapeType, readShapeParams, } from './core/shapes';
+export type { ShapeParams, ShapeType } from './core/shapes';
+export { createChildSystem } from './core/systems';
+export type { ChildSystemOptions } from './core/systems';
 export { ensurePortableTextureUrl } from './core/textureExport';
+export { buildCurve, buildScalar, mergePieces, readPieces, readScalar, sampleCurve, splitPieces } from './core/values';
+export type { CurvePiece, ScalarGenerator, ScalarMode, ScalarValueState } from './core/values';

package/dist/index.js

@@ -1,10 +1,12 @@
 export { EffectBinding } from './core/binding';
-export { EffectHistory } from './core/history';
-export { createChildSystem } from './core/systems';
-export { buildEffectTree, collectSystems, serializeEffectTree, serializeEffectForest } from './core/effectTree';
-export { readScalar, buildScalar, sampleCurve, readPieces, buildCurve, splitPieces, mergePieces } from './core/values';
-export { DEFAULT_GRADIENT_STOPS, buildGradient, buildColorOverLife, rgbaToVector4, stopToCss, stopsToCssGradient, hexToRgb, rgbToHex, findBehavior, } from './core/colors';
-export { SHAPE_TYPES, SHAPE_PARAM_KEYS, DEFAULT_SHAPE_PARAMS, getShapeType, readShapeParams, createShape, } from './core/shapes';
 export { GroundPlaneResolver, ensureGroundResolver } from './core/collision';
+export { DEFAULT_GRADIENT_STOPS, buildColorOverLife, buildGradient, findBehavior, hexToRgb, rgbToHex, rgbaToVector4, stopToCss, stopsToCssGradient, } from './core/colors';
+export { buildEffectTree, collectSystems, serializeEffectForest, serializeEffectTree } from './core/effectTree';
+export { EffectHistory } from './core/history';
+export { IndexedDbProjectStore } from './core/indexedDbProjectStore';
 export { applyRendererMaterial, getMaterialLabel } from './core/material';
+export { formatBytes } from './core/projectStore';
+export { DEFAULT_SHAPE_PARAMS, SHAPE_PARAM_KEYS, SHAPE_TYPES, createShape, getShapeType, readShapeParams, } from './core/shapes';
+export { createChildSystem } from './core/systems';
 export { ensurePortableTextureUrl } from './core/textureExport';
+export { buildCurve, buildScalar, mergePieces, readPieces, readScalar, sampleCurve, splitPieces } from './core/values';

package/dist/react/AssetsPanel.d.ts

@@ -0,0 +1,22 @@
+import React from 'react';
+import { type AssetDragPayload } from '../core/assetTree';
+import { type AssetLoadProgress, type EffectAsset } from '../core/assets';
+export interface AssetsPanelProps {
+    assets: EffectAsset[];
+    /** Scene instance count per asset id. */
+    instanceCounts: ReadonlyMap<number, number>;
+    loading: AssetLoadProgress | null;
+    folderInputRef: React.RefObject<HTMLInputElement | null>;
+    onImportFiles: (files: FileList | File[]) => void;
+    onImportFolder: () => void;
+    /** Adds a new instance of each asset in the payload to the scene. */
+    onAddToScene: (payload: AssetDragPayload) => void;
+    onDelete: (payload: AssetDragPayload) => void;
+    /** Opens the asset on its own to edit it (double-click). Without it, double-click adds to the scene. */
+    onOpenPrefab?: (asset: EffectAsset) => void;
+}
+/**
+ * Bottom-dock asset browser: folder tree on the left, the open folder's effects as tiles on the
+ * right. Drag a tile into the viewport (as many times as needed) or right-click it for actions.
+ */
+export declare function AssetsPanel(props: AssetsPanelProps): React.ReactElement;