@3driseai/3drise-viewer 0.1.28 → 0.1.29

package/dist/operations/catalogue/turnAway.js

@@ -0,0 +1,54 @@
+// Turn away — the object turns like a card and leaves edge-on. It spins up about
+// a vertical (or horizontal) axis and, as it comes round to face the camera with
+// its edge, the side that would face you thins away — it vanishes at the moment
+// it is edge-on. The way back: it turns into view from a sliver, slowing, and
+// settles with a small overshoot.
+import { Quaternion, Vector3 } from 'three';
+import { physicalExit, ring, smooth } from './physicalExit.js';
+const _q = new Quaternion(), _q2 = new Quaternion(), _e = new Vector3();
+/** Total turn: whole turns, then the quarter that brings it edge-on. */
+const angleOf = (a) => (Number(a.p.turns) + 0.25) * 2 * Math.PI * (a.p.reverse ? -1 : 1);
+/**
+ * Turn by `th` about the chosen screen axis and thin `thin` (0…1) the side that ends up
+ * across the view when the full turn `end` is reached.
+ */
+function pose(out, a, th, end, thin) {
+    const f = a.frame;
+    const vertical = a.p.axis !== 'horizontal';
+    const turnAxis = vertical ? f.up : f.right;
+    _q.setFromAxisAngle(turnAxis, th);
+    out.q.copy(a.local(_q));
+    // the rest-pose direction that the end turn carries onto the collapsing screen axis
+    _e.copy(vertical ? f.right : f.up).applyQuaternion(_q2.setFromAxisAngle(turnAxis, -end));
+    const k = 1 - thin;
+    out.s.set(1, 1, 1).setComponent(a.axis(_e), Math.max(k, 0));
+}
+export default physicalExit({
+    value: 'turnAway',
+    label: 'Turn away',
+    description: 'Turns like a card and vanishes edge-on — it turns back into view from a sliver',
+    params: {
+        axis: {
+            type: 'select', label: 'Turns about', default: 'vertical', options: [{ value: 'vertical', label: 'Its upright axis' }, { value: 'horizontal', label: 'A level axis (flips over)' }],
+        },
+        turns: { type: 'number', label: 'Turns', default: 1, min: 0, max: 5, step: 0.25, hint: 'Whole turns before it goes edge-on' },
+        reverse: { type: 'boolean', label: 'Other way', default: false },
+        duration: { type: 'number', label: 'Duration', default: 1.2, min: 0.3, max: 6, step: 0.05, unit: 's' },
+    },
+    exit(u, out, a) {
+        const end = angleOf(a);
+        // spins up (turn ∝ u²); the side across the view thins over the last quarter turn
+        const th = end * u * u;
+        const last = 1 - 0.25 / (Number(a.p.turns) + 0.25); // where the last quarter starts, in turn share
+        const thin = smooth(Math.sqrt(Math.max(0, last)) * 0.98, 1, u);
+        pose(out, a, th, end, thin);
+    },
+    enter(v, out, a) {
+        const end = angleOf(a);
+        // from edge-on (−end) back to facing, slowing; a small overshoot at the end
+        const left = 1 - v;
+        const th = -end * Math.pow(left, 2.2) + 0.12 * Math.sign(end) * ring(smooth(0.55, 1, v), 1, 3);
+        const thin = 1 - smooth(0, 0.3, v);
+        pose(out, a, th, -end, thin);
+    },
+});

package/dist/operations/catalogue/vortexDrain.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("..").OperationDefinition;
+export default _default;
+//# sourceMappingURL=vortexDrain.d.ts.map

package/dist/operations/catalogue/vortexDrain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vortexDrain.d.ts","sourceRoot":"","sources":["../../../src/operations/catalogue/vortexDrain.ts"],"names":[],"mappings":";AAuBA,wBA8BG"}

package/dist/operations/catalogue/vortexDrain.js

