@solidrt/core 0.0.65 → 0.0.67

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
@@ -320,7 +320,7 @@ that reads exactly like Solid fallout.
   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, `srt render` or a test. The stamp is
+  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.
@@ -616,7 +616,7 @@ that reads exactly like Solid fallout.
   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, `srt render` and tests. A JS
+  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.

package/README.md

@@ -35,7 +35,7 @@ render(() => <App />)
 Run the app:
 
 ```sh
-bun run 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

@@ -149,29 +149,31 @@ 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; `bun run 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
-   kernel (typed-array math, tight inner loops, no host calls inside the
-   loop) compiled from a systems language can come out a real multiple
-   faster than the same loop in interpreted JavaScript, and when profiling
-   shows such a kernel is what the app is spending its time on, that
-   multiple is worth having: measure the JS loop, port the kernel, measure
-   again, keep whichever wins. What wasm does not do is speed up
-   render-path work (rules 1-3 are that leverage), and every host call
-   costs marshalling, so batch at the boundary - one call over a byte
-   buffer, not a call per element. It is also the way to ship one compiled
-   module across every target with no native toolchain, and it pairs with
-   an isolate when a call runs long enough to block.
-9. `flux:ffi` (dlopen of a native library) is a binding tool, not a
-   performance tool. It needs a shared library compiled per platform and
-   architecture and shipped under each target's packing rules (Android
-   loads only what arrives inside the APK as a lib*.so), so reaching for
-   it "to make something fast" buys a build-and-packaging problem on every
-   platform the app targets. Use it when the app must call a native
-   library that already exists and already ships for those targets; for
-   speed, everything above comes first.
+8. `flux:wasm` compiles a module to machine code on devices that allow it
+   (`Flux.capabilities` lists `wasm-native`: desktop, 64-bit Android) and
+   interprets it elsewhere (iOS, 32-bit Android). Both lanes are the fast
+   lane for compute: measured on a desktop, an arm64 tablet and a 32-bit
+   TV, a numeric kernel (typed-array math, tight inner loops, no host calls
+   inside the loop) runs 18x to 960x faster than the same loop in
+   JavaScript when compiled and 4x to 88x when interpreted, float at the low
+   end, integer and SIMD-shaped loops at the high end. So when profiling
+   shows such a kernel is where the app spends its time, port it: measure
+   the JS loop, port the kernel, measure again, keep whichever wins. The
+   boundary is the cost, not the code: a host call out of the module costs
+   3x to 7x a plain JavaScript call, two to three hundred iterations of a
+   tight loop, so batch at the boundary - one call per frame over a byte
+   buffer, never a call per element. What wasm does not do is speed up
+   render-path work (rules 1-3 are that leverage). It is also the way to
+   ship one compiled module across every target with no native toolchain,
+   and it pairs with an isolate when a call runs long enough to block.
+9. There is no native-library route from app code. A shared library is
+   compiled per platform, so it cannot travel in a portable app payload,
+   and Android loads only what arrived inside the APK. Binding one is a
+   custom runtime build: the runtime crates with the library registered
+   beside the built-in modules. For speed, everything above comes first;
+   for a proven library that has a wasm build, rule 8.
 10. Text costs shaping, once per word per style, through a shared word cache;
    line breaking is arithmetic over the shaped words. So re-breaking text
    every frame with prepareText + layoutNextLine (a shape that breathes, an
@@ -188,7 +190,7 @@ Rules, in order of leverage:
 ## Isolates: heavy work off the JS thread
 
 A long synchronous computation (a big parse, a simulation step, a blocking
-`flux:ffi`/`flux:wasm` call) freezes rendering and input for its duration.
+`flux:wasm` call) freezes rendering and input for its duration.
 Move it into an isolate module: a file whose first statement is the
 `"use isolate"` directive runs in a second runtime on its own thread, and
 main calls its exports as async functions.
