@solidrt/core 0.0.50 → 0.0.51

package/src/{sound.ts → audio.ts}

@@ -27,6 +27,15 @@ export type SoundOptions = {
    * Omitted means unspatialized.
    */
   pan?: number
+  /**
+   * Playback rate: 1.0 plays as loaded, higher is faster and higher-pitched
+   * (clamped to [0.01, 100]). Defaults to 1.0.
+   */
+  rate?: number
+  /** Fade each play() in from silence over this many milliseconds. */
+  fadeInMs?: number
+  /** Bus name for every voice of this sound (see flux:audio `stop({ bus })`). */
+  bus?: string
   /**
    * Let play() stack overlapping voices instead of restarting. Defaults to
    * true: rapid triggers overlap. Set false for a single-voice sound where each
@@ -35,6 +44,21 @@ export type SoundOptions = {
   overlap?: boolean
 }
 
+/** Options for the live setters: ramp to the value instead of jumping. */
+export type SoundRampOptions = {
+  /**
+   * Reach the new value over this many milliseconds, engine-smoothed (immune
+   * to frame hitches). Omitted (or 0) sets immediately.
+   */
+  rampMs?: number
+}
+
+/** Options for {@link Sound.stop}. */
+export type SoundStopOptions = {
+  /** Fade to silence over this many milliseconds before stopping. */
+  fadeOutMs?: number
+}
+
 /** Options for a PCM sound: `SoundOptions` plus the channel count. */
 export type PcmSoundOptions = SoundOptions & {
   /** Channel count, interleaved samples when 2. Defaults to 1 (mono). */
@@ -49,18 +73,26 @@ export type SoundStreamOptions = {
   gain?: number
   /** Stereo position in [-1, 1] (see {@link SoundOptions.pan}). */
   pan?: number
+  /** Playback rate (see {@link SoundOptions.rate}). Defaults to 1.0. */
+  rate?: number
+  /** Fade each play() in from silence over this many milliseconds. */
+  fadeInMs?: number
+  /** Bus name for the stream's voice (see flux:audio `stop({ bus })`). */
+  bus?: string
 }
 
 /** A decoded sound with reactive lifecycle. */
 export type Sound = {
   /** Start the clip. Overlaps or restarts per the `overlap` option. */
   play(): void
-  /** Stop every voice started from this sound. */
-  stop(): void
+  /** Stop every voice started from this sound, fading first if asked. */
+  stop(options?: SoundStopOptions): void
   /** Set the volume of every live voice, and of voices started later. */
-  setGain(gain: number): void
+  setGain(gain: number, options?: SoundRampOptions): void
   /** Set the stereo position of every live voice, and of voices started later. */
-  setPan(pan: number): void
+  setPan(pan: number, options?: SoundRampOptions): void
+  /** Set the playback rate of every live voice, and of voices started later. */
+  setRate(rate: number, options?: SoundRampOptions): void
   /** True after play() until stop() (does not track natural completion). */
   playing(): boolean
   /** Set if loading failed. */
@@ -69,12 +101,12 @@ export type Sound = {
 
 // Shared reactive wrapper: owns the loaded clip, tracks live voices, and
 // disposes both on cleanup. `loader` runs once (may throw -> error signal).
-// Gain and pan are remembered so later voices start where setGain/setPan left
-// the sound, not back at the initial options.
+// Gain, pan and rate are remembered so later voices start where the setters
+// left the sound, not back at the initial options.
 function reactiveSound(
   loader: () => Clip,
   overlap: boolean,
-  initial: { loop?: boolean; gain?: number; pan?: number },
+  initial: { loop?: boolean; gain?: number; pan?: number; rate?: number; fadeInMs?: number; bus?: string },
 ): Sound {
   let [error, setError] = createSignal<Error | undefined>(undefined, { ownedWrite: true })
   let [playing, setPlaying] = createSignal(false, { ownedWrite: true })
@@ -84,6 +116,9 @@ function reactiveSound(
   let loop = initial.loop
   let gain = initial.gain
   let pan = initial.pan
+  let rate = initial.rate
+  let fadeInMs = initial.fadeInMs
+  let bus = initial.bus
   try {
     clip = loader()
   } catch (e) {
@@ -96,8 +131,8 @@ function reactiveSound(
     voices = voices.filter((v) => !v.ended())
   }
 
-  let stopAll = () => {
-    for (let v of voices) v.stop()
+  let stopAll = (options?: SoundStopOptions) => {
+    for (let v of voices) v.stop(options)
     voices = []
     setPlaying(false)
   }
@@ -115,19 +150,24 @@ function reactiveSound(
       if (!clip) return
       if (overlap) prune()
       else stopAll()
-      voices.push(clip.play({ loop, gain, pan }))
+      voices.push(clip.play({ loop, gain, pan, rate, fadeInMs, bus }))
       setPlaying(true)
     },
     stop: stopAll,
-    setGain(value) {
+    setGain(value, options) {
       gain = value
       prune()
-      for (let v of voices) v.setGain(value)
+      for (let v of voices) v.setGain(value, options)
     },
-    setPan(value) {
+    setPan(value, options) {
       pan = value
       prune()
-      for (let v of voices) v.setPan(value)
+      for (let v of voices) v.setPan(value, options)
+    },
+    setRate(value, options) {
+      rate = value
+      prune()
+      for (let v of voices) v.setRate(value, options)
     },
     playing,
     error,
@@ -144,6 +184,9 @@ export function createSound(source: Uint8Array, options: SoundOptions = {}): Sou
     loop: options.loop,
     gain: options.gain,
     pan: options.pan,
+    rate: options.rate,
+    fadeInMs: options.fadeInMs,
+    bus: options.bus,
   })
 }
 
@@ -165,6 +208,9 @@ export function createPcmSound(
     loop: options.loop,
     gain: options.gain,
     pan: options.pan,
+    rate: options.rate,
+    fadeInMs: options.fadeInMs,
+    bus: options.bus,
   })
 }
 
@@ -178,5 +224,12 @@ export function createPcmSound(
  */
 export function createSoundStream(source: string | FluxFile, options: SoundStreamOptions = {}): Sound {
   let src = typeof source === "string" ? file(source) : source
-  return reactiveSound(() => stream(src), false, { loop: options.loop, gain: options.gain, pan: options.pan })
+  return reactiveSound(() => stream(src), false, {
+    loop: options.loop,
+    gain: options.gain,
+    pan: options.pan,
+    rate: options.rate,
+    fadeInMs: options.fadeInMs,
+    bus: options.bus,
+  })
 }

package/src/color.ts

@@ -1,30 +1,29 @@
-import { colord, extend } from "colord"
-import namesPlugin from "colord/plugins/names"
-import mixPlugin from "colord/plugins/mix"
-extend([namesPlugin, mixPlugin])
+import * as tree from "flux:rendertree"
+
+// Color parsing and mixing live in the runtime (alloy's color module), one
+// owner for the CSS grammar and the perceptual math; these re-exports keep
+// the core API surface. The renderer no longer parses at all: color strings
+// cross the FFI raw and the runtime decodes them.
 
 /**
  * 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. Throws on a string that is not a valid CSS color, so a
- * typo fails on the line that wrote it instead of silently painting black.
+ * `0xRRGGBBAA` u32: red in the high byte, alpha in the low byte. This is the
+ * wire format the runtime expects for the `color` property. Throws on a
+ * string that is not a valid CSS color, so a typo fails on the line that
+ * wrote it instead of silently painting black.
  */
 export function parseColor(color: string): number {
-  let c = colord(color)
-  if (!c.isValid()) throw new Error(`Invalid color "${color}"`)
-  let { r, g, b, a } = c.toRgb()
-  return (((r & 0xFF) << 24) | ((g & 0xFF) << 16) | ((b & 0xFF) << 8) | ((a * 255) & 0xFF)) >>> 0
+  return tree.parseColor(color)
 }
 
 /**
- * Mixes two CSS colors in the CIE LAB color space; `t` is the fraction of `b`
- * (0 = pure `a`, 1 = pure `b`). Returns an opaque hex string. Use it to derive
- * semantic tones (muted text, subtle borders) instead of alpha overlays, so
- * the resulting color does not depend on what is drawn beneath it.
+ * Mixes two CSS colors in oklab; `t` is the fraction of `b` (0 = pure `a`,
+ * 1 = pure `b`). Returns a hex string. Use it to derive semantic tones
+ * (muted text, subtle borders) instead of alpha overlays, so the resulting
+ * color does not depend on what is drawn beneath it.
  */
 export function mixColors(a: string, b: string, t: number): string {
-  return colord(a).mix(b, t).toHex()
+  return tree.mixColors(a, b, t)
 }
 
 /**
@@ -33,7 +32,7 @@ export function mixColors(a: string, b: string, t: number): string {
  * e.g. whether a label sits light-on-dark (see typeWeight in components).
  */
 export function brightness(color: string): number {
-  return colord(color).brightness()
+  return tree.brightness(color)
 }
 
 // A color stop: `offset` is 0..1 along the gradient, `color` any CSS color string.

package/src/core.ts

@@ -363,6 +363,21 @@ export type TextLine = {
   cursor: number
 }
 
+/**
+ * Ink width of the wrap unit starting at unit `index`: its advance through
+ * every glued piece that follows, plus the last piece's ink. What must fit on
+ * the line for the unit to go on it.
+ */
+export function unitInk(units: tree.TextUnit[], index: number): number {
+  let ink = units[index]!.width
+  let advance = 0
+  for (let j = index + 1; j < units.length && units[j]!.glue; j++) {
+    advance += units[j - 1]!.advance
+    ink = advance + units[j]!.width
+  }
+  return ink
+}
+
 /**
  * The next line of `prepared` from unit `cursor` that fits `width`, or null
  * when the text is used up. Greedy: units go on the line while the pen plus
@@ -370,7 +385,9 @@ export type TextLine = {
  * wider than `width` on its own goes on the line whole and overflows. Draw a
  * line as `<d-text x y w={line.width + 1}>{prepared.text.slice(line.start, line.end)}</d-text>`
  * with the same font options; its words are already shaped, so that is
- * cheap. Floats, balancing and ellipsis are <text> features, not this.
+ * cheap. With `runs`, a unit crossing a run boundary is several glued units
+ * that always land on one line; draw such a line with a <span> per run.
+ * Floats, balancing and ellipsis are <text> features, not this.
  */
 export function layoutNextLine(prepared: tree.PreparedText, cursor: number, width: number): TextLine | null {
   let units = prepared.units
@@ -381,7 +398,9 @@ export function layoutNextLine(prepared: tree.PreparedText, cursor: number, widt
   let i = cursor
   while (i < units.length) {
     let unit = units[i]!
-    if (i > cursor && pen + unit.width > width) break
+    // Glued pieces stay with the unit they continue: the whole wrap unit
+    // (this piece through the last glued one) must fit for any of it to go on.
+    if (i > cursor && !unit.glue && pen + unitInk(units, i) > width) break
     pen += unit.advance
     if (unit.ascent > ascent) ascent = unit.ascent
     if (unit.descent > descent) descent = unit.descent

package/src/data.ts

@@ -0,0 +1,99 @@
+// Reactive SQLite. A query is a reactive value: it re-runs when any table it
+// reads is written on this connection, and every consumer updates through
+// normal Solid reactivity. SQLite itself reports both sides of the dependency
+// graph - the statement's read-set comes from `stmt.tables()` (SQLite's
+// authorizer) and writes come from `db.onWrite` (SQLite's update hook, so
+// trigger and cascade writes are included). No SQL parsing, no manual
+// declarations, no wrapper: queries take the plain `flux:sqlite` Database.
+//
+// The contract, in one sentence: a query re-runs when any table it reads is
+// written on this connection. Granularity is per table; writes from another
+// connection or process are not seen; WITHOUT ROWID tables do not report.
+//
+// The imperative primitives live in the `flux:sqlite` module and are
+// framework-neutral. This module is only the thin Solid binding on top (a
+// version signal per table, an async memo per query).
+
+import { createMemo, createSignal } from "@solidjs/signals"
+import type { Signal, SourceAccessor } from "@solidjs/signals"
+import type { Database, Row, SqlParam, Statement } from "flux:sqlite"
+
+export { Database } from "flux:sqlite"
+export type { OpenMode, Row, RunResult, SqlParam, SqlValue, Statement } from "flux:sqlite"
+
+/** Bind parameters: a plain array, or an accessor for reactive params. */
+export type Params = SqlParam[] | (() => SqlParam[])
+
+// Per-database dependency tracking, created lazily on the first createQuery:
+// one version signal per table, bumped from the connection's write events.
+// The function reads (and lazily creates) the version signal of one table.
+// Keyed by the plain Database so there is no wrapper type to hand around.
+let trackers = new WeakMap<Database, (table: string) => void>()
+
+function trackerFor(db: Database): (table: string) => void {
+  let track = trackers.get(db)
+  if (track) return track
+
+  let versions = new Map<string, Signal<number>>()
+  // A write bumps only existing signals: a signal that was never read has no
+  // subscribers, so there is nothing to invalidate. The subscription lives
+  // for the connection's life; close() ends it.
+  db.onWrite((tables) => {
+    for (let table of tables) {
+      let version = versions.get(table)
+      if (version) version[1]((v) => v + 1)
+    }
+  })
+  track = (table) => {
+    let version = versions.get(table)
+    if (!version) {
+      version = createSignal(0)
+      versions.set(table, version)
+    }
+    version[0]()
+  }
+  trackers.set(db, track)
+  return track
+}
+
+/**
+ * A reactive query: an accessor over the matching rows that re-runs when any
+ * table the statement reads is written on this connection. Reads surface as
+ * pending until the first result lands - wrap in `<Loading>` or default with
+ * `?? []`. Pass params as an accessor to also re-run when they change.
+ */
+export function createQuery(db: Database, sql: string, params?: Params): SourceAccessor<Row[]> {
+  return statementQuery(db, sql, params, (stmt, p) => stmt.all(p))
+}
+
+/**
+ * Like {@link createQuery}, but for single-row reads: resolves to the first
+ * matching row, or `undefined` when there is none.
+ */
+export function createQueryRow(
+  db: Database,
+  sql: string,
+  params?: Params,
+): SourceAccessor<Row | undefined> {
+  return statementQuery(db, sql, params, (stmt, p) => stmt.get(p))
+}
+
+function statementQuery<T>(
+  db: Database,
+  sql: string,
+  params: Params | undefined,
+  run: (stmt: Statement, params?: SqlParam[]) => Promise<T>,
+): SourceAccessor<T> {
+  let track = trackerFor(db)
+  let stmt = db.query(sql)
+  // The read-set arrives async (one authorizer round-trip on the connection
+  // thread); computed once, it never changes for a given statement. Reads of
+  // the query below surface as pending until it lands, then the query runs -
+  // so the first execution already subscribes to its tables and no write can
+  // slip between subscription and execution.
+  let tables = createMemo(() => stmt.tables())
+  return createMemo(() => {
+    for (let table of tables()) track(table)
+    return run(stmt, typeof params === "function" ? params() : params)
+  })
+}

package/src/gpu.ts

@@ -100,6 +100,7 @@ export type { BufferId, DrawId, ProgramId, RenderPipelineId, ShaderStageId, Text
 // registered at creation keeps working and no re-registration is needed.
 export {
   destroyTexture,
+  endBufferWrite,
   resizeTexture,
   setTargetParams,
   setTargetSize,
@@ -575,12 +576,29 @@ export function createPipelineTexture(
  * created outside a reactive scope you must call `destroyBuffer` yourself.
  * (Destruction order relative to pipelines does not matter.)
  */
-export function createBuffer(data: ArrayBuffer | ArrayBufferView, opts?: CreateOptions): gpu.BufferId {
-  let id = gpu.createBuffer(toUint8(data), opts)
+export function createBuffer(data: ArrayBuffer | ArrayBufferView | number, opts?: CreateOptions): gpu.BufferId {
+  let id = gpu.createBuffer(typeof data === "number" ? data : toUint8(data), opts)
   if (opts?.autoFree !== false && getOwner()) onCleanup(() => gpu.destroyBuffer(id))
   return id
 }
 
+/**
+ * Opens a zero-copy write into a vertex buffer: returns a Float32Array over
+ * runtime-owned memory spanning the whole buffer. Write records in place,
+ * then publish with {@link endBufferWrite} - the bytes move to the GPU with
+ * no copy on the CPU path, which is the per-frame streaming path (instanced
+ * sprites, dynamic geometry). Reach other element types through `.buffer`.
+ *
+ * Contents are UNSPECIFIED at begin (a recycled block holds what was
+ * published the time before last): fill everything you publish. One open
+ * write per buffer at a time. The view is detached at end/destroy - retained
+ * references become zero-length, so a stale write is inert, never a race.
+ */
+export function beginBufferWrite(id: gpu.BufferId): Float32Array {
+  let ab = gpu.beginBufferWrite(id)
+  return new Float32Array(ab, 0, (ab.byteLength / 4) | 0)
+}
+
 /**
  * Overwrites part of a vertex buffer at `byteOffset` (default 0). Every
  * pipeline drawing from the buffer re-renders with its last-applied params,

package/src/index.ts

@@ -1,11 +1,11 @@
 export * from "./renderer"
-export { setFocus, focusedNode, startTextInput, textInputActive, getFocusables, measureText, prepareText, layoutNextLine, getBoundingBox, getBoundingBoxViewport, onPointerMove } from "./core"
+export { setFocus, focusedNode, startTextInput, textInputActive, getFocusables, measureText, prepareText, layoutNextLine, unitInk, getBoundingBox, getBoundingBoxViewport, onPointerMove } from "./core"
 export type { BoundingBox, GlobalPointerEvent, TextLine } from "./core"
 export { parseColor, mixColors, brightness, createLinearGradient, createRadialGradient } from "./color"
 export type { Gradient, GradientStop } from "./color"
 export { onFrame, onLayout, onResize, onWindowFocus, onWindowBlur, onBack, exit } from "./window"
 export type { BackEvent } from "./window"
-export { windowSize, safeArea, displayScale, windowFocused, keyboardHeight } from "./window"
+export { windowSize, safeArea, displayScale, windowFocused, keyboardHeight, lockPointer, pointerLocked } from "./window"
 export { env } from "./environment"
 export type { InputDevices, SystemTheme, Orientation, Visibility } from "./environment"
 export { gamepads } from "./gamepad"

package/src/renderer.ts

@@ -4,7 +4,6 @@ import type { Element } from "solid-js"
 import * as tree from "flux:rendertree"
 import { attachWindow } from "./window"
 import { setEventHandler, setFocusable, setTextInputHints, cleanupNode, focusedNode, setFocus } from "./core"
-import { parseColor, isGradient } from "./color"
 
 export { getEventHandler } from "./core"
 
@@ -166,34 +165,49 @@ function setTreeProperty(node: ProxyNode, name: string, value: unknown): void {
 // Shared by the renderer's setProperty hook and by createElement, which since
 // the dom-expressions "universal" template passes static props inline as a
 // second argument rather than as separate setProp calls.
+// A property's route is a function of its name alone, so the classifying
+// regex and compares run once per unique name; per write it is one Map get.
+const ROUTE_TREE = 0
+const ROUTE_EVENT = 1
+const ROUTE_FOCUSABLE = 2
+const ROUTE_HINTS = 3
+let propRoutes = new Map<string, number>()
+
+function routeFor(name: string): number {
+  let route = propRoutes.get(name)
+  if (route === undefined) {
+    route = /^on[A-Z]/.test(name)
+      ? ROUTE_EVENT
+      : name === "focusable"
+        ? ROUTE_FOCUSABLE
+        : name === "textInputHints"
+          ? ROUTE_HINTS
+          : ROUTE_TREE
+    propRoutes.set(name, route)
+  }
+  return route
+}
+
 function applyProp<T>(node: ProxyNode, name: string, value: T): void {
   if (!node) return
 
   // console.debug("[srt] applyProp", node.id, name, value)
 
-  if (/^on[A-Z]/.test(name) && (value == null || typeof value === "function")) {
-    setEventHandler(node.id, name, value as Function | null | undefined)
-    return
-  }
-
-  if (name === "focusable") {
-    setFocusable(node.id, value === true)
-    return
-  }
-
-  if (name === "textInputHints") {
-    setTextInputHints(node.id, value as any)
-    return
-  }
-
-  if (name === "color" && isGradient(value)) {
-    setTreeProperty(node, name, value)
-    return
-  }
-
-  if (name === "color" && typeof value === "string") {
-    setTreeProperty(node, name, parseColor(value))
-    return
+  switch (routeFor(name)) {
+    case ROUTE_EVENT:
+      // A non-function, non-null value on an on* name is not a handler;
+      // fall through to the tree so the native side rejects it.
+      if (value == null || typeof value === "function") {
+        setEventHandler(node.id, name, value as Function | null | undefined)
+        return
+      }
+      break
+    case ROUTE_FOCUSABLE:
+      setFocusable(node.id, value === true)
+      return
+    case ROUTE_HINTS:
+      setTextInputHints(node.id, value as any)
+      return
   }
 
   setTreeProperty(node, name, value)

package/src/runtime-modules.d.ts

@@ -88,8 +88,9 @@ declare module "srt:dev" {
   /**
    * Register a named debug command, listable and callable from the dev server
    * (the list_debug / call_debug MCP tools). `args` arrives JSON-parsed; the
-   * return value must be JSON-serializable and synchronous (promises are not
-   * awaited). Re-registering a name replaces it; registrations reset on hot
+   * return value must be JSON-serializable and synchronous (an async command's
+   * Promise is not awaited - the call errors). Re-registering a name replaces
+   * it; registrations reset on hot
    * reload, so register at module init. Callable in every build, but only dev
    * clients ever invoke commands.
    */

package/src/scroll.ts

@@ -2,7 +2,7 @@
 // scrollable region -- the offset and its clamping against the measured content
 // and viewport sizes -- and nothing with a UI opinion. Wheel/drag input,
 // momentum, scrollbars and styling are policy and belong to the component (the
-// "skin") that composes this, the same way createCaretScroll backs TextInput.
+// "skin") that composes this, the same way createTextEditorLayout backs TextInput.
 
 import { createSignal, flush } from "@solidjs/signals"
 import { getBoundingBox } from "./core"