nuspace 0.6.2__tar.gz → 0.6.4__tar.gz

{nuspace-0.6.2 → nuspace-0.6.4}/CHANGELOG.md

@@ -2,13 +2,33 @@
 
 ## Packages shipped from this repo
 
-- **nuspace** (the runtime, the `nuspace` command) — 0.6.2
-- **nuspace-ui** (the compiled web bundle) — 0.5.8
+- **nuspace** (the runtime, the `nuspace` command) — 0.6.4
+- **nuspace-ui** (the compiled web bundle) — 0.6.4
 
 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.6.4 - 2026-11-07
+
+- Release nuspace and nuspace-ui 0.6.4 on nu 0.7.1, virtuals 0.2.1 and ui-kit 0.4.0
+- Telemetry sends only known nuspace events and stays off in every major CI
+- Cmd+Enter at the end of text leaves no empty line behind
+- Writing keeps to prose islands: arrows stop at other cells, input lines join in
+- Plane menus share one layout; sidebar menu gains copy id and close items
+- Text cells read as one document: arrows cross seams, Backspace merges, Cmd+Enter splits
+- Writing in a plane: honest hints, slash in empty text, arrows across text cells
+- Move onto the new reactive flows; failing arms now restart, isolate or fail their run
+- Workers come from the hardened pool: one stop grace, no orphans, clean exit causes
+
+## 0.6.3 - 2026-11-05
+
+- Release nuspace and nuspace-ui 0.6.3 on nu 0.7.0 and virtuals 0.2.0
+- Reads of containers that may never exist give empty instead of failing
+- A space creates every fixed store container at open, so reads find them
+- Kernel, supervisor and boot list create their containers up front at open
+- Move onto nu's NULL model: absent reads checked by existence, safe defaults
+
 ## 0.6.2 — 2026-10-30
 
 - Release nuspace 0.6.2 on nu 0.6.8 and nuverse 0.3.5

{nuspace-0.6.2 → nuspace-0.6.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: nuspace
-Version: 0.6.2
+Version: 0.6.4
 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.6.8
-Requires-Dist: nuspace-ui>=0.5.8
-Requires-Dist: nustd[kv,mp-pool,proxy,ui,valkey]>=0.6.8
+Requires-Dist: nucore>=0.7.1
+Requires-Dist: nuspace-ui>=0.6.4
+Requires-Dist: nustd[kv,mp-pool,proxy,ui,valkey]>=0.7.1
 Requires-Dist: nuverse>=0.3.5
 Requires-Dist: rich-click>=1.6
 Requires-Dist: rich>=10.7
 Requires-Dist: typing-extensions>=4.7.0
-Requires-Dist: virtuals-py[redis]>=0.1.10
+Requires-Dist: virtuals-py[redis]>=0.2.1
 Provides-Extra: all
-Requires-Dist: nustd[all]>=0.6.5; extra == 'all'
+Requires-Dist: nustd[all]>=0.7.1; extra == 'all'
 Description-Content-Type: text/markdown
 
 <div align="center">

{nuspace-0.6.2 → nuspace-0.6.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "nuspace"
-version = "0.6.2"
+version = "0.6.4"
 description = "Computational space for your data and tools."
 readme = "README.md"
 license = "AGPL-3.0-or-later"
@@ -14,14 +14,14 @@ 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.6.8",
-    "nustd[kv,ui,valkey,mp_pool,proxy]>=0.6.8",
+    "nucore>=0.7.1",
+    "nustd[kv,ui,valkey,mp_pool,proxy]>=0.7.1",
     # The store's change notifications run over virtuals' redis backend.
-    "virtuals-py[redis]>=0.1.10",
+    "virtuals-py[redis]>=0.2.1",
     # 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.5.8",
+    "nuspace-ui>=0.6.4",
     # The everyday Planes and Cells. A plugin like any other, found through
     # its entry point, but every space ships with it.
     "nuverse>=0.3.5",
@@ -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.6.5",
+    "nustd[all]>=0.7.1",
 ]
 
 [project.urls]
@@ -76,6 +76,7 @@ exclude = [
 ]
 
 [tool.uv.sources]
+virtuals-py = { path = "../virtuals", editable = true }
 nuspace-ui = { path = "./pkgs/ts/nuspace-ui", editable = true }
 nucore = { path = "../nu", editable = true }
 nustd = { path = "../nu/pkgs/nustd", editable = true }

{nuspace-0.6.2 → nuspace-0.6.4}/src/nuspace/__init__.py

@@ -5,8 +5,7 @@ What a host and a program need, without knowing the layers:
 - :func:`open_space`, and what an installed package registers with: an
   :class:`Extension` of :class:`PlaneSpec`, :class:`CellSpec` and
   :class:`ContentSpec` (the store's own shapes are ``shapes.Plane`` and
-  ``shapes.Cell``), and :data:`TEXT_CELL`, ``nuverse.text``, the Cell
-  document editing works on;
+  ``shapes.Cell``);
 - :class:`Content`, a kind of findable item, ``class
   TextContent(nuspace.Content[Text], name="Text")``, registered through a
   :class:`ContentSpec` (:mod:`nuspace.content`);
