@solidrt/core 0.0.11 → 0.0.13

package/AGENTS.md

@@ -68,10 +68,14 @@ Peer deps @solidjs/signals and @solidjs/universal must match (currently
   onKeyDown/Up, onTextInput, onFocus/onBlur. Text entry: focus a node with an
   `onTextInput` handler (setFocus activates the on-screen keyboard).
 
-- Reactivity is plain SolidJS (`createSignal`, `createEffect`, ... from
-  @solidjs/signals). Per-frame work: `onFrame((tick, frame) => {})` (returns a
-  cleanup; auto-cleaned inside a reactive scope). Also onResize, onLayout,
-  onWindowFocus, onWindowBlur.
+- Reactivity is SolidJS 2.0 (`@solidjs/signals`), NOT Solid 1.x. `createSignal`
+  is as you expect, but `createEffect` takes the 2.0 two-function shape: a
+  TRACKED compute that reads signals and returns a value, then an UNTRACKED
+  effect that receives it - `createEffect(() => count(), (c) => ...)`. The 1.x
+  single-callback form `createEffect(() => { ...count()... })` does NOT track
+  here. Per-frame work: `onFrame((tick, frame) => {})` (returns a cleanup;
+  auto-cleaned inside a reactive scope) or standard `requestAnimationFrame`.
+  Also onResize, onLayout, onWindowFocus, onWindowBlur.
 
 - Device/GPU access via subpath imports: @solidrt/core/camera, /microphone,
   /speech, /gpu. Image flow: `decodeImage(bytes)` -> `createTexture(data,w,h)`

package/jsx-runtime.d.ts

@@ -3,6 +3,7 @@ import type {
   RectProps,
   OvalProps,
   PathProps,
+  SvgProps,
   ViewProps,
   TextProps,
   TextureProps,
@@ -32,12 +33,14 @@ export namespace JSX {
     rect: RectProps & LayoutProps
     oval: OvalProps & LayoutProps
     path: PathProps & LayoutProps
+    svg: SvgProps & LayoutProps
     texture: TextureProps & LayoutProps
     audio: AudioProps
     "d-view": ViewProps
     "d-rect": RectProps
     "d-oval": OvalProps
     "d-path": PathProps
+    "d-svg": SvgProps
     "d-texture": TextureProps
     "d-text": TextProps
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidrt/core",
-  "version": "0.0.11",
+  "version": "0.0.13",
   "license": "MIT",
   "author": "Antoine van Wel",
   "type": "module",
@@ -9,8 +9,10 @@
     ".": "./src/index.ts",
     "./camera": "./src/camera.ts",
     "./gpu": "./src/gpu.ts",
+    "./image": "./src/image.ts",
     "./microphone": "./src/microphone.ts",
-    "./speech": "./src/speech.ts",
+    "./speech-recognition": "./src/speech-recognition.ts",
+    "./text-input": "./src/text-input.ts",
     "./jsx-runtime": "./jsx-runtime.d.ts",
     "./jsx-runtime-dev": "./jsx-runtime.d.ts"
   },
@@ -23,7 +25,7 @@
     "colord": "^2.9.3"
   },
   "devDependencies": {
-    "@solidrt/flux-types": "0.0.11"
+    "@solidrt/flux-types": "0.0.13"
   },
   "peerDependencies": {
     "@solidjs/signals": "2.0.0-beta.14",

package/src/camera.ts

@@ -1,8 +1,13 @@
-// Camera capture. A camera streams into a texture id, so a viewfinder is just
-// <texture src={cam.texture} />. Opening the camera IS the permission request
-// (SDL semantics): the promise resolves once the stream is configured and
-// rejects if the user denies access.
+// Camera capture, reactive (SolidJS) layer. A camera streams into a texture id,
+// so a viewfinder is just <texture src={cam.texture} />. Opening the camera IS
+// the permission request (SDL semantics): it resolves once the stream is
+// configured and rejects if the user denies access.
+//
+// The imperative primitive lives in the `flux:camera` module; import { open,
+// listCameras, scanImage } from "flux:camera" for non-reactive use.
 
+import { createSignal, onCleanup } from "@solidjs/signals"
+import { listCameras, open } from "flux:camera"
 import { on } from "srt:events"
 
 export type CameraFacing = "front" | "back" | "unknown"
@@ -21,58 +26,96 @@ export type BarcodeResult = {
 }
 
 export type CameraOptions = {
-  /** Explicit device id from listCameras(); takes precedence over facing. */
+  /** Explicit device id from flux:camera listCameras(); takes precedence over facing. */
   camera?: number
   /** Pick the first camera with this facing (falls back to the first camera). */
   facing?: "front" | "back"
   /** Size hint; the device picks the closest supported mode. */
   width?: number
   height?: number
-  /** Decode these barcode formats from the stream (delivered via onBarcode). */
+  /** Decode these barcode formats from the stream (delivered via the barcode signal). */
   scan?: BarcodeFormat[]
 }
 
-export type Camera = {
-  /** Texture id updated every frame while open; render with <texture src={...}>. */
-  texture: number
-  /** Actual stream size (may differ from the requested hint). */
-  width: number
-  height: number
-  /** Receive decoded barcodes (requires the scan option; replaces any previous callback). */
-  onBarcode(callback: (result: BarcodeResult) => void): void
-  /** Release the device. The texture keeps showing the last frame. */
-  close(): void
-}
+let devicesAccessor: (() => CameraInfo[]) | undefined
 
-export function listCameras(): CameraInfo[] {
-  return camera.listCameras()
+/**
+ * Current camera list as a reactive accessor: re-enumerates on hotplug. Also
+ * initializes the camera subsystem (required before hotplug events fire).
+ * App-lifetime: there is one camera subsystem, so no cleanup is needed.
+ *
+ * Coverage caveat (SDL 3.4.8): only Android delivers both add and remove. On
+ * Linux you get add events but not remove (removal is broken upstream); on
+ * macOS/Windows there is no camera hotplug at all.
+ */
+export function cameraDevices(): CameraInfo[] {
+  if (!devicesAccessor) {
+    let [devices, setDevices] = createSignal<CameraInfo[]>(listCameras())
+    on("cameraDeviceChange", () => setDevices(listCameras()))
+    devicesAccessor = devices
+  }
+  return devicesAccessor()
 }
 
-// Camera hotplug. Re-enumerate with listCameras() to see the new device set.
-// Events only flow once the camera subsystem is up, i.e. after the first
-// listCameras() or openCamera() call. Returns an unsubscribe function.
-// Coverage caveat (SDL 3.4.8): only Android delivers both add and remove. On
-// Linux you get added=true but not added=false (removal is broken upstream);
-// on macOS/Windows there is no camera hotplug at all, so nothing fires.
+/**
+ * Low-level fallback: subscribe to camera hotplug events with a callback. Prefer
+ * `cameraDevices()` unless the reactive accessor does not fit. Re-enumerate with
+ * `listCameras()` (from flux:camera) inside the callback to get the new set.
+ * Returns an unsubscribe function.
+ */
 export function onDeviceChange(callback: (event: { added: boolean }) => void): () => void {
   return on("cameraDeviceChange", callback)
 }
 
-// One-shot scan of an RGBA8 pixel buffer for QR codes; composes with
-// decodeImage: scanBarcodes(img.data, img.width, img.height).
-export function scanBarcodes(data: Uint8Array, width: number, height: number): BarcodeResult[] {
-  return camera.scanImage(data, width, height)
+/** A live camera as reactive accessors. */
+export type CameraStream = {
+  /** Texture id once the stream is up, undefined while opening; render with <texture src={...}>. */
+  texture(): number | undefined
+  /** Actual stream size, undefined while opening. */
+  width(): number | undefined
+  height(): number | undefined
+  /** The most recently decoded barcode (requires the scan option). */
+  barcode(): BarcodeResult | undefined
+  /** Set if opening failed (e.g. permission denied). */
+  error(): Error | undefined
 }
 
-export async function openCamera(options: CameraOptions = {}): Promise<Camera> {
-  let opened = await camera.open(options)
-  return {
-    texture: opened.texture,
-    width: opened.width,
-    height: opened.height,
-    onBarcode: (callback: (result: BarcodeResult) => void) => camera.setBarcodeCallback(opened.handle, callback),
-    close: () => camera.close(opened.handle),
-  }
-}
+/**
+ * Opens a camera and exposes it as reactive signals: read texture() in JSX and
+ * it appears once the stream is configured. Closes automatically when the
+ * reactive owner is disposed (e.g. the component unmounts). For imperative use,
+ * call open() from "flux:camera" directly.
+ */
+export function createCamera(options: CameraOptions = {}): CameraStream {
+  let [texture, setTexture] = createSignal<number | undefined>(undefined)
+  let [width, setWidth] = createSignal<number | undefined>(undefined)
+  let [height, setHeight] = createSignal<number | undefined>(undefined)
+  let [barcode, setBarcode] = createSignal<BarcodeResult | undefined>(undefined)
+  let [error, setError] = createSignal<Error | undefined>(undefined)
+  let session: Awaited<ReturnType<typeof open>> | undefined
+  let disposed = false
+
+  open(options)
+    .then((cam) => {
+      if (disposed) {
+        cam.close()
+        return
+      }
+      session = cam
+      if (options.scan) cam.onBarcode((result) => setBarcode(result))
+      setTexture(cam.texture)
+      setWidth(cam.width)
+      setHeight(cam.height)
+    })
+    .catch((e) => setError(e instanceof Error ? e : new Error(String(e))))
+
+  onCleanup(() => {
+    disposed = true
+    if (session) {
+      session.close()
+      session = undefined
+    }
+  })
 
-export { CameraView, type CameraViewProps } from "./camera-view"
+  return { texture, width, height, barcode, error }
+}

package/src/color.ts

@@ -0,0 +1,58 @@
+import { colord, extend } from "colord"
+import namesPlugin from "colord/plugins/names"
+extend([namesPlugin])
+
+/**
+ * Parses a CSS color string (named, hex, `rgb()`, `hsl()`, ...) into a packed
+ * `0xRRGGBBAA` u32: red in the high byte, alpha in the low byte. Alpha is scaled
+ * from colord's 0..1 to 0..255. This is the wire format the runtime expects for
+ * the `color` property.
+ */
+export function parseColor(color: string): number {
+  let { r, g, b, a } = colord(color).toRgb()
+  return (((r & 0xFF) << 24) | ((g & 0xFF) << 16) | ((b & 0xFF) << 8) | ((a * 255) & 0xFF)) >>> 0
+}
+
+// A color stop: `offset` is 0..1 along the gradient, `color` any CSS color string.
+export type GradientStop = { offset: number; color: string }
+
+type Stop = { offset: number; color: number }
+
+// A gradient fill value, produced by createLinearGradient / createRadialGradient
+// and passed to a paint `color` prop. Coordinates are relative (0..1 of the
+// element's box), so one gradient can be reused on elements of any size. Branded
+// so the renderer can tell it from a solid color string. The object crosses to
+// the runtime as-is and is decoded by key (see properties/paint.rs).
+export type Gradient =
+  | { readonly __gradient: "linear"; x0: number; y0: number; x1: number; y1: number; stops: Stop[] }
+  | { readonly __gradient: "radial"; cx: number; cy: number; r: number; circle: boolean; stops: Stop[] }
+
+/**
+ * A linear gradient between two points, each given in 0..1 of the element's box
+ * ((0,0) top-left, (1,1) bottom-right). Stops are clamped at the ends.
+ */
+export function createLinearGradient(
+  x0: number, y0: number, x1: number, y1: number, stops: GradientStop[],
+): Gradient {
+  return { __gradient: "linear", x0, y0, x1, y1, stops: parseStops(stops) }
+}
+
+/**
+ * A radial gradient centered at `(cx, cy)` (0..1 of the box) with radius `r`
+ * (0..1). Defaults to an ellipse that follows the box's aspect ratio; pass
+ * `{ shape: "circle" }` to keep a true circle (radius is then a fraction of the
+ * shorter side).
+ */
+export function createRadialGradient(
+  cx: number, cy: number, r: number, stops: GradientStop[], opts?: { shape?: "ellipse" | "circle" },
+): Gradient {
+  return { __gradient: "radial", cx, cy, r, circle: opts?.shape === "circle", stops: parseStops(stops) }
+}
+
+export function isGradient(value: unknown): value is Gradient {
+  return typeof value === "object" && value !== null && "__gradient" in value
+}
+
+function parseStops(stops: GradientStop[]): Stop[] {
+  return stops.map((s) => ({ offset: s.offset, color: parseColor(s.color) }))
+}

package/src/core.ts

@@ -1,12 +1,4 @@
-import { colord, extend } from "colord"
-import namesPlugin from "colord/plugins/names"
-import type { MeasureTextOptions } from "./types"
-extend([namesPlugin])
-
-export function parseColorToU32(color: string): number {
-  let { r, g, b, a } = colord(color).toRgb()
-  return (((r & 0xFF) << 24) | ((g & 0xFF) << 16) | ((b & 0xFF) << 8) | ((a * 255) & 0xFF)) >>> 0
-}
+import * as tree from "flux:rendertree"
 
 let handlers = new Map<number, Map<string, Function>>()
 
@@ -36,6 +28,13 @@ export function cleanupNodeHandlers(nodeId: number): void {
 let focusedNodeId: number | null = null
 let textInputActive = false
 
+/**
+ * Moves keyboard focus to `nodeId`, or clears it with `null`. Fires `onBlur` on
+ * the previously focused node and `onFocus` on the new one. As a side effect,
+ * the on-screen keyboard is activated when the newly focused node has an
+ * `onTextInput` handler and deactivated otherwise. No-op if the node is already
+ * focused.
+ */
 export function setFocus(nodeId: number | null): void {
   if (nodeId === focusedNodeId) return
   let oldId = focusedNodeId
@@ -49,7 +48,7 @@ export function setFocus(nodeId: number | null): void {
   let wantActive = nodeId != null && getEventHandler(nodeId, "onTextInput") != null
   if (wantActive !== textInputActive) {
     textInputActive = wantActive
-    ffi.setTextInputActive(wantActive)
+    tree.setTextInputActive(wantActive)
   }
 }
 
@@ -64,15 +63,22 @@ export interface BoundingBox {
   height: number
 }
 
-// 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 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.
+ */
 export function getBoundingBox(node: { id: number }): BoundingBox | null {
-  return ffi.getBoundingBox(node.id)
+  return tree.getBoundingBox(node.id)
 }
 
-export function measureText(text: string, options?: MeasureTextOptions): { width: number, height: number } {
-  return ffi.measureText(text, options)
+/**
+ * Measures the rendered size of `text` in layout pixels under the given font
+ * options (family, size, weight, style, maxLines), without adding it to the
+ * tree. Useful for sizing or laying out around text before it is drawn.
+ */
+export function measureText(text: string, options?: tree.MeasureTextOptions): { width: number, height: number } {
+  return tree.measureText(text, options)
 }

package/src/gpu.ts

@@ -1,34 +1,52 @@
-export type DecodedImage = {
-  data: Uint8Array
-  width: number
-  height: number
-}
+// GPU textures and shaders, reactive (SolidJS) layer: the create* helpers free
+// their texture automatically when the reactive owner is disposed. The imperative
+// primitive lives in the `flux:gpu` module; import { uploadTexture,
+// setShaderParams, destroyTexture, ... } from "flux:gpu" for non-reactive use.
 
-export function decodeImage(bytes: Uint8Array): DecodedImage {
-  return gpu.decodeImage(bytes)
-}
+import { getOwner, onCleanup } from "@solidjs/signals"
+import * as gpu from "flux:gpu"
 
+/**
+ * Uploads raw RGBA8 pixels to an immutable GPU texture and returns its id (use
+ * it as `<texture src={id} />`). `data` must be exactly `width * height * 4`
+ * bytes; a mismatch throws. For pixels you intend to mutate and re-upload, use
+ * `createMutableTexture` instead. When called inside a reactive scope the
+ * 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.
+ */
 export function createTexture(data: Uint8Array, width: number, height: number): number {
-  return gpu.createTexture(data, width, height)
+  let id = gpu.createTexture(data, width, height)
+  if (getOwner()) onCleanup(() => gpu.destroyTexture(id))
+  return id
 }
 
-// The texture keeps reading from `data` (which may hold multiple frames):
-// mutate it in place, then call uploadTexture to push the pixels to the GPU.
+/**
+ * Creates a GPU texture you intend to update over time: seed it with `data`,
+ * 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.
+ */
 export function createMutableTexture(data: Uint8Array, width: number, height: number): number {
-  return gpu.createMutableTexture(data, width, height)
-}
-
-export function uploadTexture(textureId: number, offset: number = 0): void {
-  gpu.uploadTexture(textureId, offset)
+  let id = gpu.createMutableTexture(data, width, height)
+  if (getOwner()) onCleanup(() => gpu.destroyTexture(id))
+  return id
 }
 
-// Compile a GLSL ES 3.00 fragment shader and render it into a texture, returning
-// the texture id (usable anywhere a normal texture id is, e.g. <texture src>).
-// The fragment body may reference vUV (0..1, top-left origin), iResolution,
-// iTime, and any `uniform float` it declares; pass their values via `params`.
-// `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 setShaderParams call, so live sources stay current.
+/**
+ * Compiles a GLSL ES 3.00 fragment shader and renders it into a texture,
+ * returning the texture id (usable anywhere a normal texture id is, e.g.
+ * `<texture src>`). The fragment body may reference `vUV` (0..1, top-left
+ * origin), `iResolution`, `iTime`, and any `uniform float` it declares; pass
+ * their values via `params`. `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 `setShaderParams` call, 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.
+ */
 export function createShader(
   fragmentSrc: string,
   width: number,
@@ -36,11 +54,7 @@ export function createShader(
   params?: Record<string, number>,
   textures?: Record<string, number>,
 ): number {
-  return gpu.createShader(fragmentSrc, width, height, params, textures)
-}
-
-// Re-render an existing shader texture with new param values and request a
-// frame. Use this to animate (e.g. update iTime each frame).
-export function setShaderParams(textureId: number, params: Record<string, number>): void {
-  gpu.setShaderParams(textureId, params)
+  let id = gpu.createShader(fragmentSrc, width, height, params, textures)
+  if (getOwner()) onCleanup(() => gpu.destroyTexture(id))
+  return id
 }

package/src/image.ts

@@ -0,0 +1,19 @@
+// CPU image codec: decode encoded image bytes into raw RGBA8 pixels (and, in
+// future, encode them back). Kept separate from the GPU/texture APIs because no
+// GPU is involved; pair decodeImage with createTexture from "@solidrt/core/gpu"
+// to upload the result.
+
+export type DecodedImage = {
+  data: Uint8Array
+  width: number
+  height: number
+}
+
+/**
+ * Decodes encoded image bytes (PNG, JPEG, and the other formats the runtime's
+ * image decoder supports) into raw, tightly-packed RGBA8 pixels plus the
+ * decoded dimensions. Feed the result straight into `createTexture`.
+ */
+export function decodeImage(bytes: Uint8Array): DecodedImage {
+  return image.decodeImage(bytes)
+}

package/src/index.ts

@@ -1,9 +1,13 @@
 export * from "./renderer"
-export { setFocus, getFocusedNodeId, measureText, getBoundingBox, parseColorToU32 } from "./core"
+export { setFocus, getFocusedNodeId, measureText, getBoundingBox } from "./core"
 export type { BoundingBox } from "./core"
+export { parseColor, createLinearGradient, createRadialGradient } from "./color"
+export type { Gradient, GradientStop } from "./color"
 export { onFrame, onLayout, onResize, onWindowFocus, onWindowBlur } from "./window"
-export { createTexture, decodeImage } from "./gpu"
-export type { DecodedImage } from "./gpu"
+export { windowSize, safeArea, displayScale, windowFocused, keyboardHeight } from "./window"
+export { createTexture } from "./gpu"
+export { decodeImage } from "./image"
+export type { DecodedImage } from "./image"
 export type {
   LayoutProps,
   TransformProps,
@@ -22,6 +26,6 @@ export type {
   TextProps,
   TextureProps,
   AudioProps,
-  MeasureTextOptions,
   Color,
 } from "./types"
+export type { MeasureTextOptions } from "flux:rendertree"

package/src/microphone.ts

@@ -1,40 +1,58 @@
-// Microphone capture. A session delivers raw mono float32 samples at the
-// requested sample rate (the device format is converted by SDL); read()
-// drains whatever was captured since the last call. Captured audio buffers
-// until read, so poll read() regularly (e.g. once per frame) while open.
+// Microphone capture, reactive (SolidJS) layer. A session delivers raw mono
+// float32 samples at the requested sample rate (the device format is converted
+// by SDL); read() drains whatever was captured since the last call. Captured
+// audio buffers until read, so poll read() regularly (e.g. once per frame) while
+// open.
+//
+// The imperative primitive lives in the `flux:microphone` module; import
+// { open, listMicrophones } from "flux:microphone" for non-reactive use.
 
-export type MicrophoneInfo = {
-  id: number
-  name: string
-}
+import { createSignal, onCleanup } from "@solidjs/signals"
+import { open } from "flux:microphone"
 
 export type MicrophoneOptions = {
-  /** Explicit device id from listMicrophones(); default is the system default recording device. */
+  /** Explicit device id from flux:microphone listMicrophones(); default is the system default. */
   microphone?: number
   /** Sample rate of the delivered samples (the device rate is converted). Default 16000. */
   sampleRate?: number
 }
 
-export type Microphone = {
-  /** Sample rate of read() samples. */
-  sampleRate: number
-  /** Drain the mono float32 samples captured since the last read. */
+/** A live microphone with reactive lifecycle. */
+export type MicrophoneStream = {
+  /** Sample rate of read() samples (0 if opening failed). */
+  sampleRate(): number
+  /** Drain the mono float32 samples captured since the last read (empty if not open). */
   read(): Float32Array
-  /** Release the device. */
-  close(): void
+  /** Set if opening failed. */
+  error(): Error | undefined
 }
 
-export function listMicrophones(): MicrophoneInfo[] {
-  return microphone.listMicrophones()
-}
+/**
+ * Opens a microphone and owns its lifecycle: closes when the reactive owner is
+ * disposed. Capture stays pull-based, so read() drains samples on demand (e.g.
+ * once per frame). For imperative use, call open() from "flux:microphone".
+ */
+export function createMicrophone(options: MicrophoneOptions = {}): MicrophoneStream {
+  let [error, setError] = createSignal<Error | undefined>(undefined)
+  let session: ReturnType<typeof open> | undefined
+  let rate = 0
+  try {
+    session = open(options)
+    rate = session.sampleRate
+  } catch (e) {
+    setError(e instanceof Error ? e : new Error(String(e)))
+  }
+
+  onCleanup(() => {
+    if (session) {
+      session.close()
+      session = undefined
+    }
+  })
 
-// Async to leave room for an OS permission prompt on platforms that need one
-// (the desktop backends open synchronously).
-export async function openMicrophone(options: MicrophoneOptions = {}): Promise<Microphone> {
-  let opened = microphone.open(options)
   return {
-    sampleRate: opened.sampleRate,
-    read: () => microphone.read(opened.handle),
-    close: () => microphone.close(opened.handle),
+    sampleRate: () => rate,
+    read: () => (session ? session.read() : new Float32Array(0)),
+    error,
   }
 }