@solidrt/3d 0.0.65 → 0.0.67

package/AGENTS.md

@@ -217,7 +217,7 @@ displacement - and `cullMargin` (world units, Godot's
 `extra_cull_margin`) for bounded displacement such as wind. Sprites
 cull by their quad's reach at any facing. A SKINNED part is culled by
 the union of its joints' boxes (the bake computes each joint's
-influence box in joint space, `ModelSkin.jointBounds`, .srtm VERSION
+influence box in joint space, `ModelSkin.jointBounds`, .sol3m VERSION
 5; the joint nodes carry them as culling-only bounds, outside the
 picking index), so the box follows the pose with no per-frame JS -
 Unity's bone bounds, Godot's per-bone AABBs; no `updateWhenOffscreen`
@@ -409,7 +409,7 @@ that pop in and shrink away on tap, the shelf cascading out and back
 through `<Show>`. Each natural settle calls the node's `onTransitionEnd`
 (plain field like the pointer handlers) with `{ component }` - never on
 a cancel, snap, leave or exit; the raw "spatialTransitionEnd" engine
-event (srt:events, carrying the CORE node id `_node`) stays for
+event (sol:events, carrying the CORE node id `_node`) stays for
 flux:spatial consumers.
 
 ### Geometry layout, indices and topology
@@ -495,7 +495,7 @@ so the mesh picks and culls where it is now drawn (the box follows at
 the next flush, the triangle index is rebuilt by the next query - a
 deforming mesh needs no re-attach). transformGeometry and
 the edge builders share extra streams with their source; merge
-concatenates every stream; the `.srtm` container refuses streams (run
+concatenates every stream; the `.sol3m` container refuses streams (run
 time data). `setDrawRange(mesh, first, count?)` draws indices `[first,
 first + count)` of the mesh's geometry (Three's `setDrawRange`, on the
 mesh because the scene owns the entries), applied to every entry of the
@@ -550,12 +550,12 @@ are Solid-free and
 GPU-free BY DESIGN so they can be checked headless and run under bun:
 `src/model-data.ts` re-exports exactly this set as the published
 `@solidrt/3d/model` entry (the bake tool and app bake scripts), and
-`tests/model-data.test.ts` imports it under `srt test`, on the bare flux
-binary, so a gui or `srt:` import creeping into any of them fails there
+`tests/model-data.test.ts` imports it under `sol test`, on the bare flux
+binary, so a gui or `sol:` import creeping into any of them fails there
 (a headless `flux:` import would not); keep them that way.
 `src/splat-data.ts` is its own published entry the same way
 (`@solidrt/3d/splat`, guarded by `tests/splat-data.test.ts`).
-The tests under `tests/` run with `bun run srt test packages/3d` from the
+The tests under `tests/` run with `bun run sol test packages/3d` from the
 repo root, or one file, or `--filter <text>` for the tests whose name
 contains it: the pure modules on the bare flux binary, and the files
 that need a GPU (`.test.tsx`, importing `@solidrt/test`) on the
@@ -1664,10 +1664,10 @@ specular, `envIrradiance` - the fully rough sample along the normal, as
 Three's getIBLIrradiance and Godot read it - added to the hemisphere
 for the diffuse) and every `phong({ reflectivity })` material mirrors,
 typically the skybox's own cube turned with it. The cube to use is a
-BAKED one: `bun run srt tool 3d/environment sky.hdr -o assets/sky.srte`
+BAKED one: `bun run sol tool 3d/environment sky.hdr -o assets/sky.sol3e`
 turns an equirectangular Radiance .hdr (Poly Haven's are CC0) into the
 six faces plus the GGX-prefiltered mip chain in linear float, and
-`await loadEnvironment("assets/sky.srte")` uploads it as an explicit
+`await loadEnvironment("assets/sky.sol3e")` uploads it as an explicit
 "rgba16f" chain (createCubeTexture's array-of-levels form: no generated
 mipmaps, so no half-float render support needed - it works on every
 device; created after an await, so not auto-freed). Unity convolves at
@@ -1682,7 +1682,7 @@ is a coarse average - fine for a sky gradient, wrong for a photograph.
 A 128 environment (2 MiB, the default) lights any surface; for a
 mirror-finish showpiece bake at 256, and for a crisp backdrop pair it
 with a separate hi-res LDR skybox (a 2k panorama through equirectToCube)
-as `background` while the .srte stays the `environment`. Scene-level like Three's
+as `background` while the .sol3e stays the `environment`. Scene-level like Three's
 `scene.environment`, Unity's environment reflections and Godot's
 sky-lit reflections: ONE `uEnv` samplerCube bound on every target the
 scene draws into (a 1x1 black placeholder while unset) and one
@@ -1750,7 +1750,7 @@ one), then the PREFILTER: the faces convolved on the GPU into a second,
 `mipmap: true` cube target level by level (`renderTarget(chain, face,
 level)`, one small pass each - 48 at 128 - the bake tool's GGX
 importance sampling as a fragment, `createPrefilter` in environment.ts,
-with the same roughness-to-level rule as a .srte chain), so `standard`
+with the same roughness-to-level rule as a .sol3e chain), so `standard`
 blurs a probe by roughness exactly like a baked environment; `prefilter:
 false` skips it and hands out the sharp faces (Three's CubeCamera: a
 mirror at every roughness). COST: the chain's passes are tiny, but a
@@ -1808,7 +1808,7 @@ clamp (`repeat` also wraps vertically and bleeds the poles). An HDR
 panorama uploaded as rgba16f converts into a half-float cube (sharp:
 a skybox, or `mipmap: true` for the box chain); its PREFILTERED form is
 the bake tool above, whose CPU pipeline (`src/environment-bake.ts`:
-decodeHdr, panoramaToCube, prefilterCube, the .srte encode/decode) is
+decodeHdr, panoramaToCube, prefilterCube, the .sol3e encode/decode) is
 pure TypeScript and bun-tested - there is no runtime .hdr decoder.
 
 ### Fog
@@ -2324,8 +2324,8 @@ for the loaders that scope is the caller's at the call, captured before
 the await, so a model loaded inside a memo goes with the memo's rerun
 and one loaded in a component with its unmount. A load that settles
 after its scope is gone (unmounted mid-load) is freed on arrival and
-resolves already disposed - nothing owns it any more. `loadModel` reads the baked `.srtm` written by `srt tool
-3d/model <in.gltf|glb> -o assets/<name>.srtm`: the same parse run once
+resolves already disposed - nothing owns it any more. `loadModel` reads the baked `.sol3m` written by `sol tool
+3d/model <in.gltf|glb> -o assets/<name>.sol3m`: the same parse run once
 at build time, stored in the GPU layout, so loading is views onto the
 file's bytes plus the image decodes. Numbers from a 32k-vertex, 6-texture model
 on a release client: `parseGltf` 124 ms on flux (22 ms under bun) against