@@ -23,7 +22,7 @@ Workers import this package: nothing here may pull in a server.
 
 from nuspace import content, ops, shapes, ui
 from nuspace.content import Content
-from nuspace.ext import TEXT_CELL, CellSpec, ContentSpec, Extension, PlaneSpec
+from nuspace.ext import CellSpec, ContentSpec, Extension, PlaneSpec
 from nuspace.host import open_space
 from nuspace.ops import env
 from nuspace.shapes import CellState, PlaneState, Space, States
@@ -38,7 +37,6 @@ from nuspace.system.services import (
 
 
 __all__ = [
-    "TEXT_CELL",
     "CellSpec",
     "CellState",
     "Content",

{nuspace-0.6.2 → nuspace-0.6.4}/src/nuspace/_telemetry/__init__.py

@@ -8,10 +8,12 @@
 What is sent: ``first_run`` once per user and ``space_opened`` per open, by
 the host however the space is opened (:func:`.opened`), ``space_loaded`` per
 page load in the browser (through the web device, never from the browser
-itself), and ``plane_created``, ``plane_removed``, ``cell_created``,
+itself), ``plane_created``, ``plane_removed``, ``cell_created``,
 ``cell_removed`` by the ops that do it, in whatever process runs them
-(:mod:`nuspace.ops.usage`). Each carries the versions and the machine's
-kind, nothing about the space.
+(:mod:`nuspace.ops.usage`), and the ``quickstart_*`` steps nuverse tracks
+through those ops. Each carries the versions and the machine's kind,
+nothing about the space. Those names, :data:`.send.EVENTS`, are all that is
+ever sent: any other is dropped before it is queued.
 
 Stdlib only and silent on every failure. Queuing is free and never sends:
 the sender drops everything when telemetry is off, on a dev install, under
@@ -28,14 +30,14 @@ from .config import (
     set_telemetry,
     telemetry_enabled,
 )
-from .send import PREFIX, base_properties, capture, first_run, flush, opened, track
+from .send import EVENTS, PREFIX, base_properties, first_run, flush, opened, track
 
 
 __all__ = [
     "ENV",
+    "EVENTS",
     "PREFIX",
     "base_properties",
-    "capture",
     "config_path",
     "distinct_id",
     "env_override",

{nuspace-0.6.2 → nuspace-0.6.4}/src/nuspace/_telemetry/config.py

@@ -7,8 +7,9 @@ test or a sandbox pointing ``HOME`` elsewhere gets its own.
 
 The environment only ever turns telemetry off, whatever the file says:
 ``NUSPACE_TELEMETRY`` set to ``0``, ``false`` or ``off``, ``DO_NOT_TRACK``
-set to anything but that (the cross tool convention), or ``CI`` set the same
-way, which every major CI does, so nobody's pipeline is counted as use.
+set to anything but that (the cross tool convention), or ``CI`` or a major
+CI's own variable (``GITHUB_ACTIONS``, ``JENKINS_URL``, ...) set the same
+way, so nobody's pipeline is counted as use.
 """
 
 from __future__ import annotations
@@ -42,8 +43,21 @@ ENV = "NUSPACE_TELEMETRY"
 #: What ``NUSPACE_TELEMETRY`` reads as off, case ignored.
 _OFF = frozenset({"0", "false", "off", "no"})
 
-#: Conventions that turn telemetry off when set to anything but empty or off.
-_OFF_WHEN_SET = ("DO_NOT_TRACK", "CI")
+#: Conventions that turn telemetry off when set to anything but empty or off:
+#: the cross tool one, then ``CI`` and the variables CIs set of their own.
+_OFF_WHEN_SET = (
+    "DO_NOT_TRACK",
+    "CI",
+    "GITHUB_ACTIONS",
+    "GITLAB_CI",
+    "BUILDKITE",
+    "CIRCLECI",
+    "TF_BUILD",
+    "JENKINS_URL",
+    "TEAMCITY_VERSION",
+    "CODEBUILD_BUILD_ID",
+    "BITBUCKET_BUILD_NUMBER",
+)
 
 
 def home() -> Path:

{nuspace-0.6.2 → nuspace-0.6.4}/src/nuspace/_telemetry/send.py

@@ -1,6 +1,6 @@
 """Fire and forget PostHog capture, no dependency beyond the stdlib.
 
-One sender thread per process, fed by a bounded queue. :func:`capture`
+One sender thread per process, fed by a bounded queue. :func:`track`
 puts the event's name and time on the queue and returns, O(1): it never
 waits, never touches the network or the disk, and drops the event when the
 queue is full. The thread does the rest, the properties, the id, the opt out
@@ -9,9 +9,14 @@ and the JSON, and drains what is queued into one ``/batch/`` POST at a time. Eve
 breaks because of telemetry. At exit the thread gets a short grace to send
 what is left.
 
+Only nuspace's own events are ever queued: a name not in :data:`EVENTS`,
+or anything but a str, is dropped before it reaches the queue, so no caller
+can send a name of its own.
+
 Nothing is sent when telemetry is off (see :mod:`.config`: the flag, or
-``NUSPACE_TELEMETRY``, ``DO_NOT_TRACK`` or ``CI``), on a dev install, or with no token: the thread checks before each POST and drops the
-batch. ``NUSPACE_POSTHOG_TOKEN`` and ``NUSPACE_POSTHOG_HOST`` point it at
+``NUSPACE_TELEMETRY``, ``DO_NOT_TRACK``, ``CI`` or a CI's own variable), on
+a dev install, or with no token: the thread checks before each POST and
+drops the batch. ``NUSPACE_POSTHOG_TOKEN`` and ``NUSPACE_POSTHOG_HOST`` point it at
 another PostHog project, eg to test.
 """
 
@@ -40,10 +45,10 @@ if TYPE_CHECKING:
 
 
 __all__ = [
+    "EVENTS",
     "FIRST_RUN_EVENT",
     "PREFIX",
     "base_properties",
-    "capture",
     "first_run",
     "flush",
     "opened",
@@ -65,6 +70,28 @@ _BATCH_PATH = "/batch/"
 #: What every event is sent as: the product, then what happened.
 PREFIX = "nuspace_"
 
+#: Every event that may be sent, by its name before :data:`PREFIX`. Nothing else ever is.
+EVENTS = frozenset(
+    {
+        "first_run",
+        "space_opened",
+        "space_loaded",
+        "plane_created",
+        "plane_removed",
+        "cell_created",
+        "cell_removed",
+        # nuverse's quickstart, through ``nuspace.ops.track``.
+        "quickstart_demo_opened",
+        "quickstart_page_made",
+        "quickstart_edited",
+        "quickstart_put_back",
+        "quickstart_moved",
+    }
+)
+
+#: :data:`EVENTS` as sent, prefixed.
+_SENT = frozenset(f"{PREFIX}{event}" for event in EVENTS)
+
 #: Sent once per user, retried on every open until PostHog acks it.
 FIRST_RUN_EVENT = f"{PREFIX}first_run"
 
@@ -253,11 +280,16 @@ def _the_sender() -> _Sender:
 
 
 def _queue(event: str, on_success: Callable[[], None] | None) -> None:
-    _the_sender().put((event, time.time(), on_success))
+    """Put ``event``, a prefixed name, on the queue. Every send goes through here.
+
+    A name not in :data:`EVENTS`, or anything but a str, is dropped.
+    """
+    if isinstance(event, str) and event in _SENT:
+        _the_sender().put((event, time.time(), on_success))
 
 
-def capture(event: str) -> None:
-    """Queue ``event`` for the sender thread. O(1), never waits, never raises."""
+def _capture(event: str) -> None:
+    """Queue ``event``, a prefixed name, for the sender thread. O(1), never waits, never raises."""
     try:
         _queue(event, None)
     except Exception:  # noqa: S110
@@ -265,9 +297,12 @@ def capture(event: str) -> None:
 
 
 def track(event: str) -> None:
-    """:func:`capture` ``event`` as nuspace's own, eg ``plane_created``. Anything but a str is dropped."""
+    """Queue ``event`` as nuspace's own, eg ``plane_created``. Never raises.
+
+    Anything not in :data:`EVENTS`, or not a str, is dropped.
+    """
     if isinstance(event, str):
-        capture(f"{PREFIX}{event}")
+        _capture(f"{PREFIX}{event}")
 
 
 def flush(timeout: float = _EXIT_GRACE_SECONDS) -> bool:

{nuspace-0.6.2 → nuspace-0.6.4}/src/nuspace/content/kind.py

@@ -304,7 +304,8 @@ class Content(Generic[S]):
         ``items(scope)[id]`` is :meth:`at`. The mapping is the store's own, so
         ``keys``, ``len``, ``contains`` and ``on_children_change`` read and
         watch storage, a write lands an item and ``items(scope)[id].erase()``
-        removes one. Not relative: name the running cell as
+        removes one. A scope no item ever landed in has no mapping yet:
+        ``exists()`` is False and ``len`` or ``keys`` raise. Not relative: name the running cell as
         ``(CELL, ops.Here.cell)``.
 
         Args:

{nuspace-0.6.2 → nuspace-0.6.4}/src/nuspace/content/search.py

@@ -31,6 +31,15 @@ if TYPE_CHECKING:
 __all__ = ["asked", "matched", "scopes", "walk"]
 
 
+def _ids(held: nu.Nu) -> nu.List:
+    """A mapping's keys, ``[]`` when it was never written.
+
+    A kind's level, or one scope of it, exists only once an item landed
+    there: a kind never written in a plane has no ``planes`` to list.
+    """
+    return nu.list(nu.If(held.exists(), nu.list(held.keys()), []))
+
+
 def scopes(kind: type[Content[Any]], level: str) -> nu.List:
     """The ids of the scopes at ``level`` holding items of ``kind``: cells or planes. A bare read.
 
@@ -41,7 +50,8 @@ def scopes(kind: type[Content[Any]], level: str) -> nu.List:
     if level not in SLOTS:
         msg = f"scope level {level!r} is none of {tuple(SLOTS)}"
         raise ValueError(msg)
-    return nu.list(getattr(States.contents[kind_name(kind)], SLOTS[level]).keys())
+    held = getattr(States.contents[kind_name(kind)], SLOTS[level])
+    return _ids(held)
 
 
 def matched(
@@ -59,7 +69,7 @@ def matched(
     """
     held = kind.items(scope)
     return (
-        nu.list(held.keys())
+        _ids(held)
         .iter()
         .filter(lambda found: kind.match(kind.at(scope, nu.Str(found)), **question))
     )

{nuspace-0.6.2 → nuspace-0.6.4}/src/nuspace/ext/__init__.py

@@ -27,13 +27,12 @@ from .registry import (
     short_name,
     space_registry,
 )
-from .specs import EMPTY_PLANE, TEXT_CELL, CellSpec, ContentSpec, PlaneSpec
+from .specs import EMPTY_PLANE, CellSpec, ContentSpec, PlaneSpec
 
 
 __all__ = [
     "EMPTY_PLANE",
     "GROUP",
-    "TEXT_CELL",
     "CellSpec",
     "ContentSpec",
     "Extension",

{nuspace-0.6.2 → nuspace-0.6.4}/src/nuspace/ext/specs.py

@@ -20,12 +20,7 @@ if TYPE_CHECKING:
     from nuspace.content import Content
 
 
-__all__ = ["EMPTY_PLANE", "TEXT_CELL", "CellSpec", "ContentSpec", "PlaneSpec"]
-
-
-#: The ``nuverse.text`` Cell: nuspace's document editing works on its cells.
-#: See :class:`CellSpec`.
-TEXT_CELL = "nuverse.text"
+__all__ = ["EMPTY_PLANE", "CellSpec", "ContentSpec", "PlaneSpec"]
 
 
 @dataclass(frozen=True)
@@ -91,12 +86,18 @@ EMPTY_PLANE = PlaneSpec(
 class CellSpec:
     """Source for one cell, offered from the ``/`` menu.
 
-    nuspace's document editing works on the cells of the ``nuverse.text``
-    Cell (:data:`TEXT_CELL`), the plane's text cells, written like a
-    document: typing on an empty line starts one, Enter in the title starts
-    one at the top with the text after the caret, Cmd+Enter in one starts
-    the next below, and Backspace in an empty one removes it. With no Cell
-    under that name, typing opens the ``/`` menu and the rest is off.
+    A cell made from it keeps the spec's classes: the protocols it promises,
+    which the browser's sugar binds to, never to which spec made a cell. A
+    class is a name, its promise written here. ``prose``: the cell draws
+    exactly one document that registers a kit document handle (a kit
+    ``MarkdownRef`` does on its own), and its value is markdown. Any spec
+    whose cell keeps that promise declares it, whoever wrote it. A cell made
+    from no spec, or from one no longer installed, has no classes and gets
+    the plane's core behaviour only.
+
+    One spec per class is its default, what typing on the input line
+    creates: a spec claims it with ``default_for``. When two installed specs
+    claim the same class, the first in registration order wins, no error.
 
     Args:
         name: The new cell's name. Installed by a package, it registers
@@ -111,6 +112,13 @@ class CellSpec:
             come last, under no heading.
         icon: What the menu draws beside it, spelled as :class:`PlaneSpec`'s
             ``icon``. ``""`` for the default.
+        classes: The protocols its cells keep, ``("prose",)``.
+        default_for: The classes it is the default of, each one of
+            ``classes``.
+
+    Raises:
+        TypeError: ``classes`` or ``default_for`` is a bare string.
+        ValueError: ``default_for`` names a class not in ``classes``.
     """
 
     name: str
@@ -119,6 +127,17 @@ class CellSpec:
     description: str = ""
     group: str = ""
     icon: str = ""
+    classes: tuple[str, ...] = ()
+    default_for: tuple[str, ...] = ()
+
+    def __post_init__(self) -> None:
+        if isinstance(self.classes, str) or isinstance(self.default_for, str):
+            msg = f"CellSpec {self.name!r}: classes and default_for are tuples, eg ('prose',)"
+            raise TypeError(msg)
+        stray = [c for c in self.default_for if c not in self.classes]
+        if stray:
+            msg = f"CellSpec {self.name!r}: default_for {stray} not among classes {self.classes}"
+            raise ValueError(msg)
 
 
 @dataclass(frozen=True)

{nuspace-0.6.2 → nuspace-0.6.4}/src/nuspace/host/presets.py

@@ -23,7 +23,7 @@ from nuspace import ops
 from nuspace.ext.registry import registered_name
 from nuspace.ops.utils import atomic
 from nuspace.shapes import Space
-from nuspace.system.utils import park, snap
+from nuspace.system.utils import snap
 
 from .space import open_space
 
@@ -165,7 +165,7 @@ def with_plane(
         ]
         if web and open_browser:
             steps.append(Browse(nu.Str(f"http://{host}:{port}/") + pid, host, port))
-        return nu.Sequential(*steps, park())
+        return nu.Sequential(*steps, nu.Park())
 
     body = nu.let("", opened)
     if not web:

{nuspace-0.6.2 → nuspace-0.6.4}/src/nuspace/host/space.py

@@ -26,7 +26,8 @@ planes are sure to exist on a first open, so the start is sequenced here
 instead (the same term, same ``by``).
 
 :func:`init_space` is steps 1 and 2 alone, in the store's brackets only: the
-space directory made and seeded, and closed again, nothing run.
+space directory made, its containers created (as reconcile does at open)
+and seeded, and closed again, nothing run.
 
 Workers import :mod:`nuspace`, and so this module: the web device, which
 pulls in the web server, is imported only when a space serves.
@@ -39,6 +40,7 @@ from typing import TYPE_CHECKING
 
 import nu
 from nuspace.ext import RegistryWarning, space_registry
+from nuspace.ops import init_stores
 from nuspace.ops.usage import opened
 from nuspace.system.info import write_info
 from nuspace.system.kernel import DEFAULT_SPARES, init_start, open_kernel, store
@@ -48,7 +50,6 @@ from nuspace.system.services.nav import clear_connections
 from nuspace.system.ui.home import ensure_home
 from nuspace.system.ui.search import ensure_search
 from nuspace.system.ui.settings import ensure_settings
-from nuspace.system.utils import park
 
 
 if TYPE_CHECKING:
@@ -92,7 +93,7 @@ def init_space(path: str) -> nu.With:
     Raises:
         NotASpace: ``path`` holds something other than a space.
     """
-    return nu.With(store(path), body=seed_space())
+    return nu.With(store(path), body=init_stores() >> seed_space())
 
 
 def open_space(
@@ -155,7 +156,7 @@ def open_space(
         )
         factories = _with_session(factories, web_envs)
         arms.append(served)
-    arms.append(park() if body is None else body)
+    arms.append(nu.Park() if body is None else body)
     beside = arms[0] if len(arms) == 1 else nu.Race(*arms)
     kwargs = {} if name is None else {"name": name}
     return open_kernel(

{nuspace-0.6.2 → nuspace-0.6.4}/src/nuspace/ops/__init__.py

@@ -84,6 +84,7 @@ from .state import (
     plane_state,
     sibling,
 )
+from .stores import init_stores
 from .tree import move_plane
 from .usage import track
 from .utils import atomic, atomic_state, mint_ordered_id, snapshot
@@ -114,6 +115,7 @@ __all__ = [
     "create_cell",
     "create_plane",
     "env",
+    "init_stores",
     "latest",
     "mint_ordered_id",
     "move_pin",

{nuspace-0.6.2 → nuspace-0.6.4}/src/nuspace/ops/cell.py

@@ -229,6 +229,7 @@ def cell_writes(
         >> row.name.set(name)
         >> _write_prog(row, prog, has_ui)
         >> row.props.made_by.set(made_by)
+        >> row.meta.init(nu.Dict.create())
     )
     if meta is not None:
         writes = writes >> row.meta.update(meta)

{nuspace-0.6.2 → nuspace-0.6.4}/src/nuspace/ops/kernel.py

@@ -20,11 +20,10 @@ from __future__ import annotations
 from typing import TYPE_CHECKING
 
 import nu
-import nustd.kv
 from nuspace.shapes import Space
 
 from .read import cell_plane, cells, plane_exists
-from .utils import MintId, atomic
+from .utils import MintId, atomic, listed, snapshot
 
 
 if TYPE_CHECKING:
@@ -48,6 +47,7 @@ __all__ = [
     "off_running",
     "plane_interrupt",
     "plane_kill",
+    "plane_live",
     "plane_run",
     "plane_stop",
     "run",
@@ -76,8 +76,13 @@ STOP_GRACE = 10.0
 _kernel = Space.kernel
 
 
-def _snap(term: nu.Nu) -> nu.Nu:
-    return nustd.kv.Snapshot(term, scope=Space)
+def plane_live(plane_id: nu.StrArg) -> nu.List:
+    """A plane's live plane run ids, ``[]`` when it has none. Bare read.
+
+    Its ``planes_running`` entry is there only while it has live runs (the
+    last run out takes it away), so a plane with none has no set to read.
+    """
+    return listed(_kernel.planes_running[plane_id].runs)
 
 
 # --- Running -------------------------------------------------------------------
@@ -134,10 +139,11 @@ def add_plane_run(
         >> row.by.set(by)
         >> row.envs.set(_envs(envs))
         >> row.termination_requested.set(False)
-        >> row.cells.init({})
-        >> row.cells_running.init(set())
-        >> row.latest.init({})
-        >> row.workers.init(set())
+        >> row.cells.init(nu.Dict.create())
+        >> row.cells_running.init(nu.Set.create())
+        >> row.latest.init(nu.Dict.create())
+        >> row.workers.init(nu.Set.create())
+        >> row.workers_running.init(nu.Set.create())
         >> nu.ForEachDo(
             cells(plane_id),
             lambda cell: nu.let(
@@ -255,8 +261,8 @@ def _until_ended(run_id: nu.StrArg) -> nu.Nu:
     Woken by its plane's live runs, which it leaves in the same commit.
     """
     live = _kernel.planes_running[_kernel.runs[run_id].plane.fallback("")].runs
-    return nu.WaitReactive(
-        _snap(live.on_children_change()), _snap(_kernel.running.contains(run_id).not_())
+    return nu.WaitUntil(
+        snapshot(live.on_children_change()), snapshot(_kernel.running.contains(run_id).not_())
     )
 
 
@@ -291,7 +297,7 @@ def off_running(run_id: nu.StrArg) -> nu.Nu:
 
 def live_runs_of(plane_id: nu.StrArg, body: Callable[[nu.Str], nu.Nu]) -> nu.Nu:
     """``body(run_id)`` for every live plane run of the plane. No bracket."""
-    live = nu.list(_kernel.planes_running[plane_id].runs)
+    live = plane_live(plane_id)
     return nu.ForEachDo(live, lambda rid: body(nu.Str(rid)))
 
 
@@ -378,7 +384,7 @@ def runs(plane: nu.StrArg | None = None) -> nu.List:
     A run's cell runs are :func:`cell_runs`; an ended run is read by id with
     :func:`run`.
     """
-    live = _kernel.running if plane is None else _kernel.planes_running[plane].runs
+    live = _kernel.running if plane is None else plane_live(plane)
     return nu.sorted(live).iter().map(lambda rid: _run_row(nu.Str(rid))).to_list()
 
 

{nuspace-0.6.2 → nuspace-0.6.4}/src/nuspace/ops/read.py

@@ -14,6 +14,8 @@ from __future__ import annotations
 import nu
 from nuspace.shapes import Space
 
+from .utils import listed
+
 
 __all__ = [
     "cell_exists",
@@ -53,7 +55,7 @@ def plane_title(plane_id: nu.StrArg) -> nu.Str:
 
 def cells(plane_id: nu.StrArg) -> nu.List:
     """A plane's cell ids, in order. ``[]`` for a plane never written."""
-    return nu.list(Space.planes[plane_id].cells)
+    return listed(Space.planes[plane_id].cells)
 
 
 def cell_exists(cell_id: nu.StrArg) -> nu.Bool:
@@ -66,7 +68,7 @@ def cell_named(plane_id: nu.StrArg, name: nu.StrArg) -> nu.Str:
     named = (
         cells(plane_id).iter().filter(lambda c: Space.cells[nu.Str(c)].name.fallback("") == name)
     )
-    return nu.str(nu.First(named)).fallback("")
+    return nu.str(nu.First(named, ""))
 
 
 def cell_plane(cell_id: nu.StrArg) -> nu.Str:
@@ -79,7 +81,7 @@ def children(plane_id: nu.StrArg = "") -> nu.List:
 
     ``[]`` for a plane never written.
     """
-    under = nu.list(Space.planes[plane_id].children)
+    under = listed(Space.planes[plane_id].children)
     return nu.List(nu.If(nu.Str(plane_id) == "", nu.list(Space.top), under))
 
 
@@ -90,7 +92,7 @@ def parent(plane_id: nu.StrArg) -> nu.Str:
 
 def prog(cell_id: nu.StrArg) -> nu.Str:
     """A cell's source, ``""`` where there is none."""
-    return nu.str(Space.cells[cell_id].prog).fallback("")
+    return nu.str(Space.cells[cell_id].prog.fallback(""))
 
 
 def plane_rows() -> nu.List:
@@ -132,7 +134,7 @@ def cell_rows(plane_id: nu.StrArg) -> nu.List:
         return nu.Dict.of(
             id=at,
             name=cell.name.fallback(""),
-            prog=nu.str(cell.prog).fallback(""),
+            prog=nu.str(cell.prog.fallback("")),
             props=nu.Dict.of(
                 made_by=cell.props.made_by.fallback(""), has_ui=cell.props.has_ui.fallback(True)
             ),