nuspace 0.7.1__tar.gz → 0.7.2__tar.gz

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

@@ -2,13 +2,25 @@
 
 ## Packages shipped from this repo
 
-- **nuspace** (the runtime, the `nuspace` command) — 0.7.1
-- **nuspace-ui** (the compiled web bundle) — 0.7.1
+- **nuspace** (the runtime, the `nuspace` command) — 0.7.2
+- **nuspace-ui** (the compiled web bundle) — 0.7.2
 
 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.2 - 2026-11-13
+
+- Release nuspace and nuspace-ui 0.7.2
+- Home, settings and search follow the new layout model; plane links share one helper
+- New planes get a default icon when created without one
+- Home, settings and search planes get clean sectioned layouts with real tables
+- Drops show the region they make, and single planes stack anywhere
+- Sidebar states use the kit hover, press and selected washes in both themes
+- Desks keep each item on its own, programs get item ops, cross-desk drags commit once
+- The web device moves to nuspace.web, the devices package is gone
+- Group the web device by area: desk ops under desks, shipped planes together
+
 ## 0.7.1 - 2026-11-12
 
 - Release nuspace and nuspace-ui 0.7.1

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: nuspace
-Version: 0.7.1
+Version: 0.7.2
 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.3
-Requires-Dist: nuspace-ui>=0.7.1
-Requires-Dist: nustd[kv,mp-pool,proxy,ui,valkey]>=0.7.3
-Requires-Dist: nuverse>=0.3.9
+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: 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.3; extra == 'all'
+Requires-Dist: nustd[all]>=0.7.4; extra == 'all'
 Description-Content-Type: text/markdown
 
 <div align="center">

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

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "nuspace"
-version = "0.7.1"
+version = "0.7.2"
 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.3",
-    "nustd[kv,ui,valkey,mp_pool,proxy]>=0.7.3",
+    "nucore>=0.7.4",
+    "nustd[kv,ui,valkey,mp_pool,proxy]>=0.7.4",
     # 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.1",
+    "nuspace-ui>=0.7.2",
     # The everyday Planes and Cells. A plugin like any other, found through
     # its entry point, but every space ships with it.
-    "nuverse>=0.3.9",
+    "nuverse>=0.3.10",
     "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.3",
+    "nustd[all]>=0.7.4",
 ]
 
 [project.urls]

{nuspace-0.7.1 → nuspace-0.7.2}/src/nuspace/__init__.py

@@ -15,7 +15,7 @@ The top level holds the everyday names only:
 - ``nuspace.specs`` (PlaneSpec, CellSpec, the registry, add_plane,
   add_cell) and ``nuspace.errors`` (what an op raises).
 
-``nuspace.kernel``, ``nuspace.system.*``, ``nuspace.devices.web``,
+``nuspace.kernel``, ``nuspace.system.*``, ``nuspace.web``,
 ``nuspace.host`` and ``nuspace.utils`` stay namespaced.
 
 Workers import this package: nothing here may pull in a server.

{nuspace-0.7.1 → nuspace-0.7.2}/src/nuspace/host/devices.py

@@ -56,11 +56,11 @@ class Device:
 
 def _web() -> Device:
     """The web device. Its stores and planes import no server; :func:`serve` does, when called."""
-    from nuspace.devices.web.planes import ensure
-    from nuspace.devices.web.stores import CONN_STORE, WEB_STORE
+    from nuspace.web.planes import ensure
+    from nuspace.web.stores import CONN_STORE, WEB_STORE
 
     def serve(*, registry: Registry, **options: object) -> tuple[nu.Nu, Mapping[str, EnvFactory]]:
-        from nuspace.devices.web.device import serve_web
+        from nuspace.web.device import serve_web
 
         return serve_web(registry=registry, **options)
 

{nuspace-0.7.1 → nuspace-0.7.2}/src/nuspace/host/layout.py

@@ -13,7 +13,7 @@ repository keeps ``.git/``::
         infra/valkey/              the notification server's dir, per open
 
 The store files are the store records' (:mod:`.stores`,
