@solidrt/core 0.0.54 → 0.0.56

package/src/gpu.ts

@@ -11,8 +11,9 @@
 // `flux:gpu` module.
 //
 // Sampling is a per-texture property declared at creation: `filter`
-// ("linear" default | "nearest"), `wrap` ("clamp" default | "repeat") and
-// `mipmap` (default false) on every create* helper. One state for every
+// ("linear" default | "nearest"), `wrap` ("clamp" default | "repeat"),
+// `mipmap` (default false) and `anisotropy` (default 1 = off; pair it with
+// mipmap) on every create* helper. One state for every
 // consumer - `<texture>` display and shader sampling both follow it - so a
 // nearest texture upscales with hard pixels everywhere (the retro/pixel-art
 // path: render small, display big). `mipmap: true` keeps a mip chain the
@@ -50,7 +51,11 @@
 //   and target holds 8-bit RGBA UNORM exactly as written; nothing converts to
 //   or from linear light. `filter: "linear"` averages and the `blend` modes
 //   accumulate non-linear values - the usual approximation, stated so
-//   shaders written today stay correct if a format vocabulary arrives.
+//   shaders written today stay correct. The one exception is opt-in: an
+//   "rgba8-srgb" texture decodes to linear light when a shader samples it
+//   (and "rgba16f" holds linear HDR values), which is how a linear-space
+//   renderer such as `@solidrt/3d` reads its inputs before encoding its
+//   output back into this contract.
 
 import { createEffect, createSignal, getOwner, onCleanup, untrack } from "@solidjs/signals"
 import * as gpu from "flux:gpu"
@@ -68,13 +73,20 @@ export type CreateOptions = { autoFree?: boolean; label?: string }
 
 // Sampling options every texture-producing create* helper accepts, applied at
 // creation as a property of the texture id (there is no set-sampler-later).
-export type SamplerOptions = { filter?: gpu.FilterMode; wrap?: gpu.WrapMode; mipmap?: boolean }
+export type SamplerOptions = { filter?: gpu.FilterMode; wrap?: gpu.WrapMode; mipmap?: boolean; anisotropy?: number }
 export type { FilterMode, WrapMode, TextureBinding, TextureBindings } from "flux:gpu"
 
 // Pixel format option for the pixel-upload creates (createTexture,
-// createMutableTexture), fixed for the id's lifetime like the sampler state.
-// "rgba8" (default) or "r8" - see TextureFormat in flux:gpu for the r8
-// contract (1 byte/pixel, sampled as `(v, 0, 0, 1)`, any width).
+// createCubeTexture, createMutableTexture), fixed for the id's lifetime like
+// the sampler state. "rgba8" (default), "rgba8-srgb" (decodes to linear
+// light on sample), "r8", the float data-texture formats "r32f"/"rgba32f"
+// (Float32Array payload, nearest/texelFetch sampling only, no readback) and
+// the HDR image format "rgba16f" (Float32Array payload packed to half float,
+// filterable) - see TextureFormat in flux:gpu for each format's contract.
+// Draw targets (createDrawTarget, createCubeDrawTarget) take the renderable
+// subset: "rgba8", "rgba8-srgb", "rgba16f".
+// "etc2-rgba8" (compressed) is a reserved future value of the same
+// vocabulary.
 export type TextureFormatOptions = { format?: gpu.TextureFormat }
 export type { TextureFormat } from "flux:gpu"
 
