@3driseai/3drise-viewer 0.1.28 → 0.1.29

package/dist/index.d.ts.map

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

package/dist/index.js

@@ -10,7 +10,9 @@ export * from './hooks/index.js';
 export { createSceneHandle } from './api/sceneHandle.js';
 export * from './animationsV2/index.js';
 export * from './interactions/index.js';
+export * from './ui/index.js';
 export * from './operations/index.js';
+export * from './triggers/index.js';
 // Utils
 export { cameraManager } from './utils/CameraSingleton.js';
 export { applyAnchorSettings, createCurves, createSunPosition, randomRange, } from './utils/utils3d.js';
@@ -21,7 +23,11 @@ export { findById } from './utils/sceneQuery.js';
 export { hasFrameRenderer, registerFrameRenderer, renderFrame } from './utils/frameRenderer.js';
 export { resolveObject3D } from './utils/resolveObject3D.js';
 export * from './utils/textEffects.js';
-export { applyTerrainUniforms } from './utils/terrainUniforms.js';
+export { applyTerrainUniforms, applyTerrainTextures } from './utils/terrainUniforms.js';
+export { useTerrainTextures } from './hooks/useTerrainTextures.js';
+export { terrainHeightAt } from './utils/terrainHeight.js';
+export { setTerrainTextureResolver, resolveTerrainTextureSets, useTerrainTextureResolverVersion } from './utils/terrainTextureResolver.js';
+export { landHeightAt, landWorldHeightAt, landSeedOffset, landToTerrainConfig, LAND_SEGMENTS } from './utils/landPatch.js';
 export { applyLandscapeMaps, applyLandscapeUniforms } from './utils/landscapeUniforms.js';
 export { getLandscapeHeightAt, registerLandscapeHeightField, sampleLandscapeHeight, snapToLandscape, unregisterLandscapeHeightField, } from './utils/landscapeHeight.js';
 export { buildLandscapeGeometry, rtinTileFor, setLandscapeBounds } from './utils/landscapeGeometry.js';
