# The plug The plug is the contract between a module and the shell. A module hands the shell parts (`LightOS.register({...})`). The shell hands back the `api`. This note also covers messages, the data door, the import door, the package, and why a module is refused. Plug version is **1**. Look version is **1**. Every module says `needsShell: 1` today. Start a new module from `templates/module.template.js`. Read with `look.md`, `lightos.sop.md`, `kit.md` and the module's own `.vision.md` and `.sop.md`. Only what exists today is described; the last section lists what is not built. **Words.** The **shell** is `lightos.html`: data layer, door, import door, side tree, command center and Terminal engine, look, Settings, messages, routing. A **module** is one file, `.module.js`, that calls `LightOS.register` once. A **box** is the element the shell hands a module to draw in (`api.where` is `centre`, `split`, `lens`, `over`, `card`, `embed` or `settings`). A **kind** is a named list of records, plural (`cards`); a few kinds are one plain object (`settings`, `readAt`). A **shape** is one thing, singular (`card`); the door calls it `"shape"`. A **ref** is `{ kind:"page", id:"pg-12" }` (`kind` is the shape word). A **pack** is a block of door commands. **Off** hides a module; **taken out** moves its file to `Cold/`; data is never touched either way. Screen words are Joel's words; the app's name comes from `api.util.appName()`. ## A module file ```js (function () { "use strict"; LightOS.register({ id: "notebook", name: "Notebook", icon: "notebook", blurb: "Pages that say how to fix things.", version: "1.4.0", needsShell: 1, owns: ["pages"], reads: ["cards", "labels"], shapes: { page: "pages" }, mount(box, api) { /* draw */ }, unmount(box) { /* clean up */ } }); })(); ``` - Call `register` once. Do nothing else at load: no drawing, timers, listeners or globals. - Never touch `localStorage`, `sessionStorage`, IndexedDB, files or the clipboard. Never open a file picker or start a download. Use `api.data`, `api.files`, `api.copyText`, `api.download`. - Never find anything by page id or add `id` attributes. Use `api.part(name)` or `box.querySelector`. - Work offline. Never call a server yourself (`fetch`, `XMLHttpRequest`, `WebSocket`, `EventSource`, `sendBeacon`): only the shell's network door may, when the workplace pack allows it. The build's guard stops on them. Never write an html, head, body or script end tag as text, even in a comment: the build refuses it. - Keep workplace words out of a shared module (no Talison, ServiceNow, ticket numbers, AD, asset tags or site names, not even in help). A workplace's things come in through its pack, kit, sources and modules. See `lightos.sop.md` › "Workplaces". - One function per action: a button and its command call the same function. Your commands live in your module, as a thin table that points at those functions. `register` returns `true`, or `false` when it refuses. The reason shows on the module's row in Settings › Modules. | Problem | What Joel sees | |---|---| | `needsShell` above the shell's plug | "Hello was built for a newer LightOS (plug 2). This one has plug 1, so it was not loaded." | | `id`, `name`, `version`, `needsShell`, `owns`, `reads` or `mount` missing | "This module could not load: it has no version." | | `mount` not a function; `owns` / `reads` not lists | "…its mount is not a step it can run." / "…its owns and reads must be lists." | | `id` not lower-case letters, digits, dashes | "…its id must be plain lower-case letters." | | Id already here | "There are two modules called notebook. The second one was not loaded." | | Owns `settings`, `notes` or `places` | "Hello cannot look after notes: that is the shell's. Hello was not loaded." | | Owns a kind or claims a shape another module has | "Notebook and Hello both look after pages. Hello was not loaded." / "…both answer for page…" | | A Terminal word the shell or another module holds | The word is refused, with a note on its row | | `register` called twice; file throws; never calls `register` | "hello.module.js registered twice. Only the first was kept." / "…could not load: (message)." / "…did not call LightOS.register, so nothing was added." | In the single file, a module in `Modules/` with a higher version than the built-in one wins. ## The register parts | Part | Must? | What it is | |---|---|---| | `id`, `name`, `icon`, `blurb` | id, name | Who it is. `icon` is a look icon name. Built-in ids keep a fixed sidebar order; others go after, by name | | `version`, `needsShell` | must | Semver `"1.4.0"`; the plug version it was built for | | `needsShellStandalone` | – | Plug it needs without the kit (see "A standalone package (3.2)") | | `owns`, `reads` | must (may be `[]`) | Kinds it changes in place / only reads | | `shapes` | if it owns data | `{ page:"pages" }`: one-thing word to kind | | `mount(box, api)`, `unmount(box)` | mount | Draw / clean up | | `open(ref, api)` | if it has things | Show one thing. Return `true`, or `false` if it could not | | `start(api)` | – | Work while on, with no box. May return a stop function | | `tree(api)` | – | Provider for the one shared tree. None means no side panel | | `search` | – | List of search parts | | `place` | – | Its place in the Terminal (`cd`), Browse rows | | `commands`, `keys` | – | Terminal commands; one-letter keys that work anywhere | | `copy` | – | `copy ` summaries and `copy guide` lines | | `actions` | to let others change its data | Door actions per shape | | `imports` | – | File types it claims at the import door | | `upgrade(fromVersion, api)` | – | Changes its stored data for a new version | | `settings(box, api)` | – | Its part of Settings | | `badge(api)` | – | Count on its sidebar row | | `routeNow(api)`, `route(parts, api)` | – | Its part of the address after `#/id` | | `beside`, `lens` | – | `beside`: may open in the split pane. `lens`: the Schedule's lens may sit beside it (Schedule not built) | | `card` | – | Its parts of a card's sheet in Decks | | `embed(box, ref, api)` | – | Draw one of its things, read only, in a box another module lends | | `opening` | – | `{ : "sentence" }` said while that kind is not loaded. Default: " is still opening. Try again in a moment." | | `topbar(el, api)` | – | One small button left of the bell. Return a function called when it goes | | `css` | – | Its styles. Every selector starts `.m-`; layout only, look tokens only, never restyle an `lo-` class | | `alwaysOn` | Decks only | No off switch | | `parts` | – | 3.2.20: lists it gives other modules, by name: `{ sources: [...], cardKeys: [fn] }`. See "Plug lists (3.2.20)" | | `system`, `early(sys, api)` | system modules only | A-J4: `system: true` marks a system module (see "System modules (A-J4)"). `early(sys, api)` runs before the data loads and gets `sys` (the extra object in "System modules (A-J4)") and the module's own `api`; only a system module that is built in or has Joel's stamp ever runs it. `api.system` does not exist | | `kits` | – | 3.2.12: the workplace kits it needs, like `["talison"]`. With one off it still loads and opens, and the shell says "That needs the Talison kit, which is off." (a toast when it opens, and on its error card if it breaks) | ## The parts, one by one **owns, reads, shapes.** The shell routes a door action, `api.open` and a search result by `shapes`. A shape names a kind the module owns (Map's `place` names the shell's read-only `places`). `settings`, `notes` and `places` are readable by every module and owned by none. Tickets are keyed by `number`; the shell uses `number` wherever it uses `id` for them. New kinds are lists, never objects. **mount.** The shell unmounts what was in the box (removing its api's listeners), empties and resets the box (`lo-box m-`, `data-module`, `data-where`), adds the module's `css` once, makes a fresh api, calls `mount` in try/catch (a throw shows the error card), then `open(ref, api)` if something waits. In the middle only, it draws the tree in the side panel. - **One box at a time.** Keep view state per box (a `WeakMap`), never module-wide. Never change the box's class or style. The box is a size container: use `@container lo-box`, not `@media`. - In the middle draw only what is open, never your own `.lo-split-list`. In the split pane draw your own tree with `api.look.tree(el, P)`. At 860 px or less there is no split pane: `{ beside:true }` opens in the middle. - Redraw on `data.changed`. In `unmount` undo what the shell cannot see: listeners on the box, `window`, `document`, timers, per-box state, object URLs. - Listen for keys, drops and pastes only inside your own box. An event your element handled (`preventDefault` or `stopPropagation`) is never taken by the shell. - A module moves only through its tree. The middle shows what is open, never a second clickable list of the section's things. What acts on the whole section (New, Clear, Bring in) goes in the tree (`add`, `onNew`, a row's `menu`, `head()`). **start.** Runs once when the module is on, before any `mount`. The api given to `start`, `tree`, `search`, `commands`, `keys`, `copy`, `actions`, `imports`, `upgrade`, `badge`, `route` and `card.replies` has no box (`api.box` and `api.where` are `null`). An Escape `keys` entry gets its box's api; `card.panel` gets the card box's api. **tree(api).** Returns a provider `P`. The shell calls `tree(api)` before every draw; keep lasting state (search text) outside `P`. | Field | What it is | |---|---| | `id`, `title`, `count` | Short name (folds are kept under it), heading, number beside it | | `ph`, `q()`, `setQ(v)` | The search box: placeholder, text, change | | `roots()`, `kids(n)` | The rows | | `on(k)`, `current()`, `open(k)` | Is this the row you are on; which that is; click or Enter (return `false` and the shell folds the row instead) | | `add(k)`, `menu(btn, k)` | The + and … on a row (drawn only if the row asks) | | `move(k, t, where)`, `canDrop(k, t, where)` | A row dropped on another | | `isOpen`, `setOpen`, `defOpen`, `reveal()` | Folds; rows to unfold so the current one shows | | `hits()`, `none`, `hitsNote()` | Search results `[{ k, t, s, x, sub, head }]` (escaped html), text for none, note above | | `wire(body)`, `searched()`, `slow` | Extras for results (`wire` may add listeners to `body` only); `slow` waits while typing | | `head()`, `newLabel`, `onNew()`, `cap`, `empty` | Heading menu; foot row; rows before "search"; empty text | A row: `{ k, name, label, icon, badge, dot, ncls, cls, title, add, addTitle, menu, drag, leaf }`, or `{ sep:true }` (a light line). `k` is unique; `name` is escaped html; `label` plain text; `icon` a look icon name; `badge` a number, short text or `{ n, warm:true, title }` (never html); `dot` is `true` or a flag text; `cls` only `idle`; `ncls` only `untitled` or `warn` (other classes are dropped). **search.** A list of parts, one per shape. | Field | What it is | |---|---| | `kind`, `label`, `word`, `key`, `icon` | Shape word; result heading; scope word (`greetings ` + space); optional one-key scope (`@`, `#`); row icon | | `kinds` | Kinds its things come from. The shell rebuilds only when one changes | | `things(api)` | Every searchable thing. Called once and kept; first call is when search first opens, never at start-up | | `boost(q)` | Optional number added to scores | | `peek(thing, api)` | Peek card or `null`: `{ sub, facts:[[icon, label, value, { mono, pill }]], body?, avatar?, today? }` | | `related(ref, api)` | "Look inside": `[{ label, refs:[ref…] }]` of its things that link to `ref`. The shell asks **every on module** | | `second` | Ctrl+Enter: `{ label(thing, api), run(thing, api) }`. A hand gesture: send changes with `{ gesture:true }` | | `show(ref, t, api)` | Print one thing in the Terminal. Throw plain words when gone | | `findAll(w, api)` | Its part of `find` at the top: `[{ id, name, where }]`, `w` lower case | A thing: `{ id, title, detail, match:[[text, weight]], fill:[text], icon?, sub?, hidden?, props? }`. Keep `match` short. `sub` shows small beside the title in look-inside rows. `hidden:true`: search never matches or offers it, but peek, look inside and open still reach it by id. `props` feeds `+` and `-`: an object of plain values `{ state:"Closed", labels:["Urgent"], shared:true }`, or a step `props: () => ({…})` called only when a filter is typed. Without `props`, `+` never keeps the thing and `-` never drops it. Peek `pill` is `true`, `"warm"` or `"green"`; `avatar` is a person's name; `today` (with `avatar`) is `"w"` on site, `"h"` from home, `"o"` off. Filters: `+value` keeps things with a prop of that value; `-value` leaves them out; quotes allow spaces; a term matches a whole value or whole word, case-blind. `#ticket` scopes to that kind. `john #ticket -closed` is John's open tickets. Search has no commands; the Terminal uses `show` and `findAll`, not the search engine. **place.** `place: { id, what, sum, ls, find, add, foot }`: `id` is the word after `cd`; `foot` (3.2.21) puts its `sum` in the Terminal's footer (`true`, or words to add after it, like `"items"`); `sum` is a function giving "now" text; `ls`, `find` and `add` each name a command (typed words are added on) or are a function `(t, api)`. No `find` means `find` at the top. Optional `browse(cwd, q, api)` gives Browse rows `[{ ref, label, dot, cmd? }]` (or `{ wait:"…" }` while loading); without it Browse lists the module's search things. A place with levels (Decks) adds `inside: { cd, path, complete, list }` and optionally `rows(cwd, api)`. The cwd is `{ place, refs }` (`t.cwd`, `api.terminal.cwd()`). **commands.** Fields: `word`; `sub` (second word for a shared word, `add person`); `also` (other words); `usage` (example line); `help` (the `?` text; none means no row); `group`, `order` (heading and position; new rows use 1000 and up); `part`, `join`, `alone` (only for a `?` row two owners share); `complete(c, api)`; `run(t, api)`. - A word belongs to one module; a word and sub-word count as separate words. The shell's words: `? help clear cls exit open history undo copy theme themes modules module version versions update`. - A module's own settings are one command: `word:"set"`, `sub:""` (`set hello remind off`). A setting in `api.prefs` is set directly; a shell setting goes through the door. Everything a person can do in a module can also be done by a command or a door action. - `complete(c, api)` gets `c = { rest, word, sub }`; `rest` is untrimmed. Return strings that could replace the whole `rest`, or `[]`. Offer only what `run` takes. Never start a load. `t` in `run(t, api)`: | `t.` | What it is | |---|---| | `line`, `word`, `rest`, `args` | Whole line; the word; text after it, trimmed; that text in words (quoted stay together) | | `out(tone, html)`; `ok`, `err`, `warn`, `dim`, `head(text)` | Print a line (tones `""`, `ok`, `err`, `warn`, `dim`, `head`); the second group takes plain text | | `tone(name, text)` | Coloured bit as html: `dim gho ok err warn hl key bold was`. Never write class names | | `block(html)` | Print html. The one way to print a table or box | | `table(cols, rows, o)`, `box(title, rows)` | **Return** html. `cols` `[[label, cls, cap]]`; `rows` `[{ cells:[html], ref?, cmd?, cls? }]` (`ref` opens on click, `cmd` runs a line). `box` rows `[[key, html]]` | | `cards`, `status`, `link(label, target)`, `verb`, `esc`, `room` | Card table rows; status word; Terminal link (`target` a ref or a line); colour a door line's first verb; safe html; characters across | | `door(ops, note)` | Check ops; if any fail print them and change nothing; else apply and return the log entry | | `refs(list)`, `ref(n, kind)` | Set "the last list"; get number n (throws a plain message if none or wrong kind) | | `cwd` | `{ place, refs }` | Throw `new Error("plain words")` for a problem. `run` may return a promise. A command that changes data goes through the door (`t.door` or `api.data.send`); a read-only one may use `api.data.get`. **keys.** `keys: [{ key:"h", help:"Jot a new greeting", run: api => … }]`. Runs when the key is pressed, nobody is typing, no Ctrl/Cmd/Alt, and no menu, dialog or command center is open. A key belongs to one module. The shell keeps `/`, `k`, `K`, Ctrl+K. `key` matches exactly (`"s"` and `"S"` are two). **Escape**: the shell closes its own layers first, then offers Escape to the split pane module, then the middle one; `run(api)` returns `true` when it used the key. **here** (3.2.16): `{ key:"f", here:true, run }` works only while that module is in the middle or the split pane (the middle first; the key's one owner wins while it is on screen), and several modules may share it. Its `run` gets that box's api and returns `false` to let the key pass on. **copy.** `copy: { targets:[{ word, usage, also?, order?, summary(arg, out, api) }], guide:[{ section, order, text, part?, join? }] }`. - The shell makes the envelope `{ "lightos":"summary", "v":1, "made", "app", "what", "reply_with", …, "cut", "note" }`; `summary` fills the module's fields. `out.cap(list, n, name)` keeps the first n and notes "n of m shown". `out.lean(o)` drops blank, empty, `false`, `null` fields. `out.say(text)` adds a sentence to the note (use it when a kind is still loading). `summary` may return a promise. Throw for a problem. - The first target whose word starts with what was typed wins. `copy` alone is `copy cards`. The shell owns `copy settings`, `history`, `result`, `guide`. - **One word, several modules:** give targets the same `word` and `usage` and an `order`. Every on module's `summary` fills one `out`. With none on: "That needs , which is off." (`copy places`: Map fills `map`, Assets `devicePlaces`, People `buildings`.) - Guide: sections come in a fixed order, new ones just before `Rules:`. Lines sort by `order` in a section. A line two owners share uses `part` and `join`. **actions.** `actions: { : { ops:["add","done"], run(op, ctx) } }`. One run step per shape. The shell calls it twice: on a copy (check), then for real (apply), so the preview can never disagree with the result. An op not in `ops` gives '"fly" on a greeting is not something the Terminal can do.' A step reads `ctx.data(kind)`, checks with `ctx.keys` and `ctx.fail`, calls `ctx.touch` before changing an old record and `ctx.mark` on what it changed, queues messages with `ctx.after`, and returns a verb line such as `"Add greeting " + ctx.q(text)`. **imports.** `imports: [{ name, about, binary?, test(file, text, info), read(file, text, api, info) }]`. See "The import door". **upgrade.** For a version that changes how its own data is stored. The shell calls it once, with the version that last wrote the data, after it copied Data and asked the person (import check 6). Change records in place, then `api.data.changed(kind)`. Be safe to run on data that is already new. Keep every old step. If it throws, the shell puts the copy back and keeps the old version. After an upgrade the command log can no longer put back that module's older records. **settings, badge, routeNow, route.** `settings` has the same box rule; save with `api.prefs`; shell settings change through the door (`"shape":"setting"`) with `{ gesture:true }`. `badge` returns a number, short text or `{ n, warm, title }`, asked again after every `data.changed` and `viewChanged`. `routeNow` gives its part of the address; `route(parts, api)` turns an address into a ref or `null` (the shell mounts the module, then calls `open(ref)`). Call `api.viewChanged()` whenever what the middle shows changes some other way. **card.** `card: { order, panel(box, ref, api), replies(ref, api) }`. Decks calls `api.cardParts(el, { kind:"card", id })` each time it draws the sheet, and `(el, null)` when it closes. For every on module with `panel`, in `order`, the shell adds a box (`lo-box m-`, `data-where="card"`) and calls `panel`. A throw leaves the box empty and shows on the module's row. `replies` returns `[{ ref, title, text }]`; `api.cardReplies(ref)` gives every on module's, 5 at most (`ref` may be `{ kind:"tickettype", id }`; a module that only knows cards returns `[]`). **embed.** The borrower calls `api.embed(el, ref)`. The shell finds the on module that owns the shape, adds a box to `el` (`data-where="embed"`) and calls its `embed(box, ref, api)`. Returns `true` when the owner drew; `false` (nothing drawn) when the owner is off, not here, has no `embed`, is the borrower, or throws. `api.embed(el, null)` removes the box. The owner changes data only through the door. ## The api One `api` per box (from `mount` and `settings`) and one per module (every other part). Box listeners go when the box unmounts; module listeners go when the module is turned off. `api.box`, `api.where`, `api.id` and `api.part(name)` are as named. ### api.data | Call | What it does | Notes | |---|---|---| | `get(kind)` | Live list | `[]` (`{}` for an object kind) if none yet. Only kinds in `owns` or `reads`, plus `settings`, `notes`, `places`; else throws "Hello did not say it reads assets. Add it to reads." Read on every draw; never keep your own copy | | `ready(kind, o)` | Promise, done when loaded | The ticket library loads on first ask. `ready("places",{again:true})` re-reads the old map store | | `loaded(kind)` | `true` once loaded | At once; starts nothing | | `changed(kind)` | "I changed this on my own page": save once, redraw once | Own kinds only (else throws "Hello does not own people. Send the change through the door."). Saves after 400 ms quiet; one `data.changed` a frame | | `send(pack, opts)` | Any other change, through the door | Promise of the result | | `check(pack)`, `undo(entryId)` | The check alone (promise of the plan); put a door entry back (promise of true/false) | | | `uid(prefix)` | New id `prefix-…` | | | `person(v)` | A person by email, login or name, or `null` | Needs `people` in `reads` | | `seen(kind, record)` | Clear a record's dot | Own kinds only | `send` options: `preview` (show in the Terminal old to new and wait for y or n), `skip` (apply what passes, skip the rest; otherwise nothing applies if any fails), `dots` (dot what changed; pasted blocks and previews always dot), `gesture` (a change made by hand on a page: checked and applied the same way but **not written to the command log**, so it never uses up the five undoable blocks; the result's `undo()` serves a toast's Undo). `send` resolves to `{ ok, lines, errors:[{ i, text }], missing, added, entry, undo }`. `added` is new ids by kind. `entry` is the log entry (`null` if nothing applied or a gesture). A gesture's `undo()` is refused when an owner is off, when a newer door change touched the same records ("Something changed it since. Nothing was put back."), and after a reload. Owner off: "That needs People, which is off." Not installed: "That needs Notebook, which is not here. Add it in Settings › Modules." Nobody owns it: "Nothing here looks after that." **Where a module may change its own kinds in place** (then `changed`), and nowhere else: its page, tree provider and the Undo on its toast; `open`, `settings`, `keys`; `start` and its message listeners; `upgrade`; an import `read` for its own kinds. **Everything else goes through the door**: any other module's kind, and its own kind from a command's `run` or `search.second.run`. A change that must show in `history` and come back with `undo` goes through the door too. Reading works whether or not the owner is on. Check `api.canOpen(…)` before drawing a link into another module. Key a cache on the list it was built from (a `WeakMap` on what `get` returned): trial copies are other lists, so a cache never mixes trial and real data. Every kind loads before the first `mount` except the ticket library. ### api.prefs, api.files `api.prefs.get(key, fallback)` / `set(key, value)`: a small saved object (`settings.prefs.`), plain JSON, under 50 KB. Records never go here. `set(key, undefined)` removes. | `api.files.` | What it does | |---|---| | `put(fileOrBlob, name)` | Promise of `{ id, name, size, type }`. Id is `f-…`. One file at most 8 MB (Map's pictures: 120 MB). A record holds only that meta | | `get(id)`, `url(id)`, `remove(id)` | Promise of the Blob or `null`; promise of a URL or `null`; promise (only when nothing points at it) | | `pick({ accept, import, many })` | Promise of the Files picked (`[]` if none). `import:true` sends the file through the import door, asking only this module's readers | | `inbox(name)` | A read-only folder to pick a saved file up from: `state()`, `choose()`, `allow()`, `forget()`, `open(url, o)`, `close()`, `wait({ match, after, timeout })`, `take(file, o)` (the import door as if dropped; `o.quiet` sets `info.quiet`). Nothing in it is changed or sent anywhere. Only Imports' ServiceNow page uses it | | `map(mapId)` | Promise of a site map picture URL, or `null` | | `oldMaps()` | **Map only.** Reads the old map store once for its one-time copy; writes nothing | A file dropped or pasted on the module's own element is the module's when its listener calls `preventDefault()`; keep it with `put`. A drop nothing in the box takes goes to the import door. A stored file is kept while any text inside any record of any kind, on or off, or any Undo copy equals its id. Modules only keep ids in records. ### Opening and closing | Call | What it does | |---|---| | `api.open(target, opts)` | Open `{ kind, id }` in the module that owns the shape, or a module by id (`"notebook"`), or `"settings"`. Returns `true`, or `false` with a toast "That needs Notebook, which is off." | | `api.canOpen(target, opts)` | `true` if that module is here, on, and has `open`. Also `canOpen("comms")` | | `api.close()` | Close this api's box. The split pane closes; the middle returns to Decks | | `api.lens(on)` | Read or set the Schedule's lens | | `api.viewChanged()` | The shell re-reads `routeNow` and redraws tree and badge | | `api.modules()` | Every installed module in sidebar order: `[{ id, name, icon, on, beside, owns, shapes }]` (3.2.21: `owns` the kinds it keeps, `shapes` its door shapes as `{ shape: kind }`) | `open` options: `beside` (split pane if the module has `beside`); `toggle` (with `beside`: close it if already there); `over` (open over what is showing, as Decks' card sheet: if a box already shows the owner, it opens there; else the owner mounts in the **over box**, a layer over the app, `api.where` `"over"`; `api.close()`, Escape and Back close it; the address gets `//`); `module:"assets"` (open the ref in that module; only when its `open` takes that kind, as Assets takes `person` and `place`). If a box already shows the module, `open` opens there; else the shell mounts it in the middle, calls `open`, updates the address and sends `opened`. ### Messages, drag, look, toast, notify `api.messages.send(name, payload)` and `.on(name, fn)` (returns a stop function). See "Messages". `api.drag.start(ref, event, { label })` drags a thing onto another module (after 6 px; Esc cancels). Any element with `data-drop=""` is a drop zone (`data-drop-value`, `data-drop-kinds="card,person"`); the shell adds `lo-drop-on` while a drag it takes is over it. The box holding the zone gets `drag.over` once a frame (and one with `zone:null` on leaving), then `drop` on release; the source then gets `drag.end`. A receiver's `drop` listener returns where it landed as plain data (handed to the source as `landed`), or `true` if it acted itself; nothing means not taken. The receiver acts: own kind in place plus `changed`; another module's kind through the door with `{ gesture:true }`. `api.look` is `look.md`'s `LookParts` plus: `version`, `theme()` (`{ id, name, dark }`), `themes()` (read only: switching goes through the door), `token(name)` (draw again on `theme.changed`), `icon(name, size)`, `tree(el, P)`. From the look: `menu(button, items, onPick, opts)` (items `{ label, icon, run, bad, sep }`), `select(button, { items, value, onChange })` (never a browser `