@solidrt/core 0.0.64 → 0.0.66

package/AGENTS.md

@@ -92,7 +92,7 @@ real design decision, not an afterthought:
 
 ```sh
 bun add @solidrt/core        # the renderer
-bun add -d @solidrt/cli      # the `srt` tool (see its AGENTS.md)
+bun add -d @solidrt/cli      # the `sol` tool (see its AGENTS.md)
 ```
 
 Core primitives alone are enough to build a full app. The optional extensions
@@ -111,7 +111,7 @@ tsconfig.json - the two load-bearing lines are jsx + jsxImportSource:
 ```
 
 Peer deps @solidjs/signals and @solidjs/universal must match (currently
-2.0.0-rc.9); bun resolves them from peerDependencies. On a version bump,
+2.0.0-rc.13); bun resolves them from peerDependencies. On a version bump,
 `bun install` only warns ("incorrect peer dependency") and keeps the old
 ones, and `bun update solid-js @solidjs/signals @solidjs/universal` does
 not read the pin either: it adds all three to package.json at registry
@@ -316,6 +316,24 @@ that reads exactly like Solid fallout.
   nothing focused, the window alone), so `<window onKeyDown>` is the
   app-global shortcut point; `stopPropagation()` ends the walk. `focusable`
   declares focus-navigation candidacy (enumerate via getFocusables()).
+  Every pointer, wheel and key event carries `timeStamp` (ms): when the
+  input happened. Time anything about input with it (a press length, the
+  gap between two taps, a speed from two positions), never with
+  `performance.now()` in the handler: that is when the handler ran, and
+  it does not follow the dev clock, `sol render` or a test. The stamp is
+  the input's own time, not its delivery's: a move carries the time the
+  pointer was at the position it reports, however late the frame that
+  delivers it; a down, up, wheel or key the time the platform recorded.
+  Compare stamps only with each other.
+  A pointer move also carries `predicted` (false on every other event).
+  Touch arrives in batches, and a batch can miss the frame it belongs to;
+  the runtime then bridges the gap with one predicted step so a drag does
+  not stall and jump, and that move has `predicted: true`. DRAW with it,
+  like any move; do NOT MEASURE with it: leave it out of a velocity, a
+  path or a stroke you keep. If the finger had in fact stopped, the next
+  move reports where it really is with the time it got there, which is
+  EARLIER than the predicted move's `timeStamp` - the one case where
+  stamps go back. The recognizers below already do this.
 
 - Gesture recognizers, shared by every package: `createPan` (single-pointer
   drag, axis-aware slop, per-event dx/dy) and `createTransform` (merged
@@ -332,11 +350,16 @@ that reads exactly like Solid fallout.
   and two-finger translation different meanings - dx/dy alone cannot tell
   them apart).
   Both ends carry the lift velocity (`onPanEnd(velocity)`,
-  `onTransformEnd(velocity)`: parent-frame px/s from `createVelocityTracker`,
+  `onTransformEnd(velocity)`: parent-frame px/s from `createVelocityTracker`
+  (`push(x, y, e.timeStamp)`, `velocity(up.timeStamp)`: it reads no clock;
+  push real positions only, `if (!e.predicted)`),
   a least-squares fit over the last 100 ms of positions, never the last
   two samples - the final sample before a lift is often stationary and
-  frame batching makes the last delta a frame old; zero after a 50 ms
-  rest or under `FLING_MIN_VELOCITY`), the fling fact for whoever animates
+  frame batching makes the last delta a frame old; a pause over 40 ms
+  cuts the history, so only the motion after it counts; zero after a
+  50 ms rest, when that motion covers under 8 px (a finger leaving the
+  panel shifts a pixel or two, which is not a fling), or under
+  `FLING_MIN_VELOCITY`), the fling fact for whoever animates
   on. The discrete recognizers: `createSwipe({ directions?, onSwipe(direction,
   velocity), onSwipeMove?, onSwipeEnd? })` (a pan classified at the lift:
   24 px of travel at 300 px/s within 30 degrees of an axis, direction by
@@ -432,7 +455,12 @@ that reads exactly like Solid fallout.
   `chord(...sources)` are the interactions (Unity's Hold/Tap/MultiTap):
   button sources made from button sources, so a charged attack is
   `hold(pad.button("west"))` on one action next to the plain press on
-  another; a tap reads pressed for one task, enough for onPress.
+  another; a tap reads pressed for one task, enough for onPress. `tap`
+  and `doubleTap` time a press with the source's own `changedAt()` (the
+  `timeStamp` of the event behind each edge; keyboard keys and pad
+  buttons carry it), so a custom button source has to provide it to sit
+  under one, and they throw on one that does not (a pointer pulse, a
+  `hold`). A key lost to a blur is no tap.
   Consumers with the axes contract (`createAxes({ rotate: "vec2", zoom:
   "axis" }, { onNudge, onBegin, onEnd })`, what every camera control
   exposes as `.axes`) are connected by name with `input.drive(control.axes,
@@ -479,8 +507,8 @@ that reads exactly like Solid fallout.
   forward], forward = -y), `rise` axis (up). The runtime-free
   half (`createInputMap`, `createAxes`, `keyboard`, the processors) is
   importable as `@solidrt/core/input` for headless checks;