@@ -0,0 +1,68 @@
+// Vortex drain — the object is caught by a whirlpool under it and drained away.
+// It is drawn out onto an orbit, then spirals in and down the funnel, keeping
+// its angular momentum: ω ∝ L / r², so it whirls faster and faster as the orbit
+// tightens, spins up about its own axis, leans into the funnel and shrinks into
+// the point below its base. The way back is the drain run backwards, a fountain:
+// it is flung up out of the point, slows as the orbit widens and is set down.
+import { Quaternion, Vector3 } from 'three';
+import { clamp01, physicalExit, smooth } from './physicalExit.js';
+const N = 512;
+const _q = new Quaternion(), _t = new Quaternion(), _axis = new Vector3();
+/** Orbit radius (fraction of the widest): opens to its widest a third of the way in, closes to 0. */
+const radiusAt = (u) => Math.sin(Math.PI * Math.pow(clamp01(u), 0.6));
+/** Angle along the drain at u, read from the integrated table. */
+function thetaAt(tab, u) {
+    const x = clamp01(u) * (N - 1), i = Math.floor(x), f = x - i;
+    return i >= N - 1 ? tab.theta[N - 1] : tab.theta[i] * (1 - f) + tab.theta[i + 1] * f;
+}
+export default physicalExit({
+    value: 'vortexDrain',
+    label: 'Vortex drain',
+    description: 'Caught by a whirlpool: it spirals in and down, spinning faster as the orbit tightens, and drains away — reverting flings it back up out of the funnel',
+    params: {
+        turns: { type: 'number', label: 'Turns', default: 3, min: 0.5, max: 10, step: 0.25, hint: 'Times round the funnel' },
+        radius: { type: 'number', label: 'Orbit', default: 0.7, min: 0, max: 3, step: 0.05, hint: 'Widest orbit, × its width' },
+        depth: { type: 'number', label: 'Depth', default: 0.9, min: 0, max: 4, step: 0.05, hint: 'How far it sinks, × its height' },
+        lean: { type: 'number', label: 'Lean', default: 22, min: 0, max: 60, step: 1, unit: '°', hint: 'How much it leans into the funnel' },
+        reverse: { type: 'boolean', label: 'Clockwise', default: false },
+        duration: { type: 'number', label: 'Duration', default: 2.4, min: 0.4, max: 10, step: 0.05, unit: 's' },
+    },
+    prepare({ p }) {
+        // integrate θ' = L(u) / (r² + ε²): angular momentum arrives as it is caught, then is kept
+        const theta = new Float32Array(N);
+        let acc = 0;
+        for (let i = 1; i < N; i++) {
+            const u = (i - 0.5) / (N - 1);
+            const r = radiusAt(u);
+            const L = smooth(0, 0.3, u);
+            acc += L / (r * r + 0.09) / (N - 1);
+            theta[i] = acc;
+        }
+        const k = (Number(p.turns) * 2 * Math.PI) / Math.max(acc, 1e-6) * (p.reverse ? -1 : 1);
+        for (let i = 0; i < N; i++)
+            theta[i] *= k;
+        return { theta };
+    },
+    exit(u, out, a) { drain(u, out, a); },
+    // the drain backwards in time: out of the point, the orbit widening, the whirl slowing
+    enter(v, out, a) { drain(1 - v, out, a); },
+});
+function drain(u, out, a) {
+    const p = a.p, f = a.frame;
+    const R = Math.max(a.size.x, a.size.z) * Number(p.radius) * radiusAt(u);
+    const th = thetaAt(a.mem, u);
+    const c = Math.cos(th), s = Math.sin(th);
+    const sink = Number(p.depth) * a.size.y * Math.pow(u, 2.2);
+    out.off.set(0, 0, 0)
+        .addScaledVector(f.right, R * c)
+        .addScaledVector(f.toward, R * s)
+        .addScaledVector(f.up, -sink);
+    // spins about its own up with the whirl (a little faster), leans its top in towards the axis
+    _q.setFromAxisAngle(f.up, th * 1.25);
+    const lean = (Number(p.lean) * Math.PI / 180) * smooth(0.05, 0.5, u) * (1 - smooth(0.85, 1, u) * 0.5);
+    // the tangent of the orbit: leaning about it tips the top towards the funnel's axis
+    _axis.set(0, 0, 0).addScaledVector(f.right, -s).addScaledVector(f.toward, c).normalize();
+    _t.setFromAxisAngle(_axis, lean); // + about the tangent tips the top inwards (t × up = −radial)
+    out.q.copy(a.local(_t.multiply(_q)));
+    out.s.setScalar(1 - smooth(0.4, 1, u));
+}

