nuspace 0.2.1__tar.gz → 0.3.0__tar.gz

{nuspace-0.2.1 → nuspace-0.3.0}/.github/workflows/publish-nuspace-ui.yml

@@ -20,8 +20,8 @@
 #     Environment name: (leave blank)
 #
 # Release flow:
-#   1. Bump `version` in both `src/nuspace/web/ui/pyproject.toml` and
-#      `src/nuspace/web/ui/package.json` (keep them equal).
+#   1. Bump `version` in both `ts/pyproject.toml` and
+#      `ts/package.json` (keep them equal).
 #   2. Commit and push to main.
 #   3. `git tag nuspace-ui@X.Y.Z && git push origin nuspace-ui@X.Y.Z`.
 name: Publish nuspace-ui to PyPI
@@ -40,7 +40,7 @@ concurrency:
   cancel-in-progress: false
 
 env:
-  UI_DIR: src/nuspace/web/ui
+  UI_DIR: ts
 
 jobs:
   publish:
@@ -53,7 +53,7 @@ jobs:
         with:
           node-version: 24
           cache: npm
-          cache-dependency-path: src/nuspace/web/ui/package-lock.json
+          cache-dependency-path: ts/package-lock.json
 
       - uses: actions/setup-python@v5
         with:
@@ -115,5 +115,5 @@ jobs:
         if: startsWith(github.ref, 'refs/tags/nuspace-ui@')
         uses: pypa/gh-action-pypi-publish@release/v1
         with:
-          packages-dir: src/nuspace/web/ui/wheel-dist
+          packages-dir: ts/wheel-dist
           skip-existing: true

{nuspace-0.2.1 → nuspace-0.3.0}/.github/workflows/publish-nuspace.yml

@@ -15,13 +15,13 @@
 #
 # Two distributions ship from this repo, on independent tags:
 #   .                      -> nuspace     (the runtime + the `nuspace` command)
-#   src/nuspace/web/ui     -> nuspace-ui  (the compiled vite bundle)
+#   ts     -> nuspace-ui  (the compiled vite bundle)
 #
 # They version independently. `nuspace` hard-depends on `nuspace-ui>=X.Y.Z`, so
 # a python release can require a newer bundle, but a bundle-only fix ships on
 # its own tag without republishing this wheel.
 #
-# The wheel deliberately excludes `src/nuspace/web/ui/**` (see the hatch config
+# The wheel deliberately excludes `ts/**` (see the hatch config
 # in pyproject.toml). The compiled assets live in the nuspace-ui wheel and are
 # found at runtime by `import nuspace_ui` -- see `_bundled_static()` in
 # src/nuspace/web/serve/app.py. So this build needs no node toolchain, even

{nuspace-0.2.1 → nuspace-0.3.0}/CHANGELOG.md

@@ -2,13 +2,26 @@
 
 ## Packages shipped from this repo
 
-- **nuspace** (the runtime, the `nuspace` command) — 0.2.1
-- **nuspace-ui** (the compiled web bundle) — 0.2.1
+- **nuspace** (the runtime, the `nuspace` command) — 0.3.0
+- **nuspace-ui** (the compiled web bundle) — 0.3.0
 
 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.3.0 — 2026-09-21
+
+- Make a chat, ask it for something, and watch it work the space
+- See how a job is set to run, and edit what it does in a real editor
+- Keep pages and jobs in separate sidebar sections, and make either in one click
+- Collapse the whole interface to one sidebar and one viewer over any plane
+- A plane now says whether it draws and whether you can edit it
+- Open a space in the browser and write prose and programs into a plane's cells
+- Boot a browser tab with the chrome it holds before anything is drawn
+- Let a cell draw on a browser connection, and let a driver say which planes are up
+- Run a space of planes and cells, each cell with its own restart policy
+- Clear the v0.2 source out of the way for the v0.3 rewrite
+
 ## 0.2.1 — 2026-09-17
 
 - Open a page on quiet air and its own name instead of decoration

{nuspace-0.2.1 → nuspace-0.3.0}/Makefile