-  checks/input-map-check.ts runs it on the bare flux binary, and
-  checks/input-gamepad-check.ts drives the gamepad device and the join
+  tests/input-map.test.ts runs it on the bare flux binary, and
+  tests/input-gamepad.test.ts drives the gamepad device and the join
   order over a signal of pad snapshots (input-gamepad-device.ts is
   runtime-free; input-gamepad.ts hands it gamepads()). The pointer
   feed's discrete pulses (`doubleTap`, `longPress`) bound to an AXIS
@@ -494,7 +522,7 @@ that reads exactly like Solid fallout.
   on, and the shot blender (`createShotBlend`: several cameras, a
   priority, a timed blend, over the packages' `createShots`) - is
   `@solidrt/core/camera-control`, pure, pinned by
-  checks/camera-control-check.ts; okf/design/camera-controls.md is the
+  tests/camera-control.test.ts; okf/design/camera-controls.md is the
   pipeline the 2d and 3d controls run over it.
 
 - Reactivity is SolidJS 2.0 (`@solidjs/signals`), NOT Solid 1.x. `createSignal`
@@ -581,7 +609,14 @@ that reads exactly like Solid fallout.
   apply, return it so the loop runs only while the condition holds); `rate` is the
   display's nominal refresh rate in Hz, which a fixed-timestep loop needs
   (see @solidrt/cli agents/debugging.md on stepping); `requestAnimationFrame`
-  exists as a web-standard one-shot but is not the preferred driver. A JS
+  exists as a web-standard one-shot but is not the preferred driver.
+  `onFrame(fn, { demand: false })` is the same hook without the standing
+  frame request: it runs on every frame the runtime delivers and the app
+  presents only when the body writes, for a loop that follows time but
+  seldom changes the picture. `frameTime()` is the current frame's `tick`
+  read from anywhere (not reactive, requests nothing): the app's own
+  clock for code with no tick in hand, where `performance.now()` would
+  ignore the dev clock, `sol render` and tests. A JS
   tween loop or an animation library pushing interpolated values through
   signals is the single most expensive mistake available here - read
   agents/performance.md before writing either.
@@ -612,6 +647,54 @@ that reads exactly like Solid fallout.
   transparent pixels for CPU work, and `encodeImage` converts back to
   straight for the file.
 
