@solidrt/core 0.0.52 → 0.0.53

package/AGENTS.md

@@ -111,7 +111,7 @@ tsconfig.json - the two load-bearing lines are jsx + jsxImportSource:
 ```
 
 Peer deps @solidjs/signals and @solidjs/universal must match (currently
-2.0.0-rc.1); bun resolves them from peerDependencies.
+2.0.0-rc.3); bun resolves them from peerDependencies.
 
 ## Element model (the parts that are easy to get wrong)
 
@@ -147,6 +147,13 @@ Peer deps @solidjs/signals and @solidjs/universal must match (currently
   endpoint props and spans its layout box corner to corner. `points` (a flat
   `[x0, y0, x1, y1, ...]` array, plus `closed`) turns either form into a
   polyline and wins over the endpoints while set.
+- Nesting rule: d-* elements go under anything; laid-out elements only under
+  laid-out parents. A detached subtree is entirely detached, and the insert
+  throws otherwise (`<view> cannot be a child of <d-view>: ...`). So a
+  component that renders any laid-out element is a LAYOUT component and
+  cannot be used inside a d-* subtree, and a component meant for d-* trees
+  renders d-* only. Say which in the component's doc comment: the types
+  cannot tell (every JSX expression is the same `Element`).
 
 - Plain vs `d-` variant (the `d-` prefix means "detached" - detached from the
   layout engine, Taffy): a plain element (e.g. `rect`) is `RectProps &
@@ -267,6 +274,11 @@ Peer deps @solidjs/signals and @solidjs/universal must match (currently
   `children()` helper (re-exported from @solidrt/core) and probe the resolved
   memo - never `typeof props.children` on the raw prop.
 
+- Keep the simulation out of the renderer: app or game state as plain
+  TypeScript with no @solidrt imports, with the JSX reading it and the
+  per-frame hook doing one state step plus a handful of property writes.
+  That shape runs under bun with no window (tests, audits, replaying a whole
+  session in seconds) and it is what keeps per-frame work cheap.
 - Animation is target-shaped first: declare `transition` on the element and
   write targets, and the runtime animates natively with no per-frame JS.
   Reach for per-frame work only for genuinely procedural motion:
@@ -294,7 +306,10 @@ Peer deps @solidjs/signals and @solidjs/universal must match (currently
 
 - Device/GPU access via subpath imports: @solidrt/core/camera, /microphone,
   /speech, /gpu. Image flow: `decodeImage(bytes)` ->
-  `createTexture(data,w,h)` -> `<texture src={id} />`.
+  `createTexture(data,w,h)` -> `<texture src={id} />`. Pixels are
+  premultiplied alpha from decode onward (the GPU contract); `decodeImage(bytes,
+  { alpha: "straight" })` keeps the file's color under transparent pixels for
+  CPU work, and `encodeImage` converts back to straight for the file.
 
 ## Minimal app, core primitives only (verified to render)
 

package/docs/reference/gpu.md

@@ -167,7 +167,10 @@ Three facts hold for every texture and target:
   a top-left origin.
 - **Color is premultiplied alpha.** A target's RGB is already multiplied by
   its A: write `vec4(rgb * a, a)`. `vec4(rgb, a)` composites as opaque.
-  `clearColor` is premultiplied too.
+  `clearColor` is premultiplied too, and so are uploaded pixels:
+  `decodeImage` premultiplies at the codec boundary (image files store
+  straight alpha) and `encodeImage` converts back, so pixels inside the app
+  are premultiplied everywhere.
 - **Values are non-linear RGBA8** (or `"r8"` for single-channel data), with
   no color-space conversion anywhere. Filtering and blending operate on the
   stored values.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidrt/core",
-  "version": "0.0.52",
+  "version": "0.0.53",
   "license": "MIT",
   "funding": "https://github.com/sponsors/wellawaretech",
   "author": "Antoine van Wel",
@@ -29,11 +29,11 @@
     "AGENTS.md"
   ],
   "devDependencies": {
-    "@solidrt/flux-types": "0.0.52"
+    "@solidrt/flux-types": "0.0.53"
   },
   "peerDependencies": {
-    "@solidjs/signals": "2.0.0-rc.1",
-    "@solidjs/universal": "2.0.0-rc.1",
-    "solid-js": "2.0.0-rc.1"
+    "@solidjs/signals": "2.0.0-rc.3",
+    "@solidjs/universal": "2.0.0-rc.3",
+    "solid-js": "2.0.0-rc.3"
   }
 }

package/src/gpu.ts

@@ -42,7 +42,10 @@
 //   multiplied by its A - `vec4(rgb * a, a)`, not `vec4(rgb, a)`, which
 //   composites as opaque. That is what Impeller composites and what
 //   `<texture blendMode>` blends; `clearColor` is premultiplied too, so the
-//   default transparent black needs no thought.
+//   default transparent black needs no thought. Uploaded pixels follow the
+//   same rule: `decodeImage` premultiplies at the codec boundary (image
+//   files store straight alpha) and `encodeImage` undoes it, so pixels
+//   inside the app are premultiplied everywhere.
 // - Values are non-linear RGBA8, with no color-space concept. Every texture
 //   and target holds 8-bit RGBA UNORM exactly as written; nothing converts to
 //   or from linear light. `filter: "linear"` averages and the `blend` modes
@@ -110,6 +113,7 @@ export {
   endBufferWrite,
   resizeTexture,
   setTargetParams,
+  setTargetRect,
   setTargetSize,
   setTargetTextures,
   uploadTexture,
@@ -213,7 +217,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. For pixels you intend to mutate and
+ * for "r8"); 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
  * reactive scope the texture is freed automatically once that owner is
  * disposed; when called outside one (e.g. after an `await`, where the owner
@@ -389,6 +395,13 @@ export function createShaderTarget(
  * driven later with `setTargetTextures`, same precedence and coverage
  * rules.
  *
+ * `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
+ * every verb but not a texture (display and sample the parent, with
+ * `srcX`/`srcY` on the leaf), and `setTargetRect` moves it. Auto-free works
+ * the same way; destroying the parent takes its tiles.
+ *
  * The render contract is unchanged: the list is input data, so an ordinary
  * (`render: "auto"`) draw target re-renders exactly when its entries or
  * their inputs change - a static scene costs zero passes, and one render is
@@ -408,6 +421,9 @@ export function createDrawTarget(
     render?: "auto" | "manual"
     loadOp?: "clear" | "load"
     samples?: 1 | 2 | 4 | 8
+    into?: gpu.TextureId
+    x?: number
+    y?: number
   } & CreateOptions &
     SamplerOptions,
 ): gpu.TextureId {

package/src/renderer.ts

@@ -266,6 +266,14 @@ let renderer = createRenderer<ProxyNode>({
     pendingDestroy.delete(node.id)
 
     if (parent) {
+      // console.debug("[srt] insertNode", parent.id, node.id, anchor?.id ?? "")
+
+      // Native first: the tree refuses a laid-out element under a d-* parent
+      // (it throws, naming both tags), and the mirror must not record a child
+      // the tree does not have.
+      if (anchor) tree.insertNode(parent.id, node.id, anchor.id)
+      else tree.insertNode(parent.id, node.id)
+
       node.parent = parent
 
       if (!anchor) {
@@ -278,11 +286,6 @@ let renderer = createRenderer<ProxyNode>({
           parent.children.splice(index, 0, node)
         }
       }
-
-      // console.debug("[srt] insertNode", parent.id, node.id, anchor?.id ?? "")
-
-      if (anchor) tree.insertNode(parent.id, node.id, anchor.id)
-      else tree.insertNode(parent.id, node.id)
     }
   },