@solidrt/core 0.0.34 → 0.0.36

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidrt/core",
-  "version": "0.0.34",
+  "version": "0.0.36",
   "license": "MIT",
   "author": "Antoine van Wel",
   "type": "module",
@@ -27,7 +27,7 @@
     "colord": "^2.9.3"
   },
   "devDependencies": {
-    "@solidrt/flux-types": "0.0.34"
+    "@solidrt/flux-types": "0.0.36"
   },
   "peerDependencies": {
     "@solidjs/signals": "2.0.0-beta.20",

package/src/core.ts

@@ -64,16 +64,27 @@ export interface BoundingBox {
 }
 
 /**
- * Returns the node's window-relative bounding box from the most recently
- * computed layout, or `null` if the node has no layout or has not been laid out
- * yet. This is a snapshot read, not reactive: call it inside `onLayout` (or an
- * event handler) to get values for the current frame. Phase 1 composes only
- * translations; x/y are wrong when a rotate/scale sits anywhere above the node.
+ * Returns the node's bounding box from the most recently computed layout,
+ * relative to its nearest positioning context (an ancestor with an explicit
+ * `position="relative"`, falling back to the window), or `null` if the node
+ * has no layout or has not been laid out yet. This is a snapshot read, not
+ * reactive: call it inside `onLayout` (or an event handler) to get values for
+ * the current frame. Transforms anywhere in the chain (including the node's
+ * own) compose fully; the box is the axis-aligned bounds of the transformed
+ * quad.
  */
 export function getBoundingBox(node: { id: number }): BoundingBox | null {
   return tree.getBoundingBox(node.id)
 }
 
+/**
+ * Like getBoundingBox, but always window-relative (getBoundingClientRect
+ * semantics), the frame pointer event clientX/clientY are reported in.
+ */
+export function getBoundingBoxViewport(node: { id: number }): BoundingBox | null {
+  return tree.getBoundingBoxViewport(node.id)
+}
+
 /**
  * Measures the rendered size of `text` in layout pixels under the given font
  * options (family, size, weight, style, maxLines), without adding it to the

package/src/gpu.ts

@@ -8,16 +8,35 @@
 // sampler2D input. The imperative primitives (uploadTexture, setShaderParams,
 // destroyTexture, ...) live in the `flux:gpu` module.
 
-import { getOwner, onCleanup } from "@solidjs/signals"
+import { createEffect, createSignal, getOwner, onCleanup, untrack } from "@solidjs/signals"
 import * as gpu from "flux:gpu"
 
+// The create* helpers accept { manual: true } to opt out of the owner-scoped
+// auto-free, for resources whose lifetime is managed by hand (rebuilt on
+// signal changes inside a long-lived component, handed across owners, ...).
+// Without it, each rebuild would stack another onCleanup on the component
+// owner: a leak until unmount, then a double-free against manual destroys.
+export type CreateOptions = { manual?: boolean }
+
 // Re-exported so callers that depend on @solidrt/core -- like @solidrt/components
 // -- need not import flux directly: destroyTexture for the manual-cleanup path
 // (textures made outside a reactive scope, e.g. after an await, are not
 // auto-freed), uploadTexture to push new pixels into a mutable texture, and
 // setShaderParams as the non-reactive exception described above - prefer
 // `<texture params={...}>` when a `<texture>` element is already in the tree.
-export { destroyTexture, setShaderParams, uploadTexture } from "flux:gpu"
+// resizeTexture and setShaderSize resize in place at a stable id (so
+// `<texture src>` and sampler bindings stay valid); because the id survives,
+// the owner-scoped auto-free registered at creation keeps working and no
+// re-registration is needed. setShaderTextures is the sampler analog of
+// setShaderParams: retarget a shader's sampler2D inputs without recompiling.
+export {
+  destroyTexture,
+  resizeTexture,
+  setShaderParams,
+  setShaderSize,
+  setShaderTextures,
+  uploadTexture,
+} from "flux:gpu"
 
 // Pipeline plumbing re-exported raw: setDrawCount re-renders a pipeline after
 // its buffer gained or lost dynamic geometry; destroyBuffer is the manual
@@ -40,11 +59,12 @@ export { captureSnapshot, readTexture } from "flux:gpu"
  * texture is freed automatically once that owner is disposed; when called
  * outside one (e.g. after an `await`, where the owner is no longer current)
  * nothing is registered and you must call `destroyTexture` (from flux:gpu)
- * yourself.
+ * yourself. Pass `{ manual: true }` to skip the auto-free and own the
+ * disposal yourself even inside a reactive scope.
  */
-export function createTexture(data: Uint8Array, width: number, height: number): number {
+export function createTexture(data: Uint8Array, width: number, height: number, opts?: CreateOptions): number {
   let id = gpu.createTexture(data, width, height)
-  if (getOwner()) onCleanup(() => gpu.destroyTexture(id))
+  if (!opts?.manual && getOwner()) onCleanup(() => gpu.destroyTexture(id))
   return id
 }
 
@@ -53,12 +73,13 @@ export function createTexture(data: Uint8Array, width: number, height: number):
  * then call `uploadTexture(id, data)` (from flux:gpu) to push new pixels. `data`
  * is RGBA8 and must hold at least `width * height * 4` bytes (it may hold several
  * frames). Like `createTexture`, the texture is freed automatically when the
- * reactive owner is disposed; created outside a reactive scope you must call
- * `destroyTexture` (from flux:gpu) yourself.
+ * reactive owner is disposed (opt out with `{ manual: true }`); created
+ * outside a reactive scope you must call `destroyTexture` (from flux:gpu)
+ * yourself.
  */
-export function createMutableTexture(data: Uint8Array, width: number, height: number): number {
+export function createMutableTexture(data: Uint8Array, width: number, height: number, opts?: CreateOptions): number {
   let id = gpu.createMutableTexture(data, width, height)
-  if (getOwner()) onCleanup(() => gpu.destroyTexture(id))
+  if (!opts?.manual && getOwner()) onCleanup(() => gpu.destroyTexture(id))
   return id
 }
 
@@ -72,8 +93,10 @@ export function createMutableTexture(data: Uint8Array, width: number, height: nu
  * `textures` binds each declared `uniform sampler2D` to an existing texture id
  * (e.g. a camera or decoded image) so the shader can read it; those inputs are
  * re-sampled on every params update, so live sources stay current. Frees the
- * texture and shader program when the reactive owner is disposed; create
- * outside any reactive scope for app-lifetime shaders.
+ * texture and shader program when the reactive owner is disposed (opt out
+ * with `{ manual: true }`); create outside any reactive scope for
+ * app-lifetime shaders. For a shader whose source or inputs change
+ * reactively, use {@link createShaderMemo} instead.
  */
 export function createShader(
   fragmentSrc: string,
@@ -81,9 +104,67 @@ export function createShader(
   height: number,
   params?: Record<string, number>,
   textures?: Record<string, number>,
+  opts?: CreateOptions,
 ): number {
   let id = gpu.createShader(fragmentSrc, width, height, params, textures)
-  if (getOwner()) onCleanup(() => gpu.destroyTexture(id))
+  if (!opts?.manual && getOwner()) onCleanup(() => gpu.destroyTexture(id))
+  return id
+}
+
+/** The reactive shader description `createShaderMemo` builds from. */
+export type ShaderSpec = {
+  fragmentSrc: string
+  width: number
+  height: number
+  params?: Record<string, number>
+  textures?: Record<string, number>
+}
+
+// Shallow name->number equality for params/textures records; treats undefined
+// as the empty record.
+function sameRecord(a: Record<string, number> | undefined, b: Record<string, number> | undefined): boolean {
+  if (a === b) return true
+  let ka = a ? Object.keys(a) : []
+  let kb = b ? Object.keys(b) : []
+  return ka.length === kb.length && ka.every(k => a![k] === b![k])
+}
+
+/**
+ * A fragment shader whose spec is reactive: returns an accessor for the
+ * current texture id (use it as `<texture src={id()} />`) and keeps the GPU
+ * resource in step with `spec` from then on. Changes that keep the compiled
+ * program valid mutate in place at a stable id - a size change routes to
+ * `setShaderSize`, a params change to `setShaderParams` - while a change to
+ * the fragment source or the sampler bindings rebuilds at a fresh id, updates
+ * the accessor, and destroys the old id. That destroy is frame-safe (the
+ * runtime reclaims an id only once the render tree no longer references it),
+ * so the swap never paints a blank frame. The current id is freed when the
+ * owning scope is disposed. Data textures need no analog: `uploadTexture` and
+ * `resizeTexture` already cover their reactive changes id-stably.
+ */
+export function createShaderMemo(spec: () => ShaderSpec): () => number {
+  let current = untrack(spec)
+  let currentId = gpu.createShader(current.fragmentSrc, current.width, current.height, current.params, current.textures)
+  let [id, setId] = createSignal(currentId)
+  createEffect(spec, next => {
+    if (next.fragmentSrc === current.fragmentSrc && sameRecord(next.textures, current.textures)) {
+      // Program and inputs unchanged: mutate in place, the id stays stable.
+      if (next.width !== current.width || next.height !== current.height) {
+        gpu.setShaderSize(currentId, next.width, next.height)
+      }
+      if (!sameRecord(next.params, current.params) && next.params) {
+        gpu.setShaderParams(currentId, next.params)
+      }
+      current = next
+      return
+    }
+    let old = currentId
+    current = next
+    currentId = gpu.createShader(next.fragmentSrc, next.width, next.height, next.params, next.textures)
+    setId(currentId)
+    gpu.destroyTexture(old)
+  })
+  if (getOwner()) onCleanup(() => gpu.destroyTexture(currentId))
   return id
 }
 
@@ -107,8 +188,8 @@ function toUint8(data: ArrayBuffer | ArrayBufferView): Uint8Array {
  * `opts.depth` attaches a private depth buffer (cleared + tested per render);
  * `opts.vertexCount` defaults to the whole buffer and can be changed later
  * with `setDrawCount`. Frees the texture and GL program when the reactive
- * owner is disposed; create outside any reactive scope for app-lifetime
- * pipelines.
+ * owner is disposed (opt out with `opts.manual`); create outside any reactive
+ * scope for app-lifetime pipelines.
  */
 export function createPipeline(
   vertexSrc: string,
@@ -124,10 +205,10 @@ export function createPipeline(
     vertexCount?: number
     depth?: boolean
     clearColor?: [number, number, number, number]
-  },
+  } & CreateOptions,
 ): number {
   let id = gpu.createPipeline(vertexSrc, fragmentSrc, width, height, opts)
-  if (getOwner()) onCleanup(() => gpu.destroyTexture(id))
+  if (!opts?.manual && getOwner()) onCleanup(() => gpu.destroyTexture(id))
   return id
 }
 
@@ -136,12 +217,13 @@ export function createPipeline(
  * Float32Array laid out to match the pipeline's interleaved attribute list).
  * Update it later with {@link writeBuffer}; the buffer's byte size is fixed at
  * creation, so reserve room up front for dynamic geometry. Freed automatically
- * when the reactive owner is disposed; created outside a reactive scope you
- * must call `destroyBuffer` yourself. Destroy pipelines before their buffer.
+ * when the reactive owner is disposed (opt out with `{ manual: true }`);
+ * created outside a reactive scope you must call `destroyBuffer` yourself.
+ * Destroy pipelines before their buffer.
  */
-export function createBuffer(data: ArrayBuffer | ArrayBufferView): number {
+export function createBuffer(data: ArrayBuffer | ArrayBufferView, opts?: CreateOptions): number {
   let id = gpu.createBuffer(toUint8(data))
-  if (getOwner()) onCleanup(() => gpu.destroyBuffer(id))
+  if (!opts?.manual && getOwner()) onCleanup(() => gpu.destroyBuffer(id))
   return id
 }
 

package/src/index.ts

@@ -1,10 +1,9 @@
 export * from "./renderer"
-export { setFocus, getFocusedNodeId, measureText, getBoundingBox } from "./core"
+export { setFocus, getFocusedNodeId, measureText, getBoundingBox, getBoundingBoxViewport } from "./core"
 export type { BoundingBox } from "./core"
 export { parseColor, mixColors, brightness, createLinearGradient, createRadialGradient } from "./color"
 export type { Gradient, GradientStop } from "./color"
 export { onFrame, onLayout, onResize, onWindowFocus, onWindowBlur } from "./window"
-export { setPointerCapture, releasePointerCapture } from "./window"
 export { windowSize, safeArea, displayScale, windowFocused, keyboardHeight } from "./window"
 export { env } from "./environment"
 export type { InputDevices, SystemTheme, Orientation } from "./environment"

package/src/runtime-modules.d.ts

@@ -67,14 +67,19 @@ declare module "srt:apps" {
   export type AppVersion = { id: string; size: number; current: boolean }
   /** One file in a listing: a relative path and its size in bytes. */
   export type AppFile = { path: string; size: number }
+  /**
+   * One fetch-cache entry: the cached (resolved) url, the response content
+   * type (lowercased, parameters stripped; absent when the response had
+   * none) and the entry's size on disk.
+   */
+  export type AppCacheEntry = { url: string; type?: string; size: number }
   /**
    * Usage details for one installed app: total bytes of its stored versions
-   * (assets shared between versions via hardlinks count in each) and of its
-   * data sandbox, plus the stored versions (current first, then newest first)
-   * and three file listings, each sorted by path. `assets` is the current
-   * version's manifest claim (declared sizes); `files` and `data` are disk
-   * walks of the current version dir and the data sandbox - the truth, so a
-   * divergence from the manifest is visible.
+   * (assets shared between versions via hardlinks count in each), of its
+   * data sandbox and of its fetch cache, plus the stored versions (current
+   * first, then newest first) and three listings: `files` and `data` are
+   * disk walks of the current version dir and the data sandbox (sorted by
+   * path), `cache` is the fetch cache's entries (sorted by url).
    */
   export type AppInfo = {
     id: string
@@ -82,10 +87,11 @@ declare module "srt:apps" {
     version: string
     installSize: number
     dataSize: number
+    cacheSize: number
     versions: AppVersion[]
-    assets: AppFile[]
     files: AppFile[]
     data: AppFile[]
+    cache: AppCacheEntry[]
   }
   /** Usage details for an installed app. Throws when the app is not installed. */
   export function info(id: string): AppInfo
@@ -100,6 +106,22 @@ declare module "srt:apps" {
    * the app is not installed.
    */
   export function remove(id: string): void
+  /**
+   * Delete the app's fetch cache. Clearing a missing or empty cache is a
+   * no-op; the id does not need to be installed, so a removed app's
+   * leftover cache is still clearable.
+   */
+  export function clearCache(id: string): void
+  /**
+   * Build identity of this runtime, for the launcher's settings screen. Not
+   * app-specific, but surfaced here since the launcher already imports this
+   * module. `version` is the release version (git describe; "0.0.0-dev" in a
+   * plain build), `profile` is "debug" or "release", `platform` is the OS
+   * (std::env::consts::OS, e.g. "linux", "android", "windows", "macos").
+   */
+  export const version: string
+  export const profile: string
+  export const platform: string
 }
 
 // Frame draw (lattice runner). renderFrame() synchronously renders the current

package/src/window.ts

@@ -5,27 +5,17 @@ import { on, once } from "srt:events"
 import { getEventHandler, getFocusedNodeId, setFocus } from "./core"
 import { scanForOrphans } from "./renderer"
 
-// ------ Pointer capture -----------------
-
-// Active pointer captures, pointerId -> nodeId. While a pointer is captured, its
-// move/up events dispatch straight to the captured node (bypassing hit testing),
-// so a drag keeps working when the pointer drifts off the element. Modeled on the
-// web setPointerCapture; capture auto-releases on pointerUp.
-let pointerCaptures = new Map<number, number>()
-
-/**
- * Routes all further move/up events for `pointerId` to `nodeId` until release,
- * regardless of what is under the pointer. Call from a pointerdown handler to own
- * a drag (e.g. a slider). Auto-releases on the matching pointerup.
- */
-export function setPointerCapture(nodeId: number, pointerId: number) {
-  pointerCaptures.set(pointerId, nodeId)
-}
-
-/** Ends a capture early. Not needed for the common case (pointerup releases it). */
-export function releasePointerCapture(pointerId: number) {
-  pointerCaptures.delete(pointerId)
-}
+// ------ Pointer routing -----------------
+
+// Hit path frozen at pointerDown, pointerId -> targets. While a pointer has an
+// active down, its moves and up dispatch along this path (same leaf-to-root
+// bubble) no matter where the pointer currently is, so every node under the
+// original down observes the whole gesture: a drag keeps working off-element,
+// and an ancestor recognizer (a scroller's pan) sees the moves it needs to
+// take over mid-gesture via the arena. There is no exclusive pointer capture;
+// gesture ownership is claim-based, above this layer. Enter/leave stay
+// hover-driven, and moves with no active down follow the live hit path.
+let downPaths = new Map<number, number[]>()
 
 // ------ Animation frames ----------------
 
@@ -244,6 +234,7 @@ export function attachWindow(_nodeId: number) {
     unsubDown = on(
       "pointerDown",
       ({ targets, ...e }: { targets: number[]; [k: string]: any }) => {
+        downPaths.set(e.pointerId, targets)
         bubble(targets, "onPointerDown", e)
         // Outside-tap blur. Read focus AFTER per-node handlers so a tap that
         // moves focus to a new node is not immediately blurred again.
@@ -255,28 +246,15 @@ export function attachWindow(_nodeId: number) {
     )
 
     unsubUp = on("pointerUp", ({ targets, ...e }: { targets: number[]; [k: string]: any }) => {
-      let captured = pointerCaptures.get(e.pointerId)
-      if (captured != null) {
-        // Deliver to the captured node, then release (web auto-release on up).
-        e.stopPropagation = () => {}
-        getEventHandler(captured, "onPointerUp")?.(e)
-        pointerCaptures.delete(e.pointerId)
-        return
-      }
-      bubble(targets, "onPointerUp", e)
+      let frozen = downPaths.get(e.pointerId)
+      downPaths.delete(e.pointerId)
+      bubble(frozen ?? targets, "onPointerUp", e)
     })
 
     unsubMove = on(
       "pointerMove",
       ({ targets, ...e }: { targets: number[]; [k: string]: any }) => {
-        let captured = pointerCaptures.get(e.pointerId)
-        if (captured != null) {
-          // Captured drags get moves anywhere over the window, bypassing hit test.
-          e.stopPropagation = () => {}
-          getEventHandler(captured, "onPointerMove")?.(e)
-          return
-        }
-        bubble(targets, "onPointerMove", e)
+        bubble(downPaths.get(e.pointerId) ?? targets, "onPointerMove", e)
       },
     )