@@ -2336,7 +2336,7 @@ models and a binary import (`import bytes from "./x.glb" with { type:
 
 #### Compressed textures
 
-`srt tool 3d/model <in> -o assets/<name>.srtm` bakes the images
+`sol tool 3d/model <in> -o assets/<name>.sol3m` bakes the images
 too: each becomes a KTX2 compressed texture with its mip chain. The file is the
 same for every platform; at load each device turns the images into the
 block format its GPU samples (BC7 on desktops, ETC2 elsewhere), which
@@ -2456,12 +2456,12 @@ import type { ModelData } from "@solidrt/3d/model"
 // takes `placements`), materials as glTF-shaped records, app data in
 // `extras` (JSON) and `blobs` (named bytes, each an aligned block).
 let data: ModelData = { nodes, parts, skins: [], clips: [], materials, images: [], bounds, extras: { spawn }, blobs: { grid } }
-await Bun.write("assets/level.srtm", encodeModel(data))
+await Bun.write("assets/level.sol3m", encodeModel(data))
 ```
 
-`loadModel("assets/level.srtm")` then builds it like any authored model;
+`loadModel("assets/level.sol3m")` then builds it like any authored model;
 `model.extras` and `model.blobs` hand the app data back (blobs are views
-onto the loaded bytes). `srt tool 3d/model` is the same entry applied
+onto the loaded bytes). `sol tool 3d/model` is the same entry applied
 to a glTF, so the two bakes share one code path.
 
 ### Async loading
@@ -2479,7 +2479,7 @@ PENDING_ASYNC_UNTRACKED_READ, and any element the component builds before
 the suspending read is orphaned on the boundary's retry and never freed
 (the dev leak sentinel reports it) - so the suspending component creates
 no elements of its own. Async here means the file read: the parse and
-createModel run synchronously on main. Bake anything big to .srtm; when
+createModel run synchronously on main. Bake anything big to .sol3m; when
 a source glTF must be parsed at runtime, do the parse in an isolate
 (parseGltf's result is plain data and copies across) and keep
 createModel on main.
@@ -2552,10 +2552,10 @@ rigged one; linear and premultiplied as glTF stores it) and the default
 material takes `vertexColors: true` for such parts - the callback's
 fourth argument says so, and a material shared by painted and unpainted
 parts is made once per variant, like the skinned split.
-A `.srtm` baked before the material records carried the PBR fields
+A `.sol3m` baked before the material records carried the PBR fields
 (file version 3), or before the vertex formats took the WebGPU spelling
 and byte counts (file version 5), is rejected by loadModel - re-bake
-with `srt tool 3d/model`. A baked part keeps a quantized export's
+with `sol tool 3d/model`. A baked part keeps a quantized export's
 bytes: u8 colors, u8/u16 joints and normalized weights, u16 uvs land in
 their own formats, positions and normals as floats.
 
@@ -2695,10 +2695,10 @@ mesh (JS-written records, no nodes) cannot morph: rejected at add().
 
 Not in the subset, dropped: tangents and further UV sets; samplers are
 ignored (every texture repeats); additive blending draws as base color.
-The follow-ups are filed in okf/backlog/3d-model-loader.md. The `.srtm`
+The follow-ups are filed in okf/backlog/3d-model-loader.md. The `.sol3m`
 container is VERSION 11 (node table in the header, node-local vertices,
 skins, clips, packed morph targets, app data, images under their
-names); older bakes are rejected - re-bake with `srt tool 3d/model`.
+names); older bakes are rejected - re-bake with `sol tool 3d/model`.
 
 ## Splats
 
@@ -2715,12 +2715,12 @@ successors) as ordinary content, the model-loading split repeated:
   times opacity, so the first n are the scene at n), y-down captures
   (.ply, .splat) stood up to y-up (positions and covariances rotated
   together; `keepOrientation` opts out, `.spz` is y-up already), bounds
-  measured. `encodeSplat`/`decodeSplat` round-trip the `.srts` container
+  measured. `encodeSplat`/`decodeSplat` round-trip the `.sol3s` container
   (the record and SH blocks, next bullet); decode is a header parse
-  plus byte VIEWS, nothing per-splat. `srt tool 3d/splat <in> [-o
-  out.srts] [--sh 0..3] [--keep-orientation]` is the parse and bake
+  plus byte VIEWS, nothing per-splat. `sol tool 3d/splat <in> [-o
+  out.sol3s] [--sh 0..3] [--keep-orientation]` is the parse and bake
   under bun (tools/splat.ts); an app bake script uses the same entry.
-- The `.srts` record (version 2) is 32 bytes = two rgba32ui texels:
+- The `.sol3s` record (version 2) is 32 bytes = two rgba32ui texels:
   center float32x3 + sRGB color and opacity unorm8x4, then the
   covariance upper triangle as six float16 + a spare word
   (SPLAT_ATTRIBUTES as a byte layout, SPLAT_RECORD_TEXELS). `--sh 1..3`
@@ -2731,7 +2731,7 @@ successors) as ordinary content, the model-loading split repeated:
   rgb interleaved), 32/48/96 bytes per splat of texture, so the
   default is 0 and a bake opts in. The y-up flip negates the
   coefficients whose basis is odd in (y, z).
-- On the runtime, `loadSplat(path)` reads a `.srts` (fetch + decode,
+- On the runtime, `loadSplat(path)` reads a `.sol3s` (fetch + decode,
   the loadModel shape) and `createSplatMesh(data, { count?, material?,
   label? })` / `<SplatMesh>` shows it: a RecordMesh in the INDEXED form
   (see "Instance order") - the records handed to the engine as the
@@ -2828,7 +2828,7 @@ successors) as ordinary content, the model-loading split repeated:
   ambient probe, this does not). glTF's default metallic factor is 1,
   so an untextured asset is all metal, and createModel's default is
   `standard`: give a model scene an `environment` (loadEnvironment's
-  baked .srte, or the skybox's cube), or pass `phong` as the material.
+  baked .sol3e, or the skybox's cube), or pass `phong` as the material.
 - Light intensities are the same numbers for `phong` and `standard`: 1
   lights a white matte surface to 1 face-on. A Three scene's intensities
   are a factor pi larger for the same look; divide when porting.
@@ -2901,7 +2901,7 @@ successors) as ordinary content, the model-loading split repeated:
 - A generated cube chain (`mipmap: true` from six faces) is a box
   filter, not the GGX convolution the roughness-to-level rule assumes:
   rough reflections read too sharp and the diffuse `envIrradiance` is a
