@solidrt/core 0.0.57 → 0.0.59

package/AGENTS.md

@@ -111,12 +111,18 @@ tsconfig.json - the two load-bearing lines are jsx + jsxImportSource:
 ```
 
 Peer deps @solidjs/signals and @solidjs/universal must match (currently
-2.0.0-rc.6); bun resolves them from peerDependencies. On a version bump,
+2.0.0-rc.8); bun resolves them from peerDependencies. On a version bump,
 `bun install` only warns ("incorrect peer dependency") and keeps the old
 ones, and `bun update solid-js @solidjs/signals @solidjs/universal` does
 not read the pin either: it adds all three to package.json at registry
-latest (solid-js 1.x, off Solid 2.0 entirely). The recipe that works is
-`rm -rf bun.lock node_modules/solid-js node_modules/@solidjs && bun install`.
+latest (solid-js 1.x, off Solid 2.0 entirely). The recipe that works
+deletes the installed copies and leaves the lockfile alone:
+`rm -rf node_modules/solid-js node_modules/@solidjs && bun install`
+(delete any nested `node_modules/@solidjs` too, or the old copy keeps
+resolving). Removing the directories is what forces re-resolution. Do not
+delete `bun.lock` to force it: that re-resolves every unrelated dependency
+as well, and a package that floats elsewhere fails the typecheck in a way
+that reads exactly like Solid fallout.
 
 ## Element model (the parts that are easy to get wrong)
 
@@ -361,7 +367,17 @@ latest (solid-js 1.x, off Solid 2.0 entirely). The recipe that works is
   `<View2d pointer>` take a feed and spread it on their built-in leaf) and
   bind its gestures `drag` (one pointer), `pan` (two), `pinch`, `twist`,
   `wheel` and `mouseDelta` (raw motion while pointerLocked()). One
-  merged recognizer serves them, so they arbitrate in the arena as one. A
+  merged recognizer serves them, so they arbitrate in the arena as one.
+  Each gesture takes a chord in the key-spec grammar: `pointer.drag("Ctrl")`
+  fires only when the event that opens the gesture carries Ctrl, and then
+  instead of the bare `drag` (the most specific bound chord wins, as a
+  key spec does), held for the whole gesture - so plain drag on `rotate`
+  and `drag("Ctrl")` on `pan` is one binding each, the every-viewport
+  default. A bracketed spec may end in its button (`drag("Right")`,
+  `drag("Shift+Middle")`; bare means Left), a discriminator rather than
+  a modifier: a right drag feeds only Right specs. Touch carries no
+  modifiers or buttons: a chord is the desktop path, the bare binding
+  stays for fingers. A
   detached d-* leaf has no layout box: give the feed `{ layout }` or it
   throws at the first press. `invert(source)` and `scale(source, k)` are
   the two processors: keys and sticks move the CAMERA where a drag moves
@@ -445,13 +461,32 @@ latest (solid-js 1.x, off Solid 2.0 entirely). The recipe that works is
   write targets, and the runtime animates natively with no per-frame JS.
   Enter and exit are per-property entries on that same spec: `from` is the
   value the property animates in from at first attach, `exit` the value it
-  animates to on removal (the node stays painted until it settles, then
-  frees - no AnimatePresence equivalent needed). `stagger` (ms) goes on an
+  animates to on removal. An exit reaches the whole unmounted subtree: every
+  `exit` declared under the node that unmounts plays, and the node stays
+  painted until the last of them settles, then frees - a panel's contents
+  leave with `exit` beside their `from`, no closing signal, held mount or
+  settle cue (no AnimatePresence equivalent needed). One rule in both
+  trees: a node animating out is a ghost, painted and nothing else -
+  hit-test invisible here, and in the spatial arena (a @solidrt/2d sprite,
+  a @solidrt/3d node, whose `destroy` verbs carry the same `exit`)
+  invisible to every pick, raycast, overlap and sweep - while an entering
+  node is live from its first frame, whatever `from` it passes through.
+  Either endpoint takes
+  `{ value, curve?, duration?, bounce?, delay? }` to own its direction's
+  motion (an ease-out enter, an ease-in exit). `stagger` (ms) goes on an
   ANCESTOR, never on the animating elements: it delays each descendant's
   enter/exit by `index * stagger`, and cascades nothing unless the
   descendants declare `from`/`exit`. An enter plays once per mount; to
   replay it, remount the subtree (`<Show when={epoch()} keyed>` around it,
-  then bump `epoch`). See examples/stagger.tsx.
+  then bump `epoch`). See examples/stagger.tsx. The companion to the exit
+  pop-out is `layout` on the same spec: an element declaring it slides
+  from where it was painted to the box a layout gives it (a row removed
+  above it, one inserted, a `<For>` reorder) instead of jumping, retargets
+  if the layout changes again mid-slide, and is hit-tested where it is
+  drawn. It is parent-relative, so declare it on every level that should
+  glide; `layout: true` borrows the `all` motion, and `all` alone never
+  slides. Position only today, a size change snaps. See
+  examples/layout-slide.tsx.
   Per-frame work is for genuinely procedural motion, and a game or a
   simulation is that in full: its natural shape is ONE `onFrame` doing one
   sim step and N property (or sprite) writes, which is not a smell but the

package/docs/index.md

@@ -146,6 +146,29 @@ let camera = createCamera()
 The same pattern covers `@solidrt/core/microphone`, `/sound`,
 `/speech-recognition`, `/text-input`, `/image`, `/color`, and `/gpu`.
 
+## Lifecycle
+
+The runtime reports the platform's lifecycle facts and holds the platform
+open while the app acts on them; what to do with them is the app's policy.
+`onBack` is the user's back intent (prevent it for in-app navigation, or let
+it fall through to the platform's default: `background()` on Android, where
+the system keeps the app behind the others, `exit()` elsewhere). `onSuspend` fires when the app is being
+suspended and may be killed without notice (switching away on Android or
+iOS; never on desktop): persist session state there, async is fine, the
+runtime waits for the returned promise up to its deadline. `onQuit` fires
+when this app instance is ending (`exit()`, the window closing, the Android
+activity finishing) and waits the same way, inside the platform's close
+budget. `env.launch` says how this process came to run: "restored" when the
+system recreated the app from a session it ended on its own, "fresh" for a
+launch the user started. Whether to load what `onSuspend` saved is the app's
+call. `env.visibility` is only whether anything is on screen, for pausing
+animation and audio, not the persistence moment.
+
+```tsx
+onSuspend(() => file("session.json").write(JSON.stringify(state)))
+if (env.launch === "restored") state = JSON.parse(await file("session.json").text())
+```
+
 ## Reference
 
 The [reference](/core/reference/) covers the API by subject: the element

package/examples/README.md

@@ -21,6 +21,7 @@ for the element/prop model see `@solidrt/core/AGENTS.md`.
 - `frame-animation.tsx` - `onFrame` driving a transform animation each frame.
 - `on-layout-connect.tsx` - `onLayout` + `getBoundingBox` connecting laid-out boxes with a `d-path`.
 - `stagger.tsx` - enter/exit/stagger with no per-frame JS: `from` and `exit` per property on each row's own `transition`, `stagger` on the ANCESTOR cascading them in occurrence order, and the replay idiom - a keyed `<Show>` remounts the subtree when its `when` value changes, so bumping an epoch replays the whole cascade. Exiting rows stay painted until they settle.
+- `layout-slide.tsx` - the `layout` transition, the companion to exit: rows declaring it slide from the box they had to the box a layout gives them instead of jumping - tap a row to remove it (its exit plays where it was while the rows below slide up), the header to shuffle the order (a `<For>` reorder), the footer to add one back. No per-frame JS, no hand-animated `y`.
 
 ## Pointer input
 - `pointer-local-coords.tsx` - the three pointer coordinate frames (`clientX` window, `localX` the handling node's own frame, `parentX` its path-parent's frame - where the node's x/y live) and the transform-proof drag idiom: grab offset from `localX` at down, place with `parentX - offset` on moves. Exact inside rotated/scaled ancestors and when the pointer leaves the node mid-drag.

package/examples/gpu-draw-list.tsx

@@ -60,22 +60,22 @@ let FRAGMENT_PULSE = glsl`
 function App() {
   let triangle = createBuffer(new Float32Array([0, 0.6, -0.5, -0.4, 0.5, -0.4]), { label: "tri" })
   let vs = compileShader("vertex", VERTEX, { header: true })
-  let attrs = [{ name: "aPos", format: "vec2" as const }]
+  let attrs = [{ name: "aPos", format: "float32x2" as const }]
   let warm = createRenderPipeline(linkProgram(vs, compileShader("fragment", FRAGMENT_WARM, { header: true })), {
-    attributes: attrs,
+    buffers: [{ attributes: attrs }],
     depth: true,
   })
   let cool = createRenderPipeline(linkProgram(vs, compileShader("fragment", FRAGMENT_COOL, { header: true })), {
-    attributes: attrs,
+    buffers: [{ attributes: attrs }],
     depth: true,
   })
   let pulse = createRenderPipeline(linkProgram(vs, compileShader("fragment", FRAGMENT_PULSE, { header: true })), {
-    attributes: attrs,
+    buffers: [{ attributes: attrs }],
   })
 
   let target = createDrawTarget(512, 512, null, { depth: true, clearColor: [0.04, 0.04, 0.08, 1], label: "orbits" })
-  let warmDraw = addDraw(target, warm, { uAngle: 0 }, { buffer: triangle })
-  let coolDraw = addDraw(target, cool, { uAngle: Math.PI }, { buffer: triangle })
+  let warmDraw = addDraw(target, warm, { uAngle: 0 }, { buffers: [triangle] })
+  let coolDraw = addDraw(target, cool, { uAngle: Math.PI }, { buffers: [triangle] })
 
   // A third entry blinks in and out every second: add/remove are ordinary
   // per-frame-affordable writes, and a removed DrawId simply retires. Its
@@ -91,7 +91,7 @@ function App() {
     setDrawParams(target, coolDraw, { uAngle: t + Math.PI })
     let wantPulse = Math.floor(t) % 2 === 0
     if (wantPulse && pulseDraw === null) {
-      pulseDraw = addDraw(target, pulse, { uAngle: t * 0.3, uPhase: t * 5 }, { buffer: triangle, before: warmDraw })
+      pulseDraw = addDraw(target, pulse, { uAngle: t * 0.3, uPhase: t * 5 }, { buffers: [triangle], before: warmDraw })
     } else if (!wantPulse && pulseDraw !== null) {
       removeDraw(target, pulseDraw)
       pulseDraw = null

package/examples/gpu-instancing.tsx

@@ -1,7 +1,7 @@
 // Instanced drawing with per-instance attributes: one 3-vertex triangle in
 // the vertex buffer, drawn hundreds of times, each copy reading its own
-// record from an instance buffer (instanceAttributes on the pipeline +
-// instanceBuffer on the target, vertex divisor 1 underneath). Here each
+// record from an instance buffer (a `stepMode: "instance"` layout on the
+// pipeline, vertex divisor 1 underneath). Here each
 // record is one petal of a phyllotaxis spiral - its angle, radius, size, and
 // tint, computed once in JS - so the vertex stage just reads state instead
 // of re-deriving it from gl_InstanceID every frame, and the geometry buffer
@@ -45,7 +45,7 @@ let FRAGMENT = glsl`
   }
 `
 
-// One record per petal (matching instanceAttributes: 6 floats): radius grows
+// One record per petal (matching the instance layout: 6 floats): radius grows
 // with sqrt(index), the angle steps by the golden angle (~2.39996 rad) - the
 // sunflower layout - petals shrink toward the rim, and the tint walks a
 // cosine palette.
@@ -70,15 +70,19 @@ function App() {
   let instanceId = createBuffer(petalRecords(), { label: "petal-records" })
   let id = createPipelineTexture(VERTEX, FRAGMENT, 512, 512, { uTime: 0 }, {
     label: "petals",
-    attributes: [{ name: "aPos", format: "vec2" }],
-    buffer: bufferId,
-    instanceAttributes: [
-      { name: "iAngle", format: "f32" },
-      { name: "iRadius", format: "f32" },
-      { name: "iScale", format: "f32" },
-      { name: "iTint", format: "vec3" },
+    buffers: [
+      { attributes: [{ name: "aPos", format: "float32x2" }], buffer: bufferId },
+      {
+        stepMode: "instance",
+        attributes: [
+          { name: "iAngle", format: "float32" },
+          { name: "iRadius", format: "float32" },
+          { name: "iScale", format: "float32" },
+          { name: "iTint", format: "float32x3" },
+        ],
+        buffer: instanceId,
+      },
     ],
-    instanceBuffer: instanceId,
     instanceCount: 1,
     clearColor: [0.03, 0.03, 0.06, 1],
   })

package/examples/gpu-particles.tsx

@@ -74,11 +74,15 @@ function App() {
   let bufferId = createBuffer(particles(1500), { label: "particle-verts" })
   let id = createPipelineTexture(VERTEX, FRAGMENT, 512, 512, { uTime: 0, uTintA: [1.0, 0.45, 0.15], uTintB: [0.25, 0.5, 1.0] }, {
     label: "particles",
-    attributes: [
-      { name: "aPos", format: "vec3" },
-      { name: "aSeed", format: "f32" },
+    buffers: [
+      {
+        attributes: [
+          { name: "aPos", format: "float32x3" },
+          { name: "aSeed", format: "float32" },
+        ],
+        buffer: bufferId,
+      },
     ],
-    buffer: bufferId,
     topology: "points",
     blend: "add",
     clearColor: [0.02, 0.02, 0.05, 1],

package/examples/gpu-pipeline.tsx

@@ -87,11 +87,15 @@ function App() {
   let indexId = createBuffer(cubeIndices(), { label: "cube-indices" })
   let id = createPipelineTexture(VERTEX, FRAGMENT, 1024, 1024, { uTime: 0 }, {
     label: "cube",
-    attributes: [
-      { name: "aPos", format: "vec3" },
-      { name: "aColor", format: "vec3" },
+    buffers: [
+      {
+        attributes: [
+          { name: "aPos", format: "float32x3" },
+          { name: "aColor", format: "float32x3" },
+        ],
+        buffer: bufferId,
+      },
     ],
-    buffer: bufferId,
     indexBuffer: indexId,
     indexFormat: "uint16",
     depth: true,

package/examples/gpu-shared-params.tsx

@@ -65,12 +65,12 @@ let FRAGMENT_MAP = glsl`
 function App() {
   let quad = createBuffer(new Float32Array([-1, -1, 1, -1, 1, 1, -1, -1, 1, 1, -1, 1]), { label: "quad" })
   let vs = compileShader("vertex", VERTEX, { header: true })
-  let attrs = [{ name: "aPos", format: "vec2" as const }]
+  let attrs = [{ name: "aPos", format: "float32x2" as const }]
   let tint = createRenderPipeline(linkProgram(vs, compileShader("fragment", FRAGMENT_TINT, { header: true })), {
-    attributes: attrs,
+    buffers: [{ attributes: attrs }],
   })
   let mapped = createRenderPipeline(linkProgram(vs, compileShader("fragment", FRAGMENT_MAP, { header: true })), {
-    attributes: attrs,
+    buffers: [{ attributes: attrs }],
   })
 
   // 2x2 patterns, nearest + repeat, so gl_FragCoord tiling shows hard cells.
@@ -99,12 +99,12 @@ function App() {
     if (i === 1 || i === 5) {
       // Patterned entries read the shared uMap; the one at i === 5 brings
       // its own binding and keeps its stripes through every shared swap.
-      addDraw(target, mapped, { uCenter }, i === 5 ? { buffer: quad, textures: { uMap: stripes } } : { buffer: quad })
+      addDraw(target, mapped, { uCenter }, i === 5 ? { buffers: [quad], textures: { uMap: stripes } } : { buffers: [quad] })
     } else if (i === 3) {
       // The override quad: its own uTint beats the shared color cycle.
-      addDraw(target, tint, { uCenter, uTint: [1, 0.62, 0.1, 1] }, { buffer: quad })
+      addDraw(target, tint, { uCenter, uTint: [1, 0.62, 0.1, 1] }, { buffers: [quad] })
     } else {
-      addDraw(target, tint, { uCenter }, { buffer: quad })
+      addDraw(target, tint, { uCenter }, { buffers: [quad] })
     }
   }
 

package/examples/gpu-sprites.tsx

@@ -60,14 +60,18 @@ function App() {
     label: "sprites",
     topology: "triangle-strip",
     vertexCount: 4,
-    attributes: [{ name: "aPos", format: "vec2" }],
-    buffer: quad,
-    instanceAttributes: [
-      { name: "iCenter", format: "vec2" },
-      { name: "iSize", format: "f32" },
-      { name: "iTint", format: "vec3" },
+    buffers: [
+      { attributes: [{ name: "aPos", format: "float32x2" }], buffer: quad },
+      {
+        stepMode: "instance",
+        attributes: [
+          { name: "iCenter", format: "float32x2" },
+          { name: "iSize", format: "float32" },
+          { name: "iTint", format: "float32x3" },
+        ],
+        buffer: records,
+      },
     ],
-    instanceBuffer: records,
     instanceCount: MAX_SPRITES,
     clearColor: [0.03, 0.03, 0.06, 1],
   })

package/examples/layout-slide.tsx

@@ -0,0 +1,78 @@
+// The `layout` transition, the companion to `exit`: a row declaring it
+// slides from the box it had to the box the next layout gives it, so the
+// list never jumps when a row leaves, arrives or moves. Nothing here
+// animates `y` by hand and there is no per-frame JS: the rows keep their
+// flex layout, and the runtime slides each one from where it was painted.
+// Tap a row to remove it - its exit plays where it was (the pop-out) while
+// the rows below slide up past it. Tap the header to shuffle: a `<For>`
+// reorder moves the surviving nodes, so every displaced row slides. Tap
+// the footer to add a row back: the rows below its slot slide apart and
+// the new row enters through its `from`. A reflow that lands mid-slide
+// retargets, and a spring keeps its momentum. `layout` is parent-relative
+// (declare it on every level that should glide) and position only: a size
+// change snaps.
+import { render, createSignal, For } from "@solidrt/core"
+import type { Transition } from "@solidrt/core"
+
+const ALL_ROWS = ["Signals", "Effects", "Memos", "Stores", "Boundaries", "Resources"]
+// Rows the list starts with; the rest come back through the footer.
+const INITIAL_ROWS = 4
+// Every reflow slides on this spring.
+const SLIDE = { duration: 400, bounce: 0.15 } satisfies Transition
+// Enter from the left, leave to the right, each direction on its own curve.
+const ARRIVE = {
+  duration: 300,
+  curve: "ease-out",
+  from: -80,
+  exit: { value: 80, curve: "ease-in", duration: 200 },
+} satisfies Transition
+const FADE = {
+  duration: 300,
+  curve: "ease-out",
+  from: 0,
+  exit: { value: 0, curve: "ease-in", duration: 200 },
+} satisfies Transition
+
+function shuffled(items: string[]): string[] {
+  let pool = items.slice()
+  let out: string[] = []
+  while (pool.length > 0) out.push(...pool.splice(Math.floor(Math.random() * pool.length), 1))
+  return out
+}
+
+function App() {
+  let [rows, setRows] = createSignal(ALL_ROWS.slice(0, INITIAL_ROWS))
+  let addRow = () => {
+    let next = ALL_ROWS.find((label) => !rows().includes(label))
+    if (next) setRows([...rows(), next])
+  }
+
+  return (
+    <window padding={40} gap={12}>
+      <view height={40} justifyContent="center" onPointerDown={() => setRows(shuffled(rows()))}>
+        <text color="#8899aa" fontSize={14}>Tap here to shuffle, a row to remove it</text>
+      </view>
+      <For each={rows()}>
+        {(label) => (
+          <view
+            x={0}
+            opacity={1}
+            transition={{ layout: SLIDE, x: ARRIVE, opacity: FADE }}
+            height={48}
+            justifyContent="center"
+            paddingLeft={16}
+            onPointerDown={() => setRows(rows().filter((row) => row !== label))}
+          >
+            <d-rect color="#2a3a55" radius={10} />
+            <text color="#e8eef6" fontSize={18}>{label}</text>
+          </view>
+        )}
+      </For>
+      <view height={40} justifyContent="center" transition={{ layout: SLIDE }} onPointerDown={addRow}>
+        <text color="#8899aa" fontSize={14}>Tap here to add a row back</text>
+      </view>
+    </window>
+  )
+}
+
+render(() => <App />)

package/examples/stagger.tsx

@@ -1,16 +1,24 @@
 // Enter, exit and stagger are declared on elements; the runtime plays them
 // with no per-frame JS. `from` is the value a property animates in from at
-// first attach, `exit` the value it animates to on removal - the node stays
-// painted until that settles, then frees. Both are per-property entries on
-// the element's own transition spec. `stagger` (ms) goes on an ANCESTOR,
-// never on the animating elements: every descendant enter or exit that
-// begins in the same frame gets index * stagger of extra delay, in
-// occurrence order. It cascades nothing on its own - the descendants must
-// declare from/exit.
+// first attach, `exit` the value it animates to on removal. Both are
+// per-property entries on the element's own transition spec. An exit
+// reaches the whole removed subtree: every `exit` declared under the node
+// that unmounts plays, and that node stays painted until the last of them
+// settles, then frees. It leaves the layout at once, so a fresh panel
+// mounted mid-exit takes its place while the old one fades over it. The
+// rows below never unmount one by one - the panel around them does - and
+// they still leave the way they arrived. Each direction owns its motion:
+// `from`/`exit` take a bare value (the entry's curve, duration and delay)
+// or `{ value, curve?, duration?, bounce?, delay? }`, so the fade below
+// eases out on the way in and eases in, shorter, on the way out.
+// `stagger` (ms) goes on an ANCESTOR, never on the animating elements: every
+// descendant enter or exit that begins in the same frame gets index * stagger
+// of extra delay, in tree order. It cascades nothing on its own - the
+// descendants must declare from/exit.
 //
 // An enter plays once per mount. To replay it, remount the subtree: a keyed
 // <Show> re-creates its child whenever `when` changes value, so bumping an
-// epoch replays the whole cascade. Tap anywhere: odd taps unmount the list
+// epoch replays the whole cascade. Tap anywhere: odd taps unmount the panel
 // (staggered exits), even taps mount a fresh one (staggered enters).
 import { render, createSignal, Show } from "@solidrt/core"
 import type { Transition } from "@solidrt/core"
@@ -18,25 +26,33 @@ import type { Transition } from "@solidrt/core"
 const ROWS = ["Signals", "Effects", "Memos", "Stores", "Boundaries"]
 // Extra delay per row before its enter or exit starts.
 const STAGGER_MS = 70
-// Slide in from the left, out to the right; fade both ways.
+// Slide in from the left, out to the right; fade both ways, the exit on
+// its own curve and clock.
 const SLIDE = { duration: 500, bounce: 0.2, from: -80, exit: 80 } satisfies Transition
-const FADE = { duration: 350, curve: "ease-out", from: 0, exit: 0 } satisfies Transition
+const FADE = {
+  duration: 350,
+  curve: "ease-out",
+  from: 0,
+  exit: { value: 0, curve: "ease-in", duration: 200 },
+} satisfies Transition
 
 function App() {
   let [epoch, setEpoch] = createSignal(1)
 
   return (
-    <window padding={40} gap={12} onPointerDown={() => setEpoch((e) => e + 1)} transition={{ stagger: STAGGER_MS }}>
+    <window padding={40} gap={12} onPointerDown={() => setEpoch((e) => e + 1)}>
       <text color="#8899aa" fontSize={14}>Tap to replay</text>
       <Show when={epoch() % 2 === 1 ? epoch() : 0} keyed>
-        {(_epoch) =>
-          ROWS.map((label) => (
-            <view x={0} opacity={1} transition={{ x: SLIDE, opacity: FADE }} height={48} justifyContent="center" paddingLeft={16}>
-              <d-rect color="#2a3a55" radius={10} />
-              <text color="#e8eef6" fontSize={18}>{label}</text>
-            </view>
-          ))
-        }
+        {(_epoch) => (
+          <view gap={12} transition={{ stagger: STAGGER_MS }}>
+            {ROWS.map((label) => (
+              <view x={0} opacity={1} transition={{ x: SLIDE, opacity: FADE }} height={48} justifyContent="center" paddingLeft={16}>
+                <d-rect color="#2a3a55" radius={10} />
+                <text color="#e8eef6" fontSize={18}>{label}</text>
+              </view>
+            ))}
+          </view>
+        )}
       </Show>
     </window>
   )

package/package.json

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

package/src/environment.ts

@@ -37,6 +37,8 @@ export type SystemTheme = "dark" | "light" | "unknown"
 
 export type Visibility = "visible" | "hidden"
 
+export type Launch = "fresh" | "restored"
+
 export type Orientation = "portrait" | "portraitFlipped" | "landscape" | "landscapeFlipped" | "unknown"
 
 let devicesAccessor: (() => InputDevices | undefined) | undefined
@@ -65,6 +67,22 @@ function ensureSystemThemeState() {
   })
 }
 
+// Fixed for the process, so a plain value rather than a signal: the sticky
+// `launch` event replays synchronously on subscribe, and the runner emits it
+// before any app code runs.
+let launchValue: Launch | undefined
+
+function ensureLaunchState() {
+  if (launchValue) return
+  runWithOwner(null, () => {
+    on("launch", (e: { state?: Launch }) => {
+      launchValue = e.state === "restored" ? "restored" : "fresh"
+    })
+  })
+  // A runtime that reports no launch fact (desktop today) launches fresh.
+  launchValue ??= "fresh"
+}
+
 let visibilityAccessor: (() => Visibility) | undefined
 
 function ensureVisibilityState() {
@@ -218,15 +236,27 @@ export let env = {
    * `visibilityState` vocabulary without the `document` machinery - react
    * to it in a tracked scope (JSX, memo, effect).
    *
-   * This is the persistence moment: there is no close event on any
-   * platform (Android gives no time, desktop window close never enters
-   * JS), so save state when this goes "hidden". While hidden, timers keep
-   * running but no frames are produced.
+   * A rendering and UI fact (nothing is on screen: stop animating, pause
+   * the audio), not the persistence moment - that is `onSuspend`, which the
+   * runtime waits for. While hidden no frames are produced.
    */
   get visibility(): Visibility {
     ensureVisibilityState()
     return visibilityAccessor!()
   },
+  /**
+   * How this process came to run. "restored": the system recreated the app
+   * from a session it ended on its own (a suspended app reclaimed in the
+   * background; Android's saved instance state). "fresh": launched anew, a
+   * first start or one after `exit()` or a close ended the previous
+   * instance, and always on desktop. Reported, not interpreted: whether to
+   * load what `onSuspend` saved is the app's decision. Fixed for the
+   * process, so it needs no tracked scope.
+   */
+  get launch(): Launch {
+    ensureLaunchState()
+    return launchValue!
+  },
   /** Orientation of the display the window is on. */
   get orientation(): Orientation {
     ensureOrientationState()