@solidrt/core 0.0.10 → 0.0.13

package/AGENTS.md

@@ -0,0 +1,112 @@
+# @solidrt/core - agent notes
+
+Dense, self-contained facts for writing a SolidRT app.
+Full docs live in docs/ (and the website). When this conflicts with prose docs,
+trust this file and the types in src/types.d.ts and jsx-runtime.d.ts.
+
+SolidRT is a custom SolidJS renderer: it paints through a Rust runtime, not the
+DOM. There is no HTML, no CSS cascade, no `className`.
+
+## Setup
+
+```sh
+bun add @solidrt/core        # the renderer
+bun add -d @solidrt/cli      # the `srt` tool (see its AGENTS.md)
+```
+
+`@solidrt/components` is a separate, optional package of higher-level components
+(see its own AGENTS.md); core primitives alone are enough to build a full app.
+
+tsconfig.json - the two load-bearing lines are jsx + jsxImportSource:
+
+```json
+{ "compilerOptions": {
+  "jsx": "preserve",
+  "jsxImportSource": "@solidrt/core",
+  "moduleResolution": "bundler",
+  "strict": true
+} }
+```
+
+Peer deps @solidjs/signals and @solidjs/universal must match (currently
+2.0.0-beta.14); bun resolves them from peerDependencies.
+
+## Element model (the parts that are easy to get wrong)
+
+- `render(() => <App />)`. The returned root MUST be a `<window>` or it throws.
+  Call render once, at the top level.
+
+- Two kinds of element:
+  - Containers - `<window>`, `<view>`. Do layout + transform + pointer events.
+    THEY DO NOT PAINT. A `<view>` has no background/fill prop.
+  - Draw primitives - `<rect>`, `<oval>`, `<path>`, `<texture>`, `<text>`.
+    These paint. To give a view a background, render a draw primitive (e.g.
+    `<d-rect>`) as a child, behind the content.
+
+- Paint color is the `color` prop (a CSS color string). There is NO `fill`,
+  `stroke`, or `background` prop (some older doc examples are wrong about this).
+  Outlines: `drawStyle="stroke"` (or "stroke-and-fill") plus `strokeWidth`.
+  Corner radius on draw primitives: `radius` (number or [tl, tr, br, bl]).
+
+- Registered JSX intrinsics: `window`, `view`, `text`, `rect`, `oval`, `path`,
+  `texture`, `audio`, plus the `d-` variants `d-view`, `d-rect`, `d-oval`,
+  `d-path`, `d-texture`, `d-text`. NOTE: `<line>` has a LineProps type but is
+  NOT a registered intrinsic - it will not typecheck.
+
+- Plain vs `d-` variant (the `d-` prefix means "detached" - detached from the
+  layout engine, Taffy): a plain element (e.g. `rect`) is `RectProps &
+  LayoutProps`, so it draws AND is laid out by Taffy. The detached variant
+  (`d-rect`) is `RectProps` only - it draws but is NOT in the layout pass; you
+  place it yourself with `x`/`y` (omit them and it fills the parent, which is
+  how backgrounds work). Reach for `d-` whenever you want explicit coordinate
+  positioning instead of layout. It is also a performance lever: for many
+  directly-positioned, often-animating elements (e.g. hundreds of balls), `d-`
+  skips the per-element layout that plain elements would incur.
+
+- Events: there is NO `onClick`/`onPress`. A "button" is a `<view>`/`<rect>`
+  with `onPointerDown`. Handlers: onPointerDown/Up/Move/Enter/Leave, onWheel,
+  onKeyDown/Up, onTextInput, onFocus/onBlur. Text entry: focus a node with an
+  `onTextInput` handler (setFocus activates the on-screen keyboard).
+
+- 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)`
+  -> `<texture src={id} />`.
+
+## Minimal app, core primitives only (verified to render)
+
+```tsx
+import { render } from "@solidrt/core"
+import { createSignal } from "@solidjs/signals"
+
+function App() {
+  let [count, setCount] = createSignal(0)
+  return (
+    <window flexDirection="column" alignItems="center" justifyContent="center" gap={24}>
+      <d-rect color="#0b0f17" />                  {/* window background */}
+      <text color="#1f6feb" fontSize={48} fontWeight={800}>{count()}</text>
+      <view onPointerDown={() => setCount((c) => c + 1)}
+        padding={16} alignItems="center" justifyContent="center">
+        <d-rect color="#1f6feb" radius={12} />    {/* button background, underlays the label */}
+        <text color="#ffffff" fontSize={20}>increment</text>
+      </view>
+    </window>
+  )
+}
+
+render(() => <App />)
+```
+
+Note the two `<d-rect>` underlays: a `<view>`/`<window>` does not paint, so a
+background is a draw-primitive child placed behind the content.
+
+To run and verify (incl. headless), see @solidrt/cli (its AGENTS.md). For
+higher-level components, see @solidrt/components (its AGENTS.md).

package/README.md

@@ -4,6 +4,8 @@ A low-level toolkit for creating cross-platform applications.
 
 _SolidRT is in pre-alpha stage. Anything can and will be changed._
 
+> LLM agents: see [AGENTS.md](./AGENTS.md) for a dense, self-contained quickstart.
+
 ## Getting started
 
 Prerequisites: [bun](https://bun.sh) (only required for development; not needed to run built apps).

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.10",
+  "version": "0.0.13",
   "license": "MIT",
   "author": "Antoine van Wel",
   "type": "module",
@@ -9,24 +9,27 @@
     ".": "./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"
   },
   "files": [
     "src/",
     "jsx-runtime.d.ts",
-    "LICENSE"
+    "AGENTS.md"
   ],
   "dependencies": {
     "colord": "^2.9.3"
   },
   "devDependencies": {
-    "@solidrt/flux-types": "0.0.10"
+    "@solidrt/flux-types": "0.0.13"
   },
   "peerDependencies": {
     "@solidjs/signals": "2.0.0-beta.14",
-    "@solidjs/universal": "2.0.0-beta.14"
+    "@solidjs/universal": "2.0.0-beta.14",
+    "solid-js": "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,23 +1,60 @@
-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)
+  let id = gpu.createMutableTexture(data, width, height)
+  if (getOwner()) onCleanup(() => gpu.destroyTexture(id))
+  return id
 }
 
-export function uploadTexture(textureId: number, offset: number = 0): void {
-  gpu.uploadTexture(textureId, offset)
+/**
+ * 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,
+  height: number,
+  params?: Record<string, number>,
+  textures?: Record<string, number>,
+): number {
+  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 } 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"