package/dist/operations/catalogue/warp.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("..").OperationDefinition;
+export default _default;
+//# sourceMappingURL=warp.d.ts.map

package/dist/operations/catalogue/warp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"warp.d.ts","sourceRoot":"","sources":["../../../src/operations/catalogue/warp.ts"],"names":[],"mappings":";AAkBA,wBAsDG"}

package/dist/operations/catalogue/warp.js

@@ -0,0 +1,73 @@
+// Warp — a jump to hyperspace. The object charges: it draws back a touch and
+// compresses along its heading with a fine hum, then stretches far along it
+// while thinning across (volume kept) and accelerates exponentially, gone in a
+// few frames. The way back: it shoots in stretched, decelerating exponentially,
+// snaps out of the stretch on arrival and jiggles until it is exactly at rest.
+import { Vector3 } from 'three';
+import { clamp01, physicalExit, ring, smooth, stretchAxis } from './physicalExit.js';
+const ARRIVE = 0.55;
+const _d = new Vector3();
+function dirOf(f, d) {
+    if (d === 'right')
+        return _d.copy(f.right);
+    if (d === 'left')
+        return _d.copy(f.right).negate();
+    if (d === 'up')
+        return _d.copy(f.up);
+    return _d.copy(f.toward).negate(); // away, into the scene
+}
+export default physicalExit({
+    value: 'warp',
+    label: 'Warp',
+    description: 'Charges, then stretches along its heading and jumps away in a blink — it shoots back in, snaps out of the stretch and jiggles to rest',
+    params: {
+        direction: {
+            type: 'select', label: 'Direction', default: 'right', options: [
+                { value: 'right', label: 'Right' }, { value: 'away', label: 'Away' }, { value: 'left', label: 'Left' }, { value: 'up', label: 'Up' },
+            ], hint: 'Screen-relative when it starts',
+        },
+        stretch: { type: 'number', label: 'Stretch', default: 3, min: 1, max: 8, step: 0.1, unit: '×', hint: 'How long it gets at the jump' },
+        charge: { type: 'number', label: 'Charge', default: 0.55, min: 0.1, max: 0.85, step: 0.01, hint: 'Share of the duration spent charging' },
+        distance: { type: 'number', label: 'Distance', default: 30, min: 5, max: 120, step: 1, hint: 'How far it jumps, × its size' },
+        duration: { type: 'number', label: 'Duration', default: 1.4, min: 0.3, max: 6, step: 0.05, unit: 's' },
+    },
+    exit(u, out, a) {
+        const p = a.p, D = Number(p.duration);
+        const d = dirOf(a.frame, p.direction);
+        const axis = a.axis(d);
+        const C = Number(p.charge), S = Number(p.stretch), L = Number(p.distance) * a.span;
+        if (u < C) {
+            const t = u / C;
+            // draws back a little and compresses along the heading; a fine hum builds
+            const c = smooth(0, 1, t);
+            const hum = 0.012 * smooth(0.3, 0.8, t) * (1 - smooth(0.9, 1, t)) * Math.sin(2 * Math.PI * 24 * u * D);
+            out.off.copy(d).multiplyScalar(-0.06 * a.span * c);
+            stretchAxis(out.s, axis, 1 - 0.14 * c + hum);
+            return;
+        }
+        const tau = (u - C) / (1 - C);
+        const k = 6;
+        const x = (Math.exp(k * tau) - 1) / (Math.exp(k) - 1); // exponential take-off
+        out.off.copy(d).multiplyScalar(-0.06 * a.span + (L + 0.06 * a.span) * x);
+        const s = 0.86 + (S - 0.86) * smooth(0, 0.35, tau);
+        stretchAxis(out.s, axis, s, 1 - smooth(0.7, 1, tau));
+    },
+    enter(v, out, a) {
+        const p = a.p;
+        const d = dirOf(a.frame, p.direction);
+        const axis = a.axis(d);
+        const S = Number(p.stretch), L = Number(p.distance) * a.span;
+        if (v < ARRIVE) {
+            const tau = v / ARRIVE;
+            const k = 6;
+            const x = (Math.exp(k * (1 - tau)) - 1) / (Math.exp(k) - 1); // exponential braking
+            out.off.copy(d).multiplyScalar(L * x);
+            const s = 1 + (S - 1) * (1 - smooth(0.65, 1, tau));
+            stretchAxis(out.s, axis, s, smooth(0, 0.2, tau));
+            return;
+        }
+        // snapped out of the stretch: it jiggles along the heading
+        const sg = clamp01((v - ARRIVE) / (1 - ARRIVE));
+        stretchAxis(out.s, axis, 1 - 0.18 * ring(sg, 2, 3.5));
+    },
+});

