babavoss 0.12.6 → 0.13.1

package/src/runtime/harness.ts

@@ -6,7 +6,7 @@ import { manifestOf, type Baba } from "../ecs/baba.ts";
 import { Runtime, ContractError } from "../ecs/runtime.ts";
 import { StateError, type Snapshot } from "../ecs/state.ts";
 import { makeBridge, portOver } from "./bridge.ts";
-import { withPromptware } from "../promptware/system.ts";
+import { withInstructions } from "../agents/system.ts";
 
 /** How long a `state` read waits for the round past `since` before answering the state as it is. */
 export const STATE_WAIT_MS = 25_000;
@@ -23,7 +23,7 @@ export class Harness {
   /** Loads the baba over the snapshot given; answers `loaded`, or throws for `failed`. */
   load(own: Baba, project: { name: string; dir: string; baba: string }, env: Record<string, string>, snapshot: Snapshot | null, prepare = false): void {
     // Voss's own systems join every baba after its own.
-    const v = withPromptware(own);
+    const v = withInstructions(own);
     const manifest = manifestOf(v);
     const make = (snapshot: Snapshot | null, auto: boolean) => new Runtime(v, {
       auto,

package/src/server/edge.ts

@@ -5,13 +5,13 @@
 // same socket, in order. No file, no project, no Node here: only memory and IPC.
 import { isIP } from "node:net";
 import type { Server, ServerWebSocket, WebSocketHandler } from "bun";
-import type { Serve, Described, Failure, Describe, DescribeAnswer, View, ViewAnswer, Call, CallAnswer, Refresh, RefreshAnswer, Restart, RestartAnswer, Browse, BrowseAnswer, Add, AddAnswer } from "./messages.ts";
+import type { Serve, Described, Failure, Describe, DescribeAnswer, View, ViewAnswer, Call, CallAnswer, Refresh, RefreshAnswer, Restart, RestartAnswer, Browse, BrowseAnswer, Add, AddAnswer, Remove, Setup, SetSettings, SettingsAnswer, Rename } from "./messages.ts";
 import type { Raw } from "../ecs/runtime.ts";
 import type { Json } from "../kernel/schema.ts";
 import { frameHeader, resolveInterest, sliceFrame, type Resolved } from "../ecs/codec.ts";
 import { CLOSE, SOCKET_PROTOCOL, type Down, type Interest, type Up } from "./protocol.ts";
 
-interface Pairs { describe: [Describe, DescribeAnswer]; view: [View, ViewAnswer]; call: [Call, CallAnswer]; refresh: [Refresh, RefreshAnswer]; restart: [Restart, RestartAnswer]; browse: [Browse, BrowseAnswer]; add: [Add, AddAnswer] }
+interface Pairs { describe: [Describe, DescribeAnswer]; view: [View, ViewAnswer]; call: [Call, CallAnswer]; refresh: [Refresh, RefreshAnswer]; restart: [Restart, RestartAnswer]; browse: [Browse, BrowseAnswer]; add: [Add, AddAnswer]; remove: [Remove, AddAnswer]; setup: [Setup, AddAnswer]; "set-settings": [SetSettings, SettingsAnswer]; rename: [Rename, AddAnswer] }
 type Unnumbered<T> = T extends unknown ? Omit<T, "id"> : never;
 /** Sends a request to the kernel, numbered by the sender, and resolves with its answer. */
 export type Ask = <K extends keyof Pairs>(m: Unnumbered<Pairs[K][0]>) => Promise<Pairs[K][1]>;
@@ -294,7 +294,35 @@ export function edge(state: Serve, ask: Ask): Edge {
         const a = await ask<"add">({ type: "add", dir: body.dir, init: body.init === true, ...(typeof body.name === "string" && body.name ? { name: body.name } : {}), ...(typeof body.title === "string" && body.title ? { title: body.title } : {}) });
         return a.ok ? json(a.value) : failed(a);
       }
-      if (parts[1] === "projects") return json({ projects: state.projects, voss: state.voss, home: state.home });
+      // /api/projects/remove: forget a folder, its files kept. /api/projects/setup: set what voss requires of the folder's baba, making its .baba first when there is none.
+      if (parts[1] === "projects" && (parts[2] === "remove" || parts[2] === "setup") && parts.length === 3) {
+        if (req.method !== "POST") return json({ error: { code: "notfound", message: "no such route" } }, 404);
+        let body: { dir?: unknown; values?: unknown } = {};
+        try { body = await req.json() as typeof body; } catch { return json({ error: { code: "args", message: "the body is not JSON" } }, 400); }
+        if (typeof body.dir !== "string" || !body.dir) return json({ error: { code: "args", message: "dir: the folder, absolute" } }, 400);
+        if (parts[2] === "remove") { const a = await ask<"remove">({ type: "remove", dir: body.dir }); return a.ok ? json(a.value) : failed(a); }
+        const v = (typeof body.values === "object" && body.values ? body.values : {}) as Record<string, unknown>;
+        const a = await ask<"setup">({ type: "setup", dir: body.dir, values: typeof v.name === "string" ? { name: v.name } : {} });
+        return a.ok ? json(a.value) : failed(a);
+      }
+      // /api/projects/rename: a baba under another name, its address moving with it.
+      if (parts[1] === "projects" && parts[2] === "rename" && parts.length === 3) {
+        if (req.method !== "POST") return json({ error: { code: "notfound", message: "no such route" } }, 404);
+        let body: { name?: unknown; to?: unknown } = {};
+        try { body = await req.json() as typeof body; } catch { return json({ error: { code: "args", message: "the body is not JSON" } }, 400); }
+        if (typeof body.name !== "string" || typeof body.to !== "string") return json({ error: { code: "args", message: "name: the baba's name now; to: the name it takes" } }, 400);
+        const a = await ask<"rename">({ type: "rename", name: body.name, to: body.to });
+        return a.ok ? json(a.value) : failed(a);
+      }
+      if (parts[1] === "projects") return json({ projects: state.projects, pending: state.pending, voss: state.voss, home: state.home });
+      // /api/settings: voss's own settings, the person's; a POST changes them, `keys` naming commands with a binding or null for the default.
+      if (parts[1] === "settings" && parts.length === 2) {
+        if (req.method !== "POST") return json(state.settings);
+        let body: { theme?: unknown; keys?: unknown } = {};
+        try { body = await req.json() as typeof body; } catch { return json({ error: { code: "args", message: "the body is not JSON" } }, 400); }
+        const a = await ask<"set-settings">({ type: "set-settings", ...(typeof body.theme === "string" ? { theme: body.theme as SetSettings["theme"] & string } : {}), ...(body.keys && typeof body.keys === "object" ? { keys: body.keys as SetSettings["keys"] } : {}) });
+        return a.ok ? json(a.value) : failed(a);
+      }
       // /api/dirs?path=: the directories under one, for picking where a baba is or goes.
       if (parts[1] === "dirs" && parts.length === 2) {
         const a = await ask<"browse">({ type: "browse", path: url.searchParams.get("path") ?? "" });

package/src/server/main.ts

@@ -34,8 +34,9 @@ kernel.onMessage((m) => {
     return;
   }
   // The edge reads the projects and pages from the served state on every request.
-  if (m.type === "projects") { if (served) { served.projects = m.projects; served.pages = m.pages; } return; }
+  if (m.type === "projects") { if (served) { served.projects = m.projects; served.pending = m.pending; served.pages = m.pages; } return; }
   if (m.type === "voss") { if (served) served.voss = m.voss; return; }
+  if (m.type === "settings") { if (served) served.settings = m.settings; return; }
   if (m.type === "round") { live?.push(m.name, m.round, m.frame); return; }
   if (m.type === "generation") { live?.generation(m.name, m.gen); return; }
   const resolve = pending.get(m.id);

package/src/server/messages.ts

@@ -4,6 +4,9 @@
 import type { Described } from "../baba/node.ts";
 import type { Raw } from "../ecs/runtime.ts";
 import type { Interest } from "./protocol.ts";
+import type { Requirement, RequirementValues } from "../baba/requirements.ts";
+import type { Theme } from "../desktop/index.ts";
+import type { KeyChanges, KeyOverrides } from "../desktop/keys.ts";
 
 // ---- kernel → server ---------------------------------------------------
 
@@ -14,6 +17,20 @@ export interface Voss {
   kept: boolean;
   stale: boolean;
   installed: { version: string; sha: string; at: string } | null;
+  /** Where this voss is and what it runs on, for the settings' About page. */
+  about?: About;
+}
+/** Where a running voss is and what it runs on: its runtime, the package it runs from, the state it keeps, the service that keeps it running. */
+export interface About {
+  /** When this voss started, ISO. */
+  started: string;
+  runtime: { bun: string; platform: string; arch: string; executable: string };
+  /** The framework's package directory, and the CLI it was started with. */
+  framework: string; cli: string;
+  /** voss's own state: its root, the registry of babas, the page token. */
+  root: string; registry: string; token: string;
+  /** The user service's file and log, when one is installed; null otherwise. */
+  service: { file: string; log: string } | null;
 }
 
 /** Everything the server holds, sent once: it listens when this arrives. */
@@ -24,6 +41,10 @@ export interface Serve {
   token: string;
   voss: Voss;
   projects: ProjectEntry[];
+  /** The folders voss remembers that it does not run: each to be set up, or failed. */
+  pending: PendingEntry[];
+  /** The person's settings, voss-wide: what every baba's pages look like and the keys they run. */
+  settings: VossSettings;
   /** The user's home directory: the picker writes paths under it as ~/… and starts browsing there. */
   home: string;
   /** The page per scope: "" is the picker's, a project's name its own. The token meta is already in. */
@@ -34,6 +55,13 @@ export interface Serve {
 
 /** A registered project; `parent` is the nearest registered project whose directory holds it, for nesting. */
 export interface ProjectEntry { name: string; title: string; dir: string; parent: string | null }
+/**
+ * A folder voss remembers but does not run. To be set up when it lacks a required property, a .baba among them:
+ * `missing` names them, and the picker opens its wizard. Failed when it has them all and still does not open: `error` says why.
+ */
+export interface PendingEntry { dir: string; baba: boolean; missing: Requirement[]; error: string | null; parent: string | null }
+/** voss's own settings, the person's, kept in its root's settings.json: the theme of every page, the keys remapped on every desktop. */
+export interface VossSettings { theme: Theme; keys?: KeyOverrides }
 export interface Asset { mime: string; bytes: Uint8Array<ArrayBuffer> }
 
 export type { Described };
@@ -48,9 +76,9 @@ export type ViewAnswer = { type: "view-answer"; id: number } & ({ ok: true; gen:
 export type CallAnswer = { type: "call-answer"; id: number } & ({ ok: true; value: unknown; /** The round a fire or a raw write ran in. */ round?: number } | Failure);
 
 /** The registry changed: the projects and their pages, replacing what `serve` sent. */
-export interface Projects { type: "projects"; projects: ProjectEntry[]; pages: Record<string, string> }
-/** What a refresh did: the projects now open, and the directories that did not load, with why. */
-export interface Refreshed { projects: ProjectEntry[]; errors: { dir: string; error: string }[] }
+export interface Projects { type: "projects"; projects: ProjectEntry[]; pending: PendingEntry[]; pages: Record<string, string> }
+/** What a refresh did: the projects now open, the folders remembered but not run, and the directories that did not load, with why. */
+export interface Refreshed { projects: ProjectEntry[]; pending: PendingEntry[]; errors: { dir: string; error: string }[] }
 export type RefreshAnswer = { type: "refresh-answer"; id: number } & ({ ok: true; value: Refreshed } | Failure);
 
 /** A round of a project's live generation, as the frame every window of it gets. */
@@ -58,16 +86,19 @@ export interface RoundPush { type: "round"; name: string; round: number; frame:
 /** A project's generation advanced: its windows re-read the contract and resync. */
 export interface Generation { type: "generation"; name: string; gen: number }
 
+/** voss's settings changed: the edge answers with these from now on. */
+export interface SettingsPush { type: "settings"; settings: VossSettings }
+export type SettingsAnswer = { type: "settings-answer"; id: number } & ({ ok: true; value: VossSettings } | Failure);
 /** Voss's own standing changed: a newer one is installed. */
 export interface VossPush { type: "voss"; voss: Voss }
 export type RestartAnswer = { type: "restart-answer"; id: number } & ({ ok: true; value: { restarting: true; kept: boolean } } | Failure);
 /** A directory and what is under it: each child, whether it holds a baba, and whether it is already remembered. */
 export interface Browsed { path: string; home: string; parent: string | null; baba: boolean; known: boolean; dirs: { name: string; path: string; baba: boolean; known: boolean }[] }
 export type BrowseAnswer = { type: "browse-answer"; id: number } & ({ ok: true; value: Browsed } | Failure);
-/** What an add did: the project made or remembered, and the registry re-read. */
-export type AddAnswer = { type: "add-answer"; id: number } & ({ ok: true; value: Refreshed & { name: string; dir: string } } | Failure);
+/** What an add, a setup or a removal did: the folder, the baba's name when it runs, and the registry re-read. */
+export type AddAnswer = { type: "add-answer"; id: number } & ({ ok: true; value: Refreshed & { name: string | null; dir: string } } | Failure);
 
-export type ToServer = Serve | Projects | VossPush | DescribeAnswer | ViewAnswer | CallAnswer | RefreshAnswer | RestartAnswer | BrowseAnswer | AddAnswer | RoundPush | Generation;
+export type ToServer = Serve | Projects | VossPush | SettingsPush | DescribeAnswer | ViewAnswer | CallAnswer | RefreshAnswer | RestartAnswer | BrowseAnswer | AddAnswer | SettingsAnswer | RoundPush | Generation;
 
 // ---- server → kernel ---------------------------------------------------
 
@@ -93,5 +124,14 @@ export interface Restart { type: "restart"; id: number }
 export interface Browse { type: "browse"; id: number; path: string }
 /** Remember a project at `dir`; with `init`, make its .baba first, named and titled as given or after the directory. */
 export interface Add { type: "add"; id: number; dir: string; init: boolean; name?: string; title?: string }
+/** Forget the folder at `dir`: voss stops running its baba; its files stay. */
+export interface Remove { type: "remove"; id: number; dir: string }
+/** Set the required properties of the folder at `dir`, making its .baba first when it has none; then it runs. */
+export interface Setup { type: "setup"; id: number; dir: string; values: RequirementValues }
+
+/** Change voss's settings: the theme, keys remapped or given back their defaults. */
+export interface SetSettings { type: "set-settings"; id: number; theme?: Theme; keys?: KeyChanges }
+/** Rename the baba called `name`: its address moves to `/TO/`, and it runs again under it. */
+export interface Rename { type: "rename"; id: number; name: string; to: string }
 
-export type FromServer = Ready | Listening | Failed | Describe | View | Call | Refresh | Restart | Browse | Add;
+export type FromServer = Ready | Listening | Failed | Describe | View | Call | Refresh | Restart | Browse | Add | Remove | Setup | SetSettings | Rename;

package/src/shell/run.ts

@@ -9,7 +9,7 @@
 //   voss baba follow ENTITY | COMPONENT KEY [--until C | C.field=value] [--for 30s] [--changes]
 //   voss baba follow QUERY [args…] --changed [--for 30s]
 //   voss baba run [FILE | LINE …] | raw spawn JSON | add E COMPONENT [JSON] | remove E COMPONENT … | despawn E | set RESOURCE JSON
-//   voss baba check | install | add-system NAME | promptware … | serve [HOST:PORT]
+//   voss baba check | install | add-system NAME | agents … | serve [HOST:PORT]
 //   voss init [DIR] | babas … | gui [HOST:PORT] | service …
 //
 // Stdout is one line of JSON per answer (`--pretty` indents it); stderr is
@@ -30,8 +30,8 @@ import { serve } from "../http/server.ts";
 import { words, callArgs, usage, describeArgs, UsageError } from "./args.ts";
 import { init, install, addSystem } from "../baba/init.ts";
 import { check } from "../baba/check.ts";
-import { planProject, syncProject, outputOf, sources } from "../promptware/disk.ts";
-import { report } from "../promptware/sync.ts";
+import { planProject, syncProject, outputOf, sources } from "../agents/disk.ts";
+import { report } from "../agents/sync.ts";
 import * as service from "./service.ts";
 import { connect, daemon, type Client, type Daemon } from "./client.ts";
 import { runMcp } from "../mcp/main.ts";
@@ -131,7 +131,7 @@ const builtinHelp: Record<string, string> = {
   "add-system": "a system under .baba/systems/NAME: add-system NAME",
   serve: "the GUI for this baba alone: serve [HOST:PORT]",
   mcp: "an MCP server over stdio for agents, a client of the running voss",
-  promptware: "the harness files: promptware compile | sync | output PATH",
+  agents: "the agentic instructions compiled: agents compile | sync | output PATH",
 };
 
 /**
@@ -177,7 +177,7 @@ function globals(argv: string[]): { ws: string[]; pretty: boolean; max: number }
 
 export async function run(argv: string[], sh: Shell): Promise<number> {
   const reg = new Registry(sh.rootDir);
-  // Every answer is JSON; the promptware block below still reads this.
+  // Every answer is JSON; the agentic instructions block below still reads this.
   const json = true;
   let callUsage: string | undefined;
   let outDir: string | undefined;
@@ -304,7 +304,7 @@ export async function run(argv: string[], sh: Shell): Promise<number> {
     }
     if (name === "manifest") {
       // The baba loaded once, in this process, and let go: what every load writes, .baba/.voss/manifest.json, is there
-      // for the index, --schema and the promptware before the baba ever runs under the daemon, as in a fresh worktree.
+      // for the index, --schema and the agentic instructions before the baba ever runs under the daemon, as in a fresh worktree.
       const lines: string[] = [];
       const n = new Node(project, (l) => lines.push(l));
       try { await n.start(); } finally { await n.stop(); }
@@ -345,36 +345,36 @@ export async function run(argv: string[], sh: Shell): Promise<number> {
     const c = await connect(project, sh.rootDir, prog).catch(downOnly);
     const down = c instanceof NodeError ? c : null;
     const d = c instanceof NodeError ? null : await c.describe();
-    // Down, the promptware compiles from a manifest of the code as it is now: the baba is loaded once in this process and let
-    // go, as \`manifest\` does, so a fresh worktree has one and an edit to the promptware is in it. Busy or broken, the last one stands.
+    // Down, the agentic instructions compiles from a manifest of the code as it is now: the baba is loaded once in this process and let
+    // go, as \`manifest\` does, so a fresh worktree has one and an edit to the agentic instructions is in it. Busy or broken, the last one stands.
     let loadError: string | null = null;
-    if (down && name === "promptware") {
+    if (down && name === "agents") {
       const n = new Node(project, () => {});
       try { await n.start(); } catch (err) { loadError = err instanceof Error ? err.message : String(err); } finally { await n.stop().catch(() => {}); }
     }
     const m = d ? d.manifest : await readManifest(project);
     if (!m && loadError) throw new ShellError("failed", `${project.name} did not load: ${loadError}`);
     if (!m) { if (down) throw down; throw new ShellError("down", `${project.name} is not running${d?.error ? `: ${d.error}` : ""}`); }
-    if (name === "promptware") {
-      // Running, the baba's promptware system syncs, and the answer waits for it; down, the same compiler runs here over the files.
+    if (name === "agents") {
+      // Running, the baba's agents system syncs, and the answer waits for it; down, the same compiler runs here over the files.
       const [cmd, path] = args;
-      if (cmd === "sync" && d && !d.error && "promptware-sync" in m.actions) {
+      if (cmd === "sync" && d && !d.error && "agents-sync" in m.actions) {
         const live = c as Client;
-        const syncs = async () => await live.read("promptware-plan", {}) as { syncs: number; error: string | null };
+        const syncs = async () => await live.read("agents-plan", {}) as { syncs: number; error: string | null };
         const before = (await syncs()).syncs;
-        await live.fire("promptware-sync", {});
+        await live.fire("agents-sync", {});
         for (let i = 0; i < 200; i++) {
           const p = await syncs();
-          if (p.syncs > before) { if (p.error) return fail(`promptware sync: ${p.error}`); out(p); return 0; }
+          if (p.syncs > before) { if (p.error) return fail(`agents sync: ${p.error}`); out(p); return 0; }
           await new Promise((r) => setTimeout(r, 50));
         }
-        return fail("promptware sync: asked, not finished within 10s; promptware-plan says how it went");
+        return fail("agents sync: asked, not finished within 10s; agents-plan says how it went");
       }
       const input = sources(project.dir, m, project.title);
       if (cmd === "compile") { out(report(await planProject(project.dir, input))); return 0; }
       if (cmd === "sync") { out(await syncProject(project.dir, input)); return 0; }
       if (cmd === "output" && path) { const o = await outputOf(project.dir, input, path); out(json ? o : { path: o.path, status: o.status }); if (!json) sh.stdout(o.text); return 0; }
-      sh.stdout(`Usage: ${prog} promptware compile | sync | output PATH\n`);
+      sh.stdout(`Usage: ${prog} agents compile | sync | output PATH\n`);
       return help ? 0 : 2;
     }
     if (!name) {
@@ -462,7 +462,7 @@ function contract(prog: string, title: string, m: Manifest, error: string | null
   section("Resources", Object.entries(m.resources).map(([n, r]) => [n, r.owner]));
   section("Effects", Object.entries(m.effects).map(([n, e]) => [n, `${e.owner}${e.every ? ` · every ${e.every} ms` : ""}${e.retry ? ` · retry ${e.retry} ms` : ""}${e.summary ? ` · ${e.summary}` : ""}`]));
   section("The state", Object.entries(builtinHelp).filter(([k]) => ["state", "follow", "run", "raw"].includes(k)).map(([k, h]) => [k, h]));
-  section("Voss", Object.entries(builtinHelp).filter(([k]) => ["start", "stop", "status", "mcp", "check", "manifest", "install", "add-system", "serve", "promptware"].includes(k)).map(([k, h]) => [k, h]));
+  section("Voss", Object.entries(builtinHelp).filter(([k]) => ["start", "stop", "status", "mcp", "check", "manifest", "install", "add-system", "serve", "agents"].includes(k)).map(([k, h]) => [k, h]));
   lines.push(`State: ${where}${error ? ` · the last load failed: ${error}` : ""}`);
   return lines.join("\n") + "\n";
 }

package/src/spec/index.ts

@@ -91,7 +91,7 @@ export function spec(target: System | Baba, def: SpecDef<any, any> = {}): Spec<a
   if (!NAME.test(name)) throw new Error(`spec ${JSON.stringify(name)}: lowercase words joined by single dashes`);
   const base = whole ? (target as Baba) : baba({ systems: closureOf([target as System]) });
   const tick = def.tick === undefined ? base.tick : def.tick;
-  const v = tick === base.tick ? base : baba({ systems: base.systems, ...(tick !== null ? { tick } : {}), promptware: base.promptware, apps: base.apps });
+  const v = tick === base.tick ? base : baba({ systems: base.systems, ...(tick !== null ? { tick } : {}), instructions: base.instructions, apps: base.apps });
   const names = new Set<string>();
   for (const sc of def.scenarios ?? []) { if (names.has(sc.name)) throw new Error(`spec ${name}: two scenarios are named ${JSON.stringify(sc.name)}`); names.add(sc.name); }
   const also = def.also ?? [];

package/src/web/core.tsx

@@ -47,7 +47,7 @@ function routed(key: string, table: RouteTable): ComponentType<AppProps> {
  * the baba declares in `baba({ apps })`, and none other; the keys are checked against them. An app that
  * declares routes may be given a component per route instead, `{ "/": Prs, "/pr/:n": Pr }`, checked
  * against its routes: every route, none other. One of voss's own apps, `maker`, `state`, `contract`,
- * `promptware`, `settings`, may be given a component of the baba's to replace voss's.
+ * `agentic instructions`, `settings`, may be given a component of the baba's to replace voss's.
  * The old form, `compose({ shell })`, still loads.
  */
 export function compose<V extends { $app: string }>(def: { apps: { [K in V["$app"]]: EntryFor<RoutesFor<V, K>> } & { [K in VossApp]?: ComponentType<AppProps> } }): AppsDef;
@@ -111,7 +111,7 @@ export async function api(kind: "fire" | "read" | "state" | "raw", scope: string
  * The baba's manifest, as the server describes it: null until it arrives.
  * Asked once, then asked again "since the generation I have", so the answer
  * comes when the baba reloads: a page that draws the manifest, the Maker's
- * objects or the promptware, follows a change to the code as the state
+ * objects or the agentic instructions, follows a change to the code as the state
  * follows a round. A baba that is down is asked again in a moment.
  */
 export function useManifest(): Manifest | null {

package/src/web/index.tsx

@@ -14,4 +14,4 @@ export { formatFailure, placeOf, type ViewFailure, type Stage as FailureStage }
 export { Button, Input, Textarea, Select, Kbd, Panel, Rows, Row, Table, Dialog, CommandList, type ButtonVariant } from "./ui.tsx";
 export { plan, collect, tableOf, describeType, FieldError, type Plan, type Field, type Values } from "./form.ts";
 export { filterItems, type Item } from "./list.ts";
-export { Desktop, DesktopFrame, SpecDesktop, LocalDesktop, Eyes, AppIcon, desktopAddress, parseDesktopAddress, parseDesktopHash, routeOf, type DesktopProps, type AppProps, type SurfaceProps } from "../desktop/view.tsx";
+export { Desktop, DesktopFrame, DesktopSkeleton, SpecDesktop, LocalDesktop, Eyes, AppIcon, desktopAddress, parseDesktopAddress, parseDesktopHash, routeOf, type DesktopProps, type LauncherMode, type AppProps, type SurfaceProps } from "../desktop/view.tsx";

package/src/desktop/bob.ts

@@ -1,76 +0,0 @@
-// The launcher's dot as a body on a string: a point with a velocity, moved by
-// a small simulation rather than by CSS transitions, so a fall can gather
-// speed, the string can catch it, and a new aim mid-flight keeps the momentum.
-// The page says where the dot should be (`aim`); the bob decides how it gets
-// there and draws itself and its string on every frame until it rests.
-
-export interface Point { x: number; y: number }
-/** A spring toward the aim: stiffness pulls, damping calms. Below critical damping (2√stiffness) it overshoots. */
-export interface Spring { stiffness: number; damping: number }
-/** Falling: gravity until the string is taut. Caught: the string springs it to rest. Gliding: a spring between rows. */
-export type Phase = "falling" | "caught" | "gliding";
-export interface BobState { at: Point; v: Point; phase: Phase }
-
-/** Pixels per second squared: a fall of a few rows lasts about a tenth of a second. */
-export const gravity = 9000;
-/** The string catching the fall: stiff and loose, so it bounces. */
-export const catchSpring: Spring = { stiffness: 1400, damping: 28 };
-/** Moving between rows: quick, with a small overshoot. */
-export const glideSpring: Spring = { stiffness: 1100, damping: 40 };
-/** Sideways onto the string's vertical, while falling. */
-export const swingSpring: Spring = { stiffness: 1600, damping: 56 };
-
-const axis = (at: number, v: number, to: number, s: Spring, dt: number) => {
-  const a = s.stiffness * (to - at) - s.damping * v;
-  const nv = v + a * dt;
-  return [at + nv * dt, nv] as const;
-};
-
-/** One step of the simulation. A falling bob is pulled down by gravity until it reaches the aim, where the string goes taut and catches it. */
-export function step(s: BobState, aim: Point, dt: number): BobState {
-  const [x, vx] = axis(s.at.x, s.v.x, aim.x, s.phase === "gliding" ? glideSpring : swingSpring, dt);
-  if (s.phase === "falling") {
-    const vy = s.v.y + gravity * dt, y = s.at.y + vy * dt;
-    return y < aim.y ? { at: { x, y }, v: { x: vx, y: vy }, phase: "falling" } : { at: { x, y: aim.y }, v: { x: vx, y: vy }, phase: "caught" };
-  }
-  const [y, vy] = axis(s.at.y, s.v.y, aim.y, s.phase === "caught" ? catchSpring : glideSpring, dt);
-  return { at: { x, y }, v: { x: vx, y: vy }, phase: s.phase };
-}
-
-/** Whether a bob has come to rest at its aim. */
-export const resting = (s: BobState, aim: Point) => s.phase !== "falling" && Math.abs(s.at.x - aim.x) < .05 && Math.abs(s.at.y - aim.y) < .05 && Math.hypot(s.v.x, s.v.y) < 2;
-
-/** Runs a bob on animation frames and draws it with `draw`; it sleeps while at rest. */
-export class Bob {
-  private state: BobState | null = null;
-  private aim: Point = { x: 0, y: 0 };
-  private frame = 0;
-  private last = 0;
-  constructor(private draw: (at: Point) => void, private still = () => false) {}
-  /** Starts a fall from a point, from rest. */
-  drop(from: Point) { this.state = { at: { ...from }, v: { x: 0, y: 0 }, phase: "falling" }; this.draw(from); this.wake(); }
-  /** Where the dot should be. With `now`, it is there at once (a scroll moves it with the list). */
-  to(aim: Point, now = false) {
-    const moved = Math.abs(aim.y - this.aim.y) > .5;
-    this.aim = aim;
-    if (!this.state || now || this.still()) { this.state = { at: { ...aim }, v: { x: 0, y: 0 }, phase: "gliding" }; this.draw(aim); return; }
-    // A new aim after the catch is a move between rows; a fall keeps falling toward it.
-    if (this.state.phase === "caught" && moved) this.state = { ...this.state, phase: "gliding" };
-    this.wake();
-  }
-  stop() { cancelAnimationFrame(this.frame); this.frame = 0; this.state = null; }
-  private wake() {
-    if (this.frame) return;
-    this.last = performance.now();
-    const tick = (now: number) => {
-      // Fixed small steps keep a stiff spring stable on a slow frame.
-      let left = Math.min(.05, (now - this.last) / 1000); this.last = now;
-      while (left > 0 && this.state) { const dt = Math.min(left, 1 / 240); this.state = step(this.state, this.aim, dt); left -= dt; }
-      if (!this.state) { this.frame = 0; return; }
-      if (resting(this.state, this.aim)) { this.state = { at: { ...this.aim }, v: { x: 0, y: 0 }, phase: "gliding" }; this.draw(this.aim); this.frame = 0; return; }
-      this.draw(this.state.at);
-      this.frame = requestAnimationFrame(tick);
-    };
-    this.frame = requestAnimationFrame(tick);
-  }
-}