+- Compressed textures, for anything that holds many or large textures (a
+  3D model, a tile set): ship ONE KTX2 file per image and let each device
+  turn it into the block format its GPU samples, a quarter of the memory
+  of the decoded image. `encodeTexture(decodeImage(bytes), { codec, srgb,
+  mipmap })` makes the file at bake time (slow, never at load);
+  `transcodeTexture(ktx2)` -> `createTexture(t.data, t.width, t.height,
+  { format: t.format, mipmap: t.mipmap })` loads it, picking the
+  device's format by itself. Start a transcode per texture and await
+  them together: the runtime runs four at a time. Such a texture is
+  sample-only (no upload into it, no readback, no generated mips: the
+  chain comes from the file). Block compression is lossy and damages
+  sharp art and text, so it is not for UI images. The runtime-free half
+  is `@solidrt/core/textures`, importable under bun by a bake script or
+  an extension's pure modules: `isKtx2(bytes)` tells such a file from a
+  PNG or JPEG, and `textureSettings(packageJson)` reads how an app
+  wants its textures compressed, declared under `solidrt.textures` in
+  its package.json, so every bake, whoever wrote it, honors the same
+  settings. Three levels, the narrower one winning: `compress` for the
+  app (on unless it says otherwise), `compress` / `codec` / `quality`
+  per kind of texture, and `files`, a list of entries that each name
+  files by glob pattern (`match`, a path from the project root) and set
+  the same three for them, a later entry winning over an earlier one.
+  The kinds say what the texels ARE, not what draws them:
+  `color` (sRGB color the eye sees), `normal` (directions), `data`
+  (other linear values that tolerate a small error: a mask, a
+  roughness). An extension maps its own uses onto them. Values that
+  must come back exact (a lookup table, a distance field) are none of
+  the three and are not block compressed: an entry with
+  `"compress": false` keeps them as their file. A bake asks per
+  texture, and checks the patterns before it encodes anything, passing
+  the runtime's matcher and scan in (the entry itself has no runtime):
+
+  ```ts
+  import { glob } from "flux:fs"
+  import { matchesGlob } from "flux:path"
+  import { textureSettings, textureSettingFor, unmatchedTextureFiles } from "@solidrt/core/textures"
+
+  let settings = textureSettings(await file("package.json").json())
+  let unmatched = await unmatchedTextureFiles(settings, (pattern) => glob(pattern, { cwd: "." }))
+  if (unmatched.length > 0) throw new Error("No file matches " + unmatched.join(", "))
+  let setting = textureSettingFor(settings, "color", { file: "assets/tiles/ground.png" }, matchesGlob)
+  if (setting.compress) bytes = await encodeTexture(decodeImage(bytes), { codec: setting.codec, quality: setting.quality, srgb: true, mipmap: true })
+  ```
+
+  A texture embedded in another file (an image inside a .glb) is
+  `{ file, name }`, and a pattern picks it as `<file>#<name>`;
+  `unmatchedTextureNames` reports the names a file does not have.
+
 ## Minimal app, core primitives only (verified to render)
 
 ```tsx

package/README.md

@@ -35,7 +35,7 @@ render(() => <App />)
 Run the app:
 
 ```sh
-bunx srt run src/index.tsx
+bun run sol run src/index.tsx
 ```
 
 Optionally, create a `tsconfig.json` to enable type recognition for SolidRT elements:

package/agents/performance.md

@@ -92,7 +92,12 @@ Rules, in order of leverage:
    while a condition holds is an effect returning it:
    `createEffect(() => active(), on => { if (!on) return; return onFrame(...) })`
    - the apply phase has no owner, so onFrame registers nothing there and
-   the returned cleanup is the handle the effect disposes.
+   the returned cleanup is the handle the effect disposes. A loop that
+   follows time but changes the picture only now and then (a clip stepping
+   at 8 fps, a clock face) registers with `onFrame(fn, { demand: false })`:
+   it is called on every frame the runtime runs, requests none itself, and
+   the app presents only when the body writes something. `frameTime()`
+   reads the current frame's tick with no callback at all.
 5. repaintBoundary works like Flutter's: transforms and opacity on the
    boundary node itself (or any ancestor) are hoisted out of the cache and
    applied at composite time, so animating x/y/scale/rotate/opacity of a
@@ -144,7 +149,7 @@ Rules, in order of leverage:
    anything needing what is behind it does not - and is split from content
    invalidation, so a params-only change re-runs the pass against the cached
    snapshot instead of re-rasterizing. A window shader's output is invisible
-   to get_snapshot and every other MCP tool; `bunx srt render` is the only
+   to get_snapshot and every other MCP tool; `bun run sol render` is the only
    way to see it (see @solidrt/cli AGENTS.md).
 8. `flux:wasm` runs a pure interpreter (wasmi, no JIT), so temper browser
    expectations - but do not write it off for compute. A genuinely numeric
@@ -203,7 +208,7 @@ let n = await worker.crunch(bytes)              // main keeps rendering meanwhil
 ```
 
 The bundler builds each such module as its own bundle and ships it with the
-app (dev pushes and `srt pack` alike). Rules: main may only `import type`
+app (dev pushes and `sol pack` alike). Rules: main may only `import type`
 from an isolate module (a value import is a build error); arguments and
 results are copies (numbers, strings, byte buffers, arrays, plain objects -
 no functions, no class instances); the child has the non-gui `flux:*`
@@ -243,7 +248,7 @@ not infer it from the desktop number.
 - **Some paints cost a frame each on a tiled mobile GPU.** Measured on a
   mid-range 2020 tablet (Adreno 610, Impeller GLES) with ten panes sliding
   and resizing on a layout transition, each row by subtraction from the
