babylon.quarks-editor 0.27.0 → 0.29.0

package/dist/core/timeline.d.ts

@@ -1,24 +1,44 @@
 import type { TransformNode } from '@babylonjs/core/Meshes/transformNode.js';
 import type { FunctionValueGenerator, ParticleSystem, ValueGenerator } from 'babylon.quarks';
 import type { EffectBinding } from './binding.js';
-export type TimelineRow = {
+/** A timeline row for a group node: a heading over the tracks of the systems under it. */
+export interface TimelineGroupRow {
+    /** Tells group rows from track rows. */
     kind: 'group';
+    /** The group's node. */
     node: TransformNode;
+    /** The group's name. */
     name: string;
+    /** How deep the group sits in the effect tree; the root's children are 0. */
     depth: number;
-} | {
+}
+/** A timeline row for one particle system: a bar from its start delay over its duration. */
+export interface TimelineSystemRow {
+    /** Tells group rows from track rows. */
     kind: 'track';
+    /** The system's emitter node. */
     node: TransformNode;
+    /** The system. */
     system: ParticleSystem;
+    /** The emitter's name. */
     name: string;
+    /** How deep the emitter sits in the effect tree. */
     depth: number;
+    /** True for the effect's main system. */
     isRoot: boolean;
+    /** False for the one system an effect cannot lose. */
     removable: boolean;
+    /** Where the bar starts: the start delay, its lower end when random, in seconds. */
     startOffset: number;
+    /** True when the start delay is a curve and the bar's start is only indicative. */
     startOffsetVariable: boolean;
+    /** The bar's length, the system's duration in seconds. */
     duration: number;
+    /** True when the system loops; its bar runs to the end of the ruler. */
     looping: boolean;
-};
+}
+/** One row of the focused effect's timeline. */
+export type TimelineRow = TimelineGroupRow | TimelineSystemRow;
 /**
  * Reads a representative start-delay value for display without invoking the generator's
  * stateful `genValue` (IntervalValue caches its sampled slot on first call and returns NaN

package/dist/core/values.d.ts

@@ -1,28 +1,62 @@
-import type { FunctionValueGenerator, ValueGenerator } from 'babylon.quarks';
-import { PiecewiseBezier } from 'babylon.quarks';
+import type { FunctionValueGenerator, RotationGenerator, ValueGenerator, Vector3Generator } from 'babylon.quarks';
+import { PiecewiseBezier, RandomBetweenCurves } from 'babylon.quarks';
+/** A generator of one number: a constant or random value, or a curve over the particle's life. */
 export type ScalarGenerator = ValueGenerator | FunctionValueGenerator;
-export type ScalarMode = 'constant' | 'random' | 'curve';
+/** Any generator a value field can be pointed at; ones that are not scalar read as the default. */
+export type AnyGenerator = ScalarGenerator | Vector3Generator | RotationGenerator;
+/**
+ * How a value field produces its number: Unity's Constant, Random Between Two Constants, Curve or
+ * Random Between Two Curves.
+ */
+export type ScalarMode = 'constant' | 'random' | 'curve' | 'curves';
 /** Editable snapshot of a scalar value generator. */
 export interface ScalarValueState {
+    /** Which of the fields below is the value. */
     mode: ScalarMode;
     /** Constant value (mode: constant). */
     value: number;
-    /** Random range (mode: random). */
+    /** Lower end of the random range (mode: random). */
     min: number;
+    /** Upper end of the random range (mode: random). */
     max: number;
-    /** Cubic bezier control values over normalized lifetime (mode: curve). */
+    /** Cubic bezier control values over normalized lifetime (mode: curve; the first curve of curves). */
     curve: [number, number, number, number];
+    /** The second curve's control values (mode: curves); the first curve's when left out. */
+    curve2?: [number, number, number, number];
 }
