gesso-framework 0.4.2 → 0.5.1

package/CHANGELOG.md

@@ -1,5 +1,125 @@
 # gesso-framework
 
+## 0.5.1
+
+### Patch Changes
+
+- 77195a4: Two more semantics properties, for a field that opens a list of suggestions. `controls` is a relation, like `activeDescendant`: the node this one shows or changes, such as the list a combobox's field has open, held on the record as that node's id and written by the mirror as `aria-controls` naming its element. `autocomplete` (`'list' | 'inline' | 'both'`, the new `UiAutocomplete`) says what a field offers as it's typed into, written as `aria-autocomplete`. The editing proxy writes both while a field has focus, so `EditingMirrorTarget.describe` takes the controlled element's DOM id after the active descendant's. `Combobox` uses them: its field controls the list while it's open, and its autocomplete is `list`.
+- 6b71716: An overlay can open beside a part of its anchor: `anchorRect` on an overlay entry (and on `useOverlay`'s options), and the layout property of the same name, is a rectangle in the anchor's own coordinates that the entry is placed against, with the same flip and shift, and that it follows through scrolling and layout as it follows the anchor. It can be an Observable, so it moves without the entry opening again. `EditingService.caretRectOf(node, offset)` (and `UiEditingController.caretRectOf`) answers for a character other than the caret's, so a list opened by `@` sits under the `@` as the name is typed, and goes to the next line with it when it wraps. A point opened beside the caret stayed behind when the page scrolled.
+- 581cf89: An open overlay now follows the theme of the place it was declared. The overlay layer read the theme, text style and content colour once, as the entry opened, so a dialog or menu open when the system turned dark, or when a theme the person chose arrived from another worker a moment after they opened it, stayed in the old theme over a page in the new one until it closed. Underneath, a modifier's `host.environment(key, of?)` and `host.onEnvironment(listener, of?)` can read and follow another node's environment, and an environment provided by a node whose own environment changed in the same frame is rebuilt in that frame.
+- Updated dependencies [77195a4]
+- Updated dependencies [6b71716]
+- Updated dependencies [581cf89]
+- Updated dependencies [13c096f]
+- Updated dependencies [db7040b]
+  - gesso-core@0.5.1
+
+## 0.5.0
+
+### Minor Changes
+
+- 5a27b40: `activeDescendant` names the node that's active while another keeps focus, such as the highlighted option of a combobox whose field holds the caret, or the cell a grid's cursor is on. The semantics record carries it as the node's id, and the accessibility mirror writes `aria-activedescendant` from it, both on the node's element and on the editing proxy while a field has focus. Every mirrored element now has a DOM id for it to point at. The proxy also says `aria-expanded` for a field whose record is expanded or collapsed.
+- f265910: An AI agent can drive a web application while it runs in development. `gesso-vite-plugin` serves MCP at `/__gesso/mcp` on the dev server and prints the `claude mcp add` line to connect; the agent then sees every channel the open page can reach, the ones its render worker feeds and the ones its application and channel workers serve, and its commands change the page as a click would. Messages travel down the HMR socket to the page, which answers them against the render worker, which asks each worker behind it over a `gesso:agent` port. A command marked `@confirm` is put to the person with the browser's dialog first. The endpoint refuses requests from browser pages, the newest open tab answers, and `agent: false` turns it off. A build carries none of it.
+
+  `gesso-framework/agent` gains what the bridge is made of: `serveAgentPort`, `remoteSurface` and `combineSurfaces` for a surface across threads, `connectDevAgent` for the page's half, and `AgentSurfaceLike` for a surface whose answers are promises, which `handleMcpMessage` and `mcpHandler` now accept. `WorkerApp.openRenderPort(key)` opens a port to the render worker. The scaffolded `AGENTS.md` says how to connect.
+
+- d36a2fa: `gesso-framework/agent` hands an application to an AI agent. `agentSurface(channels)` takes the same `{ token, source }` registrations an application already serves and offers each channel as a resource holding its view, a read-only `<channel>_view` tool, and a `<channel>_<command>` tool per command that sends it and returns the view once it has settled. Tool descriptions, input schemas and hints come from the schema `gesso-vite-plugin` writes from the contract's JSDoc; arguments that do not fit are refused with a sentence naming the field, `@hidden` commands are not offered, and `@confirm` commands are sent only once the `confirm` option says the person approved.
+
+  `mcpHandler(surface)` serves it over MCP's Streamable HTTP transport as a `fetch` handler, ready for `Bun.serve`, refusing unknown browser origins and optionally requiring a bearer token. `handleMcpMessage` is the same server without the transport, for stdio or a relay.
+
+- c38f97e: A single-thread app can be driven by an AI agent too. `createSyncApp(...)` builders now answer `openRenderPort('gesso:agent')` from the page, with the channels fed there, whatever their channel workers serve, and the screen tools, so the dev server endpoint and WebMCP work exactly as they do for `createApp`. `useWebMcp(true | false | { confirm })` is the builder's form of `createApp({ webmcp })`. In a dev server, `gesso-vite-plugin` now hands a `createSyncApp` builder to the agent bridge and turns WebMCP on unless the app's own `useWebMcp(false)` says otherwise. The screen tools run a pending frame after each action on the main thread as they do in the render worker, so a background tab still reports what changed. `serveApplicationAgent` in `gesso-framework/agent` is the assembly both configurations share.
+- b90ecb2: An agent can operate the interface, not only the channels. Beside the channel tools, the page now offers `ui_snapshot`, the screen as an outline of what a screen reader announces with a short ref per control, and `ui_press`, `ui_type`, `ui_focus` and `ui_key`, which act on a control named by ref or by role and name and answer with the outline afterwards. They go through the accessibility mirror's own path, so a press is a click, a value is a keyboard edit, a disabled control refuses, and a focus trap holds. Available in the dev server endpoint and through WebMCP. `GessoRuntime.focusedNodeId()` reports which node holds focus.
+
+  The dev bridge also announces the page again whenever its HMR socket reconnects, so a restarted dev server no longer tells an agent that no page is open while one is.
+
+- 96f4bdc: A channel can describe itself. `describeChannel(token, schema)` attaches a JSON Schema of the channel's view and of each command, and `channelSchema(token)` reads it back, so anything that meets an application only at run time can ask a channel what it holds and what its commands take: an AI agent being handed the channel as tools, a devtools panel, a test that drives an app by its commands.
+
+  `gesso-vite-plugin` writes the schema for you. It reads each contract with TypeScript 7's checker and takes the descriptions from the JSDoc you already wrote: on the token, on each view key, on each command, and `@param` for its parameters. Four tags annotate a command for an agent: `@destructive`, `@idempotent`, `@confirm` and `@hidden`. A value that cannot cross a channel, such as a `Date`, a `Map` or an untyped `[]`, is reported as a build warning naming its path. The plugin needs `typescript` 7 or later installed, says so once if it is not, and `channelSchemas: false` turns the whole thing off.
+
+- 88d93b3: A command may carry bytes. An `ArrayBuffer` or a typed array in a command's parameters is no longer reported as unable to cross a channel, because a command's argument is structured-cloned and bytes clone as themselves; a file can be sent as its bytes, with no base64 pass on the render thread. The schema describes such a field as a base64 string tagged `x-gesso-binary` with the type it becomes, and the agent surface decodes an agent's base64 back into that type before the command is sent. Bytes in a view key are still a warning, since a view is diffed.
+- dc7f199: `ShellService.copyText` now returns a promise of whether the text reached the clipboard, so an application that says "Copied" after a command or a shortcut can say so only when it's true. Callers that ignore it are unaffected. The `clipboard` request carries an `id`, the shell answers it with a `clipboardResult` message, `GessoRuntime.settleClipboard` settles it, and `writeClipboard` resolves `false` when both the async clipboard and the `execCommand` fallback refuse. A runtime with no shell answers `false` at once.
+- 8fb3607: A `current` semantic state, mirrored as `aria-current`, for the current item of a set such as the navigation link to the open page. `selected` was the only way to say it, and on a link or a button a screen reader ignores `aria-selected`, so which page was open went unsaid.
+
+  `Pagination` marks the page you're on `current` instead of `selected`.
+
+- 53b4c46: A copy can put HTML on the clipboard beside the text. An editing group's new `copyHtml(start, end)` gives it, for a selection across fields or inside one field of the group, and `EditingState.html` carries it to the shell, whose copy and cut set `text/html` as well as `text/plain`. A rich editor's copy into a document or an email keeps its formatting. What a group makes of a selection is kept until the selection or its text changes, so `copyText` and `copyHtml` are no longer asked every frame.
+- f0ade22: Editables can select as one. Set `editingGroup` on a container and a selection can start in one field and end in another: arrows move between fields at their edges (up and down keep the column), Shift extends across them, a drag or a Shift and press reaches into other fields, and select all takes the whole group. Every field in the range draws its part. Typing, deleting, Enter, paste and cut over such a selection go to the group's `onEdit` with both ends, since only the application knows how its blocks join, and copy and cut take the whole selection, as the group's `copyText` if it gives one.
+- 29a36ac: `EditingService.select(anchor, focus)` sets a selection from code, in one field or across the fields of an editing group, and focuses the field its focus end is in. An editor needs it to leave a selection selected after a command over it, since its fields can only select their own text.
+- fac08c0: Focus from code can leave the page where it is, as `element.focus({ preventScroll: true })` does: `autoFocus({ preventScroll: true })`, `FocusService.focus(node, { preventScroll: true })` and `UiFocusManager.focus(node, source, { preventScroll: true })`. For focus placed for a screen reader, such as a page's content region focused as it opens, which a reveal scrolled to a few pixels short of its own top. The options reach `onFocusChange` listeners as a third argument, and a key pressed later that makes the focus visible doesn't scroll to it either. The default is unchanged.
+- 979053a: A layout listener that changes layout is painted on the same frame. `breakpoint`, `sizeContainer` (and so `Responsive`), `autoFocus` and anything else on `host.onLayout` hear a box after layout, and what they wrote used to be laid out on the next frame, so a page whose breakpoint gave it wide padding was drawn with its narrow padding first and jumped. The runtime now lays out again before it paints, as a browser does after a `ResizeObserver` callback: only what the listeners dirtied, telling only the listeners whose boxes then changed, until they write nothing more that lays out. The loop is bounded at 8 layout passes a frame; past it the frame paints what it has and a warning says so once. A frame whose listeners write nothing that lays out runs one pass. A scroll into view asked for while the listeners run (an `autoFocus` revealing its node) waits until the boxes are final. `FrameMetrics.layoutPasses` counts the passes, and `measured` and `relayoutRoots` count every pass. A geometry `sharedElement` morph lands on the frame of the change instead of being covered by a transform for one frame. `UiScheduler.recollect`, `UiFrame.merged` and `DirtyNodeSet.anyFlags` are what the runtime builds this from.
+- 99538fa: A `multiselectable` semantic state, mirrored as `aria-multiselectable`. A list whose rows are selected as a set had no way to say so, and Chrome took the option under its active descendant to be the selected one: a screen reader announced a row as selected that wasn't.
+- 28f5b72: `createApp({ pageKeys: true })` says the application is the page: a key pressed while nothing on the page has focus goes to the app, and the canvas takes focus. Keys only reached the app through its canvas, so a page that loads with focus on its body ignored every shortcut until the first click. The templates `create-gesso-app` writes turn it on; an app embedded in a larger page leaves it off.
+- b7c9514: A paste carries the clipboard's HTML along with its text. The shell read only the plain text, so a copy from a web page or a document arrived without its headings, lists and links. `UiBeforeInputEvent`, `UiPasteEvent` and an editing group's edit now have `html` (null when the clipboard had none); the field still inserts the plain text, and an editor that keeps structure can cancel that and convert the HTML. `fireEvent.paste` takes the HTML as a second argument.
+- 68b01e0: `ScrollService.scrollIntoView(node, padding?)` scrolls the containers above a node until it's in view, for a component whose highlight moves without focus: a combobox walking its list while the caret stays in the field, a grid's cursor. Focus moved from the keyboard already did this; a highlight had no way to.
+- 62883e0: `ShellService.contrast` reports the platform's contrast preference: `high` while the person has asked for more contrast (`prefers-contrast: more`) or turned on forced colours (Windows' contrast themes, which a canvas doesn't get from the browser), `standard` otherwise. Reported once at start and on every change, by both the worker and the single-thread shell. `withContrast(theme, contrast)` is the theme that answers it.
+- f02740f: A tooltip opens for focus the keyboard can see and not for the focus a press gives, so clicking a button no longer leaves its tooltip over whatever the click opened. A tooltip whose element is removed closes with it, even while the component that rendered the element stays, as when a Run button turns into Cancel. The `Tooltip` component now follows keyboard focus anywhere inside its wrapper, which it could not before because a focus event does not bubble. `FocusService.focusVisible` says whether the focus held is focus the keyboard can see.
+- cf3b16a: `createApp({ webmcp: true })` offers an application's channels to an AI agent in the browser through WebMCP. Once the app mounts, every tool the agent surface offers, a view tool per channel and a tool per command, is registered with `document.modelContext.registerTool` (or the older `navigator.modelContext`), and removed when the app is disposed. View tools carry `readOnlyHint`, `@destructive` commands carry `consequentialHint`, a call answers with the view it left or rejects with the sentence that says why, and a `@confirm` command is put to the person with `window.confirm` unless `webmcp: { confirm }` supplies the application's own dialog. In a browser without WebMCP nothing is registered and nothing fails. The code loads on demand, so the shell is no bigger for an app that does not ask.
+
+  `gesso-framework/agent` adds `registerWebMcpTools`, `connectWebMcp`, `pageModelContext` and `confirmInWindow`. `gesso-vite-plugin` turns `webmcp` on in a dev server; the app's own setting still decides.
+
+### Patch Changes
+
+- 8c1b8ed: `FrameMetrics.measured` and `relayoutRoots` are 0 for a frame that ran no layout. They used to repeat the last layout pass's numbers, so a caret blink or a scroll looked like a full re-measure to every profiler and proof panel that reads them.
+- 2bfedcd: A component no longer receives the same input value again when its parent re-renders. A prop built as a new Observable in the parent's render re-subscribed and replayed its current value, which re-ran every binding derived from that input even though nothing had changed. In a 2,868-block editor, inserting one block re-measured 12,912 nodes; it now re-measures 488. A changed value, or a new object, still arrives as before.
+- 1dfb6c2: The accessibility mirror can no longer be scrolled by the browser. A browser scrolls even an `overflow: hidden` box to bring something into view, as Tab focus, a screen reader or an automation tool does, and a region whose content reached past its box was left scrolled. Every element in it was then described tens of pixels from where it is drawn, so activating one by position activated its neighbour. The mirror now uses `overflow: clip`, which cannot be scrolled.
+- fb2a6d8: A precision device's wheel steps are paced over frames. A trackpad sends on its own clock, so a frame got one, two or three of its steps and a steady flick moved unevenly; the runtime now moves each frame by the rate the steps have been arriving at, never more than a frame behind, and applies the rest when the input stops. `UiWheelController` takes a `pace` option and an `advance()` a host calls once a frame; the runtime turns it on.
+- 0bef08b: A precision device's scroll is predicted to the frame rather than paced behind it. Each frame puts the page where the input will have reached when the frame is shown, from the steps' velocity and their timestamps, which the shells now pass with each wheel event; the page stays as even as pacing made it without trailing the hand by a frame. `UiWheelController.wheel` takes the event's time, and `advance` the frame's.
+- af33f45: `formatUrl` leaves `,` `:` `@` and `/` unencoded in a query, so a list of values reads as written (`?status=todo,done`, not `?status=todo%2Cdone`). What would change how the query parses (`&`, `=`, `+`, `#`) is still encoded, and `parseUrl` reads both forms the same.
+- 93d580b: `router.params(route)`, `router.observeParams(route)` and `router.isActive(route)` now recognise a route by its path as well as by identity. Under Vite's dev server, a route table that imports its screens, with screens that import the table, could load twice after a hot edit. The screens then held route objects the router had never seen, and every param read `null`, so a page for one team silently showed the default team.
+- 5d67836: The runtime keeps the accessibility tree as records by id plus each record's children in order, and works out a record's index only when it sends that record or the tree is asked for. A structural change used to renumber every record after it and rebuild the whole tree's order, a pass over the whole document on every Enter in a long editor. An Enter in a 5,000-line document now spends about 3 ms on semantics where it spent 7 to 10. The structural rebuild goes through `rewalkSemantics`, and `SemanticsMemory` is what each walk leaves for the next.
+- acad77f: Finding the accessibility boxes that moved after a layout now walks only what is on screen. It used to work out every mirrored node's box to learn whether it was visible, which cost a keystroke in a 5,000-line document 4 to 24 ms. Subtrees whose bounds are off screen are passed over whole.
+- 444371c: A change in the shape of the tree no longer rebuilds the whole accessibility tree, and no longer sends every later sibling an update. The tree is rebuilt from the nearest record above the change, and anything inside it that nothing touched is taken back as it was: renumbered if it moved, never described again, and a transparent subtree (a block of a long document) taken back as a run without being walked. Updates that only renumber a record whose siblings kept their order are no longer sent, since a mirror that applies removals and adds in order already has it in place: inserting a paragraph in a 5,000-line document sent 4,266 patches to the main thread, and now sends 2. `diffSemantics` gains a companion, `dropIndexShifts`.
+- 5b59d13: Every wheel step between two frames counts. Each was added to the offset the last layout settled on, so when a device sent faster than the display drew, as a trackpad does, each step overwrote the one before and a flick moved about half as far as it should, unevenly. A scroll now starts from where the container is going, clamped to its range.
+- Updated dependencies [5a27b40]
+- Updated dependencies [8d25c04]
+- Updated dependencies [20ac739]
+- Updated dependencies [303e85a]
+- Updated dependencies [0f02fc2]
+- Updated dependencies [8fb3607]
+- Updated dependencies [4450c5c]
+- Updated dependencies [53b4c46]
+- Updated dependencies [d356006]
+- Updated dependencies [101ea8a]
+- Updated dependencies [839011e]
+- Updated dependencies [f0ade22]
+- Updated dependencies [29a36ac]
+- Updated dependencies [7753bdc]
+- Updated dependencies [47aba08]
+- Updated dependencies [fac08c0]
+- Updated dependencies [5b3508d]
+- Updated dependencies [fe0c1e0]
+- Updated dependencies [2ce079c]
+- Updated dependencies [b502e0e]
+- Updated dependencies [be3e274]
+- Updated dependencies [979053a]
+- Updated dependencies [b2dddbc]
+- Updated dependencies [ab0c1a6]
+- Updated dependencies [80a3577]
+- Updated dependencies [47aba08]
+- Updated dependencies [99538fa]
+- Updated dependencies [fb2a6d8]
+- Updated dependencies [94a9f13]
+- Updated dependencies [427ce99]
+- Updated dependencies [b7c9514]
+- Updated dependencies [d3ab865]
+- Updated dependencies [0bef08b]
+- Updated dependencies [aa33728]
+- Updated dependencies [6d51def]
+- Updated dependencies [8c4f475]
+- Updated dependencies [1d61bae]
+- Updated dependencies [5d67836]
+- Updated dependencies [444371c]
+- Updated dependencies [d617d34]
+- Updated dependencies [6f03f61]
+- Updated dependencies [2c572e3]
+- Updated dependencies [84fe6d5]
+- Updated dependencies [e73a5fc]
+- Updated dependencies [1de054a]
+- Updated dependencies [9341d31]
+- Updated dependencies [2e3e56d]
+- Updated dependencies [db1a6a1]
+  - gesso-core@0.5.0
+
 ## 0.4.2
 
 ### Patch Changes

package/README.md

@@ -1,5 +1,7 @@
 # gesso-framework
 
+SwiftUI and Compose, for the web: declarative components for native-grade apps, with the whole interface drawn from a worker so it stays fast however hard your code works.
+
 Components, cells, the frame runtime, channels, routing and the worker barrier, over [`gesso-core`](https://github.com/kevinpbaker/gesso/tree/main/packages/core).
 
 ```bash

package/dist/ChannelProtocol-ByNoHujM.d.ts

@@ -0,0 +1,247 @@
+//#region src/channel/ChannelToken.d.ts
+/**
+ * The barrier between the application and the view, declared once.
+ *
+ * A token is a name, a shape and an initial value — and no
+ * implementation at all. Both threads import it, which is the point:
+ * the module holding it has nothing in it to bundle, so an app's api
+ * client and domain logic never reach the render worker the way a
+ * shared `Store` class dragged them there.
+ *
+ * What the framework knows about a channel ends here. It diffs plain
+ * data and ships patches; where the observables came from — a single
+ * subject, or an api → repository → domain → view-model stack — is the
+ * application's business and the framework cannot tell the difference.
+ *
+ *   export interface CatalogView {
+ *     products: ProductRow[];
+ *     status: 'loading' | 'ready' | 'error';
+ *   }
+ *   export interface CatalogCommands {
+ *     addToCart(id: string): void;
+ *   }
+ *   export const Catalog = channel<CatalogView, CatalogCommands>('catalog', {
+ *     products: [],
+ *     status: 'loading'
+ *   });
+ */
+/**
+ * A command a component can send back across the barrier.
+ *
+ * The arguments are what cross: each is structured-cloned onto the
+ * owning thread, so they must be plain data. There may be as many as
+ * the command needs, which is why `move(from, to)` is written the way
+ * anyone would write it rather than as `move({ from, to })`; a command
+ * used to carry one payload and the second argument was dropped on the
+ * floor with a warning.
+ *
+ * Commands return nothing: the effect comes back as a patch, never as
+ * a return value, since there is no synchronous answer to be had
+ * across a thread.
+ */
+type Command = (...args: never[]) => void;
+/**
+ * The internal view of a command set: a bag of callables by name.
+ *
+ * Public signatures constrain to `object`, not to this. An application
+ * declares its commands as an ordinary interface —
+ * `interface CatalogCommands { addToCart(id: string): void }` — and an
+ * interface has no index signature, so it does not satisfy a
+ * `Record<string, …>` constraint however well it fits in spirit.
+ * Constraining to `object` accepts what people actually write; this
+ * alias is what the implementation casts to when it looks a command up
+ * by name.
+ */
+type CommandMap = Record<string, Command>;
+/** The declared barrier for one area of an application. */
+interface ChannelToken<View extends object, Commands extends object = Record<string, never>> {
+  readonly name: string;
+  /**
+   * What every view key holds before the first patch arrives.
+   *
+   * Required rather than optional, so the render thread never observes
+   * `undefined` for a declared key. A channel that is genuinely still
+   * loading says so in its own shape — a `status` field — rather than
+   * leaving the view to infer it from an absence.
+   */
+  readonly initial: View;
+  /** Phantom, carrying the command types to `send`. Never read. */
+  readonly commands?: Commands;
+}
+/**
+ * Declares a channel.
+ *
+ * The name identifies it across the thread boundary and must be
+ * stable; unlike a class name it survives minification, which is why
+ * it is written out rather than derived.
+ */
+declare function channel<View extends object, Commands extends object = Record<string, never>>(name: string, initial: View): ChannelToken<View, Commands>;
+/** A channel written as one object: the view with its values, and the commands. */
+interface ChannelSpec<View extends object, Commands extends object> {
+  /**
+   * Every view key with the value it holds before the first patch.
+   *
+   * The type of the channel's view is the type of this object, so the
+   * keys and their initial values are written once instead of in an
+   * interface and again in a literal that has to agree with it.
+   */
+  readonly view: View;
+  /**
+   * The commands, as a type rather than as implementations.
+   *
+   * Written `{} as { addToCart(id: string, quantity: number): void }`:
+   * the handlers live on the thread that owns the data and are passed
+   * to `provide`, so what belongs in the token is only their shape.
+   */
+  readonly commands?: Commands;
+}
+/**
+ * Declares a channel from one object.
+ *
+ *   export const Catalog = defineChannel('catalog', {
+ *     view: {
+ *       products: [] as readonly ProductRow[],
+ *       status: 'loading' as ShelfStatus
+ *     },
+ *     commands: {} as {
+ *       addToCart(id: string, quantity: number): void;
+ *       move(from: number, to: number): void;
+ *     }
+ *   });
+ *
+ *   export type CatalogView = ViewOf<typeof Catalog>;
+ *
+ * The same token `channel()` returns, declared once instead of three
+ * times. `channel<View, Commands>(name, initial)` wrote the view as an
+ * interface, then as an initial literal that had to agree with it, and
+ * a key added to one and forgotten in the other was a type error in a
+ * third file. Here the object is the type.
+ *
+ * A field whose initial value is narrower than the type it holds is
+ * given the type it holds: `[]` is `never[]` and `'loading'` is
+ * `string` unless it is said, which is what the `as` clauses above are
+ * for. `ViewOf` and `CommandsOf` name the resulting types wherever the
+ * application used to name its own interface.
+ *
+ * `channel()` is not deprecated and keeps working exactly as it did.
+ * An application with interfaces it wants to keep, because they are
+ * shared with something else or because the initial values are built
+ * elsewhere, has nothing to migrate.
+ */
+declare function defineChannel<View extends object, Commands extends object = Record<string, never>>(name: string, spec: ChannelSpec<View, Commands>): ChannelToken<View, Commands>;
+/** The view type of a channel token, for an application that wants to name it. */
+type ViewOf<T> = T extends ChannelToken<infer View, object> ? View : never;
+/** The command type of a channel token. */
+type CommandsOf<T> = T extends ChannelToken<object, infer Commands> ? Commands : never;
+/**
+ * The keys a channel publishes.
+ *
+ * Structural in its parameter rather than generic over the token, so
+ * it does not have to agree with any particular command type to read
+ * what is only ever the initial value's shape.
+ */
+declare function viewKeys(token: {
+  initial: object;
+}): string[];
+//#endregion
+//#region src/channel/StorePatch.d.ts
+type PatchPath = readonly (string | number)[];
+/**
+ * A change to one projection, as sent from a data worker to a replica.
+ *
+ * Paths are relative to the projection's root value, so a patch is
+ * self-contained: the replica never needs the previous value to apply
+ * one, only the value it already holds.
+ */
+type Patch = {
+  op: 'set';
+  projection: string;
+  path: PatchPath;
+  value: unknown;
+} | {
+  op: 'delete';
+  projection: string;
+  path: PatchPath;
+} | {
+  op: 'splice';
+  projection: string;
+  path: PatchPath;
+  index: number;
+  deleteCount: number;
+  items: readonly unknown[];
+};
+/**
+ * Describes how to turn `previous` into `current` for one projection.
+ *
+ * Returns an empty list when nothing changed, which is the common case
+ * and the reason this exists: the point of a projection is that most
+ * state changes do not alter it, and the ones that do usually alter a
+ * small part.
+ */
+declare function diffProjection(projection: string, previous: unknown, current: unknown): Patch[];
+/**
+ * Applies patches to a projection value, sharing structure with the
+ * original everywhere the patch did not reach.
+ *
+ * Nothing handed in is mutated: bindings hold onto emitted values, so a
+ * replica that edited in place would change data a component already
+ * rendered.
+ *
+ * **Each container on a patched path is copied once per batch, not once
+ * per patch.** A batch of N patches into one K-key object used to cost
+ * N × K: every patch spread the whole object again to change one key.
+ * A snapshot keyed by id is exactly that shape — gessologic published
+ * `Record<netId, 0 | 1>` for ten thousand nets, about nine hundred
+ * patches a publish, and the render worker's patch phase fell minutes
+ * behind a 60 Hz stream it could never catch. So the batch remembers
+ * the containers it has copied, and writes into those in place: they
+ * are its own, made during this call and seen by nobody yet. Values
+ * that arrived inside a patch are never written into, because they are
+ * the patch's — a devtools log replays the same patch objects again.
+ */
+declare function applyPatches(root: unknown, patches: readonly Patch[]): unknown;
+declare function applyPatch(root: unknown, patch: Patch): unknown;
+//#endregion
+//#region src/channel/ChannelProtocol.d.ts
+/**
+ * A two-way channel endpoint. `MessagePort` satisfies it, as does a
+ * test double, so nothing in the channel layer depends on Worker.
+ */
+interface ChannelPort {
+  postMessage(message: unknown): void;
+  onmessage: ((event: {
+    data: unknown;
+  }) => void) | null;
+}
+/**
+ * Render thread → the thread that owns the channel.
+ *
+ * A command's first argument stayed `payload` when commands learned to
+ * take more than one, and the rest travel beside it. That is not
+ * tidiness: an older view talking to a newer application worker sends
+ * no `rest`, which reads as the one-argument call it is, and an older
+ * application worker ignores the field, which is exactly what it did
+ * before the field existed.
+ */
+type ChannelClientMessage = {
+  type: 'channel:sync';
+} | {
+  type: 'channel:command';
+  command: string;
+  payload: unknown;
+  rest?: unknown[];
+};
+/** The owning thread → render thread. */
+type ChannelHostMessage = {
+  type: 'channel:patch';
+  patches: Patch[];
+} | {
+  type: 'channel:error';
+  message: string;
+  stack?: string;
+};
+declare function isChannelClientMessage(value: unknown): value is ChannelClientMessage;
+declare function isChannelHostMessage(value: unknown): value is ChannelHostMessage;
+//#endregion
+export { channel as _, isChannelHostMessage as a, applyPatch as c, ChannelSpec as d, ChannelToken as f, ViewOf as g, CommandsOf as h, isChannelClientMessage as i, applyPatches as l, CommandMap as m, ChannelHostMessage as n, Patch as o, Command as p, ChannelPort as r, PatchPath as s, ChannelClientMessage as t, diffProjection as u, defineChannel as v, viewKeys as y };
+//# sourceMappingURL=ChannelProtocol-ByNoHujM.d.ts.map

package/dist/{FunctionComponent-CgwLKE5d.d.ts → FunctionComponent-fYMdePtH.d.ts}

@@ -1,3 +1,4 @@
+import { f as ChannelToken, o as Patch, r as ChannelPort } from "./ChannelProtocol-ByNoHujM.js";
 import { BehaviorSubject, Observable, Subject, Subscription } from "rxjs";
 import { LayoutBox, Reactive, UiChild, UiModifier } from "gesso-core";
 //#region src/Component.d.ts
@@ -257,251 +258,6 @@ declare class BoundsCell extends InternalState<LayoutBox> {
  */
 declare function bounds(label?: string): BoundsCell;
 //#endregion
-//#region src/channel/ChannelToken.d.ts
-/**
- * The barrier between the application and the view, declared once.
- *
- * A token is a name, a shape and an initial value — and no
- * implementation at all. Both threads import it, which is the point:
- * the module holding it has nothing in it to bundle, so an app's api
- * client and domain logic never reach the render worker the way a
- * shared `Store` class dragged them there.
- *
- * What the framework knows about a channel ends here. It diffs plain
- * data and ships patches; where the observables came from — a single
- * subject, or an api → repository → domain → view-model stack — is the
- * application's business and the framework cannot tell the difference.
- *
- *   export interface CatalogView {
- *     products: ProductRow[];
- *     status: 'loading' | 'ready' | 'error';
- *   }
- *   export interface CatalogCommands {
- *     addToCart(id: string): void;
- *   }
- *   export const Catalog = channel<CatalogView, CatalogCommands>('catalog', {
- *     products: [],
- *     status: 'loading'
- *   });
- */
-/**
- * A command a component can send back across the barrier.
- *
- * The arguments are what cross: each is structured-cloned onto the
- * owning thread, so they must be plain data. There may be as many as
- * the command needs, which is why `move(from, to)` is written the way
- * anyone would write it rather than as `move({ from, to })`; a command
- * used to carry one payload and the second argument was dropped on the
- * floor with a warning.
- *
- * Commands return nothing: the effect comes back as a patch, never as
- * a return value, since there is no synchronous answer to be had
- * across a thread.
- */
-type Command = (...args: never[]) => void;
-/**
- * The internal view of a command set: a bag of callables by name.
- *
- * Public signatures constrain to `object`, not to this. An application
- * declares its commands as an ordinary interface —
- * `interface CatalogCommands { addToCart(id: string): void }` — and an
- * interface has no index signature, so it does not satisfy a
- * `Record<string, …>` constraint however well it fits in spirit.
- * Constraining to `object` accepts what people actually write; this
- * alias is what the implementation casts to when it looks a command up
- * by name.
- */
-type CommandMap = Record<string, Command>;
-/** The declared barrier for one area of an application. */
-interface ChannelToken<View extends object, Commands extends object = Record<string, never>> {
-  readonly name: string;
-  /**
-   * What every view key holds before the first patch arrives.
-   *
-   * Required rather than optional, so the render thread never observes
-   * `undefined` for a declared key. A channel that is genuinely still
-   * loading says so in its own shape — a `status` field — rather than
-   * leaving the view to infer it from an absence.
-   */
-  readonly initial: View;
-  /** Phantom, carrying the command types to `send`. Never read. */
-  readonly commands?: Commands;
-}
-/**
- * Declares a channel.
- *
- * The name identifies it across the thread boundary and must be
- * stable; unlike a class name it survives minification, which is why
- * it is written out rather than derived.
- */
-declare function channel<View extends object, Commands extends object = Record<string, never>>(name: string, initial: View): ChannelToken<View, Commands>;
-/** A channel written as one object: the view with its values, and the commands. */
-interface ChannelSpec<View extends object, Commands extends object> {
-  /**
-   * Every view key with the value it holds before the first patch.
-   *
-   * The type of the channel's view is the type of this object, so the
-   * keys and their initial values are written once instead of in an
-   * interface and again in a literal that has to agree with it.
-   */
-  readonly view: View;
-  /**
-   * The commands, as a type rather than as implementations.
-   *
-   * Written `{} as { addToCart(id: string, quantity: number): void }`:
-   * the handlers live on the thread that owns the data and are passed
-   * to `provide`, so what belongs in the token is only their shape.
-   */
-  readonly commands?: Commands;
-}
-/**
- * Declares a channel from one object.
- *
- *   export const Catalog = defineChannel('catalog', {
- *     view: {
- *       products: [] as readonly ProductRow[],
- *       status: 'loading' as ShelfStatus
- *     },
- *     commands: {} as {
- *       addToCart(id: string, quantity: number): void;
- *       move(from: number, to: number): void;
- *     }
- *   });
- *
- *   export type CatalogView = ViewOf<typeof Catalog>;
- *
- * The same token `channel()` returns, declared once instead of three
- * times. `channel<View, Commands>(name, initial)` wrote the view as an
- * interface, then as an initial literal that had to agree with it, and
- * a key added to one and forgotten in the other was a type error in a
- * third file. Here the object is the type.
- *
- * A field whose initial value is narrower than the type it holds is
- * given the type it holds: `[]` is `never[]` and `'loading'` is
- * `string` unless it is said, which is what the `as` clauses above are
- * for. `ViewOf` and `CommandsOf` name the resulting types wherever the
- * application used to name its own interface.
- *
- * `channel()` is not deprecated and keeps working exactly as it did.
- * An application with interfaces it wants to keep, because they are
- * shared with something else or because the initial values are built
- * elsewhere, has nothing to migrate.
- */
-declare function defineChannel<View extends object, Commands extends object = Record<string, never>>(name: string, spec: ChannelSpec<View, Commands>): ChannelToken<View, Commands>;
-/** The view type of a channel token, for an application that wants to name it. */
-type ViewOf<T> = T extends ChannelToken<infer View, object> ? View : never;
-/** The command type of a channel token. */
-type CommandsOf<T> = T extends ChannelToken<object, infer Commands> ? Commands : never;
-/**
- * The keys a channel publishes.
- *
- * Structural in its parameter rather than generic over the token, so
- * it does not have to agree with any particular command type to read
- * what is only ever the initial value's shape.
- */
-declare function viewKeys(token: {
-  initial: object;
-}): string[];
-//#endregion
-//#region src/channel/StorePatch.d.ts
-type PatchPath = readonly (string | number)[];
-/**
- * A change to one projection, as sent from a data worker to a replica.
- *
- * Paths are relative to the projection's root value, so a patch is
- * self-contained: the replica never needs the previous value to apply
- * one, only the value it already holds.
- */
-type Patch = {
-  op: 'set';
-  projection: string;
-  path: PatchPath;
-  value: unknown;
-} | {
-  op: 'delete';
-  projection: string;
-  path: PatchPath;
-} | {
-  op: 'splice';
-  projection: string;
-  path: PatchPath;
-  index: number;
-  deleteCount: number;
-  items: readonly unknown[];
-};
-/**
- * Describes how to turn `previous` into `current` for one projection.
- *
- * Returns an empty list when nothing changed, which is the common case
- * and the reason this exists: the point of a projection is that most
- * state changes do not alter it, and the ones that do usually alter a
- * small part.
- */
-declare function diffProjection(projection: string, previous: unknown, current: unknown): Patch[];
-/**
- * Applies patches to a projection value, sharing structure with the
- * original everywhere the patch did not reach.
- *
- * Nothing handed in is mutated: bindings hold onto emitted values, so a
- * replica that edited in place would change data a component already
- * rendered.
- *
- * **Each container on a patched path is copied once per batch, not once
- * per patch.** A batch of N patches into one K-key object used to cost
- * N × K: every patch spread the whole object again to change one key.
- * A snapshot keyed by id is exactly that shape — gessologic published
- * `Record<netId, 0 | 1>` for ten thousand nets, about nine hundred
- * patches a publish, and the render worker's patch phase fell minutes
- * behind a 60 Hz stream it could never catch. So the batch remembers
- * the containers it has copied, and writes into those in place: they
- * are its own, made during this call and seen by nobody yet. Values
- * that arrived inside a patch are never written into, because they are
- * the patch's — a devtools log replays the same patch objects again.
- */
-declare function applyPatches(root: unknown, patches: readonly Patch[]): unknown;
-declare function applyPatch(root: unknown, patch: Patch): unknown;
-//#endregion
-//#region src/channel/ChannelProtocol.d.ts
-/**
- * A two-way channel endpoint. `MessagePort` satisfies it, as does a
- * test double, so nothing in the channel layer depends on Worker.
- */
-interface ChannelPort {
-  postMessage(message: unknown): void;
-  onmessage: ((event: {
-    data: unknown;
-  }) => void) | null;
-}
-/**
- * Render thread → the thread that owns the channel.
- *
- * A command's first argument stayed `payload` when commands learned to
- * take more than one, and the rest travel beside it. That is not
- * tidiness: an older view talking to a newer application worker sends
- * no `rest`, which reads as the one-argument call it is, and an older
- * application worker ignores the field, which is exactly what it did
- * before the field existed.
- */
-type ChannelClientMessage = {
-  type: 'channel:sync';
-} | {
-  type: 'channel:command';
-  command: string;
-  payload: unknown;
-  rest?: unknown[];
-};
-/** The owning thread → render thread. */
-type ChannelHostMessage = {
-  type: 'channel:patch';
-  patches: Patch[];
-} | {
-  type: 'channel:error';
-  message: string;
-  stack?: string;
-};
-declare function isChannelClientMessage(value: unknown): value is ChannelClientMessage;
-declare function isChannelHostMessage(value: unknown): value is ChannelHostMessage;
-//#endregion
 //#region src/channel/ChannelReplica.d.ts
 /**
  * The render thread's end of a channel.
@@ -725,5 +481,5 @@ type ComponentArgs<C> = RequiredKeys<ComponentProps<C>> extends never ? [inputs?
  */
 declare function isClassComponent(component: ComponentType): component is ClassComponent;
 //#endregion
-export { bounds as A, output as B, CommandMap as C, defineChannel as D, channel as E, OutputTarget as F, internalState as H, ReadableCell as I, input as L, EmitValue as M, InputCell as N, viewKeys as O, OutputCell as P, into as R, Command as S, ViewOf as T, Component as U, InternalState as V, applyPatch as _, ComponentType as a, ChannelSpec as b, isClassComponent as c, ChannelHostMessage as d, ChannelPort as f, PatchPath as g, Patch as h, ComponentProps as i, EmitArgs as j, BoundsCell as k, ChannelReplica as l, isChannelHostMessage as m, ComponentArgs as n, FunctionComponent as o, isChannelClientMessage as p, ComponentContext as r, Inputs as s, ClassComponent as t, ChannelClientMessage as u, applyPatches as v, CommandsOf as w, ChannelToken as x, diffProjection as y, isOutputTarget as z };
-//# sourceMappingURL=FunctionComponent-CgwLKE5d.d.ts.map
+export { internalState as C, InternalState as S, ReadableCell as _, ComponentType as a, isOutputTarget as b, isClassComponent as c, bounds as d, EmitArgs as f, OutputTarget as g, OutputCell as h, ComponentProps as i, ChannelReplica as l, InputCell as m, ComponentArgs as n, FunctionComponent as o, EmitValue as p, ComponentContext as r, Inputs as s, ClassComponent as t, BoundsCell as u, input as v, Component as w, output as x, into as y };
+//# sourceMappingURL=FunctionComponent-fYMdePtH.d.ts.map