-  compositor's own present record (`srt android --census`), against a
+  compositor's own present record (`sol android --census`), against a
   frame that ran at 60 fps with a 13 ms GPU span:
   - a 3-stop linear-gradient fill per pane: +15 ms, 20 fps. A gradient is
     shaded per pixel per frame; the same tint as a flat `d-rect` costs

package/docs/index.md

@@ -98,6 +98,15 @@ bubble the same way, starting at the focused node - or at the window root
 when nothing is focused, so `onKeyDown` on the window is where app-global
 shortcuts live.
 
+Every input event carries `timeStamp`, in milliseconds: when the input
+happened, not when the handler ran. Time a press, the gap between two taps
+or a speed with it. A pointer move also carries `predicted`. Touch arrives
+in batches, and when one is late the runtime bridges the frame with a
+predicted position so a drag does not stall; that move has `predicted:
+true`. Draw with it, but leave it out of anything you measure or keep, such
+as a velocity or a stroke: if the finger had stopped, the next move reports
+where it really is, with an earlier `timeStamp`.
+
 Text entry goes to the focused node's `onTextInput`. Focusing a field never
 raises the on-screen keyboard by itself - a tap on the field (or an explicit
 `startTextInput()`) does, and never while a physical keyboard is attached.
@@ -167,7 +176,7 @@ animation and audio, not the persistence moment.
 A link from outside (a custom scheme link the OS routed to the app, or one
 a dev tool sent) arrives raw: `env.launchLink` is the one this run of the
 app was started with (null without; a hot reload starts at the location
-the app last reported, see `reportLocation` in `srt:dev`), `onLink` fires
+the app last reported, see `reportLocation` in `sol:dev`), `onLink` fires
 for one arriving while the app runs. What a link names is the app's to decide, and it is untrusted input:
 validate before acting on any part of it. A router turns links into screens
 for you; without one, parse it yourself. The scheme a packed app answers to

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidrt/core",
-  "version": "0.0.64",
+  "version": "0.0.66",
   "license": "MIT",
   "funding": "https://github.com/sponsors/wellawaretech",
   "author": "Antoine van Wel",
@@ -19,6 +19,7 @@
     "./microphone": "./src/microphone.ts",
     "./speech-recognition": "./src/speech-recognition.ts",
     "./text-input": "./src/text-input.ts",
+    "./textures": "./src/textures.ts",
     "./video": "./src/video.ts",
     "./jsx-runtime": "./jsx-runtime.d.ts",
     "./jsx-runtime-dev": "./jsx-runtime.d.ts"
@@ -32,11 +33,12 @@
     "AGENTS.md"
   ],
   "devDependencies": {
-    "@solidrt/flux-types": "0.0.64"
+    "@solidrt/flux-types": "0.0.66",
+    "@solidrt/test": "0.0.66"
   },
   "peerDependencies": {
-    "@solidjs/signals": "2.0.0-rc.9",
-    "@solidjs/universal": "2.0.0-rc.9",
-    "solid-js": "2.0.0-rc.9"
+    "@solidjs/signals": "2.0.0-rc.13",
+    "@solidjs/universal": "2.0.0-rc.13",
+    "solid-js": "2.0.0-rc.13"
   }
 }

package/src/camera.ts

@@ -9,7 +9,7 @@
 import { createSignal, onCleanup } from "@solidjs/signals"
 import { listCameras, open } from "flux:camera"
 import type { TextureId } from "flux:gpu"
-import { on } from "srt:events"
+import { on } from "sol:events"
 
 export type CameraFacing = "front" | "back" | "unknown"
 

package/src/core.ts

@@ -1,7 +1,7 @@
 import * as tree from "flux:rendertree"
 import type { TextureId } from "flux:gpu"
 import { createSignal, getOwner, onCleanup } from "@solidjs/signals"
-import { on } from "srt:events"
+import { on } from "sol:events"
 
 let handlers = new Map<number, Map<string, Function>>()
 