@@ -135,7 +147,7 @@ export {
 // GPU-side (exact, same size): seed a loadOp "load" accumulator, snapshot a
 // ping-pong buffer, reset state to a known image.
 export { copyTexture, destroyBuffer, renderTarget, setDraw } from "flux:gpu"
-export type { BlendMode, BufferUpdate, CullMode, DrawRange, IndexBinding, IndexFormat, IndexRange, InstanceAttribute, ShaderParams, Topology, VertexAttribute } from "flux:gpu"
+export type { BlendMode, BufferUpdate, CullMode, DrawRange, IndexBinding, IndexFormat, IndexRange, InstanceAttribute, InstanceOrder, OrderUpdate, ShaderParams, Topology, VertexAttribute } from "flux:gpu"
 
 // The draw-list verbs, re-exported raw: entries live and die with their draw
 // target (see createDrawTarget below), so there is no per-entry lifetime to
@@ -149,7 +161,10 @@ export type { BlendMode, BufferUpdate, CullMode, DrawRange, IndexBinding, IndexF
 // params every entry reads. setDrawOrder replaces the whole
 // list order with a full permutation of the live ids - the sorting verb
 // (opaque front-to-back, transparent back-to-front, re-issued when the
-// camera moves).
+// camera moves). That orders ENTRIES; ordering the instance RECORDS within
+// one entry is the instanceOrder creation option (see InstanceOrder), whose
+// projected-key direction updates ride setDraw/setDrawRange as
+// orderDirection.
 export { addDraw, removeDraw, setDrawBuffers, setDrawOrder, setDrawParams, setDrawRange, setDrawTextures } from "flux:gpu"
 
 // The device ceilings (max texture/target size, sampler inputs per pass,
@@ -216,8 +231,9 @@ export { captureSnapshot, readTexture } from "flux:gpu"
 /**
  * Uploads raw pixels to an immutable GPU texture and returns its id (use it
  * as `<texture src={id} />`). `data` must be exactly `width * height` pixels
- * at the declared format's size (`* 4` bytes for the default "rgba8", `* 1`
- * for "r8"); a mismatch throws. RGBA data is uploaded verbatim and composited
+ * at the declared format's size, in the view type matching the format
+ * (Uint8Array for "rgba8"/"rgba8-srgb"/"r8", Float32Array for "r32f"/
+ * "rgba32f"/"rgba16f"); a mismatch throws. RGBA data is uploaded verbatim and composited
  * as premultiplied alpha, like every texture: `decodeImage` and the readback
  * calls already deliver that, and hand-built pixels must too (`rgb * a`). For pixels you intend to mutate and
  * re-upload, use `createMutableTexture` instead. When called inside a
@@ -229,7 +245,7 @@ export { captureSnapshot, readTexture } from "flux:gpu"
  * scope.
  */
 export function createTexture(
-  data: Uint8Array,
+  data: Uint8Array | Float32Array,
   width: number,
   height: number,
   opts?: CreateOptions & SamplerOptions & TextureFormatOptions,
@@ -239,18 +255,52 @@ export function createTexture(
   return id
 }
 
+/**
+ * Uploads a cube map: six square faces of `size * size` pixels in GL order
+ * (+X, -X, +Y, -Y, +Z, -Z), each in the view type matching the declared
+ * format like `createTexture`, and returns its id. A cube map is sampled by
+ * DIRECTION from a `uniform samplerCube` in a shader (`texture(uEnv, dir)`;
+ * `textureLod` for an explicit mip level, `mipmap: true` builds the chain
+ * from the faces) - the skybox, reflection and environment-lighting
+ * primitive. `faces` may instead be an explicit mip chain - an array of
+ * six-face arrays, level 0 first, halving down to the 1x1 level (the full
+ * chain) - uploaded as given: prefiltered environment levels, with no
+ * generated chain and so no renderability requirement on the format (an
+ * "rgba16f" chain works on every device). Explicit levels imply `mipmap:
+ * true`. Sampler-only: the id binds through `textures` like any other,
+ * but `<texture src>` cannot display it and `readTexture`, `copyTexture`,
+ * `uploadTexture` and `resizeTexture` throw (it is create-once). `wrap` has
+ * no effect - cube filtering is seamless across faces. Binding a cube map
+ * to a `sampler2D`, or a 2D texture to a `samplerCube`, throws at the bind.
+ * Note GL's cube convention: each face is what a lookup in that direction
+ * returns, the cube as seen from OUTSIDE, so a face set authored the Three
+ * way (each face as seen from inside) reads mirrored on x unless each
+ * image is mirrored at load. Freed like `createTexture` (auto-free under a
+ * reactive owner, `{ autoFree: false }` or `destroyTexture` otherwise).
+ */
+export function createCubeTexture(
+  faces: (Uint8Array | Float32Array)[] | (Uint8Array | Float32Array)[][],
+  size: number,
+  opts?: CreateOptions & SamplerOptions & TextureFormatOptions,
+): gpu.TextureId {
+  let id = gpu.createCubeTexture(faces, size, opts)
+  if (opts?.autoFree !== false && getOwner()) onCleanup(() => gpu.destroyTexture(id))
+  return id
+}
+
 /**
  * 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` must hold at least `width * height` pixels at the declared format's
- * size (`* 4` bytes for the default "rgba8", `* 1` for "r8"; it may hold
- * several frames). Like `createTexture`, the texture is freed automatically
+ * size, in the view type matching the format (Uint8Array for "rgba8"/
+ * "rgba8-srgb"/"r8", Float32Array for "r32f"/"rgba32f"/"rgba16f"); it may
+ * hold several frames. Like `createTexture`, the texture is freed automatically
  * when the reactive owner is disposed (opt out with `{ autoFree: false }`);
  * created outside a reactive scope you must call `destroyTexture` (from
  * flux:gpu) yourself.
  */
 export function createMutableTexture(
-  data: Uint8Array,
+  data: Uint8Array | Float32Array,
   width: number,
   height: number,
   opts?: CreateOptions & SamplerOptions & TextureFormatOptions,
@@ -293,6 +343,10 @@ export function createMutableTexture(
  * `in vec2 vUV;` yourself to read it. One naming trap: GLSL ES reserves
  * `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
+ * 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.
  */
 export function createShaderTexture(
   fragmentSrc: string,
@@ -355,6 +409,8 @@ export function createShaderTarget(
     /** One buffer per instance slot of the pipeline (index = the
      * attributes' `slot`); pass this OR `instanceBuffer`, not both. */
     instanceBuffers?: gpu.BufferId[]
+    /** Draw the instance records in key order (see InstanceOrder). */
+    instanceOrder?: gpu.InstanceOrder
     clearColor?: [number, number, number, number]
     render?: "auto" | "manual"
     loadOp?: "clear" | "load"
@@ -395,6 +451,13 @@ export function createShaderTarget(
  * driven later with `setTargetTextures`, same precedence and coverage
  * rules.
  *
+ * `format` is the color storage: "rgba8" (default), "rgba8-srgb" (encodes
+ * what a pass writes, decodes on sample) or "rgba16f" (half float, keeps
+ * the range - an HDR view or bake; where `limits.halfFloatRenderable`,
+ * else it throws). A target of either non-default format is SAMPLER-ONLY:
+ * a pass source, never displayed by a `<texture>` leaf, read back or
+ * copied (render it through a pass into an rgba8 target for those).
+ *
  * `into` makes a sub-target: a draw target rendering into the rectangle at
  * `x`/`y` (top-left origin) of draw target `into`'s storage, so N views or
  * N shadow maps share one texture and ONE pass; the id is a draw target to
@@ -416,6 +479,7 @@ export function createDrawTarget(
   params?: gpu.ShaderParams | null,
   opts?: {
     depth?: boolean | "texture"
+    format?: "rgba8" | "rgba8-srgb" | "rgba16f"
     textures?: gpu.TextureBindings
     clearColor?: [number, number, number, number]
     render?: "auto" | "manual"
@@ -432,6 +496,41 @@ export function createDrawTarget(
   return id
 }
 
+/**
+ * Creates a cube draw target: a draw target whose output is a `size` x
+ * `size` cube map, rendered one face at a time with `renderTarget(id,
+ * face)` (0 +X, 1 -X, 2 +Y, 3 -Y, 4 +Z, 5 -Z) - the reflection-probe
+ * primitive (`@solidrt/3d`'s `scene.createReflectionProbe` drives it).
+ * Manual by contract, one depth renderbuffer for the six faces (`depth:
+ * true`), no samples or tiles; `format` rgba8, rgba8-srgb (encodes on
+ * write, decodes on sample) or rgba16f (half float, the HDR probe format,
+ * where `limits.halfFloatRenderable`); `mipmap: true` allocates the chain and
+ * `renderTarget(id, face, level)` renders one level of it (a face render
+ * without a level regenerates the chain instead) - the prefiltered
+ * environment path. The id binds to a `samplerCube`
+ * and cannot be displayed, read back, copied or resized. Each face pass
+ * inverts the front-face rule (a GL cube face is the x mirror of a 2D
+ * target's image), so render the faces through an x-mirrored projection;
+ * see flux:gpu's createCubeDrawTarget. Freed like every target.
+ */
+export function createCubeDrawTarget(
+  size: number,
+  params?: gpu.ShaderParams | null,
+  opts?: {
+    depth?: boolean
+    format?: "rgba8" | "rgba8-srgb" | "rgba16f"
+    textures?: gpu.TextureBindings
+    clearColor?: [number, number, number, number]
+    render?: "manual"
+    loadOp?: "clear" | "load"
+  } & CreateOptions &
+    SamplerOptions,
+): gpu.TextureId {
+  let id = gpu.createCubeDrawTarget(size, params, opts)
+  if (opts?.autoFree !== false && getOwner()) onCleanup(() => gpu.destroyTexture(id))
+  return id
+}
+
 /** The reactive shader description `createShaderTextureMemo` builds from.
  * Sampling (`filter`/`wrap`/`mipmap`) is creation-time state, so changing it rebuilds
  * at a fresh id, like a fragment-source or sampler-binding change. */
@@ -444,14 +543,22 @@ export type ShaderSpec = {
 } & SamplerOptions
 
 // Shallow name->value equality for params/textures records; treats undefined
-// as the empty record. A param value may be a number or a flat number array
-// (typed uniforms), so arrays compare elementwise; a texture binding may be
-// an `{ id, filter?, wrap? }` override, compared field by field.
-type RecordValue = number | number[] | gpu.TextureBinding
+// as the empty record. A param value may be a number or a flat number list
+// (typed uniforms: a number[] or a Float32Array/Float64Array), so lists
+// compare elementwise; a texture binding may be an `{ id, filter?, wrap? }`
+// override, compared field by field.
+type RecordValue = number | number[] | Float32Array | Float64Array | gpu.TextureBinding
+function isNumberList(v: RecordValue | undefined): v is number[] | Float32Array | Float64Array {
+  return Array.isArray(v) || v instanceof Float32Array || v instanceof Float64Array
+}
 function sameValue(a: RecordValue | undefined, b: RecordValue | undefined): boolean {
   if (a === b) return true
-  if (Array.isArray(a) && Array.isArray(b)) return a.length === b.length && a.every((v, i) => v === b[i])
-  if (typeof a === "object" && typeof b === "object" && !Array.isArray(a) && !Array.isArray(b)) {
+  if (isNumberList(a) && isNumberList(b)) {
+    if (a.length !== b.length) return false
+    for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false
+    return true
+  }
+  if (typeof a === "object" && typeof b === "object" && !isNumberList(a) && !isNumberList(b)) {
     return a.id === b.id && a.filter === b.filter && a.wrap === b.wrap
   }
   return false
@@ -601,6 +708,8 @@ export function createPipelineTexture(
     /** One buffer per instance slot (index = the attributes' `slot`);
      * pass this OR `instanceBuffer`, not both. */
     instanceBuffers?: gpu.BufferId[]
+    /** Draw the instance records in key order (see InstanceOrder). */
+    instanceOrder?: gpu.InstanceOrder
     topology?: gpu.Topology
     depth?: boolean
     depthWrite?: boolean

package/src/index.ts

@@ -1,7 +1,7 @@
 export * from "./renderer"
-export { setFocus, focusedNode, startTextInput, textInputActive, getFocusables, measureText, prepareText, layoutNextLine, unitInk, getBoundingBox, getBoundingBoxViewport, snapshotTexture, onPointerMove } from "./core"
+export { setFocus, focusedNode, startTextInput, textInputActive, getFocusables, measureText, prepareText, layoutNextLine, unitInk, getBoundingBox, getBoundingBoxViewport, getLayoutBox, snapshotTexture, onPointerMove } from "./core"
 export type { BoundingBox, GlobalPointerEvent, TextLine } from "./core"
-export { parseColor, mixColors, brightness, createLinearGradient, createRadialGradient } from "./color"
+export { parseColor, mixColors, withAlpha, 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"
@@ -12,7 +12,7 @@ export { gamepads } from "./gamepad"
 export type { GamepadState } from "./gamepad"
 export { capabilities } from "./capabilities"
 export type { Capabilities, WindowSizeClass } from "./capabilities"
-export { createTexture } from "./gpu"
+export { createCubeTexture, createTexture } from "./gpu"
 export type { TextureId } from "./gpu"
 export { createImage, decodeImage, encodeImage } from "./image"
 export type { DecodedImage, ImageSource } from "./image"
@@ -43,6 +43,10 @@ export type {
   TextEvent,
   TextInputHints,
   PaintProps,
+  BlendMode,
+  DrawStyle,
+  StrokeCap,
+  StrokeJoin,
   WindowProps,
   WindowShaderProps,
   ViewProps,
@@ -51,11 +55,17 @@ export type {
   LineProps,
   PathProps,
   TextProps,
+  FontFamily,
+  FontStyle,
+  FontWeight,
+  TextDecoration,
+  TextAlign,
+  TextOverflow,
   TextureProps,
   Color,
   Pct,
 } from "./types"
-export type { MeasureTextOptions, PreparedText, TextUnit } from "flux:rendertree"
+export type { MeasureTextOptions, PreparedText, TextRunRange, TextUnit } from "flux:rendertree"
 
 // A percentage value for dimensional props (e.g. transformOrigin): `pct(50)` is
 // half the element box. Keeps percentages a first-class branded value rather

package/src/pan.ts

@@ -18,7 +18,13 @@ export interface PanOptions {
    */
   axis?: PanAxis
   onPanStart?: () => void
-  /** Pointer movement since the previous event; positive dx is rightward, positive dy downward. */
+  /**
+   * Pointer movement since the previous event, in the handler node's PARENT
+   * frame (the frame its own x/y live in: window pixels under no scaling
+   * ancestor, design pixels under a designSize fit), so it applies 1:1
+   * whether the consumer moves the node itself or content inside it.
+   * Positive dx is rightward, positive dy downward.
+   */
   onPanMove?: (dx: number, dy: number) => void
   onPanEnd?: () => void
 }
@@ -35,8 +41,17 @@ export interface PanOptions {
 // cancel() is the external-cancel hook; it ends an active pan without
 // 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
+// (clientX/clientY); the deltas are measured in the node's parent frame
+// (parentX/parentY), the frame the node's own coordinates live in, so a
+// scaled ancestor (a designSize fit) is accounted for and both the drag
+// idiom (move the node) and the content idiom (scroll what is inside it)
+// apply the delta unchanged. The event carries both frames exactly, on
+// and off the node.
 export function createPan(options: PanOptions) {
-  // Down position while armed; last delivered position while active.
+  // Down position (window pixels) while armed; last delivered position
+  // (parent frame) while active.
   let origin: { x: number; y: number } | null = null
   let active: number | null = null
   let armed: number | null = null
@@ -78,7 +93,7 @@ export function createPan(options: PanOptions) {
         if (arena.steal(e.pointerId, owner)) {
           active = e.pointerId
           armed = null
-          origin = { x: e.clientX, y: e.clientY }
+          origin = { x: e.parentX, y: e.parentY }
           options.onPanStart?.()
         } else {
           // The arena is resolved against us; the drag belongs elsewhere.
@@ -87,8 +102,8 @@ export function createPan(options: PanOptions) {
         return
       }
       if (active === e.pointerId && origin) {
-        options.onPanMove?.(e.clientX - origin.x, e.clientY - origin.y)
-        origin = { x: e.clientX, y: e.clientY }
+        options.onPanMove?.(e.parentX - origin.x, e.parentY - origin.y)
+        origin = { x: e.parentX, y: e.parentY }
       }
     },
     onPointerUp: (e: PointerEvent) => {

package/src/renderer.ts

@@ -125,16 +125,18 @@ export function scanForOrphans(now: number): void {
     counts.set(node.elementType, (counts.get(node.elementType) ?? 0) + 1)
   }
   if (total === 0) return
+  // Warn only when a new element type joins the orphans, but list every type
+  // with its count so the breakdown always adds up to the total.
   let fresh = [...counts].filter(([type]) => !warnedLeakTypes.has(type))
   if (fresh.length === 0) return
   for (let [type] of fresh) warnedLeakTypes.add(type)
-  let list = fresh.map(([type, n]) => `<${type}> x${n}`).join(", ")
+  let list = [...counts].map(([type, n]) => `<${type}> x${n}`).join(", ")
   console.warn(
     `Leak sentinel: ${total} nodes are unreachable and will never be freed: ${list}. ` +
       `The usual cause is reading an element-valued prop more than once (every read ` +
       `builds a new subtree); read it once where it mounts, or resolve it with ` +
       `children(). If these nodes are intentionally kept for later mounting, ignore ` +
-      `this. Element types already reported are not reported again.`,
+      `this. The next warning comes when a new element type joins the list.`,
   )
 }
 
@@ -261,6 +263,18 @@ let renderer = createRenderer<ProxyNode>({
   insertNode: (parent: ProxyNode, node: ProxyNode, anchor?: ProxyNode): void => {
     if (!node) return
 
+    // A value without an id is not a node: a signal accessor (<For>, <Repeat>,
+    // a memo) that reached the renderer unresolved. Without this check it
+    // surfaces as an FFI type error on node.id, which names nothing. Known
+    // cause: okf/upstream/signals-flatten-array-clobbers-needs-unwrap.md.
+    if (typeof node !== "object" || node.id === undefined) {
+      let what = typeof node === "function" ? "a signal accessor" : `a ${typeof node}`
+      throw new Error(
+        `insertNode received ${what} instead of an element under <${parent?.elementType ?? "?"}>; ` +
+          `resolve the children with children() or return one root element from the component.`,
+      )
+    }
+
     // A re-inserted node is being moved, not destroyed: cancel its pending
     // destroy so the end-of-tick sweep leaves it (and its subtree) alone.
     pendingDestroy.delete(node.id)

package/src/runtime-modules.d.ts

@@ -66,8 +66,8 @@ declare module "srt:events" {
 // The running application's own surface (lattice), present in every build.
 declare module "srt:app" {
   /**
-   * Leave the current app, unconditionally: back to the launcher in a dev
-   * client, quit when standalone or at the launcher root (on Android the
+   * Leave the current app, unconditionally: back to the player in a dev
+   * client, quit when standalone or at the player root (on Android the
    * client backgrounds instead of dying). The default action of an
    * unprevented `back` event; prefer the @solidrt/core re-export.
    */
@@ -81,7 +81,7 @@ declare module "srt:dev" {
   export const canDiscover: boolean
   export const recents: string[]
   /**
-   * The dev-server address the client was launched with (so the launcher can
+   * The dev-server address the client was launched with (so the player can
    * auto-connect without on-device interaction), or null when launched without
    * one.
    */
@@ -101,7 +101,7 @@ declare module "srt:dev" {
   export function registerDebug(name: string, fn: (args?: any) => unknown): void
 }
 
-// Installed-app management (lattice), the launcher's surface over the client's
+// 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" {
@@ -166,7 +166,7 @@ declare module "srt:apps" {
   export function info(id: string): AppInfo
   /**
    * Boot the app's installed current version, replacing the running app (the
-   * launcher). Throws when the app is not installed. Custom fonts of the
+   * player). Throws when the app is not installed. Custom fonts of the
    * launched app register at client startup only, not mid-session.
    */
   export function launch(id: string): void
@@ -182,8 +182,8 @@ declare module "srt:apps" {
    */
   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
+   * Build identity of this runtime, for the player's settings screen. Not
+   * app-specific, but surfaced here since the player 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").

package/src/svg.ts

@@ -6,6 +6,7 @@
 
 import { parseSvg as fluxParseSvg } from "flux:svg"
 import { parseColor, type Gradient } from "./color"
+import type { StrokeCap, StrokeJoin } from "./types"
 
 /**
  * Tags an inline SVG source, returning it unchanged. Documents small enough to
@@ -27,8 +28,8 @@ export type SvgDraw = {
   drawStyle: "fill" | "stroke"
   fillRule?: "nonzero" | "evenodd"
   strokeWidth?: number
-  strokeCap?: "butt" | "round" | "square"
-  strokeJoin?: "miter" | "round" | "bevel"
+  strokeCap?: StrokeCap
+  strokeJoin?: StrokeJoin
 }
 
 /** A parsed document: intrinsic size (viewBox/width-height) plus the flat draw list. */

package/src/text-input.ts

@@ -214,6 +214,9 @@ export type EditorLine = {
 /** The caret's box in content coordinates (before scroll). */
 export type CaretRect = { x: number; y: number; height: number }
 
+/** One line's slice of a selection highlight, in content coordinates (before scroll). */
+export type SelectionRect = { x: number; y: number; width: number; height: number }
+
 export type TextEditorLayout = {
   lines(): EditorLine[]
   caret(): CaretRect
@@ -221,6 +224,8 @@ export type TextEditorLayout = {
   caretLine(): number
   /** The caret position (grapheme boundary) on line `line` nearest to content x. */
   offsetAtX(line: number, x: number): number
+  /** Highlight boxes for the anchor..focus range, one per touched line; empty when collapsed. */
+  selectionRects(anchor: number, focus: number): SelectionRect[]
   /** Index of the line at content y (clamped to the first/last line). */
   lineAtY(y: number): number
   /** The caret position one grapheme left/right of `offset`; a break sequence is one step. For createTextBuffer's `step`. */
@@ -322,18 +327,22 @@ export function createTextEditorLayout(
   }
   let caretLine = createMemo(() => lineOf(input().caret))
 
-  // The caret sits at the last stop at or before its offset (an offset inside
-  // a grapheme, e.g. from a controlled value, snaps back).
-  let caret = createMemo((): CaretRect => {
-    let offset = input().caret
-    let index = caretLine()
-    let line = lines()[index]!
+  // The x of the last stop at or before `offset` on line `index` (an offset
+  // inside a grapheme, e.g. from a controlled value, snaps back).
+  let xAt = (index: number, offset: number): number => {
     let x = 0
     for (let stop of lineStops(index)) {
       if (stop.offset > offset) break
       x = stop.x
     }
-    return { x, y: line.y, height: line.height }
+    return x
+  }
+
+  let caret = createMemo((): CaretRect => {
+    let offset = input().caret
+    let index = caretLine()
+    let line = lines()[index]!
+    return { x: xAt(index, offset), y: line.y, height: line.height }
   })
 
   // Only positions that show on this line are candidates: a boundary offset
@@ -352,6 +361,32 @@ export function createTextEditorLayout(
     return best
   }
 
+  // One box per line the range touches, offsets snapped to stops like the
+  // caret. A line the selection continues past (every one but the last)
+  // highlights to its ink end plus a space width, so the selected break - a
+  // newline, or the wrap the range crosses - is visible, and a selected empty
+  // line shows as that sliver alone. The last line ends at the focus stop; a
+  // range ending on a wrap boundary owns a zero-width box there (the boundary
+  // offset displays on the next line) and drops it.
+  let selectionRects = (anchor: number, focus: number): SelectionRect[] => {
+    let start = Math.min(anchor, focus)
+    let end = Math.max(anchor, focus)
+    if (start >= end) return []
+    let ls = lines()
+    let first = lineOf(start)
+    let last = lineOf(end)
+    let breakWidth = measureText(" ", input().font).width
+    let out: SelectionRect[] = []
+    for (let i = first; i <= last; i++) {
+      let line = ls[i]!
+      let x = i === first ? xAt(i, start) : 0
+      let width = i === last ? xAt(i, end) - x : Math.max(line.width - x, 0) + breakWidth
+      if (width <= 0) continue
+      out.push({ x, y: line.y, width, height: line.height })
+    }
+    return out
+  }
+
   let lineAtY = (y: number): number => {
     let ls = lines()
     let index = 0
@@ -399,7 +434,7 @@ export function createTextEditorLayout(
     setScrollY(follow(scrollY(), c.y, c.height, vh, contentHeight))
   })
 
-  return { lines, caret, caretLine, offsetAtX, lineAtY, step, scrollX, scrollY }
+  return { lines, caret, caretLine, offsetAtX, selectionRects, lineAtY, step, scrollX, scrollY }
 }
 
 // Wrap units wider than `width` (through their glued pieces) split into one