@solidrt/core 0.0.65 → 0.0.66

package/AGENTS.md

@@ -92,7 +92,7 @@ real design decision, not an afterthought:
 
 ```sh
 bun add @solidrt/core        # the renderer
-bun add -d @solidrt/cli      # the `srt` tool (see its AGENTS.md)
+bun add -d @solidrt/cli      # the `sol` tool (see its AGENTS.md)
 ```
 
 Core primitives alone are enough to build a full app. The optional extensions
@@ -320,7 +320,7 @@ that reads exactly like Solid fallout.
   input happened. Time anything about input with it (a press length, the
   gap between two taps, a speed from two positions), never with
   `performance.now()` in the handler: that is when the handler ran, and
-  it does not follow the dev clock, `srt render` or a test. The stamp is
+  it does not follow the dev clock, `sol render` or a test. The stamp is
   the input's own time, not its delivery's: a move carries the time the
   pointer was at the position it reports, however late the frame that
   delivers it; a down, up, wheel or key the time the platform recorded.
@@ -616,7 +616,7 @@ that reads exactly like Solid fallout.
   seldom changes the picture. `frameTime()` is the current frame's `tick`
   read from anywhere (not reactive, requests nothing): the app's own
   clock for code with no tick in hand, where `performance.now()` would
-  ignore the dev clock, `srt render` and tests. A JS
+  ignore the dev clock, `sol render` and tests. A JS
   tween loop or an animation library pushing interpolated values through
   signals is the single most expensive mistake available here - read
   agents/performance.md before writing either.

package/README.md

@@ -35,7 +35,7 @@ render(() => <App />)
 Run the app:
 
 ```sh
-bun run srt run src/index.tsx
+bun run sol run src/index.tsx
 ```
 
 Optionally, create a `tsconfig.json` to enable type recognition for SolidRT elements:

package/agents/performance.md

@@ -149,7 +149,7 @@ Rules, in order of leverage:
    anything needing what is behind it does not - and is split from content
    invalidation, so a params-only change re-runs the pass against the cached
    snapshot instead of re-rasterizing. A window shader's output is invisible
-   to get_snapshot and every other MCP tool; `bun run srt render` is the only
+   to get_snapshot and every other MCP tool; `bun run sol render` is the only
    way to see it (see @solidrt/cli AGENTS.md).
 8. `flux:wasm` runs a pure interpreter (wasmi, no JIT), so temper browser
    expectations - but do not write it off for compute. A genuinely numeric
