@solidrt/cli 0.0.40 → 0.0.42

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidrt/cli",
-  "version": "0.0.40",
+  "version": "0.0.42",
   "license": "MIT",
   "author": "Antoine van Wel",
   "type": "module",
@@ -28,17 +28,17 @@
     "zod": "^4.4.3"
   },
   "optionalDependencies": {
-    "@solidrt/darwin-arm64": "0.0.40",
-    "@solidrt/linux-arm64-gnu": "0.0.40",
-    "@solidrt/linux-x64-gnu": "0.0.40",
-    "@solidrt/win32-x64-msvc": "0.0.40"
+    "@solidrt/darwin-arm64": "0.0.42",
+    "@solidrt/linux-arm64-gnu": "0.0.42",
+    "@solidrt/linux-x64-gnu": "0.0.42",
+    "@solidrt/win32-x64-msvc": "0.0.42"
   },
   "peerDependencies": {
-    "@solidrt/core": "0.0.40",
+    "@solidrt/core": "0.0.42",
     "typescript": "^7"
   },
   "devDependencies": {
-    "@solidrt/flux-types": "0.0.40",
+    "@solidrt/flux-types": "0.0.42",
     "@types/babel__core": "^7.20.5",
     "@types/bun": "latest"
   }

package/scaffold/AGENTS.md

@@ -140,9 +140,11 @@ nearly free. That holds on desktop and on current mobile hardware; "Where GPU
 work stops being free" below is where it does not. Rules, in order of leverage:
 
 1. Continuous effects (snow, particles, animated backgrounds) belong in a
-   fragment shader: createShader (from @solidrt/core/gpu) + `<texture
-   params={{ iTime }}>`. The whole effect then costs one setProperty per
-   frame - the iTime write - regardless of visual complexity. Shader output
+   fragment shader: createShaderTexture (from @solidrt/core/gpu) + `<texture
+   params={{ uTime }}>` (the shader declares `uniform float uTime;` itself -
+   the preamble declares only what the runtime fills). The whole effect then
+   costs one setProperty per frame - the uTime write - regardless of visual
+   complexity. Shader output
    must be premultiplied alpha (white flakes are `vec4(vec3(a), a)`);
    straight alpha (`vec4(1,1,1,a)`) composites as opaque white. A source that
    starts with `#version 300 es` is compiled exactly as written - no preamble
@@ -155,15 +157,18 @@ work stops being free" below is where it does not. Rules, in order of leverage:
    `vec3 iResolution` needs no splitting into scalars. To combine several
    GPU passes, stack `<texture>` elements and set `blendMode` (e.g. a base
    pass plus an additive `blendMode="plus"` pass) rather than writing a
-   compositing shader. Within one pipeline draw, createPipeline's
+   compositing shader. Within one pipeline draw, createPipelineTexture's
    `blend: "add"` accumulates overlapping geometry additively (soft point
    splats, glow) - pair it with `depthWrite: false` when depth-tested;
-   neither option implies the other. Sampling is a create-time option on
-   every texture: `{ filter: "nearest" }` for hard-pixel upscaling (render a
-   small target, display it big - the retro/pixel-art path) and
-   `{ wrap: "repeat" }` to tile outside 0..1 in shaders; the defaults are
-   linear and clamp, and the choice applies both on screen and to shaders
-   sampling the texture.
+   neither option implies the other. A pipeline's own vertex stage writes
+   into a y-down clip space: `gl_Position` y = -1 is the top row of the
+   target and +1 the bottom, so camera-up geometry must negate y (or fold
+   the flip into its projection) or it draws upside down. Sampling is a
+   create-time option on every texture: `{ filter: "nearest" }` for
+   hard-pixel upscaling (render a small target, display it big - the
+   retro/pixel-art path) and `{ wrap: "repeat" }` to tile outside 0..1 in
+   shaders; the defaults are linear and clamp, and the choice applies both
+   on screen and to shaders sampling the texture.
 2. Reduce setProperty calls wherever possible: one path string rebuilt per
    frame beats N elements with N animated positions; a shader beats the path
    string. get_stats' setPropsPerFrame is the counter to watch.