-  4x4 average. Bake with `srt tool 3d/environment` for anything
+  4x4 average. Bake with `sol tool 3d/environment` for anything
   photographed; the JS sky gradients in the examples get away with it.
 - The background covers the whole target with depth off, drawn first: it
   REPLACES the clearColor visually (the clear still runs; you just never

package/examples/README.md

@@ -1,6 +1,6 @@
 # @solidrt/3d examples
 
-One concept per file; run with `bun run srt run <file>` from an app that
+One concept per file; run with `bun run sol run <file>` from an app that
 depends on `@solidrt/3d` (or in-repo from the package directory).
 
 - `scene-basic.tsx` - the whole v1 surface: a `<Scene>` composited as a
@@ -57,8 +57,8 @@ depends on `@solidrt/3d` (or in-repo from the package directory).
   the environment as tinted reflections, the dielectric row the same
   sky as a faint face-on gloss. Drag to look around.
 - `environment.tsx` - a baked HDR environment lighting the scene ALONE
-  (no lights, no hemisphere): `loadEnvironment` reads the .srte that
-  `bun run srt tool 3d/environment <panorama>.hdr -o assets/environment.srte`
+  (no lights, no hemisphere): `loadEnvironment` reads the .sol3e that
+  `bun run sol tool 3d/environment <panorama>.hdr -o assets/environment.sol3e`
   bakes from any equirectangular .hdr (Poly Haven's are CC0; the asset
   is not committed, bake one first), used as background and environment
   with ACES tone mapping. A metal row and a red dielectric row, roughness
@@ -200,4 +200,4 @@ depends on `@solidrt/3d` (or in-repo from the package directory).
   stays above the boundary - the two rules that avoid
   PENDING_ASYNC_UNTRACKED_READ and the suspend-retry element leak. Needs
   the asset baked into the running app:
-  `bun run srt tool 3d/model examples/model.glb -o assets/model.srtm`.
+  `bun run sol tool 3d/model examples/model.glb -o assets/model.sol3m`.

package/examples/cascades.tsx

@@ -22,7 +22,7 @@
 // plane, so the far pillars sink into the horizon instead of clipping
 // (`examples/fog.tsx` is the fog tour).
 import { createSignal, flush, onFrame, pct, render } from "@solidrt/core"
-import { registerDebug } from "srt:dev"
+import { registerDebug } from "sol:dev"
 import { box, DirectionalLight, HemisphereLight, phong, Mesh, PerspectiveCamera, plane, Scene, sphere } from "@solidrt/3d"
 import type { Geometry, Vec3 } from "@solidrt/3d"
 

package/examples/collision.tsx

@@ -30,7 +30,7 @@ import {
   sphere,
 } from "@solidrt/3d"
 import type { FirstPersonCameraHandle, MeshNode, MoveResult, SceneHandle, Vec3, Volume } from "@solidrt/3d"
-import { registerDebug } from "srt:dev"
+import { registerDebug } from "sol:dev"
 
 // Layer bit the level geometry adds to its drawn layer: what every
 // collision query selects, so pickups (drawn only) never block the walker.

package/examples/exits.tsx

@@ -14,7 +14,7 @@
 import { createSignal, For, pct, render, Show } from "@solidrt/core"
 import { box, Group, Mesh, PerspectiveCamera, plane, Scene, unlit } from "@solidrt/3d"
 import type { NodeTransition, SceneHandle, SceneTapEvent, Vec3 } from "@solidrt/3d"
-import { registerDebug } from "srt:dev"
+import { registerDebug } from "sol:dev"
 
 const COUNT = 5
 // Crate spacing along x, and the pause before a tapped-away crate is

package/examples/first-person.tsx

@@ -13,7 +13,7 @@ import { createInputMap, createPointerFeed, createSignal, gamepad, keyboard, loc
 import type { PointerEvent } from "@solidrt/core"
 import { box, cylinder, DirectionalLight, FirstPersonCamera, firstPersonActions, firstPersonBindings, HemisphereLight, phong, Mesh, PerspectiveCamera, plane, Scene } from "@solidrt/3d"
 import type { FirstPersonCameraHandle, Vec3 } from "@solidrt/3d"
-import { registerDebug } from "srt:dev"
+import { registerDebug } from "sol:dev"
 
 // Half extent of the walkable courtyard in world units; the walls stand
 // just outside it.

package/examples/fleet.tsx

@@ -18,7 +18,7 @@
 import { createInputMap, createPointerFeed, createSignal, flush, For, gamepad, pct, render } from "@solidrt/core"
 import { box, DirectionalLight, HemisphereLight, Instance, InstancedMesh, phong, Mesh, OrbitCamera, orbitActions, orbitBindings, plane, Scene, worldPosition } from "@solidrt/3d"
 import type { InstanceNode, NodeTransition, SceneHandle, Vec3 } from "@solidrt/3d"
-import { registerDebug } from "srt:dev"
+import { registerDebug } from "sol:dev"
 
 type Tint = [number, number, number, number]
 

package/examples/fog.tsx

@@ -19,7 +19,7 @@
 // repeats; `suns` is the two suns' world positions and `project`
 // (`{ point }`) is where a world point is on screen, for a pixel probe.
 import { createSignal, flush, onFrame, pct, render } from "@solidrt/core"
-import { registerDebug } from "srt:dev"
+import { registerDebug } from "sol:dev"
 import { cone, cylinder, DirectionalLight, HemisphereLight, phong, Mesh, PerspectiveCamera, plane, Scene, sphere, unlit } from "@solidrt/3d"
 import type { FogOptions, SceneHandle, Vec3 } from "@solidrt/3d"
 

package/examples/lod.tsx

@@ -21,7 +21,7 @@
 import { onFrame, pct, render } from "@solidrt/core"
 import { addInstance, cone, cylinder, DirectionalLight, HemisphereLight, icosahedron, InstancedLod, phong, Lod, Mesh, mergeGeometries, plane, Scene, transformGeometry, useScene } from "@solidrt/3d"
 import type { InstancedMeshNode } from "@solidrt/3d"
-import { registerDebug } from "srt:dev"
+import { registerDebug } from "sol:dev"
 
 const TREES = 1000
 // Half the side of the square field the trees scatter over.

package/examples/model-load.tsx

@@ -3,7 +3,7 @@
 // bundle - the shape every app with real content ends up needing. Bake
 // the asset once and drop it in your app's assets tree:
 //
-//   bun run srt tool 3d/model examples/model.glb -o assets/model.srtm
+//   bun run sol tool 3d/model examples/model.glb -o assets/model.sol3m
 //
 // (loadGltf("assets/model.glb") has the exact same async shape; the bake
 // just removes the runtime parse.)
@@ -51,7 +51,7 @@ function Rover(props: { turn: () => number }) {
   // The async value: a memo returning a Promise. Its read below suspends
   // until the file is read and the model built, then resumes under the
   // <Loading> boundary in App.
-  let loaded = createMemo(() => loadModel("assets/model.srtm", { label: "rover" }))
+  let loaded = createMemo(() => loadModel("assets/model.sol3m", { label: "rover" }))
 
   // Everything derived from the model - framing, mounting - happens in
   // this memo, AFTER the suspending read, so nothing here runs or builds

package/examples/model.tsx

@@ -4,7 +4,7 @@
 // with parseGltf and turned into a Group of meshes by createModel. The
 // glb rides in the bundle as a binary import; a model under assets/ goes
 // through loadGltf (same parser, read with flux:fs) or, baked once with
-// `srt tool 3d/model`, through loadModel (no parsing at all). Every part
+// `sol tool 3d/model`, through loadModel (no parsing at all). Every part
 // keeps its node name and is an ordinary mesh: pointer events, transforms
 // and materials work per part. The materials are createModel's default
 // `standard` from the file's PBR factors, so the scene carries an

package/examples/morph.tsx

@@ -20,7 +20,7 @@
 // shadows morph too.
 
 import { createSignal, onCleanup, onFrame, pct, render } from "@solidrt/core"
-import { registerDebug } from "srt:dev"
+import { registerDebug } from "sol:dev"
 import { DirectionalLight, geometryAttribute, geometryVertexCount, getMorphNames, getMorphWeights, HemisphereLight, Instance, InstancedMesh, phong, Mesh, PerspectiveCamera, plane, Scene, setMorphWeights, sphere, withMorphTargets } from "@solidrt/3d"
 import type { InstanceNode, MeshNode } from "@solidrt/3d"
 

package/examples/normals.tsx

@@ -17,7 +17,7 @@
 // `helpers` debug command ({ on?: boolean }) toggles them.
 
 import { createSignal, onFrame, pct, render } from "@solidrt/core"
-import { registerDebug } from "srt:dev"
+import { registerDebug } from "sol:dev"
 import { computeVertexNormals, cylinder, DirectionalLight, fillAttribute, geometryAttribute, geometryVertexCount, Group, HemisphereLight, phong, Mesh, normalsHelper, PerspectiveCamera, Scene, sphere, toNonIndexed, unlit, updateVertices, withNormals } from "@solidrt/3d"
 
 // The crease angles in degrees: flat, the default, everything smoothed.

package/examples/pick.tsx

@@ -24,7 +24,7 @@
 import { createInputMap, createPointerFeed, createSignal, displayScale, pct, render } from "@solidrt/core"
 import { box, cone, getRotation, Group, Mesh, OrbitCamera, orbitActions, orbitBindings, PerspectiveCamera, plane, Scene, setMeshParams, setTransform, sphere, torus, unlit, useScene } from "@solidrt/3d"
 import type { Geometry, MeshNode, NodePointerEvent, NodeTapEvent, NodeWheelEvent, OrbitCameraHandle, SceneHandle, Vec3 } from "@solidrt/3d"
-import { registerDebug } from "srt:dev"
+import { registerDebug } from "sol:dev"
 
 type Color = [number, number, number]
 

package/examples/wireframe.tsx

@@ -18,7 +18,7 @@
 import { createSignal, onFrame, pct, render } from "@solidrt/core"
 import { createTexture } from "@solidrt/core/gpu"
 import type { TextureId } from "@solidrt/core/gpu"
-import { registerDebug } from "srt:dev"
+import { registerDebug } from "sol:dev"
 import { add, axesHelper, box3Helper, createModel, DirectionalLight, edgesGeometry, equirectToCube, gridHelper, Group, Mesh, parseGltf, PerspectiveCamera, Scene, setGeometry, setMaterial, unlit, wireframeGeometry } from "@solidrt/3d"
 import type { SceneNode } from "@solidrt/3d"
 import modelBytes from "./model.glb" with { type: "binary" }

package/package.json

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

package/src/components/node-props.ts

@@ -50,6 +50,9 @@ export type BubblingPointerEventProps = {
   onPointerDown?: (event: NodePointerEvent) => void
   onPointerMove?: (event: NodePointerEvent) => void
   onPointerUp?: (event: NodePointerEvent) => void
+  /** The pointer's other end: the system took it away (see core's
+   * onPointerCancel); bubbles like up, and the press it ends never taps. */
+  onPointerCancel?: (event: NodePointerEvent) => void
   /** The wheel over the node: `deltaX`/`deltaY`. */
   onWheel?: (event: NodeWheelEvent) => void
   /** A press released on the node within the slop, alone for its whole
@@ -73,18 +76,20 @@ export function syncNode(node: SceneNode, props: TransformProps & PointerEventPr
         props.onPointerDown,
         props.onPointerMove,
         props.onPointerUp,
+        props.onPointerCancel,
         props.onPointerEnter,
         props.onPointerLeave,
         props.onWheel,
         props.onTap,
         props.onTransitionEnd,
       ] as const,
-    ([position, rotation, quaternion, scale, visible, down, move, up, enter, leave, wheel, tap, end]) => {
+    ([position, rotation, quaternion, scale, visible, down, move, up, cancel, enter, leave, wheel, tap, end]) => {
       setTransform(node, { position, rotation, quaternion, scale })
       setVisible(node, visible !== false)
       node.onPointerDown = down
       node.onPointerMove = move
       node.onPointerUp = up
+      node.onPointerCancel = cancel
       node.onPointerEnter = enter
       node.onPointerLeave = leave
       node.onWheel = wheel

package/src/components/scene.tsx

@@ -18,6 +18,7 @@ export type ScenePointerProps = {
   onPointerDown?: (event: ScenePointerEvent) => void
   onPointerMove?: (event: ScenePointerEvent) => void
   onPointerUp?: (event: ScenePointerEvent) => void
+  onPointerCancel?: (event: ScenePointerEvent) => void
   onWheel?: (event: SceneWheelEvent) => void
   onTap?: (event: SceneTapEvent) => void
 }
@@ -268,6 +269,7 @@ export let Scene: ParentComponent<SceneProps> = props => {
       onPointerDown: e => props.onPointerDown?.(e),
       onPointerMove: e => props.onPointerMove?.(e),
       onPointerUp: e => props.onPointerUp?.(e),
+      onPointerCancel: e => props.onPointerCancel?.(e),
       onWheel: e => props.onWheel?.(e),
       onTap: e => props.onTap?.(e),
     }),
@@ -331,6 +333,7 @@ export let Scene: ParentComponent<SceneProps> = props => {
           onPointerDown={events ? sceneHandlers.onPointerDown : undefined}
           onPointerMove={events ? sceneHandlers.onPointerMove : undefined}
           onPointerUp={events ? sceneHandlers.onPointerUp : undefined}
+          onPointerCancel={events ? sceneHandlers.onPointerCancel : undefined}
           onPointerLeave={events ? sceneHandlers.onPointerLeave : undefined}
           onWheel={events ? sceneHandlers.onWheel : undefined}
         />

package/src/components/view3d.tsx

@@ -129,6 +129,7 @@ export let View3d: ParentComponent<View3dProps> = props => {
       onPointerDown: e => props.onPointerDown?.(e),
       onPointerMove: e => props.onPointerMove?.(e),
       onPointerUp: e => props.onPointerUp?.(e),
+      onPointerCancel: e => props.onPointerCancel?.(e),
       onWheel: e => props.onWheel?.(e),
       onTap: e => props.onTap?.(e),
     }),
@@ -159,6 +160,7 @@ export let View3d: ParentComponent<View3dProps> = props => {
           onPointerDown={events ? view.handlers.onPointerDown : undefined}
           onPointerMove={events ? view.handlers.onPointerMove : undefined}
           onPointerUp={events ? view.handlers.onPointerUp : undefined}
+          onPointerCancel={events ? view.handlers.onPointerCancel : undefined}
           onPointerLeave={events ? view.handlers.onPointerLeave : undefined}
           onWheel={events ? view.handlers.onWheel : undefined}
         />

package/src/environment-bake.ts

@@ -1,10 +1,10 @@
-// Environment baking: the pure pipeline behind `srt tool 3d/environment`
+// Environment baking: the pure pipeline behind `sol tool 3d/environment`
 // and its tests. A Radiance .hdr panorama is decoded to linear float, laid
 // onto the six faces of a cube, convolved level by level with the GGX lobe
 // `standard`'s split sum samples (Karis's importance sampling, the source
 // lod picked from each sample's solid angle - the Filament and Unity
 // method; Godot and Three convolve the same way at runtime), and packed
-// into the .srte container loadEnvironment uploads as an explicit rgba16f
+// into the .sol3e container loadEnvironment uploads as an explicit rgba16f
 // chain. Runs under bun and on the runtime alike: no GPU, no flux imports.
 //
 // Cube faces hold what a GL lookup of a world direction returns (GL's own
@@ -428,15 +428,15 @@ export function prefilterCube(base: CubeFaces, size: number): CubeFaces[] {
   return levels
 }
 
-// The .srte container: "SRTE" u32 | version u32 | size u32 | levels u32,
+// The .sol3e container: "SOLE" u32 | version u32 | size u32 | levels u32,
 // then the faces as float32 rgba, level-major, face-major - the exact
 // buffers createCubeTexture's explicit chain takes, viewed in place.
-/** "SRTE" read as a little-endian u32. */
-const MAGIC = 0x45545253
+/** "SOLE" read as a little-endian u32. */
+const MAGIC = 0x454c4f53
 const VERSION = 1
 const HEADER_BYTES = 16
 
-/** Serialize a prefiltered chain (prefilterCube's result) into the .srte container. */
+/** Serialize a prefiltered chain (prefilterCube's result) into the .sol3e container. */
 export function encodeEnvironment(levels: CubeFaces[], size: number): Uint8Array {
   if (levels.length !== mipLevels(size)) {
     throw new Error("encodeEnvironment: a " + size + " chain has " + mipLevels(size) + " levels, got " + levels.length)
@@ -459,14 +459,14 @@ export function encodeEnvironment(levels: CubeFaces[], size: number): Uint8Array
   return out
 }
 
-/** Read a .srte container back into its size and chain, the faces viewing
+/** Read a .sol3e container back into its size and chain, the faces viewing
  * the bytes in place (copied only if the buffer is not float-aligned). */
 export function decodeEnvironment(bytes: Uint8Array): { size: number; levels: CubeFaces[] } {
   if (bytes.byteLength < HEADER_BYTES) throw new Error("decodeEnvironment: not an environment file (too short)")
   let view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength)
   if (view.getUint32(0, true) !== MAGIC) throw new Error("decodeEnvironment: not an environment file (bad magic)")
   let version = view.getUint32(4, true)
-  if (version !== VERSION) throw new Error("decodeEnvironment: version " + version + ", expected " + VERSION + " - re-bake with srt tool 3d/environment")
+  if (version !== VERSION) throw new Error("decodeEnvironment: version " + version + ", expected " + VERSION + " - re-bake with sol tool 3d/environment")
   let size = view.getUint32(8, true)
   let count = view.getUint32(12, true)
   if (size < 1 || count !== mipLevels(size)) throw new Error("decodeEnvironment: a " + size + " chain has " + mipLevels(size) + " levels, file says " + count)

package/src/environment.ts

@@ -1,5 +1,5 @@
-// Environment helpers: the baked HDR environment loader (the .srte chain
-// `srt tool 3d/environment` writes), the equirectangular-to-cube
+// Environment helpers: the baked HDR environment loader (the .sol3e chain
+// `sol tool 3d/environment` writes), the equirectangular-to-cube
 // conversion a fetched LDR panorama needs at runtime, the GPU prefilter
 // that turns a rendered cube (a reflection probe's, a baked sky's) into
 // the roughness chain, and the placeholder cube a scene binds as uEnv
@@ -28,8 +28,8 @@ import type { CreateOptions, DrawId, ProgramId, RenderPipelineId, SamplerOptions
 import { decodeEnvironment, levelRoughness, mipLevels } from "./environment-bake.ts"
 
 /**
- * Read a baked environment (`srt tool 3d/environment sky.hdr -o
- * assets/sky.srte`) and upload it: the HDR cube with its GGX-prefiltered
+ * Read a baked environment (`sol tool 3d/environment sky.hdr -o
+ * assets/sky.sol3e`) and upload it: the HDR cube with its GGX-prefiltered
  * mip chain, as an explicit "rgba16f" chain - no generated mipmaps, so it
  * works on every device. The id is what `environment={{ cube }}` and
  * `background={{ cube }}` take (Three's `scene.environment` from an
@@ -147,7 +147,7 @@ const EQUIRECT_FACE = glsl`
  * photographed sky uploaded as such, "rgba8" (default) for data,
  * "rgba16f" for an HDR panorama (the cube keeps the range; renderable on
  * every device with half-float rendering, else it throws - the prefiltered
- * form of that panorama is `srt tool 3d/environment` plus
+ * form of that panorama is `sol tool 3d/environment` plus
  * loadEnvironment). The panorama's center column faces -Z and its top
  * row is +Y. Leave its wrap at the default clamp: `repeat` would also
  * wrap vertically and bleed the poles across the top and bottom rows,
@@ -280,7 +280,7 @@ export function bufferFormat(): BufferFormat {
  * `source`, a `mipmap: true` cube of the same size and format (a cube
  * draw target rendered sharp), one pass per face per level - 48 small
  * passes at 128. Three's PMREMGenerator, Unity's and Godot's probe
- * convolution, on the same roughness-to-level rule as the .srte chain
+ * convolution, on the same roughness-to-level rule as the .sol3e chain
  * (levelRoughness), so `standard` reads both alike.
  */
 export function createPrefilter(size: number, source: TextureId, format: BufferFormat, label: string): Prefilter {

package/src/glsl.ts

@@ -815,7 +815,7 @@ export function resolveFragment(source: string = DEFAULT_RESOLVE): string {
  * roughness - 0 the sharp base level, 1 the level whose faces are
  * ENV_ROUGH_FACE (4) texels wide, linear between (Godot's
  * `roughness * MAX_ROUGHNESS_LOD`; Unity's six LOD steps; Three maps
- * onto a 16-texel floor): the level a baked chain (`srt tool
+ * onto a 16-texel floor): the level a baked chain (`sol tool
  * 3d/environment`, loadEnvironment) convolves at that roughness, and a
  * generated chain merely box-filters - scaled by the intensity: the
  * prefiltered radiance of the split sum (`standard` multiplies it by PBR's

package/src/mixer.ts

@@ -44,7 +44,7 @@
 
 import * as spatial from "flux:spatial"
 import type { NodeId } from "flux:spatial"
-import { on } from "srt:events"
+import { on } from "sol:events"
 import type { ModelChannel, ModelClip } from "./gltf.ts"
 import { channelElements, sampleChannel } from "./clip.ts"
 import type { Vec3 } from "./math.ts"

package/src/model-data.ts

@@ -1,5 +1,5 @@
 // @solidrt/3d/model - the model DATA side of the package without the
-// runtime: the glTF parser, the .srtm container and the pure geometry kit,
+// runtime: the glTF parser, the .sol3m container and the pure geometry kit,
 // for a script that bakes an app's own geometry under bun (or any host
 // with no flux). The package root imports `flux:*` and so loads only on
 // the runtime; this entry imports nothing that does. tools/model.flux.ts
@@ -7,11 +7,11 @@
 // app's bake script and the tool share one path:
 //
 //   import { box, encodeModel, transformGeometry } from "@solidrt/3d/model"
-//   writeFileSync("assets/terrain.srtm", encodeModel({ nodes, parts, ... }))
+//   writeFileSync("assets/terrain.sol3m", encodeModel({ nodes, parts, ... }))
 //
 // createModel / loadModel on the runtime read what it writes. Keep this
 // entry pure. tests/model-data.test.ts imports it on the bare flux binary
-// and fails the moment a gui or srt: import creeps into the chain; a
+// and fails the moment a gui or sol: import creeps into the chain; a
 // headless flux: import it would not notice, and a bake script under bun
 // would.
 

package/src/model-file.ts

@@ -1,4 +1,4 @@
-// The baked model container (.srtm): ModelData as one file whose payload IS
+// The baked model container (.sol3m): ModelData as one file whose payload IS
 // the GPU layout, so loading it is a header parse plus typed-array views -
 // no per-vertex work. Written by tools/model.flux.ts (from parseGltf),
 // read by loadModel on flux; both ends are this pure module. An image
@@ -6,7 +6,7 @@
 // the image's name.
 //
 // Layout, all little-endian:
-//   "SRTM" u32 | version u32 | jsonLength u32 | json (padded to 4) | payload
+//   "SOLM" u32 | version u32 | jsonLength u32 | json (padded to 4) | payload
 // The JSON header describes each block's byte range into the payload; every
 // block starts 4-aligned so Float32Array/Uint32Array views sit on it
 // directly. Images travel as their encoded files (PNG/JPEG bytes), app
@@ -23,14 +23,14 @@ import { layoutStride, vertexView, VERTEX_FORMATS } from "./geometry.ts"
 import type { VertexAttribute } from "@solidrt/core/gpu"
 import type { Geometry, VertexLayout } from "./geometry.ts"
 
-/** "SRTM" read as a little-endian u32. */
-const MAGIC = 0x4d545253
+/** "SOLM" read as a little-endian u32. */
+const MAGIC = 0x4d4c4f53
 // Version 3 retained the node hierarchy - a node table (name/parent/TRS)
 // in the header, parts referencing their node, vertices NODE-LOCAL
 // instead of world-baked - and carries skins (joints + inverse binds,
 // parts in the "skinned" layout) and animation clips (channel
 // times/values as payload blocks). Version-2 files world-baked and have
-// none of it, so they are rejected - re-bake with `srt tool 3d/model`.
+// none of it, so they are rejected - re-bake with `sol tool 3d/model`.
 // Version 4 adds the metalness/roughness fields to the material records
 // (metalness, roughness, metalnessRoughnessMap); a version-3 file lacks
 // them, so it is rejected the same way rather than read as all-metal.
@@ -39,7 +39,7 @@ const MAGIC = 0x4d545253
 // carry packed channels; a version-5 file's "vec3" words do not parse.
 // Version 7 changes the named "skinned" layout's joints from float32x4 to
 // uint8x4 (an integer shader input), so a version-6 skinned part would
-// decode at the wrong stride; it is rejected. Re-bake with `srt tool
+// decode at the wrong stride; it is rejected. Re-bake with `sol tool
 // 3d/model`.
 // Version 8 carries morph targets: a part's packed targets block (names,
 // the sparse-by-vertex texels, the extent - see packMorphTargets), the
@@ -55,7 +55,7 @@ const MAGIC = 0x4d545253
 // shared blocks, see the header). A version-9 file has none of these and is rejected like
 // every earlier version rather than read as a file without them, so a
 // stale bake never silently drops the data an app relies on. Re-bake
-// with `srt tool 3d/model`.
+// with `sol tool 3d/model`.
 // Version 11 names the images: an image record is its block and the
 // image's name (ModelImage.name), which labels its texture. A
 // version-10 file has blocks alone and is rejected the same way.
@@ -138,7 +138,7 @@ type Header = {
   blobs?: Record<string, Block>
 }
 
-/** Serialize a model into the .srtm container. */
+/** Serialize a model into the .sol3m container. */
 export function encodeModel(data: ModelData): Uint8Array {
   let blocks: Uint8Array[] = []
   let offset = 0
@@ -237,7 +237,7 @@ export function encodeModel(data: ModelData): Uint8Array {
 }
 
 /**
- * Read a .srtm container back into ModelData. The geometry arrays are
+ * Read a .sol3m container back into ModelData. The geometry arrays are
  * VIEWS onto `bytes` (copied once only when the input is not 4-aligned),
  * so the bytes must outlive the model.
  */

package/src/model.ts

@@ -1,4 +1,4 @@
-// Models in a scene: ModelData (parsed glTF or a decoded .srtm) becomes a
+// Models in a scene: ModelData (parsed glTF or a decoded .sol3m) becomes a
 // Group carrying the file's node hierarchy - nested Groups with the file's
 // local TRS, each part's mesh under its node - with the images uploaded as
 // textures and a material per glTF material: Three's `gltf.scene`, an
@@ -13,7 +13,7 @@
 // them and detaches the group. loadGltf / loadModel are the
 // read-then-create conveniences over flux:fs; parseGltf / decodeModel +
 // createModel are the primitives under them, for bytes obtained any other
-// way (a binary import, a fetch). Compressed images (KTX2, what `srt tool
+// way (a binary import, a fetch). Compressed images (KTX2, what `sol tool
 // 3d/model` bakes) are turned into this device's block format by
 // transcodeModelImages, the one asynchronous step between the two.
 
@@ -439,7 +439,7 @@ function buildOwned(owner: Owner | null, opts: ModelOptions | undefined, build:
  * Read a .glb or .gltf (with its external .bin and image files, resolved
  * next to it) and build the model. The parse runs on the runtime - fine
  * for models of tens of thousands of vertices; bake bigger ones with
- * `srt tool 3d/model` and use loadModel.
+ * `sol tool 3d/model` and use loadModel.
  */
 export async function loadGltf(path: string, opts?: ModelOptions): Promise<Model> {
   let owner = getOwner()
@@ -456,7 +456,7 @@ export async function loadGltf(path: string, opts?: ModelOptions): Promise<Model
   return buildOwned(owner, opts, () => createModel(data, opts))
 }
 
-/** Read a baked .srtm model (`srt tool 3d/model`) and build it: no parsing,
+/** Read a baked .sol3m model (`sol tool 3d/model`) and build it: no parsing,
  * the geometry views the file's bytes directly. */
 export async function loadModel(path: string, opts?: ModelOptions): Promise<Model> {
   let owner = getOwner()

package/src/node.ts

@@ -8,7 +8,7 @@
 
 import * as spatial from "flux:spatial"
 import type { NodeId, NodeMotionSpec, NodeTransition } from "flux:spatial"
-import { on } from "srt:events"
+import { on } from "sol:events"
 import { createMutableTexture, destroyTexture } from "@solidrt/core/gpu"
 import type { ShaderParams, TextureId } from "@solidrt/core/gpu"
 import type { PointerEvent as ElementPointerEvent, WheelEvent as ElementWheelEvent } from "@solidrt/core"
@@ -203,6 +203,7 @@ export type SceneNode = {
   onPointerDown?: (event: NodePointerEvent) => void
   onPointerMove?: (event: NodePointerEvent) => void
   onPointerUp?: (event: NodePointerEvent) => void
+  onPointerCancel?: (event: NodePointerEvent) => void
   onPointerEnter?: (event: NodePointerEvent) => void
   onPointerLeave?: (event: NodePointerEvent) => void
   /** The wheel over the node (NodeWheelEvent: `deltaX`/`deltaY`), bubbling
@@ -352,6 +353,7 @@ export type ScenePointerListener = {
   onPointerDown?: (event: ScenePointerEvent) => void
   onPointerMove?: (event: ScenePointerEvent) => void
   onPointerUp?: (event: ScenePointerEvent) => void
+  onPointerCancel?: (event: ScenePointerEvent) => void
   onWheel?: (event: SceneWheelEvent) => void
   onTap?: (event: SceneTapEvent) => void
 }
@@ -776,7 +778,7 @@ export type { TransformUpdate } from "./math.ts"
  * orchestrator is always an ancestor). Clearing cancels running tracks in
  * place (the node keeps its mid-flight transform) and later writes snap. Each natural settle calls the node's
  * `onTransitionEnd` with the component (the raw "spatialTransitionEnd"
- * engine event on srt:events stays for flux:spatial consumers; it carries
+ * engine event on sol:events stays for flux:spatial consumers; it carries
  * the core id, `_node`).
  */
 export function setTransition(node: SceneNode, transition: NodeTransition | string | null): void {

package/src/scene-pointer.ts

@@ -41,7 +41,7 @@ const TAP_INTERVAL_MS = 300
 // neighbouring meshes.
 const TAP_REPEAT_SLOP = 20
 
-type HandlerName = "onPointerDown" | "onPointerMove" | "onPointerUp" | "onWheel" | "onTap"
+type HandlerName = "onPointerDown" | "onPointerMove" | "onPointerUp" | "onPointerCancel" | "onWheel" | "onTap"
 
 // What a press captures, a hover tracks and a tap compares: the struck
 // mesh, and the instance when the mesh is instanced.
@@ -254,6 +254,18 @@ export function makePointerInput(deps: PointerInputDeps): PointerInput {
         tap.tapCount = count
         walk("onTap", tap, !press.claimed)
       },
+      onPointerCancel(e) {
+        let [x, y] = toScene(e)
+        let press = presses.get(e.pointerId)
+        if (!press) {
+          let hit = nearest(x, y)
+          walk("onPointerCancel", makeEvent(e, hit === null ? null : targetOf(hit), x, y, hit), true)
+          return
+        }
+        // The press ends where it was: the walk it captured, never a tap.
+        presses.delete(e.pointerId)
+        walk("onPointerCancel", makeEvent(e, press.target, x, y, hitOn(press.target, x, y)), !press.claimed)
+      },
       onWheel(e) {
         let [x, y] = toScene(e)
         let hit = nearest(x, y)
@@ -290,6 +302,7 @@ export function feedPointer(root: { listen(listener: ScenePointerListener): () =
     onPointerDown: e => feed.handlers.onPointerDown(e.native),
     onPointerMove: e => feed.handlers.onPointerMove(e.native),
     onPointerUp: e => feed.handlers.onPointerUp(e.native),
+    onPointerCancel: e => feed.handlers.onPointerCancel(e.native),
     onWheel: e => feed.handlers.onWheel(e.native),
   })
 }

package/src/scene.ts

@@ -227,6 +227,7 @@ export type SceneHandlers = {
   onPointerDown(event: ElementPointerEvent): void
   onPointerMove(event: ElementPointerEvent): void
   onPointerUp(event: ElementPointerEvent): void
+  onPointerCancel(event: ElementPointerEvent): void
   onPointerLeave(event: ElementPointerEvent): void
   onWheel(event: ElementWheelEvent): void
 }
@@ -635,7 +636,7 @@ export type ReflectionProbeOptions = {
 export type ReflectionProbe = {
   /** The cube map: what `environment={{ cube }}` and `background={{
    * cube }}` take. The prefiltered chain (roughness 0 sharp at level 0,
-   * blurred below, the same rule as a baked .srte), or with `prefilter:
+   * blurred below, the same rule as a baked .sol3e), or with `prefilter:
    * false` the sharp faces alone - then `standard` reflects it at its
    * roughness 0 look whatever its roughness. */
   cube: TextureId

package/src/splat-data.ts

@@ -1,15 +1,15 @@
 // @solidrt/3d/splat - the splat DATA side of the package without the
 // runtime: the capture parsers (.ply, .splat, gunzipped .spz), the
-// covariance bake and the .srts container, for `srt tool 3d/splat` and any
+// covariance bake and the .sol3s container, for `sol tool 3d/splat` and any
 // app bake script under bun. The package root imports `flux:*` and so
 // loads only on the runtime; this entry imports nothing that does (the
 // model-data rule; tests/splat-data.test.ts imports it on the bare flux
-// binary and fails the moment a gui or srt: import creeps into the chain).
+// binary and fails the moment a gui or sol: import creeps into the chain).
 //
 //   import { encodeSplat, parseSplat } from "@solidrt/3d/splat"
-//   writeFileSync("assets/scan.srts", encodeSplat(parseSplat(bytes)))
+//   writeFileSync("assets/scan.sol3s", encodeSplat(parseSplat(bytes)))
 //
-// loadSplat / createSplatMesh on the runtime read what it writes: a .srts
+// loadSplat / createSplatMesh on the runtime read what it writes: a .sol3s
 // record IS the texel data the splat shader fetches (two rgba32ui texels
 // per splat, SPLAT_ATTRIBUTES as a byte layout) and the record the core
 // sorts by depth, so runtime loading is a header parse plus byte views -
@@ -113,8 +113,8 @@ const SPZ_COLOR_SCALE = 0.15
 const SPZ_SCALE_OFFSET = 10
 const SPZ_SCALE_STEP = 16
 
-/** "SRTS" read as a little-endian u32. */
-const MAGIC = 0x53545253
+/** "SOLS" read as a little-endian u32. */
+const MAGIC = 0x534c4f53
 // Version 2: the 32-byte two-texel record, importance-sorted, y-up unless
 // the bake kept orientation, plus the optional SH texel block; the header
 // carries count, shDegree, bounds and both block ranges. (Version 1 was
@@ -164,10 +164,10 @@ let colorByte = (v: number) => Math.round(Math.min(1, Math.max(0, v)) * 255)
  * Parse a captured splat cloud - a trainer's .ply, the de-facto .splat
  * interchange, or a gunzipped .spz (Niantic; the container is
  * gzip-compressed, and this entry stays decompression-free, so hand it
- * the inflated bytes - `srt tool 3d/splat` does) - into baked SplatData:
+ * the inflated bytes - `sol tool 3d/splat` does) - into baked SplatData:
  * covariance precomputed, y-up by default, importance-sorted (size times
  * opacity), bounds measured. Runs anywhere (bun, the runtime); for a
- * capture of real size run it at pack time and ship encodeSplat's .srts.
+ * capture of real size run it at pack time and ship encodeSplat's .sol3s.
  */
 export function parseSplat(bytes: Uint8Array, opts?: ParseSplatOptions): SplatData {
   let format = opts?.format ?? sniffFormat(bytes)
@@ -185,7 +185,7 @@ function sniffFormat(bytes: Uint8Array): SplatFormat {
     if (dv.getUint32(0, true) === SPZ_MAGIC) return "spz"
   }
   if (bytes.length >= 2 && bytes[0] === 0x1f && bytes[1] === 0x8b) {
-    throw new Error("parseSplat: gzip-compressed input (.spz files are); gunzip the bytes first - srt tool 3d/splat does")
+    throw new Error("parseSplat: gzip-compressed input (.spz files are); gunzip the bytes first - sol tool 3d/splat does")
   }
   if (bytes.length > 0 && bytes.length % SPLAT_IN_BYTES === 0) return "splat"
   throw new Error("parseSplat: unrecognized input - not a .ply, not a gunzipped .spz, and not whole 32-byte .splat records")
@@ -537,8 +537,8 @@ function shBytesOf(count: number, shDegree: number): number {
 }
 
 /**
- * Serialize a splat cloud into the .srts container, all little-endian:
- * "SRTS" u32 | version u32 | jsonLength u32 | json (padded to 4) |
+ * Serialize a splat cloud into the .sol3s container, all little-endian:
+ * "SOLS" u32 | version u32 | jsonLength u32 | json (padded to 4) |
  * payload. The JSON header carries count, shDegree, bounds and the byte
  * range of the record block and (above degree 0) the SH block; the
  * payload is both blocks verbatim.
@@ -574,7 +574,7 @@ export function encodeSplat(data: SplatData): Uint8Array {
 }
 
 /**
- * Read a .srts container back into SplatData. The records and the SH
+ * Read a .sol3s container back into SplatData. The records and the SH
  * block are VIEWS onto `bytes` (copied once only when the input is not
  * 4-aligned), so the bytes must outlive the data - which is the point:
  * loading a bake is a header parse, and the views upload as-is.
@@ -585,7 +585,7 @@ export function decodeSplat(bytes: Uint8Array): SplatData {
   let dv = new DataView(bytes.buffer, bytes.byteOffset, 12)
   if (dv.getUint32(0, true) !== MAGIC) throw new Error("decodeSplat: not a splat file (bad magic)")
   let version = dv.getUint32(4, true)
-  if (version !== VERSION) throw new Error("decodeSplat: version " + version + ", expected " + VERSION + " - re-bake with `srt tool 3d/splat`")
+  if (version !== VERSION) throw new Error("decodeSplat: version " + version + ", expected " + VERSION + " - re-bake with `sol tool 3d/splat`")
   let jsonLength = dv.getUint32(8, true)
   let header: Header = JSON.parse(new TextDecoder().decode(bytes.subarray(12, 12 + jsonLength)))
   let payload = 12 + jsonLength + ((4 - (jsonLength % 4)) % 4)

package/src/splat.ts

@@ -1,7 +1,7 @@
 // The splat RUNTIME side: the stock splat material and createSplatMesh
 // over a baked SplatData (parse and bake live in ./splat-data.ts, the
-// runtime-free `@solidrt/3d/splat` entry; `srt tool 3d/splat` writes the
-// .srts this loads). A splat cloud here is an ordinary record mesh in the
+// runtime-free `@solidrt/3d/splat` entry; `sol tool 3d/splat` writes the
+// .sol3s this loads). A splat cloud here is an ordinary record mesh in the
 // INDEXED form - the records live in an rgba32ui data texture the vertex
 // stage fetches by id, SPLAT_GROUP splats share one drawn instance (a
 // merged-quad geometry; the instancing frontend was the measured wall),
@@ -393,7 +393,7 @@ export function createSplatMesh(data: SplatData, opts?: SplatMeshOptions): Splat
   return mesh
 }
 
-/** Read a baked .srts splat cloud (`srt tool 3d/splat`): no parsing, the
+/** Read a baked .sol3s splat cloud (`sol tool 3d/splat`): no parsing, the
  * records and the SH block view the file's bytes and upload as-is at
  * createSplatMesh. */
 export async function loadSplat(path: string): Promise<SplatData> {

package/tools/environment.ts

@@ -1,7 +1,7 @@
 #!/usr/bin/env bun
 /// <reference path="./node-env.d.ts" />
 
-// srt tool 3d/environment: bake a Radiance .hdr panorama into a .srte
+// sol tool 3d/environment: bake a Radiance .hdr panorama into a .sol3e
 // environment file - the six cube faces and their GGX-prefiltered mip
 // chain in linear float, the exact chain loadEnvironment uploads as an
 // explicit rgba16f cube (no runtime conversion, no generated mipmaps, no
@@ -10,7 +10,7 @@
 // at runtime every time the sky changes. Put the output under assets/ so
 // it ships with the app.
 //
-//   srt tool 3d/environment <in.hdr> [-o <out.srte>] [--size <edge>]
+//   sol tool 3d/environment <in.hdr> [-o <out.sol3e>] [--size <edge>]
 //
 // --size is the cube's face edge: 128 (default) is Unity's probe default
 // and enough for every surface short of a mirror; 256 (Godot's radiance
@@ -28,7 +28,7 @@ const MAX_SIZE = 1024
 
 function usage(error?: string): never {
   if (error) console.error(error)
-  console.log("Usage: srt tool 3d/environment <in.hdr> [-o <out.srte>] [--size <edge>]")
+  console.log("Usage: sol tool 3d/environment <in.hdr> [-o <out.sol3e>] [--size <edge>]")
   process.exit(error ? 1 : 0)
 }
 
@@ -54,7 +54,7 @@ for (let i = 0; i < args.length; i++) {
   else usage("Unexpected argument " + arg)
 }
 if (input === undefined) usage("Missing input file")
-if (output === undefined) output = basename(input, extname(input)) + ".srte"
+if (output === undefined) output = basename(input, extname(input)) + ".sol3e"
 
 let started = performance.now()
 let panorama = decodeHdr(new Uint8Array(readFileSync(input)))

package/tools/model.flux.ts

@@ -1,4 +1,4 @@
-// srt tool 3d/model: bake a glTF into a .srtm model file - the parse
+// sol tool 3d/model: bake a glTF into a .sol3m model file - the parse
 // (src/gltf.ts) run once here, the result written in the exact layout
 // loadModel views without any per-vertex work at runtime. Same parser,
 // same subset, same result as loadGltf; this only moves the cost to build
@@ -20,7 +20,7 @@
 // `@solidrt/3d/model` entry (src/model-data.ts), the same surface an
 // app's own bake script uses under bun.
 //
-//   srt tool 3d/model <in.gltf|in.glb> [-o <out.srtm>] [--compress|--no-compress]
+//   sol tool 3d/model <in.gltf|in.glb> [-o <out.sol3m>] [--compress|--no-compress]
 
 import { file, glob } from "flux:fs"
 import { decodeImage, encodeTexture } from "flux:image"
@@ -42,7 +42,7 @@ const IMAGES_IN_FLIGHT = 4
 // of the texture settings are written from.
 const PROJECT_ROOT = "."
 
-const USAGE = "Usage: srt tool 3d/model <in.gltf|in.glb> [-o <out.srtm>] [--compress|--no-compress]"
+const USAGE = "Usage: sol tool 3d/model <in.gltf|in.glb> [-o <out.sol3m>] [--compress|--no-compress]"
 
 function usage(error?: string): never {
   if (error) console.error(error)
@@ -149,7 +149,7 @@ for (let i = 0; i < argv.length; i++) {
   else usage("Unexpected argument " + arg)
 }
 if (input === undefined) usage("Missing input file")
-if (output === undefined) output = basename(input, extname(input)) + ".srtm"
+if (output === undefined) output = basename(input, extname(input)) + ".sol3m"
 
 // The parse is synchronous, so the external files it will open are read
 // ahead of it (the same prefetch loadGltf does).

package/tools/node-env.d.ts

@@ -1,4 +1,4 @@
-// The node surface the tools use, declared here so `srt check
+// The node surface the tools use, declared here so `sol check
 // packages/3d/tools/<name>.ts` typechecks them on the package's flux-typed
 // program (the nearest tsconfig is the repo root's). The tools run under
 // bun, but bun's own types cannot join this program: their globals

package/tools/splat.ts

@@ -1,7 +1,7 @@
 #!/usr/bin/env bun
 /// <reference path="./node-env.d.ts" />
 
-// srt tool 3d/splat: bake a captured splat cloud into a .srts file - the
+// sol tool 3d/splat: bake a captured splat cloud into a .sol3s file - the
 // parse, covariance bake and SH packing (src/splat-data.ts) run once here
 // under bun, the result written in the exact texel layout createSplatMesh
 // uploads and the engine sorts, without any per-splat work at runtime.
@@ -9,7 +9,7 @@
 // Everything here comes from the runtime-free `@solidrt/3d/splat` entry,
 // the same surface an app's own bake script uses.
 //
-//   srt tool 3d/splat <in.ply|in.splat|in.spz> [-o <out.srts>] [--sh <0..3>] [--keep-orientation]
+//   sol tool 3d/splat <in.ply|in.splat|in.spz> [-o <out.sol3s>] [--sh <0..3>] [--keep-orientation]
 //
 // Inputs: a trainer's .ply, the de-facto .splat interchange, or Niantic's
 // .spz (gunzipped here; version 2 or 3). A y-down capture (.ply, .splat)
@@ -25,7 +25,7 @@ import { encodeSplat, parseSplat } from "../src/splat-data.ts"
 
 function usage(error?: string): never {
   if (error) console.error(error)
-  console.log("Usage: srt tool 3d/splat <in.ply|in.splat|in.spz> [-o <out.srts>] [--sh <0..3>] [--keep-orientation]")
+  console.log("Usage: sol tool 3d/splat <in.ply|in.splat|in.spz> [-o <out.sol3s>] [--sh <0..3>] [--keep-orientation]")
   process.exit(error ? 1 : 0)
 }
 
@@ -51,7 +51,7 @@ for (let i = 0; i < args.length; i++) {
   else usage("Unexpected argument " + arg)
 }
 if (input === undefined) usage("Missing input file")
-if (output === undefined) output = basename(input, extname(input)) + ".srts"
+if (output === undefined) output = basename(input, extname(input)) + ".sol3s"
 
 let bytes = new Uint8Array(readFileSync(input))
 // .spz is gzip-compressed; the parser takes the inflated bytes.