package/dist/operations/catalogue/whoosh.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("..").OperationDefinition;
+export default _default;
+//# sourceMappingURL=whoosh.d.ts.map

package/dist/operations/catalogue/whoosh.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"whoosh.d.ts","sourceRoot":"","sources":["../../../src/operations/catalogue/whoosh.ts"],"names":[],"mappings":";AAmEA,wBAcG"}

package/dist/operations/catalogue/whoosh.js

@@ -0,0 +1,84 @@
+// Whoosh — the object streaks through its own spot again and again, each pass
+// crossing the one before it (an X seen from above: back-left → front-right,
+// then back-right → front-left, the angle opening a little every pair), with a
+// soft alternating arc. On each streak it stretches along its motion (volume
+// kept) and banks into it. After `passes` fly-throughs it comes in on the next
+// crossing line, brakes exponentially into place, overshoots a touch and settles.
+// Leaving plays it backwards in time: it bolts off along that line, then streaks
+// through its spot the other way round, and is gone.
+import { Quaternion, Vector3 } from 'three';
+import { clamp01, physicalExit, ring, smooth, stretchAxis } from './physicalExit.js';
+const _d = new Vector3(), _q = new Quaternion();
+const PASS = 1, GAP = 0.14, ARRIVE = 1.5, SETTLE = 0.75; // timeline units
+/** Direction of crossing line i on the ground plane (screen-relative), mostly across the view. */
+function lineDir(a, i, out) {
+    const f = a.frame;
+    const side = (i % 2 === 0 ? 1 : -1) * (a.p.mirror ? -1 : 1); // alternates which way it crosses
+    const phi = (24 + 9 * Math.floor(i / 2)) * Math.PI / 180; // each pair opens a little wider
+    return out.set(0, 0, 0).addScaledVector(f.right, side * Math.cos(phi)).addScaledVector(f.toward, Math.sin(phi)).normalize();
+}
+function streak(out, a, tau, i) {
+    const f = a.frame, H = a.size.y;
+    const W = Number(a.p.spread) * a.span;
+    lineDir(a, i, _d);
+    // straight through its spot at constant speed, with a soft arc that alternates up / down
+    const arc = (i % 2 === 0 ? 1 : -0.45) * 0.3 * H * Math.sin(Math.PI * tau);
+    out.off.copy(_d).multiplyScalar(W * (2 * tau - 1)).addScaledVector(f.up, arc + 0.15 * H * Math.sin(Math.PI * tau));
+    stretchAxis(out.s, a.axis(_d), 1 + Number(a.p.stretch), smooth(0, 0.06, tau) * (1 - smooth(0.94, 1, tau)));
+    out.q.copy(a.local(_q.setFromAxisAngle(_d, (i % 2 === 0 ? -1 : 1) * 0.3 * Math.cos(Math.PI * tau))));
+}
+function arrive(out, a, tau, i) {
+    const st = Number(a.p.stretch);
+    const L = Number(a.p.spread) * a.span;
+    lineDir(a, i, _d);
+    const k = 5;
+    const left = (Math.exp(k * (1 - tau)) - 1) / (Math.exp(k) - 1); // exponential braking
+    out.off.copy(_d).multiplyScalar(-L * left);
+    stretchAxis(out.s, a.axis(_d), 1 + st * Math.min(1, left * 4), smooth(0, 0.06, tau));
+}
+function settle(out, a, sg, i) {
+    const st = Number(a.p.stretch);
+    lineDir(a, i, _d);
+    const r = ring(sg, 1.5, 3.4);
+    out.off.copy(_d).multiplyScalar(0.12 * a.span * r); // past its spot along the line, and back
+    stretchAxis(out.s, 1, 1 - 0.3 * st * Math.abs(r));
+    out.pivot = 'bottom';
+}
+/** The entrance at v (0 gone → 1 at rest). */
+function entrance(v, out, a) {
+    const n = Math.max(0, Math.round(Number(a.p.passes)));
+    const total = n * (PASS + GAP) + ARRIVE + SETTLE;
+    let t = clamp01(v) * total;
+    for (let i = 0; i < n; i++) {
+        if (t < PASS) {
+            streak(out, a, t / PASS, i);
+            return;
+        }
+        t -= PASS;
+        if (t < GAP) {
+            out.s.setScalar(0);
+            return;
+        } // off-screen between passes
+        t -= GAP;
+    }
+    if (t < ARRIVE) {
+        arrive(out, a, t / ARRIVE, n);
+        return;
+    }
+    settle(out, a, clamp01((t - ARRIVE) / SETTLE), n);
+}
+export default physicalExit({
+    value: 'whoosh',
+    label: 'Whoosh',
+    description: 'Streaks through its own spot again and again, each pass crossing the last, then brakes into place; it leaves the same way, in reverse',
+    params: {
+        passes: { type: 'number', label: 'Passes', default: 3, min: 0, max: 8, step: 1, hint: 'Fly-throughs before it settles (add duration with more passes)' },
+        spread: { type: 'number', label: 'Reach', default: 7, min: 2, max: 25, step: 0.5, hint: 'How far each pass runs either side of its spot, × its size' },
+        stretch: { type: 'number', label: 'Stretch', default: 0.6, min: 0, max: 2, step: 0.05, hint: 'How long it gets while it streaks' },
+        mirror: { type: 'boolean', label: 'Mirror', default: false, hint: 'Start the first pass from the right' },
+        duration: { type: 'number', label: 'Duration', default: 3, min: 0.6, max: 14, step: 0.05, unit: 's', hint: 'The whole entrance (or exit)' },
+    },
+    // leaving: the same timeline backwards (bolts off along the last line, then the passes the other way round)
+    exit(u, out, a) { entrance(1 - u, out, a); },
+    enter(v, out, a) { entrance(v, out, a); },
+});