@@ -345,8 +350,10 @@ flag: `"args": [..., "mcp", "--port", "N"]`.
 - console.log + get_logs is your primary probe into runtime state. For state
   you will want repeatedly (a pose, a mode, a counter), bind a debug key that
   logs it and read it back via get_logs.
-- Key events are delivered ONLY to the focused node (no bubbling): call
-  setFocus(node.id) from the window's ref or onKeyDown never fires. `key` and
+- Key events start at the focused node and bubble to the window root; with
+  nothing focused they go to the window root alone. So a debug key bound via
+  `<window onKeyDown>` always fires (unless a focused component consumes the
+  key with stopPropagation, as TextInput does for editing keys). `key` and
   `code` are W3C KeyboardEvent values, so arrow keys arrive as "ArrowLeft"/
   "ArrowRight"/"ArrowUp"/"ArrowDown" (not "Left"), alongside "Enter",
   "Escape", "a".

package/scaffold/package.json

@@ -9,12 +9,12 @@
     "android": "srt client --android"
   },
   "dependencies": {
-    "@solidrt/core": "0.0.40",
-    "@solidrt/components": "0.0.40"
+    "@solidrt/core": "0.0.42",
+    "@solidrt/components": "0.0.42"
   },
   "devDependencies": {
-    "@solidrt/cli": "0.0.40",
-    "@solidrt/flux-types": "0.0.40",
+    "@solidrt/cli": "0.0.42",
+    "@solidrt/flux-types": "0.0.42",
     "typescript": "^7"
   }
 }

package/src/commands/mcp.ts