@@ -208,7 +208,7 @@ let n = await worker.crunch(bytes)              // main keeps rendering meanwhil
 ```
 
 The bundler builds each such module as its own bundle and ships it with the
-app (dev pushes and `srt pack` alike). Rules: main may only `import type`
+app (dev pushes and `sol pack` alike). Rules: main may only `import type`
 from an isolate module (a value import is a build error); arguments and
 results are copies (numbers, strings, byte buffers, arrays, plain objects -
 no functions, no class instances); the child has the non-gui `flux:*`
@@ -248,7 +248,7 @@ not infer it from the desktop number.
 - **Some paints cost a frame each on a tiled mobile GPU.** Measured on a
   mid-range 2020 tablet (Adreno 610, Impeller GLES) with ten panes sliding
   and resizing on a layout transition, each row by subtraction from the
-  compositor's own present record (`srt android --census`), against a
+  compositor's own present record (`sol android --census`), against a
   frame that ran at 60 fps with a 13 ms GPU span:
   - a 3-stop linear-gradient fill per pane: +15 ms, 20 fps. A gradient is
     shaded per pixel per frame; the same tint as a flat `d-rect` costs

package/docs/index.md

@@ -176,7 +176,7 @@ animation and audio, not the persistence moment.
 A link from outside (a custom scheme link the OS routed to the app, or one
 a dev tool sent) arrives raw: `env.launchLink` is the one this run of the
 app was started with (null without; a hot reload starts at the location
-the app last reported, see `reportLocation` in `srt:dev`), `onLink` fires
+the app last reported, see `reportLocation` in `sol:dev`), `onLink` fires
 for one arriving while the app runs. What a link names is the app's to decide, and it is untrusted input:
 validate before acting on any part of it. A router turns links into screens
 for you; without one, parse it yourself. The scheme a packed app answers to

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidrt/core",
-  "version": "0.0.65",
+  "version": "0.0.66",
   "license": "MIT",
   "funding": "https://github.com/sponsors/wellawaretech",
   "author": "Antoine van Wel",
@@ -33,8 +33,8 @@
     "AGENTS.md"
   ],
   "devDependencies": {
-    "@solidrt/flux-types": "0.0.65",
-    "@solidrt/test": "0.0.65"
+    "@solidrt/flux-types": "0.0.66",
+    "@solidrt/test": "0.0.66"
   },
   "peerDependencies": {
     "@solidjs/signals": "2.0.0-rc.13",

package/src/camera.ts

@@ -9,7 +9,7 @@
 import { createSignal, onCleanup } from "@solidjs/signals"
 import { listCameras, open } from "flux:camera"
 import type { TextureId } from "flux:gpu"
-import { on } from "srt:events"
+import { on } from "sol:events"
 
 export type CameraFacing = "front" | "back" | "unknown"
 

package/src/core.ts

@@ -1,7 +1,7 @@
 import * as tree from "flux:rendertree"
 import type { TextureId } from "flux:gpu"
 import { createSignal, getOwner, onCleanup } from "@solidjs/signals"
-import { on } from "srt:events"
+import { on } from "sol:events"
 
 let handlers = new Map<number, Map<string, Function>>()
 

package/src/environment.ts

@@ -1,5 +1,5 @@
 import { createSignal, runWithOwner } from "@solidjs/signals"
-import { on } from "srt:events"
+import { on } from "sol:events"
 import { onPointerMove } from "./core"
 import { windowSize, safeArea, displayScale, windowFocused, keyboardHeight } from "./window"
 
@@ -16,7 +16,7 @@ import { windowSize, safeArea, displayScale, windowFocused, keyboardHeight } fro
 // runs, which is usually inside a component or a computation (a memo's first
 // read of env.inputDevices, a HUD effect's first read of pointerLocked()).
 // Created there, the fact would belong to that reader: sticky events replay
-// their cached value synchronously on subscribe (srt:events' on()), so the
+// their cached value synchronously on subscribe (sol:events' on()), so the
 // on() call writes the signal it just created inside the reader's owned
 // scope - a render-time write, which the guard rejects - and a root or a
 // subscription created there is disposed with the reader. The facts are
@@ -274,7 +274,7 @@ export let env = {
   },
   /**
    * The link this process was started with, or null: a custom scheme link
-   * the OS routed to the app (Android intent data; `srt render --link`),
+   * the OS routed to the app (Android intent data; `sol render --link`),
    * raw, exactly as it arrived. What it names is the app's to decide, and
    * it is untrusted input: validate before acting on any part of it. A link
    * arriving while the app runs is an event instead: `onLink`. Fixed for the

package/src/gamepad.ts

@@ -1,5 +1,5 @@
 import { createSignal, runWithOwner } from "@solidjs/signals"
-import { on } from "srt:events"
+import { on } from "sol:events"
 
 // Gamepad State: a reactive mirror of the runtime's sticky "gamepads" event.
 //

package/src/gpu.ts

@@ -347,7 +347,7 @@ export function createMutableTexture(
  * `packed` as a keyword, so `vec4 packed = texture(...)` fails with a syntax
  * error that does not name the identifier - pick another name.
  *
- * A bad source is a runtime failure, not one `srt check` catches: the compile
+ * A bad source is a runtime failure, not one `sol check` catches: the compile
  * throws at this call, so a shader created in a component body takes the app
  * to the error window unless an `<Errored>` closer in the tree claims it.
  */

package/src/renderer.ts

@@ -86,7 +86,7 @@ function flushDestroy(): void {
 function removeNode(parent: ProxyNode, node: ProxyNode): void {
   if (!node || !parent) return
 
-  // console.debug("[srt] removeNode", parent.id, node.id)
+  // console.debug("[sol] removeNode", parent.id, node.id)
 
   // Update JS tree references
   let index = parent.children.indexOf(node)
@@ -113,7 +113,7 @@ function removeNode(parent: ProxyNode, node: ProxyNode): void {
 // bookkeeping on the hot create/insert paths, orphans are derived from the
 // proxy map itself: parentless, not the window root, and not awaiting the
 // destroy sweep. window.ts runs the scan on a rendered frame every few
-// seconds; dev bundles only (srt always defines import.meta.env.DEV, so a
+// seconds; dev bundles only (sol always defines import.meta.env.DEV, so a
 // production bundle folds the check into a constant early return).
 const SENTINEL_INTERVAL_MS = 5000
 let sentinelDue = 0
@@ -208,7 +208,7 @@ function routeFor(name: string): number {
 function applyProp<T>(node: ProxyNode, name: string, value: T): void {
   if (!node) return
 
-  // console.debug("[srt] applyProp", node.id, name, value)
+  // console.debug("[sol] applyProp", node.id, name, value)
 
   switch (routeFor(name)) {
     case ROUTE_EVENT:
@@ -234,7 +234,7 @@ let renderer = createRenderer<ProxyNode>({
   createElement: (elementType: string, props?: Record<string, any>): ProxyNode => {
     let proxy = createProxyNode(elementType)
 
-    // console.debug("[srt] createElement", proxy.id, elementType)
+    // console.debug("[sol] createElement", proxy.id, elementType)
 
     if (elementType === "window") tree.createRoot(proxy.id)
     else tree.createNode(proxy.id, elementType)
@@ -257,20 +257,20 @@ let renderer = createRenderer<ProxyNode>({
   // no element form of its own (the DOM's "#text" node name).
   createTextNode: (value: string): ProxyNode => {
     let proxy = createProxyNode("#text")
-    // console.debug("[srt] createTextNode", proxy.id, value)
+    // console.debug("[sol] createTextNode", proxy.id, value)
     tree.createNode(proxy.id, "#text")
     tree.setProperty(proxy.id, "text", "" + value)
     return proxy
   },
 
   replaceText: (node: ProxyNode, value: string): void => {
-    // console.debug("[srt] replaceText", node.id, value)
+    // console.debug("[sol] replaceText", node.id, value)
     tree.setProperty(node.id, "text", "" + value)
   },
 
   isTextNode: (node: ProxyNode): boolean => node?.elementType === "#text",
   setProperty: <T>(node: ProxyNode, name: string, value: T): void => {
-    // console.debug("[srt] setProperty", node.id, name, value)
+    // console.debug("[sol] setProperty", node.id, name, value)
     applyProp(node, name, value)
   },
 
@@ -294,7 +294,7 @@ let renderer = createRenderer<ProxyNode>({
     pendingDestroy.delete(node.id)
 
     if (parent) {
-      // console.debug("[srt] insertNode", parent.id, node.id, anchor?.id ?? "")
+      // console.debug("[sol] 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

package/src/runtime-modules.d.ts

@@ -1,4 +1,4 @@
-// Lattice runner builtin modules (the "srt:*" surface). These are ambient
+// Lattice runner builtin modules (the "sol:*" surface). These are ambient
 // module declarations, so they live in this global-script .d.ts (no top-level
 // import/export) rather than in types.d.ts: an ambient `declare module` only
 // becomes globally visible to consumers from a non-module declaration file.
@@ -51,7 +51,7 @@ declare module "*.glb" {
   const bytes: Uint8Array
   export default bytes
 }
-declare module "*.srtm" {
+declare module "*.sol3m" {
   const bytes: Uint8Array
   export default bytes
 }
@@ -63,13 +63,13 @@ declare module "*.srtm" {
 // pointer moves have dispatched, every pointer the same age - multi-pointer
 // recognizers measure there; its `timeStamp` is theirs), and "render" (the
 // per-frame signal).
-declare module "srt:events" {
+declare module "sol:events" {
   export function on(event: string, callback: (data: any) => void): () => void
   export function once(event: string, callback: (data: any) => void): () => void
 }
 
 // The running application's own surface (lattice), present in every build.
-declare module "srt:app" {
+declare module "sol:app" {
   /**
    * End the current app now, without running the quit hooks: back to the
    * player in a dev client, quit when standalone or at the player root (on
@@ -100,7 +100,7 @@ declare module "srt:app" {
 
 // Dev-server control surface (lattice). Present only in dev/go builds; in other
 // builds `available` is false and the functions are no-ops.
-declare module "srt:dev" {
+declare module "sol:dev" {
   export const available: boolean
   export const canDiscover: boolean
   export const recents: string[]
@@ -139,7 +139,7 @@ declare module "srt:dev" {
 // Installed-app management (lattice), the player's surface over the client's
 // version store. Present only in go/dev client builds; elsewhere `available`
 // is false, `list` returns [], and launch/remove are no-ops.
-declare module "srt:apps" {
+declare module "sol:apps" {
   export const available: boolean
   /**
    * An installed app: id, display name (the installed manifest's displayName,
@@ -233,16 +233,16 @@ declare module "srt:apps" {
 // submits the display list. To schedule a future frame instead, use
 // requestFrame() from "flux:rendertree". The tree-building surface itself is
 // "flux:rendertree" (from @solidrt/flux-types).
-declare module "srt:render" {
+declare module "sol:render" {
   export function renderFrame(): void
 }
 
 // The engine verbs of an app test (lattice, dev client only), which
 // @solidrt/test builds its surface on; tests import that, not this.
-// The verbs work only in an engine a test host built (`srt test`) and throw
+// The verbs work only in an engine a test host built (`sol test`) and throw
 // anywhere else. App time there is frame / frameRate and nothing else: no
 // frame runs unless one is asked for.
-declare module "srt:test" {
+declare module "sol:test" {
   /**
    * Runs one frame: timers due by its time fire, then frame callbacks and
    * the flush, then the draw if anything demanded one. Fulfills once the

package/src/textures.ts

@@ -2,7 +2,7 @@
 // the runtime: this entry imports nothing the runtime provides, so a bake
 // script under bun and an extension's pure modules use it as it is
 // (tests/textures.test.ts imports it on the bare flux binary and fails the
-// moment a gui or srt: import creeps in). Any extension that bakes or loads textures
+// moment a gui or sol: import creeps in). Any extension that bakes or loads textures
 // builds on this, the first-party 3d one included.
 //
 // isKtx2 tells a compressed texture file from a PNG or JPEG.

package/src/transform.ts

@@ -1,5 +1,5 @@
 import { onSettled } from "@solidjs/signals"
-import { on } from "srt:events"
+import { on } from "sol:events"
 import type { PointerEvent } from "./types"
 import { arena, type ArenaOwner } from "./arena"
 import { createVelocityTracker, flingVelocity } from "./velocity"

package/src/types.d.ts

@@ -9,14 +9,14 @@ import type { Element } from "solid-js"
 
 export type { TextInputHints }
 
-// The "srt:*" lattice runner modules are declared in ./runtime-modules.d.ts
+// The "sol:*" lattice runner modules are declared in ./runtime-modules.d.ts
 // (referenced above) - ambient `declare module` only reaches consumers from a
 // non-module declaration file, and this file is a module.
 
 declare global {
   interface ImportMeta {
     /**
-     * Build-mode constants, substituted textually by the srt bundler (Vite
+     * Build-mode constants, substituted textually by the sol bundler (Vite
      * vocabulary). `DEV` is true in dev bundles and false in production
      * bundles, where the substituted constant lets the minifier fold
      * dev-only code away entirely.
@@ -291,7 +291,7 @@ export interface PointerEvent {
    * pointer, so the real move after it can carry an earlier time. Use it
    * where you would reach for `performance.now()` in a handler: that one
    * measures when the handler ran, not when the input happened, and it does
-   * not follow the dev clock, `srt render` or a test. The origin is
+   * not follow the dev clock, `sol render` or a test. The origin is
    * arbitrary (compare stamps with each other, not with `performance.now()`,
    * a timer or the `onFrame` tick).
    */

package/src/window.ts

@@ -1,8 +1,8 @@
 import { createSignal, getOwner, onCleanup, onSettled, runWithOwner, flush } from "@solidjs/signals"
 import { requestFrame, setPointerLock } from "flux:rendertree"
-import { renderFrame } from "srt:render"
-import { on, once } from "srt:events"
-import { exit as nativeExit, background as nativeBackground, registerProtocolHandler as nativeRegisterProtocolHandler } from "srt:app"
+import { renderFrame } from "sol:render"
+import { on, once } from "sol:events"
+import { exit as nativeExit, background as nativeBackground, registerProtocolHandler as nativeRegisterProtocolHandler } from "sol:app"
 import { platform } from "flux:process"
 import { getEventHandler, focusedNode, setFocus, activateTextInput, setInterestRoot } from "./core"
 import { scanForOrphans, getNodePath } from "./renderer"
@@ -269,7 +269,7 @@ export function onFrame(fn: (tick: number, frame: number, rate: number) => void,
  * between frames (an event handler, a timer) it is the latest frame's. It
  * is 0 before the first frame. Not reactive, and reading it requests no
  * frame. Use it to time things against the app's own clock from code that
- * has no tick in hand: it follows the dev tools' clock control, `srt
+ * has no tick in hand: it follows the dev tools' clock control, `sol
  * render` and a test, where performance.now() does not.
  */
 export function frameTime(): number {