@solidrt/core 0.0.11 → 0.0.14

package/AGENTS.md

@@ -29,7 +29,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.14); bun resolves them from peerDependencies.
+2.0.0-beta.15); bun resolves them from peerDependencies.
 
 ## Element model (the parts that are easy to get wrong)
 
@@ -63,15 +63,37 @@ Peer deps @solidjs/signals and @solidjs/universal must match (currently
   directly-positioned, often-animating elements (e.g. hundreds of balls), `d-`
   skips the per-element layout that plain elements would incur.
 
+- Layout-affecting vs not (this matters for per-frame work). Props fall in three
+  buckets, split by where they take effect:
+  - `LayoutProps` - width/height, min/max sizes, margin, padding, `position` and
+    its `top`/`right`/`bottom`/`left` offsets, flex*/gap/display, grid*,
+    aspectRatio, overflow. Changing ANY of these triggers a Taffy reflow of the
+    node and its subtree.
+  - `TransformProps` - x, y, scale/scaleX/scaleY, rotate/rotateX/rotateY,
+    perspective, cx/cy, scrollX/scrollY. Applied at paint/composite; NO reflow.
+  - `PaintProps` - color, drawStyle, strokeWidth, blendMode, radius. Also no
+    reflow.
+  So to MOVE or animate an element - dragging, transitions, per-frame motion -
+  translate it with the transform `x`/`y` (or scale/rotate), never by animating
+  `left`/`top`/`margin`/`width`. Common trap: `left`/`top` read like "position"
+  but they are LAYOUT offsets (for `position:absolute`), so driving them every
+  frame reflows the tree. Anchor the element once with layout (e.g.
+  `position:absolute` at `left:0,top:0`, or just let normal flow place it) and
+  then translate it with `x`/`y`.
+
 - 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 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.14",
   "license": "MIT",
   "author": "Antoine van Wel",
   "type": "module",
@@ -9,8 +9,11 @@
     ".": "./src/index.ts",
     "./camera": "./src/camera.ts",
     "./gpu": "./src/gpu.ts",
+    "./image": "./src/image.ts",
     "./microphone": "./src/microphone.ts",
-    "./speech": "./src/speech.ts",
+    "./scroll": "./src/scroll.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,11 +26,11 @@
     "colord": "^2.9.3"
   },
   "devDependencies": {
-    "@solidrt/flux-types": "0.0.11"
+    "@solidrt/flux-types": "0.0.0"
   },
   "peerDependencies": {
-    "@solidjs/signals": "2.0.0-beta.14",
-    "@solidjs/universal": "2.0.0-beta.14",
-    "solid-js": "2.0.0-beta.14"
+    "@solidjs/signals": "2.0.0-beta.15",
+    "@solidjs/universal": "2.0.0-beta.15",
+    "solid-js": "2.0.0-beta.15"
   }
 }

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,59 @@
-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"
 
+// The imperative destroy, surfaced here for the manual-cleanup path documented
+// on the create* helpers (textures made outside a reactive scope, e.g. after an
+// await, are not auto-freed). Re-exported so callers that depend on
+// @solidrt/core -- like @solidrt/components -- can free textures without
+// importing flux directly.
+export { destroyTexture } 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)
-}
-
-// 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 +61,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,57 @@ export type {
   TextProps,
   TextureProps,
   AudioProps,
-  MeasureTextOptions,
   Color,
 } from "./types"
+export type { MeasureTextOptions } from "flux:rendertree"
+
+// --- Authoring-surface re-exports -------------------------------------------
+// A SolidRT app is built from three substrate packages: @solidjs/signals
+// (reactivity), solid-js (control-flow components), and @solidjs/universal (the
+// renderer factory, surfaced via ./renderer). Forwarding the app-facing pieces
+// here means an app imports its whole vocabulary from "@solidrt/core" instead of
+// having to know which substrate package each symbol lives in. These are already
+// peerDependencies, so this adds no new dependency. Curated on purpose - do not
+// `export *` from solid-js, which would leak DOM/hydration-only helpers that are
+// meaningless on the flux runtime.
+
+// Reactivity (from @solidjs/signals).
+export {
+  createSignal,
+  createMemo,
+  createEffect,
+  createRenderEffect,
+  createRoot,
+  createStore,
+  reconcile,
+  mapArray,
+  repeat,
+  untrack,
+  onCleanup,
+  onSettled,
+} from "@solidjs/signals"
+export type { Accessor, Setter, Signal, Store, StoreSetter } from "@solidjs/signals"
+
+// Control flow, components, and context (from solid-js).
+export {
+  For,
+  Show,
+  Switch,
+  Match,
+  Repeat,
+  Loading,
+  Errored,
+  Reveal,
+  lazy,
+  createUniqueId,
+  createContext,
+  useContext,
+  children,
+} from "solid-js"
+export type {
+  Component,
+  ParentComponent,
+  FlowComponent,
+  VoidComponent,
+  ComponentProps,
+} from "solid-js"