@@ -103,7 +103,7 @@ let TOOLS: {
     name: "get_stats",
     readOnly: true,
     description:
-      "Performance statistics from a running app client: fps, CPU%, memory, smoothed JS/layout/paint/hover frame times (ms), setProperty writes per frame, demand-gate reuse/skip counts per second, and live texture count. Layout-activity counters cover the last full rebuild, raw: nodes (live node count, mounted AND detached), mountedNodes/orphanNodes (live at query time: nodes reachable from the root vs not - orphans growing at a stable tree shape mean an unmount leak; absent when no engine is running), measureCalls (text measures; mostly cache hits, cheap), paraShapes (paragraphs actually shaped; the expensive signal - high layoutMs with near-zero paraShapes means the cost is not text shaping), dirtiedNodes (layout caches cleared by property writes since the previous rebuild; how much of the tree a write burst invalidated), cacheGets/cacheHits (layout-cache lookups during the rebuild; a hit on a container skips its whole subtree, so a healthy incremental rebuild shows a near-100% hit rate - a low rate at scale means the layout cache is being defeated). GPU-side health, read live at query time (absent when no engine is running): rasterQueue (raster commands sent but not yet executed; stuck nonzero means the raster thread is backlogged - the state where fps and frameMs go blind because no frames complete), idleTicks (cumulative idle frame signals emitted while the GPU had nothing queued; idleTicks racing while rasterQueue sits nonzero would mean the idle-tick gate is broken), fenceTimeouts (cumulative present-fence waits that expired instead of signaling - each one is a frame where the GPU was over budget for 100ms+ and one-frame-in-flight pacing was lost; zero on a healthy machine, climbing means the GPU is the bottleneck right now).",
+      "Performance statistics from a running app client: fps, CPU%, memory, smoothed JS/layout/paint/hover frame times (ms), setProperty writes per frame, demand-gate reuse/skip counts per second, and live texture count. Layout-activity counters cover the last full rebuild, raw: nodes (live node count, mounted AND detached), mountedNodes/orphanNodes (live at query time: nodes reachable from the root vs not - orphans growing at a stable tree shape mean an unmount leak; absent when no engine is running), measureCalls (text measures; mostly cache hits, cheap), paraShapes (paragraphs actually shaped; the expensive signal - high layoutMs with near-zero paraShapes means the cost is not text shaping), dirtiedNodes (layout caches cleared by property writes since the previous rebuild; how much of the tree a write burst invalidated), cacheGets/cacheHits (layout-cache lookups during the rebuild; a hit on a container skips its whole subtree, so a healthy incremental rebuild shows a near-100% hit rate - a low rate at scale means the layout cache is being defeated). GPU-side health, read live at query time (absent when no engine is running): rasterQueue (raster commands sent but not yet executed; stuck nonzero means the raster thread is backlogged - the state where fps and frameMs go blind because no frames complete), idleTicks (cumulative idle frame signals emitted while the GPU had nothing queued; idleTicks racing while rasterQueue sits nonzero would mean the idle-tick gate is broken), fenceTimeouts (cumulative present-fence waits that expired instead of signaling - each one is a frame where the GPU was over budget for 100ms+ and one-frame-in-flight pacing was lost; zero on a healthy machine, climbing means the GPU is the bottleneck right now), gpuPasses/gpuPassMs (cumulative shader/pipeline target renders on the raster thread and the wall time they took in whole ms - diff two queries to get a rate; passes racing far ahead of frames means redundant target re-renders, the failure mode where fps and frameMs look healthy while the raster thread drowns; the ms figure is raster-thread occupancy issuing the passes, not GPU-side duration), rasterCmdMs (cumulative wall time in whole ms the raster thread spent executing non-frame commands - texture uploads, readbacks, offscreen rasterizations, shader compiles, param writes and the target re-renders they trigger; the work frameMs never sees, so rasterCmdMs growing much faster than frames are presented means the raster thread is drowning in side work even if every counter above looks calm).",
     inputSchema: { client: CLIENT_ARG },
   },
   {
@@ -151,14 +151,14 @@ let TOOLS: {
     name: "get_gpu_resources",
     readOnly: true,
     description:
-      "Inventory of a running app client's GPU resources: textures (id, size, whether a shader renders into it), vertex buffers (id, byteLength), and shader/pipeline targets (output textureId, kind, bufferId, topology, drawCount, depth, attribute layout, bound sampler texture ids, current uniform values - the most recent writes, which the next frame or readback draws with). Use it when the render tree is just a <texture> leaf and the interesting state lives behind it; follow up with get_texture or get_buffer to see contents.",
+      "Inventory of a running app client's GPU resources: textures (id, size, whether a shader renders into it), vertex buffers (id, byteLength), and shader/pipeline targets (output textureId, kind, bufferId, topology, drawCount plus firstVertex/instanceCount when off their 0/1 defaults, depth, attribute layout, bound sampler texture ids, current uniform values - the most recent writes, which the next frame or readback draws with - plus passes/passMs, cumulative per-target render count and raster-thread wall time in whole ms: when get_stats shows gpuPasses running hot, these attribute the cost to the specific target). Use it when the render tree is just a <texture> leaf and the interesting state lives behind it; follow up with get_texture or get_buffer to see contents.",
     inputSchema: { client: CLIENT_ARG },
   },
   {
     name: "get_texture",
     readOnly: true,
     description:
-      "Read back any GPU texture from a running app client as a PNG, by texture id (from get_gpu_resources, or the id returned by createImage/createShader/createPipeline in app code). Works on sampled textures (atlases, data textures) and shader/pipeline render targets alike, without needing a frame: a render target reads as its current output, with any pending params, geometry or sampled-input changes resolved first. Pass x/y/width/height to crop, e.g. one tile of an atlas.",
+      "Read back any GPU texture from a running app client as a PNG, by texture id (from get_gpu_resources, or the id returned by createImage/createShaderTexture/createPipelineTexture in app code). Works on sampled textures (atlases, data textures) and shader/pipeline render targets alike, without needing a frame: a render target reads as its current output, with any pending params, geometry or sampled-input changes resolved first. Pass x/y/width/height to crop, e.g. one tile of an atlas.",
     inputSchema: {
       id: z.number().int().describe("Texture id, from get_gpu_resources"),
       x: z.number().int().describe("Crop rect left edge in texture pixels (requires y, width, height)").optional(),