@solidrt/3d 0.0.71 → 0.0.72

package/AGENTS.md

@@ -301,7 +301,10 @@ shadow })`, `setLight`) makes the scene own an internal
 `createView({ depth: "texture", overrideMaterial: depth pass })` drawing
 the `castShadow` meshes (`<Mesh castShadow>`, `setCastShadow`) from an
 orthographic camera at the light's WORLD position along its world
-direction, `shadow.camera` (+-5, 0.5..500 by default) as the frustum.
+direction, `shadow.camera` (+-5, 0.5..500 by default) as the frustum,
+re-placed whenever the light's world matrix moves - by a JS write or
+by native motion (a transition on the light or an ancestor, a clip
+player), in the frame the lighting moves.
 Any light may cast, bounded by the shadow-slot budget
 (`MAX_SHADOW_MAPS` = 8, its own constant, exported from the root and
 `/glsl` with `MAX_LIGHTS` and `MAX_CASCADES`: a directional light claims
@@ -382,7 +385,18 @@ RETARGETED motion is native: `setTransition(node, { position:
 animates toward every frame (position/scale per lane, rotation along
 the quaternion geodesic - a spring keeps its velocity through
 retargets), so a mesh gliding to a slot or a camera rig easing costs
-one JS write per target change, zero per frame. The declaration lives
+one JS write per target change, zero per frame - for the mesh, its
+lighting and its shadow alike (a casting light on a transitioned group
+re-places its shadow cameras in the scene's sync, which runs every
+frame). One rule for every native mover, transitions and clip players
+both: the core steps running motion BEFORE the frame's callbacks and
+starts what they declared (an enter from its `from`, an exit) AFTER
+them and their flush - Unity's animation update between Update and
+LateUpdate - so `worldPosition`, `getTransform` and a late-pass follow
+read the pose the frame draws (a node created in a frame's callback
+reads its created pose there and its `from` from the late pass on),
+and a raw `setTransform` made in the frame wins that frame (the next
+step overwrites it again - the producer rule, last write wins). The declaration lives
 on the SceneNode and re-applies on every scene enter; the pose a node
 enters with snaps, unless a component's `from` (`position: { duration,
 from: [x, y, z] }`, a quaternion for `rotation`) animates it in from
@@ -418,6 +432,27 @@ a cancel, snap, leave or exit; the raw "spatialTransitionEnd" engine
 event (sol:events, carrying the CORE node id `_node`) stays for
 flux:spatial consumers.
 
+PAUSE and time scale are a node declaration too: `setTimeScale(node,
+scale)` / the `timeScale` prop sets the rate the native motion under the
+node runs at - transitions with their delays, enters, exits and stagger
+slots, morph weight tracks, and the clip players of the models under it
+(a mixer's players are clocked on their model's node, so this is Three's
+`mixer.timeScale` as well). 0 freezes, 1 is app time, 0.5 is slow
+motion; `scene.setTimeScale` / `<Scene timeScale>` declares it on
+`scene.root`, the whole-world pause. The NEAREST declaring ancestor
+wins, never a product (Godot's process_mode shape): a world at 0 with a
+`<Group timeScale={1}>` inside keeps that group running - the spinning
+preview on a pause screen, which a product could not express. A frozen
+scene asks for no frames (the loop idles; the write that resumes it
+brings the frame), writes while frozen behave as always (undeclared
+components snap, declared ones retarget and wait), a `destroy` with an
+`exit` stays a ghost until its time moves again (a scene `dispose`
+still cuts it short), and a node created frozen sits at its `from`. The
+scale covers the CORE's motion only: your own `onFrame` logic, timers,
+video and audio stay on app time - gate them yourself, multiplying your
+step by `timeRate(node)` / `scene.timeRate()`, the effective rate read.
+The dev clock (`/clock?scale=`) scales app time underneath all of this.
+
 ### Geometry layout, indices and topology
 
 One interleaved vertex buffer per geometry, described by an open layout
@@ -1098,11 +1133,14 @@ the root as it crosses meshes; a drag from a mesh keeps naming it, with
 `point`/`distance` null while the ray misses it). Enter/leave fire on
 the struck node alone - a group never receives them - while the root
 sees every move, so "hovering empty space" is a root move with `mesh`
-null. Taps are synthesized by the dispatch (DOM click, Unity's click
-handler): `onTap` fires after the up when the press released on the
-target it pressed within the slop (8 window px, core's recognizer slop,
-so a press is never both a tap and a drag), was the only pointer down
-for its whole press (a pinch never taps), with `tapCount` counting
+null. Taps are synthesized by the dispatch, as DOM click (Unity's click
+handler fires for every button; ours, like DOM's, for the primary alone):
+`onTap` fires after the up when a PRIMARY-button press (a right click
+walks its down and up with `button` 2 but never taps, like core's press;
+read `button` on the down to act on it) released on the target it
+pressed within the slop (8 window px, core's recognizer slop, so a press
+is never both a tap and a drag), was the only pointer down for its whole
+press (a pinch never taps), with `tapCount` counting
 repeats within 300 ms and 20 px on the same target (a double tap is
 `tapCount === 2`); a release on another instance of the same mesh is no
 tap. Wheel walks like a move with `deltaX/deltaY` (a node stopping it
@@ -1322,7 +1360,7 @@ uint16/uint32 indices by vertex count automatically.
 
 #### unlit
 
-`unlit({ color?, map?, vertexColors?, transparent?, blend?, cull?, alphaTest?, fog? })` -
+`unlit({ color?, map?, vertexColors?, transparent?, blend?, cull?, alphaTest?, fog?, prelude?, surface? })` -
 straight `[r, g, b, a?]` 0..1 sRGB (decoded to linear light, see Color
 below), premultiplied internally; `vertexColors: true` multiplies by the
 "colored" layout's aColor (the geometry must carry it: withColors, a
@@ -1331,12 +1369,16 @@ gridHelper or axesHelper); `blend` the factors of a transparent draw,
 `transparent` unless told `transparent: false`, the shaderMaterial
 rule); `cull` and
 `alphaTest` as on phong (a mapped cutout casts its cutout); `fog: false`
-opts out of the scene's fog (all four library materials take it).
+opts out of the scene's fog (all four library materials take it);
+`prelude`/`surface` the tier-2 slot every stock material takes (Custom
+looks below): `void surface(inout Surface s)` called with the base
+resolved, `s.base` the only field the unlit program reads back, a
+discard casting through the shadow twin like phong's.
 
 #### sprite
 
 `sprite({ color?, map?, transparent?, blend?, billboard?, shape?,
-falloff?, minScreenPx?, maxScreenPx? })` - unlit on a quad
+falloff?, minScreenPx?, maxScreenPx?, prelude?, surface? })` - unlit on a quad
 that turns to face the camera IN THE VERTEX STAGE (off the shared
 uCamRight/uCamUp, or uCamPos for `billboard: "fixed-y"`, which yaws
 only and stays upright on world y - Godot's BILLBOARD_FIXED_Y, the
@@ -1996,7 +2038,14 @@ same constants - customizing never means leaving the system.
 
 A custom look is a citizen of the scene - lit by its lights, shadowed
 and fogged like the stock materials, exposed and tone mapped by the same
-resolve - at one of three tiers, top first:
+resolve - at one of three tiers, top first. The same three tiers, the
+same words (`unlit`, `prelude`/`surface`, `shaderMaterialClass`,
+`instanceBuffers`/`instanceStyle`/`setInstanceStyle`) are
+`@solidrt/2d`'s, where the material sits on the LAYER (the layer is the
+batch, as the mesh is the draw entry here); the one deliberate
+asymmetry is that a 3d `blend` implies `transparent` and the scene's
+back-to-front sort, while a 2d layer has no depth and draws in record
+order (okf/plans/materials-one-model.md).
 
 1. STANDARD FRAGMENT, CUSTOM VERTEX. Any vertex stage that writes the lit
    varyings (vWorldPos, vNormal, vUv, plus vColor with `vertexColors`,
@@ -2014,7 +2063,10 @@ resolve - at one of three tiers, top first:
    is the white starting point (the stock materials seed exactly this
    from their `color` option).
 2. A SURFACE FUNCTION inside the stock material. `phong({ ..., prelude,
-   surface })` / `standard({ ..., prelude, surface })`: every other
+   surface })` / `standard({ ..., prelude, surface })`, and the same two
+   slots on `unlit` and `sprite` (the unlit program shades nothing, so
+   `s.base` is the one field read back, after the cutout and the
+   sprite's radial falloff): every other
    option seeds as usual (`color`, the maps, metalness and roughness),
    `prelude` is file scope (uniforms and helpers; a uniform it declares
    is an ordinary per-entry param, `params` on the mesh or
@@ -2616,7 +2668,11 @@ sample, weight-blend and write joint TRS natively each frame, so a
 playing character costs zero JS per frame (gate other work on
 `mixer.playing()`). play() requires the model to be IN a scene (players
 bind live arena nodes; removing the model drops them - a re-added model
-plays again from play()). Three traps that follow from core ownership:
+plays again from play()). The players run on the model node's time:
+`setTimeScale(model, 0)` (or on any ancestor, the scene root included)
+pauses every clip and crossfade of the model where it stands and resumes
+it from there - Three's `mixer.timeScale`, Unity's `Animator.speed`
+under `Time.timeScale` (see Retargeted motion). Three traps that follow from core ownership:
 (1) players advance BEFORE your onFrame, which is therefore the
 post-animation hook - read a freshly posed joint and overwrite it
 (root-motion strips, skeleton copies) in plain setTransform, last write

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidrt/3d",
-  "version": "0.0.71",
+  "version": "0.0.72",
   "license": "MIT",
   "funding": "https://github.com/sponsors/wellawaretech",
   "author": "Antoine van Wel",
@@ -20,10 +20,10 @@
     "AGENTS.md"
   ],
   "devDependencies": {
-    "@solidrt/test": "0.0.71"
+    "@solidrt/test": "0.0.72"
   },
   "peerDependencies": {
     "@solidjs/signals": "2.0.0-rc.13",
-    "@solidrt/core": "0.0.71"
+    "@solidrt/core": "0.0.72"
   }
 }

package/src/components/directional-light.tsx

@@ -1,4 +1,4 @@
-import { createEffect, onCleanup, untrack, useContext } from "@solidrt/core"
+import { callRef, createEffect, onCleanup, untrack, useContext } from "@solidrt/core"
 import type { VoidComponent } from "@solidrt/core"
 import { SceneContext } from "./context.tsx"
 import { syncNode } from "./node-props.ts"
@@ -46,7 +46,7 @@ export let DirectionalLight: VoidComponent<DirectionalLightProps> = props => {
     () => [props.direction, props.color, props.intensity, props.layers, props.castShadow, props.shadow] as const,
     ([direction, color, intensity, layers, castShadow, shadow]) => setLight(light, { direction, color, intensity, layers, castShadow, shadow }),
   )
-  untrack(() => props.ref)?.(light)
+  callRef(() => props.ref, light)
   onCleanup(() => destroy(light))
   return null
 }

package/src/components/first-person-camera.tsx

@@ -1,4 +1,4 @@
-import { createEffect, merge, onFrame, untrack, useContext } from "@solidrt/core"
+import { callRef, createEffect, merge, onFrame, untrack, useContext } from "@solidrt/core"
 import type { InputMap, VoidComponent } from "@solidrt/core"
 import { SceneContext } from "./context.tsx"
 import { createFirstPersonCamera } from "../first-person.ts"
@@ -67,6 +67,6 @@ export let FirstPersonCamera: VoidComponent<FirstPersonCameraProps> = props => {
     () => untrack(() => camera.set({})),
     { defer: true },
   )
-  untrack(() => props.ref)?.(camera)
+  callRef(() => props.ref, camera)
   return null
 }

package/src/components/group.tsx

@@ -1,4 +1,4 @@
-import { onCleanup, untrack, useContext } from "@solidrt/core"
+import { callRef, onCleanup, useContext } from "@solidrt/core"
 import type { ParentComponent } from "@solidrt/core"
 import { SceneContext, provide } from "./context.tsx"
 import { syncNode } from "./node-props.ts"
@@ -16,7 +16,7 @@ export let Group: ParentComponent<GroupProps> = props => {
   let node = createGroup()
   add(ctx.parent, node)
   syncNode(node, props)
-  untrack(() => props.ref)?.(node)
+  callRef(() => props.ref, node)
   onCleanup(() => destroy(node))
   return provide(ctx, node, props)
 }

package/src/components/hemisphere-light.tsx

@@ -1,4 +1,4 @@
-import { createEffect, onCleanup, untrack, useContext } from "@solidrt/core"
+import { callRef, createEffect, onCleanup, untrack, useContext } from "@solidrt/core"
 import type { VoidComponent } from "@solidrt/core"
 import { SceneContext } from "./context.tsx"
 import { add, destroy } from "../node.ts"
@@ -26,7 +26,7 @@ export let HemisphereLight: VoidComponent<HemisphereLightProps> = props => {
     () => [props.sky, props.ground, props.intensity, props.layers] as const,
     ([sky, ground, intensity, layers]) => setLight(light, { sky, ground, intensity, layers }),
   )
-  untrack(() => props.ref)?.(light)
+  callRef(() => props.ref, light)
   onCleanup(() => destroy(light))
   return null
 }

package/src/components/instanced-mesh.tsx

@@ -1,4 +1,4 @@
-import { createContext, createEffect, onCleanup, untrack, useContext } from "@solidrt/core"
+import { callRef, createContext, createEffect, onCleanup, untrack, useContext } from "@solidrt/core"
 import type { ParentComponent } from "@solidrt/core"
 import { SceneContext, provide } from "./context.tsx"
 import { syncNode } from "./node-props.ts"
@@ -80,7 +80,7 @@ export let InstancedMesh: ParentComponent<InstancedMeshProps> = props => {
     c => setCastShadow(mesh, c === true),
   )
   syncMesh(mesh, props)
-  untrack(() => props.ref)?.(mesh)
+  callRef(() => props.ref, mesh)
   onCleanup(() => {
     destroy(mesh)
     disposeInstances(mesh)
@@ -140,7 +140,7 @@ export let Instance: ParentComponent<InstanceProps> = props => {
       if (w !== undefined) setMorphWeights(instance, w)
     },
   )
-  untrack(() => props.ref)?.(instance)
+  callRef(() => props.ref, instance)
   onCleanup(() => destroy(instance))
   return provide(ctx, instance, props)
 }

package/src/components/lod.tsx

@@ -1,4 +1,4 @@
-import { createEffect, onCleanup, untrack, useContext } from "@solidrt/core"
+import { callRef, createEffect, onCleanup, untrack, useContext } from "@solidrt/core"
 import type { ParentComponent } from "@solidrt/core"
 import { LodContext, SceneContext, provide } from "./context.tsx"
 import type { LodRegistry } from "./context.tsx"
@@ -54,7 +54,7 @@ export let Lod: ParentComponent<LodProps> = props => {
     () => declare(),
     { defer: true },
   )
-  untrack(() => props.ref)?.(node)
+  callRef(() => props.ref, node)
   onCleanup(() => destroy(node))
   return <LodContext value={registry}>{provide(ctx, node, props)}</LodContext>
 }
@@ -91,7 +91,7 @@ export let InstancedLod: ParentComponent<InstancedLodProps> = props => {
     c => setCastShadow(mesh, c === true),
   )
   syncMesh(mesh, props)
-  untrack(() => props.ref)?.(mesh)
+  callRef(() => props.ref, mesh)
   onCleanup(() => {
     destroy(mesh)
     disposeInstances(mesh)

package/src/components/mesh.tsx

@@ -1,4 +1,4 @@
-import { createEffect, onCleanup, untrack, useContext } from "@solidrt/core"
+import { callRef, createEffect, onCleanup, untrack, useContext } from "@solidrt/core"
 import type { VoidComponent } from "@solidrt/core"
 import { SceneContext } from "./context.tsx"
 import { syncNode } from "./node-props.ts"
@@ -110,7 +110,7 @@ export let Mesh: VoidComponent<MeshProps> = props => {
     },
   )
   syncMesh(mesh, props)
-  untrack(() => props.ref)?.(mesh)
+  callRef(() => props.ref, mesh)
   onCleanup(() => destroy(mesh))
   return null
 }

package/src/components/node-props.ts

@@ -1,6 +1,6 @@
 import { createEffect, onCleanup, useContext } from "@solidrt/core"
 import { LodContext } from "./context.tsx"
-import { setTransform, setTransition, setVisible } from "../node.ts"
+import { setTimeScale, setTransform, setTransition, setVisible } from "../node.ts"
 import type { HoverHandlers, NodePointerEvent, NodeTapEvent, NodeWheelEvent, SceneNode, TransitionEndEvent } from "../node.ts"
 import type { NodeTransition } from "flux:spatial"
 import type { Quat, Vec3 } from "../math.ts"
@@ -19,6 +19,10 @@ export type TransformProps = {
   transition?: NodeTransition | string | null
   /** A declared transition settled on one component. */
   onTransitionEnd?: (event: TransitionEndEvent) => void
+  /** The rate the native motion under this node runs at (see
+   * setTimeScale): 0 freezes the subtree, 1 is app time; the nearest
+   * declaring ancestor wins. Undefined or null inherits. */
+  timeScale?: number | null
   /** Under a `<Lod>`: this node is a level of it, drawn while the group's
    * projected size is at or above this and below the next larger level's
    * (see createLod). Only on a direct child of `<Lod>`; throws elsewhere. */
@@ -104,6 +108,14 @@ export function syncNode(node: SceneNode & HoverHandlers, props: TransformProps
     () => props.transition,
     transition => setTransition(node, transition ?? null),
   )
+  // Built only when the prop is present (the compiler emits the getter
+  // only then), so a plain node pays no effect for it.
+  if ("timeScale" in props) {
+    createEffect(
+      () => props.timeScale,
+      scale => setTimeScale(node, scale ?? null),
+    )
+  }
   // A level of the enclosing <Lod>, keyed by size; built only when the
   // prop is present (the compiler emits the getter only then), so a plain
   // node pays nothing.

package/src/components/orbit-camera.tsx

@@ -1,4 +1,4 @@
-import { createEffect, merge, onFrame, untrack, useContext } from "@solidrt/core"
+import { callRef, createEffect, merge, onFrame, untrack, useContext } from "@solidrt/core"
 import type { InputMap, VoidComponent } from "@solidrt/core"
 import type { Vec2 } from "@solidrt/core/input"
 import { SceneContext } from "./context.tsx"
@@ -158,6 +158,6 @@ export let OrbitCamera: VoidComponent<OrbitCameraProps> = props => {
     () => untrack(() => orbit.set({})),
     { defer: true },
   )
-  untrack(() => props.ref)?.(orbit)
+  callRef(() => props.ref, orbit)
   return null
 }

package/src/components/point-light.tsx

@@ -1,4 +1,4 @@
-import { createEffect, onCleanup, untrack, useContext } from "@solidrt/core"
+import { callRef, createEffect, onCleanup, untrack, useContext } from "@solidrt/core"
 import type { VoidComponent } from "@solidrt/core"
 import { SceneContext } from "./context.tsx"
 import { syncNode } from "./node-props.ts"
@@ -50,7 +50,7 @@ export let PointLight: VoidComponent<PointLightProps> = props => {
     () => [props.color, props.intensity, props.layers, props.distance, props.decay, props.castShadow, props.shadow] as const,
     ([color, intensity, layers, distance, decay, castShadow, shadow]) => setLight(light, { color, intensity, layers, distance, decay, castShadow, shadow }),
   )
-  untrack(() => props.ref)?.(light)
+  callRef(() => props.ref, light)
   onCleanup(() => destroy(light))
   return null
 }

package/src/components/record-mesh.tsx

@@ -1,4 +1,4 @@
-import { createEffect, onCleanup, untrack, useContext } from "@solidrt/core"
+import { callRef, createEffect, onCleanup, untrack, useContext } from "@solidrt/core"
 import type { VoidComponent } from "@solidrt/core"
 import { SceneContext } from "./context.tsx"
 import { syncMesh } from "./mesh.tsx"
@@ -76,7 +76,7 @@ export let RecordMesh: VoidComponent<RecordMeshProps> = props => {
     c => setCastShadow(mesh, c === true),
   )
   syncMesh(mesh, props)
-  untrack(() => props.ref)?.(mesh)
+  callRef(() => props.ref, mesh)
   onCleanup(() => {
     destroy(mesh)
     disposeInstances(mesh)

package/src/components/scene.tsx

@@ -1,4 +1,4 @@
-import { createEffect, createRenderEffect, createSignal, displayScale, getBoundingBoxViewport, getLayoutBox, onCleanup, onLayout, untrack, warnOnce } from "@solidrt/core"
+import { callRef, createEffect, createRenderEffect, createSignal, displayScale, getBoundingBoxViewport, getLayoutBox, onCleanup, onLayout, untrack, warnOnce } from "@solidrt/core"
 import type { Element, ParentComponent, PointerFeed, TextureId } from "@solidrt/core"
 import { SceneContext } from "./context.tsx"
 import { createScene } from "../scene.ts"
@@ -65,6 +65,11 @@ export type SceneProps = ScenePointerProps & {
    * stagger`, the whole-scene form of `<Group transition={{ stagger }}>`
    * (see SceneOptions.stagger). Live (scene.setStagger). */
   stagger?: number