-export declare function readScalar(generator: ScalarGenerator | undefined): ScalarValueState;
+/**
+ * What a value field shows for `generator`: its constant, its range or its first curve segment.
+ * Anything else, including a missing generator, reads as the constant 1.
+ */
+export declare function readScalar(generator: AnyGenerator | undefined): ScalarValueState;
+/** The generator a value field's state describes; a curve state builds a one-segment curve. */
+export declare function buildScalar(state: ScalarValueState & {
+    mode: 'curve';
+}): PiecewiseBezier;
 export declare function buildScalar(state: ScalarValueState): ScalarGenerator;
 /** One segment of a piecewise bezier curve: start x (0..1) + four control values. */
 export interface CurvePiece {
+    /** Where the segment starts, 0..1 over the particle's life. */
     start: number;
+    /** The segment's four bezier control values. */
     p: [number, number, number, number];
 }
-/** Reads pieces from a PiecewiseBezier (or synthesizes one segment for other generators). */
-export declare function readPieces(generator: ScalarGenerator | undefined): CurvePiece[];
+/**
+ * Reads pieces from a PiecewiseBezier, or from the first curve of a RandomBetweenCurves (the
+ * second with `second`). A constant reads as a flat curve, a random range as a flat curve at its
+ * lower end (its upper with `second`), and other generators as one default segment.
+ */
+export declare function readPieces(generator: AnyGenerator | undefined, second?: boolean): CurvePiece[];
+/** A piecewise bezier from segments, sorted by their start. */
 export declare function buildCurve(pieces: CurvePiece[]): PiecewiseBezier;
+/**
+ * `generator` as one curve (`'curve'`) or two (`'curves'`, Unity's Random Between Two Curves),
+ * keeping every segment: one curve becomes both bounds of two, and two keep their first as one.
+ * A constant is a flat curve, and a random range flat curves at its ends.
+ */
+export declare function withCurves(generator: AnyGenerator | undefined, mode: 'curve'): PiecewiseBezier;
+export declare function withCurves(generator: AnyGenerator | undefined, mode: 'curves'): RandomBetweenCurves;
+export declare function withCurves(generator: AnyGenerator | undefined, mode: 'curve' | 'curves'): PiecewiseBezier | RandomBetweenCurves;
 /** Splits the piece containing x into two exact halves using Bezier.split. */
 export declare function splitPieces(pieces: CurvePiece[], x: number): CurvePiece[];
 /** Removes the boundary at pieces[index].start by merging with the previous piece. */

package/dist/core/values.js