package/dist/operations/catalogue/wobble.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("..").OperationDefinition;
+export default _default;
+//# sourceMappingURL=wobble.d.ts.map

package/dist/operations/catalogue/wobble.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wobble.d.ts","sourceRoot":"","sources":["../../../src/operations/catalogue/wobble.ts"],"names":[],"mappings":";AAOA,wBAiBG"}

package/dist/operations/catalogue/wobble.js

@@ -0,0 +1,23 @@
+// Wobble — the object's up axis traces a small cone, like a spinning top that is
+// settling (precession), with a slow nutation so the circle breathes.
+import { Vector3 } from 'three';
+import { DURATION, heldPhysical } from './physicalHeld.js';
+const _axis = new Vector3();
+export default heldPhysical({
+    value: 'wobble', label: 'Wobble',
+    description: 'Lean round in a circle, like a top that is settling — standing on its base',
+    params: {
+        angle: { type: 'number', label: 'Lean', default: 6, min: 0.5, max: 40, step: 0.5, unit: '°' },
+        speed: { type: 'number', label: 'Speed', default: 1, min: 0.1, max: 6, step: 0.05, unit: '×' },
+        clockwise: { type: 'boolean', label: 'Clockwise', default: false },
+        duration: { ...DURATION, default: 3 },
+    },
+    memory: () => null,
+    move(part, st, time) {
+        const p = st.p;
+        const phi = (p.clockwise ? -1 : 1) * 2 * Math.PI * 0.45 * Number(p.speed) * time;
+        const lean = (Number(p.angle) * Math.PI / 180) * (1 + 0.18 * Math.sin(phi * 0.37)) * st.amp.v;
+        part.q.setFromAxisAngle(_axis.set(Math.cos(phi), 0, Math.sin(phi)), lean);
+        part.pivot.copy(st.body.bottomLocal);
+    },
+});