+  /** The rate the scene's native motion runs at (scene.setTimeScale as a
+   * prop): 0 pauses the world while the app's UI keeps moving, 1 is app
+   * time; a `<Group timeScale={1}>` inside keeps running. Undefined or
+   * null is app time. Live. */
+  timeScale?: number | null
   /** Scene-wide fog (scene.setFog): linear `{ color, near, far }` or exp2
    * `{ color, density }`, optionally thinning above `height` by
    * `heightFalloff`; every standard material fades toward `color` by
@@ -187,6 +192,7 @@ export let Scene: ParentComponent<SceneProps> = props => {
       bloom: props.bloom,
       layers: props.layers,
       stagger: props.stagger,
+      timeScale: props.timeScale ?? undefined,
       onError: e => {
         pendingError = e
         setErrorTick(errorTick() + 1)
@@ -261,7 +267,12 @@ export let Scene: ParentComponent<SceneProps> = props => {
     ms => scene.setStagger(ms ?? null),
     { defer: true },
   )
-  untrack(() => props.ref)?.(scene)
+  createEffect(
+    () => props.timeScale,
+    scale => scene.setTimeScale(scale ?? null),
+    { defer: true },
+  )
+  callRef(() => props.ref, scene)
   // The pointer feed the app handed in listens at the scene's root, and
   // children reach it through useScene().pointer. Fixed at creation, like
   // output.

package/src/components/shots.tsx

@@ -1,4 +1,4 @@
-import { createContext, createEffect, onCleanup, onFrame, untrack, useContext } from "@solidrt/core"
+import { callRef, createContext, createEffect, onCleanup, onFrame, untrack, useContext } from "@solidrt/core"
 import type { Element, ParentComponent } from "@solidrt/core"
 import { SceneContext } from "./context.tsx"
 import { createShots } from "../shots.ts"
@@ -60,7 +60,7 @@ export let Shots: ParentComponent<ShotsProps> = props => {
       })
     },
   )
-  untrack(() => props.ref)?.(shots)
+  callRef(() => props.ref, shots)
   return <ShotsContext value={shots}>{props.children}</ShotsContext>
 }
 

package/src/components/splat-mesh.tsx

@@ -1,4 +1,4 @@
-import { createEffect, onCleanup, untrack, useContext } from "@solidrt/core"
+import { callRef, createEffect, onCleanup, untrack, useContext } from "@solidrt/core"
 import type { VoidComponent } from "@solidrt/core"
 import { SceneContext } from "./context.tsx"
 import { syncMesh } from "./mesh.tsx"
@@ -41,7 +41,7 @@ export let SplatMesh: VoidComponent<SplatMeshProps> = props => {
     { defer: true },
   )
   syncMesh(mesh, props)
-  untrack(() => props.ref)?.(mesh)
+  callRef(() => props.ref, mesh)
   onCleanup(() => {
     destroy(mesh)
     disposeInstances(mesh)

package/src/components/spot-light.tsx

@@ -1,4 +1,4 @@
-import { createEffect, onCleanup, untrack, useContext } from "@solidrt/core"
+import { callRef, createEffect, onCleanup, untrack, useContext } from "@solidrt/core"
 import type { VoidComponent } from "@solidrt/core"
 import { SceneContext } from "./context.tsx"
 import { syncNode } from "./node-props.ts"
@@ -63,7 +63,7 @@ export let SpotLight: VoidComponent<SpotLightProps> = props => {
     ([direction, color, intensity, layers, distance, angle, penumbra, decay, castShadow, shadow]) =>
       setLight(light, { direction, color, intensity, layers, distance, angle, penumbra, decay, castShadow, shadow }),
   )
-  untrack(() => props.ref)?.(light)
+  callRef(() => props.ref, light)
   onCleanup(() => destroy(light))
   return null
 }

package/src/components/sprite.tsx

@@ -1,4 +1,4 @@
-import { onCleanup, untrack, useContext } from "@solidrt/core"
+import { callRef, onCleanup, untrack, useContext } from "@solidrt/core"
 import type { VoidComponent } from "@solidrt/core"
 import { SceneContext } from "./context.tsx"
 import type { TransformProps, NodePointerProps } from "./node-props.ts"
@@ -32,7 +32,7 @@ export let Sprite: VoidComponent<SpriteProps> = props => {
   let mesh = untrack(() => createSprite(props.material))
   add(ctx.parent, mesh)
   syncMesh(mesh, props)
-  untrack(() => props.ref)?.(mesh)
+  callRef(() => props.ref, mesh)
   onCleanup(() => destroy(mesh))
   return null
 }

package/src/components/view3d.tsx

@@ -1,4 +1,4 @@
-import { createEffect, onCleanup, untrack, useContext } from "@solidrt/core"
+import { callRef, createEffect, onCleanup, untrack, useContext } from "@solidrt/core"
 import type { Element, ParentComponent, PointerFeed, TextureId } from "@solidrt/core"
 import { SceneContext } from "./context.tsx"
 import { feedPointer } from "../scene-pointer.ts"
@@ -116,7 +116,7 @@ export let View3d: ParentComponent<View3dProps> = props => {
     b => view.setBloom(b ?? null),
     { defer: true },
   )
-  untrack(() => props.ref)?.(view)
+  callRef(() => props.ref, view)
   onCleanup(() => view.dispose())
   // The pointer feed the app handed in (see Scene) listens at the view's
   // root; children reach it through useScene().pointer.