@solidrt/3d 0.0.64 → 0.0.66

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"
@@ -273,6 +273,11 @@ export type SceneEventBase = {
    * (a view's own pixels under a view leaf). */
   x: number
   y: number
+  /** When the event happened, ms: the element event's `timeStamp`. */
+  timeStamp: number
+  /** The element event's `predicted`: a move the pointer was never
+   * reported at. Draw with it, do not measure with it. */
+  predicted: boolean
   pointerId: number
   pointerType: string
   button?: number
@@ -771,7 +776,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

@@ -19,7 +19,7 @@
 // dispatch.ts is the same model one dimension down.
 //
 // Pure BY DESIGN (types only, nothing with GPU imports) so
-// checks/dispatch-check.ts drives it headless with a fake pick.
+// tests/dispatch.test.ts drives it headless with a fake pick.
 
 import type { PointerEvent as ElementPointerEvent, PointerFeed } from "@solidrt/core"
 import type { NodePointerEvent, SceneNode, ScenePointerListener } from "./node.ts"
@@ -58,6 +58,8 @@ type InternalEvent = {
   distance: number | null
   x: number
   y: number
+  timeStamp: number
+  predicted: boolean
   pointerId: number
   pointerType: string
   button?: number
@@ -95,8 +97,6 @@ export type PointerInputDeps = {
   root: Scene | ViewHandle
   /** The root's listeners, in registration order. */
   listeners: Set<ScenePointerListener>
-  /** The clock for tap repeats (default performance.now; checks inject). */
-  now?: () => number
 }
 
 export type PointerInput = {
@@ -108,7 +108,6 @@ export type PointerInput = {
 }
 
 export function makePointerInput(deps: PointerInputDeps): PointerInput {
-  let now = deps.now ?? (() => performance.now())
   let presses = new Map<number, Press>()
   let hover = new Map<number, Target>()
   let lastTap: { time: number; cx: number; cy: number; target: Target | null; count: number } | null = null
@@ -170,6 +169,8 @@ export function makePointerInput(deps: PointerInputDeps): PointerInput {
         distance: hit === null ? null : hit.distance,
         x,
         y,
+        timeStamp: e.timeStamp,
+        predicted: e.predicted,
         pointerId: e.pointerId,
         pointerType: e.pointerType,
         button: e.button,
@@ -245,7 +246,7 @@ export function makePointerInput(deps: PointerInputDeps): PointerInput {
         if (press.moved || !press.alone) return
         let release = nearest(x, y)
         if (press.target === null ? release !== null : release === null || !sameHit(release, press.target)) return
-        let time = now()
+        let time = e.timeStamp
         let repeat = lastTap !== null && time - lastTap.time <= TAP_INTERVAL_MS && sameTarget(lastTap.target, press.target) && Math.hypot(e.clientX - lastTap.cx, e.clientY - lastTap.cy) <= TAP_REPEAT_SLOP
         let count = repeat ? lastTap!.count + 1 : 1
         lastTap = { time, cx: e.clientX, cy: e.clientY, target: press.target, count }

package/src/scene.ts

@@ -635,7 +635,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 under bun and fails
-// the moment a runtime import creeps into the chain).
+// model-data rule; tests/splat-data.test.ts imports it on the bare flux
+// 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

@@ -0,0 +1,206 @@
+// 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
+// time. Put the output under assets/ so it ships with the app.
+//
+// The images are baked too: each PNG or JPEG becomes a KTX2 compressed
+// texture with its mip chain, which the device turns into its own block
+// format at load (a quarter of the GPU memory of the decoded image). One
+// file for every platform, so the tool takes no platform. How each image
+// is compressed, and whether, is the app's: the `textures` group of the
+// `solidrt` key in the package.json of the project the tool runs in, over
+// the defaults (@solidrt/core/textures) - per kind of map (color, normal,
+// data) and per file, an image named by its path from the project root
+// and an embedded one by `<model path>#<its name>`. --compress and
+// --no-compress stand in for the app's own `compress` for one run.
+//
+// A flux tool (the file name says so): the texture encoder is the
+// runtime's, flux:image. The model side comes from the runtime-free
+// `@solidrt/3d/model` entry (src/model-data.ts), the same surface an
+// app's own bake script uses under bun.
+//
+//   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"
+import { basename, dirname, extname, join, matchesGlob, relative } from "flux:path"
+import { argv, exit } from "flux:process"
+import { isKtx2, textureSettingFor, textureSettings, unmatchedTextureFiles, unmatchedTextureNames } from "@solidrt/core/textures"
+import type { TextureKind, TextureSetting, TextureSettings, TextureSource } from "@solidrt/core/textures"
+import { encodeModel, gltfExternalUris, layoutStride, modelImageUses, parseGltf } from "../src/model-data.ts"
+import type { ModelData, ModelImage } from "../src/model-data.ts"
+
+// The project's package.json, where the texture settings live.
+const PROJECT_CONFIG = "package.json"
+
+// How many images are decoded and encoded at once: what the runtime
+// encodes at a time. More would only queue, each with its decoded pixels.
+const IMAGES_IN_FLIGHT = 4
+
+// The project the tool runs in: its root is the cwd, which the patterns
+// of the texture settings are written from.
+const PROJECT_ROOT = "."
+
+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)
+  console.log(USAGE)
+  exit(error ? 1 : 0)
+}
+
+function kib(bytes: number): string {
+  return (bytes / 1024).toFixed(0) + " KiB"
+}
+
+function images(count: number): string {
+  return count === 1 ? "1 image" : count + " images"
+}
+
+// The texture settings of the project the tool runs in; the defaults where
+// it has no package.json. `compress` is the run's own word, when it has
+// one.
+async function projectTextureSettings(compress: boolean | undefined): Promise<TextureSettings> {
+  let config = file(PROJECT_CONFIG)
+  return textureSettings((await config.exists()) ? await config.json() : undefined, { compress })
+}
+
+// What an image is to the texture settings: its file as the path from the
+// project root, or for an embedded image the model's file and its name.
+function imageSource(image: ModelImage, model: string): TextureSource {
+  if (image.uri === undefined) return { file: relative(PROJECT_ROOT, model), name: image.name }
+  return { file: relative(PROJECT_ROOT, join(dirname(model), decodeURIComponent(image.uri))) }
+}
+
+// The entries of the settings that name nothing, which is a misspelled
+// pattern: a file the project does not have, a name the model does not.
+async function unmatchedPatterns(data: ModelData, model: string, settings: TextureSettings): Promise<string[]> {
+  let files = await unmatchedTextureFiles(settings, (pattern) => glob(pattern, { cwd: PROJECT_ROOT }))
+  let embedded = data.images.filter((image) => image.uri === undefined).map((image) => image.name)
+  return [...files, ...unmatchedTextureNames(settings, relative(PROJECT_ROOT, model), embedded, matchesGlob)]
+}
+
+// The images of one kind compressed the same way, and the ones kept.
+type Group = { kind: TextureKind; setting: TextureSetting; images: number; from: number; to: number }
+type Baked = { groups: Group[]; kept: { images: number; bytes: number } }
+
+// The images as KTX2, in place, each as the settings say for it and in
+// the color space createModel samples it in (modelImageUses, the rule the
+// two share), mipmapped for repeat wrap. IMAGES_IN_FLIGHT at a time, each
+// decoded when its turn comes. An image the settings leave alone is kept,
+// and so is one that is a KTX2 already.
+async function bakeImages(data: ModelData, model: string, settings: TextureSettings): Promise<Baked> {
+  let baked: Baked = { groups: [], kept: { images: 0, bytes: 0 } }
+  let groupOf = (kind: TextureKind, setting: TextureSetting): Group => {
+    let group = baked.groups.find((g) => g.kind === kind && g.setting.codec === setting.codec && g.setting.quality === setting.quality)
+    if (group === undefined) {
+      group = { kind, setting, images: 0, from: 0, to: 0 }
+      baked.groups.push(group)
+    }
+    return group
+  }
+  let uses = modelImageUses(data)
+  let next = 0
+  let lane = async () => {
+    while (next < data.images.length) {
+      let i = next++
+      let image = data.images[i]!
+      let source = image.bytes
+      let { kind, srgb } = uses[i]!
+      let setting = textureSettingFor(settings, kind, imageSource(image, model), matchesGlob)
+      if (!setting.compress || isKtx2(source)) {
+        baked.kept.images++
+        baked.kept.bytes += source.byteLength
+        continue
+      }
+      image.bytes = await encodeTexture(decodeImage(source), {
+        codec: setting.codec,
+        quality: setting.quality,
+        srgb,
+        mipmap: true,
+        wrap: "repeat",
+      })
+      let group = groupOf(kind, setting)
+      group.images++
+      group.from += source.byteLength
+      group.to += image.bytes.byteLength
+    }
+  }
+  await Promise.all(Array.from({ length: IMAGES_IN_FLIGHT }, lane))
+  let order: TextureKind[] = ["color", "normal", "data"]
+  baked.groups.sort((a, b) => order.indexOf(a.kind) - order.indexOf(b.kind))
+  return baked
+}
+
+let input: string | undefined
+let output: string | undefined
+let compress: boolean | undefined
+for (let i = 0; i < argv.length; i++) {
+  let arg = argv[i]!
+  if (arg === "--help" || arg === "-h") usage()
+  else if (arg === "-o" || arg === "--output") {
+    output = argv[++i]
+    if (output === undefined) usage("Missing value for " + arg)
+  } else if (arg === "--compress") compress = true
+  else if (arg === "--no-compress") compress = false
+  else if (arg.startsWith("-")) usage("Unknown option " + arg)
+  else if (input === undefined) input = arg
+  else usage("Unexpected argument " + arg)
+}
+if (input === undefined) usage("Missing input file")
+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).
+let dir = dirname(input)
+let bytes = await file(input).bytes()
+let files = new Map<string, Uint8Array>()
+for (let uri of gltfExternalUris(bytes)) {
+  if (!files.has(uri)) files.set(uri, await file(join(dir, decodeURIComponent(uri))).bytes())
+}
+
+let started = performance.now()
+let data = parseGltf(bytes, (uri) => files.get(uri)!)
+let parsed = performance.now() - started
+
+// Read and checked before the encode, so a mistake in the settings costs
+// no bake.
+let settings: TextureSettings
+let unmatched: string[]
+try {
+  settings = await projectTextureSettings(compress)
+  unmatched = await unmatchedPatterns(data, input, settings)
+} catch (e) {
+  console.error(`The texture settings in ${PROJECT_CONFIG} cannot be used: ${e instanceof Error ? e.message : String(e)}`)
+  exit(1)
+}
+if (unmatched.length > 0) {
+  console.error(`The texture settings in ${PROJECT_CONFIG} (solidrt.textures.files) name nothing with:`)
+  for (let pattern of unmatched) console.error(`  ${pattern}`)
+  console.error("A pattern is a path from the project root; after a model's path, #name picks an image embedded in it.")
+  exit(1)
+}
+started = performance.now()
+let baked = await bakeImages(data, input, settings)
+let bakeMs = performance.now() - started
+
+let encoded = encodeModel(data)
+await file(output).write(encoded)
+
+let triangles = data.parts.reduce((n, p) => n + p.geometry.indices.length / 3, 0)
+let vertices = data.parts.reduce((n, p) => n + p.geometry.vertices.byteLength / layoutStride(p.geometry.layout), 0)
+let targets = data.parts.reduce((n, p) => n + (p.geometry.morphs?.names.length ?? 0), 0)
+console.log(
+  `${output}: ${data.nodes.length} nodes, ${data.parts.length} parts, ${vertices} vertices, ${triangles} triangles, ` +
+    (targets > 0 ? `${targets} morph targets, ` : "") +
+    `${data.clips.length} clips, ${data.materials.length} materials, ${data.images.length} images, ${kib(encoded.byteLength)} ` +
+    `(parsed in ${parsed.toFixed(0)} ms)`,
+)
+if (baked.groups.length > 0) {
+  console.log(`Images as KTX2 (encoded in ${(bakeMs / 1000).toFixed(1)} s):`)
+  for (let group of baked.groups) {
+    console.log(`  ${group.kind}: ${images(group.images)}, ${group.setting.codec} at quality ${group.setting.quality}, ${kib(group.from)} to ${kib(group.to)}`)
+  }
+}
+if (baked.kept.images > 0) console.log(`Kept as they are: ${images(baked.kept.images)}, ${kib(baked.kept.bytes)}`)

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.

package/tools/model.ts

@@ -1,56 +0,0 @@
-#!/usr/bin/env bun
-/// <reference path="./node-env.d.ts" />
-
-// srt tool 3d/model: bake a glTF into a .srtm model file - the parse
-// (src/gltf.ts) run once here under bun, 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 time. Put the output under assets/ so it ships with the app.
-// Everything here comes from the runtime-free `@solidrt/3d/model` entry
-// (src/model-data.ts), the same surface an app's own bake script uses.
-//
-//   srt tool 3d/model <in.gltf|in.glb> [-o <out.srtm>]
-
-import { readFileSync, writeFileSync } from "node:fs"
-import { basename, dirname, extname, join } from "node:path"
-import { encodeModel, layoutStride, parseGltf } from "../src/model-data.ts"
-
-function usage(error?: string): never {
-  if (error) console.error(error)
-  console.log("Usage: srt tool 3d/model <in.gltf|in.glb> [-o <out.srtm>]")
-  process.exit(error ? 1 : 0)
-}
-
-let input: string | undefined
-let output: string | undefined
-let args = process.argv.slice(2)
-for (let i = 0; i < args.length; i++) {
-  let arg = args[i]!
-  if (arg === "--help" || arg === "-h") usage()
-  else if (arg === "-o" || arg === "--output") {
-    output = args[++i]
-    if (output === undefined) usage("Missing value for " + arg)
-  } else if (arg.startsWith("-")) usage("Unknown option " + arg)
-  else if (input === undefined) input = arg
-  else usage("Unexpected argument " + arg)
-}
-if (input === undefined) usage("Missing input file")
-if (output === undefined) output = basename(input, extname(input)) + ".srtm"
-
-let dir = dirname(input)
-let bytes = new Uint8Array(readFileSync(input))
-let started = performance.now()
-let data = parseGltf(bytes, (uri) => new Uint8Array(readFileSync(join(dir, decodeURIComponent(uri)))))
-let parsed = performance.now() - started
-let encoded = encodeModel(data)
-writeFileSync(output, encoded)
-
-let triangles = data.parts.reduce((n, p) => n + p.geometry.indices.length / 3, 0)
-let vertices = data.parts.reduce((n, p) => n + p.geometry.vertices.byteLength / layoutStride(p.geometry.layout), 0)
-let targets = data.parts.reduce((n, p) => n + (p.geometry.morphs?.names.length ?? 0), 0)
-console.log(
-  `${output}: ${data.nodes.length} nodes, ${data.parts.length} parts, ${vertices} vertices, ${triangles} triangles, ` +
-    (targets > 0 ? `${targets} morph targets, ` : "") +
-    `${data.clips.length} clips, ${data.materials.length} materials, ${data.images.length} images, ${(encoded.byteLength / 1024).toFixed(0)} KiB ` +
-    `(parsed in ${parsed.toFixed(0)} ms)`,
-)