package/dist/operations/clipPreview.d.ts

@@ -0,0 +1,3 @@
+/** A JPEG of the current frame, at most `maxSize` px on its long side. Null when no scene is mounted. */
+export declare function captureFrameImage(maxSize?: number, quality?: number): Promise<Blob | null>;
+//# sourceMappingURL=clipPreview.d.ts.map

package/dist/operations/clipPreview.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clipPreview.d.ts","sourceRoot":"","sources":["../../src/operations/clipPreview.ts"],"names":[],"mappings":"AAOA,yGAAyG;AACzG,wBAAgB,iBAAiB,CAAC,OAAO,SAAM,EAAE,OAAO,SAAO,GAAG,OAAO,CAAC,IAAI,GAAG,IAAI,CAAC,CAWrF"}

package/dist/operations/clipPreview.js

@@ -0,0 +1,20 @@
+// A small preview image of what the scene shows right now — for an effect clip template's card.
+// The same full frame as the studio's screenshots (renderFrame: clouds and other full-screen
+// passes included), scaled down to a thumbnail.
+import { SceneStore } from '@3driseai/3drise-core';
+import cameraManager from '../utils/CameraSingleton.js';
+import { renderFrame } from '../utils/frameRenderer.js';
+/** A JPEG of the current frame, at most `maxSize` px on its long side. Null when no scene is mounted. */
+export function captureFrameImage(maxSize = 512, quality = 0.85) {
+    const gl = SceneStore.gl, scene = SceneStore.scene, camera = cameraManager.getCamera?.();
+    if (!gl || !scene || !camera || typeof document === 'undefined')
+        return Promise.resolve(null);
+    renderFrame(gl, scene, camera);
+    const src = gl.domElement;
+    const k = Math.min(1, maxSize / Math.max(src.width, src.height, 1));
+    const out = document.createElement('canvas');
+    out.width = Math.max(1, Math.round(src.width * k));
+    out.height = Math.max(1, Math.round(src.height * k));
+    out.getContext('2d')?.drawImage(src, 0, 0, out.width, out.height);
+    return new Promise(resolve => out.toBlob(b => resolve(b), 'image/jpeg', quality));
+}

package/dist/operations/groupFanout.d.ts