@@ -208,7 +210,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:*`
@@ -248,7 +250,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

@@ -91,9 +91,13 @@ ancestor with `position="relative"`.
 ## Input
 
 Pointer, wheel, and key events are props on any element:
-`onPointerDown`, `onPointerMove`, `onPointerUp`, `onPointerEnter`,
-`onPointerLeave`, `onWheel`, `onKeyDown`, `onKeyUp`. Events travel from the
-hit leaf up to the root, and `stopPropagation()` ends the walk. Key events
+`onPointerDown`, `onPointerMove`, `onPointerUp`, `onPointerCancel`,
+`onPointerEnter`, `onPointerLeave`, `onWheel`, `onKeyDown`, `onKeyUp`.
+Events travel from the hit leaf up to the root, and `stopPropagation()`
+ends the walk. A pointer ends with an up or a cancel, never both: the
+cancel is the system taking the touch away (a back swipe, palm rejection),
+delivered along the pressed path with the pointer's last position, so a
+press ends without firing and a drag ends without a fling. Key events
 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.
@@ -176,7 +180,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.65",
+  "version": "0.0.67",
   "license": "MIT",
   "funding": "https://github.com/sponsors/wellawaretech",
   "author": "Antoine van Wel",
@@ -33,8 +33,8 @@
     "AGENTS.md"
   ],
   "devDependencies": {
-    "@solidrt/flux-types": "0.0.65",
-    "@solidrt/test": "0.0.65"
+    "@solidrt/flux-types": "0.0.67",
+    "@solidrt/test": "0.0.67"
   },
   "peerDependencies": {
     "@solidjs/signals": "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,15 +1,16 @@
 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>>()
 
 // Pointer-handler presence mirrored into the render tree, so the runtime can
 // skip building deliveries that would reach nobody (moves over static content
 // are the flood case). Bits match alloy's EventInterest (rendertree/hit.rs);
-// keep the two in sync. Down/up are recorded but the runtime never gates
-// them: focus and gesture side effects hang off them regardless of handlers.
+// keep the two in sync. Down, up and cancel are recorded but the runtime
+// never gates them: focus and gesture side effects hang off them regardless
+// of handlers.
 const MOVE_BIT = 1
 const POINTER_INTEREST: Record<string, number> = {
   onPointerMove: MOVE_BIT,
@@ -18,6 +19,7 @@ const POINTER_INTEREST: Record<string, number> = {
   onPointerEnter: 8,
   onPointerLeave: 16,
   onWheel: 32,
+  onPointerCancel: 64,
 }
 
 let interests = new Map<number, number>()

package/src/double-tap.ts

@@ -48,8 +48,8 @@ export interface TapSequenceOptions {
 }
 
 /** The tap bookkeeping under a double-tap: one first tap at a time,
- * decided by the second down, by travel, by a long hold, by the window
- * timer or by cancel(). */
+ * decided by the second down, by travel, by a long hold, by a cancelled
+ * pointer, by the window timer or by cancel(). */
 export function createTapSequence(options: TapSequenceOptions) {
   let first: { id: number; at: PointerPoint; downAt: number; upAt: number | null } | null = null
   let timer: ReturnType<typeof setTimeout> | null = null
@@ -99,6 +99,9 @@ export function createTapSequence(options: TapSequenceOptions) {
         settle(false)
       }, DOUBLE_TAP_MS)
     },
+    cancelled(e: PointerEvent) {
+      if (first && first.id === e.pointerId) settle(false)
+    },
     cancel: () => settle(false),
   }
 }
@@ -145,6 +148,10 @@ export function createDoubleTap(options: DoubleTapOptions) {
       if (second === e.pointerId) release()
       taps.up(e)
     },
+    onPointerCancel: (e: PointerEvent) => {
+      if (second === e.pointerId) release()
+      taps.cancelled(e)
+    },
   }
   return { handlers, cancel }
 }

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.
 //

package/src/gpu.ts

@@ -347,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/input-pointer.ts

@@ -133,6 +133,7 @@ export interface PointerFeed extends InputDevice {
     onPointerDown(event: PointerEvent): void
     onPointerMove(event: PointerEvent): void
     onPointerUp(event: PointerEvent): void
+    onPointerCancel(event: PointerEvent): void
     onPointerLeave(event: PointerEvent): void
     onWheel(event: WheelEvent): void
   }
@@ -481,6 +482,17 @@ export function createPointerFeed(options: PointerFeedOptions = {}): PointerFeed
           opening = null
         }
       },
+      onPointerCancel(e) {
+        if (!downs.has(e.pointerId)) return
+        // The brackets close with no velocity and no swipe: the pointer
+        // ended without its lift.
+        transform.handlers.onPointerCancel(e)
+        released = null
+        lifted(e)
+        hold.cancelled(e)
+        taps.cancelled(e)
+        if (opening && opening.id === e.pointerId) opening = null
+      },
       onPointerLeave() {},
       onWheel(e) {
         if (e.deltaY === 0) return

package/src/long-press.ts

@@ -36,7 +36,8 @@ export interface HoldTimerOptions {
 }
 
 /** The arm / slop / timer machine under a long-press: one pointer at a
- * time, disarmed by travel, by a lift, by a second pointer or by cancel(). */
+ * time, disarmed by travel, by a lift, by a cancelled pointer, by a second
+ * pointer or by cancel(). */
 export function createHoldTimer(options: HoldTimerOptions) {
   let armed: { id: number; at: PointerPoint; mods: { shiftKey: boolean; ctrlKey: boolean; altKey: boolean; metaKey: boolean; button?: number } } | null = null
   let timer: ReturnType<typeof setTimeout> | null = null
@@ -69,6 +70,9 @@ export function createHoldTimer(options: HoldTimerOptions) {
     up(e: PointerEvent) {
       if (armed && armed.id === e.pointerId) disarm()
     },
+    cancelled(e: PointerEvent) {
+      if (armed && armed.id === e.pointerId) disarm()
+    },
     cancel: disarm,
   }
 }
@@ -84,6 +88,10 @@ export interface LongPressOptions {
   onLongPressMove?: (dx: number, dy: number) => void
   /** The lift after a fire. */
   onLongPressEnd?: () => void
+  /** A fired long press ended without its lift: the system cancelled the
+   * pointer (onPointerCancel), or another recognizer took it in the
+   * arena. Fired instead of onLongPressEnd. */
+  onLongPressCancel?: () => void
 }
 
 export function createLongPress(options: LongPressOptions) {
@@ -99,16 +107,26 @@ export function createLongPress(options: LongPressOptions) {
       options.onLongPress?.(at)
     },
   })
-  let cancel = () => {
-    hold.cancel()
+  let release = () => {
     if (fired !== null) {
       arena.release(fired, owner)
       fired = null
       last = null
     }
   }
+  // The press ends without its lift, whatever took the pointer: the arena
+  // (cancel) or the system (onPointerCancel). An unmount releases alone.
+  let cancel = () => {
+    hold.cancel()
+    let won = fired !== null
+    release()
+    if (won) options.onLongPressCancel?.()
+  }
   let owner: ArenaOwner = { cancel }
-  onSettled(() => cancel)
+  onSettled(() => () => {
+    hold.cancel()
+    release()
+  })
 
   let handlers = {
     onPointerDown: (e: PointerEvent) => {
@@ -126,12 +144,16 @@ export function createLongPress(options: LongPressOptions) {
     },
     onPointerUp: (e: PointerEvent) => {
       if (fired === e.pointerId) {
-        cancel()
+        release()
         options.onLongPressEnd?.()
         return
       }
       hold.up(e)
     },
+    onPointerCancel: (e: PointerEvent) => {
+      if (fired === e.pointerId) cancel()
+      else hold.cancelled(e)
+    },
   }
   return { handlers, cancel }
 }

package/src/pan.ts

@@ -35,6 +35,13 @@ export interface PanOptions {
    * finger rested before lifting or moved under FLING_MIN_VELOCITY.
    */
   onPanEnd?: (velocity: Velocity) => void
+  /**
+   * The pan ended without its result: the system cancelled the pointer
+   * (onPointerCancel), or another recognizer took it in the arena. Fired
+   * instead of onPanEnd, only after onPanStart; whoever animates on
+   * settles here, nothing flings.
+   */
+  onPanCancel?: () => void
 }
 
 // The pan recognizer: turns a drag into a movement-delta stream. On a down it
@@ -49,8 +56,9 @@ export interface PanOptions {
 // fling minimum) for momentum. Moves and the up arrive on the frozen down
 // path, so an active pan keeps streaming when the pointer leaves the node
 // or the window.
-// cancel() is the external-cancel hook; it ends an active pan without
-// onPanEnd. Options are read at event time. Single-pointer by design; for
+// cancel() is the external-cancel hook, the arena's; it and a pointer cancel
+// end an active pan with onPanCancel instead of onPanEnd. Options are read
+// at event time. Single-pointer by design; for
 // multi-pointer pinch/rotate compose createTransform instead.
 //
 // Frames: the slop is finger travel, so it is measured in window pixels
@@ -87,7 +95,13 @@ export function createPan(options: PanOptions) {
     armed = null
     origin = null
   }
-  let cancel = reset
+  // The pan ends without its result, whatever took the pointer: the arena
+  // (cancel) or the system (onPointerCancel). An unmount resets alone.
+  let cancel = () => {
+    let started = active != null
+    reset()
+    if (started) options.onPanCancel?.()
+  }
   let owner = { cancel }
 
   // An unmount mid-drag must not leave a resolved claim behind.
@@ -134,6 +148,10 @@ export function createPan(options: PanOptions) {
         reset()
       }
     },
+    onPointerCancel: (e: PointerEvent) => {
+      if (active === e.pointerId) cancel()
+      else if (armed === e.pointerId) reset()
+    },
   }
 
   return { handlers, cancel }

package/src/renderer.ts

@@ -86,7 +86,7 @@ function flushDestroy(): void {
 function removeNode(parent: ProxyNode, node: ProxyNode): void {
   if (!node || !parent) return
 
-  // console.debug("[srt] removeNode", parent.id, node.id)
+  // console.debug("[sol] removeNode", parent.id, node.id)
 
   // Update JS tree references
   let index = parent.children.indexOf(node)
@@ -113,7 +113,7 @@ function removeNode(parent: ProxyNode, node: ProxyNode): void {
 // bookkeeping on the hot create/insert paths, orphans are derived from the
 // proxy map itself: parentless, not the window root, and not awaiting the
 // destroy sweep. window.ts runs the scan on a rendered frame every few
-// seconds; dev bundles only (srt always defines import.meta.env.DEV, so a
+// seconds; dev bundles only (sol always defines import.meta.env.DEV, so a
 // production bundle folds the check into a constant early return).
 const SENTINEL_INTERVAL_MS = 5000
 let sentinelDue = 0
@@ -208,7 +208,7 @@ function routeFor(name: string): number {
 function applyProp<T>(node: ProxyNode, name: string, value: T): void {
   if (!node) return
 
-  // console.debug("[srt] applyProp", node.id, name, value)
+  // console.debug("[sol] applyProp", node.id, name, value)
 
   switch (routeFor(name)) {
     case ROUTE_EVENT:
@@ -234,7 +234,7 @@ let renderer = createRenderer<ProxyNode>({
   createElement: (elementType: string, props?: Record<string, any>): ProxyNode => {
     let proxy = createProxyNode(elementType)
 
-    // console.debug("[srt] createElement", proxy.id, elementType)
+    // console.debug("[sol] createElement", proxy.id, elementType)
 
     if (elementType === "window") tree.createRoot(proxy.id)
     else tree.createNode(proxy.id, elementType)
@@ -257,20 +257,20 @@ let renderer = createRenderer<ProxyNode>({
   // no element form of its own (the DOM's "#text" node name).
   createTextNode: (value: string): ProxyNode => {
     let proxy = createProxyNode("#text")
-    // console.debug("[srt] createTextNode", proxy.id, value)
+    // console.debug("[sol] createTextNode", proxy.id, value)
     tree.createNode(proxy.id, "#text")
     tree.setProperty(proxy.id, "text", "" + value)
     return proxy
   },
 
   replaceText: (node: ProxyNode, value: string): void => {
-    // console.debug("[srt] replaceText", node.id, value)
+    // console.debug("[sol] replaceText", node.id, value)
     tree.setProperty(node.id, "text", "" + value)
   },
 
   isTextNode: (node: ProxyNode): boolean => node?.elementType === "#text",
   setProperty: <T>(node: ProxyNode, name: string, value: T): void => {
-    // console.debug("[srt] setProperty", node.id, name, value)
+    // console.debug("[sol] setProperty", node.id, name, value)
     applyProp(node, name, value)
   },
 
@@ -294,7 +294,7 @@ let renderer = createRenderer<ProxyNode>({
     pendingDestroy.delete(node.id)
 
     if (parent) {
-      // console.debug("[srt] insertNode", parent.id, node.id, anchor?.id ?? "")
+      // console.debug("[sol] insertNode", parent.id, node.id, anchor?.id ?? "")
 
       // Native first: the tree refuses a laid-out element under a d-* parent
       // (it throws, naming both tags), and the mirror must not record a child

package/src/runtime-modules.d.ts

@@ -1,4 +1,4 @@
-// Lattice runner builtin modules (the "srt:*" surface). These are ambient
+// Lattice runner builtin modules (the "sol:*" surface). These are ambient
 // module declarations, so they live in this global-script .d.ts (no top-level
 // import/export) rather than in types.d.ts: an ambient `declare module` only
 // becomes globally visible to consumers from a non-module declaration file.
@@ -26,7 +26,8 @@ declare module "*.frag" {
 
 // Binary asset imports: `import data from "./pic.png" with { type: "binary" }`.
 // The bundler inlines the file's bytes as a Uint8Array (see packages/cli
-// bundler `inlineImport`); feed it straight into createImage/decodeImage.
+// bundler `inlineImport`); feed it straight into createImage/decodeImage, or a
+// `.wasm` into `new Module` from flux:wasm.
 declare module "*.png" {
   const bytes: Uint8Array
   export default bytes
@@ -51,7 +52,11 @@ declare module "*.glb" {
   const bytes: Uint8Array
   export default bytes
 }
-declare module "*.srtm" {
+declare module "*.sol3m" {
+  const bytes: Uint8Array
+  export default bytes
+}
+declare module "*.wasm" {
   const bytes: Uint8Array
   export default bytes
 }
@@ -63,13 +68,13 @@ declare module "*.srtm" {
 // pointer moves have dispatched, every pointer the same age - multi-pointer
 // recognizers measure there; its `timeStamp` is theirs), and "render" (the
 // per-frame signal).
-declare module "srt:events" {
+declare module "sol:events" {
   export function on(event: string, callback: (data: any) => void): () => void
   export function once(event: string, callback: (data: any) => void): () => void
 }
 
 // The running application's own surface (lattice), present in every build.
-declare module "srt:app" {
+declare module "sol:app" {
   /**
    * End the current app now, without running the quit hooks: back to the
    * player in a dev client, quit when standalone or at the player root (on
@@ -100,7 +105,7 @@ declare module "srt:app" {
 
 // Dev-server control surface (lattice). Present only in dev/go builds; in other
 // builds `available` is false and the functions are no-ops.
-declare module "srt:dev" {
+declare module "sol:dev" {
   export const available: boolean
   export const canDiscover: boolean
   export const recents: string[]
@@ -139,7 +144,7 @@ declare module "srt:dev" {
 // Installed-app management (lattice), the player's surface over the client's
 // version store. Present only in go/dev client builds; elsewhere `available`
 // is false, `list` returns [], and launch/remove are no-ops.
-declare module "srt:apps" {
+declare module "sol:apps" {
   export const available: boolean
   /**
    * An installed app: id, display name (the installed manifest's displayName,
@@ -233,16 +238,16 @@ declare module "srt:apps" {
 // submits the display list. To schedule a future frame instead, use
 // requestFrame() from "flux:rendertree". The tree-building surface itself is
 // "flux:rendertree" (from @solidrt/flux-types).
-declare module "srt:render" {
+declare module "sol:render" {
   export function renderFrame(): void
 }
 
 // The engine verbs of an app test (lattice, dev client only), which
 // @solidrt/test builds its surface on; tests import that, not this.
-// The verbs work only in an engine a test host built (`srt test`) and throw
+// The verbs work only in an engine a test host built (`sol test`) and throw
 // anywhere else. App time there is frame / frameRate and nothing else: no
 // frame runs unless one is asked for.
-declare module "srt:test" {
+declare module "sol:test" {
   /**
    * Runs one frame: timers due by its time fire, then frame callbacks and
    * the flush, then the draw if anything demanded one. Fulfills once the

package/src/swipe.ts

@@ -67,6 +67,10 @@ export interface SwipeOptions {
   onSwipe?: (direction: SwipeDirection, velocity: Velocity) => void
   /** Every lift of an active swipe, qualified or not. */
   onSwipeEnd?: (velocity: Velocity) => void
+  /** An active swipe ended without its lift: the system cancelled the
+   * pointer (onPointerCancel), or another recognizer took it in the
+   * arena. Fired instead of onSwipe and onSwipeEnd. */
+  onSwipeCancel?: () => void
 }
 
 export function createSwipe(options: SwipeOptions) {
@@ -97,6 +101,11 @@ export function createSwipe(options: SwipeOptions) {
       if (direction) options.onSwipe?.(direction, velocity)
       options.onSwipeEnd?.(velocity)
     },
+    onPanCancel: () => {
+      down = null
+      lift = null
+      options.onSwipeCancel?.()
+    },
   })
 
   let handlers = {
@@ -120,6 +129,13 @@ export function createSwipe(options: SwipeOptions) {
         lift = null
       }
     },
+    onPointerCancel: (e: PointerEvent) => {
+      pan.handlers.onPointerCancel(e)
+      if (down && down.id === e.pointerId) {
+        down = null
+        lift = null
+      }
+    },
   }
   let cancel = () => {
     pan.cancel()

package/src/textures.ts

@@ -2,7 +2,7 @@
 // the runtime: this entry imports nothing the runtime provides, so a bake
 // script under bun and an extension's pure modules use it as it is
 // (tests/textures.test.ts imports it on the bare flux binary and fails the
-// moment a gui or srt: import creeps in). Any extension that bakes or loads textures
+// moment a gui or sol: import creeps in). Any extension that bakes or loads textures
 // builds on this, the first-party 3d one included.
 //
 // isKtx2 tells a compressed texture file from a PNG or JPEG.

package/src/transform.ts

@@ -1,5 +1,5 @@
 import { onSettled } from "@solidjs/signals"
-import { on } from "srt:events"
+import { on } from "sol:events"
 import type { PointerEvent } from "./types"
 import { arena, type ArenaOwner } from "./arena"
 import { createVelocityTracker, flingVelocity } from "./velocity"
@@ -59,6 +59,10 @@ export interface TransformOptions {
    * parent-frame pixels per second (velocity.ts; zero after a rest or
    * under the fling minimum). */
   onTransformEnd?: (velocity: Velocity) => void
+  /** The gesture ended without its result: the system cancelled a finger
+   * (onPointerCancel), or another recognizer took the pointers in the
+   * arena. Fired instead of onTransformEnd, only after onTransformStart. */
+  onTransformCancel?: () => void
 }
 
 // The merged transform recognizer: pan + pinch + rotate as ONE gesture over
@@ -116,7 +120,8 @@ export interface TransformOptions {
 // configuration, so the change itself never emits a jump delta. The gesture
 // ends when the last finger lifts. Moves and ups arrive on the frozen down
 // path, so an active transform survives leaving the node or the window.
-// cancel() is the external-cancel hook; it ends an active gesture without
+// cancel() is the external-cancel hook, the arena's; it and a cancelled
+// finger end an active gesture with onTransformCancel instead of
 // onTransformEnd. Options are read at event time.
 //
 // Frames: the slop, the span filter and its rate gates are finger-travel
@@ -206,7 +211,11 @@ export function createTransform(options: TransformOptions) {
     rebase = false
     tracker.reset()
   }
-  let cancel = reset
+  let cancel = () => {
+    let started = active
+    reset()
+    if (started) options.onTransformCancel?.()
+  }
   let owner: ArenaOwner = { cancel }
 
   // The per-frame measure point: runs at the pointerFrame terminator, when
@@ -355,6 +364,17 @@ export function createTransform(options: TransformOptions) {
       pointers.delete(e.pointerId)
       ref = pointers.size > 0 ? measure() : null
     },
+    onPointerCancel: (e: PointerEvent) => {
+      if (!pointers.has(e.pointerId)) return
+      // The system cancels the gesture, not a finger: every platform
+      // cancels all of them together, so the whole gesture ends.
+      if (active) {
+        cancel()
+        return
+      }
+      pointers.delete(e.pointerId)
+      ref = pointers.size > 0 ? measure() : null
+    },
   }
 
   return { handlers, cancel }

package/src/types.d.ts

@@ -9,14 +9,14 @@ import type { Element } from "solid-js"
 
 export type { TextInputHints }
 
-// The "srt:*" lattice runner modules are declared in ./runtime-modules.d.ts
+// The "sol:*" lattice runner modules are declared in ./runtime-modules.d.ts
 // (referenced above) - ambient `declare module` only reaches consumers from a
 // non-module declaration file, and this file is a module.
 
 declare global {
   interface ImportMeta {
     /**
-     * Build-mode constants, substituted textually by the srt bundler (Vite
+     * Build-mode constants, substituted textually by the sol bundler (Vite
      * vocabulary). `DEV` is true in dev bundles and false in production
      * bundles, where the substituted constant lets the minifier fold
      * dev-only code away entirely.
@@ -278,7 +278,8 @@ export interface TransformProps {
 
 // Window-relative pointer coordinates are reported as clientX/clientY (matching
 // the DOM MouseEvent). pointerType distinguishes mouse from touch; button is the
-// pressed button on down/up (0 = primary); the modifier flags mirror the DOM.
+// pressed button on down/up (0 = primary) and absent on a cancel; the modifier
+// flags mirror the DOM.
 export interface PointerEvent {
   /**
    * When the event happened, in milliseconds. Every input event carries one,
@@ -291,7 +292,7 @@ export interface PointerEvent {
    * pointer, so the real move after it can carry an earlier time. Use it
    * where you would reach for `performance.now()` in a handler: that one
    * measures when the handler ran, not when the input happened, and it does
-   * not follow the dev clock, `srt render` or a test. The origin is
+   * not follow the dev clock, `sol render` or a test. The origin is
    * arbitrary (compare stamps with each other, not with `performance.now()`,
    * a timer or the `onFrame` tick).
    */
@@ -408,6 +409,15 @@ export interface NodeProps {
 export interface PointerProps extends NodeProps {
   onPointerDown?: (event: PointerEvent) => void
   onPointerUp?: (event: PointerEvent) => void
+  /**
+   * The system took the pointer away: a system gesture (the back swipe,
+   * the notification shade), palm rejection, the window losing the touch.
+   * The last event for that pointer, and no up follows it, so a press
+   * ends without firing and a drag ends without a fling. Routed along the
+   * pressed path like an up, with the pointer's last known position and
+   * no `button`.
+   */
+  onPointerCancel?: (event: PointerEvent) => void
   onPointerMove?: (event: PointerEvent) => void
   onPointerEnter?: (event: PointerEvent) => void
   onPointerLeave?: (event: PointerEvent) => void

package/src/window.ts

@@ -1,8 +1,8 @@
 import { createSignal, getOwner, onCleanup, onSettled, runWithOwner, flush } from "@solidjs/signals"
 import { requestFrame, setPointerLock } from "flux:rendertree"
-import { renderFrame } from "srt:render"
-import { on, once } from "srt:events"
-import { exit as nativeExit, background as nativeBackground, registerProtocolHandler as nativeRegisterProtocolHandler } from "srt:app"
+import { renderFrame } from "sol:render"
+import { on, once } from "sol:events"
+import { exit as nativeExit, background as nativeBackground, registerProtocolHandler as nativeRegisterProtocolHandler } from "sol:app"
 import { platform } from "flux:process"
 import { getEventHandler, focusedNode, setFocus, activateTextInput, setInterestRoot } from "./core"
 import { scanForOrphans, getNodePath } from "./renderer"
@@ -269,7 +269,7 @@ export function onFrame(fn: (tick: number, frame: number, rate: number) => void,
  * between frames (an event handler, a timer) it is the latest frame's. It
  * is 0 before the first frame. Not reactive, and reading it requests no
  * frame. Use it to time things against the app's own clock from code that
- * has no tick in hand: it follows the dev tools' clock control, `srt
+ * has no tick in hand: it follows the dev tools' clock control, `sol
  * render` and a test, where performance.now() does not.
  */
 export function frameTime(): number {
@@ -553,6 +553,7 @@ export function attachWindow(nodeId: number) {
   let unsubscribe: () => void = null!
   let unsubDown: () => void = null!
   let unsubUp: () => void = null!
+  let unsubCancel: () => void = null!
   let unsubMove: () => void = null!
   let unsubEnter: () => void = null!
   let unsubLeave: () => void = null!
@@ -664,6 +665,10 @@ export function attachWindow(nodeId: number) {
       bubble(raw, "onPointerUp")
     })
 
+    unsubCancel = on("pointerCancel", (raw: RawPointer) => {
+      bubble(raw, "onPointerCancel")
+    })
+
     unsubMove = on("pointerMove", (raw: RawPointer) => {
       bubble(raw, "onPointerMove")
     })
@@ -761,6 +766,7 @@ export function attachWindow(nodeId: number) {
     if (unsubscribe) unsubscribe()
     if (unsubDown) unsubDown()
     if (unsubUp) unsubUp()
+    if (unsubCancel) unsubCancel()
     if (unsubMove) unsubMove()
     if (unsubEnter) unsubEnter()
     if (unsubLeave) unsubLeave()