-:mod:`nuspace.devices.web.stores`). The Space store's file is the mark of a
+:mod:`nuspace.web.stores`). The Space store's file is the mark of a
 space: ``~/.nuspace`` holds the user's config whether or not home is a space.
 """
 

{nuspace-0.7.1 → nuspace-0.7.2}/src/nuspace/host/resources.py

@@ -126,9 +126,6 @@ class Warmed:
         Never the web device's server.
         """
         import nu.prog  # noqa: F401 -- imported for the module cache
-        import nuspace.devices.web.env
-        import nuspace.kernel.body
-        import nuspace.kernel.out  # noqa: F401
         import nustd.ui  # noqa: F401
 
     async def asetup(self, ctx: Context) -> None:

{nuspace-0.7.1 → nuspace-0.7.2}/src/nuspace/host/stores.py

@@ -10,7 +10,7 @@ so stores never wake each other's subscribers. Each is declared as a
     store/state.db     State   nuspace.state   what programs keep
 
 A device keeps its own stores beside these (the web device:
-:mod:`nuspace.devices.web.stores`).
+:mod:`nuspace.web.stores`).
 
 A container never written is absent, and reading one (its length, its keys,
 whether it holds an id) raises. So each store's fixed containers are made

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

@@ -56,6 +56,9 @@ __all__ = [
 #: The prefixes an icon is spelled with, a lucide name or an emoji after it.
 ICON_PREFIXES = ("lucide:", "emoji:")
 
+#: The icon a plane is made with when none is given.
+DEFAULT_ICON = "lucide:file-text"
+
 
 def _icon_spelled(icon: nu.StrArg) -> None:
     """A literal icon is ``""`` or a prefix with something after it. A term is stored as it is.
@@ -138,7 +141,7 @@ def add(
         name: Display text only.
         key: An optional handle in key chars (letters, digits, ``_``, ``-``),
             case-sensitive, ``""`` for none.
-        icon: ``lucide:<name>``, ``emoji:<char>`` or ``""``.
+        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.
@@ -169,7 +172,7 @@ def add(
             return (
                 row.name.set(name)
                 >> row.key.set(key)
-                >> row.icon.set(icon)
+                >> row.icon.set(icon or DEFAULT_ICON if isinstance(icon, str) else icon)
                 >> row.parent.set(parent)
                 >> row.version.set(0)
                 >> row.cells.set(nu.Dict.create())

{nuspace-0.7.1 → nuspace-0.7.2}/src/nuspace/shapes/__init__.py

@@ -28,7 +28,7 @@ for a cell run's output.
 
 Each store is a :class:`Store` record (root, file, channel, init), declared
 by the host for the core stores. The web device keeps its own stores and
-shapes, in :mod:`nuspace.devices.web.shapes`. Core never reads them.
+shapes, in :mod:`nuspace.web.shapes`. Core never reads them.
 """
 
 from .cell import Cell

{nuspace-0.7.1 → nuspace-0.7.2}/src/nuspace/shapes/content.py

@@ -13,7 +13,7 @@ Finding reads one kind's subtree, scope by scope, all bare reads:
 the items ``match`` holds for in one scope, :meth:`Content.find` both
 together. A search reads per kind, so it never touches another kind's
 items; the web device's search drives it a place at a time
-(:mod:`nuspace.devices.web.search`).
+(:mod:`nuspace.web.planes.search`).
 
 Workers import this module: nothing here may pull in a server.
 """
@@ -219,7 +219,7 @@ class Content(Generic[S]):
       only the checks asked for.
     - :meth:`render`, :meth:`render_hit`: how an item draws in full and as a
       search hit. Bare ui chains, landed under wherever the drawing goes
-      (:class:`~nuspace.devices.web.interactions.Drawing`).
+      (:class:`~nuspace.web.interactions.Drawing`).
     - :meth:`form`: the search form, generated from ``match``'s keywords.
     - :meth:`find`: every item ``match`` holds for, from every place.
 

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

@@ -16,7 +16,7 @@ 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.devices.web.planes``): the searches folder, 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.

{nuspace-0.7.1 → nuspace-0.7.2}/src/nuspace/shapes/store.py

@@ -1,7 +1,7 @@
 """Store: one store of a space, as a record: its root shape, its file, its channel, its init.
 
 The core stores are declared in :mod:`nuspace.host.stores`, a device's
-beside its shapes (the web device: :mod:`nuspace.devices.web.stores`). The
+beside its shapes (the web device: :mod:`nuspace.web.stores`). The
 record sits here, with the roots, so the host and the devices both read it
 and neither imports the other for it. A store has no ops of its own: its
 init term is the one thing it runs, and the store's declaration builds it.

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

@@ -119,11 +119,11 @@ class _Tree:
 
 
 def _web_row(pid: nu.Str, spec: PlaneSpec) -> nu.Nu:
-    """The plane's web row, from ``spec.web``: ``nuspace.devices.web.add``, the plane shows on the web.
+    """The plane's web row, from ``spec.web``: ``nuspace.web.add``, the plane shows on the web.
 
     Imported here, not at the top, so core loads without the web device.
     """
-    from nuspace.devices.web import ops as web
+    from nuspace.web import ops as web
 
     flags = spec.web
     return web.add(

{nuspace-0.7.1 → nuspace-0.7.2}/src/nuspace/utils/placement.py

@@ -1,8 +1,8 @@
 """Placing an id in an ordered list: before an anchor, after one, or at the end.
 
 The one spelling of "placement is ``before=`` / ``after=`` an id, neither
-means the end" that ops share. Generic: it works on any ``OrderedDictRef``
-of bool. The checks that make an anchor valid (it is there, it is a
+means the end" that ops share. Generic: it works on any ``OrderedDictRef``,
+of bool (membership, the default) or of values. The checks that make an anchor valid (it is there, it is a
 sibling) are the caller's, made before this runs.
 """
 
@@ -37,17 +37,19 @@ def place(
     *,
     before: nu.StrArg | None = None,
     after: nu.StrArg | None = None,
+    value: object = True,
 ) -> nu.Nu:
     """Put ``id`` into ``listed`` before or after an anchor, or at the end. One view call.
 
-    ``id`` must not be listed yet: to move one, take it out first. No bracket.
+    ``value`` is what ``id`` holds, ``True`` for a membership list. ``id``
+    must not be listed yet: to move one, take it out first. No bracket.
 
     Raises:
         TypeError: Both ``before`` and ``after`` are given, at build.
     """
     anchor_of(before, after)
     if before is not None:
-        return listed.insert_before(before, id)
+        return listed.insert_before(before, id, value)
     if after is not None:
-        return listed.insert_after(after, id)
-    return listed.set_item(id, True)
+        return listed.insert_after(after, id, value)
+    return listed.set_item(id, value)

{nuspace-0.7.1/src/nuspace/devices → nuspace-0.7.2/src/nuspace}/web/__init__.py

@@ -1,49 +1,49 @@
-"""``nuspace.devices.web``: the web device, the browser's way into the space, with its own stores.
+"""``nuspace.web``: the web device, the browser's way into the space, with its own stores.
 
 The sdk, what a program calls, is the ops (:mod:`.ops`), flat here::
 
-    import nuspace.devices.web as web
+    import nuspace.web as web
 
     nuspace.atomic(web.add(plane, editable=True))     # put a plane on the web
     web.params(), web.on_params()                     # a cell's own pane params
     web.restart_cell(sid, cell)                       # run one cell again, brackets itself
     nuspace.atomic(web.link(row.link, plane))         # draw a link to a plane
-    nuspace.atomic(web.set_desk(desk_id, desk))       # replace a desk whole
+    nuspace.atomic(web.page(plane))                   # {id, title, icon, href}: a PageLink table cell
+    web.url(plane, {"id": 3})                         # its URL, plain python, for rows built outside a term
     nuspace.atomic(web.set_role("home", plane))       # make a plane the home
 
 - :mod:`.shapes`: :class:`Web` (web planes, recents, desks, roles) and :class:`Conn`
   (browser tabs, their panes and sidebar folds); :mod:`.stores`: their
   files, channels and init terms.
-- :mod:`.ops`: the ops over them.
+- :mod:`.ops`: the ops over them, all but the desks'.
+- :mod:`.desks`: the desks: their ops (``web.desks.add_plane``, ...), the
+  browser node and feed, the desk pruner.
+- :mod:`.home`: Home and the home indexer; :mod:`.planes`: every plane
+  the device ships with, made at open (search and settings live there).
 - :mod:`.nav`: the driver running what the panes show.
 - :mod:`.device`: the server and one arm per tab, the sidebar, viewer and
-  desks feeds under it, and :mod:`.planes` (the home, settings and search
-  role planes) it ships with.
+  desks feeds under it.
   Imported by the host only: it pulls in the web server.
 
 Safe for a worker to import: nothing imported here pulls in a server.
 """
 
+from . import desks
+from .interactions import url
 from .ops import (
     add,
     close_tab,
     collapse,
-    create_desk,
-    delete_desk,
-    desk_order,
     expand,
-    get_desk,
     href,
     link,
-    list_desks,
-    move_desk,
     on_params,
     open_tab,
+    page,
     params,
     restart_cell,
     restart_pane,
     set,
-    set_desk,
     set_pane_params,
     set_panes,
     set_role,
@@ -66,24 +66,20 @@ __all__ = [
     "add",
     "close_tab",
     "collapse",
-    "create_desk",
-    "delete_desk",
-    "desk_order",
+    "desks",
     "expand",
-    "get_desk",
     "href",
     "link",
-    "list_desks",
-    "move_desk",
     "on_params",
     "open_tab",
+    "page",
     "params",
     "restart_cell",
     "restart_pane",
     "set",
-    "set_desk",
     "set_pane_params",
     "set_panes",
     "set_role",
+    "url",
     "visit",
 ]

nuspace-0.7.2/src/nuspace/web/desks/__init__.py

@@ -0,0 +1,58 @@
+"""The desks: their ops, the tab's copy of the desks and the roles, and the pruner.
+
+``ops``
+    The desk ops a program calls, re-exported here::
+
+        import nuspace.web.desks as desks
+
+        nuspace.atomic(desks.add_plane(desk_id, plane))
+
+``model``
+    The desk shape in plain python, and the hosts running it.
+``ref``
+    The node the browser keeps, write only: it draws nothing.
+``interactions``
+    Everything that node says and hears, in the browser's words.
+``feed``
+    One arm per interaction. An event runs one op, a store change ships
+    the desks, the roles or the desk planes' titles again.
+``pruner``
+    The system plane taking removed planes off every desk.
+
+The wire contract is ``task-167/contract.md`` in Go.
+"""
+
+from nuspace.web.desks.ops import (
+    add_item,
+    add_plane,
+    create_desk,
+    delete_desk,
+    get_desk,
+    list_desks,
+    move_desk,
+    move_item,
+    remove_item,
+    rename_desk,
+    reset_item,
+    save_desk,
+    set_item,
+    write_items,
+)
+
+
+__all__ = [
+    "add_item",
+    "add_plane",
+    "create_desk",
+    "delete_desk",
+    "get_desk",
+    "list_desks",
+    "move_desk",
+    "move_item",
+    "remove_item",
+    "rename_desk",
+    "reset_item",
+    "save_desk",
+    "set_item",
+    "write_items",
+]

nuspace-0.7.2/src/nuspace/web/desks/feed.py

@@ -0,0 +1,152 @@
+"""The desks feed: one arm per interaction, all in parallel, for one tab. Host only.
+
+- **browser to store.** A desk event runs its ops in one Web commit: a
+  create, a rename, a delete, a move, or ``items.write``, item writes on
+  one desk or more (a move across desks is one of these). A failure toasts
+  on the tab (:meth:`~nuspace.web.utils.Arms.event`) and writes nothing.
+- **store to browser.** Any desk write (a desk created, renamed, moved or
+  deleted, an item set, moved or taken off, by any tab or program): every
+  desk ships again, whole, read back as ``{name, items}``, in sidebar
+  order, with that order as a list. A desk is a few hundred bytes, so
+  shipping all of them is cheaper than tracking which one moved. The roles
+  changed: the roles ship again.
+- **titles.** The title and icon of every plane a desk links to, original
+  or recent, ship as their own write, so a tab names an item it neither
+  has open nor sees in its lazy tree. They ship again when the desks
+  change and when a plane's name or icon changes, the watches the
+  sidebar's tree uses. A plane with no row, or removed, is left out.
+
+Level, with no re-checks, as the sidebar: a missed notification leaves
+the tab stale until the next change.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import nu
+import nuspace
+from nuspace.ops.brackets import atomic
+from nuspace.shapes.space import Space
+from nuspace.web import ops as web
+from nuspace.web.desks import interactions
+from nuspace.web.desks import ops as desk_ops
+from nuspace.web.desks.model import DeskPlanes, DesksView, Items
+from nuspace.web.shapes import Web
+from nuspace.web.utils import Arms, field_dict, field_dicts, field_str
+
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from nustd.ui.core import Ref
+
+
+__all__ = ["desks_feed", "titles"]
+
+
+def _ship(read: nu.Nu, send: Callable[[nu.Dict], nu.Nu]) -> nu.Nu:
+    """``read`` in one snapshot, then ``send(value)`` to the browser."""
+    return nu.let(atomic(read), lambda held: send(nu.Dict(held)))
+
+
+def titles() -> nu.Dict:
+    """``{plane_id: {title, icon}}`` for every plane a desk links to, original or recent. Bare read.
+
+    A title or icon the plane lacks is ``""``. A plane with no row, or
+    removed, is left out. Cost: one read of the desks, four reads a plane
+    on them.
+    """
+
+    def look(at: nu.Attr) -> nu.List:
+        plane = nu.Str(at)
+        row = Space.planes[plane]
+        return nu.List.of(
+            plane, nu.Dict.of(title=row.name.fallback(""), icon=row.icon.fallback(""))
+        )
+
+    planes = nu.List(DeskPlanes(Web.desks.extract()))
+    shown = planes.iter().filter(lambda p: nuspace.plane.exists(nu.Str(p)))
+    return nu.dict(shown.map(look).to_list())
+
+
+def _create(ev: nu.Attr) -> nu.Nu:
+    """``desk.create``: the desk, last, then its items in their order."""
+    desk_id = field_str(ev, "desk_id")
+    desk = field_dict(ev, "desk")
+    made = desk_ops.create_desk(nu.Str(desk["name"]), id=desk_id)
+    return made >> desk_ops.write_items(desk_id, Items(desk["items"]))
+
+
+def _move(ev: nu.Attr) -> nu.Nu:
+    """``desk.move``: in front of ``before``, last for ``""``."""
+    desk_id, before = field_str(ev, "desk_id"), field_str(ev, "before")
+    return nu.IfDo(
+        before == "", desk_ops.move_desk(desk_id), desk_ops.move_desk(desk_id, before=before)
+    )
+
+
+def _write(ev: nu.Attr) -> nu.Nu:
+    """``items.write``: each desk's writes in turn, the caller's one commit around them all."""
+
+    def one(held: nu.Attr) -> nu.Nu:
+        w = nu.Dict(held)
+        return desk_ops.write_items(nu.Str(w["desk_id"]), w["sets"], w["deletes"], w["order"])
+
+    return nu.ForEachDo(field_dicts(ev, "writes"), one)
+
+
+def desks_feed(desks: Ref, toasts: Ref) -> nu.Nu:
+    """The desks, the roles and the desk planes' titles of one tab, live, as one term. Built per tab, never ends.
+
+    Args:
+        desks: The shell's desks ref.
+        toasts: The tab's toast ref, where a failed event shows.
+    """
+    arms = Arms("desks", toasts)
+
+    def op(name: str, change: nu.Nu, run: Callable[[nu.Attr], nu.Nu]) -> nu.Nu:
+        return arms.event(name, change, lambda ev: atomic(run(ev)))
+
+    def send_desks(held: nu.Dict) -> nu.Nu:
+        return interactions.set_desks(desks, held, nu.list(held.keys()))
+
+    shipped_desks = _ship(DesksView(Web.desks.extract()), send_desks)
+    shipped_roles = _ship(Web.roles.extract(), lambda r: interactions.set_roles(desks, r))
+    shipped_titles = _ship(titles(), lambda t: interactions.set_titles(desks, t))
+    on_desks = atomic(Web.desks.on_change())
+    return nu.ParallelAsync(
+        arms.states("desks", [on_desks], shipped_desks),
+        arms.states(
+            "roles",
+            [atomic(Web.roles.on_children_change()), atomic(Web.roles.on_descendants_change("*"))],
+            shipped_roles,
+        ),
+        arms.states(
+            "titles",
+            [
+                atomic(Web.desks.on_change()),
+                atomic(Space.planes.on_descendants_change("*", "name")),
+                atomic(Space.planes.on_descendants_change("*", "icon")),
+            ],
+            shipped_titles,
+        ),
+        op("create", interactions.on_create_desk(desks), _create),
+        op(
+            "rename",
+            interactions.on_rename_desk(desks),
+            lambda ev: desk_ops.rename_desk(field_str(ev, "desk_id"), field_str(ev, "name")),
+        ),
+        op(
+            "delete",
+            interactions.on_delete_desk(desks),
+            lambda ev: desk_ops.delete_desk(field_str(ev, "desk_id")),
+        ),
+        op("move", interactions.on_move_desk(desks), _move),
+        op("write", interactions.on_write_items(desks), _write),
+        op(
+            "role",
+            interactions.on_set_role(desks),
+            lambda ev: web.set_role(field_str(ev, "role"), field_str(ev, "plane_id")),
+        ),
+    )

{nuspace-0.7.1/src/nuspace/devices → nuspace-0.7.2/src/nuspace}/web/desks/interactions.py

@@ -13,7 +13,7 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
-from nuspace.devices.web.utils import event, write
+from nuspace.web.utils import event, write
 
 
 if TYPE_CHECKING:
@@ -25,8 +25,9 @@ __all__ = [
     "on_create_desk",
     "on_delete_desk",
     "on_move_desk",
-    "on_set_desk",
+    "on_rename_desk",
     "on_set_role",
+    "on_write_items",
     "set_desks",
     "set_roles",
     "set_titles",
@@ -37,7 +38,7 @@ __all__ = [
 
 
 def set_desks(desks: Ref, held: DictArg, order: ListArg[str]) -> Nu:
-    """Replace every desk: ``{desk_id: desk}``, each desk the whole dict, and ``order``, their ids in creation order."""
+    """Replace every desk: ``{desk_id: {name, items}}``, each desk whole, and ``order``, their ids in sidebar order."""
     return write(desks, "set_desks", desks=held, order=order)
 
 
@@ -55,13 +56,23 @@ def set_titles(desks: Ref, titles: DictArg) -> Nu:
 
 
 def on_create_desk(desks: Ref) -> Changed:
-    """``{desk_id, desk}``. The browser minted ``desk_id``."""
+    """``{desk_id, desk}``, ``desk`` as ``{name, items}``, last among the desks. The browser minted ``desk_id``."""
     return event(desks, "desk.create")
 
 
-def on_set_desk(desks: Ref) -> Changed:
-    """``{desk_id, desk}``. The desk whole, last write wins."""
-    return event(desks, "desk.set")
+def on_rename_desk(desks: Ref) -> Changed:
+    """``{desk_id, name}``."""
+    return event(desks, "desk.rename")
+
+
+def on_write_items(desks: Ref) -> Changed:
+    """``{writes: [{desk_id, sets, deletes, order}]}``: item writes on one desk or more, as one commit.
+
+    ``sets`` item id to item (no id in it), ``deletes`` and ``order`` item
+    ids. A move across desks is one event: a delete on one desk, a set on
+    the other.
+    """
+    return event(desks, "items.write")
 
 
 def on_delete_desk(desks: Ref) -> Changed: