@solidrt/core 0.0.48 → 0.0.49

package/AGENTS.md

@@ -94,7 +94,7 @@ tsconfig.json - the two load-bearing lines are jsx + jsxImportSource:
 ```
 
 Peer deps @solidjs/signals and @solidjs/universal must match (currently
-2.0.0-beta.31); bun resolves them from peerDependencies.
+2.0.0-rc.0); bun resolves them from peerDependencies.
 
 ## Element model (the parts that are easy to get wrong)
 
@@ -200,8 +200,8 @@ Peer deps @solidjs/signals and @solidjs/universal must match (currently
   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)`
-  -> `<texture src={id} />`.
+  /speech, /gpu. Image flow: `decodeImage(bytes)` ->
+  `createTexture(data,w,h)` -> `<texture src={id} />`.
 
 ## Minimal app, core primitives only (verified to render)
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidrt/core",
-  "version": "0.0.48",
+  "version": "0.0.49",
   "license": "MIT",
   "author": "Antoine van Wel",
   "type": "module",
@@ -27,11 +27,11 @@
     "colord": "^2.9.3"
   },
   "devDependencies": {
-    "@solidrt/flux-types": "0.0.48"
+    "@solidrt/flux-types": "0.0.49"
   },
   "peerDependencies": {
-    "@solidjs/signals": "2.0.0-beta.31",
-    "@solidjs/universal": "2.0.0-beta.31",
-    "solid-js": "2.0.0-beta.31"
+    "@solidjs/signals": "2.0.0-rc.0",
+    "@solidjs/universal": "2.0.0-rc.0",
+    "solid-js": "2.0.0-rc.0"
   }
 }

package/src/text-input.ts

@@ -63,14 +63,19 @@ export type TextBuffer = {
  * source. Without one it holds the text itself. The selection is always
  * buffer-owned state and is clamped to the current text length on read, so an
  * external truncation of a controlled value cannot leave the caret dangling.
- * Every edit is clamped to `maxLength`.
+ * Every edit is clamped to `maxLength`. Mutations commit synchronously
+ * (flush), so consecutive edits in one task observe each other - required for
+ * burst input, where several handlers run with no microtask between them.
  */
 export function createTextBuffer(options: TextBufferOptions = {}): TextBuffer {
   let initial = options.defaultValue ?? ""
   let [internalValue, setInternalValue] = createSignal(initial)
+  // The caret starts at the end of the current text: for a controlled buffer
+  // that is the owner's value, which defaultValue does not reflect.
+  let initialCaret = (options.value?.() ?? initial).length
   let [selectionState, setSelectionState] = createSignal<Selection>({
-    anchor: initial.length,
-    focus: initial.length,
+    anchor: initialCaret,
+    focus: initialCaret,
   })
 
   let value = () => options.value?.() ?? internalValue()
@@ -89,7 +94,12 @@ export function createTextBuffer(options: TextBufferOptions = {}): TextBuffer {
 
   let setCaret = (offset: number) => setSelectionState({ anchor: offset, focus: offset })
 
-  // Apply a text edit and place the caret, clamping to maxLength.
+  // Apply a text edit and place the caret, clamping to maxLength. The flush
+  // commits the writes (including a controlled owner's from onInput) before
+  // returning: edits must observe each other within one task, because event
+  // bursts can dispatch several handlers with no microtask between them
+  // (Android IME input arrives as backspace+commit bursts; see
+  // okf/backlog/event-burst-stale-signal-reads.md).
   let apply = (next: string, caret: number) => {
     let max = options.maxLength?.()
     if (max != null && next.length > max) next = next.slice(0, max)
@@ -97,6 +107,7 @@ export function createTextBuffer(options: TextBufferOptions = {}): TextBuffer {
     if (options.value?.() == null) setInternalValue(next)
     setCaret(caret)
     options.onInput?.(next)
+    flush()
   }
 
   return {
@@ -131,6 +142,7 @@ export function createTextBuffer(options: TextBufferOptions = {}): TextBuffer {
       // A non-extending left/right on a range collapses to the near edge.
       if (!extend && anchor !== focus && (direction === "left" || direction === "right")) {
         setCaret(direction === "left" ? Math.min(anchor, focus) : Math.max(anchor, focus))
+        flush()
         return
       }
       let next = focus
@@ -139,11 +151,13 @@ export function createTextBuffer(options: TextBufferOptions = {}): TextBuffer {
       else if (direction === "start") next = 0
       else if (direction === "end") next = len
       setSelectionState({ anchor: extend ? anchor : next, focus: next })
+      flush()
     },
 
     setSelection: (anchor, focus) => {
       let len = value().length
       setSelectionState({ anchor: Math.min(anchor, len), focus: Math.min(focus, len) })
+      flush()
     },
 
     setValue: (next) => apply(next, next.length),

package/src/video.ts

@@ -0,0 +1,100 @@
+// Video playback, reactive (SolidJS) layer. There is no <video> element by
+// design: a player streams into a texture id, so displaying it is just
+// <texture src={video.texture()} /> (or <d-texture> for detached-layout
+// placement), and every texture capability - shaders, offscreen targets,
+// subtree effects - applies to video for free. A richer Video component
+// composes on top of this in a higher layer, not in core.
+//
+// The imperative primitive lives in the `flux:video` module; import { open }
+// from "flux:video" for non-reactive use.
+
+import { createSignal, onCleanup } from "@solidjs/signals"
+import type { TextureId } from "flux:gpu"
+import { open } from "flux:video"
+
+export type VideoOptions = {
+  /** Start playback as soon as the file is open. */
+  autoplay?: boolean
+}
+
+/** An opened video as reactive accessors plus playback controls. */
+export type VideoStream = {
+  /** Texture id once the file is open, undefined while opening; render with <texture src={...}>. */
+  texture(): TextureId | undefined
+  /** Frame size, undefined while opening. */
+  width(): number | undefined
+  height(): number | undefined
+  /** Duration in seconds, undefined while opening. */
+  duration(): number | undefined
+  /** Set if opening failed (unreadable file, unsupported codec). */
+  error(): Error | undefined
+  /** Start or resume playback (before open resolves, playback starts on resolve). */
+  play(): void
+  /** Pause playback; the current frame stays displayed. */
+  pause(): void
+  /** Whether playback is running (plain read, not a signal). */
+  playing(): boolean
+  /** Presentation time of the displayed frame in seconds (plain read, not a signal). */
+  currentTime(): number
+  /** Whether the last frame has been displayed (plain read, not a signal). */
+  finished(): boolean
+}
+
+/**
+ * Opens a video file (MP4, H.264 + AAC) and exposes it as reactive signals:
+ * read texture() in JSX and the frames appear once playback starts. Closes
+ * automatically when the reactive owner is disposed (e.g. the component
+ * unmounts). For imperative use, call open() from "flux:video" directly.
+ */
+export function createVideo(path: string, options: VideoOptions = {}): VideoStream {
+  let [texture, setTexture] = createSignal<TextureId | undefined>(undefined)
+  let [width, setWidth] = createSignal<number | undefined>(undefined)
+  let [height, setHeight] = createSignal<number | undefined>(undefined)
+  let [duration, setDuration] = createSignal<number | undefined>(undefined)
+  let [error, setError] = createSignal<Error | undefined>(undefined)
+  let player: Awaited<ReturnType<typeof open>> | undefined
+  let disposed = false
+  let wantPlay = options.autoplay ?? false
+
+  open(path)
+    .then((video) => {
+      if (disposed) {
+        video.close()
+        return
+      }
+      player = video
+      setTexture(video.texture)
+      setWidth(video.width)
+      setHeight(video.height)
+      setDuration(video.duration)
+      if (wantPlay) video.play()
+    })
+    .catch((e) => setError(e instanceof Error ? e : new Error(String(e))))
+
+  onCleanup(() => {
+    disposed = true
+    if (player) {
+      player.close()
+      player = undefined
+    }
+  })
+
+  return {
+    texture,
+    width,
+    height,
+    duration,
+    error,
+    play() {
+      wantPlay = true
+      player?.play()
+    },
+    pause() {
+      wantPlay = false
+      player?.pause()
+    },
+    playing: () => player?.playing() ?? false,
+    currentTime: () => player?.currentTime() ?? 0,
+    finished: () => player?.finished() ?? false,
+  }
+}