nuspace 0.7.2__tar.gz → 0.7.3__tar.gz

{nuspace-0.7.2 → nuspace-0.7.3}/CHANGELOG.md

@@ -2,13 +2,39 @@
 
 ## Packages shipped from this repo
 
-- **nuspace** (the runtime, the `nuspace` command) — 0.7.2
-- **nuspace-ui** (the compiled web bundle) — 0.7.2
+- **nuspace** (the runtime, the `nuspace` command) — 0.7.3
+- **nuspace-ui** (the compiled web bundle) — 0.7.3
 
 Below is the changelog for **nuspace** - the full commit stream. Newest first.
 The `nuspace-ui` wheel is the same source tree's vite output and is not tracked
 separately here.
 
+## 0.7.3 - 2026-11-16
+
+- Release nuspace and nuspace-ui 0.7.3
+- Home's Recent timeline shows the last hour, so long runs never hide short ones
+- System planes get minted ids, reserved keys and readable titles, found by key
+- Home execution rows and timeline lanes name their plane without linking to it
+- Sidebar hover buttons shrink to the fold chevron's size, rows and titles alike
+- Boot skeleton gets its top gap back above the title
+
+- Drop unused cell and status wire fields; ref classes cover every feed op
+- Cells can make their pane follow the bottom or scroll, for chat style output
+- Opening a deep plane opens its sidebar folders, and only the sidebar reads its tree
+- Each open pane is its own node, so a rename no longer resends its cells
+- Pane menu Width choice now reaches the server and sticks
+- Urls are /p/<plane> and /d/<desk>; old plane links now read page not found
+- Plane and cell ids given from outside must be slugs, so they read cleanly in urls
+- Add plane and / menus fold packages by focus, with flat rows that wrap
+- Pane breadcrumbs come from the server, so they show under collapsed sidebar branches
+- Desk header shows only the desk name and close; items stay in the sidebar
+- Search runs on Enter in any filter, on the new nu input contract
+- Option Cmd click opens a plane to the side; panes get a close button again
+- Desks get a header to switch items and leave; panes close from their menu
+- Sidebar drops say what they do, refuse with a reason, and never shift rows
+- Flat desk shell, one plane frame, and a page, board or full width setting
+- Plane width replaces the compact and full width flags; update specs that set them
+
 ## 0.7.2 - 2026-11-13
 
 - Release nuspace and nuspace-ui 0.7.2