@@ -5,7 +5,7 @@ GREEN := \033[0;32m
 YELLOW := \033[1;33m
 NC := \033[0m
 
-UI_APP := src/nuspace/web/ui
+UI_APP := ts
 
 help:
 	@echo "$(BLUE)nuspace$(NC)"

{nuspace-0.2.1 → nuspace-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: nuspace
-Version: 0.2.1
+Version: 0.3.0
 Summary: Nu runtime built on Nu. A self-hosted programmable space that runs Nu apps in a tree of containers and applications.
 Project-URL: Repository, https://github.com/nustackdev/nuspace
 Author-email: Gor Arakelyan <gorarkln@gmail.com>
@@ -17,9 +17,9 @@ Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.10
 Requires-Dist: click>=8.0
 Requires-Dist: nuagent>=0.1.3
-Requires-Dist: nucore>=0.5.1
-Requires-Dist: nuspace-ui>=0.2.1
-Requires-Dist: nustd[all]>=0.5.1
+Requires-Dist: nucore>=0.5.2
+Requires-Dist: nuspace-ui>=0.3.0
+Requires-Dist: nustd[all]>=0.5.2
 Requires-Dist: rich-click>=1.6
 Requires-Dist: rich>=10.7
 Requires-Dist: typing-extensions>=4.7.0

nuspace-0.3.0/examples/headless.py

@@ -0,0 +1,277 @@
+"""A Space of two Planes and three Cells, run headless, start to finish in twelve seconds.
+
+Everything phase 1 claims, shown rather than described:
+
+- a Plane whose ``exec_mode`` is ``async`` holds two Cells in one worker;
+- a Plane whose ``exec_mode`` is ``mp`` gives its one Cell a process to itself;
+- nothing a person wrote runs in the main process, which the pids prove;
+- ``restart: always`` brings a program back after it returns, ``restart: no``
+  leaves it stopped;
+- ``reload`` restarts the Cell whose program changed, and only that one.
+
+Every Cell runs the same tiny program: count this run, stamp the process it ran
+in, say which version of itself it is. Three numbers, and between them they
+answer every question above.
+
+Run it::
+
+    python examples/headless.py
+
+The Space is left on disk, so ``nuspace -s <path> ls`` reads what it did.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import os
+import tempfile
+
+import nu
+import nustd.kv
+from nuspace import (
+    EXEC_ASYNC,
+    EXEC_MP,
+    RESTART_ALWAYS,
+    RESTART_NO,
+    TRIGGER_BOOT,
+    Space,
+    open_space,
+    ops,
+    store,
+)
+from nuspace.drivers import run_space
+
+
+# Closing the Space drops two sockets under workers that are still holding them,
+# and the transport logs every one of those as an error. Expected, and the only
+# thing this demo has to say is what it printed itself. At module scope so a
+# spawned worker, which imports this file, is quiet too.
+logging.getLogger("invisibles").setLevel(logging.CRITICAL)
+
+
+LOOP, BEAT, HOLD = "loop", "beat", "hold"
+SOLO, WORK = "solo", "work"
+
+#: How long the Space runs before the first report. Long enough for a Cell that
+#: keeps coming back to have come back a good few times.
+BOOT_SECONDS = 5.0
+
+#: How long an edit is given to land before the report after it.
+EDIT_SECONDS = 3.0
+
+
+def source(version: int) -> str:
+    """The program every Cell holds. Counts the run, stamps the process, ends.
+
+    Ending is the point: a program that returns is what ``restart`` is about,
+    so the same three lines demonstrate both settings of it.
+    """
+    return f'''import os
+
+import nu
+import nustd.kv
+from nuspace import Space
+
+
+def out(plane, cell):
+    """Count this run, stamp the process it ran in, and end."""
+    state = Space.planes[plane].cells[cell].state
+    runs = nu.Int(nu.ToInt(state.get_item("runs", nu.Int(0))))
+    return nustd.kv.auto_flow_atomic(
+        state.set_item("runs", runs + nu.Int(1))
+        >> state.set_item("pid", nu.Int(os.getpid()))
+        >> state.set_item("version", nu.Int({version})),
+        scope=Space,
+    )
+'''
+
+
+# --- what the Space is -------------------------------------------------------
+
+
+def seed():
+    """Two Planes and three Cells, each Cell one commit."""
+    return (
+        ops.add_plane(plane_id=LOOP, exec_mode=EXEC_ASYNC, trigger=TRIGGER_BOOT)
+        >> ops.add_cell(LOOP, source(1), cell_id=BEAT, restart=RESTART_ALWAYS)
+        >> ops.add_cell(LOOP, source(1), cell_id=HOLD, restart=RESTART_NO)
+        >> ops.add_plane(plane_id=SOLO, exec_mode=EXEC_MP, trigger=TRIGGER_BOOT)
+        >> ops.add_cell(SOLO, source(1), cell_id=WORK, restart=RESTART_ALWAYS)
+    )
+
+
+# --- what it says while it runs ----------------------------------------------
+
+
+def say(text):
+    return nu.Print(nu.STDOUT, nu.Str(text), flush=True)
+
+
+def kept(plane, cell, key):
+    """One number a Cell's program kept, zero where it has not written it yet."""
+    state = Space.planes[plane].cells[cell].state
+    return nu.Int(nu.ToInt(state.get_item(key, nu.Int(0))))
+
+
+def show(plane, cell):
+    return nu.Print(
+        nu.STDOUT,
+        nu.Str(f"  {plane}/{cell:<6}"),
+        nu.Str("  runs "),
+        nu.ToStr(kept(plane, cell, "runs")),
+        nu.Str("   version "),
+        nu.ToStr(kept(plane, cell, "version")),
+        nu.Str("   pid "),
+        nu.ToStr(kept(plane, cell, "pid")),
+        sep="",
+        flush=True,
+    )
+
+
+def report(title):
+    return say(title) >> show(LOOP, BEAT) >> show(LOOP, HOLD) >> show(SOLO, WORK)
+
+
+def timeline():
+    """The whole demo as one branch: watch, edit, watch, edit, watch.
+
+    It runs beside the runtime in the main process. When it ends, the Race
+    around it ends, which is what closes the Space.
+    """
+    return (
+        nu.DelayedDo(
+            nu.Float(BOOT_SECONDS),
+            report(f"\nact 1  {BOOT_SECONDS:.0f} seconds in, nobody has touched anything"),
+        )
+        >> say("\nact 2  editing loop/beat to version 2")
+        >> ops.set_prog(LOOP, BEAT, source(2))
+        >> nu.DelayedDo(
+            nu.Float(EDIT_SECONDS),
+            report("       beat is on the new program, hold has not moved"),
+        )
+        >> say("\nact 3  editing loop/hold, which has been stopped since its one run")
+        >> ops.set_prog(LOOP, HOLD, source(2))
+        >> nu.DelayedDo(
+            nu.Float(EDIT_SECONDS),
+            report("       the edit started it again, for exactly one more run"),
+        )
+    )
+
+
+def body():
+    """Seed the Space, then run it against the timeline until the timeline ends."""
+    return nustd.kv.auto_flow_atomic(seed(), scope=Space) >> nu.Race(
+        run_space(),
+        nustd.kv.auto_flow_atomic(timeline(), scope=Space),
+    )
+
+
+# --- what it says afterwards -------------------------------------------------
+
+
+def read_back(path):
+    """What the three Cells kept, read out of the closed store."""
+    value, _ = nu.run_in_loop(
+        nu.With(
+            store(path),
+            body=nustd.kv.Snapshot(
+                nu.Dict.of(
+                    beat=ops.cell_state(LOOP, BEAT),
+                    hold=ops.cell_state(LOOP, HOLD),
+                    work=ops.cell_state(SOLO, WORK),
+                ),
+                scope=Space,
+            ),
+        ),
+        nu.Context(),
+    )
+    return value
+
+
+def verdict(path, main_pid):
+    """Every claim as a check against the final state, so it passes or it does not."""
+    state = read_back(path)
+    runs = {k: state[k].get("runs", 0) for k in state}
+    pids = {k: state[k].get("pid", 0) for k in state}
+    version = {k: state[k].get("version", 0) for k in state}
+    checks = [
+        (
+            "restart always",
+            runs["beat"] >= 5,
+            f"loop/beat returned and came back {runs['beat']} times",
+        ),
+        (
+            "restart no",
+            runs["hold"] == 2,
+            f"loop/hold ran {runs['hold']} times, never once on its own account",
+        ),
+        (
+            "reload",
+            version["beat"] == 2,
+            "loop/beat is running the program it was edited to",
+        ),
+        (
+            "reload restarts a stopped Cell",
+            version["hold"] == 2 and runs["hold"] == 2,
+            "loop/hold was parked, and the edit is what started it again",
+        ),
+        (
+            "siblings are left alone",
+            runs["hold"] == 2,
+            "editing loop/beat left loop/hold on its single boot run",
+        ),
+        (
+            "nothing runs in main",
+            main_pid not in pids.values(),
+            f"main is {main_pid}, no Cell is",
+        ),
+        (
+            "async is one process for the Plane",
+            pids["beat"] == pids["hold"],
+            f"loop/beat and loop/hold both ran in {pids['beat']}",
+        ),
+        (
+            "mp is one process for the Cell",
+            pids["work"] not in (main_pid, pids["beat"]),
+            f"solo/work ran in {pids['work']}, on its own",
+        ),
+    ]
+    print("\nverdict, read back from the closed store\n")
+    for name, passed, detail in checks:
+        print(f"  {'PASS' if passed else 'FAIL'}  {name:<36}{detail}")
+    failed = [name for name, passed, _ in checks if not passed]
+    print()
+    if failed:
+        print(f"{len(failed)} check(s) failed: {', '.join(failed)}")
+    else:
+        print("all good")
+    print(f"\nthe Space is still there: nuspace -s {path} ls")
+
+
+# --- driving it --------------------------------------------------------------
+
+
+async def live(path):
+    """The Space open, from boot to the end of the timeline."""
+    # max_parallel=1: nothing in the runtime computes, and a larger budget
+    # rations each Plane's Race against a semaphore those arms never give back.
+    await nu.arun(open_space(body(), path=path), nu.Context(), max_parallel=1)
+
+
+def main():
+    path = tempfile.mkdtemp(prefix="nuspace-demo-")
+    print(f"\nnuspace headless demo   {path}\n")
+    print("  loop  async  boot   beat (restart always)   hold (restart no)")
+    print("  solo  mp     boot   work (restart always)")
+    print(f"  main process is {os.getpid()}")
+    asyncio.run(live(path))
+    # The read back happens after the loop is gone, on a store nothing holds
+    # any more, which is the point: this is what a person would find there.
+    verdict(path, os.getpid())
+
+
+if __name__ == "__main__":
+    # The guard is load bearing: the pool spawns, and a child re-imports
+    # whatever __main__ is. Without it, opening a Space forks forever.
+    main()

nuspace-0.3.0/examples/web.py

@@ -0,0 +1,141 @@
+"""A Space in a browser, where opening a Plane is what starts it.
+
+Everything phase 2 claims, in a tab rather than in a print:
+
+- the sidebar lists every Plane that draws, under one row for the Space;
+- clicking one selects it, and selecting it is what brings its Cells up;
+- a Cell draws under its own node on the page, from the worker it runs in;
+- navigating away takes that worker down, and navigating back brings it up
+  again, which the counter says out loud by starting from where it left off;
+- prose is a Cell like any other: it holds a program that draws an editor.
+
+Two Planes are seeded the first time and nothing after that, so what you write
+is still there next time.
+
+Run it::
+
+    python examples/web.py
+
+A browser opens on http://127.0.0.1:8080. Pick Notes and type. Pick
+Counter and watch it climb, then pick Notes again and come back to it: the
+seconds are not the ones that went by while you were away, because nothing was
+running while nobody was looking.
+
+Ctrl+C stops it. The Space is left on disk, so `nuspace -s <path> ls` reads
+what it did.
+"""
+
+from __future__ import annotations
+
+import logging
+import tempfile
+from pathlib import Path
+
+import nu
+import nustd.kv
+from nuspace import EXEC_ASYNC, TRIGGER_NAV, Space, ops, presets, store
+from nuspace.web.viewer import prose_source
+
+
+# Closing the Space drops the sockets under workers that are still holding
+# them, and the transport logs every one of those. Expected, and the only thing
+# this demo has to say is what it drew. At module scope so a spawned worker,
+# which imports this file, is quiet too.
+logging.getLogger("invisibles").setLevel(logging.CRITICAL)
+
+
+#: Kept between runs, because the point of a page is that what you wrote is
+#: still on it tomorrow.
+STORE = Path(tempfile.gettempdir()) / "nuspace-web-demo"
+
+PORT = 8080
+
+NOTES, COUNTER = "p_notes", "p_counter"
+TEXT, TICK = "s_text", "s_tick"
+
+
+#: A Cell that draws. One stat tile and a loop, and it says nothing about where
+#: the tile lives: the ref is written bare and the host roots it under this
+#: Cell's own node on whatever surface the Plane is drawn on.
+TICKER = '''import nu
+import nustd.kv
+import nustd.ui
+from nuspace import Space
+
+
+def out(plane, cell):
+    """Count seconds, in the browser and in this Cell's own state."""
+    tile = nustd.ui.StatRef("seconds")
+    state = Space.planes[plane].cells[cell].state
+    now = nu.Int(nu.ToInt(state.get_item("ticks", nu.Int(0))))
+    step = state.set_item("ticks", now + nu.Int(1)) >> tile.set_value(
+        nu.ToStr(now + nu.Int(1))
+    )
+    # A program owns its own atomicity. Nothing brackets it on the way in,
+    # because the host cannot see inside a program it evaluates.
+    return nustd.kv.auto_flow_atomic(
+        tile.set_label(nu.Str("seconds this Plane has been open"))
+        >> nu.ForeverDo(nu.DelayedDo(nu.Float(1.0), step)),
+        scope=Space,
+    )
+'''
+
+
+def plane(plane_id, name):
+    """One Plane a tab can navigate to, drawn as a page."""
+    return ops.add_plane(
+        plane_id=plane_id,
+        name=name,
+        exec_mode=EXEC_ASYNC,
+        # Up because somebody is looking at it, and down again when they stop.
+        trigger=TRIGGER_NAV,
+        ui=True,
+        editable=True,
+    )
+
+
+def seed():
+    """Two Planes, once. A Space that already has one is left alone.
+
+    Guarded rather than made idempotent: adding a Cell rewrites the row, so
+    seeding on every run would put the empty page back over whatever the last
+    run wrote on it.
+    """
+    made = (
+        plane(NOTES, "Notes")
+        >> ops.add_cell(NOTES, prose_source(Space), cell_id=TEXT, name=TEXT)
+        >> plane(COUNTER, "Counter")
+        >> ops.add_cell(COUNTER, TICKER, cell_id=TICK, name=TICK)
+    )
+    return nu.IfDo(nu.Eq(nu.Len(ops.plane_ids()), nu.Int(0)), made)
+
+
+def main():
+    STORE.mkdir(parents=True, exist_ok=True)
+    print(f"\nnuspace web demo   {STORE}")
+    print("  Notes     a page to write on")
+    print("  Counter   a Cell that draws, and only while you are looking")
+    # Seeded against a store this process then closes, because the Space the
+    # server opens takes the write lock for as long as it is up.
+    nu.run_in_loop(
+        nu.With(store(str(STORE)), body=nustd.kv.auto_flow_atomic(seed(), scope=Space)),
+        nu.Context(),
+    )
+    print(f"\n  http://127.0.0.1:{PORT}, Ctrl+C to stop\n")
+    try:
+        # max_parallel=1: nothing in the runtime computes, every branch is an
+        # await, and a larger budget rations each arm against a semaphore those
+        # arms never give back.
+        nu.run_in_loop(
+            presets.full(path=str(STORE), port=PORT),
+            nu.Context(),
+            max_parallel=1,
+        )
+    except KeyboardInterrupt:
+        print("stopped")
+
+
+if __name__ == "__main__":
+    # The guard is load bearing: the pool spawns, and a child re-imports
+    # whatever __main__ is. Without it, opening a Space forks forever.
+    main()

{nuspace-0.2.1 → nuspace-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "nuspace"
-version = "0.2.1"
+version = "0.3.0"
 description = "Nu runtime built on Nu. A self-hosted programmable space that runs Nu apps in a tree of containers and applications."
 readme = "README.md"
 license = "AGPL-3.0-or-later"
@@ -16,12 +16,12 @@ dependencies = [
     # ui for the browser, proxy (invisibles) for the worker's session, mp_pool
     # for the workers themselves. Picking extras just means discovering the
     # missing one at import time.
-    "nucore>=0.5.1",
-    "nustd[all]>=0.5.1",
+    "nucore>=0.5.2",
+    "nustd[all]>=0.5.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.2.1",
+    "nuspace-ui>=0.3.0",
     "nuagent>=0.1.3",
     "typing-extensions>=4.7.0",
     "click>=8.0",
@@ -56,21 +56,18 @@ nuspace = "nuspace.cli:main"
 
 [tool.hatch.build.targets.wheel]
 packages = ["src/nuspace"]
-exclude = [
-    "src/nuspace/web/ui/**",
-]
 
 [tool.hatch.build.targets.sdist]
 exclude = [
-    "src/nuspace/web/ui/node_modules",
-    "src/nuspace/web/ui/dist",
+    "ts/node_modules",
+    "ts/dist",
 ]
 
 [tool.uv.sources]
-nuspace-ui = { path = "./src/nuspace/web/ui" }
-nucore = { path = "../nu/packages/nucore", editable = true }
-nustd = { path = "../nu/packages/nustd", editable = true }
-nucli = { path = "../nu/packages/nucli", editable = true }
+nuspace-ui = { path = "./ts" }
+nucore = { path = "../nu", editable = true }
+nustd = { path = "../nu/pkgs/nustd", editable = true }
+nucli = { path = "../nu/pkgs/nucli", editable = true }
 nuagent = { path = "../nuagent", editable = true }
 
 [tool.uv]

nuspace-0.3.0/src/nuspace/__init__.py

@@ -0,0 +1,82 @@
+"""nuspace: a Nu orchestrator that supports different mediums and behaviors.
+
+Everything is inside a **Space**. A Space is a collection of **Planes**, and a
+Plane says how and when its **Cells** run and how they are drawn. A Cell is a
+Nu program, and it is the only thing here that executes.
+
+Six modules, and the names are the model::
+
+    nuspace.shapes    the store layout
+    nuspace.space     opening a Space in a process
+    nuspace.ops       what a person does to a Space
+    nuspace.exec      how a Space runs
+    nuspace.drivers   when and what runs
+    nuspace.presets   a Space open with some set of drivers in it
+
+The store layout and the two entry points are re-exported here, so a program
+that lives in a Cell says ``from nuspace import Space`` and a process that
+opens one says ``open_space(run_space())``. Everything else is reached through
+the module it lives in, because ``ops``, ``exec``, ``drivers`` and ``presets``
+are families rather than functions.
+"""
+
+from nuspace import drivers, exec, ops, presets
+from nuspace.drivers import run_space
+from nuspace.shapes import (
+    DEFAULT_EDITABLE,
+    DEFAULT_EXEC_MODE,
+    DEFAULT_RELOAD,
+    DEFAULT_RESTART,
+    DEFAULT_TRIGGER,
+    DEFAULT_UI,
+    EXEC_ASYNC,
+    EXEC_MODES,
+    EXEC_MP,
+    RESTART_ALWAYS,
+    RESTART_NO,
+    RESTART_ON_FAILURE,
+    RESTARTS,
+    TRIGGER_BOOT,
+    TRIGGER_MANUAL,
+    TRIGGER_NAV,
+    TRIGGERS,
+    Cell,
+    CellProps,
+    Plane,
+    PlaneProps,
+    Space,
+)
+from nuspace.space import open_space, store
+
+
+__all__ = [
+    "DEFAULT_EDITABLE",
+    "DEFAULT_EXEC_MODE",
+    "DEFAULT_RELOAD",
+    "DEFAULT_RESTART",
+    "DEFAULT_TRIGGER",
+    "DEFAULT_UI",
+    "EXEC_ASYNC",
+    "EXEC_MODES",
+    "EXEC_MP",
+    "RESTARTS",
+    "RESTART_ALWAYS",
+    "RESTART_NO",
+    "RESTART_ON_FAILURE",
+    "TRIGGERS",
+    "TRIGGER_BOOT",
+    "TRIGGER_MANUAL",
+    "TRIGGER_NAV",
+    "Cell",
+    "CellProps",
+    "Plane",
+    "PlaneProps",
+    "Space",
+    "drivers",
+    "exec",
+    "open_space",
+    "ops",
+    "presets",
+    "run_space",
+    "store",
+]

nuspace-0.3.0/src/nuspace/cli/__init__.py

@@ -0,0 +1,11 @@
+"""The ``nuspace`` command.
+
+Seed a Space with ``plane`` and ``cell``, run it headless with ``run``, look at
+it with ``ls``. A Space is a directory one process locks at a time, so the
+commands that write want it to themselves and ``run`` holds it while it is up.
+"""
+
+from nuspace.cli.main import cli, main
+
+
+__all__ = ["cli", "main"]

nuspace-0.3.0/src/nuspace/cli/__main__.py

@@ -0,0 +1,11 @@
+"""Enables ``python -m nuspace.cli``.
+
+The guard is load bearing, not decoration: the worker pool spawns, and a child
+re-imports whatever ``__main__`` is. Without it, opening a Space forks forever.
+"""
+
+from nuspace.cli.main import main
+
+
+if __name__ == "__main__":
+    main()