@solidrt/cli 0.0.52 → 0.0.53

package/dist/demos/components/package.json

@@ -0,0 +1,9 @@
+{
+  "name": "solidrt-components-demos",
+  "type": "module",
+  "private": true,
+  "solidrt": {
+    "appId": "dev.solidrt.demos.components",
+    "displayName": "Gallery"
+  }
+}

package/dist/server.js

@@ -3842,7 +3842,7 @@ async function bindFirstFree() {
     candidates.push(p);
   let last = null;
   for (let port of candidates) {
-    if (await probe("127.0.0.1", port, { timeoutMs: 200 }) !== "closed")
+    if (await probe("127.0.0.1", port, { timeoutMs: 200 }) === "open")
       continue;
     try {
       return bind(port);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidrt/cli",
-  "version": "0.0.52",
+  "version": "0.0.53",
   "license": "MIT",
   "funding": "https://github.com/sponsors/wellawaretech",
   "author": "Antoine van Wel",
@@ -24,22 +24,22 @@
     "@jridgewell/remapping": "^2.3.0",
     "@jridgewell/trace-mapping": "^0.3.25",
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "babel-preset-solid": "2.0.0-rc.1",
+    "@solidjs/babel-plugin": "2.0.0-rc.3",
     "bonjour-service": "^1.4.0",
     "qrcode-generator": "^2.0.4",
     "zod": "^4.4.3"
   },
   "optionalDependencies": {
-    "@solidrt/darwin-arm64": "0.0.52",
-    "@solidrt/linux-arm64-gnu": "0.0.52",
-    "@solidrt/linux-x64-gnu": "0.0.52",
-    "@solidrt/win32-x64-msvc": "0.0.52"
+    "@solidrt/darwin-arm64": "0.0.53",
+    "@solidrt/linux-arm64-gnu": "0.0.53",
+    "@solidrt/linux-x64-gnu": "0.0.53",
+    "@solidrt/win32-x64-msvc": "0.0.53"
   },
   "peerDependencies": {
     "typescript": "^7"
   },
   "devDependencies": {
-    "@solidrt/flux-types": "0.0.52",
+    "@solidrt/flux-types": "0.0.53",
     "@types/babel__core": "^7.20.5",
     "@types/bun": "latest"
   }

package/src/bundle/bundler.ts

@@ -2,7 +2,7 @@ import { transformAsync } from "@babel/core"
 import jsx from "@babel/plugin-syntax-jsx"
 import ts from "@babel/preset-typescript"
 import remapping from "@jridgewell/remapping"
-import solid from "babel-preset-solid"
+import solid from "@solidjs/babel-plugin"
 import { type BunPlugin, type BuildArtifact } from "bun"
 import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs"
 import { dirname, join, relative, resolve as resolvePath, sep } from "node:path"
@@ -76,7 +76,7 @@ async function codeFromOutputs(outputs: BuildArtifact[]): Promise<string> {
   return code
 }
 
-// Bun build plugin that runs JSX/TSX through babel-preset-solid (universal
+// Bun build plugin that runs JSX/TSX through @solidjs/babel-plugin (universal
 // generate, targeting @solidrt/core) plus the TS preset. `moduleName` only ends
 // up as an import specifier in the emitted code, resolved from the app's tree at
 // bundle time; the CLI itself never loads core, so core is deliberately neither
@@ -108,8 +108,8 @@ function solidPlugin(inputs: Set<string>, babelMaps?: Map<string, object>, isola
         let transforms = await transformAsync(code, {
           filename: args.path,
           sourceMaps: !!babelMaps,
-          presets: [[solid, { moduleName: "@solidrt/core", generate: "universal" }], [ts]],
-          plugins: [jsx, inlineImport(inputs)],
+          presets: [[ts]],
+          plugins: [jsx, [solid, { moduleName: "@solidrt/core", generate: "universal" }], inlineImport(inputs)],
         })
         if (babelMaps && transforms?.map) babelMaps.set(args.path, transforms.map)
         return { contents: transforms?.code ?? "", loader: "js" }

package/src/bundle/untyped-deps.d.ts

@@ -11,8 +11,8 @@ declare module "@babel/preset-typescript" {
   let preset: PluginItem
   export default preset
 }
-declare module "babel-preset-solid" {
+declare module "@solidjs/babel-plugin" {
   import { type PluginItem } from "@babel/core"
-  let preset: PluginItem
-  export default preset
+  let plugin: PluginItem
+  export default plugin
 }

package/src/demo/docs.md

@@ -2,26 +2,32 @@
 
 {{ usage demo }}
 
-The demos that come with the packages this project installs. Without an
-argument it lists them, numbered:
+The demos the SolidRT packages come with, shipped pre-bundled with the CLI so
+every install has all of them, whether or not the packages themselves are
+installed. Without an argument it lists them, numbered:
 
 ```
   1  3d/the-third-dimension
+  2  components/gallery
 ```
 
 `srt demo 1` runs that one, exactly as [srt run](../server/docs.md) runs any
-project: a dev server, a local client window, reload on save, and the same
-server options (`--lan` to reach it from a device, `--port`, `--tunnel`). The qualified
-name works too (`srt demo 3d/the-third-dimension`), which is the stable way to
-name one in a script - the numbers follow the list, and the list follows what
-is installed.
+project: a dev server and a local client window, with the same server
+options (`--lan` to reach it from a device, `--port`, `--tunnel`). So a
+running demo is an app the [console](../console/docs.md) picks up like any
+other, with its tree, stats and control API. The qualified name works too
+(`srt demo 3d/the-third-dimension`), which is the stable way to name one in
+a script - the numbers follow the list.
 
-A package keeps its demos in `demos/`, and that folder is one project: its own
-package.json, one `assets/` folder, and `src/<name>.tsx` per demo. So the
-demos of one package share a dev server and a port - start a second one while
-the first is up and it says so. Demos from different packages run side by
-side.
+A package keeps its demos in `demos/` in the repository, and that folder is
+one project: its own package.json, one `assets/` folder, and `src/<name>.tsx`
+per demo. The CLI ships that project bundled (`dist/demos/<package>/`, built
+by `make -C packages/cli demos`), and `srt demo` serves it with the chosen
+bundle as its entry. So the demos of one package share a dev server and a
+port - start a second one while the first is up and it says so. Demos from
+different packages run side by side.
 
-The demos ship inside the packages, so `node_modules` is where they are found:
-`srt demo` looks in the current directory and nowhere above it. Run it from
-the project root.
+The bundles are what runs, so editing a demo's source does not reload it. In
+a checkout, work on a demo with `srt run src/<name>.tsx --project` from the
+package's `demos/` folder, and rebuild the shipped bundles with
+`make -C packages/cli demos` when done.

package/src/demo/main.ts

@@ -1,34 +1,36 @@
 import { readdirSync } from "node:fs"
-import { join, resolve } from "node:path"
+import { join } from "node:path"
+import { fileURLToPath } from "node:url"
 import { source } from "../lib/args"
 
-// srt demo: the demos the installed @solidrt packages ship. A package's
-// demos are ONE project (`<package>/demos/`: package.json, one assets/, and
-// src/<name>.tsx per demo), so a demo runs as the project it lives in - this
-// file only lists and resolves, and main.ts starts the ordinary dev server
-// with its cwd set to that project. Nothing downstream knows about demos.
+// srt demo: the package demos the CLI ships pre-bundled (dist/demos/, built
+// by `make -C packages/cli demos`: the release workflow before publishing, a
+// checkout after editing a demo or its package). dist/demos/<pkg>/ is the
+// package's demos project as the dev server serves it - package.json,
+// assets/, and <slug>/<slug>.srt.js per demo - so a demo runs as the project
+// it lives in: this file only lists and resolves, and main.ts starts the
+// ordinary dev server with its cwd set to that project. Nothing downstream
+// knows about demos, and a demo shows up in the console like any app.
 
 export type Demo = { name: string; cwd: string; entry: string }
 
-const SCOPE = join("node_modules", "@solidrt")
+const DEMOS = fileURLToPath(new URL("../../dist/demos", import.meta.url))
 
-/** Every demo installed here, sorted so the printed numbers are stable.
- * The cwd and nothing above it - the same rule the server's mode resolution
- * follows (server/mode.ts), so this lists what THIS project installed. */
+/** Every demo the CLI ships, sorted so the printed numbers are stable. */
 function discover(): Demo[] {
   let demos: Demo[] = []
-  for (let pkg of names(SCOPE)) {
-    let dir = join(SCOPE, pkg, "demos")
-    for (let file of names(join(dir, "src"))) {
-      if (!file.endsWith(".tsx")) continue
-      demos.push({ name: `${pkg}/${file.slice(0, -".tsx".length)}`, cwd: resolve(dir), entry: join("src", file) })
+  for (let pkg of names(DEMOS)) {
+    let cwd = join(DEMOS, pkg)
+    for (let slug of names(cwd)) {
+      let entry = join(slug, `${slug}.srt.js`)
+      if (names(join(cwd, slug)).includes(`${slug}.srt.js`)) demos.push({ name: `${pkg}/${slug}`, cwd, entry })
     }
   }
   return demos
 }
 
-// A missing folder is the normal case (most packages ship no demos), so it
-// reads as an empty one rather than an error.
+// A missing folder reads as an empty one: a checkout without a demos build
+// has none, and assets/ is a sibling of the demo dirs, not one of them.
 function names(dir: string): string[] {
   try {
     return readdirSync(dir).sort()
@@ -45,7 +47,7 @@ function list(demos: Demo[]) {
 export async function main(): Promise<{ cwd: string; entry: string } | undefined> {
   let demos = discover()
   if (demos.length === 0) {
-    console.error(`No demos installed in ${process.cwd()} (looked in ${SCOPE}/*/demos/src/)`)
+    console.error("Demos not built: run make -C packages/cli demos")
     process.exit(1)
   }
 

package/src/init/scaffold/AGENTS.md

@@ -11,7 +11,9 @@ should open whenever the work matches its trigger.
 - @solidrt/core is the low-level foundation: host intrinsics (`<window>`,
   `<view>`, `<text>`, the detached `d-*` drawing primitives) with flat props
   that feed the layout and paint engine directly. An app can be written
-  entirely at this level.
+  entirely at this level. d-* elements go under anything; laid-out elements
+  only under laid-out parents (a `<view>` inside a `<d-view>` throws), so a
+  component's doc comment says which kind it renders.
 - Extensions build on core. The first-party ones are @solidrt/components
   (UI components), @solidrt/2d (2D graphics) and @solidrt/3d (3D graphics).
   None is privileged - an extension is just functions returning core JSX,

package/src/init/scaffold/package.json

@@ -10,14 +10,14 @@
     "android": "srt android"
   },
   "dependencies": {
-    "@solidrt/core": "0.0.52",
-    "@solidrt/components": "0.0.52",
-    "@solidrt/2d": "0.0.52",
-    "@solidrt/3d": "0.0.52"
+    "@solidrt/core": "0.0.53",
+    "@solidrt/components": "0.0.53",
+    "@solidrt/2d": "0.0.53",
+    "@solidrt/3d": "0.0.53"
   },
   "devDependencies": {
-    "@solidrt/cli": "0.0.52",
-    "@solidrt/flux-types": "0.0.52",
+    "@solidrt/cli": "0.0.53",
+    "@solidrt/flux-types": "0.0.53",
     "typescript": "^7"
   }
 }

package/src/lib/usage.ts

@@ -27,7 +27,7 @@ Commands:
   run [file]             Start dev server + local solidrt-go client
   server [file]          Start dev server only
   client                 Start solidrt-go client only
-  demo [<number>]        List the demos the installed packages ship, or run one
+  demo [<number>]        List the demos the CLI ships, or run one
   tool [<pkg>/<name>]    List the tools the installed packages ship, or run one
                          (everything after the tool name is the tool's own arguments)
   console                Start the dev console: the dev servers on this machine and their clients

package/src/server/main.ts

@@ -348,18 +348,21 @@ function bind(port: number): Server {
   })
 }
 
-// A bind alone does not prove a port free: with SO_REUSEADDR (the default
-// on a listener) Linux lets a loopback bind coexist with another process's
+// A bind alone does not prove a port free: on macOS (BSD SO_REUSEADDR, the
+// default on a listener) a loopback bind coexists with another process's
 // all-interfaces listener on the same port, and the newcomer then silently
-// takes the loopback traffic. So each candidate is dialed first; only a
-// refusal means free.
+// takes the loopback traffic; Linux and Windows refuse the second bind. So
+// each candidate is dialed first, and an answer means taken. Anything else
+// is left to the bind: a refusal cannot be waited for, because Windows only
+// reports one after ~2 s of SYN retries, so it reads as filtered within the
+// probe budget and the bind is the truth.
 async function bindFirstFree(): Promise<Server> {
   if (config.port !== undefined) return bind(config.port)
   let candidates: number[] = remembered !== null ? [remembered] : []
   for (let p = DEFAULT_PORT; p < DEFAULT_PORT + PORT_TRIES; p++) candidates.push(p)
   let last: unknown = null
   for (let port of candidates) {
-    if ((await probe("127.0.0.1", port, { timeoutMs: 200 })) !== "closed") continue
+    if ((await probe("127.0.0.1", port, { timeoutMs: 200 })) === "open") continue
     try {
       return bind(port)
     } catch (e) {