@@ -38,9 +38,12 @@ function syncInterest(nodeId: number): void {
 /**
  * A pointer fact with no per-node fields: window coordinates plus pointer
  * identity and modifiers. `target` is the deepest node under the pointer
- * (0 when nothing is hit).
+ * (0 when nothing is hit). `timeStamp` and `predicted` are
+ * `PointerEvent`'s.
  */
 export interface GlobalPointerEvent {
+  timeStamp: number
+  predicted: boolean
   clientX: number
   clientY: number
   target: number
@@ -70,6 +73,8 @@ export function onPointerMove(fn: (e: GlobalPointerEvent) => void): () => void {
   if (globalMoveSubs.size === 1) {
     globalMoveUnsub = on("pointerMove", (raw: any) => {
       let e: GlobalPointerEvent = {
+        timeStamp: raw.timeStamp,
+        predicted: raw.predicted,
         clientX: raw.clientX,
         clientY: raw.clientY,
         target: raw.target,

package/src/double-tap.ts

@@ -63,7 +63,7 @@ export function createTapSequence(options: TapSequenceOptions) {
   }
   return {
     down(e: PointerEvent) {
-      let now = performance.now()
+      let now = e.timeStamp
       if (first) {
         if (first.upAt === null) {
           // A second finger while the first is down: neither is a tap.
@@ -88,7 +88,7 @@ export function createTapSequence(options: TapSequenceOptions) {
     },
     up(e: PointerEvent) {
       if (!first || first.id !== e.pointerId || first.upAt !== null) return
-      let now = performance.now()
+      let now = e.timeStamp
       if (now - first.downAt > TAP_MAX_MS) {
         settle(false)
         return

package/src/environment.ts

@@ -1,5 +1,5 @@
 import { createSignal, runWithOwner } from "@solidjs/signals"
-import { on } from "srt:events"
+import { on } from "sol:events"
 import { onPointerMove } from "./core"
 import { windowSize, safeArea, displayScale, windowFocused, keyboardHeight } from "./window"
 
@@ -16,7 +16,7 @@ import { windowSize, safeArea, displayScale, windowFocused, keyboardHeight } fro
 // runs, which is usually inside a component or a computation (a memo's first
 // read of env.inputDevices, a HUD effect's first read of pointerLocked()).
 // Created there, the fact would belong to that reader: sticky events replay
-// their cached value synchronously on subscribe (srt:events' on()), so the
+// their cached value synchronously on subscribe (sol:events' on()), so the
 // on() call writes the signal it just created inside the reader's owned
 // scope - a render-time write, which the guard rejects - and a root or a
 // subscription created there is disposed with the reader. The facts are
@@ -274,7 +274,7 @@ export let env = {
   },
   /**
    * The link this process was started with, or null: a custom scheme link
-   * the OS routed to the app (Android intent data; `srt render --link`),
+   * the OS routed to the app (Android intent data; `sol render --link`),
    * raw, exactly as it arrived. What it names is the app's to decide, and
    * it is untrusted input: validate before acting on any part of it. A link
    * arriving while the app runs is an event instead: `onLink`. Fixed for the

package/src/gamepad.ts

@@ -1,5 +1,5 @@
 import { createSignal, runWithOwner } from "@solidjs/signals"
-import { on } from "srt:events"
+import { on } from "sol:events"
 
 // Gamepad State: a reactive mirror of the runtime's sticky "gamepads" event.
 //
@@ -43,6 +43,33 @@ export interface GamepadState {
 
 let gamepadsAccessor: (() => (GamepadState | null)[]) | undefined
 
+// When each pad button last changed: per slot, button name to the
+// `timeStamp` of the "gamepads" event that pressed or released it. Kept
+// here, where every snapshot passes once, because a reader of the
+// accessor sees only the latest one.
+let buttonTimes: Map<string, number>[] = []
+let lastPads: (GamepadState | null)[] = []
+
+function recordButtonTimes(pads: (GamepadState | null)[], at: number): void {
+  for (let slot = 0; slot < Math.max(pads.length, lastPads.length); slot++) {
+    let before = lastPads[slot]?.buttons ?? []
+    let after = pads[slot]?.buttons ?? []
+    let times = (buttonTimes[slot] ??= new Map())
+    for (let name of after) if (!before.includes(name)) times.set(name, at)
+    for (let name of before) if (!after.includes(name)) times.set(name, at)
+  }
+  lastPads = pads
+}
+
+/** When the button `name` of the pad in `slot` was last pressed or
+ * released, as the `timeStamp` (ms, the clock of `PointerEvent.timeStamp`)
+ * of the pad snapshot that carried the change; null when it never
+ * changed. Needs `gamepads()` to have been read: the snapshots are
+ * watched from its first read on. */
+export function gamepadButtonChangedAt(slot: number, name: string): number | null {
+  return buttonTimes[slot]?.get(name) ?? null
+}
+
 /**
  * Connected gamepads as a reactive accessor. Slots are stable web-style: a
  * pad keeps its index for its whole connection, disconnecting leaves a null
@@ -56,7 +83,11 @@ export function gamepads(): (GamepadState | null)[] {
     // and the first read is usually a tracked scope (see environment.ts).
     runWithOwner(null, () => {
       let [pads, setPads] = createSignal<(GamepadState | null)[]>([])
-      on("gamepads", (e: { pads?: (GamepadState | null)[] }) => setPads(e.pads ?? []))
+      on("gamepads", (e: { pads?: (GamepadState | null)[]; timeStamp: number }) => {
+        let next = e.pads ?? []
+        recordButtonTimes(next, e.timeStamp)
+        setPads(next)
+      })
       gamepadsAccessor = pads
     })
   }

package/src/gpu.ts

@@ -84,11 +84,12 @@ export type { FilterMode, WrapMode, TextureBinding, TextureBindings } from "flux
 // HDR image format "rgba16f" (Float32Array payload packed to half float,
 // filterable) and the integer data-texture format "rgba32ui" (Uint32Array
 // payload, a uvec4 per texel through a usampler2D, nearest/texelFetch only)
-// - see TextureFormat in flux:gpu for each format's contract.
-// Draw targets (createDrawTarget, createCubeDrawTarget) take the renderable
-// subset: "rgba8", "rgba8-srgb", "rgba16f".
-// "etc2-rgba8" (compressed) is a reserved future value of the same
-// vocabulary.
+// and the block-compressed formats "etc2-rgba8"/"etc2-rgba8-srgb" (GLES 3.0
+// core, every device) and "bc7-rgba8"/"bc7-rgba8-srgb" (desktops, behind
+// limits.bc7Textures): raw 4x4 blocks, the full mip chain when mipmap is
+// set, create-once and sample-only - see TextureFormat in flux:gpu for each
+// format's contract. Draw targets (createDrawTarget, createCubeDrawTarget)
+// take the renderable subset: "rgba8", "rgba8-srgb", "rgba16f".
 export type TextureFormatOptions = { format?: gpu.TextureFormat }
 export type { TextureFormat } from "flux:gpu"
 
@@ -346,7 +347,7 @@ export function createMutableTexture(
  * `packed` as a keyword, so `vec4 packed = texture(...)` fails with a syntax
  * error that does not name the identifier - pick another name.
  *
- * A bad source is a runtime failure, not one `srt check` catches: the compile
+ * A bad source is a runtime failure, not one `sol check` catches: the compile
  * throws at this call, so a shader created in a component body takes the app
  * to the error window unless an `<Errored>` closer in the tree claims it.
  */

package/src/image.ts

@@ -6,10 +6,18 @@
 
 import { createMemo, onCleanup } from "@solidjs/signals"
 import { decodeImage, type DecodedImage } from "flux:image"
+import type { TextureCodec } from "flux:image"
 import { createTexture, destroyTexture, type TextureId } from "./gpu"
+import type { TextureCodec as SettingsCodec } from "./textures"
 
-export { decodeImage, encodeImage } from "flux:image"
-export type { DecodedImage } from "flux:image"
+export { decodeImage, encodeImage, encodeTexture, transcodeTexture } from "flux:image"
+export type { DecodedImage, TextureCodec, TranscodedTexture } from "flux:image"
+
+// The codecs the texture settings name (./textures, which takes no type
+// from the runtime) are the encoder's: a codec added to one side alone
+// stops this line from compiling.
+type SameType<A, B> = [A] extends [B] ? ([B] extends [A] ? true : false) : false
+const SETTINGS_NAME_THE_ENCODERS_CODECS: SameType<SettingsCodec, TextureCodec> = true
 
 export type ImageSource = string | Uint8Array
 

package/src/index.ts

@@ -3,8 +3,8 @@ export { setFocus, focusedNode, startTextInput, textInputActive, getFocusables,
 export type { BoundingBox, GlobalPointerEvent, TextLine } from "./core"
 export { parseColor, mixColors, withAlpha, brightness, createLinearGradient, createRadialGradient } from "./color"
 export type { Gradient, GradientStop } from "./color"
-export { onFrame, onLayout, onResize, onWindowFocus, onWindowBlur, onBack, onLink, onSuspend, onQuit, exit, background, registerProtocolHandler } from "./window"
-export type { BackEvent, LifecycleHandler } from "./window"
+export { onFrame, frameTime, onLayout, onResize, onWindowFocus, onWindowBlur, onBack, onLink, onSuspend, onQuit, exit, background, registerProtocolHandler } from "./window"
+export type { BackEvent, FrameOptions, LifecycleHandler } from "./window"
 export { windowSize, safeArea, displayScale, windowFocused, keyboardHeight, lockPointer, pointerLocked } from "./window"
 export { env } from "./environment"
 export type { InputDevices, SystemTheme, Orientation, Visibility, Launch } from "./environment"
@@ -14,10 +14,12 @@ export { capabilities } from "./capabilities"
 export type { Capabilities, WindowSizeClass } from "./capabilities"
 export { createCubeTexture, createTexture } from "./gpu"
 export type { TextureId } from "./gpu"
-export { createImage, decodeImage, encodeImage } from "./image"
+export { createImage, decodeImage, encodeImage, encodeTexture, transcodeTexture } from "./image"
 export { createCursor } from "./cursor"
 export type { CursorFrame, CursorId, CursorName, CursorOptions } from "./cursor"
-export type { DecodedImage, ImageSource } from "./image"
+export type { DecodedImage, ImageSource, TextureCodec, TranscodedTexture } from "./image"
+export { isKtx2, textureSettings, textureSettingFor, unmatchedTextureFiles, unmatchedTextureNames, DEFAULT_TEXTURE_SETTINGS } from "./textures"
+export type { GlobMatcher, GlobScan, TextureFileRule, TextureKind, TextureSetting, TextureSettings, TextureSource } from "./textures"
 export { parseSvg, svg } from "./svg"
 export { Logo } from "./logo"
 export type { LogoProps } from "./logo"

package/src/input-gamepad-device.ts

@@ -1,8 +1,8 @@
-// A gamepad as input sources, over any accessor of pad snapshots: sticks
+// A gamepad as input sources, over any reader of pad snapshots: sticks
 // and the dpad as vec2, triggers and shoulders as axes, any button as a
-// button, any raw axis by name. Runtime-free (the accessor is injected,
+// button, any raw axis by name. Runtime-free (the reader is injected,
 // the public `gamepad` in input-gamepad.ts hands in core's gamepads()),
-// so the join logic below runs headless in the checks.
+// so the join logic below runs headless in the tests.
 //
 // Every read is reactive when the accessor is (gamepads() is a signal),
 // so a stick moved while a control's frame loop is off wakes it. Sticks
@@ -33,7 +33,14 @@ const LISTEN_THRESHOLD = 0.5
 // saved binding restores onto the device the app hands in.
 const DEVICE = "gamepad"
 
-export type PadsAccessor = () => (GamepadState | null)[]
+/** What a gamepad device reads: the pad snapshots by slot (reactive),
+ * and when a slot's button last changed (the `timeStamp` of the snapshot
+ * that pressed or released it, null when it never did), which is what a
+ * button source reports as its `changedAt`. */
+export interface PadsReader {
+  pads(): (GamepadState | null)[]
+  buttonChangedAt(slot: number, name: string): number | null
+}
 
 export interface GamepadDevice extends InputDevice {
   readonly name: "gamepad"
@@ -74,9 +81,10 @@ const DPAD_BUTTONS = ["dpadUp", "dpadDown", "dpadLeft", "dpadRight"]
 
 /**
  * The sources over `pads()` (the pads this device reads now, reactive),
- * with `slot()` as the device's slot and `who` as the label prefix.
+ * with `slot()` as the device's slot, `buttonChangedAt` as the time a
+ * button of the pads it reads last changed, and `who` as the label prefix.
  */
-export function createGamepadDevice(pads: () => GamepadState[], slot: () => number | undefined, who: string): GamepadDevice {
+export function createGamepadDevice(pads: () => GamepadState[], slot: () => number | undefined, buttonChangedAt: (name: string) => number | null, who: string): GamepadDevice {
   let sumAxis = (read: (pad: GamepadState) => number) => (): number => {
     let sum = 0
     for (let pad of pads()) sum += read(pad)
@@ -145,7 +153,7 @@ export function createGamepadDevice(pads: () => GamepadState[], slot: () => numb
       if (typeof name !== "string" || name.length === 0) throw new Error(`gamepad.button: expected a button name, got ${String(name)}`)
       let source = buttons.get(name)
       if (!source) {
-        source = { kind: "button", label: `${who} ${name}`, id: `${DEVICE}:button:${name}`, device: DEVICE, rate: anyButton(name) }
+        source = { kind: "button", label: `${who} ${name}`, id: `${DEVICE}:button:${name}`, device: DEVICE, rate: anyButton(name), changedAt: () => buttonChangedAt(name) }
         buttons.set(name, source)
       }
       return source
@@ -216,22 +224,34 @@ export function createGamepadDevice(pads: () => GamepadState[], slot: () => numb
 }
 
 /** One slot, or every connected pad when `slot` is undefined. */
-export function createGamepadSlot(read: PadsAccessor, slot: number | undefined): GamepadDevice {
+export function createGamepadSlot(read: PadsReader, slot: number | undefined): GamepadDevice {
   if (slot !== undefined && !(Number.isInteger(slot) && slot >= 0)) throw new Error(`gamepad: slot must be a non-negative integer, got ${String(slot)}`)
   let pads = (): GamepadState[] => {
-    let all = read()
+    let all = read.pads()
     if (slot === undefined) return all.filter((p): p is GamepadState => p !== null)
     let pad = all[slot]
     return pad ? [pad] : []
   }
-  return createGamepadDevice(pads, () => slot, slot === undefined ? "gamepad" : `gamepad ${slot}`)
+  // Every pad: the latest change on any slot, as the button reads pressed
+  // while any of them holds it.
+  let changedAt = (name: string): number | null => {
+    if (slot !== undefined) return read.buttonChangedAt(slot, name)
+    let latest: number | null = null
+    let count = untrack(read.pads).length
+    for (let i = 0; i < count; i++) {
+      let at = read.buttonChangedAt(i, name)
+      if (at !== null && (latest === null || at > latest)) latest = at
+    }
+    return latest
+  }
+  return createGamepadDevice(pads, () => slot, changedAt, slot === undefined ? "gamepad" : `gamepad ${slot}`)
 }
 
 // Slots held by joining devices, shared so a pad joins once.
 let claimed = new Set<number>()
 
 /** A device that claims the next unclaimed pad to press any button. */
-export function createGamepadJoin(read: PadsAccessor): GamepadDevice {
+export function createGamepadJoin(read: PadsReader): GamepadDevice {
   // ownedWrite: the claim lands inside an effect, the release in a cleanup.
   let [slot, setSlot] = createSignal<number | undefined>(undefined, { ownedWrite: true })
   let mine: number | undefined
@@ -239,7 +259,7 @@ export function createGamepadJoin(read: PadsAccessor): GamepadDevice {
   // the device only when there is none to tie it to.
   let dispose = createRoot(dispose => {
     createEffect(
-      () => read(),
+      () => read.pads(),
       pads => {
         if (mine !== undefined) return
         for (let i = 0; i < pads.length; i++) {
@@ -263,8 +283,12 @@ export function createGamepadJoin(read: PadsAccessor): GamepadDevice {
   let pads = (): GamepadState[] => {
     let s = slot()
     if (s === undefined) return []
-    let pad = read()[s]
+    let pad = read.pads()[s]
     return pad ? [pad] : []
   }
-  return createGamepadDevice(pads, slot, "gamepad (joined)")
+  let changedAt = (name: string): number | null => {
+    let s = untrack(slot)
+    return s === undefined ? null : read.buttonChangedAt(s, name)
+  }
+  return createGamepadDevice(pads, slot, changedAt, "gamepad (joined)")
 }

package/src/input-gamepad.ts

@@ -6,14 +6,16 @@
 // split screen that seats players in pick-up order. The sources and the
 // join logic live in input-gamepad-device.ts, runtime-free.
 
-import { gamepads } from "./gamepad"
+import { gamepadButtonChangedAt, gamepads } from "./gamepad"
 import { createGamepadJoin, createGamepadSlot } from "./input-gamepad-device"
-import type { GamepadDevice } from "./input-gamepad-device"
+import type { GamepadDevice, PadsReader } from "./input-gamepad-device"
 
 export type { GamepadDevice } from "./input-gamepad-device"
 
+let reader: PadsReader = { pads: gamepads, buttonChangedAt: gamepadButtonChangedAt }
+
 export function gamepad(slot?: number): GamepadDevice {
-  return createGamepadSlot(gamepads, slot)
+  return createGamepadSlot(reader, slot)
 }
 
 /**
@@ -21,4 +23,4 @@ export function gamepad(slot?: number): GamepadDevice {
  * any button, then that pad for good (`slot` resolves, reactively). The
  * claim is released when the creating scope is disposed.
  */
-gamepad.next = (): GamepadDevice => createGamepadJoin(gamepads)
+gamepad.next = (): GamepadDevice => createGamepadJoin(reader)