{nuspace-0.7.2 → nuspace-0.7.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: nuspace
-Version: 0.7.2
+Version: 0.7.3
 Summary: Computational space for your data and tools.
 Project-URL: Repository, https://github.com/nustackdev/nuspace
 Author-email: Gor Arakelyan <gorarkln@gmail.com>
@@ -17,16 +17,16 @@ Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.10
 Requires-Dist: certifi>=2023.7.22
 Requires-Dist: click>=8.0
-Requires-Dist: nucore>=0.7.4
-Requires-Dist: nuspace-ui>=0.7.2
-Requires-Dist: nustd[kv,mp-pool,proxy,ui,valkey]>=0.7.4
-Requires-Dist: nuverse>=0.3.10
+Requires-Dist: nucore>=0.7.5
+Requires-Dist: nuspace-ui>=0.7.3
+Requires-Dist: nustd[kv,mp-pool,proxy,ui,valkey]>=0.7.5
+Requires-Dist: nuverse>=0.3.11
 Requires-Dist: rich-click>=1.6
 Requires-Dist: rich>=10.7
 Requires-Dist: typing-extensions>=4.7.0
 Requires-Dist: virtuals-py[redis]>=0.2.2
 Provides-Extra: all
-Requires-Dist: nustd[all]>=0.7.4; extra == 'all'
+Requires-Dist: nustd[all]>=0.7.5; extra == 'all'
 Description-Content-Type: text/markdown
 
 <div align="center">

{nuspace-0.7.2 → nuspace-0.7.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "nuspace"
-version = "0.7.2"
+version = "0.7.3"
 description = "Computational space for your data and tools."
 readme = "README.md"
 license = "AGPL-3.0-or-later"
@@ -14,17 +14,17 @@ dependencies = [
     # The fabrics a space runs on, nothing more: kv for the store, valkey for
     # its change notifications, ui for the browser, mp_pool for the workers,
     # proxy (invisibles) for the worker's session.
-    "nucore>=0.7.4",
-    "nustd[kv,ui,valkey,mp_pool,proxy]>=0.7.4",
+    "nucore>=0.7.5",
+    "nustd[kv,ui,valkey,mp_pool,proxy]>=0.7.5",
     # The store's change notifications run over virtuals' redis backend.
     "virtuals-py[redis]>=0.2.2",
     # The compiled web bundle. A separate distribution only because PyPI caps
     # project size and a SPA rebuilt on every UI tweak would eat the quota --
     # not optional. `pip install nuspace` gives you the browser.
-    "nuspace-ui>=0.7.2",
+    "nuspace-ui>=0.7.3",
     # The everyday Planes and Cells. A plugin like any other, found through
     # its entry point, but every space ships with it.
-    "nuverse>=0.3.10",
+    "nuverse>=0.3.11",
     "typing-extensions>=4.7.0",
     "click>=8.0",
     "rich>=10.7",
@@ -55,7 +55,7 @@ classifiers = [
 [project.optional-dependencies]
 # Every nustd fabric and kv backend, for cells that reach past the defaults.
 all = [
-    "nustd[all]>=0.7.4",
+    "nustd[all]>=0.7.5",
 ]
 
 [project.urls]

{nuspace-0.7.2 → nuspace-0.7.3}/src/nuspace/host/presets.py

@@ -102,7 +102,10 @@ def with_plane(
     def opened(plane: nu.ObjectRef) -> nu.Nu:
         steps = [_plane_of(found, plane)]
         if web and open_browser:
-            url = nu.Str(f"http://{host}:{port}/") + nu.Str(plane)
+            # The web device's own url, so the tab opens on the same encoded path a link would.
+            from nuspace.web.interactions import Href
+
+            url = nu.Str(f"http://{host}:{port}") + nu.Str(Href(plane, {}))
             steps.append(Browse(url, host, port))
         return nu.Sequential(*steps, nu.Park())
 

{nuspace-0.7.2 → nuspace-0.7.3}/src/nuspace/ops/cell.py

@@ -21,6 +21,7 @@ from nuspace.shapes.space import Space
 from nuspace.utils import MintId, Require, anchor_of, place
 from nuspace.utils.checks import (
     anchored,
+    id_spelled,
     key_free,
     key_spelled,
     live,
@@ -91,7 +92,7 @@ def add(
     Args:
         plane: The plane it goes on.
         prog: Its source.
-        id: Its id. Minted when the op evaluates when absent.
+        id: Its id, key chars. Minted when the op evaluates when absent.
         before: A cell of the plane to place it before.
         after: A cell of the plane to place it after. Neither: the end.
         name: Display text only.
@@ -109,8 +110,8 @@ def add(
         Exists: The id or the key is taken.
         Missing: No plane or anchor with that id.
         Removed: The plane or the anchor is removed.
-        Refused: An anchor on another plane, a key that is not key chars
-            (a literal at build).
+        Refused: An anchor on another plane, an id or a key that is not
+            key chars (a literal at build).
         TypeError: Both ``before`` and ``after``, at build.
     """
     anchor = anchor_of(before, after)
@@ -136,7 +137,8 @@ def add(
             )
 
         writes = (
-            refuse(rows.contains(cid), Exists, "cell ", cid, " exists")
+            id_spelled(cid, "cell")
+            >> refuse(rows.contains(cid), Exists, "cell ", cid, " exists")
             >> live(Space.planes, plane, "plane")
             >> anchored(listed, rows, anchor, cid, "cell", text("plane ", plane))
             >> spelled

{nuspace-0.7.2 → nuspace-0.7.3}/src/nuspace/ops/plane.py

@@ -25,6 +25,7 @@ from nuspace.shapes.space import Space
 from nuspace.utils import MintId, Require, anchor_of, place
 from nuspace.utils.checks import (
     anchored,
+    id_spelled,
     key_free,
     key_spelled,
     live,
@@ -39,6 +40,7 @@ from nuspace.utils.tree import no_cycle, subtree
 __all__ = [
     "add",
     "exists",
+    "keyed",
     "move",
     "on_change",
     "on_children_change",
@@ -74,23 +76,34 @@ def _icon_spelled(icon: nu.StrArg) -> None:
         raise Refused(msg)
 
 
-def _reserved(id: nu.StrArg, system: nu.BoolArg) -> nu.Nu:
-    """Refuse an id no new plane may take: root's, ``""``, or a :data:`RESERVED` one for a user plane.
+def _reserved(id: nu.StrArg) -> nu.Nu:
+    """Refuse an id no plane may take: root's or ``""``.
 
     Raises:
         Refused: A literal at build, a term at run time.
     """
     if isinstance(id, str):
-        user = system is False
-        if id in (ROOT, "") or (user and id in RESERVED):
+        if id in (ROOT, ""):
             msg = f"plane id {id!r} is reserved"
             raise Refused(msg)
-        if system is True or id not in RESERVED:
-            return nu.Noop()
+        return nu.Noop()
     pid = nu.Str(id)
-    always = (pid == ROOT).or_(pid == "")
-    taken = nu.List.of(*sorted(RESERVED)).contains(pid).and_(nu.Bool(system).not_())
-    return refuse(always.or_(taken), Refused, "plane id ", id, " is reserved")
+    return refuse((pid == ROOT).or_(pid == ""), Refused, "plane id ", id, " is reserved")
+
+
+def _key_reserved(key: nu.StrArg, system: nu.BoolArg) -> nu.Nu:
+    """Refuse a :data:`RESERVED` key for a plane that is not system.
+
+    Raises:
+        Refused: A literal at build, a term at run time.
+    """
+    if isinstance(key, str) and isinstance(system, bool):
+        if key in RESERVED and not system:
+            msg = f"plane key {key!r} is reserved"
+            raise Refused(msg)
+        return nu.Noop()
+    taken = nu.List.of(*sorted(RESERVED)).contains(key).and_(nu.Bool(system).not_())
+    return refuse(taken, Refused, "plane key ", key, " is reserved")
 
 
 def _not_root(id: nu.StrArg, doing: str) -> nu.Nu:
@@ -134,7 +147,7 @@ def add(
     when given. Cost: O(1), about 20 keys.
 
     Args:
-        id: Its id. Minted when the op evaluates when absent.
+        id: Its id, key chars. Minted when the op evaluates when absent.
         parent: The plane it hangs under.
         before: A sibling to place it before.
         after: A sibling to place it after. Neither: the end.
@@ -143,8 +156,8 @@ def add(
             case-sensitive, ``""`` for none.
         icon: ``lucide:<name>`` or ``emoji:<char>``. ``""``: :data:`DEFAULT_ICON`.
         backend: What its runs execute on. ``""``: it does not run.
-        system: Protected: ``remove`` refuses it. Only a system plane takes
-            a :data:`~nuspace.shapes.plane.RESERVED` id.
+        system: Protected: ``remove`` refuses it. Only a system plane holds
+            a :data:`~nuspace.shapes.plane.RESERVED` key.
         spec: The spec it was made from, ``""`` for none.
         meta: The free dict, for programs. nuspace never reads it.
         into: A ref set to the id in the same commit, for a minted one.
@@ -153,10 +166,10 @@ def add(
         Exists: The id or the key is taken.
         Missing: No parent or anchor with that id.
         Removed: The parent or the anchor is removed.
-        Refused: A reserved id (root's, ``""``, or one of
-            :data:`~nuspace.shapes.plane.RESERVED` unless ``system``), an
-            anchor that is not a sibling, a key that is not key chars, an
-            icon spelled wrong. A literal at build.
+        Refused: A reserved id (root's or ``""``), a
+            :data:`~nuspace.shapes.plane.RESERVED` key unless ``system``, an
+            id or a key that is not key chars, an anchor that is not a
+            sibling, an icon spelled wrong. A literal at build.
         TypeError: Both ``before`` and ``after``, at build.
     """
     anchor = anchor_of(before, after)
@@ -186,11 +199,13 @@ def add(
             )
 
         writes = (
-            _reserved(pid, system)
+            _reserved(pid)
+            >> id_spelled(pid, "plane")
             >> refuse(rows.contains(pid), Exists, "plane ", pid, " exists")
             >> live(rows, parent, "plane")
             >> anchored(siblings, rows, anchor, pid, "plane", text("plane ", parent))
             >> spelled
+            >> _key_reserved(key, system)
             >> key_free(Space.indexes.plane_keys, key, None, "plane")
             >> nu.let(nustd.time.time(), made)
             >> place(siblings, pid, before=before, after=after)
@@ -308,7 +323,9 @@ def set_key(id: nu.StrArg, key: nu.StrArg) -> nu.Nu:
         Missing: No plane with that id.
         Removed: It is removed.
         Exists: Another plane holds the key.
-        Refused: An empty key, or one not in key chars. A literal at build.
+        Refused: An empty key, or one not in key chars, a literal at build.
+            A :data:`~nuspace.shapes.plane.RESERVED` key on a plane that is
+            not system.
     """
     spelled = key_spelled(key, "plane", empty_ok=False)
     index = Space.indexes.plane_keys
@@ -317,6 +334,7 @@ def set_key(id: nu.StrArg, key: nu.StrArg) -> nu.Nu:
     return (
         spelled
         >> live(Space.planes, id, "plane")
+        >> _key_reserved(key, row.system.fallback(False))
         >> key_free(index, key, id, "plane")
         >> nu.IfDo((old != "").and_(old != key), index.del_item(old))
         >> index.set_item(key, id)
@@ -391,6 +409,11 @@ def exists(id: nu.StrArg, *, removed: bool = False) -> nu.Bool:
     return there if removed else there.and_(Space.planes[id].removed_at.exists().not_())
 
 
+def keyed(key: nu.StrArg) -> nu.Str:
+    """The id of the live plane holding ``key``, ``""`` when none does. A read. Cost: O(1), 1 point read."""
+    return nu.Str(Space.indexes.plane_keys.get_item(key, ""))
+
+
 def title(id: nu.StrArg) -> nu.Str:
     """What a list or a header shows for a plane: its name, else its id. Cost: O(1), 2 reads.
 

{nuspace-0.7.2 → nuspace-0.7.3}/src/nuspace/shapes/plane.py

@@ -14,12 +14,12 @@ __all__ = ["RESERVED", "ROOT", "Plane"]
 #: remove), has no backend (no run) and no parent of its own (``""``).
 ROOT = "root"
 
-#: Plane ids only nuspace's own planes take: ``plane.add`` refuses them
-#: unless ``system=True``. The system planes' (``nuspace.system``), then the
-#: web device's (``nuspace.web.planes``): the searches folder, the
-#: home indexer and the desk pruner. Home, search and settings have minted
-#: ids, found through the web device's roles. Root's id and ``""`` are
-#: refused for every add.
+#: Plane keys only nuspace's own planes hold: ``plane.add`` and ``plane.set_key``
+#: refuse them unless the plane is system. The system planes'
+#: (``nuspace.system``), then the web device's (``nuspace.web.planes``): the
+#: searches folder, the home indexer and the desk pruner. Their ids are
+#: minted like any plane's; code finds them by key. Home, search and
+#: settings are found through the web device's roles.
 RESERVED = frozenset(
     {
         "init",

{nuspace-0.7.2 → nuspace-0.7.3}/src/nuspace/specs/ops.py

@@ -129,8 +129,7 @@ def _web_row(pid: nu.Str, spec: PlaneSpec) -> nu.Nu:
     return web.add(
         pid,
         editable=flags.editable,  # type: ignore[union-attr]
-        full_width=flags.full_width,  # type: ignore[union-attr]
-        compact=flags.compact,  # type: ignore[union-attr]
+        width=flags.width,  # type: ignore[union-attr]
     )
 
 

{nuspace-0.7.2 → nuspace-0.7.3}/src/nuspace/specs/specs.py

@@ -16,7 +16,7 @@ spec says how a space presents it.
 from __future__ import annotations
 
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, Literal
 
 import nu
 import nustd.kv
@@ -38,13 +38,13 @@ class WebOptions:
 
     Args:
         editable: Its cells can be edited in the browser.
-        full_width: It takes the whole width of a pane.
-        compact: It draws its cells tight.
+        width: How wide its content runs in a pane, at most: ``page`` (the
+            reading measure), ``board`` (a dashboard's) or ``full`` (the
+            whole pane).
     """
 
     editable: bool = True
-    full_width: bool = False
-    compact: bool = False
+    width: Literal["page", "board", "full"] = "page"
 
 
 class SpecCells(nu.Shape):
@@ -123,7 +123,7 @@ EMPTY_PLANE = PlaneSpec(
     "",
     "Empty",
     description="An empty plane. Add cells with /, or nest planes under it.",
-    web=WebOptions(editable=True, full_width=False),
+    web=WebOptions(editable=True),
     backend="async",
 )
 

nuspace-0.7.3/src/nuspace/system/init/__init__.py

@@ -0,0 +1,12 @@
+"""``nuspace.system.init``: the system plane that starts planes when the space opens.
+
+- ops: :func:`boot`, :func:`unboot`, over the boot list (:class:`Boot`).
+- :mod:`.plane`: the plane's cell and its driver.
+"""
+
+from .ops import boot, unboot
+from .plane import BOOTED, BY, driver
+from .shapes import KEY, Boot, boot_list
+
+
+__all__ = ["BOOTED", "BY", "KEY", "Boot", "boot", "boot_list", "driver", "unboot"]

{nuspace-0.7.2 → nuspace-0.7.3}/src/nuspace/system/init/plane.py

@@ -1,6 +1,6 @@
 """The init plane: starts the planes on its boot list when the space opens.
 
-One cell, :data:`CELL`, runs :func:`driver`. The host asks for init's own
+One cell, ``main``, runs :func:`driver`. The host asks for init's own
 plane run at open (``nuspace.system.start``); init asks for the rest. A
 plane on the boot list (:class:`~.shapes.Boot`) gets one plane run ``by``
 init in every open, unless it already ran in this open:
@@ -35,22 +35,20 @@ from nuspace.utils import keys_of
 from nuspace.utils.policies import report, restarting
 
 from .. import supervisor
-from .shapes import PLANE, boot_list
+from .shapes import KEY, boot_list
 
 
-__all__ = ["BACKEND", "BOOTED", "BY", "CELL", "PROG", "driver"]
+__all__ = ["BACKEND", "BOOTED", "BY", "PROG", "driver"]
 
 
-#: Its one cell's id, fixed.
-CELL = "init_main"
-
 #: What its runs execute on.
 BACKEND = "mp"
 
 #: What the plane runs init asks for are recorded as ``by``.
 BY = "init"
 
-#: What the boot list starts as, the first time the system planes are made.
+#: What the boot list starts as, the first time the system planes are made: plane keys,
+#: written as the ids they find.
 BOOTED = ("supervisor", "reload", "reactions")
 
 #: The cell's prog: the driver lives here, the store holds this.
@@ -69,7 +67,7 @@ def _supervised(plane: nu.Str) -> nu.Bool:
     The supervisor plane itself is never skipped: init is what brings it up.
     """
     policy = supervisor.supervised()[plane].policy
-    return policy.exists().and_(plane != supervisor.PLANE)
+    return policy.exists().and_(plane != ops.plane.keyed(supervisor.KEY))
 
 
 def _due(plane: nu.Str) -> nu.Bool:
@@ -93,7 +91,7 @@ def _due(plane: nu.Str) -> nu.Bool:
 def _up(plane: nu.Str) -> nu.Nu:
     """One listed plane run if it is due, check and run in one commit. A raise is reported."""
     up = atomic(nu.IfDo(_due(plane), ops.plane_run.add(plane, by=BY)))
-    return nu.TryCatch(up, catch=lambda err: report(PLANE, plane, err))
+    return nu.TryCatch(up, catch=lambda err: report(KEY, plane, err))
 
 
 def driver() -> nu.Nu:
@@ -103,7 +101,7 @@ def driver() -> nu.Nu:
     raise outside a plane's step (reading the list) is reported and the
     driver runs again (``restarting``).
     """
-    planes = boot_list()
+    planes = boot_list(here=True)
     listed = keys_of(planes)
     one_pass = nu.ForEachDo(atomic(listed), lambda p: _up(nu.Str(p)))
     flow = nu.Reconcile(
@@ -112,4 +110,4 @@ def driver() -> nu.Nu:
         after=nu.RECHECK_AFTER,
         every=nu.RECHECK_EVERY,
     )
-    return restarting(flow, PLANE)
+    return restarting(flow, KEY)

nuspace-0.7.3/src/nuspace/system/init/shapes.py

@@ -0,0 +1,33 @@
+"""init's own state: the plane's key and the boot list, kept in the init plane's state."""
+
+from __future__ import annotations
+
+import nu
+import nustd.kv
+from nuspace.places import at
+
+
+__all__ = ["KEY", "Boot", "boot_list"]
+
+
+#: The plane's key. Its id is minted when it is made; code finds it by this.
+KEY = "init"
+
+
+class Boot(nu.Shape):
+    """init's state, in the init plane's state.
+
+    ``planes`` is the boot list: the ids of the planes init runs at every
+    open, a set (dict of bool, point add and delete). Reach it through the
+    plane's place: ``nuspace.at.plane(init.KEY).state(Boot).planes``.
+    """
+
+    planes = nustd.kv.DictRef.slot(bool)
+
+
+def boot_list(*, here: bool = False) -> nu.Nu:
+    """The boot list's ref, found by key: one index read. ``here``: the running plane's, no read.
+
+    ``here`` is for init's own cell; every other caller finds the plane by key.
+    """
+    return (at.plane if here else at.plane(KEY)).state(Boot).planes

nuspace-0.7.3/src/nuspace/system/planes.py

@@ -0,0 +1,94 @@
+"""The system planes as a set: made where missing, and init started. What the host runs at open.
+
+Each system plane has a minted id like any plane, a key code finds it by
+(``nuspace.at.plane(KEY)``, ``ops.plane.keyed(KEY)``), a title, is
+``system`` (remove refuses it, only it holds a reserved key) and holds
+cells whose progs are short shims: the code lives in
+``nuspace.system.<plane>``, the store holds the shim. init's boot list
+starts as the other three, so init brings them up:
+
+    host        ensure() >> start()
+    init        boots supervisor, reload, reactions
+"""
+
+from __future__ import annotations
+
+import nu
+from nuspace import ops
+from nuspace.ops.brackets import atomic
+from nuspace.utils import MintId
+
+from . import init, reactions, reload, supervisor
+from .init.plane import BACKEND as INIT_BACKEND
+from .init.plane import PROG as INIT_PROG
+from .reactions.plane import BACKEND as REACTIONS_BACKEND
+from .reactions.plane import PARK_PROG
+from .reload.plane import BACKEND as RELOAD_BACKEND
+from .reload.plane import PROG as RELOAD_PROG
+from .supervisor.plane import BACKEND as SUPERVISOR_BACKEND
+from .supervisor.plane import PROG as SUPERVISOR_PROG
+
+
+__all__ = ["BY", "PLANES", "ensure", "start"]
+
+
+#: Every system plane: ``(key, title, backend, ((cell name, prog), ...))``. init first.
+PLANES = (
+    (init.KEY, "Init", INIT_BACKEND, (("main", INIT_PROG),)),
+    (supervisor.KEY, "Supervisor", SUPERVISOR_BACKEND, (("main", SUPERVISOR_PROG),)),
+    (reload.KEY, "Reload", RELOAD_BACKEND, (("main", RELOAD_PROG),)),
+    (reactions.KEY, "Reactions", REACTIONS_BACKEND, (("park", PARK_PROG),)),
+)
+
+#: What init's own plane run is recorded as ``by`` when :func:`start` asks for it.
+BY = "host"
+
+
+def _made(key: str, title: str, backend: str, cells: tuple[tuple[str, str], ...]) -> nu.Nu:
+    """One system plane and its cells, minted ids, when no plane holds its key. One commit."""
+
+    def made(minted: nu.ObjectRef) -> nu.Nu:
+        plane = nu.Str(minted)
+        adds = ops.plane.add(plane, key=key, name=title, backend=backend, system=True)
+        for name, prog in cells:
+            adds = adds >> ops.cell.add(plane, prog, name=name, fabrics=[])
+        return adds
+
+    return atomic(nu.IfDo(ops.plane.keyed(key) == "", nu.let(MintId("p"), made)))
+
+
+def ensure() -> nu.Nu:
+    """Every system plane and its cells, then their state's containers, made where missing.
+
+    Idempotent: a plane is made only when no plane holds its key, and what
+    is there is left exactly as it is, init's boot list included (it is data
+    somebody may have edited). The boot list starts as the ids of
+    :data:`~nuspace.system.init.BOOTED`'s planes the first time. One commit
+    per plane, then one State commit.
+    """
+    made = nu.Sequential(*(_made(*spec) for spec in PLANES))
+    booted = init.boot_list()
+    first = nu.Sequential(
+        booted.init({}),
+        *(booted.set_item(ops.plane.keyed(key), True) for key in init.BOOTED),
+    )
+    state = (
+        nu.IfDo(booted.exists().not_(), first)
+        >> supervisor.supervised().init({})
+        >> reactions.registry().by_plane.init({})
+    )
+    return made >> atomic(state)
+
+
+def start(*, by: nu.StrArg = BY) -> nu.Nu:
+    """A plane run of init asked for, unless it has a live one. One commit. The kernel runs it.
+
+    Args:
+        by: Who asks, what the run is recorded as.
+
+    Raises:
+        Missing: No init plane: :func:`ensure` first.
+    """
+    plane = ops.plane.keyed(init.KEY)
+    idle = ops.plane_run.any_live(plane).not_()
+    return atomic(nu.IfDo(idle, ops.plane_run.add(plane, by=by)))

{nuspace-0.7.2 → nuspace-0.7.3}/src/nuspace/system/reactions/__init__.py

@@ -1,18 +1,17 @@
 """``nuspace.system.reactions``: the system plane that runs a plane when something changes.
 
 - ops: :func:`add`, :func:`remove`, :func:`clear`; :func:`source`, a reaction's prog.
-- :mod:`.plane`: the plane's ids, its park cell, :func:`react` (a reaction's program) and :func:`up_plane`.
+- :mod:`.plane`: its park cell, :func:`react` (a reaction's program) and :func:`up_plane`.
 - shapes: :class:`Registry` (by plane), :class:`Reaction` (a reaction's plane and run).
 """
 
 from .ops import add, clear, remove, source
-from .plane import PARK, react, up_plane
-from .shapes import PLANE, Reaction, ReactionIds, Registry, registry
+from .plane import react, up_plane
+from .shapes import KEY, Reaction, ReactionIds, Registry, registry
 
 
 __all__ = [
-    "PARK",
-    "PLANE",
+    "KEY",
     "Reaction",
     "ReactionIds",
     "Registry",

{nuspace-0.7.2 → nuspace-0.7.3}/src/nuspace/system/reactions/ops.py

@@ -26,7 +26,7 @@ from nuspace.shapes import Space
 from nuspace.utils import MintId, keys_of
 from nuspace.utils.checks import live, refuse
 
-from .shapes import PLANE, Reaction, registry
+from .shapes import KEY, Reaction, registry
 
 
 if TYPE_CHECKING:
@@ -127,7 +127,7 @@ def add(
             >> at.cell(id=reaction).state(Reaction).plane.set(plane)
             >> registry().by_plane[plane].ids.set_item(reaction, True)
         )
-        cell = ops.cell.add(PLANE, src, id=reaction, name=plane, fabrics=[])
+        cell = ops.cell.add(ops.plane.keyed(KEY), src, id=reaction, name=plane, fabrics=[])
         steps = atomic(kept) >> atomic(cell)
         if into is not None:
             steps = steps >> atomic(into.set(reaction))
@@ -141,7 +141,7 @@ def add(
 def _known(reaction: nu.StrArg) -> nu.Bool:
     """Whether ``reaction`` is a live reaction: a cell on the reactions plane, not removed, with its plane kept."""
     row = Space.cells[reaction]
-    on = row.plane.fallback("") == PLANE
+    on = row.plane.fallback("") == ops.plane.keyed(KEY)
     kept = at.cell(id=reaction).state(Reaction).plane.exists()
     return on.and_(row.removed_at.exists().not_()).and_(kept)
 

{nuspace-0.7.2 → nuspace-0.7.3}/src/nuspace/system/reactions/plane.py

@@ -1,7 +1,7 @@
 """The reactions plane: runs a plane when something changes. No engine of its own.
 
 The plane runs its cells like any plane, on the ``async`` backend, and
-init boots it. Its first cell, :data:`PARK`, runs ``nu.Park()``: it never
+init boots it. Its first cell, ``park``, runs ``nu.Park()``: it never
 ends, so the plane run stays live with no reactions at all, and reload
 gives each new reaction cell its first run in it. Every other cell is a
 reaction (see :mod:`.ops`), whose program is :func:`react`::
@@ -30,15 +30,12 @@ from nuspace.places import at
 from nuspace.shapes import Space
 from nuspace.utils.policies import restarting
 
-from .shapes import PLANE, Reaction
+from .shapes import KEY, Reaction
 
 
-__all__ = ["BACKEND", "PARK", "PARK_PROG", "react", "up_plane"]
+__all__ = ["BACKEND", "PARK_PROG", "react", "up_plane"]
 
 
-#: Its fixed first cell, the one that keeps its run live.
-PARK = "reactions_park"
-
 #: What its runs execute on.
 BACKEND = "async"
 
@@ -99,4 +96,4 @@ def react(change: nu.Nu, plane: nu.StrArg, reaction: nu.StrArg) -> nu.Nu:
         reaction: The reaction's id.
     """
     flow = nu.ReactEvery(atomic(change), up_plane(plane, reaction))
-    return restarting(flow, PLANE, reaction)
+    return restarting(flow, KEY, reaction)