@@ -1,6 +1,17 @@
-import { Bezier, ConstantValue, IntervalValue, PiecewiseBezier } from 'babylon.quarks';
+import { Bezier, ConstantValue, IntervalValue, PiecewiseBezier, RandomBetweenCurves } from 'babylon.quarks';
+/**
+ * What a value field shows for `generator`: its constant, its range or its first curve segment.
+ * Anything else, including a missing generator, reads as the constant 1.
+ */
 export function readScalar(generator) {
-    const state = { mode: 'constant', value: 1, min: 0.5, max: 1.5, curve: [0, 1, 1, 0] };
+    const state = {
+        mode: 'constant',
+        value: 1,
+        min: 0.5,
+        max: 1.5,
+        curve: [0, 1, 1, 0],
+        curve2: [0, 1, 1, 0],
+    };
     if (generator instanceof ConstantValue) {
         state.mode = 'constant';
         state.value = generator.value;
@@ -15,14 +26,23 @@ export function readScalar(generator) {
     }
     else if (generator instanceof PiecewiseBezier) {
         state.mode = 'curve';
-        const first = generator.functions[0]?.[0];
-        if (first) {
-            state.curve = [first.p[0], first.p[1], first.p[2], first.p[3]];
-            state.value = first.p[0];
-        }
+        state.curve = firstSegment(generator) ?? state.curve;
+        state.curve2 = state.curve;
+        state.value = state.curve[0];
+    }
+    else if (generator instanceof RandomBetweenCurves) {
+        state.mode = 'curves';
+        state.curve = firstSegment(generator.curve1) ?? state.curve;
+        state.curve2 = firstSegment(generator.curve2) ?? state.curve;
+        state.value = state.curve[0];
     }
     return state;
 }
+/** The control values of a curve's first segment, if it has one. */
+function firstSegment(curve) {
+    const first = curve.functions[0]?.[0];
+    return first ? [first.p[0], first.p[1], first.p[2], first.p[3]] : undefined;
+}
 export function buildScalar(state) {
     switch (state.mode) {
         case 'constant':
@@ -31,10 +51,24 @@ export function buildScalar(state) {
             return new IntervalValue(Math.min(state.min, state.max), Math.max(state.min, state.max));
         case 'curve':
             return new PiecewiseBezier([[new Bezier(...state.curve), 0]]);
+        case 'curves':
+            return new RandomBetweenCurves(new PiecewiseBezier([[new Bezier(...state.curve), 0]]), new PiecewiseBezier([[new Bezier(...(state.curve2 ?? state.curve)), 0]]));
     }
 }
-/** Reads pieces from a PiecewiseBezier (or synthesizes one segment for other generators). */
-export function readPieces(generator) {
+/**
+ * Reads pieces from a PiecewiseBezier, or from the first curve of a RandomBetweenCurves (the
+ * second with `second`). A constant reads as a flat curve, a random range as a flat curve at its
+ * lower end (its upper with `second`), and other generators as one default segment.
+ */
+export function readPieces(generator, second = false) {
+    if (generator instanceof RandomBetweenCurves) {
+        return readPieces(second ? generator.curve2 : generator.curve1);
+    }
+    // A constant is a flat curve, and a random range two flat curves at its ends.
+    if (generator instanceof ConstantValue || generator instanceof IntervalValue) {
+        const value = generator instanceof ConstantValue ? generator.value : second ? generator.b : generator.a;
+        return [{ start: 0, p: [value, value, value, value] }];
+    }
     if (generator instanceof PiecewiseBezier && generator.functions.length > 0) {
         return generator.functions.map(([bezier, start]) => ({
             start,
@@ -44,10 +78,19 @@ export function readPieces(generator) {
     const fallback = readScalar(generator);
     return [{ start: 0, p: fallback.curve }];
 }
+/** A piecewise bezier from segments, sorted by their start. */
 export function buildCurve(pieces) {
     const sorted = [...pieces].sort((a, b) => a.start - b.start);
     return new PiecewiseBezier(sorted.map((piece) => [new Bezier(...piece.p), piece.start]));
 }
+export function withCurves(generator, mode) {
+    const first = buildCurve(readPieces(generator));
+    if (mode === 'curve') {
+        return first;
+    }
+    const second = generator instanceof RandomBetweenCurves || generator instanceof IntervalValue;
+    return new RandomBetweenCurves(first, buildCurve(readPieces(generator, second)));
+}
 /** Splits the piece containing x into two exact halves using Bezier.split. */
 export function splitPieces(pieces, x) {
     const sorted = [...pieces].sort((a, b) => a.start - b.start);

package/dist/index.d.ts

@@ -1,3 +1,5 @@
+export type { AssetLoadProgress, EffectAsset } from './core/assets.js';
+export type { AssetDragPayload } from './core/assetTree.js';
 export { EffectBinding } from './core/binding.js';
 export type { EditorListener } from './core/binding.js';
 export { GroundPlaneResolver, ensureGroundResolver } from './core/collision.js';
@@ -12,10 +14,12 @@ export { applyRendererMaterial, getMaterialLabel } from './core/material.js';
 export type { RendererMaterialPatch } from './core/material.js';
 export { formatBytes } from './core/projectStore.js';
 export type { ProjectMeta, ProjectStore, StorageEstimate, StoredAsset, StoredScene, StoredSceneEntry, } from './core/projectStore.js';
+export type { SceneEntry } from './core/sceneEntries.js';
 export { DEFAULT_SHAPE_PARAMS, SHAPE_PARAM_KEYS, SHAPE_TYPES, createShape, getShapeType, readShapeParams, } from './core/shapes.js';
 export type { ShapeParams, ShapeType } from './core/shapes.js';
 export { createChildSystem } from './core/systems.js';
 export type { ChildSystemOptions } from './core/systems.js';
 export { ensurePortableTextureUrl } from './core/textureExport.js';
+export type { TimelineGroupRow, TimelineRow, TimelineSystemRow } from './core/timeline.js';
 export { buildCurve, buildScalar, mergePieces, readPieces, readScalar, sampleCurve, splitPieces } from './core/values.js';
-export type { CurvePiece, ScalarGenerator, ScalarMode, ScalarValueState } from './core/values.js';
+export type { AnyGenerator, CurvePiece, ScalarGenerator, ScalarMode, ScalarValueState } from './core/values.js';

package/dist/react/AssetsPanel.d.ts

@@ -1,16 +1,23 @@
 import React from 'react';
 import { type AssetDragPayload } from '../core/assetTree.js';
 import { type AssetLoadProgress, type EffectAsset } from '../core/assets.js';
+/** Props of {@link AssetsPanel}. */
 export interface AssetsPanelProps {
+    /** The assets, shown as a folder tree by their paths. */
     assets: EffectAsset[];
     /** Scene instance count per asset id. */
     instanceCounts: ReadonlyMap<number, number>;
+    /** Import progress while importing; the import buttons are disabled meanwhile. */
     loading: AssetLoadProgress | null;
+    /** The hidden folder input, clicked by hosts whose browser has no directory picker. */
     folderInputRef: React.RefObject<HTMLInputElement | null>;
+    /** Imports picked files. */
     onImportFiles: (files: FileList | File[]) => void;
+    /** Opens a folder to import. */
     onImportFolder: () => void;
     /** Adds a new instance of each asset in the payload to the scene. */
     onAddToScene: (payload: AssetDragPayload) => void;
+    /** Deletes the assets in the payload. */
     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;

package/dist/react/AxesCurveField.d.ts

@@ -0,0 +1,21 @@
+import { PiecewiseBezier, RandomBetweenCurves, Vector3Function } from 'babylon.quarks';
+import React from 'react';
+import { AnyGenerator } from '../core/values.js';
+/** One curve or two, for one axis or for all of them. */
+type AxisCurve = PiecewiseBezier | RandomBetweenCurves;
+/** Props of an {@link AxesCurveField}. */
+export interface AxesCurveFieldProps {
+    /** The generator shown: one curve (or two) for every axis, or a `Vector3Function` per axis. */
+    generator: AnyGenerator | undefined;
+    /** Top of the curve editors' value range. */
+    maxValue?: number;
+    /** Receives the edited generator. */
+    onChange: (generator: AxisCurve | Vector3Function) => void;
+}
+/**
+ * A curve over life with Unity's Separate Axes switch: off, one curve (or two) for all axes; on, a
+ * {@link Vector3Function} with its own for X, Y and Z. Switching on gives every axis the shared
+ * curve; switching off keeps the X one.
+ */
+export declare function AxesCurveField(props: AxesCurveFieldProps): React.ReactElement;
+export {};

package/dist/react/AxesCurveField.js

@@ -0,0 +1,25 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { IntervalValue, RandomBetweenCurves, Vector3Function } from 'babylon.quarks';
+import { withCurves } from '../core/values.js';
+import { CheckboxField, Row } from './fields.js';
+import { LifeCurveField } from './LifeCurveField.js';
+const captionStyle = { fontSize: 10.5, opacity: 0.6, marginTop: 6 };
+/**
+ * The curve or curves `generator` holds, as a fresh copy: a constant as a flat curve, a random
+ * range as two flat ones.
+ */
+function curveOf(generator) {
+    const two = generator instanceof RandomBetweenCurves || generator instanceof IntervalValue;
+    return withCurves(generator, two ? 'curves' : 'curve');
+}
+/**
+ * A curve over life with Unity's Separate Axes switch: off, one curve (or two) for all axes; on, a
+ * {@link Vector3Function} with its own for X, Y and Z. Switching on gives every axis the shared
+ * curve; switching off keeps the X one.
+ */
+export function AxesCurveField(props) {
+    const { generator } = props;
+    const axes = generator instanceof Vector3Function ? generator : undefined;
+    const toggle = (on) => props.onChange(on ? new Vector3Function(curveOf(generator), curveOf(generator), curveOf(generator)) : curveOf(axes?.x));
+    return (_jsxs(_Fragment, { children: [_jsx(Row, { label: "Separate axes", hint: "A curve for each of X, Y and Z, as Unity's Separate Axes.", children: _jsx(CheckboxField, { value: axes !== undefined, onChange: toggle }) }), axes === undefined ? (_jsx(LifeCurveField, { generator: generator, maxValue: props.maxValue, onChange: props.onChange })) : (['x', 'y', 'z'].map((axis) => (_jsxs("div", { children: [_jsx("div", { style: captionStyle, children: axis.toUpperCase() }), _jsx(LifeCurveField, { generator: axes[axis], maxValue: props.maxValue, onChange: (curve) => props.onChange(new Vector3Function(axis === 'x' ? curve : axes.x, axis === 'y' ? curve : axes.y, axis === 'z' ? curve : axes.z)) })] }, axis))))] }));
+}

package/dist/react/ChoiceDialog.d.ts

@@ -1,13 +1,20 @@
 import React from 'react';
+/** One button of a {@link ChoiceDialog}. */
 export interface ChoiceDialogAction {
+    /** The button's text. */
     label: string;
+    /** Runs when the button is pressed. */
     onSelect: () => void;
     /** Accent button — also what Enter picks. */
     primary?: boolean;
+    /** Shows the button in red, for a destructive choice. */
     danger?: boolean;
 }
+/** Props of {@link ChoiceDialog}. */
 export interface ChoiceDialogProps {
+    /** The question. */
     title: string;
+    /** What the choice means. */
     message: React.ReactNode;
     /** Shown left to right; put the cancel action first. */
     actions: ChoiceDialogAction[];

package/dist/react/ContextMenu.d.ts

@@ -1,15 +1,24 @@
 import React from 'react';
+/** One entry of a {@link ContextMenu}. */
 export interface ContextMenuItem {
+    /** The entry's text. */
     label: string;
+    /** Runs when the entry is picked; the menu closes first. */
     onSelect: () => void;
+    /** Shows the entry in red, for a destructive action. */
     danger?: boolean;
+    /** Shows the entry greyed out and unpickable. */
     disabled?: boolean;
 }
+/** Props of {@link ContextMenu}. */
 export interface ContextMenuProps {
-    /** Client coordinates of the right-click. */
+    /** Client X of the right-click. */
     x: number;
+    /** Client Y of the right-click. */
     y: number;
+    /** The entries, top to bottom. */
     items: ContextMenuItem[];
+    /** Closes the menu: the host stops rendering it. */
     onClose: () => void;
 }
 /** Right-click menu at the pointer; closes on outside click, Escape, scroll or window blur. */

package/dist/react/EditorWorkspace.d.ts

@@ -1,6 +1,7 @@
 import React from 'react';
 import type { ProjectStore } from '../core/projectStore.js';
 import { type EffectEditorHostProps } from './EffectEditorHost.js';
+/** Props of {@link EditorWorkspace}: the editor's, plus where projects live. */
 export interface EditorWorkspaceProps extends Omit<EffectEditorHostProps, 'project' | 'onExitProject' | 'effectJson'> {
     /** Where projects are kept; defaults to the browser's IndexedDB. */
     store?: ProjectStore;
@@ -13,9 +14,15 @@ export interface EditorWorkspaceProps extends Omit<EffectEditorHostProps, 'proje
 export declare function EditorWorkspace(props: EditorWorkspaceProps): React.ReactElement;
 /** Imperative entry point, like QuarksEffectEditor.Show, for the project-based workspace. */
 export declare const QuarksEditorWorkspace: {
+    /**
+     * Mounts an {@link EditorWorkspace} into `hostElement`.
+     *
+     * @returns A handle whose `dispose()` unmounts it.
+     */
     Show(options: EditorWorkspaceProps & {
         hostElement: HTMLElement;
     }): {
+        /** Unmounts the workspace. */
         dispose: () => void;
     };
 };

package/dist/react/EditorWorkspace.js

@@ -12,10 +12,8 @@ export function EditorWorkspace(props) {
     const [project, setProject] = useState(null);
     const [resolving, setResolving] = useState(Boolean(projectId));
     useEffect(() => {
-        if (!projectId) {
-            setResolving(false);
+        if (!projectId)
             return;
-        }
         let cancelled = false;
         void store.getProject(projectId).then((meta) => {
             if (cancelled)
@@ -54,6 +52,11 @@ export function EditorWorkspace(props) {
 }
 /** Imperative entry point, like QuarksEffectEditor.Show, for the project-based workspace. */
 export const QuarksEditorWorkspace = {
+    /**
+     * Mounts an {@link EditorWorkspace} into `hostElement`.
+     *
+     * @returns A handle whose `dispose()` unmounts it.
+     */
     Show(options) {
         const { hostElement, ...props } = options;
         const root = createRoot(hostElement);

package/dist/react/EffectEditor.d.ts

@@ -1,19 +1,25 @@
+import type { Texture } from '@babylonjs/core/Materials/Textures/texture.js';
 import type { TransformNode } from '@babylonjs/core/Meshes/transformNode.js';
 import type { ParticleSystem } from 'babylon.quarks';
 import React from 'react';
 import { EffectBinding } from '../core/binding.js';
 import type { GeometryData, GeometryOption, TextureOption } from './modules.js';
+/** Props of {@link EffectEditor}. */
 export interface EffectEditorProps {
+    /** The effect the modules edit. */
     binding: EffectBinding;
     /** Currently selected system, lifted up so the timeline panel and this module stack agree. */
     selectedSystem: ParticleSystem;
+    /** The node the Object module edits the transform of. */
     gizmoTargetNode: TransformNode;
+    /** The Object module's title for that node. */
     gizmoTargetLabel: string;
     /** Texture presets offered in the Renderer module (host supplies the loader). */
     textureOptions?: TextureOption[];
     /** Mesh presets offered for the Mesh render mode (host supplies the geometry buffers). */
     geometryOptions?: GeometryOption[];
-    resolveTexture?: (url: string) => unknown;
+    /** Host texture loader for picked URLs; a plain `Texture` is made without it. */
+    resolveTexture?: (url: string) => Texture | null | undefined;
     /** Host loader for "Load from file…" in the Mesh render mode (e.g. a GLB importer). */
     resolveGeometry?: (file: File) => Promise<GeometryData>;
 }
@@ -22,4 +28,4 @@ export interface EffectEditorProps {
  * Embed it anywhere React runs — the standalone examples page or a BabylonJS Editor plugin.
  * Module order mirrors Unity's Particle System inspector.
  */
-export declare const EffectEditor: React.NamedExoticComponent<EffectEditorProps>;
+export declare const EffectEditor: React.MemoExoticComponent<(props: EffectEditorProps) => React.JSX.Element>;

package/dist/react/EffectEditorHost.d.ts

@@ -1,67 +1,71 @@
-import '@babylonjs/core/Culling/ray.js';
-import { Scene } from '@babylonjs/core/scene.js';
-import { BatchedRenderer } from 'babylon.quarks';
+import type { AbstractEngine } from '@babylonjs/core/Engines/abstractEngine.js';
+import type { Texture } from '@babylonjs/core/Materials/Textures/texture.js';
+import type { Scene } from '@babylonjs/core/scene.js';
 import React from 'react';
-import { EffectBinding } from '../core/binding.js';
-import { EffectHistory } from '../core/history.js';
-import type { ProjectStore } from '../core/projectStore.js';
+import { type EditorProject, type EffectEditorHostHandle } from '../core/editorSession.js';
 import type { GeometryData, GeometryOption, TextureOption } from './modules.js';
-export interface EffectEditorHostHandle {
-    binding: EffectBinding;
-    history: EffectHistory;
-    scene: Scene;
-    renderer: BatchedRenderer;
-    /** Replaces the scene with this effect (it is also added to Assets). */
-    importJson: (json: unknown) => void;
-    /** Imports effect files (and the texture/geometry files they reference) into Assets. */
-    importAssets: (files: FileList | File[]) => Promise<void>;
-    /** @deprecated Renamed to `importAssets`. */
-    importGallery: (files: FileList | File[]) => Promise<void>;
-    exportJson: () => string;
-}
+export type { EditorProject, EffectEditorHostHandle } from '../core/editorSession.js';
+/** Props of {@link EffectEditorHost}. */
 export interface EffectEditorHostProps {
     /** Quarks JSON export to open; a default effect is created when omitted. */
     effectJson?: unknown;
     /** When set, a Save button appears and receives the serialized effect. */
     onSave?: (json: string) => void;
-    /** Called once the engine/scene/binding are live (and after every import). */
+    /** Called once the engine, scene and binding are live, and again whenever the focused effect changes. */
     onReady?: (handle: EffectEditorHostHandle) => void;
+    /** Inspector header shown while the focused effect has no name. */
     title?: string;
+    /** Texture presets offered in the Renderer module; the first is the default effect's texture. */
     textureOptions?: TextureOption[];
     /** Mesh presets for the Mesh render mode (e.g. asset meshes from a host editor). */
     geometryOptions?: GeometryOption[];
-    resolveTexture?: (url: string, scene: Scene) => unknown;
+    /** Host texture loader for texture URLs picked in the editor. */
+    resolveTexture?: (url: string, scene: Scene) => Texture | null | undefined;
     /** Host loader for the Mesh "Load from file…" option (e.g. GLB via @babylonjs/loaders). */
     resolveGeometry?: (file: File, scene: Scene) => Promise<GeometryData>;
     /** Optional link rendered in the viewport's top-left corner (e.g. back to a host gallery page). */
     backLink?: {
+        /** Where the link goes. */
         href: string;
+        /** The link's text; a leading `←` is dropped, an arrow icon is drawn instead. */
         label: string;
     };
     /**
      * Project to edit: its assets load from and save to `store`, and the scene is saved with
      * Save / Ctrl+S. Without it the editor works in memory only.
      */
-    project?: {
-        store: ProjectStore;
-        id: string;
-        name: string;
-    };
+    project?: EditorProject;
     /** Shows a "← Projects" button; called once unsaved scene changes are dealt with. */
     onExitProject?: () => void;
+    /**
+     * Builds the engine the editor draws with, on the canvas it is given, for example a
+     * `WebGPUEngine` after `await engine.initAsync()`. It may return a promise. It must build a new
+     * engine on every call: the editor disposes the engine when it unmounts, and React may mount
+     * it more than once (StrictMode). Defaults to a WebGL `Engine` with antialiasing.
+     */
+    createEngine?: (canvas: HTMLCanvasElement) => AbstractEngine | Promise<AbstractEngine>;
 }
 /**
  * Self-contained effect editor: live Babylon preview, a Scene list of the effects placed in it,
  * an inspector, and a bottom dock with the timeline and the Assets browser. Assets are effect
  * files; dragging one into the viewport instantiates an independent copy, as many times as needed.
- * Designed for embedding — see QuarksEffectEditor.Show for the NME-style entry point.
+ * Designed for embedding — see {@link QuarksEffectEditor}.Show for the NME-style entry point.
+ *
+ * The scene, Assets, prefab mode and undo live in an {@link EditorSession}; this component is its
+ * React view.
  */
-export declare function EffectEditorHost(props: EffectEditorHostProps): React.JSX.Element;
+export declare function EffectEditorHost(props: EffectEditorHostProps): React.ReactElement;
 /** NME-style imperative entry point for hosts like BabylonJS Editor windows. */
 export declare const QuarksEffectEditor: {
+    /**
+     * Mounts an {@link EffectEditorHost} into `hostElement`.
+     *
+     * @returns A handle whose `dispose()` unmounts the editor and frees its engine.
+     */
     Show(options: EffectEditorHostProps & {
         hostElement: HTMLElement;
     }): {
+        /** Unmounts the editor. */
         dispose: () => void;
     };
 };