@@ -0,0 +1,96 @@
+import { type Object3D } from 'three';
+import type { EffectSpread, EffectStep, ObjectEffect } from '@3driseai/3drise-core';
+/** A row of a group's clip that goes to the children: a visual effect, or a physical one scoped 'each'. */
+export declare const isFanRow: (e: Pick<ObjectEffect, "operation" | "scope">) => boolean;
+/** An effect clip as the fan-out hands it to a child (the controller's EffectClipData). */
+export interface FanClip {
+    effects?: ObjectEffect[];
+    steps?: EffectStep[];
+    loop?: boolean;
+    yoyo?: boolean;
+}
+/** The part of a child's controller the fan-out uses. */
+export interface FanTarget {
+    addEffect(key: string, effect: Pick<ObjectEffect, 'operation' | 'params' | 'playback' | 'meshNames'>, opts?: {
+        instant?: boolean;
+        follows?: boolean;
+    }): boolean;
+    removeEffect(key: string): boolean;
+    applyClip(key: string, clip: FanClip): boolean;
+    removeClip(key: string): boolean;
+    fanLeave(keys: string[]): Promise<unknown>;
+    fanPark(keys: string[]): void;
+    fanEnter(keys: string[]): Promise<unknown>;
+}
+export declare class GroupFanout {
+    private root;
+    /** A child's controller; `create` makes one for a child that has no effects of its own. */
+    private controllerOf;
+    /** What is handed out now, by item id (own rows: their id; triggered rows: `t:<key>`; clips: `c:<key>`). */
+    private items;
+    private children;
+    private childKey;
+    private spread;
+    /** The group's own clip follows its visibility: its rows reach the children as following it too. */
+    private follows;
+    /** Pending gives / takes: `${itemId}|${childId}` → timer. */
+    private timers;
+    /** Pending visibility turns: childId → timer (and the leave promise to settle if called off). */
+    private vis;
+    constructor(root: Object3D, 
+    /** A child's controller; `create` makes one for a child that has no effects of its own. */
+    controllerOf: (root: Object3D, create: boolean) => FanTarget | undefined);
+    private get groupId();
+    private key;
+    private rowFits;
+    private fits;
+    /** Milliseconds before child `c` gets (or, `out`, loses) its turn among `reach` (the children concerned). */
+    private turn;
+    private delay;
+    private cancel;
+    private schedule;
+    /** Run every pending give / take now (the group is being hidden: the children must be in their final state). */
+    private flush;
+    /** Hand an item (as it is when the delay ends) to a child. */
+    private give;
+    private take;
+    /** Hand out a new item: each child it reaches after its delay. */
+    private putOn;
+    /** Take an item off: each child after its out delay (`inOrder`: a handover — in the in order). */
+    private takeOff;
+    /** The leaf scene objects under the group, in the spread's order. */
+    private collect;
+    /**
+     * The group's own fan rows now (its clip's visual rows and physical 'each' rows, Base and steps).
+     *   instant  scene load: everything lands at once, no cascade.
+     *   follows  the group's clip follows visibility.
+     */
+    sync(rows: ObjectEffect[], spread: EffectSpread | null | undefined, mode: 'animate' | 'instant', follows?: boolean): void;
+    addTriggered(key: string, effect: Pick<ObjectEffect, 'operation' | 'params' | 'playback'>): boolean;
+    removeTriggered(key: string): boolean;
+    hasTriggered(key: string): boolean;
+    applyClip(key: string, clip: FanClip): boolean;
+    removeClip(key: string): boolean;
+    hasClip(key: string): boolean;
+    /** The children that hold the group's own rows, and the keys of those rows on each. */
+    private holders;
+    private cancelVis;
+    /** The group is being hidden: each child plays the group's effects out on its turn. Resolves when the last has gone. */
+    leave(): Promise<unknown>;
+    /** The group is about to be shown: every child holding its effects starts from nothing. */
+    park(): void;
+    /** The group is drawn: each child gets ready and plays the group's effects in, on its turn. */
+    enter(): void;
+    /**
+     * Children joined or left (checked every few frames, and on each change). `quiet` on the first look.
+     * A child that joins gets what is on at once; one that leaves loses it at once.
+     */
+    check(quiet?: boolean): void;
+    /** Some child is still waiting for one of these items (a cascade is running). */
+    pending(itemIds: string[]): boolean;
+    /** Take everything off the children at once (the group is going away, or is no longer a group). */
+    dispose(): void;
+    /** Ids of the children now, in cascade order (tests / studio). */
+    get childIds(): string[];
+}
+//# sourceMappingURL=groupFanout.d.ts.map

package/dist/operations/groupFanout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"groupFanout.d.ts","sourceRoot":"","sources":["../../src/operations/groupFanout.ts"],"names":[],"mappings":"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"}