@@ -34,6 +40,7 @@ export { applyConfigKeyframeAnimations, applyConfigMouseMove, hasConfigOverrides
 // Presets
 export { volumetricCloudPresets, cirrusPresets, getCloudPresetsForType, getCloudPresetByName, getCirrusPresetByName, searchCloudPresetsByTags, } from './presets/volumetricCloudPresets.js';
 export { terrainPresets, getTerrainPresetsForType, getTerrainPresetByName, searchTerrainPresetsByTags, } from './presets/terrainPresets.js';
+export { terrainBiomes, getTerrainBiomeByName, terrainBiomeFields, applyTerrainShape, applyTerrainBiome, applyTerrainPreset, terrainRuggednessPatch, terrainCoveragePatch, BIOME_KEYS, RUGGEDNESS_KEYS, COVERAGE_KEYS, } from './presets/terrainBiomes.js';
 export { getLandscapePresetByName, landscapePresetAssetNames, landscapePresets, resolveLandscapePreset, searchLandscapePresetsByTags, } from './presets/landscapePresets.js';
 export { LANDSCAPE_DETAIL, detectLandscapeDetail, getLandscapeShape, getLandscapeType, landscapeQualityForDetail, landscapeShapes, landscapeTypePacks, landscapeTypeAvailability, landscapeTypes, repeatForMetres, resolveLandscapeType, } from './presets/landscapeTypes.js';
 export { oceanSurfacePresets, getOceanPresetsForType, getOceanPresetByName, searchOceanPresetsByTags, } from './presets/oceanSurfacePresets.js';

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

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

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

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

package/dist/operations/catalogue/blastOff.js

@@ -0,0 +1,118 @@
+// Blast off — the object crouches (a volume-keeping squash at its base), then
+// launches straight up. Thrust builds instead of kicking in at once (constant jerk:
+// height ∝ t³), it stretches along its speed and trembles a little on the thrust,
+// and is gone above.
+//
+// The way back is a powered landing, not the launch backwards:
+//   fall    it drops in from above, already fast and speeding up, a little tilted
+//   burn    hard braking: the deceleration squashes it, and it rights itself with a
+//           damped correction (overshoots, settles upright)
+//   hover   it hangs just above the ground for a moment, easing down
+//   land    touches down at almost no speed and settles with a small damped squash
+// Its height comes from integrating that speed profile (a table built per run),
+// scaled so the fall starts `height` × its height up and ends exactly on the ground.
+import { Quaternion } from 'three';
+import { clamp01, physicalExit, smooth } from './physicalExit.js';
+const _a = new Quaternion(), _b = new Quaternion();
+const CROUCH_END = 0.2; // share of the exit spent crouching
+// the landing's phases, as shares of the entrance
+const FALL_END = 0.36, BURN_END = 0.68, TOUCH = 0.86;
+const N = 400;
+/** Downward speed (relative) along the entrance, before touchdown. */
+function speedAt(v) {
+    if (v < FALL_END)
+        return 0.62 + 0.38 * (v / FALL_END); // falling, speeding up
+    if (v < BURN_END) { // the burn: from full speed to a crawl
+        const k = smooth(0, 1, (v - FALL_END) / (BURN_END - FALL_END));
+        return 1 + (0.035 - 1) * k;
+    }
+    return 0.035 * (1 - 0.6 * smooth(BURN_END, TOUCH, v)); // hover, easing down
+}
+function buildLanding() {
+    const drop = new Float32Array(N), decel = new Float32Array(N);
+    let acc = 0;
+    const dv = TOUCH / (N - 1);
+    for (let i = 1; i < N; i++) {
+        acc += speedAt((i - 0.5) * dv) * dv;
+        drop[i] = acc;
+    }
+    let peak = 0;
+    for (let i = 0; i < N; i++) {
+        drop[i] /= acc; // 0 at the start → 1 on the ground
+        decel[i] = Math.max(0, speedAt(i * dv) - speedAt(Math.min(TOUCH, (i + 1) * dv))) / dv;
+        peak = Math.max(peak, decel[i]);
+    }
+    for (let i = 0; i < N; i++)
+        decel[i] /= peak || 1; // 1 = the hardest braking
+    return { drop, decel };
+}
+function table(t, v) {
+    const x = clamp01(v / TOUCH) * (N - 1), i = Math.floor(x), f = x - i;
+    return i >= N - 1 ? t[N - 1] : t[i] * (1 - f) + t[i + 1] * f;
+}
+/** Thrust tremble: two incommensurate sines per axis, in world axes about the base. */
+function tremble(a, amount, secs, lean = 0) {
+    const rad = (Number(a.p.wobble) * Math.PI / 180) * amount;
+    const w = 2 * Math.PI * secs;
+    const rx = rad * (0.62 * Math.sin(5.3 * w) + 0.38 * Math.sin(8.71 * w + 1.1)) + lean;
+    const rz = rad * (0.62 * Math.sin(4.7 * w + 2.3) + 0.38 * Math.sin(9.13 * w + 0.4)) + lean * 0.45;
+    _a.setFromAxisAngle(a.frame.right, rx).multiply(_b.setFromAxisAngle(a.frame.toward, rz));
+    return a.local(_a);
+}
+/** Stretch `sy` along up keeping the volume. */
+function stretch(out, sy, k) {
+    const sxz = 1 / Math.sqrt(Math.max(sy, 0.05));
+    out.s.set(sxz * k, sy * k, sxz * k);
+}
+export default physicalExit({
+    value: 'blastOff',
+    label: 'Blast off',
+    description: 'Crouch, then launch straight up and out of the scene — it comes back with a powered landing: falls in, brakes hard, hovers, touches down',
+    params: {
+        height: { type: 'number', label: 'Height', default: 8, min: 2, max: 30, step: 0.5, hint: 'How high it flies before it is gone, × its height' },
+        crouch: { type: 'number', label: 'Crouch', default: 0.2, min: 0, max: 0.5, step: 0.01, hint: 'Squash before the launch and on the landing' },
+        stretch: { type: 'number', label: 'Stretch', default: 0.25, min: 0, max: 0.8, step: 0.01, hint: 'How much it stretches with its speed, and squashes when it brakes' },
+        wobble: { type: 'number', label: 'Thrust wobble', default: 2.5, min: 0, max: 12, step: 0.5, unit: '°' },
+        duration: { type: 'number', label: 'Duration', default: 1.8, min: 0.4, max: 8, step: 0.05, unit: 's' },
+    },
+    prepare: () => buildLanding(),
+    exit(u, out, a) {
+        const p = a.p, H = a.size.y, D = Number(p.duration);
+        out.pivot = 'bottom';
+        const crouch = Number(p.crouch);
+        const tau = clamp01((u - CROUCH_END) / (1 - CROUCH_END));
+        // crouch down, and spring out of it as the thrust takes over
+        const squash = crouch * (smooth(0, CROUCH_END, u) - smooth(CROUCH_END, CROUCH_END + 0.07, u));
+        const speed = tau * tau; // ∝ velocity of y = H t³
+        const sy = 1 - squash + Number(p.stretch) * Math.min(1, 3 * speed) * smooth(0, 0.25, tau);
+        stretch(out, sy, 1 - smooth(0.82, 1, tau)); // far up: it goes
+        out.off.copy(a.frame.up).multiplyScalar(Number(p.height) * H * tau * tau * tau);
+        out.q.copy(tremble(a, smooth(0, 0.15, tau), u * D));
+    },
+    enter(v, out, a) {
+        const p = a.p, H = a.size.y, D = Number(p.duration);
+        const st = Number(p.stretch), wob = Number(p.wobble) * Math.PI / 180;
+        out.pivot = 'bottom';
+        const secs = v * D;
+        if (v < TOUCH) {
+            const y = Number(p.height) * H * (1 - table(a.mem.drop, v));
+            const speed = speedAt(v);
+            // stretched by its speed while it falls; squashed by the braking (it keeps moving, the base stops it)
+            const sy = 1 + st * 0.8 * speed * (1 - smooth(FALL_END - 0.08, FALL_END + 0.08, v)) - st * 0.7 * table(a.mem.decel, v);
+            stretch(out, sy, smooth(0, 0.08, v));
+            out.off.copy(a.frame.up).multiplyScalar(y);
+            // comes in leaning; the burn rights it with a damped correction (overshoot, then upright by the hover)
+            const c = clamp01((v - FALL_END * 0.6) / (TOUCH - FALL_END * 0.6));
+            const lean = (0.12 + 2 * wob) * Math.exp(-4.5 * c) * Math.cos(2.6 * Math.PI * c) * (1 - smooth(0.7, 1, c));
+            // the thrust trembles during the burn, calms in the hover
+            const shake = smooth(FALL_END - 0.1, FALL_END, v) * (1 - 0.7 * smooth(BURN_END, TOUCH, v));
+            out.q.copy(tremble(a, shake, secs, lean));
+            return;
+        }
+        // touchdown: a small damped squash that rings out and lands exactly on rest
+        const sg = (v - TOUCH) / (1 - TOUCH);
+        const sy = 1 - Number(p.crouch) * 0.7 * Math.sin(2 * Math.PI * sg) * Math.exp(-3 * sg) * (1 - sg * sg);
+        stretch(out, sy, 1);
+        out.q.copy(tremble(a, 0.3 * (1 - sg) * (1 - sg), secs));
+    },
+});

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

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

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

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

package/dist/operations/catalogue/bounce.js

@@ -0,0 +1,34 @@
+// Bounce — real hops: a ballistic arc (it hangs at the top), a stretch on the way
+// up and down, and a volume-keeping squash on every landing, about the base.
+import { DURATION, heldPhysical } from './physicalHeld.js';
+/** Share of each hop spent on the ground, squashing. */
+const CONTACT = 0.2;
+export default heldPhysical({
+    value: 'bounce', label: 'Bounce',
+    description: 'Hop on the spot — a real arc with a squash on every landing',
+    params: {
+        height: { type: 'number', label: 'Height', default: 0.35, min: 0.02, max: 2, step: 0.01, hint: 'A fraction of the object’s height' },
+        speed: { type: 'number', label: 'Hops', default: 1.1, min: 0.2, max: 5, step: 0.05, unit: '/s' },
+        squash: { type: 'number', label: 'Squash', default: 0.16, min: 0, max: 0.5, step: 0.01 },
+        duration: { ...DURATION, default: 3 },
+    },
+    memory: () => null,
+    move(part, st, time) {
+        const p = st.p, a = st.amp.v;
+        const ph = (time * Number(p.speed)) % 1;
+        const sq = Number(p.squash) * a;
+        let y = 0, sy = 1;
+        if (ph < CONTACT) {
+            sy = 1 - sq * Math.sin(Math.PI * (ph / CONTACT));
+        }
+        else {
+            const v = (ph - CONTACT) / (1 - CONTACT);
+            y = 4 * v * (1 - v);
+            sy = 1 + sq * 0.55 * Math.abs(1 - 2 * v) * (1 - y * 0.6); // stretched while it moves fast
+        }
+        const sxz = 1 / Math.sqrt(sy);
+        part.s.set(sxz, sy, sxz);
+        part.off.set(0, y * st.body.size.y * Number(p.height) * a, 0);
+        part.pivot.copy(st.body.bottomLocal);
+    },
+});

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

@@ -1 +1 @@
-{"version":3,"file":"curlSmoke.d.ts","sourceRoot":"","sources":["../../../src/operations/catalogue/curlSmoke.ts"],"names":[],"mappings":";AAkDA,wBAwIG"}
+{"version":3,"file":"curlSmoke.d.ts","sourceRoot":"","sources":["../../../src/operations/catalogue/curlSmoke.ts"],"names":[],"mappings":";AAkDA,wBA0IG"}

package/dist/operations/catalogue/curlSmoke.js

@@ -14,7 +14,7 @@
 import { Color, Vector3 } from 'three';
 import { defineOperation } from '../types.js';
 import { addLayer, forEachMeshMaterial, removeLayer } from './shaderLayers.js';
-import { DIRECTION_OPTIONS, createFieldState, fieldGlsl, fieldUniforms, hideMeshes, runProgress, setFieldParams, surfaceLayer, } from './transitionField.js';
+import { DIRECTION_OPTIONS, createFieldState, fieldGlsl, fieldUniforms, hideMeshes, runProgress, setFieldParams, setReveal, surfaceLayer, } from './transitionField.js';
 import { sampleSurfaceCached } from './surfaceSample.js';
 import { GLSL_POINT_SIZE, createFxPoints, disposeFxPoints } from './fxPoints.js';
 const P = 'Smk';
@@ -56,6 +56,7 @@ export default defineOperation({
         disappear: { type: 'boolean', label: 'Disappear', default: true, hint: 'Off: the whole object becomes smoke in its own shape and stays' },
     },
     objectParams: { disappear: false },
+    presence: 'paint',
     apply(target, p, ctx) {
         let st = target.userData[STATE];
         if (!st) {
@@ -163,6 +164,7 @@ export default defineOperation({
         if (!s)
             return;
         hideMeshes(target, KEY, false);
+        setReveal(s.field, p);
         s.points.visible = true;
         // same speed back, from wherever it got to
         const span = s.keep.value ? 1 / KEEP_SPEED : END;

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

@@ -1 +1 @@
-{"version":3,"file":"dissolve.d.ts","sourceRoot":"","sources":["../../../src/operations/catalogue/dissolve.ts"],"names":[],"mappings":";AAcA,wBA2CG"}
+{"version":3,"file":"dissolve.d.ts","sourceRoot":"","sources":["../../../src/operations/catalogue/dissolve.ts"],"names":[],"mappings":";AAcA,wBA4CG"}

package/dist/operations/catalogue/dissolve.js

@@ -15,7 +15,8 @@ export default defineOperation({
     channel: 'visual',
     multi: true,
     toggles: true,
-    usableIn: ['interaction', 'action'],
+    usableIn: ['interaction', 'action', 'object'],
+    presence: 'vanish',
     params: {
         direction: { type: 'select', label: 'Direction', default: 'noise', options: DIRECTION_OPTIONS },
         edgeColor: { type: 'color', label: 'Edge colour', default: '#ff7a2e' },

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"driftUp.d.ts","sourceRoot":"","sources":["../../../src/operations/catalogue/driftUp.ts"],"names":[],"mappings":";AA+BA,wBA6BG"}

package/dist/operations/catalogue/driftUp.js

@@ -0,0 +1,57 @@
+// Drift up — the object turns light, like a balloon let go. Buoyancy lifts it
+// gently and keeps accelerating it (height ∝ t² after a soft start), calm
+// low-frequency wind pushes it sideways, it leans the way it drifts and sways
+// like something hanging from a lift point above it, turning slowly as it goes.
+// The way back: it sinks down from above, slowing, the sway dying away, and
+// settles with a small bob.
+import { Quaternion, Vector3 } from 'three';
+import { clamp01, physicalExit, ring, smooth } from './physicalExit.js';
+const _r = new Quaternion(), _p = new Quaternion(), _y = new Quaternion(), _d = new Vector3();
+/** Calm wind: two slow sines per ground axis, as a fraction of the drift (0 at t = 0). */
+function wind(t) {
+    const x = 0.7 * Math.sin(1.9 * t + 0.4) + 0.3 * Math.sin(3.7 * t + 2.0) - (0.7 * Math.sin(0.4) + 0.3 * Math.sin(2.0));
+    const z = 0.6 * Math.sin(1.3 * t + 1.7) + 0.4 * Math.sin(3.1 * t + 0.2) - (0.6 * Math.sin(1.7) + 0.4 * Math.sin(0.2));
+    return [x, z];
+}
+function pose(out, a, y, drift, t, sway, yaw, lean) {
+    const f = a.frame, span = a.span;
+    const [wx, wz] = wind(t);
+    _d.set(0, 0, 0).addScaledVector(f.right, wx).addScaledVector(f.toward, wz);
+    out.off.copy(_d).multiplyScalar(drift * span).addScaledVector(f.up, y);
+    // leans into its drift (the lift point leads), plus a pendulum sway about the screen axes
+    const sw = sway * Math.sin(2 * Math.PI * 0.55 * t * 1.6);
+    _r.setFromAxisAngle(f.toward, -lean * wx + sw);
+    _p.setFromAxisAngle(f.right, lean * wz + 0.6 * sw * Math.cos(2 * Math.PI * 0.37 * t));
+    _y.setFromAxisAngle(f.up, yaw);
+    out.q.copy(a.local(_r.multiply(_p).multiply(_y)));
+}
+export default physicalExit({
+    value: 'driftUp',
+    label: 'Drift up',
+    description: 'Lifts away like a balloon let go — rising faster and faster, drifting and swaying in a calm wind; it sinks back down and settles with a bob',
+    params: {
+        rise: { type: 'number', label: 'Rise', default: 7, min: 2, max: 30, step: 0.5, hint: 'How high it floats before it is gone, × its height' },
+        drift: { type: 'number', label: 'Drift', default: 0.6, min: 0, max: 4, step: 0.05, hint: 'Sideways wander in the wind, × its size' },
+        sway: { type: 'number', label: 'Sway', default: 6, min: 0, max: 25, step: 0.5, unit: '°' },
+        duration: { type: 'number', label: 'Duration', default: 3.2, min: 0.6, max: 12, step: 0.05, unit: 's' },
+    },
+    exit(u, out, a) {
+        const p = a.p, H = a.size.y, D = Number(p.duration);
+        const e = smooth(0, 0.25, u); // it lets go gently
+        const y = Number(p.rise) * H * u * u * (0.35 + 0.65 * u);
+        const sway = (Number(p.sway) * Math.PI / 180) * e;
+        pose(out, a, y, Number(p.drift) * u * u, u * D, sway, 0.6 * Math.PI * u * u, 0.25 * e);
+        out.s.setScalar(1 - smooth(0.72, 1, u));
+    },
+    enter(v, out, a) {
+        const p = a.p, H = a.size.y, D = Number(p.duration);
+        const left = 1 - v;
+        // sinks in from above, slowing; the last stretch is a damped bob about rest
+        const sink = 3.2 * H * Math.pow(left, 2.4);
+        const bob = 0.035 * H * ring(clamp01((v - 0.62) / 0.38), 1.5, 2.6);
+        const die = Math.pow(left, 1.4);
+        const sway = (Number(p.sway) * Math.PI / 180) * die;
+        pose(out, a, sink - bob, Number(p.drift) * 0.5 * left * left, -left * D, sway, -0.4 * Math.PI * left * left, 0.25 * die);
+        out.s.setScalar(smooth(0, 0.18, v));
+    },
+});

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

@@ -1 +1 @@
-{"version":3,"file":"emberAsh.d.ts","sourceRoot":"","sources":["../../../src/operations/catalogue/emberAsh.ts"],"names":[],"mappings":";AAoFA,wBA0FG"}
+{"version":3,"file":"emberAsh.d.ts","sourceRoot":"","sources":["../../../src/operations/catalogue/emberAsh.ts"],"names":[],"mappings":";AAoFA,wBA2FG"}

package/dist/operations/catalogue/emberAsh.js

@@ -78,7 +78,8 @@ export default defineOperation({
     channel: 'visual',
     multi: true,
     toggles: true,
-    usableIn: ['interaction', 'action'],
+    usableIn: ['interaction', 'action', 'object'],
+    presence: 'vanish',
     params: {
         direction: { type: 'select', label: 'Burn direction', default: 'up', options: DIRECTION_OPTIONS },
         wind: { type: 'select', label: 'Wind', default: 'left', options: [{ value: 'left', label: 'Left → right' }, { value: 'right', label: 'Right → left' }, { value: 'up', label: 'Rising' }] },

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

@@ -1 +1 @@
-{"version":3,"file":"flip.d.ts","sourceRoot":"","sources":["../../../src/operations/catalogue/flip.ts"],"names":[],"mappings":";AAaA,wBAoDG"}
+{"version":3,"file":"flip.d.ts","sourceRoot":"","sources":["../../../src/operations/catalogue/flip.ts"],"names":[],"mappings":";AAaA,wBA6DG"}

package/dist/operations/catalogue/flip.js

@@ -16,7 +16,7 @@ export default defineOperation({
     channel: 'transform',
     multi: true,
     toggles: false,
-    usableIn: ['interaction', 'action'],
+    usableIn: ['interaction', 'action', 'object'],
     params: {
         axis: { type: 'select', label: 'Flip', default: 'x', options: [{ value: 'x', label: 'Forward (X)' }, { value: 'z', label: 'Sideways (Z)' }, { value: 'y', label: 'Twist (Y)' }] },
         height: { type: 'number', label: 'Jump height', default: 0.45, min: 0.1, max: 4, step: 0.05, hint: 'A fraction of the object’s own height' },
@@ -27,10 +27,12 @@ export default defineOperation({
         const running = target.userData[KEY];
         if (running) {
             gsap.killTweensOf(running.proxy);
-            releaseRest(target);
+            releaseRest(target, KEY);
         }
-        const rest = acquireRest(target);
-        const proxy = { u: 0 };
+        const rest = acquireRest(target, KEY);
+        // p.__backward (playback: reverse / yoyo) plays the same move backwards in time.
+        const back = p.__backward === true;
+        const proxy = { u: back ? 1 : 0 };
         target.userData[KEY] = { proxy };
         const axis = AXES[String(p.axis)] ?? AXES.x;
         const dir = p.reverse ? -1 : 1;
@@ -38,7 +40,7 @@ export default defineOperation({
         const q = new Quaternion(), s = new Vector3(), off = new Vector3();
         const CROUCH = 0.18, LAND = 0.82;
         gsap.to(proxy, {
-            u: 1, duration: Number(p.duration), ease: 'none',
+            u: back ? 0 : 1, duration: Number(p.duration), ease: 'none',
             onUpdate: () => {
                 const u = proxy.u;
                 if (u < CROUCH) {
@@ -46,24 +48,32 @@ export default defineOperation({
                     const v = u / CROUCH;
                     const sy = 1 - 0.16 * Math.sin(Math.PI * v);
                     const sxz = 1 / Math.sqrt(sy);
-                    poseAbout(target, rest, rest.bottomLocal, NO_TURN, s.set(sxz, sy, sxz));
+                    poseAbout(target, rest, rest.bottomLocal, NO_TURN, s.set(sxz, sy, sxz), undefined, KEY);
                 }
                 else if (u < LAND) {
                     // ballistic hop + a full turn about the centre, eased so it hangs at the top
                     const v = (u - CROUCH) / (LAND - CROUCH);
                     off.set(0, 4 * h * v * (1 - v), 0);
                     q.setFromAxisAngle(axis, dir * 2 * Math.PI * smooth(v));
-                    poseAbout(target, rest, rest.centerLocal, q, s.set(1, 1, 1), off);
+                    poseAbout(target, rest, rest.centerLocal, q, s.set(1, 1, 1), off, KEY);
                 }
                 else {
                     // landing: squash that rings out once
                     const v = (u - LAND) / (1 - LAND);
                     const sy = 1 - 0.14 * Math.sin(Math.PI * v) * (1 - v * 0.4);
                     const sxz = 1 / Math.sqrt(sy);
-                    poseAbout(target, rest, rest.bottomLocal, NO_TURN, s.set(sxz, sy, sxz));
+                    poseAbout(target, rest, rest.bottomLocal, NO_TURN, s.set(sxz, sy, sxz), undefined, KEY);
                 }
             },
-            onComplete: () => { delete target.userData[KEY]; releaseRest(target); },
+            onComplete: () => { delete target.userData[KEY]; releaseRest(target, KEY); },
         });
     },
+    cancel(target) {
+        const running = target.userData[KEY];
+        if (!running)
+            return;
+        gsap.killTweensOf(running.proxy);
+        delete target.userData[KEY];
+        releaseRest(target, KEY);
+    },
 });

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

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

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

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

package/dist/operations/catalogue/float.js

@@ -0,0 +1,39 @@
+// Float — the object hovers. Three sines at ratios that never line up (1, φ, e)
+// make a bob that does not visibly repeat; it drifts a little sideways on slower
+// ones and banks into that drift, the way something light hangs in the air.
+import { Quaternion, Vector3 } from 'three';
+import { DURATION, heldPhysical } from './physicalHeld.js';
+const X = new Vector3(1, 0, 0), Z = new Vector3(0, 0, 1);
+const _q = new Quaternion();
+export default heldPhysical({
+    value: 'float', label: 'Float',
+    description: 'Hover in the air — a soft bob that never quite repeats, drifting and banking a little',
+    params: {
+        height: { type: 'number', label: 'Bob', default: 0.08, min: 0, max: 0.6, step: 0.005, hint: 'Up and down, as a fraction of the object’s height' },
+        drift: { type: 'number', label: 'Drift', default: 0.04, min: 0, max: 0.5, step: 0.005, hint: 'Sideways wander, as a fraction of its height' },
+        tilt: { type: 'number', label: 'Bank', default: 5, min: 0, max: 30, step: 0.5, unit: '°', hint: 'How much it leans into its drift' },
+        speed: { type: 'number', label: 'Speed', default: 1, min: 0.1, max: 5, step: 0.05, unit: '×' },
+        duration: { ...DURATION, default: 4 },
+    },
+    memory: () => ({ px: 0, pz: 0 }),
+    move(part, st, time, dt) {
+        const p = st.p, a = st.amp.v, H = st.body.size.y;
+        const w = 2 * Math.PI * 0.32 * Number(p.speed) * time;
+        const bob = 0.62 * Math.sin(w) + 0.28 * Math.sin(1.618 * w + 1.3) + 0.1 * Math.sin(2.718 * w + 4.1);
+        const dx = 0.7 * Math.sin(0.41 * w + 0.5) + 0.3 * Math.sin(0.93 * w + 2.2);
+        const dz = 0.7 * Math.sin(0.33 * w + 3.9) + 0.3 * Math.sin(0.77 * w + 0.4);
+        const D = H * Number(p.drift) * a;
+        part.off.set(dx * D, bob * H * Number(p.height) * a, dz * D);
+        // bank by the drift's own speed (finite difference, smoothed)
+        const k = dt > 0 ? Math.min(1, dt * 6) : 0;
+        const vx = dt > 0 ? (dx - st.mem.px) / dt : 0, vz = dt > 0 ? (dz - st.mem.pz) / dt : 0;
+        st.mem.px = dx;
+        st.mem.pz = dz;
+        const lean = (Number(p.tilt) * Math.PI / 180) * a;
+        const m = st.mem;
+        m.lx = (m.lx ?? 0) + (Math.max(-1, Math.min(1, vx * 0.9)) - (m.lx ?? 0)) * k;
+        m.lz = (m.lz ?? 0) + (Math.max(-1, Math.min(1, vz * 0.9)) - (m.lz ?? 0)) * k;
+        part.q.setFromAxisAngle(Z, -m.lx * lean).multiply(_q.setFromAxisAngle(X, m.lz * lean));
+        part.pivot.copy(st.body.centerLocal);
+    },
+});

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"flyBy.d.ts","sourceRoot":"","sources":["../../../src/operations/catalogue/flyBy.ts"],"names":[],"mappings":";AA+CA,wBAkCG"}

package/dist/operations/catalogue/flyBy.js

@@ -0,0 +1,79 @@
+// Fly-by — the object takes off and flies past the camera. It lifts, banks into
+// a turn and sweeps towards the viewer on a cubic Bézier, rolling into the curve
+// (bank follows the path's sideways acceleration) and yawing to its heading, and
+// passes just beside the lens. The way back: it comes in from behind the camera
+// on the other side, banks round and sets down in place, the roll easing out.
+import { Quaternion, Vector3 } from 'three';
+import { clamp01, physicalExit, ring, smooth } from './physicalExit.js';
+const _p0 = new Vector3(), _p1 = new Vector3(), _p2 = new Vector3(), _p3 = new Vector3();
+const _a = new Vector3(), _vel = new Vector3(), _acc = new Vector3(), _side = new Vector3();
+const _r = new Quaternion(), _y = new Quaternion();
+/** The flight path from the object (0) to just beside the camera (1), on `side` (±1 along screen right). */
+function path(a, side) {
+    const f = a.frame, H = a.size.y, span = a.span;
+    const cam = f.camera ?? _a.copy(f.toward).multiplyScalar(14 * span).addScaledVector(f.up, 1.5 * H);
+    const lift = Number(a.p.lift) * H;
+    _p0.set(0, 0, 0);
+    _p1.copy(f.up).multiplyScalar(lift * 1.4); // straight up off the ground
+    _p2.copy(cam).multiplyScalar(0.45).addScaledVector(f.right, side * 2.2 * span).addScaledVector(f.up, lift);
+    _p3.copy(cam).multiplyScalar(1.12).addScaledVector(f.right, side * 1.4 * span); // just past the lens, to the side
+}
+function bez(t, out, d = 0) {
+    const m = 1 - t;
+    if (d === 0)
+        return out.set(0, 0, 0).addScaledVector(_p0, m * m * m).addScaledVector(_p1, 3 * m * m * t).addScaledVector(_p2, 3 * m * t * t).addScaledVector(_p3, t * t * t);
+    if (d === 1)
+        return out.set(0, 0, 0).addScaledVector(_p1.clone().sub(_p0), 3 * m * m).addScaledVector(_p2.clone().sub(_p1), 6 * m * t).addScaledVector(_p3.clone().sub(_p2), 3 * t * t);
+    return out.set(0, 0, 0).addScaledVector(_p2.clone().sub(_p1.clone().multiplyScalar(2)).add(_p0), 6 * m).addScaledVector(_p3.clone().sub(_p2.clone().multiplyScalar(2)).add(_p1), 6 * t);
+}
+/** Bank into the curve: roll about the heading by the sideways acceleration, yaw towards the heading. */
+function attitude(a, t, amount, yawAmount) {
+    const f = a.frame;
+    bez(t, _vel, 1);
+    bez(t, _acc, 2);
+    const flat = _vel.clone().addScaledVector(f.up, -_vel.dot(f.up));
+    const heading = flat.lengthSq() > 1e-8 ? flat.normalize() : f.toward.clone();
+    _side.crossVectors(f.up, heading);
+    const lateral = _acc.dot(_side) / Math.max(1e-6, _vel.lengthSq());
+    const bank = (Number(a.p.bank) * Math.PI / 180) * Math.max(-1, Math.min(1, lateral * a.span * 1.2)) * amount;
+    const yaw = Math.atan2(heading.dot(f.right), heading.dot(f.toward)) * yawAmount;
+    _r.setFromAxisAngle(heading, -bank);
+    _y.setFromAxisAngle(f.up, yaw);
+    return a.local(_r.multiply(_y));
+}
+const sideOf = (a) => (a.p.side === 'left' ? -1 : 1);
+export default physicalExit({
+    value: 'flyBy',
+    label: 'Fly-by',
+    description: 'Takes off, banks and flies past the camera — it comes back from behind the camera on the other side and sets down in place',
+    params: {
+        side: {
+            type: 'select', label: 'Passes on the', default: 'right', options: [{ value: 'right', label: 'Right' }, { value: 'left', label: 'Left' }],
+            hint: 'The camera side it flies past',
+        },
+        bank: { type: 'number', label: 'Bank', default: 35, min: 0, max: 80, step: 1, unit: '°', hint: 'How hard it rolls into the turn' },
+        lift: { type: 'number', label: 'Climb', default: 0.8, min: 0, max: 4, step: 0.05, hint: 'How high it climbs first, × its height' },
+        duration: { type: 'number', label: 'Duration', default: 2.2, min: 0.5, max: 8, step: 0.05, unit: 's' },
+    },
+    exit(u, out, a) {
+        path(a, sideOf(a));
+        // takes off slowly, then accelerates along the path
+        const t = u * u * (0.4 + 0.6 * u);
+        bez(t, out.off);
+        const e = smooth(0, 0.2, u);
+        out.q.copy(attitude(a, Math.max(t, 0.02), e, e * 0.6));
+        out.s.setScalar(1 - smooth(0.9, 1, u)); // behind the lens: gone
+    },
+    enter(v, out, a) {
+        path(a, -sideOf(a));
+        // the same kind of path flown backwards: in from beside the lens, slowing down to set down
+        const left = 1 - v;
+        const t = Math.pow(left, 1.8);
+        bez(t, out.off);
+        // a soft touchdown bob in the last bit
+        out.off.addScaledVector(a.frame.up, -0.03 * a.size.y * ring(clamp01((v - 0.8) / 0.2), 1, 2.5));
+        const e = 1 - smooth(0.7, 1, v);
+        out.q.copy(attitude(a, Math.max(t, 0.02), e, e * 0.6));
+        out.s.setScalar(smooth(0, 0.08, v));
+    },
+});

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

@@ -1 +1 @@
-{"version":3,"file":"frost.d.ts","sourceRoot":"","sources":["../../../src/operations/catalogue/frost.ts"],"names":[],"mappings":";AAoEA,wBA4CG"}
+{"version":3,"file":"frost.d.ts","sourceRoot":"","sources":["../../../src/operations/catalogue/frost.ts"],"names":[],"mappings":";AAwEA,wBA+CG"}

package/dist/operations/catalogue/frost.js

@@ -7,7 +7,7 @@
 import { Color } from 'three';
 import { defineOperation } from '../types.js';
 import { GLSL_WORLEY, addLayer, forEachMeshMaterial, removeLayer } from './shaderLayers.js';
-import { DIRECTION_OPTIONS, createFieldState, fieldGlsl, fieldUniforms, runProgress, setFieldParams } from './transitionField.js';
+import { DIRECTION_OPTIONS, createFieldState, fieldGlsl, fieldUniforms, goneGlsl, runProgress, setFieldParams, setReveal } from './transitionField.js';
 const P = 'Frs';
 const KEY = 'frost';
 const STATE = '__opFrost';
@@ -23,7 +23,7 @@ function layerFor(st) {
     `;
     return {
         uniforms: { ...fieldUniforms(P, st.field), uFrsIce: st.ice, uFrsDensity: st.density },
-        common: `varying vec3 vFrsQ;\nvarying vec3 vFrsR;\nvarying vec3 vFrsView;\n${fieldGlsl(P)}\n${GLSL_WORLEY}`,
+        common: `varying vec3 vFrsQ;\nvarying vec3 vFrsR;\nvarying vec3 vFrsView;\n${fieldGlsl(P)}\n${goneGlsl(P)}\n${GLSL_WORLEY}`,
         fragmentPars: 'float frsFr = 0.0; vec3 frsCell = vec3(1.0); float frsSeam = 0.0;',
         vertex: /* glsl */ `
         vFrsR = (uFrsRootInv * modelMatrix * vec4(transformed, 1.0)).xyz;
@@ -31,7 +31,11 @@ function layerFor(st) {
         vFrsView = (modelViewMatrix * vec4(transformed, 1.0)).xyz;`,
         diffuse: /* glsl */ `
         {
-          frsFr = smoothstep(0.0, uFrsEdgeWidth, FrsThreshold() - FrsField(vFrsQ));
+          float frsD = FrsThreshold() - FrsField(vFrsQ);
+          frsFr = smoothstep(0.0, uFrsEdgeWidth, frsD);
+          // revealed by the ice: nothing ahead of the front, solid ice right behind it
+          if (uFrsReveal > 0.5) { if (frsD < 0.0) discard; frsFr = 1.0; }
+          frsFr *= 1.0 - FrsGone(vFrsQ);                     // wiped by the look that replaces it
           frsCell = fxWorley(vFrsR * (uFrsDensity / uFrsExtent));
           frsSeam = 1.0 - smoothstep(0.0, 0.09, frsCell.y - frsCell.x);
           ${frozen}
@@ -70,6 +74,8 @@ export default defineOperation({
     toggles: true,
     usableIn: ['interaction', 'action', 'object'],
     stack: 'surface',
+    presence: 'paint',
+    field: (target) => target.userData[STATE]?.field,
     params: {
         direction: { type: 'select', label: 'Direction', default: 'up', options: DIRECTION_OPTIONS },
         ice: { type: 'color', label: 'Ice', default: '#bfe4ff' },
@@ -103,6 +109,7 @@ export default defineOperation({
         const s = target.userData[STATE];
         if (!s)
             return;
+        setReveal(s.field, p);
         return runProgress(target, s.field, 0, {
             duration: Number(p.duration), ease: 'power1.in',
             onComplete: () => { s.mats.forEach(m => removeLayer(m, KEY)); delete target.userData[STATE]; },

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

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

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

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